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