URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ipv6/] [anycast.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *      Anycast support for IPv6
 *      Linux INET6 implementation
 *
 *      Authors:
 *      David L Stevens (dlstevens@us.ibm.com)
 *
 *      based heavily on net/ipv6/mcast.c
 *
 *      This program is free software; you can redistribute it and/or
 *      modify it under the terms of the GNU General Public License
 *      as published by the Free Software Foundation; either version
 *      2 of the License, or (at your option) any later version.
 */
 
#include <linux/config.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/random.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/sockios.h>
#include <linux/sched.h>
#include <linux/net.h>
#include <linux/in6.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
#include <linux/route.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
 
#include <net/sock.h>
#include <net/snmp.h>
 
#include <net/ipv6.h>
#include <net/protocol.h>
#include <net/if_inet6.h>
#include <net/ndisc.h>
#include <net/addrconf.h>
#include <net/ip6_route.h>
 
#include <net/checksum.h>
 
/* Big ac list lock for all the sockets */
static rwlock_t ipv6_sk_ac_lock = RW_LOCK_UNLOCKED;
 
/* XXX ip6_addr_match() and ip6_onlink() really belong in net/core.c */
 
static int
ip6_addr_match(struct in6_addr *addr1, struct in6_addr *addr2, int prefix)
{
        __u32   mask;
        int     i;
 
        if (prefix > 128 || prefix < 0)
                return 0;
        if (prefix == 0)
                return 1;
        for (i=0; i<4; ++i) {
                if (prefix >= 32)
                        mask = ~0;
                else
                        mask = htonl(~0 << (32 - prefix));
                if ((addr1->s6_addr32[i] ^ addr2->s6_addr32[i]) & mask)
                        return 0;
                prefix -= 32;
                if (prefix <= 0)
                        break;
        }
        return 1;
}
 
static int
ip6_onlink(struct in6_addr *addr, struct net_device *dev)
{
        struct inet6_dev        *idev;
        struct inet6_ifaddr     *ifa;
        int     onlink;
 
        onlink = 0;
        read_lock(&addrconf_lock);
        idev = __in6_dev_get(dev);
        if (idev) {
                read_lock_bh(&idev->lock);
                for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {
                        onlink = ip6_addr_match(addr, &ifa->addr,
                                        ifa->prefix_len);
                        if (onlink)
                                break;
                }
                read_unlock_bh(&idev->lock);
        }
        read_unlock(&addrconf_lock);
        return onlink;
}
 
 
/*
 *      socket join an anycast group
 */
 
int ipv6_sock_ac_join(struct sock *sk, int ifindex, struct in6_addr *addr)
{
        struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
        struct net_device *dev = NULL;
        struct inet6_dev *idev;
        struct ipv6_ac_socklist *pac;
        int     ishost = !ipv6_devconf.forwarding;
        int     err = 0;
 
        if (ipv6_addr_type(addr) & IPV6_ADDR_MULTICAST)
                return -EINVAL;
 
        pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);
        if (pac == NULL)
                return -ENOMEM;
        pac->acl_next = NULL;
        ipv6_addr_copy(&pac->acl_addr, addr);
 
        if (ifindex == 0) {
                struct rt6_info *rt;
 
                rt = rt6_lookup(addr, NULL, 0, 0);
                if (rt) {
                        dev = rt->rt6i_dev;
                        dev_hold(dev);
                        dst_release(&rt->u.dst);
                } else if (ishost) {
                        err = -EADDRNOTAVAIL;
                        goto out_free_pac;
                } else {
                        /* router, no matching interface: just pick one */
 
                        dev = dev_get_by_flags(IFF_UP, IFF_UP|IFF_LOOPBACK);
                }
        } else
                dev = dev_get_by_index(ifindex);
 
        if (dev == NULL) {
                err = -ENODEV;
                goto out_free_pac;
        }
 
        idev = in6_dev_get(dev);
        if (!idev) {
                if (ifindex)
                        err = -ENODEV;
                else
                        err = -EADDRNOTAVAIL;
                goto out_dev_put;
        }
        /* reset ishost, now that we have a specific device */
        ishost = !idev->cnf.forwarding;
        in6_dev_put(idev);
 
        pac->acl_ifindex = dev->ifindex;
 
        /* XXX
         * For hosts, allow link-local or matching prefix anycasts.
         * This obviates the need for propagating anycast routes while
         * still allowing some non-router anycast participation.
         *
         * allow anyone to join anycasts that don't require a special route
         * and can't be spoofs of unicast addresses (reserved anycast only)
         */
        if (!ip6_onlink(addr, dev)) {
                if (ishost)
                        err = -EADDRNOTAVAIL;
                else if (!capable(CAP_NET_ADMIN))
                        err = -EPERM;
                if (err)
                        goto out_dev_put;
        } else if (!(ipv6_addr_type(addr) & IPV6_ADDR_ANYCAST) &&
                   !capable(CAP_NET_ADMIN)) {
                err = -EPERM;
                goto out_dev_put;
        }
 
        err = ipv6_dev_ac_inc(dev, addr);
        if (err)
                goto out_dev_put;
 
        write_lock_bh(&ipv6_sk_ac_lock);
        pac->acl_next = np->ipv6_ac_list;
        np->ipv6_ac_list = pac;
        write_unlock_bh(&ipv6_sk_ac_lock);
 
        dev_put(dev);
 
        return 0;
 
out_dev_put:
        dev_put(dev);
out_free_pac:
        sock_kfree_s(sk, pac, sizeof(*pac));
        return err;
}
 
/*
 *      socket leave an anycast group
 */
int ipv6_sock_ac_drop(struct sock *sk, int ifindex, struct in6_addr *addr)
{
        struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
        struct net_device *dev;
        struct ipv6_ac_socklist *pac, *prev_pac;
 
        write_lock_bh(&ipv6_sk_ac_lock);
        prev_pac = 0;
        for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {
                if ((ifindex == 0 || pac->acl_ifindex == ifindex) &&
                     ipv6_addr_cmp(&pac->acl_addr, addr) == 0)
                        break;
                prev_pac = pac;
        }
        if (!pac) {
                write_unlock_bh(&ipv6_sk_ac_lock);
                return -ENOENT;
        }
        if (prev_pac)
                prev_pac->acl_next = pac->acl_next;
        else
                np->ipv6_ac_list = pac->acl_next;
 
        write_unlock_bh(&ipv6_sk_ac_lock);
 
        dev = dev_get_by_index(pac->acl_ifindex);
        if (dev) {
                ipv6_dev_ac_dec(dev, &pac->acl_addr);
                dev_put(dev);
        }
        sock_kfree_s(sk, pac, sizeof(*pac));
        return 0;
}
 
void ipv6_sock_ac_close(struct sock *sk)
{
        struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
        struct net_device *dev = 0;
        struct ipv6_ac_socklist *pac;
        int     prev_index;
 
        write_lock_bh(&ipv6_sk_ac_lock);
        pac = np->ipv6_ac_list;
        np->ipv6_ac_list = 0;
        write_unlock_bh(&ipv6_sk_ac_lock);
 
        prev_index = 0;
        while (pac) {
                struct ipv6_ac_socklist *next = pac->acl_next;
 
                if (pac->acl_ifindex != prev_index) {
                        if (dev)
                                dev_put(dev);
                        dev = dev_get_by_index(pac->acl_ifindex);
                        prev_index = pac->acl_ifindex;
                }
                if (dev)
                        ipv6_dev_ac_dec(dev, &pac->acl_addr);
                sock_kfree_s(sk, pac, sizeof(*pac));
                pac = next;
        }
        if (dev)
                dev_put(dev);
}
 
int inet6_ac_check(struct sock *sk, struct in6_addr *addr, int ifindex)
{
        struct ipv6_ac_socklist *pac;
        struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;
        int     found;
 
        found = 0;
        read_lock(&ipv6_sk_ac_lock);
        for (pac=np->ipv6_ac_list; pac; pac=pac->acl_next) {
                if (ifindex && pac->acl_ifindex != ifindex)
                        continue;
                found = ipv6_addr_cmp(&pac->acl_addr, addr) == 0;
                if (found)
                        break;
        }
        read_unlock(&ipv6_sk_ac_lock);
 
        return found;
}
 
static void aca_put(struct ifacaddr6 *ac)
{
        if (atomic_dec_and_test(&ac->aca_refcnt)) {
                in6_dev_put(ac->aca_idev);
                kfree(ac);
        }
}
 
/*
 *      device anycast group inc (add if not found)
 */
int ipv6_dev_ac_inc(struct net_device *dev, struct in6_addr *addr)
{
        struct ifacaddr6 *aca;
        struct inet6_dev *idev;
 
        idev = in6_dev_get(dev);
 
        if (idev == NULL)
                return -EINVAL;
 
        write_lock_bh(&idev->lock);
        if (idev->dead) {
                write_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return -ENODEV;
        }
 
        for (aca = idev->ac_list; aca; aca = aca->aca_next) {
                if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0) {
                        aca->aca_users++;
                        write_unlock_bh(&idev->lock);
                        in6_dev_put(idev);
                        return 0;
                }
        }
 
        /*
         *      not found: create a new one.
         */
 
        aca = kmalloc(sizeof(struct ifacaddr6), GFP_ATOMIC);
 
        if (aca == NULL) {
                write_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return -ENOMEM;
        }
 
        memset(aca, 0, sizeof(struct ifacaddr6));
 
        ipv6_addr_copy(&aca->aca_addr, addr);
        aca->aca_idev = idev;
        aca->aca_users = 1;
        atomic_set(&aca->aca_refcnt, 2);
        aca->aca_lock = SPIN_LOCK_UNLOCKED;
 
        aca->aca_next = idev->ac_list;
        idev->ac_list = aca;
        write_unlock_bh(&idev->lock);
 
        ip6_rt_addr_add(&aca->aca_addr, dev);
 
        addrconf_join_solict(dev, &aca->aca_addr);
 
        aca_put(aca);
        return 0;
}
 
/*
 *      device anycast group decrement
 */
int ipv6_dev_ac_dec(struct net_device *dev, struct in6_addr *addr)
{
        struct inet6_dev *idev;
        struct ifacaddr6 *aca, *prev_aca;
 
        idev = in6_dev_get(dev);
        if (idev == NULL)
                return -ENODEV;
 
        write_lock_bh(&idev->lock);
        prev_aca = 0;
        for (aca = idev->ac_list; aca; aca = aca->aca_next) {
                if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0)
                        break;
                prev_aca = aca;
        }
        if (!aca) {
                write_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return -ENOENT;
        }
        if (--aca->aca_users > 0) {
                write_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return 0;
        }
        if (prev_aca)
                prev_aca->aca_next = aca->aca_next;
        else
                idev->ac_list = aca->aca_next;
        write_unlock_bh(&idev->lock);
        addrconf_leave_solict(dev, &aca->aca_addr);
 
        ip6_rt_addr_del(&aca->aca_addr, dev);
 
        aca_put(aca);
        in6_dev_put(idev);
        return 0;
}
 
/*
 *      check if the interface has this anycast address
 */
static int ipv6_chk_acast_dev(struct net_device *dev, struct in6_addr *addr)
{
        struct inet6_dev *idev;
        struct ifacaddr6 *aca;
 
        idev = in6_dev_get(dev);
        if (idev) {
                read_lock_bh(&idev->lock);
                for (aca = idev->ac_list; aca; aca = aca->aca_next)
                        if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0)
                                break;
                read_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return aca != 0;
        }
        return 0;
}
 
/*
 *      check if given interface (or any, if dev==0) has this anycast address
 */
int ipv6_chk_acast_addr(struct net_device *dev, struct in6_addr *addr)
{
        if (dev)
                return ipv6_chk_acast_dev(dev, addr);
        read_lock(&dev_base_lock);
        for (dev=dev_base; dev; dev=dev->next)
                if (ipv6_chk_acast_dev(dev, addr))
                        break;
        read_unlock(&dev_base_lock);
        return dev != 0;
}
 
 
#ifdef CONFIG_PROC_FS
int anycast6_get_info(char *buffer, char **start, off_t offset, int length)
{
        off_t pos=0, begin=0;
        struct ifacaddr6 *im;
        int len=0;
        struct net_device *dev;
 
        read_lock(&dev_base_lock);
        for (dev = dev_base; dev; dev = dev->next) {
                struct inet6_dev *idev;
 
                if ((idev = in6_dev_get(dev)) == NULL)
                        continue;
 
                read_lock_bh(&idev->lock);
                for (im = idev->ac_list; im; im = im->aca_next) {
                        int i;
 
                        len += sprintf(buffer+len,"%-4d %-15s ", dev->ifindex, dev->name);
 
                        for (i=0; i<16; i++)
                                len += sprintf(buffer+len, "%02x", im->aca_addr.s6_addr[i]);
 
                        len += sprintf(buffer+len, " %5d\n", im->aca_users);
 
                        pos=begin+len;
                        if (pos < offset) {
                                len=0;
                                begin=pos;
                        }
                        if (pos > offset+length) {
                                read_unlock_bh(&idev->lock);
                                in6_dev_put(idev);
                                goto done;
                        }
                }
                read_unlock_bh(&idev->lock);
                in6_dev_put(idev);
        }
 
done:
        read_unlock(&dev_base_lock);
 
        *start=buffer+(offset-begin);
        len-=(offset-begin);
        if(len>length)
                len=length;
        if (len<0)
                len=0;
        return len;
}
 
#endif

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [ipv6/] [anycast.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* Anycast support for IPv6`
3			`* Linux INET6 implementation`
4			`*`
5			`* Authors:`
6			`* David L Stevens (dlstevens@us.ibm.com)`
7			`*`
8			`* based heavily on net/ipv6/mcast.c`
9			`*`
10			`* This program is free software; you can redistribute it and/or`
11			`* modify it under the terms of the GNU General Public License`
12			`* as published by the Free Software Foundation; either version`
13			`* 2 of the License, or (at your option) any later version.`
14			`*/`
15
16			`#include <linux/config.h>`
17			`#include <linux/module.h>`
18			`#include <linux/errno.h>`
19			`#include <linux/types.h>`
20			`#include <linux/random.h>`
21			`#include <linux/string.h>`
22			`#include <linux/socket.h>`
23			`#include <linux/sockios.h>`
24			`#include <linux/sched.h>`
25			`#include <linux/net.h>`
26			`#include <linux/in6.h>`
27			`#include <linux/netdevice.h>`
28			`#include <linux/if_arp.h>`
29			`#include <linux/route.h>`
30			`#include <linux/init.h>`
31			`#include <linux/proc_fs.h>`
32
33			`#include <net/sock.h>`
34			`#include <net/snmp.h>`
35
36			`#include <net/ipv6.h>`
37			`#include <net/protocol.h>`
38			`#include <net/if_inet6.h>`
39			`#include <net/ndisc.h>`
40			`#include <net/addrconf.h>`
41			`#include <net/ip6_route.h>`
42
43			`#include <net/checksum.h>`
44
45			`/* Big ac list lock for all the sockets */`
46			`static rwlock_t ipv6_sk_ac_lock = RW_LOCK_UNLOCKED;`
47
48			`/* XXX ip6_addr_match() and ip6_onlink() really belong in net/core.c */`
49
50			`static int`
51			`ip6_addr_match(struct in6_addr addr1, struct in6_addr addr2, int prefix)`
52			`{`
53			`__u32 mask;`
54			`int i;`
55
56			`if (prefix > 128 \|\| prefix < 0)`
57			`return 0;`
58			`if (prefix == 0)`
59			`return 1;`
60			`for (i=0; i<4; ++i) {`
61			`if (prefix >= 32)`
62			`mask = ~0;`
63			`else`
64			`mask = htonl(~0 << (32 - prefix));`
65			`if ((addr1->s6_addr32[i] ^ addr2->s6_addr32[i]) & mask)`
66			`return 0;`
67			`prefix -= 32;`
68			`if (prefix <= 0)`
69			`break;`
70			`}`
71			`return 1;`
72			`}`
73
74			`static int`
75			`ip6_onlink(struct in6_addr addr, struct net_device dev)`
76			`{`
77			`struct inet6_dev *idev;`
78			`struct inet6_ifaddr *ifa;`
79			`int onlink;`
80
81			`onlink = 0;`
82			`read_lock(&addrconf_lock);`
83			`idev = __in6_dev_get(dev);`
84			`if (idev) {`
85			`read_lock_bh(&idev->lock);`
86			`for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {`
87			`onlink = ip6_addr_match(addr, &ifa->addr,`
88			`ifa->prefix_len);`
89			`if (onlink)`
90			`break;`
91			`}`
92			`read_unlock_bh(&idev->lock);`
93			`}`
94			`read_unlock(&addrconf_lock);`
95			`return onlink;`
96			`}`
97
98
99			`/*`
100			`* socket join an anycast group`
101			`*/`
102
103			`int ipv6_sock_ac_join(struct sock sk, int ifindex, struct in6_addr addr)`
104			`{`
105			`struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;`
106			`struct net_device *dev = NULL;`
107			`struct inet6_dev *idev;`
108			`struct ipv6_ac_socklist *pac;`
109			`int ishost = !ipv6_devconf.forwarding;`
110			`int err = 0;`
111
112			`if (ipv6_addr_type(addr) & IPV6_ADDR_MULTICAST)`
113			`return -EINVAL;`
114
115			`pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);`
116			`if (pac == NULL)`
117			`return -ENOMEM;`
118			`pac->acl_next = NULL;`
119			`ipv6_addr_copy(&pac->acl_addr, addr);`
120
121			`if (ifindex == 0) {`
122			`struct rt6_info *rt;`
123
124			`rt = rt6_lookup(addr, NULL, 0, 0);`
125			`if (rt) {`
126			`dev = rt->rt6i_dev;`
127			`dev_hold(dev);`
128			`dst_release(&rt->u.dst);`
129			`} else if (ishost) {`
130			`err = -EADDRNOTAVAIL;`
131			`goto out_free_pac;`
132			`} else {`
133			`/* router, no matching interface: just pick one */`
134
135			`dev = dev_get_by_flags(IFF_UP, IFF_UP\|IFF_LOOPBACK);`
136			`}`
137			`} else`
138			`dev = dev_get_by_index(ifindex);`
139
140			`if (dev == NULL) {`
141			`err = -ENODEV;`
142			`goto out_free_pac;`
143			`}`
144
145			`idev = in6_dev_get(dev);`
146			`if (!idev) {`
147			`if (ifindex)`
148			`err = -ENODEV;`
149			`else`
150			`err = -EADDRNOTAVAIL;`
151			`goto out_dev_put;`
152			`}`
153			`/* reset ishost, now that we have a specific device */`
154			`ishost = !idev->cnf.forwarding;`
155			`in6_dev_put(idev);`
156
157			`pac->acl_ifindex = dev->ifindex;`
158
159			`/* XXX`
160			`* For hosts, allow link-local or matching prefix anycasts.`
161			`* This obviates the need for propagating anycast routes while`
162			`* still allowing some non-router anycast participation.`
163			`*`
164			`* allow anyone to join anycasts that don't require a special route`
165			`* and can't be spoofs of unicast addresses (reserved anycast only)`
166			`*/`
167			`if (!ip6_onlink(addr, dev)) {`
168			`if (ishost)`
169			`err = -EADDRNOTAVAIL;`
170			`else if (!capable(CAP_NET_ADMIN))`
171			`err = -EPERM;`
172			`if (err)`
173			`goto out_dev_put;`
174			`} else if (!(ipv6_addr_type(addr) & IPV6_ADDR_ANYCAST) &&`
175			`!capable(CAP_NET_ADMIN)) {`
176			`err = -EPERM;`
177			`goto out_dev_put;`
178			`}`
179
180			`err = ipv6_dev_ac_inc(dev, addr);`
181			`if (err)`
182			`goto out_dev_put;`
183
184			`write_lock_bh(&ipv6_sk_ac_lock);`
185			`pac->acl_next = np->ipv6_ac_list;`
186			`np->ipv6_ac_list = pac;`
187			`write_unlock_bh(&ipv6_sk_ac_lock);`
188
189			`dev_put(dev);`
190
191			`return 0;`
192
193			`out_dev_put:`
194			`dev_put(dev);`
195			`out_free_pac:`
196			`sock_kfree_s(sk, pac, sizeof(*pac));`
197			`return err;`
198			`}`
199
200			`/*`
201			`* socket leave an anycast group`
202			`*/`
203			`int ipv6_sock_ac_drop(struct sock sk, int ifindex, struct in6_addr addr)`
204			`{`
205			`struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;`
206			`struct net_device *dev;`
207			`struct ipv6_ac_socklist pac, prev_pac;`
208
209			`write_lock_bh(&ipv6_sk_ac_lock);`
210			`prev_pac = 0;`
211			`for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {`
212			`if ((ifindex == 0 \|\| pac->acl_ifindex == ifindex) &&`
213			`ipv6_addr_cmp(&pac->acl_addr, addr) == 0)`
214			`break;`
215			`prev_pac = pac;`
216			`}`
217			`if (!pac) {`
218			`write_unlock_bh(&ipv6_sk_ac_lock);`
219			`return -ENOENT;`
220			`}`
221			`if (prev_pac)`
222			`prev_pac->acl_next = pac->acl_next;`
223			`else`
224			`np->ipv6_ac_list = pac->acl_next;`
225
226			`write_unlock_bh(&ipv6_sk_ac_lock);`
227
228			`dev = dev_get_by_index(pac->acl_ifindex);`
229			`if (dev) {`
230			`ipv6_dev_ac_dec(dev, &pac->acl_addr);`
231			`dev_put(dev);`
232			`}`
233			`sock_kfree_s(sk, pac, sizeof(*pac));`
234			`return 0;`
235			`}`
236
237			`void ipv6_sock_ac_close(struct sock *sk)`
238			`{`
239			`struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;`
240			`struct net_device *dev = 0;`
241			`struct ipv6_ac_socklist *pac;`
242			`int prev_index;`
243
244			`write_lock_bh(&ipv6_sk_ac_lock);`
245			`pac = np->ipv6_ac_list;`
246			`np->ipv6_ac_list = 0;`
247			`write_unlock_bh(&ipv6_sk_ac_lock);`
248
249			`prev_index = 0;`
250			`while (pac) {`
251			`struct ipv6_ac_socklist *next = pac->acl_next;`
252
253			`if (pac->acl_ifindex != prev_index) {`
254			`if (dev)`
255			`dev_put(dev);`
256			`dev = dev_get_by_index(pac->acl_ifindex);`
257			`prev_index = pac->acl_ifindex;`
258			`}`
259			`if (dev)`
260			`ipv6_dev_ac_dec(dev, &pac->acl_addr);`
261			`sock_kfree_s(sk, pac, sizeof(*pac));`
262			`pac = next;`
263			`}`
264			`if (dev)`
265			`dev_put(dev);`
266			`}`
267
268			`int inet6_ac_check(struct sock sk, struct in6_addr addr, int ifindex)`
269			`{`
270			`struct ipv6_ac_socklist *pac;`
271			`struct ipv6_pinfo *np = &sk->net_pinfo.af_inet6;`
272			`int found;`
273
274			`found = 0;`
275			`read_lock(&ipv6_sk_ac_lock);`
276			`for (pac=np->ipv6_ac_list; pac; pac=pac->acl_next) {`
277			`if (ifindex && pac->acl_ifindex != ifindex)`
278			`continue;`
279			`found = ipv6_addr_cmp(&pac->acl_addr, addr) == 0;`
280			`if (found)`
281			`break;`
282			`}`
283			`read_unlock(&ipv6_sk_ac_lock);`
284
285			`return found;`
286			`}`
287
288			`static void aca_put(struct ifacaddr6 *ac)`
289			`{`
290			`if (atomic_dec_and_test(&ac->aca_refcnt)) {`
291			`in6_dev_put(ac->aca_idev);`
292			`kfree(ac);`
293			`}`
294			`}`
295
296			`/*`
297			`* device anycast group inc (add if not found)`
298			`*/`
299			`int ipv6_dev_ac_inc(struct net_device dev, struct in6_addr addr)`
300			`{`
301			`struct ifacaddr6 *aca;`
302			`struct inet6_dev *idev;`
303
304			`idev = in6_dev_get(dev);`
305
306			`if (idev == NULL)`
307			`return -EINVAL;`
308
309			`write_lock_bh(&idev->lock);`
310			`if (idev->dead) {`
311			`write_unlock_bh(&idev->lock);`
312			`in6_dev_put(idev);`
313			`return -ENODEV;`
314			`}`
315
316			`for (aca = idev->ac_list; aca; aca = aca->aca_next) {`
317			`if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0) {`
318			`aca->aca_users++;`
319			`write_unlock_bh(&idev->lock);`
320			`in6_dev_put(idev);`
321			`return 0;`
322			`}`
323			`}`
324
325			`/*`
326			`* not found: create a new one.`
327			`*/`
328
329			`aca = kmalloc(sizeof(struct ifacaddr6), GFP_ATOMIC);`
330
331			`if (aca == NULL) {`
332			`write_unlock_bh(&idev->lock);`
333			`in6_dev_put(idev);`
334			`return -ENOMEM;`
335			`}`
336
337			`memset(aca, 0, sizeof(struct ifacaddr6));`
338
339			`ipv6_addr_copy(&aca->aca_addr, addr);`
340			`aca->aca_idev = idev;`
341			`aca->aca_users = 1;`
342			`atomic_set(&aca->aca_refcnt, 2);`
343			`aca->aca_lock = SPIN_LOCK_UNLOCKED;`
344
345			`aca->aca_next = idev->ac_list;`
346			`idev->ac_list = aca;`
347			`write_unlock_bh(&idev->lock);`
348
349			`ip6_rt_addr_add(&aca->aca_addr, dev);`
350
351			`addrconf_join_solict(dev, &aca->aca_addr);`
352
353			`aca_put(aca);`
354			`return 0;`
355			`}`
356
357			`/*`
358			`* device anycast group decrement`
359			`*/`
360			`int ipv6_dev_ac_dec(struct net_device dev, struct in6_addr addr)`
361			`{`
362			`struct inet6_dev *idev;`
363			`struct ifacaddr6 aca, prev_aca;`
364
365			`idev = in6_dev_get(dev);`
366			`if (idev == NULL)`
367			`return -ENODEV;`
368
369			`write_lock_bh(&idev->lock);`
370			`prev_aca = 0;`
371			`for (aca = idev->ac_list; aca; aca = aca->aca_next) {`
372			`if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0)`
373			`break;`
374			`prev_aca = aca;`
375			`}`
376			`if (!aca) {`
377			`write_unlock_bh(&idev->lock);`
378			`in6_dev_put(idev);`
379			`return -ENOENT;`
380			`}`
381			`if (--aca->aca_users > 0) {`
382			`write_unlock_bh(&idev->lock);`
383			`in6_dev_put(idev);`
384			`return 0;`
385			`}`
386			`if (prev_aca)`
387			`prev_aca->aca_next = aca->aca_next;`
388			`else`
389			`idev->ac_list = aca->aca_next;`
390			`write_unlock_bh(&idev->lock);`
391			`addrconf_leave_solict(dev, &aca->aca_addr);`
392
393			`ip6_rt_addr_del(&aca->aca_addr, dev);`
394
395			`aca_put(aca);`
396			`in6_dev_put(idev);`
397			`return 0;`
398			`}`
399
400			`/*`
401			`* check if the interface has this anycast address`
402			`*/`
403			`static int ipv6_chk_acast_dev(struct net_device dev, struct in6_addr addr)`
404			`{`
405			`struct inet6_dev *idev;`
406			`struct ifacaddr6 *aca;`
407
408			`idev = in6_dev_get(dev);`
409			`if (idev) {`
410			`read_lock_bh(&idev->lock);`
411			`for (aca = idev->ac_list; aca; aca = aca->aca_next)`
412			`if (ipv6_addr_cmp(&aca->aca_addr, addr) == 0)`
413			`break;`
414			`read_unlock_bh(&idev->lock);`
415			`in6_dev_put(idev);`
416			`return aca != 0;`
417			`}`
418			`return 0;`
419			`}`
420
421			`/*`
422			`* check if given interface (or any, if dev==0) has this anycast address`
423			`*/`
424			`int ipv6_chk_acast_addr(struct net_device dev, struct in6_addr addr)`
425			`{`
426			`if (dev)`
427			`return ipv6_chk_acast_dev(dev, addr);`
428			`read_lock(&dev_base_lock);`
429			`for (dev=dev_base; dev; dev=dev->next)`
430			`if (ipv6_chk_acast_dev(dev, addr))`
431			`break;`
432			`read_unlock(&dev_base_lock);`
433			`return dev != 0;`
434			`}`
435
436
437			`#ifdef CONFIG_PROC_FS`
438			`int anycast6_get_info(char buffer, char *start, off_t offset, int length)`
439			`{`
440			`off_t pos=0, begin=0;`
441			`struct ifacaddr6 *im;`
442			`int len=0;`
443			`struct net_device *dev;`
444
445			`read_lock(&dev_base_lock);`
446			`for (dev = dev_base; dev; dev = dev->next) {`
447			`struct inet6_dev *idev;`
448
449			`if ((idev = in6_dev_get(dev)) == NULL)`
450			`continue;`
451
452			`read_lock_bh(&idev->lock);`
453			`for (im = idev->ac_list; im; im = im->aca_next) {`
454			`int i;`
455
456			`len += sprintf(buffer+len,"%-4d %-15s ", dev->ifindex, dev->name);`
457
458			`for (i=0; i<16; i++)`
459			`len += sprintf(buffer+len, "%02x", im->aca_addr.s6_addr[i]);`
460
461			`len += sprintf(buffer+len, " %5d\n", im->aca_users);`
462
463			`pos=begin+len;`
464			`if (pos < offset) {`
465			`len=0;`
466			`begin=pos;`
467			`}`
468			`if (pos > offset+length) {`
469			`read_unlock_bh(&idev->lock);`
470			`in6_dev_put(idev);`
471			`goto done;`
472			`}`
473			`}`
474			`read_unlock_bh(&idev->lock);`
475			`in6_dev_put(idev);`
476			`}`
477
478			`done:`
479			`read_unlock(&dev_base_lock);`
480
481			`*start=buffer+(offset-begin);`
482			`len-=(offset-begin);`
483			`if(len>length)`
484			`len=length;`
485			`if (len<0)`
486			`len=0;`
487			`return len;`
488			`}`
489
490			`#endif`