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