1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#define pr_fmt(fmt) "IPv6: " fmt
38
39#include <linux/errno.h>
40#include <linux/types.h>
41#include <linux/kernel.h>
42#include <linux/sched/signal.h>
43#include <linux/socket.h>
44#include <linux/sockios.h>
45#include <linux/net.h>
46#include <linux/inet.h>
47#include <linux/in6.h>
48#include <linux/netdevice.h>
49#include <linux/if_addr.h>
50#include <linux/if_arp.h>
51#include <linux/if_arcnet.h>
52#include <linux/if_infiniband.h>
53#include <linux/route.h>
54#include <linux/inetdevice.h>
55#include <linux/init.h>
56#include <linux/slab.h>
57#ifdef CONFIG_SYSCTL
58#include <linux/sysctl.h>
59#endif
60#include <linux/capability.h>
61#include <linux/delay.h>
62#include <linux/notifier.h>
63#include <linux/string.h>
64#include <linux/hash.h>
65
66#include <net/net_namespace.h>
67#include <net/sock.h>
68#include <net/snmp.h>
69
70#include <net/6lowpan.h>
71#include <net/firewire.h>
72#include <net/ipv6.h>
73#include <net/protocol.h>
74#include <net/ndisc.h>
75#include <net/ip6_route.h>
76#include <net/addrconf.h>
77#include <net/tcp.h>
78#include <net/ip.h>
79#include <net/netlink.h>
80#include <net/pkt_sched.h>
81#include <net/l3mdev.h>
82#include <linux/if_tunnel.h>
83#include <linux/rtnetlink.h>
84#include <linux/netconf.h>
85#include <linux/random.h>
86#include <linux/uaccess.h>
87#include <asm/unaligned.h>
88
89#include <linux/proc_fs.h>
90#include <linux/seq_file.h>
91#include <linux/export.h>
92#include <linux/ioam6.h>
93
94#define INFINITY_LIFE_TIME 0xFFFFFFFF
95
96#define IPV6_MAX_STRLEN \
97 sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")
98
99static inline u32 cstamp_delta(unsigned long cstamp)
100{
101 return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
102}
103
104static inline s32 rfc3315_s14_backoff_init(s32 irt)
105{
106
107 u64 tmp = (900000 + prandom_u32() % 200001) * (u64)irt;
108 do_div(tmp, 1000000);
109 return (s32)tmp;
110}
111
112static inline s32 rfc3315_s14_backoff_update(s32 rt, s32 mrt)
113{
114
115 u64 tmp = (1900000 + prandom_u32() % 200001) * (u64)rt;
116 do_div(tmp, 1000000);
117 if ((s32)tmp > mrt) {
118
119 tmp = (900000 + prandom_u32() % 200001) * (u64)mrt;
120 do_div(tmp, 1000000);
121 }
122 return (s32)tmp;
123}
124
125#ifdef CONFIG_SYSCTL
126static int addrconf_sysctl_register(struct inet6_dev *idev);
127static void addrconf_sysctl_unregister(struct inet6_dev *idev);
128#else
129static inline int addrconf_sysctl_register(struct inet6_dev *idev)
130{
131 return 0;
132}
133
134static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
135{
136}
137#endif
138
139static void ipv6_gen_rnd_iid(struct in6_addr *addr);
140
141static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
142static int ipv6_count_addresses(const struct inet6_dev *idev);
143static int ipv6_generate_stable_address(struct in6_addr *addr,
144 u8 dad_count,
145 const struct inet6_dev *idev);
146
147#define IN6_ADDR_HSIZE_SHIFT 8
148#define IN6_ADDR_HSIZE (1 << IN6_ADDR_HSIZE_SHIFT)
149
150
151
152static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
153static DEFINE_SPINLOCK(addrconf_hash_lock);
154
155static void addrconf_verify(void);
156static void addrconf_verify_rtnl(void);
157static void addrconf_verify_work(struct work_struct *);
158
159static struct workqueue_struct *addrconf_wq;
160static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
161
162static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
163static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
164
165static void addrconf_type_change(struct net_device *dev,
166 unsigned long event);
167static int addrconf_ifdown(struct net_device *dev, bool unregister);
168
169static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
170 int plen,
171 const struct net_device *dev,
172 u32 flags, u32 noflags,
173 bool no_gw);
174
175static void addrconf_dad_start(struct inet6_ifaddr *ifp);
176static void addrconf_dad_work(struct work_struct *w);
177static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
178 bool send_na);
179static void addrconf_dad_run(struct inet6_dev *idev, bool restart);
180static void addrconf_rs_timer(struct timer_list *t);
181static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
182static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
183
184static void inet6_prefix_notify(int event, struct inet6_dev *idev,
185 struct prefix_info *pinfo);
186
187static struct ipv6_devconf ipv6_devconf __read_mostly = {
188 .forwarding = 0,
189 .hop_limit = IPV6_DEFAULT_HOPLIMIT,
190 .mtu6 = IPV6_MIN_MTU,
191 .accept_ra = 1,
192 .accept_redirects = 1,
193 .autoconf = 1,
194 .force_mld_version = 0,
195 .mldv1_unsolicited_report_interval = 10 * HZ,
196 .mldv2_unsolicited_report_interval = HZ,
197 .dad_transmits = 1,
198 .rtr_solicits = MAX_RTR_SOLICITATIONS,
199 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
200 .rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
201 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
202 .use_tempaddr = 0,
203 .temp_valid_lft = TEMP_VALID_LIFETIME,
204 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
205 .regen_max_retry = REGEN_MAX_RETRY,
206 .max_desync_factor = MAX_DESYNC_FACTOR,
207 .max_addresses = IPV6_MAX_ADDRESSES,
208 .accept_ra_defrtr = 1,
209 .ra_defrtr_metric = IP6_RT_PRIO_USER,
210 .accept_ra_from_local = 0,
211 .accept_ra_min_hop_limit= 1,
212 .accept_ra_pinfo = 1,
213#ifdef CONFIG_IPV6_ROUTER_PREF
214 .accept_ra_rtr_pref = 1,
215 .rtr_probe_interval = 60 * HZ,
216#ifdef CONFIG_IPV6_ROUTE_INFO
217 .accept_ra_rt_info_min_plen = 0,
218 .accept_ra_rt_info_max_plen = 0,
219#endif
220#endif
221 .proxy_ndp = 0,
222 .accept_source_route = 0,
223 .disable_ipv6 = 0,
224 .accept_dad = 0,
225 .suppress_frag_ndisc = 1,
226 .accept_ra_mtu = 1,
227 .stable_secret = {
228 .initialized = false,
229 },
230 .use_oif_addrs_only = 0,
231 .ignore_routes_with_linkdown = 0,
232 .keep_addr_on_down = 0,
233 .seg6_enabled = 0,
234#ifdef CONFIG_IPV6_SEG6_HMAC
235 .seg6_require_hmac = 0,
236#endif
237 .enhanced_dad = 1,
238 .addr_gen_mode = IN6_ADDR_GEN_MODE_EUI64,
239 .disable_policy = 0,
240 .rpl_seg_enabled = 0,
241 .ioam6_enabled = 0,
242 .ioam6_id = IOAM6_DEFAULT_IF_ID,
243 .ioam6_id_wide = IOAM6_DEFAULT_IF_ID_WIDE,
244};
245
246static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
247 .forwarding = 0,
248 .hop_limit = IPV6_DEFAULT_HOPLIMIT,
249 .mtu6 = IPV6_MIN_MTU,
250 .accept_ra = 1,
251 .accept_redirects = 1,
252 .autoconf = 1,
253 .force_mld_version = 0,
254 .mldv1_unsolicited_report_interval = 10 * HZ,
255 .mldv2_unsolicited_report_interval = HZ,
256 .dad_transmits = 1,
257 .rtr_solicits = MAX_RTR_SOLICITATIONS,
258 .rtr_solicit_interval = RTR_SOLICITATION_INTERVAL,
259 .rtr_solicit_max_interval = RTR_SOLICITATION_MAX_INTERVAL,
260 .rtr_solicit_delay = MAX_RTR_SOLICITATION_DELAY,
261 .use_tempaddr = 0,
262 .temp_valid_lft = TEMP_VALID_LIFETIME,
263 .temp_prefered_lft = TEMP_PREFERRED_LIFETIME,
264 .regen_max_retry = REGEN_MAX_RETRY,
265 .max_desync_factor = MAX_DESYNC_FACTOR,
266 .max_addresses = IPV6_MAX_ADDRESSES,
267 .accept_ra_defrtr = 1,
268 .ra_defrtr_metric = IP6_RT_PRIO_USER,
269 .accept_ra_from_local = 0,
270 .accept_ra_min_hop_limit= 1,
271 .accept_ra_pinfo = 1,
272#ifdef CONFIG_IPV6_ROUTER_PREF
273 .accept_ra_rtr_pref = 1,
274 .rtr_probe_interval = 60 * HZ,
275#ifdef CONFIG_IPV6_ROUTE_INFO
276 .accept_ra_rt_info_min_plen = 0,
277 .accept_ra_rt_info_max_plen = 0,
278#endif
279#endif
280 .proxy_ndp = 0,
281 .accept_source_route = 0,
282 .disable_ipv6 = 0,
283 .accept_dad = 1,
284 .suppress_frag_ndisc = 1,
285 .accept_ra_mtu = 1,
286 .stable_secret = {
287 .initialized = false,
288 },
289 .use_oif_addrs_only = 0,
290 .ignore_routes_with_linkdown = 0,
291 .keep_addr_on_down = 0,
292 .seg6_enabled = 0,
293#ifdef CONFIG_IPV6_SEG6_HMAC
294 .seg6_require_hmac = 0,
295#endif
296 .enhanced_dad = 1,
297 .addr_gen_mode = IN6_ADDR_GEN_MODE_EUI64,
298 .disable_policy = 0,
299 .rpl_seg_enabled = 0,
300 .ioam6_enabled = 0,
301 .ioam6_id = IOAM6_DEFAULT_IF_ID,
302 .ioam6_id_wide = IOAM6_DEFAULT_IF_ID_WIDE,
303};
304
305
306static inline bool addrconf_link_ready(const struct net_device *dev)
307{
308 return netif_oper_up(dev) && !qdisc_tx_is_noop(dev);
309}
310
311static void addrconf_del_rs_timer(struct inet6_dev *idev)
312{
313 if (del_timer(&idev->rs_timer))
314 __in6_dev_put(idev);
315}
316
317static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
318{
319 if (cancel_delayed_work(&ifp->dad_work))
320 __in6_ifa_put(ifp);
321}
322
323static void addrconf_mod_rs_timer(struct inet6_dev *idev,
324 unsigned long when)
325{
326 if (!timer_pending(&idev->rs_timer))
327 in6_dev_hold(idev);
328 mod_timer(&idev->rs_timer, jiffies + when);
329}
330
331static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
332 unsigned long delay)
333{
334 in6_ifa_hold(ifp);
335 if (mod_delayed_work(addrconf_wq, &ifp->dad_work, delay))
336 in6_ifa_put(ifp);
337}
338
339static int snmp6_alloc_dev(struct inet6_dev *idev)
340{
341 int i;
342
343 idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
344 if (!idev->stats.ipv6)
345 goto err_ip;
346
347 for_each_possible_cpu(i) {
348 struct ipstats_mib *addrconf_stats;
349 addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
350 u64_stats_init(&addrconf_stats->syncp);
351 }
352
353
354 idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
355 GFP_KERNEL);
356 if (!idev->stats.icmpv6dev)
357 goto err_icmp;
358 idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
359 GFP_KERNEL);
360 if (!idev->stats.icmpv6msgdev)
361 goto err_icmpmsg;
362
363 return 0;
364
365err_icmpmsg:
366 kfree(idev->stats.icmpv6dev);
367err_icmp:
368 free_percpu(idev->stats.ipv6);
369err_ip:
370 return -ENOMEM;
371}
372
373static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
374{
375 struct inet6_dev *ndev;
376 int err = -ENOMEM;
377
378 ASSERT_RTNL();
379
380 if (dev->mtu < IPV6_MIN_MTU)
381 return ERR_PTR(-EINVAL);
382
383 ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
384 if (!ndev)
385 return ERR_PTR(err);
386
387 rwlock_init(&ndev->lock);
388 ndev->dev = dev;
389 INIT_LIST_HEAD(&ndev->addr_list);
390 timer_setup(&ndev->rs_timer, addrconf_rs_timer, 0);
391 memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
392
393 if (ndev->cnf.stable_secret.initialized)
394 ndev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
395
396 ndev->cnf.mtu6 = dev->mtu;
397 ndev->ra_mtu = 0;
398 ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
399 if (!ndev->nd_parms) {
400 kfree(ndev);
401 return ERR_PTR(err);
402 }
403 if (ndev->cnf.forwarding)
404 dev_disable_lro(dev);
405
406 dev_hold(dev);
407
408 if (snmp6_alloc_dev(ndev) < 0) {
409 netdev_dbg(dev, "%s: cannot allocate memory for statistics\n",
410 __func__);
411 neigh_parms_release(&nd_tbl, ndev->nd_parms);
412 dev_put(dev);
413 kfree(ndev);
414 return ERR_PTR(err);
415 }
416
417 if (snmp6_register_dev(ndev) < 0) {
418 netdev_dbg(dev, "%s: cannot create /proc/net/dev_snmp6/%s\n",
419 __func__, dev->name);
420 goto err_release;
421 }
422
423
424 refcount_set(&ndev->refcnt, 1);
425
426 if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
427 ndev->cnf.accept_dad = -1;
428
429#if IS_ENABLED(CONFIG_IPV6_SIT)
430 if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
431 pr_info("%s: Disabled Multicast RS\n", dev->name);
432 ndev->cnf.rtr_solicits = 0;
433 }
434#endif
435
436 INIT_LIST_HEAD(&ndev->tempaddr_list);
437 ndev->desync_factor = U32_MAX;
438 if ((dev->flags&IFF_LOOPBACK) ||
439 dev->type == ARPHRD_TUNNEL ||
440 dev->type == ARPHRD_TUNNEL6 ||
441 dev->type == ARPHRD_SIT ||
442 dev->type == ARPHRD_NONE) {
443 ndev->cnf.use_tempaddr = -1;
444 }
445
446 ndev->token = in6addr_any;
447
448 if (netif_running(dev) && addrconf_link_ready(dev))
449 ndev->if_flags |= IF_READY;
450
451 ipv6_mc_init_dev(ndev);
452 ndev->tstamp = jiffies;
453 err = addrconf_sysctl_register(ndev);
454 if (err) {
455 ipv6_mc_destroy_dev(ndev);
456 snmp6_unregister_dev(ndev);
457 goto err_release;
458 }
459
460 rcu_assign_pointer(dev->ip6_ptr, ndev);
461
462
463 ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
464
465
466 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
467
468
469 if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
470 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
471
472 return ndev;
473
474err_release:
475 neigh_parms_release(&nd_tbl, ndev->nd_parms);
476 ndev->dead = 1;
477 in6_dev_finish_destroy(ndev);
478 return ERR_PTR(err);
479}
480
481static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
482{
483 struct inet6_dev *idev;
484
485 ASSERT_RTNL();
486
487 idev = __in6_dev_get(dev);
488 if (!idev) {
489 idev = ipv6_add_dev(dev);
490 if (IS_ERR(idev))
491 return idev;
492 }
493
494 if (dev->flags&IFF_UP)
495 ipv6_mc_up(idev);
496 return idev;
497}
498
499static int inet6_netconf_msgsize_devconf(int type)
500{
501 int size = NLMSG_ALIGN(sizeof(struct netconfmsg))
502 + nla_total_size(4);
503 bool all = false;
504
505 if (type == NETCONFA_ALL)
506 all = true;
507
508 if (all || type == NETCONFA_FORWARDING)
509 size += nla_total_size(4);
510#ifdef CONFIG_IPV6_MROUTE
511 if (all || type == NETCONFA_MC_FORWARDING)
512 size += nla_total_size(4);
513#endif
514 if (all || type == NETCONFA_PROXY_NEIGH)
515 size += nla_total_size(4);
516
517 if (all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN)
518 size += nla_total_size(4);
519
520 return size;
521}
522
523static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
524 struct ipv6_devconf *devconf, u32 portid,
525 u32 seq, int event, unsigned int flags,
526 int type)
527{
528 struct nlmsghdr *nlh;
529 struct netconfmsg *ncm;
530 bool all = false;
531
532 nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
533 flags);
534 if (!nlh)
535 return -EMSGSIZE;
536
537 if (type == NETCONFA_ALL)
538 all = true;
539
540 ncm = nlmsg_data(nlh);
541 ncm->ncm_family = AF_INET6;
542
543 if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
544 goto nla_put_failure;
545
546 if (!devconf)
547 goto out;
548
549 if ((all || type == NETCONFA_FORWARDING) &&
550 nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
551 goto nla_put_failure;
552#ifdef CONFIG_IPV6_MROUTE
553 if ((all || type == NETCONFA_MC_FORWARDING) &&
554 nla_put_s32(skb, NETCONFA_MC_FORWARDING,
555 devconf->mc_forwarding) < 0)
556 goto nla_put_failure;
557#endif
558 if ((all || type == NETCONFA_PROXY_NEIGH) &&
559 nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
560 goto nla_put_failure;
561
562 if ((all || type == NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN) &&
563 nla_put_s32(skb, NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
564 devconf->ignore_routes_with_linkdown) < 0)
565 goto nla_put_failure;
566
567out:
568 nlmsg_end(skb, nlh);
569 return 0;
570
571nla_put_failure:
572 nlmsg_cancel(skb, nlh);
573 return -EMSGSIZE;
574}
575
576void inet6_netconf_notify_devconf(struct net *net, int event, int type,
577 int ifindex, struct ipv6_devconf *devconf)
578{
579 struct sk_buff *skb;
580 int err = -ENOBUFS;
581
582 skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_KERNEL);
583 if (!skb)
584 goto errout;
585
586 err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
587 event, 0, type);
588 if (err < 0) {
589
590 WARN_ON(err == -EMSGSIZE);
591 kfree_skb(skb);
592 goto errout;
593 }
594 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_KERNEL);
595 return;
596errout:
597 rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
598}
599
600static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
601 [NETCONFA_IFINDEX] = { .len = sizeof(int) },
602 [NETCONFA_FORWARDING] = { .len = sizeof(int) },
603 [NETCONFA_PROXY_NEIGH] = { .len = sizeof(int) },
604 [NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN] = { .len = sizeof(int) },
605};
606
607static int inet6_netconf_valid_get_req(struct sk_buff *skb,
608 const struct nlmsghdr *nlh,
609 struct nlattr **tb,
610 struct netlink_ext_ack *extack)
611{
612 int i, err;
613
614 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(struct netconfmsg))) {
615 NL_SET_ERR_MSG_MOD(extack, "Invalid header for netconf get request");
616 return -EINVAL;
617 }
618
619 if (!netlink_strict_get_check(skb))
620 return nlmsg_parse_deprecated(nlh, sizeof(struct netconfmsg),
621 tb, NETCONFA_MAX,
622 devconf_ipv6_policy, extack);
623
624 err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct netconfmsg),
625 tb, NETCONFA_MAX,
626 devconf_ipv6_policy, extack);
627 if (err)
628 return err;
629
630 for (i = 0; i <= NETCONFA_MAX; i++) {
631 if (!tb[i])
632 continue;
633
634 switch (i) {
635 case NETCONFA_IFINDEX:
636 break;
637 default:
638 NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in netconf get request");
639 return -EINVAL;
640 }
641 }
642
643 return 0;
644}
645
646static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
647 struct nlmsghdr *nlh,
648 struct netlink_ext_ack *extack)
649{
650 struct net *net = sock_net(in_skb->sk);
651 struct nlattr *tb[NETCONFA_MAX+1];
652 struct inet6_dev *in6_dev = NULL;
653 struct net_device *dev = NULL;
654 struct sk_buff *skb;
655 struct ipv6_devconf *devconf;
656 int ifindex;
657 int err;
658
659 err = inet6_netconf_valid_get_req(in_skb, nlh, tb, extack);
660 if (err < 0)
661 return err;
662
663 if (!tb[NETCONFA_IFINDEX])
664 return -EINVAL;
665
666 err = -EINVAL;
667 ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
668 switch (ifindex) {
669 case NETCONFA_IFINDEX_ALL:
670 devconf = net->ipv6.devconf_all;
671 break;
672 case NETCONFA_IFINDEX_DEFAULT:
673 devconf = net->ipv6.devconf_dflt;
674 break;
675 default:
676 dev = dev_get_by_index(net, ifindex);
677 if (!dev)
678 return -EINVAL;
679 in6_dev = in6_dev_get(dev);
680 if (!in6_dev)
681 goto errout;
682 devconf = &in6_dev->cnf;
683 break;
684 }
685
686 err = -ENOBUFS;
687 skb = nlmsg_new(inet6_netconf_msgsize_devconf(NETCONFA_ALL), GFP_KERNEL);
688 if (!skb)
689 goto errout;
690
691 err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
692 NETLINK_CB(in_skb).portid,
693 nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
694 NETCONFA_ALL);
695 if (err < 0) {
696
697 WARN_ON(err == -EMSGSIZE);
698 kfree_skb(skb);
699 goto errout;
700 }
701 err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
702errout:
703 if (in6_dev)
704 in6_dev_put(in6_dev);
705 dev_put(dev);
706 return err;
707}
708
709static int inet6_netconf_dump_devconf(struct sk_buff *skb,
710 struct netlink_callback *cb)
711{
712 const struct nlmsghdr *nlh = cb->nlh;
713 struct net *net = sock_net(skb->sk);
714 int h, s_h;
715 int idx, s_idx;
716 struct net_device *dev;
717 struct inet6_dev *idev;
718 struct hlist_head *head;
719
720 if (cb->strict_check) {
721 struct netlink_ext_ack *extack = cb->extack;
722 struct netconfmsg *ncm;
723
724 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ncm))) {
725 NL_SET_ERR_MSG_MOD(extack, "Invalid header for netconf dump request");
726 return -EINVAL;
727 }
728
729 if (nlmsg_attrlen(nlh, sizeof(*ncm))) {
730 NL_SET_ERR_MSG_MOD(extack, "Invalid data after header in netconf dump request");
731 return -EINVAL;
732 }
733 }
734
735 s_h = cb->args[0];
736 s_idx = idx = cb->args[1];
737
738 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
739 idx = 0;
740 head = &net->dev_index_head[h];
741 rcu_read_lock();
742 cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
743 net->dev_base_seq;
744 hlist_for_each_entry_rcu(dev, head, index_hlist) {
745 if (idx < s_idx)
746 goto cont;
747 idev = __in6_dev_get(dev);
748 if (!idev)
749 goto cont;
750
751 if (inet6_netconf_fill_devconf(skb, dev->ifindex,
752 &idev->cnf,
753 NETLINK_CB(cb->skb).portid,
754 nlh->nlmsg_seq,
755 RTM_NEWNETCONF,
756 NLM_F_MULTI,
757 NETCONFA_ALL) < 0) {
758 rcu_read_unlock();
759 goto done;
760 }
761 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
762cont:
763 idx++;
764 }
765 rcu_read_unlock();
766 }
767 if (h == NETDEV_HASHENTRIES) {
768 if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
769 net->ipv6.devconf_all,
770 NETLINK_CB(cb->skb).portid,
771 nlh->nlmsg_seq,
772 RTM_NEWNETCONF, NLM_F_MULTI,
773 NETCONFA_ALL) < 0)
774 goto done;
775 else
776 h++;
777 }
778 if (h == NETDEV_HASHENTRIES + 1) {
779 if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
780 net->ipv6.devconf_dflt,
781 NETLINK_CB(cb->skb).portid,
782 nlh->nlmsg_seq,
783 RTM_NEWNETCONF, NLM_F_MULTI,
784 NETCONFA_ALL) < 0)
785 goto done;
786 else
787 h++;
788 }
789done:
790 cb->args[0] = h;
791 cb->args[1] = idx;
792
793 return skb->len;
794}
795
796#ifdef CONFIG_SYSCTL
797static void dev_forward_change(struct inet6_dev *idev)
798{
799 struct net_device *dev;
800 struct inet6_ifaddr *ifa;
801
802 if (!idev)
803 return;
804 dev = idev->dev;
805 if (idev->cnf.forwarding)
806 dev_disable_lro(dev);
807 if (dev->flags & IFF_MULTICAST) {
808 if (idev->cnf.forwarding) {
809 ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
810 ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
811 ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
812 } else {
813 ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
814 ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
815 ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
816 }
817 }
818
819 list_for_each_entry(ifa, &idev->addr_list, if_list) {
820 if (ifa->flags&IFA_F_TENTATIVE)
821 continue;
822 if (idev->cnf.forwarding)
823 addrconf_join_anycast(ifa);
824 else
825 addrconf_leave_anycast(ifa);
826 }
827 inet6_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
828 NETCONFA_FORWARDING,
829 dev->ifindex, &idev->cnf);
830}
831
832
833static void addrconf_forward_change(struct net *net, __s32 newf)
834{
835 struct net_device *dev;
836 struct inet6_dev *idev;
837
838 for_each_netdev(net, dev) {
839 idev = __in6_dev_get(dev);
840 if (idev) {
841 int changed = (!idev->cnf.forwarding) ^ (!newf);
842 idev->cnf.forwarding = newf;
843 if (changed)
844 dev_forward_change(idev);
845 }
846 }
847}
848
849static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
850{
851 struct net *net;
852 int old;
853
854 if (!rtnl_trylock())
855 return restart_syscall();
856
857 net = (struct net *)table->extra2;
858 old = *p;
859 *p = newf;
860
861 if (p == &net->ipv6.devconf_dflt->forwarding) {
862 if ((!newf) ^ (!old))
863 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
864 NETCONFA_FORWARDING,
865 NETCONFA_IFINDEX_DEFAULT,
866 net->ipv6.devconf_dflt);
867 rtnl_unlock();
868 return 0;
869 }
870
871 if (p == &net->ipv6.devconf_all->forwarding) {
872 int old_dflt = net->ipv6.devconf_dflt->forwarding;
873
874 net->ipv6.devconf_dflt->forwarding = newf;
875 if ((!newf) ^ (!old_dflt))
876 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
877 NETCONFA_FORWARDING,
878 NETCONFA_IFINDEX_DEFAULT,
879 net->ipv6.devconf_dflt);
880
881 addrconf_forward_change(net, newf);
882 if ((!newf) ^ (!old))
883 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
884 NETCONFA_FORWARDING,
885 NETCONFA_IFINDEX_ALL,
886 net->ipv6.devconf_all);
887 } else if ((!newf) ^ (!old))
888 dev_forward_change((struct inet6_dev *)table->extra1);
889 rtnl_unlock();
890
891 if (newf)
892 rt6_purge_dflt_routers(net);
893 return 1;
894}
895
896static void addrconf_linkdown_change(struct net *net, __s32 newf)
897{
898 struct net_device *dev;
899 struct inet6_dev *idev;
900
901 for_each_netdev(net, dev) {
902 idev = __in6_dev_get(dev);
903 if (idev) {
904 int changed = (!idev->cnf.ignore_routes_with_linkdown) ^ (!newf);
905
906 idev->cnf.ignore_routes_with_linkdown = newf;
907 if (changed)
908 inet6_netconf_notify_devconf(dev_net(dev),
909 RTM_NEWNETCONF,
910 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
911 dev->ifindex,
912 &idev->cnf);
913 }
914 }
915}
916
917static int addrconf_fixup_linkdown(struct ctl_table *table, int *p, int newf)
918{
919 struct net *net;
920 int old;
921
922 if (!rtnl_trylock())
923 return restart_syscall();
924
925 net = (struct net *)table->extra2;
926 old = *p;
927 *p = newf;
928
929 if (p == &net->ipv6.devconf_dflt->ignore_routes_with_linkdown) {
930 if ((!newf) ^ (!old))
931 inet6_netconf_notify_devconf(net,
932 RTM_NEWNETCONF,
933 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
934 NETCONFA_IFINDEX_DEFAULT,
935 net->ipv6.devconf_dflt);
936 rtnl_unlock();
937 return 0;
938 }
939
940 if (p == &net->ipv6.devconf_all->ignore_routes_with_linkdown) {
941 net->ipv6.devconf_dflt->ignore_routes_with_linkdown = newf;
942 addrconf_linkdown_change(net, newf);
943 if ((!newf) ^ (!old))
944 inet6_netconf_notify_devconf(net,
945 RTM_NEWNETCONF,
946 NETCONFA_IGNORE_ROUTES_WITH_LINKDOWN,
947 NETCONFA_IFINDEX_ALL,
948 net->ipv6.devconf_all);
949 }
950 rtnl_unlock();
951
952 return 1;
953}
954
955#endif
956
957
958void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
959{
960 WARN_ON(!hlist_unhashed(&ifp->addr_lst));
961
962#ifdef NET_REFCNT_DEBUG
963 pr_debug("%s\n", __func__);
964#endif
965
966 in6_dev_put(ifp->idev);
967
968 if (cancel_delayed_work(&ifp->dad_work))
969 pr_notice("delayed DAD work was pending while freeing ifa=%p\n",
970 ifp);
971
972 if (ifp->state != INET6_IFADDR_STATE_DEAD) {
973 pr_warn("Freeing alive inet6 address %p\n", ifp);
974 return;
975 }
976
977 kfree_rcu(ifp, rcu);
978}
979
980static void
981ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
982{
983 struct list_head *p;
984 int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
985
986
987
988
989
990 list_for_each(p, &idev->addr_list) {
991 struct inet6_ifaddr *ifa
992 = list_entry(p, struct inet6_ifaddr, if_list);
993 if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
994 break;
995 }
996
997 list_add_tail_rcu(&ifp->if_list, p);
998}
999
1000static u32 inet6_addr_hash(const struct net *net, const struct in6_addr *addr)
1001{
1002 u32 val = ipv6_addr_hash(addr) ^ net_hash_mix(net);
1003
1004 return hash_32(val, IN6_ADDR_HSIZE_SHIFT);
1005}
1006
1007static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
1008 struct net_device *dev, unsigned int hash)
1009{
1010 struct inet6_ifaddr *ifp;
1011
1012 hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
1013 if (!net_eq(dev_net(ifp->idev->dev), net))
1014 continue;
1015 if (ipv6_addr_equal(&ifp->addr, addr)) {
1016 if (!dev || ifp->idev->dev == dev)
1017 return true;
1018 }
1019 }
1020 return false;
1021}
1022
1023static int ipv6_add_addr_hash(struct net_device *dev, struct inet6_ifaddr *ifa)
1024{
1025 unsigned int hash = inet6_addr_hash(dev_net(dev), &ifa->addr);
1026 int err = 0;
1027
1028 spin_lock(&addrconf_hash_lock);
1029
1030
1031 if (ipv6_chk_same_addr(dev_net(dev), &ifa->addr, dev, hash)) {
1032 netdev_dbg(dev, "ipv6_add_addr: already assigned\n");
1033 err = -EEXIST;
1034 } else {
1035 hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
1036 }
1037
1038 spin_unlock(&addrconf_hash_lock);
1039
1040 return err;
1041}
1042
1043
1044
1045static struct inet6_ifaddr *
1046ipv6_add_addr(struct inet6_dev *idev, struct ifa6_config *cfg,
1047 bool can_block, struct netlink_ext_ack *extack)
1048{
1049 gfp_t gfp_flags = can_block ? GFP_KERNEL : GFP_ATOMIC;
1050 int addr_type = ipv6_addr_type(cfg->pfx);
1051 struct net *net = dev_net(idev->dev);
1052 struct inet6_ifaddr *ifa = NULL;
1053 struct fib6_info *f6i = NULL;
1054 int err = 0;
1055
1056 if (addr_type == IPV6_ADDR_ANY ||
1057 (addr_type & IPV6_ADDR_MULTICAST &&
1058 !(cfg->ifa_flags & IFA_F_MCAUTOJOIN)) ||
1059 (!(idev->dev->flags & IFF_LOOPBACK) &&
1060 !netif_is_l3_master(idev->dev) &&
1061 addr_type & IPV6_ADDR_LOOPBACK))
1062 return ERR_PTR(-EADDRNOTAVAIL);
1063
1064 if (idev->dead) {
1065 err = -ENODEV;
1066 goto out;
1067 }
1068
1069 if (idev->cnf.disable_ipv6) {
1070 err = -EACCES;
1071 goto out;
1072 }
1073
1074
1075
1076
1077 if (can_block) {
1078 struct in6_validator_info i6vi = {
1079 .i6vi_addr = *cfg->pfx,
1080 .i6vi_dev = idev,
1081 .extack = extack,
1082 };
1083
1084 err = inet6addr_validator_notifier_call_chain(NETDEV_UP, &i6vi);
1085 err = notifier_to_errno(err);
1086 if (err < 0)
1087 goto out;
1088 }
1089
1090 ifa = kzalloc(sizeof(*ifa), gfp_flags | __GFP_ACCOUNT);
1091 if (!ifa) {
1092 err = -ENOBUFS;
1093 goto out;
1094 }
1095
1096 f6i = addrconf_f6i_alloc(net, idev, cfg->pfx, false, gfp_flags);
1097 if (IS_ERR(f6i)) {
1098 err = PTR_ERR(f6i);
1099 f6i = NULL;
1100 goto out;
1101 }
1102
1103 if (net->ipv6.devconf_all->disable_policy ||
1104 idev->cnf.disable_policy)
1105 f6i->dst_nopolicy = true;
1106
1107 neigh_parms_data_state_setall(idev->nd_parms);
1108
1109 ifa->addr = *cfg->pfx;
1110 if (cfg->peer_pfx)
1111 ifa->peer_addr = *cfg->peer_pfx;
1112
1113 spin_lock_init(&ifa->lock);
1114 INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
1115 INIT_HLIST_NODE(&ifa->addr_lst);
1116 ifa->scope = cfg->scope;
1117 ifa->prefix_len = cfg->plen;
1118 ifa->rt_priority = cfg->rt_priority;
1119 ifa->flags = cfg->ifa_flags;
1120
1121 if (!(cfg->ifa_flags & IFA_F_NODAD))
1122 ifa->flags |= IFA_F_TENTATIVE;
1123 ifa->valid_lft = cfg->valid_lft;
1124 ifa->prefered_lft = cfg->preferred_lft;
1125 ifa->cstamp = ifa->tstamp = jiffies;
1126 ifa->tokenized = false;
1127
1128 ifa->rt = f6i;
1129
1130 ifa->idev = idev;
1131 in6_dev_hold(idev);
1132
1133
1134 refcount_set(&ifa->refcnt, 1);
1135
1136 rcu_read_lock_bh();
1137
1138 err = ipv6_add_addr_hash(idev->dev, ifa);
1139 if (err < 0) {
1140 rcu_read_unlock_bh();
1141 goto out;
1142 }
1143
1144 write_lock(&idev->lock);
1145
1146
1147 ipv6_link_dev_addr(idev, ifa);
1148
1149 if (ifa->flags&IFA_F_TEMPORARY) {
1150 list_add(&ifa->tmp_list, &idev->tempaddr_list);
1151 in6_ifa_hold(ifa);
1152 }
1153
1154 in6_ifa_hold(ifa);
1155 write_unlock(&idev->lock);
1156
1157 rcu_read_unlock_bh();
1158
1159 inet6addr_notifier_call_chain(NETDEV_UP, ifa);
1160out:
1161 if (unlikely(err < 0)) {
1162 fib6_info_release(f6i);
1163
1164 if (ifa) {
1165 if (ifa->idev)
1166 in6_dev_put(ifa->idev);
1167 kfree(ifa);
1168 }
1169 ifa = ERR_PTR(err);
1170 }
1171
1172 return ifa;
1173}
1174
1175enum cleanup_prefix_rt_t {
1176 CLEANUP_PREFIX_RT_NOP,
1177 CLEANUP_PREFIX_RT_DEL,
1178 CLEANUP_PREFIX_RT_EXPIRE,
1179};
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199static enum cleanup_prefix_rt_t
1200check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires)
1201{
1202 struct inet6_ifaddr *ifa;
1203 struct inet6_dev *idev = ifp->idev;
1204 unsigned long lifetime;
1205 enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL;
1206
1207 *expires = jiffies;
1208
1209 list_for_each_entry(ifa, &idev->addr_list, if_list) {
1210 if (ifa == ifp)
1211 continue;
1212 if (ifa->prefix_len != ifp->prefix_len ||
1213 !ipv6_prefix_equal(&ifa->addr, &ifp->addr,
1214 ifp->prefix_len))
1215 continue;
1216 if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE))
1217 return CLEANUP_PREFIX_RT_NOP;
1218
1219 action = CLEANUP_PREFIX_RT_EXPIRE;
1220
1221 spin_lock(&ifa->lock);
1222
1223 lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
1224
1225
1226
1227
1228
1229 if (time_before(*expires, ifa->tstamp + lifetime * HZ))
1230 *expires = ifa->tstamp + lifetime * HZ;
1231 spin_unlock(&ifa->lock);
1232 }
1233
1234 return action;
1235}
1236
1237static void
1238cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires,
1239 bool del_rt, bool del_peer)
1240{
1241 struct fib6_info *f6i;
1242
1243 f6i = addrconf_get_prefix_route(del_peer ? &ifp->peer_addr : &ifp->addr,
1244 ifp->prefix_len,
1245 ifp->idev->dev, 0, RTF_DEFAULT, true);
1246 if (f6i) {
1247 if (del_rt)
1248 ip6_del_rt(dev_net(ifp->idev->dev), f6i, false);
1249 else {
1250 if (!(f6i->fib6_flags & RTF_EXPIRES))
1251 fib6_set_expires(f6i, expires);
1252 fib6_info_release(f6i);
1253 }
1254 }
1255}
1256
1257
1258
1259
1260static void ipv6_del_addr(struct inet6_ifaddr *ifp)
1261{
1262 int state;
1263 enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
1264 unsigned long expires;
1265
1266 ASSERT_RTNL();
1267
1268 spin_lock_bh(&ifp->lock);
1269 state = ifp->state;
1270 ifp->state = INET6_IFADDR_STATE_DEAD;
1271 spin_unlock_bh(&ifp->lock);
1272
1273 if (state == INET6_IFADDR_STATE_DEAD)
1274 goto out;
1275
1276 spin_lock_bh(&addrconf_hash_lock);
1277 hlist_del_init_rcu(&ifp->addr_lst);
1278 spin_unlock_bh(&addrconf_hash_lock);
1279
1280 write_lock_bh(&ifp->idev->lock);
1281
1282 if (ifp->flags&IFA_F_TEMPORARY) {
1283 list_del(&ifp->tmp_list);
1284 if (ifp->ifpub) {
1285 in6_ifa_put(ifp->ifpub);
1286 ifp->ifpub = NULL;
1287 }
1288 __in6_ifa_put(ifp);
1289 }
1290
1291 if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
1292 action = check_cleanup_prefix_route(ifp, &expires);
1293
1294 list_del_rcu(&ifp->if_list);
1295 __in6_ifa_put(ifp);
1296
1297 write_unlock_bh(&ifp->idev->lock);
1298
1299 addrconf_del_dad_work(ifp);
1300
1301 ipv6_ifa_notify(RTM_DELADDR, ifp);
1302
1303 inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
1304
1305 if (action != CLEANUP_PREFIX_RT_NOP) {
1306 cleanup_prefix_route(ifp, expires,
1307 action == CLEANUP_PREFIX_RT_DEL, false);
1308 }
1309
1310
1311 rt6_remove_prefsrc(ifp);
1312out:
1313 in6_ifa_put(ifp);
1314}
1315
1316static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, bool block)
1317{
1318 struct inet6_dev *idev = ifp->idev;
1319 unsigned long tmp_tstamp, age;
1320 unsigned long regen_advance;
1321 unsigned long now = jiffies;
1322 s32 cnf_temp_preferred_lft;
1323 struct inet6_ifaddr *ift;
1324 struct ifa6_config cfg;
1325 long max_desync_factor;
1326 struct in6_addr addr;
1327 int ret = 0;
1328
1329 write_lock_bh(&idev->lock);
1330
1331retry:
1332 in6_dev_hold(idev);
1333 if (idev->cnf.use_tempaddr <= 0) {
1334 write_unlock_bh(&idev->lock);
1335 pr_info("%s: use_tempaddr is disabled\n", __func__);
1336 in6_dev_put(idev);
1337 ret = -1;
1338 goto out;
1339 }
1340 spin_lock_bh(&ifp->lock);
1341 if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
1342 idev->cnf.use_tempaddr = -1;
1343 spin_unlock_bh(&ifp->lock);
1344 write_unlock_bh(&idev->lock);
1345 pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
1346 __func__);
1347 in6_dev_put(idev);
1348 ret = -1;
1349 goto out;
1350 }
1351 in6_ifa_hold(ifp);
1352 memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
1353 ipv6_gen_rnd_iid(&addr);
1354
1355 age = (now - ifp->tstamp) / HZ;
1356
1357 regen_advance = idev->cnf.regen_max_retry *
1358 idev->cnf.dad_transmits *
1359 max(NEIGH_VAR(idev->nd_parms, RETRANS_TIME), HZ/100) / HZ;
1360
1361
1362
1363
1364 cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft);
1365 max_desync_factor = min_t(__u32,
1366 idev->cnf.max_desync_factor,
1367 cnf_temp_preferred_lft - regen_advance);
1368
1369 if (unlikely(idev->desync_factor > max_desync_factor)) {
1370 if (max_desync_factor > 0) {
1371 get_random_bytes(&idev->desync_factor,
1372 sizeof(idev->desync_factor));
1373 idev->desync_factor %= max_desync_factor;
1374 } else {
1375 idev->desync_factor = 0;
1376 }
1377 }
1378
1379 memset(&cfg, 0, sizeof(cfg));
1380 cfg.valid_lft = min_t(__u32, ifp->valid_lft,
1381 idev->cnf.temp_valid_lft + age);
1382 cfg.preferred_lft = cnf_temp_preferred_lft + age - idev->desync_factor;
1383 cfg.preferred_lft = min_t(__u32, ifp->prefered_lft, cfg.preferred_lft);
1384
1385 cfg.plen = ifp->prefix_len;
1386 tmp_tstamp = ifp->tstamp;
1387 spin_unlock_bh(&ifp->lock);
1388
1389 write_unlock_bh(&idev->lock);
1390
1391
1392
1393
1394
1395
1396
1397
1398 age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
1399 if (cfg.preferred_lft <= regen_advance + age) {
1400 in6_ifa_put(ifp);
1401 in6_dev_put(idev);
1402 ret = -1;
1403 goto out;
1404 }
1405
1406 cfg.ifa_flags = IFA_F_TEMPORARY;
1407
1408 if (ifp->flags & IFA_F_OPTIMISTIC)
1409 cfg.ifa_flags |= IFA_F_OPTIMISTIC;
1410
1411 cfg.pfx = &addr;
1412 cfg.scope = ipv6_addr_scope(cfg.pfx);
1413
1414 ift = ipv6_add_addr(idev, &cfg, block, NULL);
1415 if (IS_ERR(ift)) {
1416 in6_ifa_put(ifp);
1417 in6_dev_put(idev);
1418 pr_info("%s: retry temporary address regeneration\n", __func__);
1419 write_lock_bh(&idev->lock);
1420 goto retry;
1421 }
1422
1423 spin_lock_bh(&ift->lock);
1424 ift->ifpub = ifp;
1425 ift->cstamp = now;
1426 ift->tstamp = tmp_tstamp;
1427 spin_unlock_bh(&ift->lock);
1428
1429 addrconf_dad_start(ift);
1430 in6_ifa_put(ift);
1431 in6_dev_put(idev);
1432out:
1433 return ret;
1434}
1435
1436
1437
1438
1439enum {
1440 IPV6_SADDR_RULE_INIT = 0,
1441 IPV6_SADDR_RULE_LOCAL,
1442 IPV6_SADDR_RULE_SCOPE,
1443 IPV6_SADDR_RULE_PREFERRED,
1444#ifdef CONFIG_IPV6_MIP6
1445 IPV6_SADDR_RULE_HOA,
1446#endif
1447 IPV6_SADDR_RULE_OIF,
1448 IPV6_SADDR_RULE_LABEL,
1449 IPV6_SADDR_RULE_PRIVACY,
1450 IPV6_SADDR_RULE_ORCHID,
1451 IPV6_SADDR_RULE_PREFIX,
1452#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1453 IPV6_SADDR_RULE_NOT_OPTIMISTIC,
1454#endif
1455 IPV6_SADDR_RULE_MAX
1456};
1457
1458struct ipv6_saddr_score {
1459 int rule;
1460 int addr_type;
1461 struct inet6_ifaddr *ifa;
1462 DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
1463 int scopedist;
1464 int matchlen;
1465};
1466
1467struct ipv6_saddr_dst {
1468 const struct in6_addr *addr;
1469 int ifindex;
1470 int scope;
1471 int label;
1472 unsigned int prefs;
1473};
1474
1475static inline int ipv6_saddr_preferred(int type)
1476{
1477 if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1478 return 1;
1479 return 0;
1480}
1481
1482static bool ipv6_use_optimistic_addr(struct net *net,
1483 struct inet6_dev *idev)
1484{
1485#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1486 if (!idev)
1487 return false;
1488 if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
1489 return false;
1490 if (!net->ipv6.devconf_all->use_optimistic && !idev->cnf.use_optimistic)
1491 return false;
1492
1493 return true;
1494#else
1495 return false;
1496#endif
1497}
1498
1499static bool ipv6_allow_optimistic_dad(struct net *net,
1500 struct inet6_dev *idev)
1501{
1502#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1503 if (!idev)
1504 return false;
1505 if (!net->ipv6.devconf_all->optimistic_dad && !idev->cnf.optimistic_dad)
1506 return false;
1507
1508 return true;
1509#else
1510 return false;
1511#endif
1512}
1513
1514static int ipv6_get_saddr_eval(struct net *net,
1515 struct ipv6_saddr_score *score,
1516 struct ipv6_saddr_dst *dst,
1517 int i)
1518{
1519 int ret;
1520
1521 if (i <= score->rule) {
1522 switch (i) {
1523 case IPV6_SADDR_RULE_SCOPE:
1524 ret = score->scopedist;
1525 break;
1526 case IPV6_SADDR_RULE_PREFIX:
1527 ret = score->matchlen;
1528 break;
1529 default:
1530 ret = !!test_bit(i, score->scorebits);
1531 }
1532 goto out;
1533 }
1534
1535 switch (i) {
1536 case IPV6_SADDR_RULE_INIT:
1537
1538 ret = !!score->ifa;
1539 break;
1540 case IPV6_SADDR_RULE_LOCAL:
1541
1542 ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
1543 break;
1544 case IPV6_SADDR_RULE_SCOPE:
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566 ret = __ipv6_addr_src_scope(score->addr_type);
1567 if (ret >= dst->scope)
1568 ret = -ret;
1569 else
1570 ret -= 128;
1571 score->scopedist = ret;
1572 break;
1573 case IPV6_SADDR_RULE_PREFERRED:
1574 {
1575
1576 u8 avoid = IFA_F_DEPRECATED;
1577
1578 if (!ipv6_use_optimistic_addr(net, score->ifa->idev))
1579 avoid |= IFA_F_OPTIMISTIC;
1580 ret = ipv6_saddr_preferred(score->addr_type) ||
1581 !(score->ifa->flags & avoid);
1582 break;
1583 }
1584#ifdef CONFIG_IPV6_MIP6
1585 case IPV6_SADDR_RULE_HOA:
1586 {
1587
1588 int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
1589 ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1590 break;
1591 }
1592#endif
1593 case IPV6_SADDR_RULE_OIF:
1594
1595 ret = (!dst->ifindex ||
1596 dst->ifindex == score->ifa->idev->dev->ifindex);
1597 break;
1598 case IPV6_SADDR_RULE_LABEL:
1599
1600 ret = ipv6_addr_label(net,
1601 &score->ifa->addr, score->addr_type,
1602 score->ifa->idev->dev->ifindex) == dst->label;
1603 break;
1604 case IPV6_SADDR_RULE_PRIVACY:
1605 {
1606
1607
1608
1609 int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
1610 !!(dst->prefs & IPV6_PREFER_SRC_TMP) :
1611 score->ifa->idev->cnf.use_tempaddr >= 2;
1612 ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1613 break;
1614 }
1615 case IPV6_SADDR_RULE_ORCHID:
1616
1617
1618
1619 ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
1620 ipv6_addr_orchid(dst->addr));
1621 break;
1622 case IPV6_SADDR_RULE_PREFIX:
1623
1624 ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
1625 if (ret > score->ifa->prefix_len)
1626 ret = score->ifa->prefix_len;
1627 score->matchlen = ret;
1628 break;
1629#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
1630 case IPV6_SADDR_RULE_NOT_OPTIMISTIC:
1631
1632
1633
1634 ret = !(score->ifa->flags & IFA_F_OPTIMISTIC);
1635 break;
1636#endif
1637 default:
1638 ret = 0;
1639 }
1640
1641 if (ret)
1642 __set_bit(i, score->scorebits);
1643 score->rule = i;
1644out:
1645 return ret;
1646}
1647
1648static int __ipv6_dev_get_saddr(struct net *net,
1649 struct ipv6_saddr_dst *dst,
1650 struct inet6_dev *idev,
1651 struct ipv6_saddr_score *scores,
1652 int hiscore_idx)
1653{
1654 struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx];
1655
1656 list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) {
1657 int i;
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669 if ((score->ifa->flags & IFA_F_TENTATIVE) &&
1670 (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1671 continue;
1672
1673 score->addr_type = __ipv6_addr_type(&score->ifa->addr);
1674
1675 if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
1676 score->addr_type & IPV6_ADDR_MULTICAST)) {
1677 net_dbg_ratelimited("ADDRCONF: unspecified / multicast address assigned as unicast address on %s",
1678 idev->dev->name);
1679 continue;
1680 }
1681
1682 score->rule = -1;
1683 bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
1684
1685 for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
1686 int minihiscore, miniscore;
1687
1688 minihiscore = ipv6_get_saddr_eval(net, hiscore, dst, i);
1689 miniscore = ipv6_get_saddr_eval(net, score, dst, i);
1690
1691 if (minihiscore > miniscore) {
1692 if (i == IPV6_SADDR_RULE_SCOPE &&
1693 score->scopedist > 0) {
1694
1695
1696
1697
1698
1699
1700
1701
1702 goto out;
1703 }
1704 break;
1705 } else if (minihiscore < miniscore) {
1706 swap(hiscore, score);
1707 hiscore_idx = 1 - hiscore_idx;
1708
1709
1710 score->ifa = hiscore->ifa;
1711
1712 break;
1713 }
1714 }
1715 }
1716out:
1717 return hiscore_idx;
1718}
1719
1720static int ipv6_get_saddr_master(struct net *net,
1721 const struct net_device *dst_dev,
1722 const struct net_device *master,
1723 struct ipv6_saddr_dst *dst,
1724 struct ipv6_saddr_score *scores,
1725 int hiscore_idx)
1726{
1727 struct inet6_dev *idev;
1728
1729 idev = __in6_dev_get(dst_dev);
1730 if (idev)
1731 hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
1732 scores, hiscore_idx);
1733
1734 idev = __in6_dev_get(master);
1735 if (idev)
1736 hiscore_idx = __ipv6_dev_get_saddr(net, dst, idev,
1737 scores, hiscore_idx);
1738
1739 return hiscore_idx;
1740}
1741
1742int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1743 const struct in6_addr *daddr, unsigned int prefs,
1744 struct in6_addr *saddr)
1745{
1746 struct ipv6_saddr_score scores[2], *hiscore;
1747 struct ipv6_saddr_dst dst;
1748 struct inet6_dev *idev;
1749 struct net_device *dev;
1750 int dst_type;
1751 bool use_oif_addr = false;
1752 int hiscore_idx = 0;
1753 int ret = 0;
1754
1755 dst_type = __ipv6_addr_type(daddr);
1756 dst.addr = daddr;
1757 dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
1758 dst.scope = __ipv6_addr_src_scope(dst_type);
1759 dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1760 dst.prefs = prefs;
1761
1762 scores[hiscore_idx].rule = -1;
1763 scores[hiscore_idx].ifa = NULL;
1764
1765 rcu_read_lock();
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783 if (dst_dev) {
1784 idev = __in6_dev_get(dst_dev);
1785 if ((dst_type & IPV6_ADDR_MULTICAST) ||
1786 dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL ||
1787 (idev && idev->cnf.use_oif_addrs_only)) {
1788 use_oif_addr = true;
1789 }
1790 }
1791
1792 if (use_oif_addr) {
1793 if (idev)
1794 hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1795 } else {
1796 const struct net_device *master;
1797 int master_idx = 0;
1798
1799
1800
1801
1802
1803 master = l3mdev_master_dev_rcu(dst_dev);
1804 if (master) {
1805 master_idx = master->ifindex;
1806
1807 hiscore_idx = ipv6_get_saddr_master(net, dst_dev,
1808 master, &dst,
1809 scores, hiscore_idx);
1810
1811 if (scores[hiscore_idx].ifa)
1812 goto out;
1813 }
1814
1815 for_each_netdev_rcu(net, dev) {
1816
1817
1818
1819 if (l3mdev_master_ifindex_rcu(dev) != master_idx)
1820 continue;
1821 idev = __in6_dev_get(dev);
1822 if (!idev)
1823 continue;
1824 hiscore_idx = __ipv6_dev_get_saddr(net, &dst, idev, scores, hiscore_idx);
1825 }
1826 }
1827
1828out:
1829 hiscore = &scores[hiscore_idx];
1830 if (!hiscore->ifa)
1831 ret = -EADDRNOTAVAIL;
1832 else
1833 *saddr = hiscore->ifa->addr;
1834
1835 rcu_read_unlock();
1836 return ret;
1837}
1838EXPORT_SYMBOL(ipv6_dev_get_saddr);
1839
1840int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1841 u32 banned_flags)
1842{
1843 struct inet6_ifaddr *ifp;
1844 int err = -EADDRNOTAVAIL;
1845
1846 list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
1847 if (ifp->scope > IFA_LINK)
1848 break;
1849 if (ifp->scope == IFA_LINK &&
1850 !(ifp->flags & banned_flags)) {
1851 *addr = ifp->addr;
1852 err = 0;
1853 break;
1854 }
1855 }
1856 return err;
1857}
1858
1859int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1860 u32 banned_flags)
1861{
1862 struct inet6_dev *idev;
1863 int err = -EADDRNOTAVAIL;
1864
1865 rcu_read_lock();
1866 idev = __in6_dev_get(dev);
1867 if (idev) {
1868 read_lock_bh(&idev->lock);
1869 err = __ipv6_get_lladdr(idev, addr, banned_flags);
1870 read_unlock_bh(&idev->lock);
1871 }
1872 rcu_read_unlock();
1873 return err;
1874}
1875
1876static int ipv6_count_addresses(const struct inet6_dev *idev)
1877{
1878 const struct inet6_ifaddr *ifp;
1879 int cnt = 0;
1880
1881 rcu_read_lock();
1882 list_for_each_entry_rcu(ifp, &idev->addr_list, if_list)
1883 cnt++;
1884 rcu_read_unlock();
1885 return cnt;
1886}
1887
1888int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1889 const struct net_device *dev, int strict)
1890{
1891 return ipv6_chk_addr_and_flags(net, addr, dev, !dev,
1892 strict, IFA_F_TENTATIVE);
1893}
1894EXPORT_SYMBOL(ipv6_chk_addr);
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905static struct net_device *
1906__ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
1907 const struct net_device *dev, bool skip_dev_check,
1908 int strict, u32 banned_flags)
1909{
1910 unsigned int hash = inet6_addr_hash(net, addr);
1911 struct net_device *l3mdev, *ndev;
1912 struct inet6_ifaddr *ifp;
1913 u32 ifp_flags;
1914
1915 rcu_read_lock();
1916
1917 l3mdev = l3mdev_master_dev_rcu(dev);
1918 if (skip_dev_check)
1919 dev = NULL;
1920
1921 hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1922 ndev = ifp->idev->dev;
1923 if (!net_eq(dev_net(ndev), net))
1924 continue;
1925
1926 if (l3mdev_master_dev_rcu(ndev) != l3mdev)
1927 continue;
1928
1929
1930
1931
1932 ifp_flags = (ifp->flags&IFA_F_OPTIMISTIC)
1933 ? (ifp->flags&~IFA_F_TENTATIVE)
1934 : ifp->flags;
1935 if (ipv6_addr_equal(&ifp->addr, addr) &&
1936 !(ifp_flags&banned_flags) &&
1937 (!dev || ndev == dev ||
1938 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1939 rcu_read_unlock();
1940 return ndev;
1941 }
1942 }
1943
1944 rcu_read_unlock();
1945 return NULL;
1946}
1947
1948int ipv6_chk_addr_and_flags(struct net *net, const struct in6_addr *addr,
1949 const struct net_device *dev, bool skip_dev_check,
1950 int strict, u32 banned_flags)
1951{
1952 return __ipv6_chk_addr_and_flags(net, addr, dev, skip_dev_check,
1953 strict, banned_flags) ? 1 : 0;
1954}
1955EXPORT_SYMBOL(ipv6_chk_addr_and_flags);
1956
1957
1958
1959
1960
1961bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
1962 const unsigned int prefix_len, struct net_device *dev)
1963{
1964 const struct inet6_ifaddr *ifa;
1965 const struct inet6_dev *idev;
1966 bool ret = false;
1967
1968 rcu_read_lock();
1969 idev = __in6_dev_get(dev);
1970 if (idev) {
1971 list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1972 ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
1973 if (ret)
1974 break;
1975 }
1976 }
1977 rcu_read_unlock();
1978
1979 return ret;
1980}
1981EXPORT_SYMBOL(ipv6_chk_custom_prefix);
1982
1983int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1984{
1985 const struct inet6_ifaddr *ifa;
1986 const struct inet6_dev *idev;
1987 int onlink;
1988
1989 onlink = 0;
1990 rcu_read_lock();
1991 idev = __in6_dev_get(dev);
1992 if (idev) {
1993 list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) {
1994 onlink = ipv6_prefix_equal(addr, &ifa->addr,
1995 ifa->prefix_len);
1996 if (onlink)
1997 break;
1998 }
1999 }
2000 rcu_read_unlock();
2001 return onlink;
2002}
2003EXPORT_SYMBOL(ipv6_chk_prefix);
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013struct net_device *ipv6_dev_find(struct net *net, const struct in6_addr *addr,
2014 struct net_device *dev)
2015{
2016 return __ipv6_chk_addr_and_flags(net, addr, dev, !dev, 1,
2017 IFA_F_TENTATIVE);
2018}
2019EXPORT_SYMBOL(ipv6_dev_find);
2020
2021struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
2022 struct net_device *dev, int strict)
2023{
2024 unsigned int hash = inet6_addr_hash(net, addr);
2025 struct inet6_ifaddr *ifp, *result = NULL;
2026
2027 rcu_read_lock();
2028 hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
2029 if (!net_eq(dev_net(ifp->idev->dev), net))
2030 continue;
2031 if (ipv6_addr_equal(&ifp->addr, addr)) {
2032 if (!dev || ifp->idev->dev == dev ||
2033 !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
2034 result = ifp;
2035 in6_ifa_hold(ifp);
2036 break;
2037 }
2038 }
2039 }
2040 rcu_read_unlock();
2041
2042 return result;
2043}
2044
2045
2046
2047static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
2048{
2049 if (dad_failed)
2050 ifp->flags |= IFA_F_DADFAILED;
2051
2052 if (ifp->flags&IFA_F_TEMPORARY) {
2053 struct inet6_ifaddr *ifpub;
2054 spin_lock_bh(&ifp->lock);
2055 ifpub = ifp->ifpub;
2056 if (ifpub) {
2057 in6_ifa_hold(ifpub);
2058 spin_unlock_bh(&ifp->lock);
2059 ipv6_create_tempaddr(ifpub, true);
2060 in6_ifa_put(ifpub);
2061 } else {
2062 spin_unlock_bh(&ifp->lock);
2063 }
2064 ipv6_del_addr(ifp);
2065 } else if (ifp->flags&IFA_F_PERMANENT || !dad_failed) {
2066 spin_lock_bh(&ifp->lock);
2067 addrconf_del_dad_work(ifp);
2068 ifp->flags |= IFA_F_TENTATIVE;
2069 if (dad_failed)
2070 ifp->flags &= ~IFA_F_OPTIMISTIC;
2071 spin_unlock_bh(&ifp->lock);
2072 if (dad_failed)
2073 ipv6_ifa_notify(0, ifp);
2074 in6_ifa_put(ifp);
2075 } else {
2076 ipv6_del_addr(ifp);
2077 }
2078}
2079
2080static int addrconf_dad_end(struct inet6_ifaddr *ifp)
2081{
2082 int err = -ENOENT;
2083
2084 spin_lock_bh(&ifp->lock);
2085 if (ifp->state == INET6_IFADDR_STATE_DAD) {
2086 ifp->state = INET6_IFADDR_STATE_POSTDAD;
2087 err = 0;
2088 }
2089 spin_unlock_bh(&ifp->lock);
2090
2091 return err;
2092}
2093
2094void addrconf_dad_failure(struct sk_buff *skb, struct inet6_ifaddr *ifp)
2095{
2096 struct inet6_dev *idev = ifp->idev;
2097 struct net *net = dev_net(ifp->idev->dev);
2098
2099 if (addrconf_dad_end(ifp)) {
2100 in6_ifa_put(ifp);
2101 return;
2102 }
2103
2104 net_info_ratelimited("%s: IPv6 duplicate address %pI6c used by %pM detected!\n",
2105 ifp->idev->dev->name, &ifp->addr, eth_hdr(skb)->h_source);
2106
2107 spin_lock_bh(&ifp->lock);
2108
2109 if (ifp->flags & IFA_F_STABLE_PRIVACY) {
2110 struct in6_addr new_addr;
2111 struct inet6_ifaddr *ifp2;
2112 int retries = ifp->stable_privacy_retry + 1;
2113 struct ifa6_config cfg = {
2114 .pfx = &new_addr,
2115 .plen = ifp->prefix_len,
2116 .ifa_flags = ifp->flags,
2117 .valid_lft = ifp->valid_lft,
2118 .preferred_lft = ifp->prefered_lft,
2119 .scope = ifp->scope,
2120 };
2121
2122 if (retries > net->ipv6.sysctl.idgen_retries) {
2123 net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n",
2124 ifp->idev->dev->name);
2125 goto errdad;
2126 }
2127
2128 new_addr = ifp->addr;
2129 if (ipv6_generate_stable_address(&new_addr, retries,
2130 idev))
2131 goto errdad;
2132
2133 spin_unlock_bh(&ifp->lock);
2134
2135 if (idev->cnf.max_addresses &&
2136 ipv6_count_addresses(idev) >=
2137 idev->cnf.max_addresses)
2138 goto lock_errdad;
2139
2140 net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n",
2141 ifp->idev->dev->name);
2142
2143 ifp2 = ipv6_add_addr(idev, &cfg, false, NULL);
2144 if (IS_ERR(ifp2))
2145 goto lock_errdad;
2146
2147 spin_lock_bh(&ifp2->lock);
2148 ifp2->stable_privacy_retry = retries;
2149 ifp2->state = INET6_IFADDR_STATE_PREDAD;
2150 spin_unlock_bh(&ifp2->lock);
2151
2152 addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
2153 in6_ifa_put(ifp2);
2154lock_errdad:
2155 spin_lock_bh(&ifp->lock);
2156 }
2157
2158errdad:
2159
2160 ifp->state = INET6_IFADDR_STATE_ERRDAD;
2161 spin_unlock_bh(&ifp->lock);
2162
2163 addrconf_mod_dad_work(ifp, 0);
2164 in6_ifa_put(ifp);
2165}
2166
2167
2168
2169void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
2170{
2171 struct in6_addr maddr;
2172
2173 if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
2174 return;
2175
2176 addrconf_addr_solict_mult(addr, &maddr);
2177 ipv6_dev_mc_inc(dev, &maddr);
2178}
2179
2180
2181void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
2182{
2183 struct in6_addr maddr;
2184
2185 if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
2186 return;
2187
2188 addrconf_addr_solict_mult(addr, &maddr);
2189 __ipv6_dev_mc_dec(idev, &maddr);
2190}
2191
2192
2193static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
2194{
2195 struct in6_addr addr;
2196
2197 if (ifp->prefix_len >= 127)
2198 return;
2199 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
2200 if (ipv6_addr_any(&addr))
2201 return;
2202 __ipv6_dev_ac_inc(ifp->idev, &addr);
2203}
2204
2205
2206static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
2207{
2208 struct in6_addr addr;
2209
2210 if (ifp->prefix_len >= 127)
2211 return;
2212 ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
2213 if (ipv6_addr_any(&addr))
2214 return;
2215 __ipv6_dev_ac_dec(ifp->idev, &addr);
2216}
2217
2218static int addrconf_ifid_6lowpan(u8 *eui, struct net_device *dev)
2219{
2220 switch (dev->addr_len) {
2221 case ETH_ALEN:
2222 memcpy(eui, dev->dev_addr, 3);
2223 eui[3] = 0xFF;
2224 eui[4] = 0xFE;
2225 memcpy(eui + 5, dev->dev_addr + 3, 3);
2226 break;
2227 case EUI64_ADDR_LEN:
2228 memcpy(eui, dev->dev_addr, EUI64_ADDR_LEN);
2229 eui[0] ^= 2;
2230 break;
2231 default:
2232 return -1;
2233 }
2234
2235 return 0;
2236}
2237
2238static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
2239{
2240 union fwnet_hwaddr *ha;
2241
2242 if (dev->addr_len != FWNET_ALEN)
2243 return -1;
2244
2245 ha = (union fwnet_hwaddr *)dev->dev_addr;
2246
2247 memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
2248 eui[0] ^= 2;
2249 return 0;
2250}
2251
2252static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
2253{
2254
2255 if (dev->addr_len != ARCNET_ALEN)
2256 return -1;
2257 memset(eui, 0, 7);
2258 eui[7] = *(u8 *)dev->dev_addr;
2259 return 0;
2260}
2261
2262static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
2263{
2264 if (dev->addr_len != INFINIBAND_ALEN)
2265 return -1;
2266 memcpy(eui, dev->dev_addr + 12, 8);
2267 eui[0] |= 2;
2268 return 0;
2269}
2270
2271static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
2272{
2273 if (addr == 0)
2274 return -1;
2275 eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
2276 ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
2277 ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
2278 ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
2279 ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
2280 ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
2281 eui[1] = 0;
2282 eui[2] = 0x5E;
2283 eui[3] = 0xFE;
2284 memcpy(eui + 4, &addr, 4);
2285 return 0;
2286}
2287
2288static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
2289{
2290 if (dev->priv_flags & IFF_ISATAP)
2291 return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2292 return -1;
2293}
2294
2295static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
2296{
2297 return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
2298}
2299
2300static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev)
2301{
2302 memcpy(eui, dev->perm_addr, 3);
2303 memcpy(eui + 5, dev->perm_addr + 3, 3);
2304 eui[3] = 0xFF;
2305 eui[4] = 0xFE;
2306 eui[0] ^= 2;
2307 return 0;
2308}
2309
2310static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
2311{
2312 switch (dev->type) {
2313 case ARPHRD_ETHER:
2314 case ARPHRD_FDDI:
2315 return addrconf_ifid_eui48(eui, dev);
2316 case ARPHRD_ARCNET:
2317 return addrconf_ifid_arcnet(eui, dev);
2318 case ARPHRD_INFINIBAND:
2319 return addrconf_ifid_infiniband(eui, dev);
2320 case ARPHRD_SIT:
2321 return addrconf_ifid_sit(eui, dev);
2322 case ARPHRD_IPGRE:
2323 case ARPHRD_TUNNEL:
2324 return addrconf_ifid_gre(eui, dev);
2325 case ARPHRD_6LOWPAN:
2326 return addrconf_ifid_6lowpan(eui, dev);
2327 case ARPHRD_IEEE1394:
2328 return addrconf_ifid_ieee1394(eui, dev);
2329 case ARPHRD_TUNNEL6:
2330 case ARPHRD_IP6GRE:
2331 case ARPHRD_RAWIP:
2332 return addrconf_ifid_ip6tnl(eui, dev);
2333 }
2334 return -1;
2335}
2336
2337static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
2338{
2339 int err = -1;
2340 struct inet6_ifaddr *ifp;
2341
2342 read_lock_bh(&idev->lock);
2343 list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
2344 if (ifp->scope > IFA_LINK)
2345 break;
2346 if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
2347 memcpy(eui, ifp->addr.s6_addr+8, 8);
2348 err = 0;
2349 break;
2350 }
2351 }
2352 read_unlock_bh(&idev->lock);
2353 return err;
2354}
2355
2356
2357
2358
2359
2360static void ipv6_gen_rnd_iid(struct in6_addr *addr)
2361{
2362regen:
2363 get_random_bytes(&addr->s6_addr[8], 8);
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373 if (!(addr->s6_addr32[2] | addr->s6_addr32[3]))
2374 goto regen;
2375
2376
2377
2378
2379
2380 if (ntohl(addr->s6_addr32[2]) == 0x02005eff &&
2381 (ntohl(addr->s6_addr32[3]) & 0Xff000000) == 0xfe000000)
2382 goto regen;
2383
2384
2385 if (ntohl(addr->s6_addr32[2]) == 0xfdffffff &&
2386 ntohl(addr->s6_addr32[3]) >= 0Xffffff80)
2387 goto regen;
2388}
2389
2390
2391
2392
2393
2394static void
2395addrconf_prefix_route(struct in6_addr *pfx, int plen, u32 metric,
2396 struct net_device *dev, unsigned long expires,
2397 u32 flags, gfp_t gfp_flags)
2398{
2399 struct fib6_config cfg = {
2400 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX,
2401 .fc_metric = metric ? : IP6_RT_PRIO_ADDRCONF,
2402 .fc_ifindex = dev->ifindex,
2403 .fc_expires = expires,
2404 .fc_dst_len = plen,
2405 .fc_flags = RTF_UP | flags,
2406 .fc_nlinfo.nl_net = dev_net(dev),
2407 .fc_protocol = RTPROT_KERNEL,
2408 .fc_type = RTN_UNICAST,
2409 };
2410
2411 cfg.fc_dst = *pfx;
2412
2413
2414
2415
2416
2417#if IS_ENABLED(CONFIG_IPV6_SIT)
2418 if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
2419 cfg.fc_flags |= RTF_NONEXTHOP;
2420#endif
2421
2422 ip6_route_add(&cfg, gfp_flags, NULL);
2423}
2424
2425
2426static struct fib6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
2427 int plen,
2428 const struct net_device *dev,
2429 u32 flags, u32 noflags,
2430 bool no_gw)
2431{
2432 struct fib6_node *fn;
2433 struct fib6_info *rt = NULL;
2434 struct fib6_table *table;
2435 u32 tb_id = l3mdev_fib_table(dev) ? : RT6_TABLE_PREFIX;
2436
2437 table = fib6_get_table(dev_net(dev), tb_id);
2438 if (!table)
2439 return NULL;
2440
2441 rcu_read_lock();
2442 fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0, true);
2443 if (!fn)
2444 goto out;
2445
2446 for_each_fib6_node_rt_rcu(fn) {
2447
2448 if (rt->nh)
2449 continue;
2450
2451 if (rt->fib6_nh->fib_nh_dev->ifindex != dev->ifindex)
2452 continue;
2453 if (no_gw && rt->fib6_nh->fib_nh_gw_family)
2454 continue;
2455 if ((rt->fib6_flags & flags) != flags)
2456 continue;
2457 if ((rt->fib6_flags & noflags) != 0)
2458 continue;
2459 if (!fib6_info_hold_safe(rt))
2460 continue;
2461 break;
2462 }
2463out:
2464 rcu_read_unlock();
2465 return rt;
2466}
2467
2468
2469
2470
2471static void addrconf_add_mroute(struct net_device *dev)
2472{
2473 struct fib6_config cfg = {
2474 .fc_table = l3mdev_fib_table(dev) ? : RT6_TABLE_LOCAL,
2475 .fc_metric = IP6_RT_PRIO_ADDRCONF,
2476 .fc_ifindex = dev->ifindex,
2477 .fc_dst_len = 8,
2478 .fc_flags = RTF_UP,
2479 .fc_type = RTN_MULTICAST,
2480 .fc_nlinfo.nl_net = dev_net(dev),
2481 .fc_protocol = RTPROT_KERNEL,
2482 };
2483
2484 ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
2485
2486 ip6_route_add(&cfg, GFP_KERNEL, NULL);
2487}
2488
2489static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
2490{
2491 struct inet6_dev *idev;
2492
2493 ASSERT_RTNL();
2494
2495 idev = ipv6_find_idev(dev);
2496 if (IS_ERR(idev))
2497 return idev;
2498
2499 if (idev->cnf.disable_ipv6)
2500 return ERR_PTR(-EACCES);
2501
2502
2503 if (!(dev->flags & IFF_LOOPBACK) && !netif_is_l3_master(dev))
2504 addrconf_add_mroute(dev);
2505
2506 return idev;
2507}
2508
2509static void manage_tempaddrs(struct inet6_dev *idev,
2510 struct inet6_ifaddr *ifp,
2511 __u32 valid_lft, __u32 prefered_lft,
2512 bool create, unsigned long now)
2513{
2514 u32 flags;
2515 struct inet6_ifaddr *ift;
2516
2517 read_lock_bh(&idev->lock);
2518
2519 list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) {
2520 int age, max_valid, max_prefered;
2521
2522 if (ifp != ift->ifpub)
2523 continue;
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533 age = (now - ift->cstamp) / HZ;
2534 max_valid = idev->cnf.temp_valid_lft - age;
2535 if (max_valid < 0)
2536 max_valid = 0;
2537
2538 max_prefered = idev->cnf.temp_prefered_lft -
2539 idev->desync_factor - age;
2540 if (max_prefered < 0)
2541 max_prefered = 0;
2542
2543 if (valid_lft > max_valid)
2544 valid_lft = max_valid;
2545
2546 if (prefered_lft > max_prefered)
2547 prefered_lft = max_prefered;
2548
2549 spin_lock(&ift->lock);
2550 flags = ift->flags;
2551 ift->valid_lft = valid_lft;
2552 ift->prefered_lft = prefered_lft;
2553 ift->tstamp = now;
2554 if (prefered_lft > 0)
2555 ift->flags &= ~IFA_F_DEPRECATED;
2556
2557 spin_unlock(&ift->lock);
2558 if (!(flags&IFA_F_TENTATIVE))
2559 ipv6_ifa_notify(0, ift);
2560 }
2561
2562 if ((create || list_empty(&idev->tempaddr_list)) &&
2563 idev->cnf.use_tempaddr > 0) {
2564
2565
2566
2567
2568
2569 read_unlock_bh(&idev->lock);
2570 ipv6_create_tempaddr(ifp, false);
2571 } else {
2572 read_unlock_bh(&idev->lock);
2573 }
2574}
2575
2576static bool is_addr_mode_generate_stable(struct inet6_dev *idev)
2577{
2578 return idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY ||
2579 idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_RANDOM;
2580}
2581
2582int addrconf_prefix_rcv_add_addr(struct net *net, struct net_device *dev,
2583 const struct prefix_info *pinfo,
2584 struct inet6_dev *in6_dev,
2585 const struct in6_addr *addr, int addr_type,
2586 u32 addr_flags, bool sllao, bool tokenized,
2587 __u32 valid_lft, u32 prefered_lft)
2588{
2589 struct inet6_ifaddr *ifp = ipv6_get_ifaddr(net, addr, dev, 1);
2590 int create = 0;
2591
2592 if (!ifp && valid_lft) {
2593 int max_addresses = in6_dev->cnf.max_addresses;
2594 struct ifa6_config cfg = {
2595 .pfx = addr,
2596 .plen = pinfo->prefix_len,
2597 .ifa_flags = addr_flags,
2598 .valid_lft = valid_lft,
2599 .preferred_lft = prefered_lft,
2600 .scope = addr_type & IPV6_ADDR_SCOPE_MASK,
2601 };
2602
2603#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2604 if ((net->ipv6.devconf_all->optimistic_dad ||
2605 in6_dev->cnf.optimistic_dad) &&
2606 !net->ipv6.devconf_all->forwarding && sllao)
2607 cfg.ifa_flags |= IFA_F_OPTIMISTIC;
2608#endif
2609
2610
2611
2612
2613 if (!max_addresses ||
2614 ipv6_count_addresses(in6_dev) < max_addresses)
2615 ifp = ipv6_add_addr(in6_dev, &cfg, false, NULL);
2616
2617 if (IS_ERR_OR_NULL(ifp))
2618 return -1;
2619
2620 create = 1;
2621 spin_lock_bh(&ifp->lock);
2622 ifp->flags |= IFA_F_MANAGETEMPADDR;
2623 ifp->cstamp = jiffies;
2624 ifp->tokenized = tokenized;
2625 spin_unlock_bh(&ifp->lock);
2626 addrconf_dad_start(ifp);
2627 }
2628
2629 if (ifp) {
2630 u32 flags;
2631 unsigned long now;
2632 u32 stored_lft;
2633
2634
2635
2636
2637
2638
2639 spin_lock_bh(&ifp->lock);
2640 now = jiffies;
2641 if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
2642 stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
2643 else
2644 stored_lft = 0;
2645
2646 if (!create && stored_lft) {
2647 ifp->valid_lft = valid_lft;
2648 ifp->prefered_lft = prefered_lft;
2649 ifp->tstamp = now;
2650 flags = ifp->flags;
2651 ifp->flags &= ~IFA_F_DEPRECATED;
2652 spin_unlock_bh(&ifp->lock);
2653
2654 if (!(flags&IFA_F_TENTATIVE))
2655 ipv6_ifa_notify(0, ifp);
2656 } else
2657 spin_unlock_bh(&ifp->lock);
2658
2659 manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
2660 create, now);
2661
2662 in6_ifa_put(ifp);
2663 addrconf_verify();
2664 }
2665
2666 return 0;
2667}
2668EXPORT_SYMBOL_GPL(addrconf_prefix_rcv_add_addr);
2669
2670void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
2671{
2672 struct prefix_info *pinfo;
2673 __u32 valid_lft;
2674 __u32 prefered_lft;
2675 int addr_type, err;
2676 u32 addr_flags = 0;
2677 struct inet6_dev *in6_dev;
2678 struct net *net = dev_net(dev);
2679
2680 pinfo = (struct prefix_info *) opt;
2681
2682 if (len < sizeof(struct prefix_info)) {
2683 netdev_dbg(dev, "addrconf: prefix option too short\n");
2684 return;
2685 }
2686
2687
2688
2689
2690
2691 addr_type = ipv6_addr_type(&pinfo->prefix);
2692
2693 if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
2694 return;
2695
2696 valid_lft = ntohl(pinfo->valid);
2697 prefered_lft = ntohl(pinfo->prefered);
2698
2699 if (prefered_lft > valid_lft) {
2700 net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
2701 return;
2702 }
2703
2704 in6_dev = in6_dev_get(dev);
2705
2706 if (!in6_dev) {
2707 net_dbg_ratelimited("addrconf: device %s not configured\n",
2708 dev->name);
2709 return;
2710 }
2711
2712
2713
2714
2715
2716
2717
2718 if (pinfo->onlink) {
2719 struct fib6_info *rt;
2720 unsigned long rt_expires;
2721
2722
2723
2724
2725
2726
2727 if (HZ > USER_HZ)
2728 rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
2729 else
2730 rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
2731
2732 if (addrconf_finite_timeout(rt_expires))
2733 rt_expires *= HZ;
2734
2735 rt = addrconf_get_prefix_route(&pinfo->prefix,
2736 pinfo->prefix_len,
2737 dev,
2738 RTF_ADDRCONF | RTF_PREFIX_RT,
2739 RTF_DEFAULT, true);
2740
2741 if (rt) {
2742
2743 if (valid_lft == 0) {
2744 ip6_del_rt(net, rt, false);
2745 rt = NULL;
2746 } else if (addrconf_finite_timeout(rt_expires)) {
2747
2748 fib6_set_expires(rt, jiffies + rt_expires);
2749 } else {
2750 fib6_clean_expires(rt);
2751 }
2752 } else if (valid_lft) {
2753 clock_t expires = 0;
2754 int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
2755 if (addrconf_finite_timeout(rt_expires)) {
2756
2757 flags |= RTF_EXPIRES;
2758 expires = jiffies_to_clock_t(rt_expires);
2759 }
2760 addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2761 0, dev, expires, flags,
2762 GFP_ATOMIC);
2763 }
2764 fib6_info_release(rt);
2765 }
2766
2767
2768
2769 if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2770 struct in6_addr addr;
2771 bool tokenized = false, dev_addr_generated = false;
2772
2773 if (pinfo->prefix_len == 64) {
2774 memcpy(&addr, &pinfo->prefix, 8);
2775
2776 if (!ipv6_addr_any(&in6_dev->token)) {
2777 read_lock_bh(&in6_dev->lock);
2778 memcpy(addr.s6_addr + 8,
2779 in6_dev->token.s6_addr + 8, 8);
2780 read_unlock_bh(&in6_dev->lock);
2781 tokenized = true;
2782 } else if (is_addr_mode_generate_stable(in6_dev) &&
2783 !ipv6_generate_stable_address(&addr, 0,
2784 in6_dev)) {
2785 addr_flags |= IFA_F_STABLE_PRIVACY;
2786 goto ok;
2787 } else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
2788 ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
2789 goto put;
2790 } else {
2791 dev_addr_generated = true;
2792 }
2793 goto ok;
2794 }
2795 net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
2796 pinfo->prefix_len);
2797 goto put;
2798
2799ok:
2800 err = addrconf_prefix_rcv_add_addr(net, dev, pinfo, in6_dev,
2801 &addr, addr_type,
2802 addr_flags, sllao,
2803 tokenized, valid_lft,
2804 prefered_lft);
2805 if (err)
2806 goto put;
2807
2808
2809
2810
2811 ndisc_ops_prefix_rcv_add_addr(net, dev, pinfo, in6_dev, &addr,
2812 addr_type, addr_flags, sllao,
2813 tokenized, valid_lft,
2814 prefered_lft,
2815 dev_addr_generated);
2816 }
2817 inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2818put:
2819 in6_dev_put(in6_dev);
2820}
2821
2822static int addrconf_set_sit_dstaddr(struct net *net, struct net_device *dev,
2823 struct in6_ifreq *ireq)
2824{
2825 struct ip_tunnel_parm p = { };
2826 int err;
2827
2828 if (!(ipv6_addr_type(&ireq->ifr6_addr) & IPV6_ADDR_COMPATv4))
2829 return -EADDRNOTAVAIL;
2830
2831 p.iph.daddr = ireq->ifr6_addr.s6_addr32[3];
2832 p.iph.version = 4;
2833 p.iph.ihl = 5;
2834 p.iph.protocol = IPPROTO_IPV6;
2835 p.iph.ttl = 64;
2836
2837 if (!dev->netdev_ops->ndo_tunnel_ctl)
2838 return -EOPNOTSUPP;
2839 err = dev->netdev_ops->ndo_tunnel_ctl(dev, &p, SIOCADDTUNNEL);
2840 if (err)
2841 return err;
2842
2843 dev = __dev_get_by_name(net, p.name);
2844 if (!dev)
2845 return -ENOBUFS;
2846 return dev_open(dev, NULL);
2847}
2848
2849
2850
2851
2852
2853
2854int addrconf_set_dstaddr(struct net *net, void __user *arg)
2855{
2856 struct net_device *dev;
2857 struct in6_ifreq ireq;
2858 int err = -ENODEV;
2859
2860 if (!IS_ENABLED(CONFIG_IPV6_SIT))
2861 return -ENODEV;
2862 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2863 return -EFAULT;
2864
2865 rtnl_lock();
2866 dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2867 if (dev && dev->type == ARPHRD_SIT)
2868 err = addrconf_set_sit_dstaddr(net, dev, &ireq);
2869 rtnl_unlock();
2870 return err;
2871}
2872
2873static int ipv6_mc_config(struct sock *sk, bool join,
2874 const struct in6_addr *addr, int ifindex)
2875{
2876 int ret;
2877
2878 ASSERT_RTNL();
2879
2880 lock_sock(sk);
2881 if (join)
2882 ret = ipv6_sock_mc_join(sk, ifindex, addr);
2883 else
2884 ret = ipv6_sock_mc_drop(sk, ifindex, addr);
2885 release_sock(sk);
2886
2887 return ret;
2888}
2889
2890
2891
2892
2893static int inet6_addr_add(struct net *net, int ifindex,
2894 struct ifa6_config *cfg,
2895 struct netlink_ext_ack *extack)
2896{
2897 struct inet6_ifaddr *ifp;
2898 struct inet6_dev *idev;
2899 struct net_device *dev;
2900 unsigned long timeout;
2901 clock_t expires;
2902 u32 flags;
2903
2904 ASSERT_RTNL();
2905
2906 if (cfg->plen > 128)
2907 return -EINVAL;
2908
2909
2910 if (!cfg->valid_lft || cfg->preferred_lft > cfg->valid_lft)
2911 return -EINVAL;
2912
2913 if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR && cfg->plen != 64)
2914 return -EINVAL;
2915
2916 dev = __dev_get_by_index(net, ifindex);
2917 if (!dev)
2918 return -ENODEV;
2919
2920 idev = addrconf_add_dev(dev);
2921 if (IS_ERR(idev))
2922 return PTR_ERR(idev);
2923
2924 if (cfg->ifa_flags & IFA_F_MCAUTOJOIN) {
2925 int ret = ipv6_mc_config(net->ipv6.mc_autojoin_sk,
2926 true, cfg->pfx, ifindex);
2927
2928 if (ret < 0)
2929 return ret;
2930 }
2931
2932 cfg->scope = ipv6_addr_scope(cfg->pfx);
2933
2934 timeout = addrconf_timeout_fixup(cfg->valid_lft, HZ);
2935 if (addrconf_finite_timeout(timeout)) {
2936 expires = jiffies_to_clock_t(timeout * HZ);
2937 cfg->valid_lft = timeout;
2938 flags = RTF_EXPIRES;
2939 } else {
2940 expires = 0;
2941 flags = 0;
2942 cfg->ifa_flags |= IFA_F_PERMANENT;
2943 }
2944
2945 timeout = addrconf_timeout_fixup(cfg->preferred_lft, HZ);
2946 if (addrconf_finite_timeout(timeout)) {
2947 if (timeout == 0)
2948 cfg->ifa_flags |= IFA_F_DEPRECATED;
2949 cfg->preferred_lft = timeout;
2950 }
2951
2952 ifp = ipv6_add_addr(idev, cfg, true, extack);
2953 if (!IS_ERR(ifp)) {
2954 if (!(cfg->ifa_flags & IFA_F_NOPREFIXROUTE)) {
2955 addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
2956 ifp->rt_priority, dev, expires,
2957 flags, GFP_KERNEL);
2958 }
2959
2960
2961
2962
2963 if (!(ifp->flags & (IFA_F_OPTIMISTIC | IFA_F_NODAD)))
2964 ipv6_ifa_notify(0, ifp);
2965
2966
2967
2968
2969
2970 addrconf_dad_start(ifp);
2971 if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR)
2972 manage_tempaddrs(idev, ifp, cfg->valid_lft,
2973 cfg->preferred_lft, true, jiffies);
2974 in6_ifa_put(ifp);
2975 addrconf_verify_rtnl();
2976 return 0;
2977 } else if (cfg->ifa_flags & IFA_F_MCAUTOJOIN) {
2978 ipv6_mc_config(net->ipv6.mc_autojoin_sk, false,
2979 cfg->pfx, ifindex);
2980 }
2981
2982 return PTR_ERR(ifp);
2983}
2984
2985static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
2986 const struct in6_addr *pfx, unsigned int plen)
2987{
2988 struct inet6_ifaddr *ifp;
2989 struct inet6_dev *idev;
2990 struct net_device *dev;
2991
2992 if (plen > 128)
2993 return -EINVAL;
2994
2995 dev = __dev_get_by_index(net, ifindex);
2996 if (!dev)
2997 return -ENODEV;
2998
2999 idev = __in6_dev_get(dev);
3000 if (!idev)
3001 return -ENXIO;
3002
3003 read_lock_bh(&idev->lock);
3004 list_for_each_entry(ifp, &idev->addr_list, if_list) {
3005 if (ifp->prefix_len == plen &&
3006 ipv6_addr_equal(pfx, &ifp->addr)) {
3007 in6_ifa_hold(ifp);
3008 read_unlock_bh(&idev->lock);
3009
3010 if (!(ifp->flags & IFA_F_TEMPORARY) &&
3011 (ifa_flags & IFA_F_MANAGETEMPADDR))
3012 manage_tempaddrs(idev, ifp, 0, 0, false,
3013 jiffies);
3014 ipv6_del_addr(ifp);
3015 addrconf_verify_rtnl();
3016 if (ipv6_addr_is_multicast(pfx)) {
3017 ipv6_mc_config(net->ipv6.mc_autojoin_sk,
3018 false, pfx, dev->ifindex);
3019 }
3020 return 0;
3021 }
3022 }
3023 read_unlock_bh(&idev->lock);
3024 return -EADDRNOTAVAIL;
3025}
3026
3027
3028int addrconf_add_ifaddr(struct net *net, void __user *arg)
3029{
3030 struct ifa6_config cfg = {
3031 .ifa_flags = IFA_F_PERMANENT,
3032 .preferred_lft = INFINITY_LIFE_TIME,
3033 .valid_lft = INFINITY_LIFE_TIME,
3034 };
3035 struct in6_ifreq ireq;
3036 int err;
3037
3038 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
3039 return -EPERM;
3040
3041 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
3042 return -EFAULT;
3043
3044 cfg.pfx = &ireq.ifr6_addr;
3045 cfg.plen = ireq.ifr6_prefixlen;
3046
3047 rtnl_lock();
3048 err = inet6_addr_add(net, ireq.ifr6_ifindex, &cfg, NULL);
3049 rtnl_unlock();
3050 return err;
3051}
3052
3053int addrconf_del_ifaddr(struct net *net, void __user *arg)
3054{
3055 struct in6_ifreq ireq;
3056 int err;
3057
3058 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
3059 return -EPERM;
3060
3061 if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
3062 return -EFAULT;
3063
3064 rtnl_lock();
3065 err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
3066 ireq.ifr6_prefixlen);
3067 rtnl_unlock();
3068 return err;
3069}
3070
3071static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
3072 int plen, int scope)
3073{
3074 struct inet6_ifaddr *ifp;
3075 struct ifa6_config cfg = {
3076 .pfx = addr,
3077 .plen = plen,
3078 .ifa_flags = IFA_F_PERMANENT,
3079 .valid_lft = INFINITY_LIFE_TIME,
3080 .preferred_lft = INFINITY_LIFE_TIME,
3081 .scope = scope
3082 };
3083
3084 ifp = ipv6_add_addr(idev, &cfg, true, NULL);
3085 if (!IS_ERR(ifp)) {
3086 spin_lock_bh(&ifp->lock);
3087 ifp->flags &= ~IFA_F_TENTATIVE;
3088 spin_unlock_bh(&ifp->lock);
3089 rt_genid_bump_ipv6(dev_net(idev->dev));
3090 ipv6_ifa_notify(RTM_NEWADDR, ifp);
3091 in6_ifa_put(ifp);
3092 }
3093}
3094
3095#if IS_ENABLED(CONFIG_IPV6_SIT) || IS_ENABLED(CONFIG_NET_IPGRE) || IS_ENABLED(CONFIG_IPV6_GRE)
3096static void add_v4_addrs(struct inet6_dev *idev)
3097{
3098 struct in6_addr addr;
3099 struct net_device *dev;
3100 struct net *net = dev_net(idev->dev);
3101 int scope, plen, offset = 0;
3102 u32 pflags = 0;
3103
3104 ASSERT_RTNL();
3105
3106 memset(&addr, 0, sizeof(struct in6_addr));
3107
3108 if (idev->dev->addr_len == sizeof(struct in6_addr))
3109 offset = sizeof(struct in6_addr) - 4;
3110 memcpy(&addr.s6_addr32[3], idev->dev->dev_addr + offset, 4);
3111
3112 if (idev->dev->flags&IFF_POINTOPOINT) {
3113 addr.s6_addr32[0] = htonl(0xfe800000);
3114 scope = IFA_LINK;
3115 plen = 64;
3116 } else {
3117 scope = IPV6_ADDR_COMPATv4;
3118 plen = 96;
3119 pflags |= RTF_NONEXTHOP;
3120 }
3121
3122 if (addr.s6_addr32[3]) {
3123 add_addr(idev, &addr, plen, scope);
3124 addrconf_prefix_route(&addr, plen, 0, idev->dev, 0, pflags,
3125 GFP_KERNEL);
3126 return;
3127 }
3128
3129 for_each_netdev(net, dev) {
3130 struct in_device *in_dev = __in_dev_get_rtnl(dev);
3131 if (in_dev && (dev->flags & IFF_UP)) {
3132 struct in_ifaddr *ifa;
3133 int flag = scope;
3134
3135 in_dev_for_each_ifa_rtnl(ifa, in_dev) {
3136 addr.s6_addr32[3] = ifa->ifa_local;
3137
3138 if (ifa->ifa_scope == RT_SCOPE_LINK)
3139 continue;
3140 if (ifa->ifa_scope >= RT_SCOPE_HOST) {
3141 if (idev->dev->flags&IFF_POINTOPOINT)
3142 continue;
3143 flag |= IFA_HOST;
3144 }
3145
3146 add_addr(idev, &addr, plen, flag);
3147 addrconf_prefix_route(&addr, plen, 0, idev->dev,
3148 0, pflags, GFP_KERNEL);
3149 }
3150 }
3151 }
3152}
3153#endif
3154
3155static void init_loopback(struct net_device *dev)
3156{
3157 struct inet6_dev *idev;
3158
3159
3160
3161 ASSERT_RTNL();
3162
3163 idev = ipv6_find_idev(dev);
3164 if (IS_ERR(idev)) {
3165 pr_debug("%s: add_dev failed\n", __func__);
3166 return;
3167 }
3168
3169 add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
3170}
3171
3172void addrconf_add_linklocal(struct inet6_dev *idev,
3173 const struct in6_addr *addr, u32 flags)
3174{
3175 struct ifa6_config cfg = {
3176 .pfx = addr,
3177 .plen = 64,
3178 .ifa_flags = flags | IFA_F_PERMANENT,
3179 .valid_lft = INFINITY_LIFE_TIME,
3180 .preferred_lft = INFINITY_LIFE_TIME,
3181 .scope = IFA_LINK
3182 };
3183 struct inet6_ifaddr *ifp;
3184
3185#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
3186 if ((dev_net(idev->dev)->ipv6.devconf_all->optimistic_dad ||
3187 idev->cnf.optimistic_dad) &&
3188 !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
3189 cfg.ifa_flags |= IFA_F_OPTIMISTIC;
3190#endif
3191
3192 ifp = ipv6_add_addr(idev, &cfg, true, NULL);
3193 if (!IS_ERR(ifp)) {
3194 addrconf_prefix_route(&ifp->addr, ifp->prefix_len, 0, idev->dev,
3195 0, 0, GFP_ATOMIC);
3196 addrconf_dad_start(ifp);
3197 in6_ifa_put(ifp);
3198 }
3199}
3200EXPORT_SYMBOL_GPL(addrconf_add_linklocal);
3201
3202static bool ipv6_reserved_interfaceid(struct in6_addr address)
3203{
3204 if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0)
3205 return true;
3206
3207 if (address.s6_addr32[2] == htonl(0x02005eff) &&
3208 ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000)))
3209 return true;
3210
3211 if (address.s6_addr32[2] == htonl(0xfdffffff) &&
3212 ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80)))
3213 return true;
3214
3215 return false;
3216}
3217
3218static int ipv6_generate_stable_address(struct in6_addr *address,
3219 u8 dad_count,
3220 const struct inet6_dev *idev)
3221{
3222 static DEFINE_SPINLOCK(lock);
3223 static __u32 digest[SHA1_DIGEST_WORDS];
3224 static __u32 workspace[SHA1_WORKSPACE_WORDS];
3225
3226 static union {
3227 char __data[SHA1_BLOCK_SIZE];
3228 struct {
3229 struct in6_addr secret;
3230 __be32 prefix[2];
3231 unsigned char hwaddr[MAX_ADDR_LEN];
3232 u8 dad_count;
3233 } __packed;
3234 } data;
3235
3236 struct in6_addr secret;
3237 struct in6_addr temp;
3238 struct net *net = dev_net(idev->dev);
3239
3240 BUILD_BUG_ON(sizeof(data.__data) != sizeof(data));
3241
3242 if (idev->cnf.stable_secret.initialized)
3243 secret = idev->cnf.stable_secret.secret;
3244 else if (net->ipv6.devconf_dflt->stable_secret.initialized)
3245 secret = net->ipv6.devconf_dflt->stable_secret.secret;
3246 else
3247 return -1;
3248
3249retry:
3250 spin_lock_bh(&lock);
3251
3252 sha1_init(digest);
3253 memset(&data, 0, sizeof(data));
3254 memset(workspace, 0, sizeof(workspace));
3255 memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len);
3256 data.prefix[0] = address->s6_addr32[0];
3257 data.prefix[1] = address->s6_addr32[1];
3258 data.secret = secret;
3259 data.dad_count = dad_count;
3260
3261 sha1_transform(digest, data.__data, workspace);
3262
3263 temp = *address;
3264 temp.s6_addr32[2] = (__force __be32)digest[0];
3265 temp.s6_addr32[3] = (__force __be32)digest[1];
3266
3267 spin_unlock_bh(&lock);
3268
3269 if (ipv6_reserved_interfaceid(temp)) {
3270 dad_count++;
3271 if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
3272 return -1;
3273 goto retry;
3274 }
3275
3276 *address = temp;
3277 return 0;
3278}
3279
3280static void ipv6_gen_mode_random_init(struct inet6_dev *idev)
3281{
3282 struct ipv6_stable_secret *s = &idev->cnf.stable_secret;
3283
3284 if (s->initialized)
3285 return;
3286 s = &idev->cnf.stable_secret;
3287 get_random_bytes(&s->secret, sizeof(s->secret));
3288 s->initialized = true;
3289}
3290
3291static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
3292{
3293 struct in6_addr addr;
3294
3295
3296 if (netif_is_l3_master(idev->dev))
3297 return;
3298
3299
3300 if (idev->dev->flags & IFF_SLAVE)
3301 return;
3302
3303 ipv6_addr_set(&addr, htonl(0xFE800000), 0, 0, 0);
3304
3305 switch (idev->cnf.addr_gen_mode) {
3306 case IN6_ADDR_GEN_MODE_RANDOM:
3307 ipv6_gen_mode_random_init(idev);
3308 fallthrough;
3309 case IN6_ADDR_GEN_MODE_STABLE_PRIVACY:
3310 if (!ipv6_generate_stable_address(&addr, 0, idev))
3311 addrconf_add_linklocal(idev, &addr,
3312 IFA_F_STABLE_PRIVACY);
3313 else if (prefix_route)
3314 addrconf_prefix_route(&addr, 64, 0, idev->dev,
3315 0, 0, GFP_KERNEL);
3316 break;
3317 case IN6_ADDR_GEN_MODE_EUI64:
3318
3319
3320
3321
3322 if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
3323 addrconf_add_linklocal(idev, &addr, 0);
3324 else if (prefix_route)
3325 addrconf_prefix_route(&addr, 64, 0, idev->dev,
3326 0, 0, GFP_KERNEL);
3327 break;
3328 case IN6_ADDR_GEN_MODE_NONE:
3329 default:
3330
3331 break;
3332 }
3333}
3334
3335static void addrconf_dev_config(struct net_device *dev)
3336{
3337 struct inet6_dev *idev;
3338
3339 ASSERT_RTNL();
3340
3341 if ((dev->type != ARPHRD_ETHER) &&
3342 (dev->type != ARPHRD_FDDI) &&
3343 (dev->type != ARPHRD_ARCNET) &&
3344 (dev->type != ARPHRD_INFINIBAND) &&
3345 (dev->type != ARPHRD_IEEE1394) &&
3346 (dev->type != ARPHRD_TUNNEL6) &&
3347 (dev->type != ARPHRD_6LOWPAN) &&
3348 (dev->type != ARPHRD_TUNNEL) &&
3349 (dev->type != ARPHRD_NONE) &&
3350 (dev->type != ARPHRD_RAWIP)) {
3351
3352 idev = __in6_dev_get(dev);
3353 if (!IS_ERR_OR_NULL(idev) && dev->flags & IFF_UP &&
3354 dev->flags & IFF_MULTICAST)
3355 ipv6_mc_up(idev);
3356 return;
3357 }
3358
3359 idev = addrconf_add_dev(dev);
3360 if (IS_ERR(idev))
3361 return;
3362
3363
3364 if (dev->type == ARPHRD_NONE &&
3365 idev->cnf.addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64)
3366 idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_RANDOM;
3367
3368 addrconf_addr_gen(idev, false);
3369}
3370
3371#if IS_ENABLED(CONFIG_IPV6_SIT)
3372static void addrconf_sit_config(struct net_device *dev)
3373{
3374 struct inet6_dev *idev;
3375
3376 ASSERT_RTNL();
3377
3378
3379
3380
3381
3382
3383
3384 idev = ipv6_find_idev(dev);
3385 if (IS_ERR(idev)) {
3386 pr_debug("%s: add_dev failed\n", __func__);
3387 return;
3388 }
3389
3390 if (dev->priv_flags & IFF_ISATAP) {
3391 addrconf_addr_gen(idev, false);
3392 return;
3393 }
3394
3395 add_v4_addrs(idev);
3396
3397 if (dev->flags&IFF_POINTOPOINT)
3398 addrconf_add_mroute(dev);
3399}
3400#endif
3401
3402#if IS_ENABLED(CONFIG_NET_IPGRE) || IS_ENABLED(CONFIG_IPV6_GRE)
3403static void addrconf_gre_config(struct net_device *dev)
3404{
3405 struct inet6_dev *idev;
3406
3407 ASSERT_RTNL();
3408
3409 idev = ipv6_find_idev(dev);
3410 if (IS_ERR(idev)) {
3411 pr_debug("%s: add_dev failed\n", __func__);
3412 return;
3413 }
3414
3415 if (dev->type == ARPHRD_ETHER) {
3416 addrconf_addr_gen(idev, true);
3417 return;
3418 }
3419
3420 add_v4_addrs(idev);
3421
3422 if (dev->flags & IFF_POINTOPOINT)
3423 addrconf_add_mroute(dev);
3424}
3425#endif
3426
3427static int fixup_permanent_addr(struct net *net,
3428 struct inet6_dev *idev,
3429 struct inet6_ifaddr *ifp)
3430{
3431
3432
3433
3434
3435 if (!ifp->rt || !ifp->rt->fib6_node) {
3436 struct fib6_info *f6i, *prev;
3437
3438 f6i = addrconf_f6i_alloc(net, idev, &ifp->addr, false,
3439 GFP_ATOMIC);
3440 if (IS_ERR(f6i))
3441 return PTR_ERR(f6i);
3442
3443
3444 spin_lock(&ifp->lock);
3445 prev = ifp->rt;
3446 ifp->rt = f6i;
3447 spin_unlock(&ifp->lock);
3448
3449 fib6_info_release(prev);
3450 }
3451
3452 if (!(ifp->flags & IFA_F_NOPREFIXROUTE)) {
3453 addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
3454 ifp->rt_priority, idev->dev, 0, 0,
3455 GFP_ATOMIC);
3456 }
3457
3458 if (ifp->state == INET6_IFADDR_STATE_PREDAD)
3459 addrconf_dad_start(ifp);
3460
3461 return 0;
3462}
3463
3464static void addrconf_permanent_addr(struct net *net, struct net_device *dev)
3465{
3466 struct inet6_ifaddr *ifp, *tmp;
3467 struct inet6_dev *idev;
3468
3469 idev = __in6_dev_get(dev);
3470 if (!idev)
3471 return;
3472
3473 write_lock_bh(&idev->lock);
3474
3475 list_for_each_entry_safe(ifp, tmp, &idev->addr_list, if_list) {
3476 if ((ifp->flags & IFA_F_PERMANENT) &&
3477 fixup_permanent_addr(net, idev, ifp) < 0) {
3478 write_unlock_bh(&idev->lock);
3479 in6_ifa_hold(ifp);
3480 ipv6_del_addr(ifp);
3481 write_lock_bh(&idev->lock);
3482
3483 net_info_ratelimited("%s: Failed to add prefix route for address %pI6c; dropping\n",
3484 idev->dev->name, &ifp->addr);
3485 }
3486 }
3487
3488 write_unlock_bh(&idev->lock);
3489}
3490
3491static int addrconf_notify(struct notifier_block *this, unsigned long event,
3492 void *ptr)
3493{
3494 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3495 struct netdev_notifier_change_info *change_info;
3496 struct netdev_notifier_changeupper_info *info;
3497 struct inet6_dev *idev = __in6_dev_get(dev);
3498 struct net *net = dev_net(dev);
3499 int run_pending = 0;
3500 int err;
3501
3502 switch (event) {
3503 case NETDEV_REGISTER:
3504 if (!idev && dev->mtu >= IPV6_MIN_MTU) {
3505 idev = ipv6_add_dev(dev);
3506 if (IS_ERR(idev))
3507 return notifier_from_errno(PTR_ERR(idev));
3508 }
3509 break;
3510
3511 case NETDEV_CHANGEMTU:
3512
3513 if (dev->mtu < IPV6_MIN_MTU) {
3514 addrconf_ifdown(dev, dev != net->loopback_dev);
3515 break;
3516 }
3517
3518 if (idev) {
3519 rt6_mtu_change(dev, dev->mtu);
3520 idev->cnf.mtu6 = dev->mtu;
3521 break;
3522 }
3523
3524
3525 idev = ipv6_add_dev(dev);
3526 if (IS_ERR(idev))
3527 break;
3528
3529
3530 if (!(idev->if_flags & IF_READY))
3531 break;
3532
3533 run_pending = 1;
3534 fallthrough;
3535 case NETDEV_UP:
3536 case NETDEV_CHANGE:
3537 if (dev->flags & IFF_SLAVE)
3538 break;
3539
3540 if (idev && idev->cnf.disable_ipv6)
3541 break;
3542
3543 if (event == NETDEV_UP) {
3544
3545 addrconf_permanent_addr(net, dev);
3546
3547 if (!addrconf_link_ready(dev)) {
3548
3549 pr_debug("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
3550 dev->name);
3551 break;
3552 }
3553
3554 if (!idev && dev->mtu >= IPV6_MIN_MTU)
3555 idev = ipv6_add_dev(dev);
3556
3557 if (!IS_ERR_OR_NULL(idev)) {
3558 idev->if_flags |= IF_READY;
3559 run_pending = 1;
3560 }
3561 } else if (event == NETDEV_CHANGE) {
3562 if (!addrconf_link_ready(dev)) {
3563
3564 rt6_sync_down_dev(dev, event);
3565 break;
3566 }
3567
3568 if (!IS_ERR_OR_NULL(idev)) {
3569 if (idev->if_flags & IF_READY) {
3570
3571
3572
3573
3574
3575 ipv6_mc_up(idev);
3576 change_info = ptr;
3577 if (change_info->flags_changed & IFF_NOARP)
3578 addrconf_dad_run(idev, true);
3579 rt6_sync_up(dev, RTNH_F_LINKDOWN);
3580 break;
3581 }
3582 idev->if_flags |= IF_READY;
3583 }
3584
3585 pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
3586 dev->name);
3587
3588 run_pending = 1;
3589 }
3590
3591 switch (dev->type) {
3592#if IS_ENABLED(CONFIG_IPV6_SIT)
3593 case ARPHRD_SIT:
3594 addrconf_sit_config(dev);
3595 break;
3596#endif
3597#if IS_ENABLED(CONFIG_NET_IPGRE) || IS_ENABLED(CONFIG_IPV6_GRE)
3598 case ARPHRD_IP6GRE:
3599 case ARPHRD_IPGRE:
3600 addrconf_gre_config(dev);
3601 break;
3602#endif
3603 case ARPHRD_LOOPBACK:
3604 init_loopback(dev);
3605 break;
3606
3607 default:
3608 addrconf_dev_config(dev);
3609 break;
3610 }
3611
3612 if (!IS_ERR_OR_NULL(idev)) {
3613 if (run_pending)
3614 addrconf_dad_run(idev, false);
3615
3616
3617 rt6_sync_up(dev, RTNH_F_DEAD);
3618
3619
3620
3621
3622
3623
3624 if (idev->cnf.mtu6 != dev->mtu &&
3625 dev->mtu >= IPV6_MIN_MTU) {
3626 rt6_mtu_change(dev, dev->mtu);
3627 idev->cnf.mtu6 = dev->mtu;
3628 }
3629 idev->tstamp = jiffies;
3630 inet6_ifinfo_notify(RTM_NEWLINK, idev);
3631
3632
3633
3634
3635
3636 if (dev->mtu < IPV6_MIN_MTU)
3637 addrconf_ifdown(dev, dev != net->loopback_dev);
3638 }
3639 break;
3640
3641 case NETDEV_DOWN:
3642 case NETDEV_UNREGISTER:
3643
3644
3645
3646 addrconf_ifdown(dev, event != NETDEV_DOWN);
3647 break;
3648
3649 case NETDEV_CHANGENAME:
3650 if (idev) {
3651 snmp6_unregister_dev(idev);
3652 addrconf_sysctl_unregister(idev);
3653 err = addrconf_sysctl_register(idev);
3654 if (err)
3655 return notifier_from_errno(err);
3656 err = snmp6_register_dev(idev);
3657 if (err) {
3658 addrconf_sysctl_unregister(idev);
3659 return notifier_from_errno(err);
3660 }
3661 }
3662 break;
3663
3664 case NETDEV_PRE_TYPE_CHANGE:
3665 case NETDEV_POST_TYPE_CHANGE:
3666 if (idev)
3667 addrconf_type_change(dev, event);
3668 break;
3669
3670 case NETDEV_CHANGEUPPER:
3671 info = ptr;
3672
3673
3674
3675
3676 if (info->upper_dev && netif_is_l3_master(info->upper_dev))
3677 addrconf_ifdown(dev, false);
3678 }
3679
3680 return NOTIFY_OK;
3681}
3682
3683
3684
3685
3686static struct notifier_block ipv6_dev_notf = {
3687 .notifier_call = addrconf_notify,
3688 .priority = ADDRCONF_NOTIFY_PRIORITY,
3689};
3690
3691static void addrconf_type_change(struct net_device *dev, unsigned long event)
3692{
3693 struct inet6_dev *idev;
3694 ASSERT_RTNL();
3695
3696 idev = __in6_dev_get(dev);
3697
3698 if (event == NETDEV_POST_TYPE_CHANGE)
3699 ipv6_mc_remap(idev);
3700 else if (event == NETDEV_PRE_TYPE_CHANGE)
3701 ipv6_mc_unmap(idev);
3702}
3703
3704static bool addr_is_local(const struct in6_addr *addr)
3705{
3706 return ipv6_addr_type(addr) &
3707 (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_LOOPBACK);
3708}
3709
3710static int addrconf_ifdown(struct net_device *dev, bool unregister)
3711{
3712 unsigned long event = unregister ? NETDEV_UNREGISTER : NETDEV_DOWN;
3713 struct net *net = dev_net(dev);
3714 struct inet6_dev *idev;
3715 struct inet6_ifaddr *ifa, *tmp;
3716 bool keep_addr = false;
3717 int state, i;
3718
3719 ASSERT_RTNL();
3720
3721 rt6_disable_ip(dev, event);
3722
3723 idev = __in6_dev_get(dev);
3724 if (!idev)
3725 return -ENODEV;
3726
3727
3728
3729
3730
3731 if (unregister) {
3732 idev->dead = 1;
3733
3734
3735 RCU_INIT_POINTER(dev->ip6_ptr, NULL);
3736
3737
3738 snmp6_unregister_dev(idev);
3739
3740 }
3741
3742
3743
3744
3745 if (!unregister && !idev->cnf.disable_ipv6) {
3746
3747 int _keep_addr = net->ipv6.devconf_all->keep_addr_on_down;
3748
3749 if (!_keep_addr)
3750 _keep_addr = idev->cnf.keep_addr_on_down;
3751
3752 keep_addr = (_keep_addr > 0);
3753 }
3754
3755
3756 for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3757 struct hlist_head *h = &inet6_addr_lst[i];
3758
3759 spin_lock_bh(&addrconf_hash_lock);
3760restart:
3761 hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3762 if (ifa->idev == idev) {
3763 addrconf_del_dad_work(ifa);
3764
3765
3766
3767 if (!keep_addr ||
3768 !(ifa->flags & IFA_F_PERMANENT) ||
3769 addr_is_local(&ifa->addr)) {
3770 hlist_del_init_rcu(&ifa->addr_lst);
3771 goto restart;
3772 }
3773 }
3774 }
3775 spin_unlock_bh(&addrconf_hash_lock);
3776 }
3777
3778 write_lock_bh(&idev->lock);
3779
3780 addrconf_del_rs_timer(idev);
3781
3782
3783 if (!unregister)
3784 idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
3785
3786
3787 while (!list_empty(&idev->tempaddr_list)) {
3788 ifa = list_first_entry(&idev->tempaddr_list,
3789 struct inet6_ifaddr, tmp_list);
3790 list_del(&ifa->tmp_list);
3791 write_unlock_bh(&idev->lock);
3792 spin_lock_bh(&ifa->lock);
3793
3794 if (ifa->ifpub) {
3795 in6_ifa_put(ifa->ifpub);
3796 ifa->ifpub = NULL;
3797 }
3798 spin_unlock_bh(&ifa->lock);
3799 in6_ifa_put(ifa);
3800 write_lock_bh(&idev->lock);
3801 }
3802
3803 list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) {
3804 struct fib6_info *rt = NULL;
3805 bool keep;
3806
3807 addrconf_del_dad_work(ifa);
3808
3809 keep = keep_addr && (ifa->flags & IFA_F_PERMANENT) &&
3810 !addr_is_local(&ifa->addr);
3811
3812 write_unlock_bh(&idev->lock);
3813 spin_lock_bh(&ifa->lock);
3814
3815 if (keep) {
3816
3817 state = INET6_IFADDR_STATE_DEAD;
3818 ifa->state = INET6_IFADDR_STATE_PREDAD;
3819 if (!(ifa->flags & IFA_F_NODAD))
3820 ifa->flags |= IFA_F_TENTATIVE;
3821
3822 rt = ifa->rt;
3823 ifa->rt = NULL;
3824 } else {
3825 state = ifa->state;
3826 ifa->state = INET6_IFADDR_STATE_DEAD;
3827 }
3828
3829 spin_unlock_bh(&ifa->lock);
3830
3831 if (rt)
3832 ip6_del_rt(net, rt, false);
3833
3834 if (state != INET6_IFADDR_STATE_DEAD) {
3835 __ipv6_ifa_notify(RTM_DELADDR, ifa);
3836 inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3837 } else {
3838 if (idev->cnf.forwarding)
3839 addrconf_leave_anycast(ifa);
3840 addrconf_leave_solict(ifa->idev, &ifa->addr);
3841 }
3842
3843 write_lock_bh(&idev->lock);
3844 if (!keep) {
3845 list_del_rcu(&ifa->if_list);
3846 in6_ifa_put(ifa);
3847 }
3848 }
3849
3850 write_unlock_bh(&idev->lock);
3851
3852
3853 if (unregister) {
3854 ipv6_ac_destroy_dev(idev);
3855 ipv6_mc_destroy_dev(idev);
3856 } else {
3857 ipv6_mc_down(idev);
3858 }
3859
3860 idev->tstamp = jiffies;
3861 idev->ra_mtu = 0;
3862
3863
3864 if (unregister) {
3865 addrconf_sysctl_unregister(idev);
3866 neigh_parms_release(&nd_tbl, idev->nd_parms);
3867 neigh_ifdown(&nd_tbl, dev);
3868 in6_dev_put(idev);
3869 }
3870 return 0;
3871}
3872
3873static void addrconf_rs_timer(struct timer_list *t)
3874{
3875 struct inet6_dev *idev = from_timer(idev, t, rs_timer);
3876 struct net_device *dev = idev->dev;
3877 struct in6_addr lladdr;
3878
3879 write_lock(&idev->lock);
3880 if (idev->dead || !(idev->if_flags & IF_READY))
3881 goto out;
3882
3883 if (!ipv6_accept_ra(idev))
3884 goto out;
3885
3886
3887 if (idev->if_flags & IF_RA_RCVD)
3888 goto out;
3889
3890 if (idev->rs_probes++ < idev->cnf.rtr_solicits || idev->cnf.rtr_solicits < 0) {
3891 write_unlock(&idev->lock);
3892 if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3893 ndisc_send_rs(dev, &lladdr,
3894 &in6addr_linklocal_allrouters);
3895 else
3896 goto put;
3897
3898 write_lock(&idev->lock);
3899 idev->rs_interval = rfc3315_s14_backoff_update(
3900 idev->rs_interval, idev->cnf.rtr_solicit_max_interval);
3901
3902 addrconf_mod_rs_timer(idev, (idev->rs_probes ==
3903 idev->cnf.rtr_solicits) ?
3904 idev->cnf.rtr_solicit_delay :
3905 idev->rs_interval);
3906 } else {
3907
3908
3909
3910
3911 pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
3912 }
3913
3914out:
3915 write_unlock(&idev->lock);
3916put:
3917 in6_dev_put(idev);
3918}
3919
3920
3921
3922
3923static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
3924{
3925 unsigned long rand_num;
3926 struct inet6_dev *idev = ifp->idev;
3927 u64 nonce;
3928
3929 if (ifp->flags & IFA_F_OPTIMISTIC)
3930 rand_num = 0;
3931 else
3932 rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3933
3934 nonce = 0;
3935 if (idev->cnf.enhanced_dad ||
3936 dev_net(idev->dev)->ipv6.devconf_all->enhanced_dad) {
3937 do
3938 get_random_bytes(&nonce, 6);
3939 while (nonce == 0);
3940 }
3941 ifp->dad_nonce = nonce;
3942 ifp->dad_probes = idev->cnf.dad_transmits;
3943 addrconf_mod_dad_work(ifp, rand_num);
3944}
3945
3946static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
3947{
3948 struct inet6_dev *idev = ifp->idev;
3949 struct net_device *dev = idev->dev;
3950 bool bump_id, notify = false;
3951 struct net *net;
3952
3953 addrconf_join_solict(dev, &ifp->addr);
3954
3955 prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
3956
3957 read_lock_bh(&idev->lock);
3958 spin_lock(&ifp->lock);
3959 if (ifp->state == INET6_IFADDR_STATE_DEAD)
3960 goto out;
3961
3962 net = dev_net(dev);
3963 if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3964 (net->ipv6.devconf_all->accept_dad < 1 &&
3965 idev->cnf.accept_dad < 1) ||
3966 !(ifp->flags&IFA_F_TENTATIVE) ||
3967 ifp->flags & IFA_F_NODAD) {
3968 bool send_na = false;
3969
3970 if (ifp->flags & IFA_F_TENTATIVE &&
3971 !(ifp->flags & IFA_F_OPTIMISTIC))
3972 send_na = true;
3973 bump_id = ifp->flags & IFA_F_TENTATIVE;
3974 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3975 spin_unlock(&ifp->lock);
3976 read_unlock_bh(&idev->lock);
3977
3978 addrconf_dad_completed(ifp, bump_id, send_na);
3979 return;
3980 }
3981
3982 if (!(idev->if_flags & IF_READY)) {
3983 spin_unlock(&ifp->lock);
3984 read_unlock_bh(&idev->lock);
3985
3986
3987
3988
3989
3990 in6_ifa_hold(ifp);
3991 addrconf_dad_stop(ifp, 0);
3992 return;
3993 }
3994
3995
3996
3997
3998
3999 if (ifp->flags & IFA_F_OPTIMISTIC) {
4000 ip6_ins_rt(net, ifp->rt);
4001 if (ipv6_use_optimistic_addr(net, idev)) {
4002
4003
4004
4005 notify = true;
4006 }
4007 }
4008
4009 addrconf_dad_kick(ifp);
4010out:
4011 spin_unlock(&ifp->lock);
4012 read_unlock_bh(&idev->lock);
4013 if (notify)
4014 ipv6_ifa_notify(RTM_NEWADDR, ifp);
4015}
4016
4017static void addrconf_dad_start(struct inet6_ifaddr *ifp)
4018{
4019 bool begin_dad = false;
4020
4021 spin_lock_bh(&ifp->lock);
4022 if (ifp->state != INET6_IFADDR_STATE_DEAD) {
4023 ifp->state = INET6_IFADDR_STATE_PREDAD;
4024 begin_dad = true;
4025 }
4026 spin_unlock_bh(&ifp->lock);
4027
4028 if (begin_dad)
4029 addrconf_mod_dad_work(ifp, 0);
4030}
4031
4032static void addrconf_dad_work(struct work_struct *w)
4033{
4034 struct inet6_ifaddr *ifp = container_of(to_delayed_work(w),
4035 struct inet6_ifaddr,
4036 dad_work);
4037 struct inet6_dev *idev = ifp->idev;
4038 bool bump_id, disable_ipv6 = false;
4039 struct in6_addr mcaddr;
4040
4041 enum {
4042 DAD_PROCESS,
4043 DAD_BEGIN,
4044 DAD_ABORT,
4045 } action = DAD_PROCESS;
4046
4047 rtnl_lock();
4048
4049 spin_lock_bh(&ifp->lock);
4050 if (ifp->state == INET6_IFADDR_STATE_PREDAD) {
4051 action = DAD_BEGIN;
4052 ifp->state = INET6_IFADDR_STATE_DAD;
4053 } else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) {
4054 action = DAD_ABORT;
4055 ifp->state = INET6_IFADDR_STATE_POSTDAD;
4056
4057 if ((dev_net(idev->dev)->ipv6.devconf_all->accept_dad > 1 ||
4058 idev->cnf.accept_dad > 1) &&
4059 !idev->cnf.disable_ipv6 &&
4060 !(ifp->flags & IFA_F_STABLE_PRIVACY)) {
4061 struct in6_addr addr;
4062
4063 addr.s6_addr32[0] = htonl(0xfe800000);
4064 addr.s6_addr32[1] = 0;
4065
4066 if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
4067 ipv6_addr_equal(&ifp->addr, &addr)) {
4068
4069 idev->cnf.disable_ipv6 = 1;
4070
4071 pr_info("%s: IPv6 being disabled!\n",
4072 ifp->idev->dev->name);
4073 disable_ipv6 = true;
4074 }
4075 }
4076 }
4077 spin_unlock_bh(&ifp->lock);
4078
4079 if (action == DAD_BEGIN) {
4080 addrconf_dad_begin(ifp);
4081 goto out;
4082 } else if (action == DAD_ABORT) {
4083 in6_ifa_hold(ifp);
4084 addrconf_dad_stop(ifp, 1);
4085 if (disable_ipv6)
4086 addrconf_ifdown(idev->dev, false);
4087 goto out;
4088 }
4089
4090 if (!ifp->dad_probes && addrconf_dad_end(ifp))
4091 goto out;
4092
4093 write_lock_bh(&idev->lock);
4094 if (idev->dead || !(idev->if_flags & IF_READY)) {
4095 write_unlock_bh(&idev->lock);
4096 goto out;
4097 }
4098
4099 spin_lock(&ifp->lock);
4100 if (ifp->state == INET6_IFADDR_STATE_DEAD) {
4101 spin_unlock(&ifp->lock);
4102 write_unlock_bh(&idev->lock);
4103 goto out;
4104 }
4105
4106 if (ifp->dad_probes == 0) {
4107 bool send_na = false;
4108
4109
4110
4111
4112
4113 if (ifp->flags & IFA_F_TENTATIVE &&
4114 !(ifp->flags & IFA_F_OPTIMISTIC))
4115 send_na = true;
4116 bump_id = ifp->flags & IFA_F_TENTATIVE;
4117 ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
4118 spin_unlock(&ifp->lock);
4119 write_unlock_bh(&idev->lock);
4120
4121 addrconf_dad_completed(ifp, bump_id, send_na);
4122
4123 goto out;
4124 }
4125
4126 ifp->dad_probes--;
4127 addrconf_mod_dad_work(ifp,
4128 max(NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME),
4129 HZ/100));
4130 spin_unlock(&ifp->lock);
4131 write_unlock_bh(&idev->lock);
4132
4133
4134 addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
4135 ndisc_send_ns(ifp->idev->dev, &ifp->addr, &mcaddr, &in6addr_any,
4136 ifp->dad_nonce);
4137out:
4138 in6_ifa_put(ifp);
4139 rtnl_unlock();
4140}
4141
4142
4143static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp)
4144{
4145 struct inet6_ifaddr *ifpiter;
4146 struct inet6_dev *idev = ifp->idev;
4147
4148 list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
4149 if (ifpiter->scope > IFA_LINK)
4150 break;
4151 if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
4152 (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
4153 IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
4154 IFA_F_PERMANENT)
4155 return false;
4156 }
4157 return true;
4158}
4159
4160static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
4161 bool send_na)
4162{
4163 struct net_device *dev = ifp->idev->dev;
4164 struct in6_addr lladdr;
4165 bool send_rs, send_mld;
4166
4167 addrconf_del_dad_work(ifp);
4168
4169
4170
4171
4172
4173 ipv6_ifa_notify(RTM_NEWADDR, ifp);
4174
4175
4176
4177
4178
4179 read_lock_bh(&ifp->idev->lock);
4180 send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
4181 send_rs = send_mld &&
4182 ipv6_accept_ra(ifp->idev) &&
4183 ifp->idev->cnf.rtr_solicits != 0 &&
4184 (dev->flags&IFF_LOOPBACK) == 0;
4185 read_unlock_bh(&ifp->idev->lock);
4186
4187
4188
4189
4190 if (send_mld)
4191 ipv6_mc_dad_complete(ifp->idev);
4192
4193
4194 if (send_na &&
4195 (ifp->idev->cnf.ndisc_notify ||
4196 dev_net(dev)->ipv6.devconf_all->ndisc_notify)) {
4197 ndisc_send_na(dev, &in6addr_linklocal_allnodes, &ifp->addr,
4198 !!ifp->idev->cnf.forwarding,
4199 false, true,
4200 true);
4201 }
4202
4203 if (send_rs) {
4204
4205
4206
4207
4208
4209 if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
4210 return;
4211 ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
4212
4213 write_lock_bh(&ifp->idev->lock);
4214 spin_lock(&ifp->lock);
4215 ifp->idev->rs_interval = rfc3315_s14_backoff_init(
4216 ifp->idev->cnf.rtr_solicit_interval);
4217 ifp->idev->rs_probes = 1;
4218 ifp->idev->if_flags |= IF_RS_SENT;
4219 addrconf_mod_rs_timer(ifp->idev, ifp->idev->rs_interval);
4220 spin_unlock(&ifp->lock);
4221 write_unlock_bh(&ifp->idev->lock);
4222 }
4223
4224 if (bump_id)
4225 rt_genid_bump_ipv6(dev_net(dev));
4226
4227
4228
4229
4230 if (ifp->flags & IFA_F_TEMPORARY)
4231 addrconf_verify_rtnl();
4232}
4233
4234static void addrconf_dad_run(struct inet6_dev *idev, bool restart)
4235{
4236 struct inet6_ifaddr *ifp;
4237
4238 read_lock_bh(&idev->lock);
4239 list_for_each_entry(ifp, &idev->addr_list, if_list) {
4240 spin_lock(&ifp->lock);
4241 if ((ifp->flags & IFA_F_TENTATIVE &&
4242 ifp->state == INET6_IFADDR_STATE_DAD) || restart) {
4243 if (restart)
4244 ifp->state = INET6_IFADDR_STATE_PREDAD;
4245 addrconf_dad_kick(ifp);
4246 }
4247 spin_unlock(&ifp->lock);
4248 }
4249 read_unlock_bh(&idev->lock);
4250}
4251
4252#ifdef CONFIG_PROC_FS
4253struct if6_iter_state {
4254 struct seq_net_private p;
4255 int bucket;
4256 int offset;
4257};
4258
4259static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
4260{
4261 struct if6_iter_state *state = seq->private;
4262 struct net *net = seq_file_net(seq);
4263 struct inet6_ifaddr *ifa = NULL;
4264 int p = 0;
4265
4266
4267 if (pos == 0) {
4268 state->bucket = 0;
4269 state->offset = 0;
4270 }
4271
4272 for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
4273 hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket],
4274 addr_lst) {
4275 if (!net_eq(dev_net(ifa->idev->dev), net))
4276 continue;
4277
4278 if (p < state->offset) {
4279 p++;
4280 continue;
4281 }
4282 return ifa;
4283 }
4284
4285
4286 state->offset = 0;
4287 p = 0;
4288 }
4289 return NULL;
4290}
4291
4292static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
4293 struct inet6_ifaddr *ifa)
4294{
4295 struct if6_iter_state *state = seq->private;
4296 struct net *net = seq_file_net(seq);
4297
4298 hlist_for_each_entry_continue_rcu(ifa, addr_lst) {
4299 if (!net_eq(dev_net(ifa->idev->dev), net))
4300 continue;
4301 state->offset++;
4302 return ifa;
4303 }
4304
4305 state->offset = 0;
4306 while (++state->bucket < IN6_ADDR_HSIZE) {
4307 hlist_for_each_entry_rcu(ifa,
4308 &inet6_addr_lst[state->bucket], addr_lst) {
4309 if (!net_eq(dev_net(ifa->idev->dev), net))
4310 continue;
4311 return ifa;
4312 }
4313 }
4314
4315 return NULL;
4316}
4317
4318static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
4319 __acquires(rcu)
4320{
4321 rcu_read_lock();
4322 return if6_get_first(seq, *pos);
4323}
4324
4325static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
4326{
4327 struct inet6_ifaddr *ifa;
4328
4329 ifa = if6_get_next(seq, v);
4330 ++*pos;
4331 return ifa;
4332}
4333
4334static void if6_seq_stop(struct seq_file *seq, void *v)
4335 __releases(rcu)
4336{
4337 rcu_read_unlock();
4338}
4339
4340static int if6_seq_show(struct seq_file *seq, void *v)
4341{
4342 struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
4343 seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
4344 &ifp->addr,
4345 ifp->idev->dev->ifindex,
4346 ifp->prefix_len,
4347 ifp->scope,
4348 (u8) ifp->flags,
4349 ifp->idev->dev->name);
4350 return 0;
4351}
4352
4353static const struct seq_operations if6_seq_ops = {
4354 .start = if6_seq_start,
4355 .next = if6_seq_next,
4356 .show = if6_seq_show,
4357 .stop = if6_seq_stop,
4358};
4359
4360static int __net_init if6_proc_net_init(struct net *net)
4361{
4362 if (!proc_create_net("if_inet6", 0444, net->proc_net, &if6_seq_ops,
4363 sizeof(struct if6_iter_state)))
4364 return -ENOMEM;
4365 return 0;
4366}
4367
4368static void __net_exit if6_proc_net_exit(struct net *net)
4369{
4370 remove_proc_entry("if_inet6", net->proc_net);
4371}
4372
4373static struct pernet_operations if6_proc_net_ops = {
4374 .init = if6_proc_net_init,
4375 .exit = if6_proc_net_exit,
4376};
4377
4378int __init if6_proc_init(void)
4379{
4380 return register_pernet_subsys(&if6_proc_net_ops);
4381}
4382
4383void if6_proc_exit(void)
4384{
4385 unregister_pernet_subsys(&if6_proc_net_ops);
4386}
4387#endif
4388
4389#if IS_ENABLED(CONFIG_IPV6_MIP6)
4390
4391int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
4392{
4393 unsigned int hash = inet6_addr_hash(net, addr);
4394 struct inet6_ifaddr *ifp = NULL;
4395 int ret = 0;
4396
4397 rcu_read_lock();
4398 hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
4399 if (!net_eq(dev_net(ifp->idev->dev), net))
4400 continue;
4401 if (ipv6_addr_equal(&ifp->addr, addr) &&
4402 (ifp->flags & IFA_F_HOMEADDRESS)) {
4403 ret = 1;
4404 break;
4405 }
4406 }
4407 rcu_read_unlock();
4408 return ret;
4409}
4410#endif
4411
4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422int ipv6_chk_rpl_srh_loop(struct net *net, const struct in6_addr *segs,
4423 unsigned char nsegs)
4424{
4425 const struct in6_addr *addr;
4426 int i, ret = 0, found = 0;
4427 struct inet6_ifaddr *ifp;
4428 bool separated = false;
4429 unsigned int hash;
4430 bool hash_found;
4431
4432 rcu_read_lock();
4433 for (i = 0; i < nsegs; i++) {
4434 addr = &segs[i];
4435 hash = inet6_addr_hash(net, addr);
4436
4437 hash_found = false;
4438 hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
4439 if (!net_eq(dev_net(ifp->idev->dev), net))
4440 continue;
4441
4442 if (ipv6_addr_equal(&ifp->addr, addr)) {
4443 hash_found = true;
4444 break;
4445 }
4446 }
4447
4448 if (hash_found) {
4449 if (found > 1 && separated) {
4450 ret = 1;
4451 break;
4452 }
4453
4454 separated = false;
4455 found++;
4456 } else {
4457 separated = true;
4458 }
4459 }
4460 rcu_read_unlock();
4461
4462 return ret;
4463}
4464
4465
4466
4467
4468
4469static void addrconf_verify_rtnl(void)
4470{
4471 unsigned long now, next, next_sec, next_sched;
4472 struct inet6_ifaddr *ifp;
4473 int i;
4474
4475 ASSERT_RTNL();
4476
4477 rcu_read_lock_bh();
4478 now = jiffies;
4479 next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
4480
4481 cancel_delayed_work(&addr_chk_work);
4482
4483 for (i = 0; i < IN6_ADDR_HSIZE; i++) {
4484restart:
4485 hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
4486 unsigned long age;
4487
4488
4489
4490
4491
4492 if ((ifp->flags & IFA_F_PERMANENT) &&
4493 (ifp->prefered_lft == INFINITY_LIFE_TIME))
4494 continue;
4495
4496 spin_lock(&ifp->lock);
4497
4498 age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
4499
4500 if (ifp->valid_lft != INFINITY_LIFE_TIME &&
4501 age >= ifp->valid_lft) {
4502 spin_unlock(&ifp->lock);
4503 in6_ifa_hold(ifp);
4504 rcu_read_unlock_bh();
4505 ipv6_del_addr(ifp);
4506 rcu_read_lock_bh();
4507 goto restart;
4508 } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
4509 spin_unlock(&ifp->lock);
4510 continue;
4511 } else if (age >= ifp->prefered_lft) {
4512
4513 int deprecate = 0;
4514
4515 if (!(ifp->flags&IFA_F_DEPRECATED)) {
4516 deprecate = 1;
4517 ifp->flags |= IFA_F_DEPRECATED;
4518 }
4519
4520 if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
4521 (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
4522 next = ifp->tstamp + ifp->valid_lft * HZ;
4523
4524 spin_unlock(&ifp->lock);
4525
4526 if (deprecate) {
4527 in6_ifa_hold(ifp);
4528
4529 ipv6_ifa_notify(0, ifp);
4530 in6_ifa_put(ifp);
4531 goto restart;
4532 }
4533 } else if ((ifp->flags&IFA_F_TEMPORARY) &&
4534 !(ifp->flags&IFA_F_TENTATIVE)) {
4535 unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
4536 ifp->idev->cnf.dad_transmits *
4537 max(NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME), HZ/100) / HZ;
4538
4539 if (age >= ifp->prefered_lft - regen_advance) {
4540 struct inet6_ifaddr *ifpub = ifp->ifpub;
4541 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4542 next = ifp->tstamp + ifp->prefered_lft * HZ;
4543 if (!ifp->regen_count && ifpub) {
4544 ifp->regen_count++;
4545 in6_ifa_hold(ifp);
4546 in6_ifa_hold(ifpub);
4547 spin_unlock(&ifp->lock);
4548
4549 spin_lock(&ifpub->lock);
4550 ifpub->regen_count = 0;
4551 spin_unlock(&ifpub->lock);
4552 rcu_read_unlock_bh();
4553 ipv6_create_tempaddr(ifpub, true);
4554 in6_ifa_put(ifpub);
4555 in6_ifa_put(ifp);
4556 rcu_read_lock_bh();
4557 goto restart;
4558 }
4559 } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
4560 next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
4561 spin_unlock(&ifp->lock);
4562 } else {
4563
4564 if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
4565 next = ifp->tstamp + ifp->prefered_lft * HZ;
4566 spin_unlock(&ifp->lock);
4567 }
4568 }
4569 }
4570
4571 next_sec = round_jiffies_up(next);
4572 next_sched = next;
4573
4574
4575 if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
4576 next_sched = next_sec;
4577
4578
4579 if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
4580 next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
4581
4582 pr_debug("now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
4583 now, next, next_sec, next_sched);
4584 mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
4585 rcu_read_unlock_bh();
4586}
4587
4588static void addrconf_verify_work(struct work_struct *w)
4589{
4590 rtnl_lock();
4591 addrconf_verify_rtnl();
4592 rtnl_unlock();
4593}
4594
4595static void addrconf_verify(void)
4596{
4597 mod_delayed_work(addrconf_wq, &addr_chk_work, 0);
4598}
4599
4600static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
4601 struct in6_addr **peer_pfx)
4602{
4603 struct in6_addr *pfx = NULL;
4604
4605 *peer_pfx = NULL;
4606
4607 if (addr)
4608 pfx = nla_data(addr);
4609
4610 if (local) {
4611 if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
4612 *peer_pfx = pfx;
4613 pfx = nla_data(local);
4614 }
4615
4616 return pfx;
4617}
4618
4619static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
4620 [IFA_ADDRESS] = { .len = sizeof(struct in6_addr) },
4621 [IFA_LOCAL] = { .len = sizeof(struct in6_addr) },
4622 [IFA_CACHEINFO] = { .len = sizeof(struct ifa_cacheinfo) },
4623 [IFA_FLAGS] = { .len = sizeof(u32) },
4624 [IFA_RT_PRIORITY] = { .len = sizeof(u32) },
4625 [IFA_TARGET_NETNSID] = { .type = NLA_S32 },
4626};
4627
4628static int
4629inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
4630 struct netlink_ext_ack *extack)
4631{
4632 struct net *net = sock_net(skb->sk);
4633 struct ifaddrmsg *ifm;
4634 struct nlattr *tb[IFA_MAX+1];
4635 struct in6_addr *pfx, *peer_pfx;
4636 u32 ifa_flags;
4637 int err;
4638
4639 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
4640 ifa_ipv6_policy, extack);
4641 if (err < 0)
4642 return err;
4643
4644 ifm = nlmsg_data(nlh);
4645 pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4646 if (!pfx)
4647 return -EINVAL;
4648
4649 ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
4650
4651
4652 ifa_flags &= IFA_F_MANAGETEMPADDR;
4653
4654 return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx,
4655 ifm->ifa_prefixlen);
4656}
4657
4658static int modify_prefix_route(struct inet6_ifaddr *ifp,
4659 unsigned long expires, u32 flags,
4660 bool modify_peer)
4661{
4662 struct fib6_info *f6i;
4663 u32 prio;
4664
4665 f6i = addrconf_get_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
4666 ifp->prefix_len,
4667 ifp->idev->dev, 0, RTF_DEFAULT, true);
4668 if (!f6i)
4669 return -ENOENT;
4670
4671 prio = ifp->rt_priority ? : IP6_RT_PRIO_ADDRCONF;
4672 if (f6i->fib6_metric != prio) {
4673
4674 ip6_del_rt(dev_net(ifp->idev->dev), f6i, false);
4675
4676
4677 addrconf_prefix_route(modify_peer ? &ifp->peer_addr : &ifp->addr,
4678 ifp->prefix_len,
4679 ifp->rt_priority, ifp->idev->dev,
4680 expires, flags, GFP_KERNEL);
4681 } else {
4682 if (!expires)
4683 fib6_clean_expires(f6i);
4684 else
4685 fib6_set_expires(f6i, expires);
4686
4687 fib6_info_release(f6i);
4688 }
4689
4690 return 0;
4691}
4692
4693static int inet6_addr_modify(struct inet6_ifaddr *ifp, struct ifa6_config *cfg)
4694{
4695 u32 flags;
4696 clock_t expires;
4697 unsigned long timeout;
4698 bool was_managetempaddr;
4699 bool had_prefixroute;
4700 bool new_peer = false;
4701
4702 ASSERT_RTNL();
4703
4704 if (!cfg->valid_lft || cfg->preferred_lft > cfg->valid_lft)
4705 return -EINVAL;
4706
4707 if (cfg->ifa_flags & IFA_F_MANAGETEMPADDR &&
4708 (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
4709 return -EINVAL;
4710
4711 if (!(ifp->flags & IFA_F_TENTATIVE) || ifp->flags & IFA_F_DADFAILED)
4712 cfg->ifa_flags &= ~IFA_F_OPTIMISTIC;
4713
4714 timeout = addrconf_timeout_fixup(cfg->valid_lft, HZ);
4715 if (addrconf_finite_timeout(timeout)) {
4716 expires = jiffies_to_clock_t(timeout * HZ);
4717 cfg->valid_lft = timeout;
4718 flags = RTF_EXPIRES;
4719 } else {
4720 expires = 0;
4721 flags = 0;
4722 cfg->ifa_flags |= IFA_F_PERMANENT;
4723 }
4724
4725 timeout = addrconf_timeout_fixup(cfg->preferred_lft, HZ);
4726 if (addrconf_finite_timeout(timeout)) {
4727 if (timeout == 0)
4728 cfg->ifa_flags |= IFA_F_DEPRECATED;
4729 cfg->preferred_lft = timeout;
4730 }
4731
4732 if (cfg->peer_pfx &&
4733 memcmp(&ifp->peer_addr, cfg->peer_pfx, sizeof(struct in6_addr))) {
4734 if (!ipv6_addr_any(&ifp->peer_addr))
4735 cleanup_prefix_route(ifp, expires, true, true);
4736 new_peer = true;
4737 }
4738
4739 spin_lock_bh(&ifp->lock);
4740 was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
4741 had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
4742 !(ifp->flags & IFA_F_NOPREFIXROUTE);
4743 ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
4744 IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
4745 IFA_F_NOPREFIXROUTE);
4746 ifp->flags |= cfg->ifa_flags;
4747 ifp->tstamp = jiffies;
4748 ifp->valid_lft = cfg->valid_lft;
4749 ifp->prefered_lft = cfg->preferred_lft;
4750
4751 if (cfg->rt_priority && cfg->rt_priority != ifp->rt_priority)
4752 ifp->rt_priority = cfg->rt_priority;
4753
4754 if (new_peer)
4755 ifp->peer_addr = *cfg->peer_pfx;
4756
4757 spin_unlock_bh(&ifp->lock);
4758 if (!(ifp->flags&IFA_F_TENTATIVE))
4759 ipv6_ifa_notify(0, ifp);
4760
4761 if (!(cfg->ifa_flags & IFA_F_NOPREFIXROUTE)) {
4762 int rc = -ENOENT;
4763
4764 if (had_prefixroute)
4765 rc = modify_prefix_route(ifp, expires, flags, false);
4766
4767
4768 if (rc == -ENOENT) {
4769 addrconf_prefix_route(&ifp->addr, ifp->prefix_len,
4770 ifp->rt_priority, ifp->idev->dev,
4771 expires, flags, GFP_KERNEL);
4772 }
4773
4774 if (had_prefixroute && !ipv6_addr_any(&ifp->peer_addr))
4775 rc = modify_prefix_route(ifp, expires, flags, true);
4776
4777 if (rc == -ENOENT && !ipv6_addr_any(&ifp->peer_addr)) {
4778 addrconf_prefix_route(&ifp->peer_addr, ifp->prefix_len,
4779 ifp->rt_priority, ifp->idev->dev,
4780 expires, flags, GFP_KERNEL);
4781 }
4782 } else if (had_prefixroute) {
4783 enum cleanup_prefix_rt_t action;
4784 unsigned long rt_expires;
4785
4786 write_lock_bh(&ifp->idev->lock);
4787 action = check_cleanup_prefix_route(ifp, &rt_expires);
4788 write_unlock_bh(&ifp->idev->lock);
4789
4790 if (action != CLEANUP_PREFIX_RT_NOP) {
4791 cleanup_prefix_route(ifp, rt_expires,
4792 action == CLEANUP_PREFIX_RT_DEL, false);
4793 }
4794 }
4795
4796 if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
4797 if (was_managetempaddr &&
4798 !(ifp->flags & IFA_F_MANAGETEMPADDR)) {
4799 cfg->valid_lft = 0;
4800 cfg->preferred_lft = 0;
4801 }
4802 manage_tempaddrs(ifp->idev, ifp, cfg->valid_lft,
4803 cfg->preferred_lft, !was_managetempaddr,
4804 jiffies);
4805 }
4806
4807 addrconf_verify_rtnl();
4808
4809 return 0;
4810}
4811
4812static int
4813inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
4814 struct netlink_ext_ack *extack)
4815{
4816 struct net *net = sock_net(skb->sk);
4817 struct ifaddrmsg *ifm;
4818 struct nlattr *tb[IFA_MAX+1];
4819 struct in6_addr *peer_pfx;
4820 struct inet6_ifaddr *ifa;
4821 struct net_device *dev;
4822 struct inet6_dev *idev;
4823 struct ifa6_config cfg;
4824 int err;
4825
4826 err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
4827 ifa_ipv6_policy, extack);
4828 if (err < 0)
4829 return err;
4830
4831 memset(&cfg, 0, sizeof(cfg));
4832
4833 ifm = nlmsg_data(nlh);
4834 cfg.pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
4835 if (!cfg.pfx)
4836 return -EINVAL;
4837
4838 cfg.peer_pfx = peer_pfx;
4839 cfg.plen = ifm->ifa_prefixlen;
4840 if (tb[IFA_RT_PRIORITY])
4841 cfg.rt_priority = nla_get_u32(tb[IFA_RT_PRIORITY]);
4842
4843 cfg.valid_lft = INFINITY_LIFE_TIME;
4844 cfg.preferred_lft = INFINITY_LIFE_TIME;
4845
4846 if (tb[IFA_CACHEINFO]) {
4847 struct ifa_cacheinfo *ci;
4848
4849 ci = nla_data(tb[IFA_CACHEINFO]);
4850 cfg.valid_lft = ci->ifa_valid;
4851 cfg.preferred_lft = ci->ifa_prefered;
4852 }
4853
4854 dev = __dev_get_by_index(net, ifm->ifa_index);
4855 if (!dev)
4856 return -ENODEV;
4857
4858 if (tb[IFA_FLAGS])
4859 cfg.ifa_flags = nla_get_u32(tb[IFA_FLAGS]);
4860 else
4861 cfg.ifa_flags = ifm->ifa_flags;
4862
4863
4864 cfg.ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS |
4865 IFA_F_MANAGETEMPADDR | IFA_F_NOPREFIXROUTE |
4866 IFA_F_MCAUTOJOIN | IFA_F_OPTIMISTIC;
4867
4868 idev = ipv6_find_idev(dev);
4869 if (IS_ERR(idev))
4870 return PTR_ERR(idev);
4871
4872 if (!ipv6_allow_optimistic_dad(net, idev))
4873 cfg.ifa_flags &= ~IFA_F_OPTIMISTIC;
4874
4875 if (cfg.ifa_flags & IFA_F_NODAD &&
4876 cfg.ifa_flags & IFA_F_OPTIMISTIC) {
4877 NL_SET_ERR_MSG(extack, "IFA_F_NODAD and IFA_F_OPTIMISTIC are mutually exclusive");
4878 return -EINVAL;
4879 }
4880
4881 ifa = ipv6_get_ifaddr(net, cfg.pfx, dev, 1);
4882 if (!ifa) {
4883
4884
4885
4886
4887 return inet6_addr_add(net, ifm->ifa_index, &cfg, extack);
4888 }
4889
4890 if (nlh->nlmsg_flags & NLM_F_EXCL ||
4891 !(nlh->nlmsg_flags & NLM_F_REPLACE))
4892 err = -EEXIST;
4893 else
4894 err = inet6_addr_modify(ifa, &cfg);
4895
4896 in6_ifa_put(ifa);
4897
4898 return err;
4899}
4900
4901static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
4902 u8 scope, int ifindex)
4903{
4904 struct ifaddrmsg *ifm;
4905
4906 ifm = nlmsg_data(nlh);
4907 ifm->ifa_family = AF_INET6;
4908 ifm->ifa_prefixlen = prefixlen;
4909 ifm->ifa_flags = flags;
4910 ifm->ifa_scope = scope;
4911 ifm->ifa_index = ifindex;
4912}
4913
4914static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
4915 unsigned long tstamp, u32 preferred, u32 valid)
4916{
4917 struct ifa_cacheinfo ci;
4918
4919 ci.cstamp = cstamp_delta(cstamp);
4920 ci.tstamp = cstamp_delta(tstamp);
4921 ci.ifa_prefered = preferred;
4922 ci.ifa_valid = valid;
4923
4924 return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
4925}
4926
4927static inline int rt_scope(int ifa_scope)
4928{
4929 if (ifa_scope & IFA_HOST)
4930 return RT_SCOPE_HOST;
4931 else if (ifa_scope & IFA_LINK)
4932 return RT_SCOPE_LINK;
4933 else if (ifa_scope & IFA_SITE)
4934 return RT_SCOPE_SITE;
4935 else
4936 return RT_SCOPE_UNIVERSE;
4937}
4938
4939static inline int inet6_ifaddr_msgsize(void)
4940{
4941 return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
4942 + nla_total_size(16)
4943 + nla_total_size(16)
4944 + nla_total_size(sizeof(struct ifa_cacheinfo))
4945 + nla_total_size(4)
4946 + nla_total_size(4) ;
4947}
4948
4949enum addr_type_t {
4950 UNICAST_ADDR,
4951 MULTICAST_ADDR,
4952 ANYCAST_ADDR,
4953};
4954
4955struct inet6_fill_args {
4956 u32 portid;
4957 u32 seq;
4958 int event;
4959 unsigned int flags;
4960 int netnsid;
4961 int ifindex;
4962 enum addr_type_t type;
4963};
4964
4965static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
4966 struct inet6_fill_args *args)
4967{
4968 struct nlmsghdr *nlh;
4969 u32 preferred, valid;
4970
4971 nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
4972 sizeof(struct ifaddrmsg), args->flags);
4973 if (!nlh)
4974 return -EMSGSIZE;
4975
4976 put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
4977 ifa->idev->dev->ifindex);
4978
4979 if (args->netnsid >= 0 &&
4980 nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid))
4981 goto error;
4982
4983 if (!((ifa->flags&IFA_F_PERMANENT) &&
4984 (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
4985 preferred = ifa->prefered_lft;
4986 valid = ifa->valid_lft;
4987 if (preferred != INFINITY_LIFE_TIME) {
4988 long tval = (jiffies - ifa->tstamp)/HZ;
4989 if (preferred > tval)
4990 preferred -= tval;
4991 else
4992 preferred = 0;
4993 if (valid != INFINITY_LIFE_TIME) {
4994 if (valid > tval)
4995 valid -= tval;
4996 else
4997 valid = 0;
4998 }
4999 }
5000 } else {
5001 preferred = INFINITY_LIFE_TIME;
5002 valid = INFINITY_LIFE_TIME;
5003 }
5004
5005 if (!ipv6_addr_any(&ifa->peer_addr)) {
5006 if (nla_put_in6_addr(skb, IFA_LOCAL, &ifa->addr) < 0 ||
5007 nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->peer_addr) < 0)
5008 goto error;
5009 } else
5010 if (nla_put_in6_addr(skb, IFA_ADDRESS, &ifa->addr) < 0)
5011 goto error;
5012
5013 if (ifa->rt_priority &&
5014 nla_put_u32(skb, IFA_RT_PRIORITY, ifa->rt_priority))
5015 goto error;
5016
5017 if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
5018 goto error;
5019
5020 if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
5021 goto error;
5022
5023 nlmsg_end(skb, nlh);
5024 return 0;
5025
5026error:
5027 nlmsg_cancel(skb, nlh);
5028 return -EMSGSIZE;
5029}
5030
5031static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
5032 struct inet6_fill_args *args)
5033{
5034 struct nlmsghdr *nlh;
5035 u8 scope = RT_SCOPE_UNIVERSE;
5036 int ifindex = ifmca->idev->dev->ifindex;
5037
5038 if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
5039 scope = RT_SCOPE_SITE;
5040
5041 nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
5042 sizeof(struct ifaddrmsg), args->flags);
5043 if (!nlh)
5044 return -EMSGSIZE;
5045
5046 if (args->netnsid >= 0 &&
5047 nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid)) {
5048 nlmsg_cancel(skb, nlh);
5049 return -EMSGSIZE;
5050 }
5051
5052 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
5053 if (nla_put_in6_addr(skb, IFA_MULTICAST, &ifmca->mca_addr) < 0 ||
5054 put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
5055 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
5056 nlmsg_cancel(skb, nlh);
5057 return -EMSGSIZE;
5058 }
5059
5060 nlmsg_end(skb, nlh);
5061 return 0;
5062}
5063
5064static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
5065 struct inet6_fill_args *args)
5066{
5067 struct net_device *dev = fib6_info_nh_dev(ifaca->aca_rt);
5068 int ifindex = dev ? dev->ifindex : 1;
5069 struct nlmsghdr *nlh;
5070 u8 scope = RT_SCOPE_UNIVERSE;
5071
5072 if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
5073 scope = RT_SCOPE_SITE;
5074
5075 nlh = nlmsg_put(skb, args->portid, args->seq, args->event,
5076 sizeof(struct ifaddrmsg), args->flags);
5077 if (!nlh)
5078 return -EMSGSIZE;
5079
5080 if (args->netnsid >= 0 &&
5081 nla_put_s32(skb, IFA_TARGET_NETNSID, args->netnsid)) {
5082 nlmsg_cancel(skb, nlh);
5083 return -EMSGSIZE;
5084 }
5085
5086 put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
5087 if (nla_put_in6_addr(skb, IFA_ANYCAST, &ifaca->aca_addr) < 0 ||
5088 put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
5089 INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
5090 nlmsg_cancel(skb, nlh);
5091 return -EMSGSIZE;
5092 }
5093
5094 nlmsg_end(skb, nlh);
5095 return 0;
5096}
5097
5098
5099static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
5100 struct netlink_callback *cb, int s_ip_idx,
5101 struct inet6_fill_args *fillargs)
5102{
5103 struct ifmcaddr6 *ifmca;
5104 struct ifacaddr6 *ifaca;
5105 int ip_idx = 0;
5106 int err = 1;
5107
5108 read_lock_bh(&idev->lock);
5109 switch (fillargs->type) {
5110 case UNICAST_ADDR: {
5111 struct inet6_ifaddr *ifa;
5112 fillargs->event = RTM_NEWADDR;
5113
5114
5115 list_for_each_entry(ifa, &idev->addr_list, if_list) {
5116 if (ip_idx < s_ip_idx)
5117 goto next;
5118 err = inet6_fill_ifaddr(skb, ifa, fillargs);
5119 if (err < 0)
5120 break;
5121 nl_dump_check_consistent(cb, nlmsg_hdr(skb));
5122next:
5123 ip_idx++;
5124 }
5125 break;
5126 }
5127 case MULTICAST_ADDR:
5128 read_unlock_bh(&idev->lock);
5129 fillargs->event = RTM_GETMULTICAST;
5130
5131
5132 for (ifmca = rcu_dereference(idev->mc_list);
5133 ifmca;
5134 ifmca = rcu_dereference(ifmca->next), ip_idx++) {
5135 if (ip_idx < s_ip_idx)
5136 continue;
5137 err = inet6_fill_ifmcaddr(skb, ifmca, fillargs);
5138 if (err < 0)
5139 break;
5140 }
5141 read_lock_bh(&idev->lock);
5142 break;
5143 case ANYCAST_ADDR:
5144 fillargs->event = RTM_GETANYCAST;
5145
5146 for (ifaca = idev->ac_list; ifaca;
5147 ifaca = ifaca->aca_next, ip_idx++) {
5148 if (ip_idx < s_ip_idx)
5149 continue;
5150 err = inet6_fill_ifacaddr(skb, ifaca, fillargs);
5151 if (err < 0)
5152 break;
5153 }
5154 break;
5155 default:
5156 break;
5157 }
5158 read_unlock_bh(&idev->lock);
5159 cb->args[2] = ip_idx;
5160 return err;
5161}
5162
5163static int inet6_valid_dump_ifaddr_req(const struct nlmsghdr *nlh,
5164 struct inet6_fill_args *fillargs,
5165 struct net **tgt_net, struct sock *sk,
5166 struct netlink_callback *cb)
5167{
5168 struct netlink_ext_ack *extack = cb->extack;
5169 struct nlattr *tb[IFA_MAX+1];
5170 struct ifaddrmsg *ifm;
5171 int err, i;
5172
5173 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
5174 NL_SET_ERR_MSG_MOD(extack, "Invalid header for address dump request");
5175 return -EINVAL;
5176 }
5177
5178 ifm = nlmsg_data(nlh);
5179 if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
5180 NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for address dump request");
5181 return -EINVAL;
5182 }
5183
5184 fillargs->ifindex = ifm->ifa_index;
5185 if (fillargs->ifindex) {
5186 cb->answer_flags |= NLM_F_DUMP_FILTERED;
5187 fillargs->flags |= NLM_F_DUMP_FILTERED;
5188 }
5189
5190 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
5191 ifa_ipv6_policy, extack);
5192 if (err < 0)
5193 return err;
5194
5195 for (i = 0; i <= IFA_MAX; ++i) {
5196 if (!tb[i])
5197 continue;
5198
5199 if (i == IFA_TARGET_NETNSID) {
5200 struct net *net;
5201
5202 fillargs->netnsid = nla_get_s32(tb[i]);
5203 net = rtnl_get_net_ns_capable(sk, fillargs->netnsid);
5204 if (IS_ERR(net)) {
5205 fillargs->netnsid = -1;
5206 NL_SET_ERR_MSG_MOD(extack, "Invalid target network namespace id");
5207 return PTR_ERR(net);
5208 }
5209 *tgt_net = net;
5210 } else {
5211 NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in dump request");
5212 return -EINVAL;
5213 }
5214 }
5215
5216 return 0;
5217}
5218
5219static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
5220 enum addr_type_t type)
5221{
5222 const struct nlmsghdr *nlh = cb->nlh;
5223 struct inet6_fill_args fillargs = {
5224 .portid = NETLINK_CB(cb->skb).portid,
5225 .seq = cb->nlh->nlmsg_seq,
5226 .flags = NLM_F_MULTI,
5227 .netnsid = -1,
5228 .type = type,
5229 };
5230 struct net *tgt_net = sock_net(skb->sk);
5231 int idx, s_idx, s_ip_idx;
5232 int h, s_h;
5233 struct net_device *dev;
5234 struct inet6_dev *idev;
5235 struct hlist_head *head;
5236 int err = 0;
5237
5238 s_h = cb->args[0];
5239 s_idx = idx = cb->args[1];
5240 s_ip_idx = cb->args[2];
5241
5242 if (cb->strict_check) {
5243 err = inet6_valid_dump_ifaddr_req(nlh, &fillargs, &tgt_net,
5244 skb->sk, cb);
5245 if (err < 0)
5246 goto put_tgt_net;
5247
5248 err = 0;
5249 if (fillargs.ifindex) {
5250 dev = __dev_get_by_index(tgt_net, fillargs.ifindex);
5251 if (!dev) {
5252 err = -ENODEV;
5253 goto put_tgt_net;
5254 }
5255 idev = __in6_dev_get(dev);
5256 if (idev) {
5257 err = in6_dump_addrs(idev, skb, cb, s_ip_idx,
5258 &fillargs);
5259 if (err > 0)
5260 err = 0;
5261 }
5262 goto put_tgt_net;
5263 }
5264 }
5265
5266 rcu_read_lock();
5267 cb->seq = atomic_read(&tgt_net->ipv6.dev_addr_genid) ^ tgt_net->dev_base_seq;
5268 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5269 idx = 0;
5270 head = &tgt_net->dev_index_head[h];
5271 hlist_for_each_entry_rcu(dev, head, index_hlist) {
5272 if (idx < s_idx)
5273 goto cont;
5274 if (h > s_h || idx > s_idx)
5275 s_ip_idx = 0;
5276 idev = __in6_dev_get(dev);
5277 if (!idev)
5278 goto cont;
5279
5280 if (in6_dump_addrs(idev, skb, cb, s_ip_idx,
5281 &fillargs) < 0)
5282 goto done;
5283cont:
5284 idx++;
5285 }
5286 }
5287done:
5288 rcu_read_unlock();
5289 cb->args[0] = h;
5290 cb->args[1] = idx;
5291put_tgt_net:
5292 if (fillargs.netnsid >= 0)
5293 put_net(tgt_net);
5294
5295 return skb->len ? : err;
5296}
5297
5298static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
5299{
5300 enum addr_type_t type = UNICAST_ADDR;
5301
5302 return inet6_dump_addr(skb, cb, type);
5303}
5304
5305static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
5306{
5307 enum addr_type_t type = MULTICAST_ADDR;
5308
5309 return inet6_dump_addr(skb, cb, type);
5310}
5311
5312
5313static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
5314{
5315 enum addr_type_t type = ANYCAST_ADDR;
5316
5317 return inet6_dump_addr(skb, cb, type);
5318}
5319
5320static int inet6_rtm_valid_getaddr_req(struct sk_buff *skb,
5321 const struct nlmsghdr *nlh,
5322 struct nlattr **tb,
5323 struct netlink_ext_ack *extack)
5324{
5325 struct ifaddrmsg *ifm;
5326 int i, err;
5327
5328 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
5329 NL_SET_ERR_MSG_MOD(extack, "Invalid header for get address request");
5330 return -EINVAL;
5331 }
5332
5333 if (!netlink_strict_get_check(skb))
5334 return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFA_MAX,
5335 ifa_ipv6_policy, extack);
5336
5337 ifm = nlmsg_data(nlh);
5338 if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
5339 NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for get address request");
5340 return -EINVAL;
5341 }
5342
5343 err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFA_MAX,
5344 ifa_ipv6_policy, extack);
5345 if (err)
5346 return err;
5347
5348 for (i = 0; i <= IFA_MAX; i++) {
5349 if (!tb[i])
5350 continue;
5351
5352 switch (i) {
5353 case IFA_TARGET_NETNSID:
5354 case IFA_ADDRESS:
5355 case IFA_LOCAL:
5356 break;
5357 default:
5358 NL_SET_ERR_MSG_MOD(extack, "Unsupported attribute in get address request");
5359 return -EINVAL;
5360 }
5361 }
5362
5363 return 0;
5364}
5365
5366static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh,
5367 struct netlink_ext_ack *extack)
5368{
5369 struct net *tgt_net = sock_net(in_skb->sk);
5370 struct inet6_fill_args fillargs = {
5371 .portid = NETLINK_CB(in_skb).portid,
5372 .seq = nlh->nlmsg_seq,
5373 .event = RTM_NEWADDR,
5374 .flags = 0,
5375 .netnsid = -1,
5376 };
5377 struct ifaddrmsg *ifm;
5378 struct nlattr *tb[IFA_MAX+1];
5379 struct in6_addr *addr = NULL, *peer;
5380 struct net_device *dev = NULL;
5381 struct inet6_ifaddr *ifa;
5382 struct sk_buff *skb;
5383 int err;
5384
5385 err = inet6_rtm_valid_getaddr_req(in_skb, nlh, tb, extack);
5386 if (err < 0)
5387 return err;
5388
5389 if (tb[IFA_TARGET_NETNSID]) {
5390 fillargs.netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
5391
5392 tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(in_skb).sk,
5393 fillargs.netnsid);
5394 if (IS_ERR(tgt_net))
5395 return PTR_ERR(tgt_net);
5396 }
5397
5398 addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
5399 if (!addr)
5400 return -EINVAL;
5401
5402 ifm = nlmsg_data(nlh);
5403 if (ifm->ifa_index)
5404 dev = dev_get_by_index(tgt_net, ifm->ifa_index);
5405
5406 ifa = ipv6_get_ifaddr(tgt_net, addr, dev, 1);
5407 if (!ifa) {
5408 err = -EADDRNOTAVAIL;
5409 goto errout;
5410 }
5411
5412 skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
5413 if (!skb) {
5414 err = -ENOBUFS;
5415 goto errout_ifa;
5416 }
5417
5418 err = inet6_fill_ifaddr(skb, ifa, &fillargs);
5419 if (err < 0) {
5420
5421 WARN_ON(err == -EMSGSIZE);
5422 kfree_skb(skb);
5423 goto errout_ifa;
5424 }
5425 err = rtnl_unicast(skb, tgt_net, NETLINK_CB(in_skb).portid);
5426errout_ifa:
5427 in6_ifa_put(ifa);
5428errout:
5429 dev_put(dev);
5430 if (fillargs.netnsid >= 0)
5431 put_net(tgt_net);
5432
5433 return err;
5434}
5435
5436static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
5437{
5438 struct sk_buff *skb;
5439 struct net *net = dev_net(ifa->idev->dev);
5440 struct inet6_fill_args fillargs = {
5441 .portid = 0,
5442 .seq = 0,
5443 .event = event,
5444 .flags = 0,
5445 .netnsid = -1,
5446 };
5447 int err = -ENOBUFS;
5448
5449 skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
5450 if (!skb)
5451 goto errout;
5452
5453 err = inet6_fill_ifaddr(skb, ifa, &fillargs);
5454 if (err < 0) {
5455
5456 WARN_ON(err == -EMSGSIZE);
5457 kfree_skb(skb);
5458 goto errout;
5459 }
5460 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
5461 return;
5462errout:
5463 if (err < 0)
5464 rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
5465}
5466
5467static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
5468 __s32 *array, int bytes)
5469{
5470 BUG_ON(bytes < (DEVCONF_MAX * 4));
5471
5472 memset(array, 0, bytes);
5473 array[DEVCONF_FORWARDING] = cnf->forwarding;
5474 array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
5475 array[DEVCONF_MTU6] = cnf->mtu6;
5476 array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
5477 array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
5478 array[DEVCONF_AUTOCONF] = cnf->autoconf;
5479 array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
5480 array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
5481 array[DEVCONF_RTR_SOLICIT_INTERVAL] =
5482 jiffies_to_msecs(cnf->rtr_solicit_interval);
5483 array[DEVCONF_RTR_SOLICIT_MAX_INTERVAL] =
5484 jiffies_to_msecs(cnf->rtr_solicit_max_interval);
5485 array[DEVCONF_RTR_SOLICIT_DELAY] =
5486 jiffies_to_msecs(cnf->rtr_solicit_delay);
5487 array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
5488 array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] =
5489 jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval);
5490 array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] =
5491 jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval);
5492 array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
5493 array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
5494 array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
5495 array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
5496 array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
5497 array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
5498 array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
5499 array[DEVCONF_RA_DEFRTR_METRIC] = cnf->ra_defrtr_metric;
5500 array[DEVCONF_ACCEPT_RA_MIN_HOP_LIMIT] = cnf->accept_ra_min_hop_limit;
5501 array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
5502#ifdef CONFIG_IPV6_ROUTER_PREF
5503 array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
5504 array[DEVCONF_RTR_PROBE_INTERVAL] =
5505 jiffies_to_msecs(cnf->rtr_probe_interval);
5506#ifdef CONFIG_IPV6_ROUTE_INFO
5507 array[DEVCONF_ACCEPT_RA_RT_INFO_MIN_PLEN] = cnf->accept_ra_rt_info_min_plen;
5508 array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
5509#endif
5510#endif
5511 array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
5512 array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
5513#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
5514 array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
5515 array[DEVCONF_USE_OPTIMISTIC] = cnf->use_optimistic;
5516#endif
5517#ifdef CONFIG_IPV6_MROUTE
5518 array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
5519#endif
5520 array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
5521 array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
5522 array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
5523 array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
5524 array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
5525 array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
5526 array[DEVCONF_ACCEPT_RA_MTU] = cnf->accept_ra_mtu;
5527 array[DEVCONF_IGNORE_ROUTES_WITH_LINKDOWN] = cnf->ignore_routes_with_linkdown;
5528
5529 array[DEVCONF_USE_OIF_ADDRS_ONLY] = cnf->use_oif_addrs_only;
5530 array[DEVCONF_DROP_UNICAST_IN_L2_MULTICAST] = cnf->drop_unicast_in_l2_multicast;
5531 array[DEVCONF_DROP_UNSOLICITED_NA] = cnf->drop_unsolicited_na;
5532 array[DEVCONF_KEEP_ADDR_ON_DOWN] = cnf->keep_addr_on_down;
5533 array[DEVCONF_SEG6_ENABLED] = cnf->seg6_enabled;
5534#ifdef CONFIG_IPV6_SEG6_HMAC
5535 array[DEVCONF_SEG6_REQUIRE_HMAC] = cnf->seg6_require_hmac;
5536#endif
5537 array[DEVCONF_ENHANCED_DAD] = cnf->enhanced_dad;
5538 array[DEVCONF_ADDR_GEN_MODE] = cnf->addr_gen_mode;
5539 array[DEVCONF_DISABLE_POLICY] = cnf->disable_policy;
5540 array[DEVCONF_NDISC_TCLASS] = cnf->ndisc_tclass;
5541 array[DEVCONF_RPL_SEG_ENABLED] = cnf->rpl_seg_enabled;
5542 array[DEVCONF_IOAM6_ENABLED] = cnf->ioam6_enabled;
5543 array[DEVCONF_IOAM6_ID] = cnf->ioam6_id;
5544 array[DEVCONF_IOAM6_ID_WIDE] = cnf->ioam6_id_wide;
5545}
5546
5547static inline size_t inet6_ifla6_size(void)
5548{
5549 return nla_total_size(4)
5550 + nla_total_size(sizeof(struct ifla_cacheinfo))
5551 + nla_total_size(DEVCONF_MAX * 4)
5552 + nla_total_size(IPSTATS_MIB_MAX * 8)
5553 + nla_total_size(ICMP6_MIB_MAX * 8)
5554 + nla_total_size(sizeof(struct in6_addr))
5555 + nla_total_size(1)
5556 + nla_total_size(4)
5557 + 0;
5558}
5559
5560static inline size_t inet6_if_nlmsg_size(void)
5561{
5562 return NLMSG_ALIGN(sizeof(struct ifinfomsg))
5563 + nla_total_size(IFNAMSIZ)
5564 + nla_total_size(MAX_ADDR_LEN)
5565 + nla_total_size(4)
5566 + nla_total_size(4)
5567 + nla_total_size(1)
5568 + nla_total_size(inet6_ifla6_size());
5569}
5570
5571static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
5572 int bytes)
5573{
5574 int i;
5575 int pad = bytes - sizeof(u64) * ICMP6_MIB_MAX;
5576 BUG_ON(pad < 0);
5577
5578
5579 put_unaligned(ICMP6_MIB_MAX, &stats[0]);
5580 for (i = 1; i < ICMP6_MIB_MAX; i++)
5581 put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
5582
5583 memset(&stats[ICMP6_MIB_MAX], 0, pad);
5584}
5585
5586static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
5587 int bytes, size_t syncpoff)
5588{
5589 int i, c;
5590 u64 buff[IPSTATS_MIB_MAX];
5591 int pad = bytes - sizeof(u64) * IPSTATS_MIB_MAX;
5592
5593 BUG_ON(pad < 0);
5594
5595 memset(buff, 0, sizeof(buff));
5596 buff[0] = IPSTATS_MIB_MAX;
5597
5598 for_each_possible_cpu(c) {
5599 for (i = 1; i < IPSTATS_MIB_MAX; i++)
5600 buff[i] += snmp_get_cpu_field64(mib, c, i, syncpoff);
5601 }
5602
5603 memcpy(stats, buff, IPSTATS_MIB_MAX * sizeof(u64));
5604 memset(&stats[IPSTATS_MIB_MAX], 0, pad);
5605}
5606
5607static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
5608 int bytes)
5609{
5610 switch (attrtype) {
5611 case IFLA_INET6_STATS:
5612 __snmp6_fill_stats64(stats, idev->stats.ipv6, bytes,
5613 offsetof(struct ipstats_mib, syncp));
5614 break;
5615 case IFLA_INET6_ICMP6STATS:
5616 __snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, bytes);
5617 break;
5618 }
5619}
5620
5621static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev,
5622 u32 ext_filter_mask)
5623{
5624 struct nlattr *nla;
5625 struct ifla_cacheinfo ci;
5626
5627 if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
5628 goto nla_put_failure;
5629 ci.max_reasm_len = IPV6_MAXPLEN;
5630 ci.tstamp = cstamp_delta(idev->tstamp);
5631 ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
5632 ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
5633 if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
5634 goto nla_put_failure;
5635 nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
5636 if (!nla)
5637 goto nla_put_failure;
5638 ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
5639
5640
5641
5642 if (ext_filter_mask & RTEXT_FILTER_SKIP_STATS)
5643 return 0;
5644
5645 nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
5646 if (!nla)
5647 goto nla_put_failure;
5648 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
5649
5650 nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
5651 if (!nla)
5652 goto nla_put_failure;
5653 snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
5654
5655 nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
5656 if (!nla)
5657 goto nla_put_failure;
5658 read_lock_bh(&idev->lock);
5659 memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
5660 read_unlock_bh(&idev->lock);
5661
5662 if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->cnf.addr_gen_mode))
5663 goto nla_put_failure;
5664
5665 if (idev->ra_mtu &&
5666 nla_put_u32(skb, IFLA_INET6_RA_MTU, idev->ra_mtu))
5667 goto nla_put_failure;
5668
5669 return 0;
5670
5671nla_put_failure:
5672 return -EMSGSIZE;
5673}
5674
5675static size_t inet6_get_link_af_size(const struct net_device *dev,
5676 u32 ext_filter_mask)
5677{
5678 if (!__in6_dev_get(dev))
5679 return 0;
5680
5681 return inet6_ifla6_size();
5682}
5683
5684static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev,
5685 u32 ext_filter_mask)
5686{
5687 struct inet6_dev *idev = __in6_dev_get(dev);
5688
5689 if (!idev)
5690 return -ENODATA;
5691
5692 if (inet6_fill_ifla6_attrs(skb, idev, ext_filter_mask) < 0)
5693 return -EMSGSIZE;
5694
5695 return 0;
5696}
5697
5698static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token,
5699 struct netlink_ext_ack *extack)
5700{
5701 struct inet6_ifaddr *ifp;
5702 struct net_device *dev = idev->dev;
5703 bool clear_token, update_rs = false;
5704 struct in6_addr ll_addr;
5705
5706 ASSERT_RTNL();
5707
5708 if (!token)
5709 return -EINVAL;
5710
5711 if (dev->flags & IFF_LOOPBACK) {
5712 NL_SET_ERR_MSG_MOD(extack, "Device is loopback");
5713 return -EINVAL;
5714 }
5715
5716 if (dev->flags & IFF_NOARP) {
5717 NL_SET_ERR_MSG_MOD(extack,
5718 "Device does not do neighbour discovery");
5719 return -EINVAL;
5720 }
5721
5722 if (!ipv6_accept_ra(idev)) {
5723 NL_SET_ERR_MSG_MOD(extack,
5724 "Router advertisement is disabled on device");
5725 return -EINVAL;
5726 }
5727
5728 if (idev->cnf.rtr_solicits == 0) {
5729 NL_SET_ERR_MSG(extack,
5730 "Router solicitation is disabled on device");
5731 return -EINVAL;
5732 }
5733
5734 write_lock_bh(&idev->lock);
5735
5736 BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
5737 memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);
5738
5739 write_unlock_bh(&idev->lock);
5740
5741 clear_token = ipv6_addr_any(token);
5742 if (clear_token)
5743 goto update_lft;
5744
5745 if (!idev->dead && (idev->if_flags & IF_READY) &&
5746 !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
5747 IFA_F_OPTIMISTIC)) {
5748
5749
5750
5751 ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
5752 update_rs = true;
5753 }
5754
5755update_lft:
5756 write_lock_bh(&idev->lock);
5757
5758 if (update_rs) {
5759 idev->if_flags |= IF_RS_SENT;
5760 idev->rs_interval = rfc3315_s14_backoff_init(
5761 idev->cnf.rtr_solicit_interval);
5762 idev->rs_probes = 1;
5763 addrconf_mod_rs_timer(idev, idev->rs_interval);
5764 }
5765
5766
5767 list_for_each_entry(ifp, &idev->addr_list, if_list) {
5768 spin_lock(&ifp->lock);
5769 if (ifp->tokenized) {
5770 ifp->valid_lft = 0;
5771 ifp->prefered_lft = 0;
5772 }
5773 spin_unlock(&ifp->lock);
5774 }
5775
5776 write_unlock_bh(&idev->lock);
5777 inet6_ifinfo_notify(RTM_NEWLINK, idev);
5778 addrconf_verify_rtnl();
5779 return 0;
5780}
5781
5782static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = {
5783 [IFLA_INET6_ADDR_GEN_MODE] = { .type = NLA_U8 },
5784 [IFLA_INET6_TOKEN] = { .len = sizeof(struct in6_addr) },
5785 [IFLA_INET6_RA_MTU] = { .type = NLA_REJECT,
5786 .reject_message =
5787 "IFLA_INET6_RA_MTU can not be set" },
5788};
5789
5790static int check_addr_gen_mode(int mode)
5791{
5792 if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
5793 mode != IN6_ADDR_GEN_MODE_NONE &&
5794 mode != IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5795 mode != IN6_ADDR_GEN_MODE_RANDOM)
5796 return -EINVAL;
5797 return 1;
5798}
5799
5800static int check_stable_privacy(struct inet6_dev *idev, struct net *net,
5801 int mode)
5802{
5803 if (mode == IN6_ADDR_GEN_MODE_STABLE_PRIVACY &&
5804 !idev->cnf.stable_secret.initialized &&
5805 !net->ipv6.devconf_dflt->stable_secret.initialized)
5806 return -EINVAL;
5807 return 1;
5808}
5809
5810static int inet6_validate_link_af(const struct net_device *dev,
5811 const struct nlattr *nla,
5812 struct netlink_ext_ack *extack)
5813{
5814 struct nlattr *tb[IFLA_INET6_MAX + 1];
5815 struct inet6_dev *idev = NULL;
5816 int err;
5817
5818 if (dev) {
5819 idev = __in6_dev_get(dev);
5820 if (!idev)
5821 return -EAFNOSUPPORT;
5822 }
5823
5824 err = nla_parse_nested_deprecated(tb, IFLA_INET6_MAX, nla,
5825 inet6_af_policy, extack);
5826 if (err)
5827 return err;
5828
5829 if (!tb[IFLA_INET6_TOKEN] && !tb[IFLA_INET6_ADDR_GEN_MODE])
5830 return -EINVAL;
5831
5832 if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
5833 u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);
5834
5835 if (check_addr_gen_mode(mode) < 0)
5836 return -EINVAL;
5837 if (dev && check_stable_privacy(idev, dev_net(dev), mode) < 0)
5838 return -EINVAL;
5839 }
5840
5841 return 0;
5842}
5843
5844static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla,
5845 struct netlink_ext_ack *extack)
5846{
5847 struct inet6_dev *idev = __in6_dev_get(dev);
5848 struct nlattr *tb[IFLA_INET6_MAX + 1];
5849 int err;
5850
5851 if (!idev)
5852 return -EAFNOSUPPORT;
5853
5854 if (nla_parse_nested_deprecated(tb, IFLA_INET6_MAX, nla, NULL, NULL) < 0)
5855 return -EINVAL;
5856
5857 if (tb[IFLA_INET6_TOKEN]) {
5858 err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]),
5859 extack);
5860 if (err)
5861 return err;
5862 }
5863
5864 if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
5865 u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);
5866
5867 idev->cnf.addr_gen_mode = mode;
5868 }
5869
5870 return 0;
5871}
5872
5873static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
5874 u32 portid, u32 seq, int event, unsigned int flags)
5875{
5876 struct net_device *dev = idev->dev;
5877 struct ifinfomsg *hdr;
5878 struct nlmsghdr *nlh;
5879 void *protoinfo;
5880
5881 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
5882 if (!nlh)
5883 return -EMSGSIZE;
5884
5885 hdr = nlmsg_data(nlh);
5886 hdr->ifi_family = AF_INET6;
5887 hdr->__ifi_pad = 0;
5888 hdr->ifi_type = dev->type;
5889 hdr->ifi_index = dev->ifindex;
5890 hdr->ifi_flags = dev_get_flags(dev);
5891 hdr->ifi_change = 0;
5892
5893 if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
5894 (dev->addr_len &&
5895 nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
5896 nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
5897 (dev->ifindex != dev_get_iflink(dev) &&
5898 nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||
5899 nla_put_u8(skb, IFLA_OPERSTATE,
5900 netif_running(dev) ? dev->operstate : IF_OPER_DOWN))
5901 goto nla_put_failure;
5902 protoinfo = nla_nest_start_noflag(skb, IFLA_PROTINFO);
5903 if (!protoinfo)
5904 goto nla_put_failure;
5905
5906 if (inet6_fill_ifla6_attrs(skb, idev, 0) < 0)
5907 goto nla_put_failure;
5908
5909 nla_nest_end(skb, protoinfo);
5910 nlmsg_end(skb, nlh);
5911 return 0;
5912
5913nla_put_failure:
5914 nlmsg_cancel(skb, nlh);
5915 return -EMSGSIZE;
5916}
5917
5918static int inet6_valid_dump_ifinfo(const struct nlmsghdr *nlh,
5919 struct netlink_ext_ack *extack)
5920{
5921 struct ifinfomsg *ifm;
5922
5923 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
5924 NL_SET_ERR_MSG_MOD(extack, "Invalid header for link dump request");
5925 return -EINVAL;
5926 }
5927
5928 if (nlmsg_attrlen(nlh, sizeof(*ifm))) {
5929 NL_SET_ERR_MSG_MOD(extack, "Invalid data after header");
5930 return -EINVAL;
5931 }
5932
5933 ifm = nlmsg_data(nlh);
5934 if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
5935 ifm->ifi_change || ifm->ifi_index) {
5936 NL_SET_ERR_MSG_MOD(extack, "Invalid values in header for dump request");
5937 return -EINVAL;
5938 }
5939
5940 return 0;
5941}
5942
5943static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
5944{
5945 struct net *net = sock_net(skb->sk);
5946 int h, s_h;
5947 int idx = 0, s_idx;
5948 struct net_device *dev;
5949 struct inet6_dev *idev;
5950 struct hlist_head *head;
5951
5952
5953
5954
5955 if (cb->strict_check) {
5956 int err = inet6_valid_dump_ifinfo(cb->nlh, cb->extack);
5957
5958 if (err < 0)
5959 return err;
5960 }
5961
5962 s_h = cb->args[0];
5963 s_idx = cb->args[1];
5964
5965 rcu_read_lock();
5966 for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
5967 idx = 0;
5968 head = &net->dev_index_head[h];
5969 hlist_for_each_entry_rcu(dev, head, index_hlist) {
5970 if (idx < s_idx)
5971 goto cont;
5972 idev = __in6_dev_get(dev);
5973 if (!idev)
5974 goto cont;
5975 if (inet6_fill_ifinfo(skb, idev,
5976 NETLINK_CB(cb->skb).portid,
5977 cb->nlh->nlmsg_seq,
5978 RTM_NEWLINK, NLM_F_MULTI) < 0)
5979 goto out;
5980cont:
5981 idx++;
5982 }
5983 }
5984out:
5985 rcu_read_unlock();
5986 cb->args[1] = idx;
5987 cb->args[0] = h;
5988
5989 return skb->len;
5990}
5991
5992void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
5993{
5994 struct sk_buff *skb;
5995 struct net *net = dev_net(idev->dev);
5996 int err = -ENOBUFS;
5997
5998 skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
5999 if (!skb)
6000 goto errout;
6001
6002 err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
6003 if (err < 0) {
6004
6005 WARN_ON(err == -EMSGSIZE);
6006 kfree_skb(skb);
6007 goto errout;
6008 }
6009 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
6010 return;
6011errout:
6012 if (err < 0)
6013 rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
6014}
6015
6016static inline size_t inet6_prefix_nlmsg_size(void)
6017{
6018 return NLMSG_ALIGN(sizeof(struct prefixmsg))
6019 + nla_total_size(sizeof(struct in6_addr))
6020 + nla_total_size(sizeof(struct prefix_cacheinfo));
6021}
6022
6023static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
6024 struct prefix_info *pinfo, u32 portid, u32 seq,
6025 int event, unsigned int flags)
6026{
6027 struct prefixmsg *pmsg;
6028 struct nlmsghdr *nlh;
6029 struct prefix_cacheinfo ci;
6030
6031 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
6032 if (!nlh)
6033 return -EMSGSIZE;
6034
6035 pmsg = nlmsg_data(nlh);
6036 pmsg->prefix_family = AF_INET6;
6037 pmsg->prefix_pad1 = 0;
6038 pmsg->prefix_pad2 = 0;
6039 pmsg->prefix_ifindex = idev->dev->ifindex;
6040 pmsg->prefix_len = pinfo->prefix_len;
6041 pmsg->prefix_type = pinfo->type;
6042 pmsg->prefix_pad3 = 0;
6043 pmsg->prefix_flags = 0;
6044 if (pinfo->onlink)
6045 pmsg->prefix_flags |= IF_PREFIX_ONLINK;
6046 if (pinfo->autoconf)
6047 pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
6048
6049 if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
6050 goto nla_put_failure;
6051 ci.preferred_time = ntohl(pinfo->prefered);
6052 ci.valid_time = ntohl(pinfo->valid);
6053 if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
6054 goto nla_put_failure;
6055 nlmsg_end(skb, nlh);
6056 return 0;
6057
6058nla_put_failure:
6059 nlmsg_cancel(skb, nlh);
6060 return -EMSGSIZE;
6061}
6062
6063static void inet6_prefix_notify(int event, struct inet6_dev *idev,
6064 struct prefix_info *pinfo)
6065{
6066 struct sk_buff *skb;
6067 struct net *net = dev_net(idev->dev);
6068 int err = -ENOBUFS;
6069
6070 skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
6071 if (!skb)
6072 goto errout;
6073
6074 err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
6075 if (err < 0) {
6076
6077 WARN_ON(err == -EMSGSIZE);
6078 kfree_skb(skb);
6079 goto errout;
6080 }
6081 rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
6082 return;
6083errout:
6084 if (err < 0)
6085 rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
6086}
6087
6088static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
6089{
6090 struct net *net = dev_net(ifp->idev->dev);
6091
6092 if (event)
6093 ASSERT_RTNL();
6094
6095 inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
6096
6097 switch (event) {
6098 case RTM_NEWADDR:
6099
6100
6101
6102
6103
6104
6105
6106
6107 if (ifp->rt && !rcu_access_pointer(ifp->rt->fib6_node)) {
6108 ip6_ins_rt(net, ifp->rt);
6109 } else if (!ifp->rt && (ifp->idev->dev->flags & IFF_UP)) {
6110 pr_warn("BUG: Address %pI6c on device %s is missing its host route.\n",
6111 &ifp->addr, ifp->idev->dev->name);
6112 }
6113
6114 if (ifp->idev->cnf.forwarding)
6115 addrconf_join_anycast(ifp);
6116 if (!ipv6_addr_any(&ifp->peer_addr))
6117 addrconf_prefix_route(&ifp->peer_addr, 128,
6118 ifp->rt_priority, ifp->idev->dev,
6119 0, 0, GFP_ATOMIC);
6120 break;
6121 case RTM_DELADDR:
6122 if (ifp->idev->cnf.forwarding)
6123 addrconf_leave_anycast(ifp);
6124 addrconf_leave_solict(ifp->idev, &ifp->addr);
6125 if (!ipv6_addr_any(&ifp->peer_addr)) {
6126 struct fib6_info *rt;
6127
6128 rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
6129 ifp->idev->dev, 0, 0,
6130 false);
6131 if (rt)
6132 ip6_del_rt(net, rt, false);
6133 }
6134 if (ifp->rt) {
6135 ip6_del_rt(net, ifp->rt, false);
6136 ifp->rt = NULL;
6137 }
6138 rt_genid_bump_ipv6(net);
6139 break;
6140 }
6141 atomic_inc(&net->ipv6.dev_addr_genid);
6142}
6143
6144static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
6145{
6146 if (likely(ifp->idev->dead == 0))
6147 __ipv6_ifa_notify(event, ifp);
6148}
6149
6150#ifdef CONFIG_SYSCTL
6151
6152static int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
6153 void *buffer, size_t *lenp, loff_t *ppos)
6154{
6155 int *valp = ctl->data;
6156 int val = *valp;
6157 loff_t pos = *ppos;
6158 struct ctl_table lctl;
6159 int ret;
6160
6161
6162
6163
6164
6165 lctl = *ctl;
6166 lctl.data = &val;
6167
6168 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
6169
6170 if (write)
6171 ret = addrconf_fixup_forwarding(ctl, valp, val);
6172 if (ret)
6173 *ppos = pos;
6174 return ret;
6175}
6176
6177static int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
6178 void *buffer, size_t *lenp, loff_t *ppos)
6179{
6180 struct inet6_dev *idev = ctl->extra1;
6181 int min_mtu = IPV6_MIN_MTU;
6182 struct ctl_table lctl;
6183
6184 lctl = *ctl;
6185 lctl.extra1 = &min_mtu;
6186 lctl.extra2 = idev ? &idev->dev->mtu : NULL;
6187
6188 return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
6189}
6190
6191static void dev_disable_change(struct inet6_dev *idev)
6192{
6193 struct netdev_notifier_info info;
6194
6195 if (!idev || !idev->dev)
6196 return;
6197
6198 netdev_notifier_info_init(&info, idev->dev);
6199 if (idev->cnf.disable_ipv6)
6200 addrconf_notify(NULL, NETDEV_DOWN, &info);
6201 else
6202 addrconf_notify(NULL, NETDEV_UP, &info);
6203}
6204
6205static void addrconf_disable_change(struct net *net, __s32 newf)
6206{
6207 struct net_device *dev;
6208 struct inet6_dev *idev;
6209
6210 for_each_netdev(net, dev) {
6211 idev = __in6_dev_get(dev);
6212 if (idev) {
6213 int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
6214 idev->cnf.disable_ipv6 = newf;
6215 if (changed)
6216 dev_disable_change(idev);
6217 }
6218 }
6219}
6220
6221static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
6222{
6223 struct net *net;
6224 int old;
6225
6226 if (!rtnl_trylock())
6227 return restart_syscall();
6228
6229 net = (struct net *)table->extra2;
6230 old = *p;
6231 *p = newf;
6232
6233 if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
6234 rtnl_unlock();
6235 return 0;
6236 }
6237
6238 if (p == &net->ipv6.devconf_all->disable_ipv6) {
6239 net->ipv6.devconf_dflt->disable_ipv6 = newf;
6240 addrconf_disable_change(net, newf);
6241 } else if ((!newf) ^ (!old))
6242 dev_disable_change((struct inet6_dev *)table->extra1);
6243
6244 rtnl_unlock();
6245 return 0;
6246}
6247
6248static int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
6249 void *buffer, size_t *lenp, loff_t *ppos)
6250{
6251 int *valp = ctl->data;
6252 int val = *valp;
6253 loff_t pos = *ppos;
6254 struct ctl_table lctl;
6255 int ret;
6256
6257
6258
6259
6260
6261 lctl = *ctl;
6262 lctl.data = &val;
6263
6264 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
6265
6266 if (write)
6267 ret = addrconf_disable_ipv6(ctl, valp, val);
6268 if (ret)
6269 *ppos = pos;
6270 return ret;
6271}
6272
6273static int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
6274 void *buffer, size_t *lenp, loff_t *ppos)
6275{
6276 int *valp = ctl->data;
6277 int ret;
6278 int old, new;
6279
6280 old = *valp;
6281 ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
6282 new = *valp;
6283
6284 if (write && old != new) {
6285 struct net *net = ctl->extra2;
6286
6287 if (!rtnl_trylock())
6288 return restart_syscall();
6289
6290 if (valp == &net->ipv6.devconf_dflt->proxy_ndp)
6291 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
6292 NETCONFA_PROXY_NEIGH,
6293 NETCONFA_IFINDEX_DEFAULT,
6294 net->ipv6.devconf_dflt);
6295 else if (valp == &net->ipv6.devconf_all->proxy_ndp)
6296 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
6297 NETCONFA_PROXY_NEIGH,
6298 NETCONFA_IFINDEX_ALL,
6299 net->ipv6.devconf_all);
6300 else {
6301 struct inet6_dev *idev = ctl->extra1;
6302
6303 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF,
6304 NETCONFA_PROXY_NEIGH,
6305 idev->dev->ifindex,
6306 &idev->cnf);
6307 }
6308 rtnl_unlock();
6309 }
6310
6311 return ret;
6312}
6313
6314static int addrconf_sysctl_addr_gen_mode(struct ctl_table *ctl, int write,
6315 void *buffer, size_t *lenp,
6316 loff_t *ppos)
6317{
6318 int ret = 0;
6319 u32 new_val;
6320 struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1;
6321 struct net *net = (struct net *)ctl->extra2;
6322 struct ctl_table tmp = {
6323 .data = &new_val,
6324 .maxlen = sizeof(new_val),
6325 .mode = ctl->mode,
6326 };
6327
6328 if (!rtnl_trylock())
6329 return restart_syscall();
6330
6331 new_val = *((u32 *)ctl->data);
6332
6333 ret = proc_douintvec(&tmp, write, buffer, lenp, ppos);
6334 if (ret != 0)
6335 goto out;
6336
6337 if (write) {
6338 if (check_addr_gen_mode(new_val) < 0) {
6339 ret = -EINVAL;
6340 goto out;
6341 }
6342
6343 if (idev) {
6344 if (check_stable_privacy(idev, net, new_val) < 0) {
6345 ret = -EINVAL;
6346 goto out;
6347 }
6348
6349 if (idev->cnf.addr_gen_mode != new_val) {
6350 idev->cnf.addr_gen_mode = new_val;
6351 addrconf_dev_config(idev->dev);
6352 }
6353 } else if (&net->ipv6.devconf_all->addr_gen_mode == ctl->data) {
6354 struct net_device *dev;
6355
6356 net->ipv6.devconf_dflt->addr_gen_mode = new_val;
6357 for_each_netdev(net, dev) {
6358 idev = __in6_dev_get(dev);
6359 if (idev &&
6360 idev->cnf.addr_gen_mode != new_val) {
6361 idev->cnf.addr_gen_mode = new_val;
6362 addrconf_dev_config(idev->dev);
6363 }
6364 }
6365 }
6366
6367 *((u32 *)ctl->data) = new_val;
6368 }
6369
6370out:
6371 rtnl_unlock();
6372
6373 return ret;
6374}
6375
6376static int addrconf_sysctl_stable_secret(struct ctl_table *ctl, int write,
6377 void *buffer, size_t *lenp,
6378 loff_t *ppos)
6379{
6380 int err;
6381 struct in6_addr addr;
6382 char str[IPV6_MAX_STRLEN];
6383 struct ctl_table lctl = *ctl;
6384 struct net *net = ctl->extra2;
6385 struct ipv6_stable_secret *secret = ctl->data;
6386
6387 if (&net->ipv6.devconf_all->stable_secret == ctl->data)
6388 return -EIO;
6389
6390 lctl.maxlen = IPV6_MAX_STRLEN;
6391 lctl.data = str;
6392
6393 if (!rtnl_trylock())
6394 return restart_syscall();
6395
6396 if (!write && !secret->initialized) {
6397 err = -EIO;
6398 goto out;
6399 }
6400
6401 err = snprintf(str, sizeof(str), "%pI6", &secret->secret);
6402 if (err >= sizeof(str)) {
6403 err = -EIO;
6404 goto out;
6405 }
6406
6407 err = proc_dostring(&lctl, write, buffer, lenp, ppos);
6408 if (err || !write)
6409 goto out;
6410
6411 if (in6_pton(str, -1, addr.in6_u.u6_addr8, -1, NULL) != 1) {
6412 err = -EIO;
6413 goto out;
6414 }
6415
6416 secret->initialized = true;
6417 secret->secret = addr;
6418
6419 if (&net->ipv6.devconf_dflt->stable_secret == ctl->data) {
6420 struct net_device *dev;
6421
6422 for_each_netdev(net, dev) {
6423 struct inet6_dev *idev = __in6_dev_get(dev);
6424
6425 if (idev) {
6426 idev->cnf.addr_gen_mode =
6427 IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
6428 }
6429 }
6430 } else {
6431 struct inet6_dev *idev = ctl->extra1;
6432
6433 idev->cnf.addr_gen_mode = IN6_ADDR_GEN_MODE_STABLE_PRIVACY;
6434 }
6435
6436out:
6437 rtnl_unlock();
6438
6439 return err;
6440}
6441
6442static
6443int addrconf_sysctl_ignore_routes_with_linkdown(struct ctl_table *ctl,
6444 int write, void *buffer,
6445 size_t *lenp,
6446 loff_t *ppos)
6447{
6448 int *valp = ctl->data;
6449 int val = *valp;
6450 loff_t pos = *ppos;
6451 struct ctl_table lctl;
6452 int ret;
6453
6454
6455
6456
6457 lctl = *ctl;
6458 lctl.data = &val;
6459
6460 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
6461
6462 if (write)
6463 ret = addrconf_fixup_linkdown(ctl, valp, val);
6464 if (ret)
6465 *ppos = pos;
6466 return ret;
6467}
6468
6469static
6470void addrconf_set_nopolicy(struct rt6_info *rt, int action)
6471{
6472 if (rt) {
6473 if (action)
6474 rt->dst.flags |= DST_NOPOLICY;
6475 else
6476 rt->dst.flags &= ~DST_NOPOLICY;
6477 }
6478}
6479
6480static
6481void addrconf_disable_policy_idev(struct inet6_dev *idev, int val)
6482{
6483 struct inet6_ifaddr *ifa;
6484
6485 read_lock_bh(&idev->lock);
6486 list_for_each_entry(ifa, &idev->addr_list, if_list) {
6487 spin_lock(&ifa->lock);
6488 if (ifa->rt) {
6489
6490 struct fib6_nh *nh = ifa->rt->fib6_nh;
6491 int cpu;
6492
6493 rcu_read_lock();
6494 ifa->rt->dst_nopolicy = val ? true : false;
6495 if (nh->rt6i_pcpu) {
6496 for_each_possible_cpu(cpu) {
6497 struct rt6_info **rtp;
6498
6499 rtp = per_cpu_ptr(nh->rt6i_pcpu, cpu);
6500 addrconf_set_nopolicy(*rtp, val);
6501 }
6502 }
6503 rcu_read_unlock();
6504 }
6505 spin_unlock(&ifa->lock);
6506 }
6507 read_unlock_bh(&idev->lock);
6508}
6509
6510static
6511int addrconf_disable_policy(struct ctl_table *ctl, int *valp, int val)
6512{
6513 struct inet6_dev *idev;
6514 struct net *net;
6515
6516 if (!rtnl_trylock())
6517 return restart_syscall();
6518
6519 *valp = val;
6520
6521 net = (struct net *)ctl->extra2;
6522 if (valp == &net->ipv6.devconf_dflt->disable_policy) {
6523 rtnl_unlock();
6524 return 0;
6525 }
6526
6527 if (valp == &net->ipv6.devconf_all->disable_policy) {
6528 struct net_device *dev;
6529
6530 for_each_netdev(net, dev) {
6531 idev = __in6_dev_get(dev);
6532 if (idev)
6533 addrconf_disable_policy_idev(idev, val);
6534 }
6535 } else {
6536 idev = (struct inet6_dev *)ctl->extra1;
6537 addrconf_disable_policy_idev(idev, val);
6538 }
6539
6540 rtnl_unlock();
6541 return 0;
6542}
6543
6544static int addrconf_sysctl_disable_policy(struct ctl_table *ctl, int write,
6545 void *buffer, size_t *lenp, loff_t *ppos)
6546{
6547 int *valp = ctl->data;
6548 int val = *valp;
6549 loff_t pos = *ppos;
6550 struct ctl_table lctl;
6551 int ret;
6552
6553 lctl = *ctl;
6554 lctl.data = &val;
6555 ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
6556
6557 if (write && (*valp != val))
6558 ret = addrconf_disable_policy(ctl, valp, val);
6559
6560 if (ret)
6561 *ppos = pos;
6562
6563 return ret;
6564}
6565
6566static int minus_one = -1;
6567static const int two_five_five = 255;
6568static u32 ioam6_if_id_max = U16_MAX;
6569
6570static const struct ctl_table addrconf_sysctl[] = {
6571 {
6572 .procname = "forwarding",
6573 .data = &ipv6_devconf.forwarding,
6574 .maxlen = sizeof(int),
6575 .mode = 0644,
6576 .proc_handler = addrconf_sysctl_forward,
6577 },
6578 {
6579 .procname = "hop_limit",
6580 .data = &ipv6_devconf.hop_limit,
6581 .maxlen = sizeof(int),
6582 .mode = 0644,
6583 .proc_handler = proc_dointvec_minmax,
6584 .extra1 = (void *)SYSCTL_ONE,
6585 .extra2 = (void *)&two_five_five,
6586 },
6587 {
6588 .procname = "mtu",
6589 .data = &ipv6_devconf.mtu6,
6590 .maxlen = sizeof(int),
6591 .mode = 0644,
6592 .proc_handler = addrconf_sysctl_mtu,
6593 },
6594 {
6595 .procname = "accept_ra",
6596 .data = &ipv6_devconf.accept_ra,
6597 .maxlen = sizeof(int),
6598 .mode = 0644,
6599 .proc_handler = proc_dointvec,
6600 },
6601 {
6602 .procname = "accept_redirects",
6603 .data = &ipv6_devconf.accept_redirects,
6604 .maxlen = sizeof(int),
6605 .mode = 0644,
6606 .proc_handler = proc_dointvec,
6607 },
6608 {
6609 .procname = "autoconf",
6610 .data = &ipv6_devconf.autoconf,
6611 .maxlen = sizeof(int),
6612 .mode = 0644,
6613 .proc_handler = proc_dointvec,
6614 },
6615 {
6616 .procname = "dad_transmits",
6617 .data = &ipv6_devconf.dad_transmits,
6618 .maxlen = sizeof(int),
6619 .mode = 0644,
6620 .proc_handler = proc_dointvec,
6621 },
6622 {
6623 .procname = "router_solicitations",
6624 .data = &ipv6_devconf.rtr_solicits,
6625 .maxlen = sizeof(int),
6626 .mode = 0644,
6627 .proc_handler = proc_dointvec_minmax,
6628 .extra1 = &minus_one,
6629 },
6630 {
6631 .procname = "router_solicitation_interval",
6632 .data = &ipv6_devconf.rtr_solicit_interval,
6633 .maxlen = sizeof(int),
6634 .mode = 0644,
6635 .proc_handler = proc_dointvec_jiffies,
6636 },
6637 {
6638 .procname = "router_solicitation_max_interval",
6639 .data = &ipv6_devconf.rtr_solicit_max_interval,
6640 .maxlen = sizeof(int),
6641 .mode = 0644,
6642 .proc_handler = proc_dointvec_jiffies,
6643 },
6644 {
6645 .procname = "router_solicitation_delay",
6646 .data = &ipv6_devconf.rtr_solicit_delay,
6647 .maxlen = sizeof(int),
6648 .mode = 0644,
6649 .proc_handler = proc_dointvec_jiffies,
6650 },
6651 {
6652 .procname = "force_mld_version",
6653 .data = &ipv6_devconf.force_mld_version,
6654 .maxlen = sizeof(int),
6655 .mode = 0644,
6656 .proc_handler = proc_dointvec,
6657 },
6658 {
6659 .procname = "mldv1_unsolicited_report_interval",
6660 .data =
6661 &ipv6_devconf.mldv1_unsolicited_report_interval,
6662 .maxlen = sizeof(int),
6663 .mode = 0644,
6664 .proc_handler = proc_dointvec_ms_jiffies,
6665 },
6666 {
6667 .procname = "mldv2_unsolicited_report_interval",
6668 .data =
6669 &ipv6_devconf.mldv2_unsolicited_report_interval,
6670 .maxlen = sizeof(int),
6671 .mode = 0644,
6672 .proc_handler = proc_dointvec_ms_jiffies,
6673 },
6674 {
6675 .procname = "use_tempaddr",
6676 .data = &ipv6_devconf.use_tempaddr,
6677 .maxlen = sizeof(int),
6678 .mode = 0644,
6679 .proc_handler = proc_dointvec,
6680 },
6681 {
6682 .procname = "temp_valid_lft",
6683 .data = &ipv6_devconf.temp_valid_lft,
6684 .maxlen = sizeof(int),
6685 .mode = 0644,
6686 .proc_handler = proc_dointvec,
6687 },
6688 {
6689 .procname = "temp_prefered_lft",
6690 .data = &ipv6_devconf.temp_prefered_lft,
6691 .maxlen = sizeof(int),
6692 .mode = 0644,
6693 .proc_handler = proc_dointvec,
6694 },
6695 {
6696 .procname = "regen_max_retry",
6697 .data = &ipv6_devconf.regen_max_retry,
6698 .maxlen = sizeof(int),
6699 .mode = 0644,
6700 .proc_handler = proc_dointvec,
6701 },
6702 {
6703 .procname = "max_desync_factor",
6704 .data = &ipv6_devconf.max_desync_factor,
6705 .maxlen = sizeof(int),
6706 .mode = 0644,
6707 .proc_handler = proc_dointvec,
6708 },
6709 {
6710 .procname = "max_addresses",
6711 .data = &ipv6_devconf.max_addresses,
6712 .maxlen = sizeof(int),
6713 .mode = 0644,
6714 .proc_handler = proc_dointvec,
6715 },
6716 {
6717 .procname = "accept_ra_defrtr",
6718 .data = &ipv6_devconf.accept_ra_defrtr,
6719 .maxlen = sizeof(int),
6720 .mode = 0644,
6721 .proc_handler = proc_dointvec,
6722 },
6723 {
6724 .procname = "ra_defrtr_metric",
6725 .data = &ipv6_devconf.ra_defrtr_metric,
6726 .maxlen = sizeof(u32),
6727 .mode = 0644,
6728 .proc_handler = proc_douintvec_minmax,
6729 .extra1 = (void *)SYSCTL_ONE,
6730 },
6731 {
6732 .procname = "accept_ra_min_hop_limit",
6733 .data = &ipv6_devconf.accept_ra_min_hop_limit,
6734 .maxlen = sizeof(int),
6735 .mode = 0644,
6736 .proc_handler = proc_dointvec,
6737 },
6738 {
6739 .procname = "accept_ra_pinfo",
6740 .data = &ipv6_devconf.accept_ra_pinfo,
6741 .maxlen = sizeof(int),
6742 .mode = 0644,
6743 .proc_handler = proc_dointvec,
6744 },
6745#ifdef CONFIG_IPV6_ROUTER_PREF
6746 {
6747 .procname = "accept_ra_rtr_pref",
6748 .data = &ipv6_devconf.accept_ra_rtr_pref,
6749 .maxlen = sizeof(int),
6750 .mode = 0644,
6751 .proc_handler = proc_dointvec,
6752 },
6753 {
6754 .procname = "router_probe_interval",
6755 .data = &ipv6_devconf.rtr_probe_interval,
6756 .maxlen = sizeof(int),
6757 .mode = 0644,
6758 .proc_handler = proc_dointvec_jiffies,
6759 },
6760#ifdef CONFIG_IPV6_ROUTE_INFO
6761 {
6762 .procname = "accept_ra_rt_info_min_plen",
6763 .data = &ipv6_devconf.accept_ra_rt_info_min_plen,
6764 .maxlen = sizeof(int),
6765 .mode = 0644,
6766 .proc_handler = proc_dointvec,
6767 },
6768 {
6769 .procname = "accept_ra_rt_info_max_plen",
6770 .data = &ipv6_devconf.accept_ra_rt_info_max_plen,
6771 .maxlen = sizeof(int),
6772 .mode = 0644,
6773 .proc_handler = proc_dointvec,
6774 },
6775#endif
6776#endif
6777 {
6778 .procname = "proxy_ndp",
6779 .data = &ipv6_devconf.proxy_ndp,
6780 .maxlen = sizeof(int),
6781 .mode = 0644,
6782 .proc_handler = addrconf_sysctl_proxy_ndp,
6783 },
6784 {
6785 .procname = "accept_source_route",
6786 .data = &ipv6_devconf.accept_source_route,
6787 .maxlen = sizeof(int),
6788 .mode = 0644,
6789 .proc_handler = proc_dointvec,
6790 },
6791#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
6792 {
6793 .procname = "optimistic_dad",
6794 .data = &ipv6_devconf.optimistic_dad,
6795 .maxlen = sizeof(int),
6796 .mode = 0644,
6797 .proc_handler = proc_dointvec,
6798 },
6799 {
6800 .procname = "use_optimistic",
6801 .data = &ipv6_devconf.use_optimistic,
6802 .maxlen = sizeof(int),
6803 .mode = 0644,
6804 .proc_handler = proc_dointvec,
6805 },
6806#endif
6807#ifdef CONFIG_IPV6_MROUTE
6808 {
6809 .procname = "mc_forwarding",
6810 .data = &ipv6_devconf.mc_forwarding,
6811 .maxlen = sizeof(int),
6812 .mode = 0444,
6813 .proc_handler = proc_dointvec,
6814 },
6815#endif
6816 {
6817 .procname = "disable_ipv6",
6818 .data = &ipv6_devconf.disable_ipv6,
6819 .maxlen = sizeof(int),
6820 .mode = 0644,
6821 .proc_handler = addrconf_sysctl_disable,
6822 },
6823 {
6824 .procname = "accept_dad",
6825 .data = &ipv6_devconf.accept_dad,
6826 .maxlen = sizeof(int),
6827 .mode = 0644,
6828 .proc_handler = proc_dointvec,
6829 },
6830 {
6831 .procname = "force_tllao",
6832 .data = &ipv6_devconf.force_tllao,
6833 .maxlen = sizeof(int),
6834 .mode = 0644,
6835 .proc_handler = proc_dointvec
6836 },
6837 {
6838 .procname = "ndisc_notify",
6839 .data = &ipv6_devconf.ndisc_notify,
6840 .maxlen = sizeof(int),
6841 .mode = 0644,
6842 .proc_handler = proc_dointvec
6843 },
6844 {
6845 .procname = "suppress_frag_ndisc",
6846 .data = &ipv6_devconf.suppress_frag_ndisc,
6847 .maxlen = sizeof(int),
6848 .mode = 0644,
6849 .proc_handler = proc_dointvec
6850 },
6851 {
6852 .procname = "accept_ra_from_local",
6853 .data = &ipv6_devconf.accept_ra_from_local,
6854 .maxlen = sizeof(int),
6855 .mode = 0644,
6856 .proc_handler = proc_dointvec,
6857 },
6858 {
6859 .procname = "accept_ra_mtu",
6860 .data = &ipv6_devconf.accept_ra_mtu,
6861 .maxlen = sizeof(int),
6862 .mode = 0644,
6863 .proc_handler = proc_dointvec,
6864 },
6865 {
6866 .procname = "stable_secret",
6867 .data = &ipv6_devconf.stable_secret,
6868 .maxlen = IPV6_MAX_STRLEN,
6869 .mode = 0600,
6870 .proc_handler = addrconf_sysctl_stable_secret,
6871 },
6872 {
6873 .procname = "use_oif_addrs_only",
6874 .data = &ipv6_devconf.use_oif_addrs_only,
6875 .maxlen = sizeof(int),
6876 .mode = 0644,
6877 .proc_handler = proc_dointvec,
6878 },
6879 {
6880 .procname = "ignore_routes_with_linkdown",
6881 .data = &ipv6_devconf.ignore_routes_with_linkdown,
6882 .maxlen = sizeof(int),
6883 .mode = 0644,
6884 .proc_handler = addrconf_sysctl_ignore_routes_with_linkdown,
6885 },
6886 {
6887 .procname = "drop_unicast_in_l2_multicast",
6888 .data = &ipv6_devconf.drop_unicast_in_l2_multicast,
6889 .maxlen = sizeof(int),
6890 .mode = 0644,
6891 .proc_handler = proc_dointvec,
6892 },
6893 {
6894 .procname = "drop_unsolicited_na",
6895 .data = &ipv6_devconf.drop_unsolicited_na,
6896 .maxlen = sizeof(int),
6897 .mode = 0644,
6898 .proc_handler = proc_dointvec,
6899 },
6900 {
6901 .procname = "keep_addr_on_down",
6902 .data = &ipv6_devconf.keep_addr_on_down,
6903 .maxlen = sizeof(int),
6904 .mode = 0644,
6905 .proc_handler = proc_dointvec,
6906
6907 },
6908 {
6909 .procname = "seg6_enabled",
6910 .data = &ipv6_devconf.seg6_enabled,
6911 .maxlen = sizeof(int),
6912 .mode = 0644,
6913 .proc_handler = proc_dointvec,
6914 },
6915#ifdef CONFIG_IPV6_SEG6_HMAC
6916 {
6917 .procname = "seg6_require_hmac",
6918 .data = &ipv6_devconf.seg6_require_hmac,
6919 .maxlen = sizeof(int),
6920 .mode = 0644,
6921 .proc_handler = proc_dointvec,
6922 },
6923#endif
6924 {
6925 .procname = "enhanced_dad",
6926 .data = &ipv6_devconf.enhanced_dad,
6927 .maxlen = sizeof(int),
6928 .mode = 0644,
6929 .proc_handler = proc_dointvec,
6930 },
6931 {
6932 .procname = "addr_gen_mode",
6933 .data = &ipv6_devconf.addr_gen_mode,
6934 .maxlen = sizeof(int),
6935 .mode = 0644,
6936 .proc_handler = addrconf_sysctl_addr_gen_mode,
6937 },
6938 {
6939 .procname = "disable_policy",
6940 .data = &ipv6_devconf.disable_policy,
6941 .maxlen = sizeof(int),
6942 .mode = 0644,
6943 .proc_handler = addrconf_sysctl_disable_policy,
6944 },
6945 {
6946 .procname = "ndisc_tclass",
6947 .data = &ipv6_devconf.ndisc_tclass,
6948 .maxlen = sizeof(int),
6949 .mode = 0644,
6950 .proc_handler = proc_dointvec_minmax,
6951 .extra1 = (void *)SYSCTL_ZERO,
6952 .extra2 = (void *)&two_five_five,
6953 },
6954 {
6955 .procname = "rpl_seg_enabled",
6956 .data = &ipv6_devconf.rpl_seg_enabled,
6957 .maxlen = sizeof(int),
6958 .mode = 0644,
6959 .proc_handler = proc_dointvec,
6960 },
6961 {
6962 .procname = "ioam6_enabled",
6963 .data = &ipv6_devconf.ioam6_enabled,
6964 .maxlen = sizeof(u8),
6965 .mode = 0644,
6966 .proc_handler = proc_dou8vec_minmax,
6967 .extra1 = (void *)SYSCTL_ZERO,
6968 .extra2 = (void *)SYSCTL_ONE,
6969 },
6970 {
6971 .procname = "ioam6_id",
6972 .data = &ipv6_devconf.ioam6_id,
6973 .maxlen = sizeof(u32),
6974 .mode = 0644,
6975 .proc_handler = proc_douintvec_minmax,
6976 .extra1 = (void *)SYSCTL_ZERO,
6977 .extra2 = (void *)&ioam6_if_id_max,
6978 },
6979 {
6980 .procname = "ioam6_id_wide",
6981 .data = &ipv6_devconf.ioam6_id_wide,
6982 .maxlen = sizeof(u32),
6983 .mode = 0644,
6984 .proc_handler = proc_douintvec,
6985 },
6986 {
6987
6988 }
6989};
6990
6991static int __addrconf_sysctl_register(struct net *net, char *dev_name,
6992 struct inet6_dev *idev, struct ipv6_devconf *p)
6993{
6994 int i, ifindex;
6995 struct ctl_table *table;
6996 char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
6997
6998 table = kmemdup(addrconf_sysctl, sizeof(addrconf_sysctl), GFP_KERNEL);
6999 if (!table)
7000 goto out;
7001
7002 for (i = 0; table[i].data; i++) {
7003 table[i].data += (char *)p - (char *)&ipv6_devconf;
7004
7005
7006
7007
7008 if (!table[i].extra1 && !table[i].extra2) {
7009 table[i].extra1 = idev;
7010 table[i].extra2 = net;
7011 }
7012 }
7013
7014 snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
7015
7016 p->sysctl_header = register_net_sysctl(net, path, table);
7017 if (!p->sysctl_header)
7018 goto free;
7019
7020 if (!strcmp(dev_name, "all"))
7021 ifindex = NETCONFA_IFINDEX_ALL;
7022 else if (!strcmp(dev_name, "default"))
7023 ifindex = NETCONFA_IFINDEX_DEFAULT;
7024 else
7025 ifindex = idev->dev->ifindex;
7026 inet6_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_ALL,
7027 ifindex, p);
7028 return 0;
7029
7030free:
7031 kfree(table);
7032out:
7033 return -ENOBUFS;
7034}
7035
7036static void __addrconf_sysctl_unregister(struct net *net,
7037 struct ipv6_devconf *p, int ifindex)
7038{
7039 struct ctl_table *table;
7040
7041 if (!p->sysctl_header)
7042 return;
7043
7044 table = p->sysctl_header->ctl_table_arg;
7045 unregister_net_sysctl_table(p->sysctl_header);
7046 p->sysctl_header = NULL;
7047 kfree(table);
7048
7049 inet6_netconf_notify_devconf(net, RTM_DELNETCONF, 0, ifindex, NULL);
7050}
7051
7052static int addrconf_sysctl_register(struct inet6_dev *idev)
7053{
7054 int err;
7055
7056 if (!sysctl_dev_name_is_allowed(idev->dev->name))
7057 return -EINVAL;
7058
7059 err = neigh_sysctl_register(idev->dev, idev->nd_parms,
7060 &ndisc_ifinfo_sysctl_change);
7061 if (err)
7062 return err;
7063 err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
7064 idev, &idev->cnf);
7065 if (err)
7066 neigh_sysctl_unregister(idev->nd_parms);
7067
7068 return err;
7069}
7070
7071static void addrconf_sysctl_unregister(struct inet6_dev *idev)
7072{
7073 __addrconf_sysctl_unregister(dev_net(idev->dev), &idev->cnf,
7074 idev->dev->ifindex);
7075 neigh_sysctl_unregister(idev->nd_parms);
7076}
7077
7078
7079#endif
7080
7081static int __net_init addrconf_init_net(struct net *net)
7082{
7083 int err = -ENOMEM;
7084 struct ipv6_devconf *all, *dflt;
7085
7086 all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
7087 if (!all)
7088 goto err_alloc_all;
7089
7090 dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
7091 if (!dflt)
7092 goto err_alloc_dflt;
7093
7094 if (IS_ENABLED(CONFIG_SYSCTL) &&
7095 !net_eq(net, &init_net)) {
7096 switch (sysctl_devconf_inherit_init_net) {
7097 case 1:
7098 memcpy(all, init_net.ipv6.devconf_all,
7099 sizeof(ipv6_devconf));
7100 memcpy(dflt, init_net.ipv6.devconf_dflt,
7101 sizeof(ipv6_devconf_dflt));
7102 break;
7103 case 3:
7104 memcpy(all, current->nsproxy->net_ns->ipv6.devconf_all,
7105 sizeof(ipv6_devconf));
7106 memcpy(dflt,
7107 current->nsproxy->net_ns->ipv6.devconf_dflt,
7108 sizeof(ipv6_devconf_dflt));
7109 break;
7110 case 0:
7111 case 2:
7112
7113 break;
7114 }
7115 }
7116
7117
7118 dflt->autoconf = ipv6_defaults.autoconf;
7119 dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
7120
7121 dflt->stable_secret.initialized = false;
7122 all->stable_secret.initialized = false;
7123
7124 net->ipv6.devconf_all = all;
7125 net->ipv6.devconf_dflt = dflt;
7126
7127#ifdef CONFIG_SYSCTL
7128 err = __addrconf_sysctl_register(net, "all", NULL, all);
7129 if (err < 0)
7130 goto err_reg_all;
7131
7132 err = __addrconf_sysctl_register(net, "default", NULL, dflt);
7133 if (err < 0)
7134 goto err_reg_dflt;
7135#endif
7136 return 0;
7137
7138#ifdef CONFIG_SYSCTL
7139err_reg_dflt:
7140 __addrconf_sysctl_unregister(net, all, NETCONFA_IFINDEX_ALL);
7141err_reg_all:
7142 kfree(dflt);
7143#endif
7144err_alloc_dflt:
7145 kfree(all);
7146err_alloc_all:
7147 return err;
7148}
7149
7150static void __net_exit addrconf_exit_net(struct net *net)
7151{
7152#ifdef CONFIG_SYSCTL
7153 __addrconf_sysctl_unregister(net, net->ipv6.devconf_dflt,
7154 NETCONFA_IFINDEX_DEFAULT);
7155 __addrconf_sysctl_unregister(net, net->ipv6.devconf_all,
7156 NETCONFA_IFINDEX_ALL);
7157#endif
7158 kfree(net->ipv6.devconf_dflt);
7159 kfree(net->ipv6.devconf_all);
7160}
7161
7162static struct pernet_operations addrconf_ops = {
7163 .init = addrconf_init_net,
7164 .exit = addrconf_exit_net,
7165};
7166
7167static struct rtnl_af_ops inet6_ops __read_mostly = {
7168 .family = AF_INET6,
7169 .fill_link_af = inet6_fill_link_af,
7170 .get_link_af_size = inet6_get_link_af_size,
7171 .validate_link_af = inet6_validate_link_af,
7172 .set_link_af = inet6_set_link_af,
7173};
7174
7175
7176
7177
7178
7179int __init addrconf_init(void)
7180{
7181 struct inet6_dev *idev;
7182 int i, err;
7183
7184 err = ipv6_addr_label_init();
7185 if (err < 0) {
7186 pr_crit("%s: cannot initialize default policy table: %d\n",
7187 __func__, err);
7188 goto out;
7189 }
7190
7191 err = register_pernet_subsys(&addrconf_ops);
7192 if (err < 0)
7193 goto out_addrlabel;
7194
7195 addrconf_wq = create_workqueue("ipv6_addrconf");
7196 if (!addrconf_wq) {
7197 err = -ENOMEM;
7198 goto out_nowq;
7199 }
7200
7201
7202
7203
7204
7205
7206
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219 rtnl_lock();
7220 idev = ipv6_add_dev(init_net.loopback_dev);
7221 rtnl_unlock();
7222 if (IS_ERR(idev)) {
7223 err = PTR_ERR(idev);
7224 goto errlo;
7225 }
7226
7227 ip6_route_init_special_entries();
7228
7229 for (i = 0; i < IN6_ADDR_HSIZE; i++)
7230 INIT_HLIST_HEAD(&inet6_addr_lst[i]);
7231
7232 register_netdevice_notifier(&ipv6_dev_notf);
7233
7234 addrconf_verify();
7235
7236 rtnl_af_register(&inet6_ops);
7237
7238 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETLINK,
7239 NULL, inet6_dump_ifinfo, 0);
7240 if (err < 0)
7241 goto errout;
7242
7243 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_NEWADDR,
7244 inet6_rtm_newaddr, NULL, 0);
7245 if (err < 0)
7246 goto errout;
7247 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_DELADDR,
7248 inet6_rtm_deladdr, NULL, 0);
7249 if (err < 0)
7250 goto errout;
7251 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETADDR,
7252 inet6_rtm_getaddr, inet6_dump_ifaddr,
7253 RTNL_FLAG_DOIT_UNLOCKED);
7254 if (err < 0)
7255 goto errout;
7256 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETMULTICAST,
7257 NULL, inet6_dump_ifmcaddr, 0);
7258 if (err < 0)
7259 goto errout;
7260 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETANYCAST,
7261 NULL, inet6_dump_ifacaddr, 0);
7262 if (err < 0)
7263 goto errout;
7264 err = rtnl_register_module(THIS_MODULE, PF_INET6, RTM_GETNETCONF,
7265 inet6_netconf_get_devconf,
7266 inet6_netconf_dump_devconf,
7267 RTNL_FLAG_DOIT_UNLOCKED);
7268 if (err < 0)
7269 goto errout;
7270 err = ipv6_addr_label_rtnl_register();
7271 if (err < 0)
7272 goto errout;
7273
7274 return 0;
7275errout:
7276 rtnl_unregister_all(PF_INET6);
7277 rtnl_af_unregister(&inet6_ops);
7278 unregister_netdevice_notifier(&ipv6_dev_notf);
7279errlo:
7280 destroy_workqueue(addrconf_wq);
7281out_nowq:
7282 unregister_pernet_subsys(&addrconf_ops);
7283out_addrlabel:
7284 ipv6_addr_label_cleanup();
7285out:
7286 return err;
7287}
7288
7289void addrconf_cleanup(void)
7290{
7291 struct net_device *dev;
7292 int i;
7293
7294 unregister_netdevice_notifier(&ipv6_dev_notf);
7295 unregister_pernet_subsys(&addrconf_ops);
7296 ipv6_addr_label_cleanup();
7297
7298 rtnl_af_unregister(&inet6_ops);
7299
7300 rtnl_lock();
7301
7302
7303 for_each_netdev(&init_net, dev) {
7304 if (__in6_dev_get(dev) == NULL)
7305 continue;
7306 addrconf_ifdown(dev, true);
7307 }
7308 addrconf_ifdown(init_net.loopback_dev, true);
7309
7310
7311
7312
7313 spin_lock_bh(&addrconf_hash_lock);
7314 for (i = 0; i < IN6_ADDR_HSIZE; i++)
7315 WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
7316 spin_unlock_bh(&addrconf_hash_lock);
7317 cancel_delayed_work(&addr_chk_work);
7318 rtnl_unlock();
7319
7320 destroy_workqueue(addrconf_wq);
7321}
7322
