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