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