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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [ipv6/] [anycast.c] - Blame information for rev 81

Go to most recent revision | 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/capability.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/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 <linux/seq_file.h>
 
#include <net/net_namespace.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>
 
static int ipv6_dev_ac_dec(struct net_device *dev, struct in6_addr *addr);
 
/* Big ac list lock for all the sockets */
static DEFINE_RWLOCK(ipv6_sk_ac_lock);
 
static int
ip6_onlink(struct in6_addr *addr, struct net_device *dev)
{
        struct inet6_dev        *idev;
        struct inet6_ifaddr     *ifa;
        int     onlink;
 
        onlink = 0;
        rcu_read_lock();
        idev = __in6_dev_get(dev);
        if (idev) {
                read_lock_bh(&idev->lock);
                for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {
                        onlink = ipv6_prefix_equal(addr, &ifa->addr,
                                                   ifa->prefix_len);
                        if (onlink)
                                break;
                }
                read_unlock_bh(&idev->lock);
        }
        rcu_read_unlock();
        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 = inet6_sk(sk);
        struct net_device *dev = NULL;
        struct inet6_dev *idev;
        struct ipv6_ac_socklist *pac;
        int     ishost = !ipv6_devconf.forwarding;
        int     err = 0;
 
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
        if (ipv6_addr_is_multicast(addr))
                return -EINVAL;
        if (ipv6_chk_addr(addr, NULL, 0))
                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(&init_net, IFF_UP, IFF_UP|IFF_LOOPBACK);
                }
        } else
                dev = dev_get_by_index(&init_net, 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.
         */
        if (!ip6_onlink(addr, dev)) {
                if (ishost)
                        err = -EADDRNOTAVAIL;
                if (err)
                        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 = inet6_sk(sk);
        struct net_device *dev;
        struct ipv6_ac_socklist *pac, *prev_pac;
 
        write_lock_bh(&ipv6_sk_ac_lock);
        prev_pac = NULL;
        for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {
                if ((ifindex == 0 || pac->acl_ifindex == ifindex) &&
                     ipv6_addr_equal(&pac->acl_addr, addr))
                        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(&init_net, 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 = inet6_sk(sk);
        struct net_device *dev = NULL;
        struct ipv6_ac_socklist *pac;
        int     prev_index;
 
        write_lock_bh(&ipv6_sk_ac_lock);
        pac = np->ipv6_ac_list;
        np->ipv6_ac_list = NULL;
        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(&init_net, 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);
}
 
#if 0
/* The function is not used, which is funny. Apparently, author
 * supposed to use it to filter out datagrams inside udp/raw but forgot.
 *
 * It is OK, anycasts are not special comparing to delivery to unicasts.
 */
 
int inet6_ac_check(struct sock *sk, struct in6_addr *addr, int ifindex)
{
        struct ipv6_ac_socklist *pac;
        struct ipv6_pinfo *np = inet6_sk(sk);
        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_equal(&pac->acl_addr, addr);
                if (found)
                        break;
        }
        read_unlock(&ipv6_sk_ac_lock);
 
        return found;
}
 
#endif
 
static void aca_put(struct ifacaddr6 *ac)
{
        if (atomic_dec_and_test(&ac->aca_refcnt)) {
                in6_dev_put(ac->aca_idev);
                dst_release(&ac->aca_rt->u.dst);
                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;
        struct rt6_info *rt;
        int err;
 
        idev = in6_dev_get(dev);
 
        if (idev == NULL)
                return -EINVAL;
 
        write_lock_bh(&idev->lock);
        if (idev->dead) {
                err = -ENODEV;
                goto out;
        }
 
        for (aca = idev->ac_list; aca; aca = aca->aca_next) {
                if (ipv6_addr_equal(&aca->aca_addr, addr)) {
                        aca->aca_users++;
                        err = 0;
                        goto out;
                }
        }
 
        /*
         *      not found: create a new one.
         */
 
        aca = kzalloc(sizeof(struct ifacaddr6), GFP_ATOMIC);
 
        if (aca == NULL) {
                err = -ENOMEM;
                goto out;
        }
 
        rt = addrconf_dst_alloc(idev, addr, 1);
        if (IS_ERR(rt)) {
                kfree(aca);
                err = PTR_ERR(rt);
                goto out;
        }
 
        ipv6_addr_copy(&aca->aca_addr, addr);
        aca->aca_idev = idev;
        aca->aca_rt = rt;
        aca->aca_users = 1;
        /* aca_tstamp should be updated upon changes */
        aca->aca_cstamp = aca->aca_tstamp = jiffies;
        atomic_set(&aca->aca_refcnt, 2);
        spin_lock_init(&aca->aca_lock);
 
        aca->aca_next = idev->ac_list;
        idev->ac_list = aca;
        write_unlock_bh(&idev->lock);
 
        dst_hold(&rt->u.dst);
        if (ip6_ins_rt(rt))
                dst_release(&rt->u.dst);
 
        addrconf_join_solict(dev, &aca->aca_addr);
 
        aca_put(aca);
        return 0;
out:
        write_unlock_bh(&idev->lock);
        in6_dev_put(idev);
        return err;
}
 
/*
 *      device anycast group decrement
 */
int __ipv6_dev_ac_dec(struct inet6_dev *idev, struct in6_addr *addr)
{
        struct ifacaddr6 *aca, *prev_aca;
 
        write_lock_bh(&idev->lock);
        prev_aca = NULL;
        for (aca = idev->ac_list; aca; aca = aca->aca_next) {
                if (ipv6_addr_equal(&aca->aca_addr, addr))
                        break;
                prev_aca = aca;
        }
        if (!aca) {
                write_unlock_bh(&idev->lock);
                return -ENOENT;
        }
        if (--aca->aca_users > 0) {
                write_unlock_bh(&idev->lock);
                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(idev, &aca->aca_addr);
 
        dst_hold(&aca->aca_rt->u.dst);
        if (ip6_del_rt(aca->aca_rt))
                dst_free(&aca->aca_rt->u.dst);
        else
                dst_release(&aca->aca_rt->u.dst);
 
        aca_put(aca);
        return 0;
}
 
static int ipv6_dev_ac_dec(struct net_device *dev, struct in6_addr *addr)
{
        int ret;
        struct inet6_dev *idev = in6_dev_get(dev);
        if (idev == NULL)
                return -ENODEV;
        ret = __ipv6_dev_ac_dec(idev, addr);
        in6_dev_put(idev);
        return ret;
}
 
/*
 *      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_equal(&aca->aca_addr, addr))
                                break;
                read_unlock_bh(&idev->lock);
                in6_dev_put(idev);
                return aca != NULL;
        }
        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)
{
        int found = 0;
 
        if (dev)
                return ipv6_chk_acast_dev(dev, addr);
        read_lock(&dev_base_lock);
        for_each_netdev(&init_net, dev)
                if (ipv6_chk_acast_dev(dev, addr)) {
                        found = 1;
                        break;
                }
        read_unlock(&dev_base_lock);
        return found;
}
 
 
#ifdef CONFIG_PROC_FS
struct ac6_iter_state {
        struct net_device *dev;
        struct inet6_dev *idev;
};
 
#define ac6_seq_private(seq)    ((struct ac6_iter_state *)(seq)->private)
 
static inline struct ifacaddr6 *ac6_get_first(struct seq_file *seq)
{
        struct ifacaddr6 *im = NULL;
        struct ac6_iter_state *state = ac6_seq_private(seq);
 
        state->idev = NULL;
        for_each_netdev(&init_net, state->dev) {
                struct inet6_dev *idev;
                idev = in6_dev_get(state->dev);
                if (!idev)
                        continue;
                read_lock_bh(&idev->lock);
                im = idev->ac_list;
                if (im) {
                        state->idev = idev;
                        break;
                }
                read_unlock_bh(&idev->lock);
                in6_dev_put(idev);
        }
        return im;
}
 
static struct ifacaddr6 *ac6_get_next(struct seq_file *seq, struct ifacaddr6 *im)
{
        struct ac6_iter_state *state = ac6_seq_private(seq);
 
        im = im->aca_next;
        while (!im) {
                if (likely(state->idev != NULL)) {
                        read_unlock_bh(&state->idev->lock);
                        in6_dev_put(state->idev);
                }
                state->dev = next_net_device(state->dev);
                if (!state->dev) {
                        state->idev = NULL;
                        break;
                }
                state->idev = in6_dev_get(state->dev);
                if (!state->idev)
                        continue;
                read_lock_bh(&state->idev->lock);
                im = state->idev->ac_list;
        }
        return im;
}
 
static struct ifacaddr6 *ac6_get_idx(struct seq_file *seq, loff_t pos)
{
        struct ifacaddr6 *im = ac6_get_first(seq);
        if (im)
                while (pos && (im = ac6_get_next(seq, im)) != NULL)
                        --pos;
        return pos ? NULL : im;
}
 
static void *ac6_seq_start(struct seq_file *seq, loff_t *pos)
{
        read_lock(&dev_base_lock);
        return ac6_get_idx(seq, *pos);
}
 
static void *ac6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
        struct ifacaddr6 *im;
        im = ac6_get_next(seq, v);
        ++*pos;
        return im;
}
 
static void ac6_seq_stop(struct seq_file *seq, void *v)
{
        struct ac6_iter_state *state = ac6_seq_private(seq);
        if (likely(state->idev != NULL)) {
                read_unlock_bh(&state->idev->lock);
                in6_dev_put(state->idev);
        }
        read_unlock(&dev_base_lock);
}
 
static int ac6_seq_show(struct seq_file *seq, void *v)
{
        struct ifacaddr6 *im = (struct ifacaddr6 *)v;
        struct ac6_iter_state *state = ac6_seq_private(seq);
 
        seq_printf(seq,
                   "%-4d %-15s " NIP6_SEQFMT " %5d\n",
                   state->dev->ifindex, state->dev->name,
                   NIP6(im->aca_addr),
                   im->aca_users);
        return 0;
}
 
static const struct seq_operations ac6_seq_ops = {
        .start  =       ac6_seq_start,
        .next   =       ac6_seq_next,
        .stop   =       ac6_seq_stop,
        .show   =       ac6_seq_show,
};
 
static int ac6_seq_open(struct inode *inode, struct file *file)
{
        return seq_open_private(file, &ac6_seq_ops,
                        sizeof(struct ac6_iter_state));
}
 
static const struct file_operations ac6_seq_fops = {
        .owner          =       THIS_MODULE,
        .open           =       ac6_seq_open,
        .read           =       seq_read,
        .llseek         =       seq_lseek,
        .release        =       seq_release_private,
};
 
int __init ac6_proc_init(void)
{
        if (!proc_net_fops_create(&init_net, "anycast6", S_IRUGO, &ac6_seq_fops))
                return -ENOMEM;
 
        return 0;
}
 
void ac6_proc_exit(void)
{
        proc_net_remove(&init_net, "anycast6");
}
#endif
 

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [ipv6/] [anycast.c] - Blame information for rev 81

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
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/capability.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/net.h>`
25			`#include <linux/in6.h>`
26			`#include <linux/netdevice.h>`
27			`#include <linux/if_arp.h>`
28			`#include <linux/route.h>`
29			`#include <linux/init.h>`
30			`#include <linux/proc_fs.h>`
31			`#include <linux/seq_file.h>`
32
33			`#include <net/net_namespace.h>`
34			`#include <net/sock.h>`
35			`#include <net/snmp.h>`
36
37			`#include <net/ipv6.h>`
38			`#include <net/protocol.h>`
39			`#include <net/if_inet6.h>`
40			`#include <net/ndisc.h>`
41			`#include <net/addrconf.h>`
42			`#include <net/ip6_route.h>`
43
44			`#include <net/checksum.h>`
45
46			`static int ipv6_dev_ac_dec(struct net_device dev, struct in6_addr addr);`
47
48			`/* Big ac list lock for all the sockets */`
49			`static DEFINE_RWLOCK(ipv6_sk_ac_lock);`
50
51			`static int`
52			`ip6_onlink(struct in6_addr addr, struct net_device dev)`
53			`{`
54			`struct inet6_dev *idev;`
55			`struct inet6_ifaddr *ifa;`
56			`int onlink;`
57
58			`onlink = 0;`
59			`rcu_read_lock();`
60			`idev = __in6_dev_get(dev);`
61			`if (idev) {`
62			`read_lock_bh(&idev->lock);`
63			`for (ifa=idev->addr_list; ifa; ifa=ifa->if_next) {`
64			`onlink = ipv6_prefix_equal(addr, &ifa->addr,`
65			`ifa->prefix_len);`
66			`if (onlink)`
67			`break;`
68			`}`
69			`read_unlock_bh(&idev->lock);`
70			`}`
71			`rcu_read_unlock();`
72			`return onlink;`
73			`}`
74
75			`/*`
76			`* socket join an anycast group`
77			`*/`
78
79			`int ipv6_sock_ac_join(struct sock sk, int ifindex, struct in6_addr addr)`
80			`{`
81			`struct ipv6_pinfo *np = inet6_sk(sk);`
82			`struct net_device *dev = NULL;`
83			`struct inet6_dev *idev;`
84			`struct ipv6_ac_socklist *pac;`
85			`int ishost = !ipv6_devconf.forwarding;`
86			`int err = 0;`
87
88			`if (!capable(CAP_NET_ADMIN))`
89			`return -EPERM;`
90			`if (ipv6_addr_is_multicast(addr))`
91			`return -EINVAL;`
92			`if (ipv6_chk_addr(addr, NULL, 0))`
93			`return -EINVAL;`
94
95			`pac = sock_kmalloc(sk, sizeof(struct ipv6_ac_socklist), GFP_KERNEL);`
96			`if (pac == NULL)`
97			`return -ENOMEM;`
98			`pac->acl_next = NULL;`
99			`ipv6_addr_copy(&pac->acl_addr, addr);`
100
101			`if (ifindex == 0) {`
102			`struct rt6_info *rt;`
103
104			`rt = rt6_lookup(addr, NULL, 0, 0);`
105			`if (rt) {`
106			`dev = rt->rt6i_dev;`
107			`dev_hold(dev);`
108			`dst_release(&rt->u.dst);`
109			`} else if (ishost) {`
110			`err = -EADDRNOTAVAIL;`
111			`goto out_free_pac;`
112			`} else {`
113			`/* router, no matching interface: just pick one */`
114
115			`dev = dev_get_by_flags(&init_net, IFF_UP, IFF_UP\|IFF_LOOPBACK);`
116			`}`
117			`} else`
118			`dev = dev_get_by_index(&init_net, ifindex);`
119
120			`if (dev == NULL) {`
121			`err = -ENODEV;`
122			`goto out_free_pac;`
123			`}`
124
125			`idev = in6_dev_get(dev);`
126			`if (!idev) {`
127			`if (ifindex)`
128			`err = -ENODEV;`
129			`else`
130			`err = -EADDRNOTAVAIL;`
131			`goto out_dev_put;`
132			`}`
133			`/* reset ishost, now that we have a specific device */`
134			`ishost = !idev->cnf.forwarding;`
135			`in6_dev_put(idev);`
136
137			`pac->acl_ifindex = dev->ifindex;`
138
139			`/* XXX`
140			`* For hosts, allow link-local or matching prefix anycasts.`
141			`* This obviates the need for propagating anycast routes while`
142			`* still allowing some non-router anycast participation.`
143			`*/`
144			`if (!ip6_onlink(addr, dev)) {`
145			`if (ishost)`
146			`err = -EADDRNOTAVAIL;`
147			`if (err)`
148			`goto out_dev_put;`
149			`}`
150
151			`err = ipv6_dev_ac_inc(dev, addr);`
152			`if (err)`
153			`goto out_dev_put;`
154
155			`write_lock_bh(&ipv6_sk_ac_lock);`
156			`pac->acl_next = np->ipv6_ac_list;`
157			`np->ipv6_ac_list = pac;`
158			`write_unlock_bh(&ipv6_sk_ac_lock);`
159
160			`dev_put(dev);`
161
162			`return 0;`
163
164			`out_dev_put:`
165			`dev_put(dev);`
166			`out_free_pac:`
167			`sock_kfree_s(sk, pac, sizeof(*pac));`
168			`return err;`
169			`}`
170
171			`/*`
172			`* socket leave an anycast group`
173			`*/`
174			`int ipv6_sock_ac_drop(struct sock sk, int ifindex, struct in6_addr addr)`
175			`{`
176			`struct ipv6_pinfo *np = inet6_sk(sk);`
177			`struct net_device *dev;`
178			`struct ipv6_ac_socklist pac, prev_pac;`
179
180			`write_lock_bh(&ipv6_sk_ac_lock);`
181			`prev_pac = NULL;`
182			`for (pac = np->ipv6_ac_list; pac; pac = pac->acl_next) {`
183			`if ((ifindex == 0 \|\| pac->acl_ifindex == ifindex) &&`
184			`ipv6_addr_equal(&pac->acl_addr, addr))`
185			`break;`
186			`prev_pac = pac;`
187			`}`
188			`if (!pac) {`
189			`write_unlock_bh(&ipv6_sk_ac_lock);`
190			`return -ENOENT;`
191			`}`
192			`if (prev_pac)`
193			`prev_pac->acl_next = pac->acl_next;`
194			`else`
195			`np->ipv6_ac_list = pac->acl_next;`
196
197			`write_unlock_bh(&ipv6_sk_ac_lock);`
198
199			`dev = dev_get_by_index(&init_net, pac->acl_ifindex);`
200			`if (dev) {`
201			`ipv6_dev_ac_dec(dev, &pac->acl_addr);`
202			`dev_put(dev);`
203			`}`
204			`sock_kfree_s(sk, pac, sizeof(*pac));`
205			`return 0;`
206			`}`
207
208			`void ipv6_sock_ac_close(struct sock *sk)`
209			`{`
210			`struct ipv6_pinfo *np = inet6_sk(sk);`
211			`struct net_device *dev = NULL;`
212			`struct ipv6_ac_socklist *pac;`
213			`int prev_index;`
214
215			`write_lock_bh(&ipv6_sk_ac_lock);`
216			`pac = np->ipv6_ac_list;`
217			`np->ipv6_ac_list = NULL;`
218			`write_unlock_bh(&ipv6_sk_ac_lock);`
219
220			`prev_index = 0;`
221			`while (pac) {`
222			`struct ipv6_ac_socklist *next = pac->acl_next;`
223
224			`if (pac->acl_ifindex != prev_index) {`
225			`if (dev)`
226			`dev_put(dev);`
227			`dev = dev_get_by_index(&init_net, pac->acl_ifindex);`
228			`prev_index = pac->acl_ifindex;`
229			`}`
230			`if (dev)`
231			`ipv6_dev_ac_dec(dev, &pac->acl_addr);`
232			`sock_kfree_s(sk, pac, sizeof(*pac));`
233			`pac = next;`
234			`}`
235			`if (dev)`
236			`dev_put(dev);`
237			`}`
238
239			`#if 0`
240			`/* The function is not used, which is funny. Apparently, author`
241			`* supposed to use it to filter out datagrams inside udp/raw but forgot.`
242			`*`
243			`* It is OK, anycasts are not special comparing to delivery to unicasts.`
244			`*/`
245
246			`int inet6_ac_check(struct sock sk, struct in6_addr addr, int ifindex)`
247			`{`
248			`struct ipv6_ac_socklist *pac;`
249			`struct ipv6_pinfo *np = inet6_sk(sk);`
250			`int found;`
251
252			`found = 0;`
253			`read_lock(&ipv6_sk_ac_lock);`
254			`for (pac=np->ipv6_ac_list; pac; pac=pac->acl_next) {`
255			`if (ifindex && pac->acl_ifindex != ifindex)`
256			`continue;`
257			`found = ipv6_addr_equal(&pac->acl_addr, addr);`
258			`if (found)`
259			`break;`
260			`}`
261			`read_unlock(&ipv6_sk_ac_lock);`
262
263			`return found;`
264			`}`
265
266			`#endif`
267
268			`static void aca_put(struct ifacaddr6 *ac)`
269			`{`
270			`if (atomic_dec_and_test(&ac->aca_refcnt)) {`
271			`in6_dev_put(ac->aca_idev);`
272			`dst_release(&ac->aca_rt->u.dst);`
273			`kfree(ac);`
274			`}`
275			`}`
276
277			`/*`
278			`* device anycast group inc (add if not found)`
279			`*/`
280			`int ipv6_dev_ac_inc(struct net_device dev, struct in6_addr addr)`
281			`{`
282			`struct ifacaddr6 *aca;`
283			`struct inet6_dev *idev;`
284			`struct rt6_info *rt;`
285			`int err;`
286
287			`idev = in6_dev_get(dev);`
288
289			`if (idev == NULL)`
290			`return -EINVAL;`
291
292			`write_lock_bh(&idev->lock);`
293			`if (idev->dead) {`
294			`err = -ENODEV;`
295			`goto out;`
296			`}`
297
298			`for (aca = idev->ac_list; aca; aca = aca->aca_next) {`
299			`if (ipv6_addr_equal(&aca->aca_addr, addr)) {`
300			`aca->aca_users++;`
301			`err = 0;`
302			`goto out;`
303			`}`
304			`}`
305
306			`/*`
307			`* not found: create a new one.`
308			`*/`
309
310			`aca = kzalloc(sizeof(struct ifacaddr6), GFP_ATOMIC);`
311
312			`if (aca == NULL) {`
313			`err = -ENOMEM;`
314			`goto out;`
315			`}`
316
317			`rt = addrconf_dst_alloc(idev, addr, 1);`
318			`if (IS_ERR(rt)) {`
319			`kfree(aca);`
320			`err = PTR_ERR(rt);`
321			`goto out;`
322			`}`
323
324			`ipv6_addr_copy(&aca->aca_addr, addr);`
325			`aca->aca_idev = idev;`
326			`aca->aca_rt = rt;`
327			`aca->aca_users = 1;`
328			`/* aca_tstamp should be updated upon changes */`
329			`aca->aca_cstamp = aca->aca_tstamp = jiffies;`
330			`atomic_set(&aca->aca_refcnt, 2);`
331			`spin_lock_init(&aca->aca_lock);`
332
333			`aca->aca_next = idev->ac_list;`
334			`idev->ac_list = aca;`
335			`write_unlock_bh(&idev->lock);`
336
337			`dst_hold(&rt->u.dst);`
338			`if (ip6_ins_rt(rt))`
339			`dst_release(&rt->u.dst);`
340
341			`addrconf_join_solict(dev, &aca->aca_addr);`
342
343			`aca_put(aca);`
344			`return 0;`
345			`out:`
346			`write_unlock_bh(&idev->lock);`
347			`in6_dev_put(idev);`
348			`return err;`
349			`}`
350
351			`/*`
352			`* device anycast group decrement`
353			`*/`
354			`int __ipv6_dev_ac_dec(struct inet6_dev idev, struct in6_addr addr)`
355			`{`
356			`struct ifacaddr6 aca, prev_aca;`
357
358			`write_lock_bh(&idev->lock);`
359			`prev_aca = NULL;`
360			`for (aca = idev->ac_list; aca; aca = aca->aca_next) {`
361			`if (ipv6_addr_equal(&aca->aca_addr, addr))`
362			`break;`
363			`prev_aca = aca;`
364			`}`
365			`if (!aca) {`
366			`write_unlock_bh(&idev->lock);`
367			`return -ENOENT;`
368			`}`
369			`if (--aca->aca_users > 0) {`
370			`write_unlock_bh(&idev->lock);`
371			`return 0;`
372			`}`
373			`if (prev_aca)`
374			`prev_aca->aca_next = aca->aca_next;`
375			`else`
376			`idev->ac_list = aca->aca_next;`
377			`write_unlock_bh(&idev->lock);`
378			`addrconf_leave_solict(idev, &aca->aca_addr);`
379
380			`dst_hold(&aca->aca_rt->u.dst);`
381			`if (ip6_del_rt(aca->aca_rt))`
382			`dst_free(&aca->aca_rt->u.dst);`
383			`else`
384			`dst_release(&aca->aca_rt->u.dst);`
385
386			`aca_put(aca);`
387			`return 0;`
388			`}`
389
390			`static int ipv6_dev_ac_dec(struct net_device dev, struct in6_addr addr)`
391			`{`
392			`int ret;`
393			`struct inet6_dev *idev = in6_dev_get(dev);`
394			`if (idev == NULL)`
395			`return -ENODEV;`
396			`ret = __ipv6_dev_ac_dec(idev, addr);`
397			`in6_dev_put(idev);`
398			`return ret;`
399			`}`
400
401			`/*`
402			`* check if the interface has this anycast address`
403			`*/`
404			`static int ipv6_chk_acast_dev(struct net_device dev, struct in6_addr addr)`
405			`{`
406			`struct inet6_dev *idev;`
407			`struct ifacaddr6 *aca;`
408
409			`idev = in6_dev_get(dev);`
410			`if (idev) {`
411			`read_lock_bh(&idev->lock);`
412			`for (aca = idev->ac_list; aca; aca = aca->aca_next)`
413			`if (ipv6_addr_equal(&aca->aca_addr, addr))`
414			`break;`
415			`read_unlock_bh(&idev->lock);`
416			`in6_dev_put(idev);`
417			`return aca != NULL;`
418			`}`
419			`return 0;`
420			`}`
421
422			`/*`
423			`* check if given interface (or any, if dev==0) has this anycast address`
424			`*/`
425			`int ipv6_chk_acast_addr(struct net_device dev, struct in6_addr addr)`
426			`{`
427			`int found = 0;`
428
429			`if (dev)`
430			`return ipv6_chk_acast_dev(dev, addr);`
431			`read_lock(&dev_base_lock);`
432			`for_each_netdev(&init_net, dev)`
433			`if (ipv6_chk_acast_dev(dev, addr)) {`
434			`found = 1;`
435			`break;`
436			`}`
437			`read_unlock(&dev_base_lock);`
438			`return found;`
439			`}`
440
441
442			`#ifdef CONFIG_PROC_FS`
443			`struct ac6_iter_state {`
444			`struct net_device *dev;`
445			`struct inet6_dev *idev;`
446			`};`
447
448			`#define ac6_seq_private(seq) ((struct ac6_iter_state *)(seq)->private)`
449
450			`static inline struct ifacaddr6 ac6_get_first(struct seq_file seq)`
451			`{`
452			`struct ifacaddr6 *im = NULL;`
453			`struct ac6_iter_state *state = ac6_seq_private(seq);`
454
455			`state->idev = NULL;`
456			`for_each_netdev(&init_net, state->dev) {`
457			`struct inet6_dev *idev;`
458			`idev = in6_dev_get(state->dev);`
459			`if (!idev)`
460			`continue;`
461			`read_lock_bh(&idev->lock);`
462			`im = idev->ac_list;`
463			`if (im) {`
464			`state->idev = idev;`
465			`break;`
466			`}`
467			`read_unlock_bh(&idev->lock);`
468			`in6_dev_put(idev);`
469			`}`
470			`return im;`
471			`}`
472
473			`static struct ifacaddr6 ac6_get_next(struct seq_file seq, struct ifacaddr6 *im)`
474			`{`
475			`struct ac6_iter_state *state = ac6_seq_private(seq);`
476
477			`im = im->aca_next;`
478			`while (!im) {`
479			`if (likely(state->idev != NULL)) {`
480			`read_unlock_bh(&state->idev->lock);`
481			`in6_dev_put(state->idev);`
482			`}`
483			`state->dev = next_net_device(state->dev);`
484			`if (!state->dev) {`
485			`state->idev = NULL;`
486			`break;`
487			`}`
488			`state->idev = in6_dev_get(state->dev);`
489			`if (!state->idev)`
490			`continue;`
491			`read_lock_bh(&state->idev->lock);`
492			`im = state->idev->ac_list;`
493			`}`
494			`return im;`
495			`}`
496
497			`static struct ifacaddr6 ac6_get_idx(struct seq_file seq, loff_t pos)`
498			`{`
499			`struct ifacaddr6 *im = ac6_get_first(seq);`
500			`if (im)`
501			`while (pos && (im = ac6_get_next(seq, im)) != NULL)`
502			`--pos;`
503			`return pos ? NULL : im;`
504			`}`
505
506			`static void ac6_seq_start(struct seq_file seq, loff_t *pos)`
507			`{`
508			`read_lock(&dev_base_lock);`
509			`return ac6_get_idx(seq, *pos);`
510			`}`
511
512			`static void ac6_seq_next(struct seq_file seq, void v, loff_t pos)`
513			`{`
514			`struct ifacaddr6 *im;`
515			`im = ac6_get_next(seq, v);`
516			`++*pos;`
517			`return im;`
518			`}`
519
520			`static void ac6_seq_stop(struct seq_file seq, void v)`
521			`{`
522			`struct ac6_iter_state *state = ac6_seq_private(seq);`
523			`if (likely(state->idev != NULL)) {`
524			`read_unlock_bh(&state->idev->lock);`
525			`in6_dev_put(state->idev);`
526			`}`
527			`read_unlock(&dev_base_lock);`
528			`}`
529
530			`static int ac6_seq_show(struct seq_file seq, void v)`
531			`{`
532			`struct ifacaddr6 im = (struct ifacaddr6 )v;`
533			`struct ac6_iter_state *state = ac6_seq_private(seq);`
534
535			`seq_printf(seq,`
536			`"%-4d %-15s " NIP6_SEQFMT " %5d\n",`
537			`state->dev->ifindex, state->dev->name,`
538			`NIP6(im->aca_addr),`
539			`im->aca_users);`
540			`return 0;`
541			`}`
542
543			`static const struct seq_operations ac6_seq_ops = {`
544			`.start = ac6_seq_start,`
545			`.next = ac6_seq_next,`
546			`.stop = ac6_seq_stop,`
547			`.show = ac6_seq_show,`
548			`};`
549
550			`static int ac6_seq_open(struct inode inode, struct file file)`
551			`{`
552			`return seq_open_private(file, &ac6_seq_ops,`
553			`sizeof(struct ac6_iter_state));`
554			`}`
555
556			`static const struct file_operations ac6_seq_fops = {`
557			`.owner = THIS_MODULE,`
558			`.open = ac6_seq_open,`
559			`.read = seq_read,`
560			`.llseek = seq_lseek,`
561			`.release = seq_release_private,`
562			`};`
563
564			`int __init ac6_proc_init(void)`
565			`{`
566			`if (!proc_net_fops_create(&init_net, "anycast6", S_IRUGO, &ac6_seq_fops))`
567			`return -ENOMEM;`
568
569			`return 0;`
570			`}`
571
572			`void ac6_proc_exit(void)`
573			`{`
574			`proc_net_remove(&init_net, "anycast6");`
575			`}`
576			`#endif`
577