source: src/linux/universal/linux-3.18/net/ipv6/addrconf.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 2 months ago

update

File size: 132.3 KB
Line 
1/*
2 *      IPv6 Address [auto]configuration
3 *      Linux INET6 implementation
4 *
5 *      Authors:
6 *      Pedro Roque             <roque@di.fc.ul.pt>
7 *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
8 *
9 *      This program is free software; you can redistribute it and/or
10 *      modify it under the terms of the GNU General Public License
11 *      as published by the Free Software Foundation; either version
12 *      2 of the License, or (at your option) any later version.
13 */
14
15/*
16 *      Changes:
17 *
18 *      Janos Farkas                    :       delete timer on ifdown
19 *      <chexum@bankinf.banki.hu>
20 *      Andi Kleen                      :       kill double kfree on module
21 *                                              unload.
22 *      Maciej W. Rozycki               :       FDDI support
23 *      sekiya@USAGI                    :       Don't send too many RS
24 *                                              packets.
25 *      yoshfuji@USAGI                  :       Fixed interval between DAD
26 *                                              packets.
27 *      YOSHIFUJI Hideaki @USAGI        :       improved accuracy of
28 *                                              address validation timer.
29 *      YOSHIFUJI Hideaki @USAGI        :       Privacy Extensions (RFC3041)
30 *                                              support.
31 *      Yuji SEKIYA @USAGI              :       Don't assign a same IPv6
32 *                                              address on a same interface.
33 *      YOSHIFUJI Hideaki @USAGI        :       ARCnet support
34 *      YOSHIFUJI Hideaki @USAGI        :       convert /proc/net/if_inet6 to
35 *                                              seq_file.
36 *      YOSHIFUJI Hideaki @USAGI        :       improved source address
37 *                                              selection; consider scope,
38 *                                              status etc.
39 */
40
41#define pr_fmt(fmt) "IPv6: " fmt
42
43#include <linux/errno.h>
44#include <linux/types.h>
45#include <linux/kernel.h>
46#include <linux/socket.h>
47#include <linux/sockios.h>
48#include <linux/net.h>
49#include <linux/in6.h>
50#include <linux/netdevice.h>
51#include <linux/if_addr.h>
52#include <linux/if_arp.h>
53#include <linux/if_arcnet.h>
54#include <linux/if_infiniband.h>
55#include <linux/route.h>
56#include <linux/inetdevice.h>
57#include <linux/init.h>
58#include <linux/slab.h>
59#ifdef CONFIG_SYSCTL
60#include <linux/sysctl.h>
61#endif
62#include <linux/capability.h>
63#include <linux/delay.h>
64#include <linux/notifier.h>
65#include <linux/string.h>
66#include <linux/hash.h>
67
68#include <net/net_namespace.h>
69#include <net/sock.h>
70#include <net/snmp.h>
71
72#include <net/af_ieee802154.h>
73#include <net/firewire.h>
74#include <net/ipv6.h>
75#include <net/protocol.h>
76#include <net/ndisc.h>
77#include <net/ip6_route.h>
78#include <net/addrconf.h>
79#include <net/tcp.h>
80#include <net/ip.h>
81#include <net/netlink.h>
82#include <net/pkt_sched.h>
83#include <linux/if_tunnel.h>
84#include <linux/rtnetlink.h>
85#include <linux/netconf.h>
86#include <linux/random.h>
87#include <linux/uaccess.h>
88#include <asm/unaligned.h>
89
90#include <linux/proc_fs.h>
91#include <linux/seq_file.h>
92#include <linux/export.h>
93
94/* Set to 3 to get tracing... */
95#define ACONF_DEBUG 2
96
97#if ACONF_DEBUG >= 3
98#define ADBG(fmt, ...) printk(fmt, ##__VA_ARGS__)
99#else
100#define ADBG(fmt, ...) do { if (0) printk(fmt, ##__VA_ARGS__); } while (0)
101#endif
102
103#define INFINITY_LIFE_TIME      0xFFFFFFFF
104
105static inline u32 cstamp_delta(unsigned long cstamp)
106{
107        return (cstamp - INITIAL_JIFFIES) * 100UL / HZ;
108}
109
110#ifdef CONFIG_SYSCTL
111static int addrconf_sysctl_register(struct inet6_dev *idev);
112static void addrconf_sysctl_unregister(struct inet6_dev *idev);
113#else
114static inline int addrconf_sysctl_register(struct inet6_dev *idev)
115{
116        return 0;
117}
118
119static inline void addrconf_sysctl_unregister(struct inet6_dev *idev)
120{
121}
122#endif
123
124static void __ipv6_regen_rndid(struct inet6_dev *idev);
125static void __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr);
126static void ipv6_regen_rndid(unsigned long data);
127
128static int ipv6_generate_eui64(u8 *eui, struct net_device *dev);
129static int ipv6_count_addresses(struct inet6_dev *idev);
130
131/*
132 *      Configured unicast address hash table
133 */
134static struct hlist_head inet6_addr_lst[IN6_ADDR_HSIZE];
135static DEFINE_SPINLOCK(addrconf_hash_lock);
136
137static void addrconf_verify(void);
138static void addrconf_verify_rtnl(void);
139static void addrconf_verify_work(struct work_struct *);
140
141static struct workqueue_struct *addrconf_wq;
142static DECLARE_DELAYED_WORK(addr_chk_work, addrconf_verify_work);
143
144static void addrconf_join_anycast(struct inet6_ifaddr *ifp);
145static void addrconf_leave_anycast(struct inet6_ifaddr *ifp);
146
147static void addrconf_type_change(struct net_device *dev,
148                                 unsigned long event);
149static int addrconf_ifdown(struct net_device *dev, int how);
150
151static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
152                                                  int plen,
153                                                  const struct net_device *dev,
154                                                  u32 flags, u32 noflags);
155
156static void addrconf_dad_start(struct inet6_ifaddr *ifp);
157static void addrconf_dad_work(struct work_struct *w);
158static void addrconf_dad_completed(struct inet6_ifaddr *ifp);
159static void addrconf_dad_run(struct inet6_dev *idev);
160static void addrconf_rs_timer(unsigned long data);
161static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
162static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
163
164static void inet6_prefix_notify(int event, struct inet6_dev *idev,
165                                struct prefix_info *pinfo);
166static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
167                               struct net_device *dev);
168
169static struct ipv6_devconf ipv6_devconf __read_mostly = {
170        .forwarding             = 0,
171        .hop_limit              = IPV6_DEFAULT_HOPLIMIT,
172        .mtu6                   = IPV6_MIN_MTU,
173        .accept_ra              = 1,
174        .accept_redirects       = 1,
175        .autoconf               = 1,
176        .force_mld_version      = 0,
177        .mldv1_unsolicited_report_interval = 10 * HZ,
178        .mldv2_unsolicited_report_interval = HZ,
179        .dad_transmits          = 1,
180        .rtr_solicits           = MAX_RTR_SOLICITATIONS,
181        .rtr_solicit_interval   = RTR_SOLICITATION_INTERVAL,
182        .rtr_solicit_delay      = MAX_RTR_SOLICITATION_DELAY,
183        .use_tempaddr           = 0,
184        .temp_valid_lft         = TEMP_VALID_LIFETIME,
185        .temp_prefered_lft      = TEMP_PREFERRED_LIFETIME,
186        .regen_max_retry        = REGEN_MAX_RETRY,
187        .max_desync_factor      = MAX_DESYNC_FACTOR,
188        .max_addresses          = IPV6_MAX_ADDRESSES,
189        .accept_ra_defrtr       = 1,
190        .accept_ra_from_local   = 0,
191        .accept_ra_pinfo        = 1,
192#ifdef CONFIG_IPV6_ROUTER_PREF
193        .accept_ra_rtr_pref     = 1,
194        .rtr_probe_interval     = 60 * HZ,
195#ifdef CONFIG_IPV6_ROUTE_INFO
196        .accept_ra_rt_info_max_plen = 0,
197#endif
198#endif
199        .proxy_ndp              = 0,
200        .accept_source_route    = 0,    /* we do not accept RH0 by default. */
201        .disable_ipv6           = 0,
202        .accept_dad             = 1,
203        .suppress_frag_ndisc    = 1,
204};
205
206static struct ipv6_devconf ipv6_devconf_dflt __read_mostly = {
207        .forwarding             = 0,
208        .hop_limit              = IPV6_DEFAULT_HOPLIMIT,
209        .mtu6                   = IPV6_MIN_MTU,
210        .accept_ra              = 1,
211        .accept_redirects       = 1,
212        .autoconf               = 1,
213        .force_mld_version      = 0,
214        .mldv1_unsolicited_report_interval = 10 * HZ,
215        .mldv2_unsolicited_report_interval = HZ,
216        .dad_transmits          = 1,
217        .rtr_solicits           = MAX_RTR_SOLICITATIONS,
218        .rtr_solicit_interval   = RTR_SOLICITATION_INTERVAL,
219        .rtr_solicit_delay      = MAX_RTR_SOLICITATION_DELAY,
220        .use_tempaddr           = 0,
221        .temp_valid_lft         = TEMP_VALID_LIFETIME,
222        .temp_prefered_lft      = TEMP_PREFERRED_LIFETIME,
223        .regen_max_retry        = REGEN_MAX_RETRY,
224        .max_desync_factor      = MAX_DESYNC_FACTOR,
225        .max_addresses          = IPV6_MAX_ADDRESSES,
226        .accept_ra_defrtr       = 1,
227        .accept_ra_from_local   = 0,
228        .accept_ra_pinfo        = 1,
229#ifdef CONFIG_IPV6_ROUTER_PREF
230        .accept_ra_rtr_pref     = 1,
231        .rtr_probe_interval     = 60 * HZ,
232#ifdef CONFIG_IPV6_ROUTE_INFO
233        .accept_ra_rt_info_max_plen = 0,
234#endif
235#endif
236        .proxy_ndp              = 0,
237        .accept_source_route    = 0,    /* we do not accept RH0 by default. */
238        .disable_ipv6           = 0,
239        .accept_dad             = 1,
240        .suppress_frag_ndisc    = 1,
241};
242
243/* Check if a valid qdisc is available */
244static inline bool addrconf_qdisc_ok(const struct net_device *dev)
245{
246        return !qdisc_tx_is_noop(dev);
247}
248
249static void addrconf_del_rs_timer(struct inet6_dev *idev)
250{
251        if (del_timer(&idev->rs_timer))
252                __in6_dev_put(idev);
253}
254
255static void addrconf_del_dad_work(struct inet6_ifaddr *ifp)
256{
257        if (cancel_delayed_work(&ifp->dad_work))
258                __in6_ifa_put(ifp);
259}
260
261static void addrconf_mod_rs_timer(struct inet6_dev *idev,
262                                  unsigned long when)
263{
264        if (!timer_pending(&idev->rs_timer))
265                in6_dev_hold(idev);
266        mod_timer(&idev->rs_timer, jiffies + when);
267}
268
269static void addrconf_mod_dad_work(struct inet6_ifaddr *ifp,
270                                   unsigned long delay)
271{
272        if (!delayed_work_pending(&ifp->dad_work))
273                in6_ifa_hold(ifp);
274        mod_delayed_work(addrconf_wq, &ifp->dad_work, delay);
275}
276
277static int snmp6_alloc_dev(struct inet6_dev *idev)
278{
279        int i;
280
281        idev->stats.ipv6 = alloc_percpu(struct ipstats_mib);
282        if (!idev->stats.ipv6)
283                goto err_ip;
284
285        for_each_possible_cpu(i) {
286                struct ipstats_mib *addrconf_stats;
287                addrconf_stats = per_cpu_ptr(idev->stats.ipv6, i);
288                u64_stats_init(&addrconf_stats->syncp);
289        }
290
291
292        idev->stats.icmpv6dev = kzalloc(sizeof(struct icmpv6_mib_device),
293                                        GFP_KERNEL);
294        if (!idev->stats.icmpv6dev)
295                goto err_icmp;
296        idev->stats.icmpv6msgdev = kzalloc(sizeof(struct icmpv6msg_mib_device),
297                                           GFP_KERNEL);
298        if (!idev->stats.icmpv6msgdev)
299                goto err_icmpmsg;
300
301        return 0;
302
303err_icmpmsg:
304        kfree(idev->stats.icmpv6dev);
305err_icmp:
306        free_percpu(idev->stats.ipv6);
307err_ip:
308        return -ENOMEM;
309}
310
311static struct inet6_dev *ipv6_add_dev(struct net_device *dev)
312{
313        struct inet6_dev *ndev;
314        int err = -ENOMEM;
315
316        ASSERT_RTNL();
317
318        if (dev->mtu < IPV6_MIN_MTU)
319                return ERR_PTR(-EINVAL);
320
321        ndev = kzalloc(sizeof(struct inet6_dev), GFP_KERNEL);
322        if (ndev == NULL)
323                return ERR_PTR(err);
324
325        rwlock_init(&ndev->lock);
326        ndev->dev = dev;
327        INIT_LIST_HEAD(&ndev->addr_list);
328        setup_timer(&ndev->rs_timer, addrconf_rs_timer,
329                    (unsigned long)ndev);
330        memcpy(&ndev->cnf, dev_net(dev)->ipv6.devconf_dflt, sizeof(ndev->cnf));
331        ndev->cnf.mtu6 = dev->mtu;
332        ndev->cnf.sysctl = NULL;
333        ndev->nd_parms = neigh_parms_alloc(dev, &nd_tbl);
334        if (ndev->nd_parms == NULL) {
335                kfree(ndev);
336                return ERR_PTR(err);
337        }
338        if (ndev->cnf.forwarding)
339                dev_disable_lro(dev);
340        /* We refer to the device */
341        dev_hold(dev);
342
343        if (snmp6_alloc_dev(ndev) < 0) {
344                ADBG(KERN_WARNING
345                        "%s: cannot allocate memory for statistics; dev=%s.\n",
346                        __func__, dev->name);
347                neigh_parms_release(&nd_tbl, ndev->nd_parms);
348                dev_put(dev);
349                kfree(ndev);
350                return ERR_PTR(err);
351        }
352
353        if (snmp6_register_dev(ndev) < 0) {
354                ADBG(KERN_WARNING
355                        "%s: cannot create /proc/net/dev_snmp6/%s\n",
356                        __func__, dev->name);
357                goto err_release;
358        }
359
360        /* One reference from device.  We must do this before
361         * we invoke __ipv6_regen_rndid().
362         */
363        in6_dev_hold(ndev);
364
365        if (dev->flags & (IFF_NOARP | IFF_LOOPBACK))
366                ndev->cnf.accept_dad = -1;
367
368#if IS_ENABLED(CONFIG_IPV6_SIT)
369        if (dev->type == ARPHRD_SIT && (dev->priv_flags & IFF_ISATAP)) {
370                pr_info("%s: Disabled Multicast RS\n", dev->name);
371                ndev->cnf.rtr_solicits = 0;
372        }
373#endif
374
375        INIT_LIST_HEAD(&ndev->tempaddr_list);
376        setup_timer(&ndev->regen_timer, ipv6_regen_rndid, (unsigned long)ndev);
377        if ((dev->flags&IFF_LOOPBACK) ||
378            dev->type == ARPHRD_TUNNEL ||
379            dev->type == ARPHRD_TUNNEL6 ||
380            dev->type == ARPHRD_SIT ||
381            dev->type == ARPHRD_NONE) {
382                ndev->cnf.use_tempaddr = -1;
383        } else {
384                in6_dev_hold(ndev);
385                ipv6_regen_rndid((unsigned long) ndev);
386        }
387
388        ndev->token = in6addr_any;
389
390        if (netif_running(dev) && addrconf_qdisc_ok(dev))
391                ndev->if_flags |= IF_READY;
392
393        ipv6_mc_init_dev(ndev);
394        ndev->tstamp = jiffies;
395        err = addrconf_sysctl_register(ndev);
396        if (err) {
397                ipv6_mc_destroy_dev(ndev);
398                del_timer(&ndev->regen_timer);
399                snmp6_unregister_dev(ndev);
400                goto err_release;
401        }
402        /* protected by rtnl_lock */
403        rcu_assign_pointer(dev->ip6_ptr, ndev);
404
405        /* Join interface-local all-node multicast group */
406        ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allnodes);
407
408        /* Join all-node multicast group */
409        ipv6_dev_mc_inc(dev, &in6addr_linklocal_allnodes);
410
411        /* Join all-router multicast group if forwarding is set */
412        if (ndev->cnf.forwarding && (dev->flags & IFF_MULTICAST))
413                ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
414
415        return ndev;
416
417err_release:
418        neigh_parms_release(&nd_tbl, ndev->nd_parms);
419        ndev->dead = 1;
420        in6_dev_finish_destroy(ndev);
421        return ERR_PTR(err);
422}
423
424static struct inet6_dev *ipv6_find_idev(struct net_device *dev)
425{
426        struct inet6_dev *idev;
427
428        ASSERT_RTNL();
429
430        idev = __in6_dev_get(dev);
431        if (!idev) {
432                idev = ipv6_add_dev(dev);
433                if (IS_ERR(idev))
434                        return NULL;
435        }
436
437        if (dev->flags&IFF_UP)
438                ipv6_mc_up(idev);
439        return idev;
440}
441
442static int inet6_netconf_msgsize_devconf(int type)
443{
444        int size =  NLMSG_ALIGN(sizeof(struct netconfmsg))
445                    + nla_total_size(4);        /* NETCONFA_IFINDEX */
446
447        /* type -1 is used for ALL */
448        if (type == -1 || type == NETCONFA_FORWARDING)
449                size += nla_total_size(4);
450#ifdef CONFIG_IPV6_MROUTE
451        if (type == -1 || type == NETCONFA_MC_FORWARDING)
452                size += nla_total_size(4);
453#endif
454        if (type == -1 || type == NETCONFA_PROXY_NEIGH)
455                size += nla_total_size(4);
456
457        return size;
458}
459
460static int inet6_netconf_fill_devconf(struct sk_buff *skb, int ifindex,
461                                      struct ipv6_devconf *devconf, u32 portid,
462                                      u32 seq, int event, unsigned int flags,
463                                      int type)
464{
465        struct nlmsghdr  *nlh;
466        struct netconfmsg *ncm;
467
468        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct netconfmsg),
469                        flags);
470        if (nlh == NULL)
471                return -EMSGSIZE;
472
473        ncm = nlmsg_data(nlh);
474        ncm->ncm_family = AF_INET6;
475
476        if (nla_put_s32(skb, NETCONFA_IFINDEX, ifindex) < 0)
477                goto nla_put_failure;
478
479        /* type -1 is used for ALL */
480        if ((type == -1 || type == NETCONFA_FORWARDING) &&
481            nla_put_s32(skb, NETCONFA_FORWARDING, devconf->forwarding) < 0)
482                goto nla_put_failure;
483#ifdef CONFIG_IPV6_MROUTE
484        if ((type == -1 || type == NETCONFA_MC_FORWARDING) &&
485            nla_put_s32(skb, NETCONFA_MC_FORWARDING,
486                        devconf->mc_forwarding) < 0)
487                goto nla_put_failure;
488#endif
489        if ((type == -1 || type == NETCONFA_PROXY_NEIGH) &&
490            nla_put_s32(skb, NETCONFA_PROXY_NEIGH, devconf->proxy_ndp) < 0)
491                goto nla_put_failure;
492
493        return nlmsg_end(skb, nlh);
494
495nla_put_failure:
496        nlmsg_cancel(skb, nlh);
497        return -EMSGSIZE;
498}
499
500void inet6_netconf_notify_devconf(struct net *net, int type, int ifindex,
501                                  struct ipv6_devconf *devconf)
502{
503        struct sk_buff *skb;
504        int err = -ENOBUFS;
505
506        skb = nlmsg_new(inet6_netconf_msgsize_devconf(type), GFP_ATOMIC);
507        if (skb == NULL)
508                goto errout;
509
510        err = inet6_netconf_fill_devconf(skb, ifindex, devconf, 0, 0,
511                                         RTM_NEWNETCONF, 0, type);
512        if (err < 0) {
513                /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
514                WARN_ON(err == -EMSGSIZE);
515                kfree_skb(skb);
516                goto errout;
517        }
518        rtnl_notify(skb, net, 0, RTNLGRP_IPV6_NETCONF, NULL, GFP_ATOMIC);
519        return;
520errout:
521        rtnl_set_sk_err(net, RTNLGRP_IPV6_NETCONF, err);
522}
523
524static const struct nla_policy devconf_ipv6_policy[NETCONFA_MAX+1] = {
525        [NETCONFA_IFINDEX]      = { .len = sizeof(int) },
526        [NETCONFA_FORWARDING]   = { .len = sizeof(int) },
527        [NETCONFA_PROXY_NEIGH]  = { .len = sizeof(int) },
528};
529
530static int inet6_netconf_get_devconf(struct sk_buff *in_skb,
531                                     struct nlmsghdr *nlh)
532{
533        struct net *net = sock_net(in_skb->sk);
534        struct nlattr *tb[NETCONFA_MAX+1];
535        struct netconfmsg *ncm;
536        struct sk_buff *skb;
537        struct ipv6_devconf *devconf;
538        struct inet6_dev *in6_dev;
539        struct net_device *dev;
540        int ifindex;
541        int err;
542
543        err = nlmsg_parse(nlh, sizeof(*ncm), tb, NETCONFA_MAX,
544                          devconf_ipv6_policy);
545        if (err < 0)
546                goto errout;
547
548        err = EINVAL;
549        if (!tb[NETCONFA_IFINDEX])
550                goto errout;
551
552        ifindex = nla_get_s32(tb[NETCONFA_IFINDEX]);
553        switch (ifindex) {
554        case NETCONFA_IFINDEX_ALL:
555                devconf = net->ipv6.devconf_all;
556                break;
557        case NETCONFA_IFINDEX_DEFAULT:
558                devconf = net->ipv6.devconf_dflt;
559                break;
560        default:
561                dev = __dev_get_by_index(net, ifindex);
562                if (dev == NULL)
563                        goto errout;
564                in6_dev = __in6_dev_get(dev);
565                if (in6_dev == NULL)
566                        goto errout;
567                devconf = &in6_dev->cnf;
568                break;
569        }
570
571        err = -ENOBUFS;
572        skb = nlmsg_new(inet6_netconf_msgsize_devconf(-1), GFP_ATOMIC);
573        if (skb == NULL)
574                goto errout;
575
576        err = inet6_netconf_fill_devconf(skb, ifindex, devconf,
577                                         NETLINK_CB(in_skb).portid,
578                                         nlh->nlmsg_seq, RTM_NEWNETCONF, 0,
579                                         -1);
580        if (err < 0) {
581                /* -EMSGSIZE implies BUG in inet6_netconf_msgsize_devconf() */
582                WARN_ON(err == -EMSGSIZE);
583                kfree_skb(skb);
584                goto errout;
585        }
586        err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
587errout:
588        return err;
589}
590
591static int inet6_netconf_dump_devconf(struct sk_buff *skb,
592                                      struct netlink_callback *cb)
593{
594        struct net *net = sock_net(skb->sk);
595        int h, s_h;
596        int idx, s_idx;
597        struct net_device *dev;
598        struct inet6_dev *idev;
599        struct hlist_head *head;
600
601        s_h = cb->args[0];
602        s_idx = idx = cb->args[1];
603
604        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
605                idx = 0;
606                head = &net->dev_index_head[h];
607                rcu_read_lock();
608                cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^
609                          net->dev_base_seq;
610                hlist_for_each_entry_rcu(dev, head, index_hlist) {
611                        if (idx < s_idx)
612                                goto cont;
613                        idev = __in6_dev_get(dev);
614                        if (!idev)
615                                goto cont;
616
617                        if (inet6_netconf_fill_devconf(skb, dev->ifindex,
618                                                       &idev->cnf,
619                                                       NETLINK_CB(cb->skb).portid,
620                                                       cb->nlh->nlmsg_seq,
621                                                       RTM_NEWNETCONF,
622                                                       NLM_F_MULTI,
623                                                       -1) <= 0) {
624                                rcu_read_unlock();
625                                goto done;
626                        }
627                        nl_dump_check_consistent(cb, nlmsg_hdr(skb));
628cont:
629                        idx++;
630                }
631                rcu_read_unlock();
632        }
633        if (h == NETDEV_HASHENTRIES) {
634                if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_ALL,
635                                               net->ipv6.devconf_all,
636                                               NETLINK_CB(cb->skb).portid,
637                                               cb->nlh->nlmsg_seq,
638                                               RTM_NEWNETCONF, NLM_F_MULTI,
639                                               -1) <= 0)
640                        goto done;
641                else
642                        h++;
643        }
644        if (h == NETDEV_HASHENTRIES + 1) {
645                if (inet6_netconf_fill_devconf(skb, NETCONFA_IFINDEX_DEFAULT,
646                                               net->ipv6.devconf_dflt,
647                                               NETLINK_CB(cb->skb).portid,
648                                               cb->nlh->nlmsg_seq,
649                                               RTM_NEWNETCONF, NLM_F_MULTI,
650                                               -1) <= 0)
651                        goto done;
652                else
653                        h++;
654        }
655done:
656        cb->args[0] = h;
657        cb->args[1] = idx;
658
659        return skb->len;
660}
661
662#ifdef CONFIG_SYSCTL
663static void dev_forward_change(struct inet6_dev *idev)
664{
665        struct net_device *dev;
666        struct inet6_ifaddr *ifa;
667
668        if (!idev)
669                return;
670        dev = idev->dev;
671        if (idev->cnf.forwarding)
672                dev_disable_lro(dev);
673        if (dev->flags & IFF_MULTICAST) {
674                if (idev->cnf.forwarding) {
675                        ipv6_dev_mc_inc(dev, &in6addr_linklocal_allrouters);
676                        ipv6_dev_mc_inc(dev, &in6addr_interfacelocal_allrouters);
677                        ipv6_dev_mc_inc(dev, &in6addr_sitelocal_allrouters);
678                } else {
679                        ipv6_dev_mc_dec(dev, &in6addr_linklocal_allrouters);
680                        ipv6_dev_mc_dec(dev, &in6addr_interfacelocal_allrouters);
681                        ipv6_dev_mc_dec(dev, &in6addr_sitelocal_allrouters);
682                }
683        }
684
685        list_for_each_entry(ifa, &idev->addr_list, if_list) {
686                if (ifa->flags&IFA_F_TENTATIVE)
687                        continue;
688                if (idev->cnf.forwarding)
689                        addrconf_join_anycast(ifa);
690                else
691                        addrconf_leave_anycast(ifa);
692        }
693        inet6_netconf_notify_devconf(dev_net(dev), NETCONFA_FORWARDING,
694                                     dev->ifindex, &idev->cnf);
695}
696
697
698static void addrconf_forward_change(struct net *net, __s32 newf)
699{
700        struct net_device *dev;
701        struct inet6_dev *idev;
702
703        for_each_netdev(net, dev) {
704                idev = __in6_dev_get(dev);
705                if (idev) {
706                        int changed = (!idev->cnf.forwarding) ^ (!newf);
707                        idev->cnf.forwarding = newf;
708                        if (changed)
709                                dev_forward_change(idev);
710                }
711        }
712}
713
714static int addrconf_fixup_forwarding(struct ctl_table *table, int *p, int newf)
715{
716        struct net *net;
717        int old;
718
719        if (!rtnl_trylock())
720                return restart_syscall();
721
722        net = (struct net *)table->extra2;
723        old = *p;
724        *p = newf;
725
726        if (p == &net->ipv6.devconf_dflt->forwarding) {
727                if ((!newf) ^ (!old))
728                        inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
729                                                     NETCONFA_IFINDEX_DEFAULT,
730                                                     net->ipv6.devconf_dflt);
731                rtnl_unlock();
732                return 0;
733        }
734
735        if (p == &net->ipv6.devconf_all->forwarding) {
736                net->ipv6.devconf_dflt->forwarding = newf;
737                addrconf_forward_change(net, newf);
738                if ((!newf) ^ (!old))
739                        inet6_netconf_notify_devconf(net, NETCONFA_FORWARDING,
740                                                     NETCONFA_IFINDEX_ALL,
741                                                     net->ipv6.devconf_all);
742        } else if ((!newf) ^ (!old))
743                dev_forward_change((struct inet6_dev *)table->extra1);
744        rtnl_unlock();
745
746        if (newf)
747                rt6_purge_dflt_routers(net);
748        return 1;
749}
750#endif
751
752/* Nobody refers to this ifaddr, destroy it */
753void inet6_ifa_finish_destroy(struct inet6_ifaddr *ifp)
754{
755        WARN_ON(!hlist_unhashed(&ifp->addr_lst));
756
757#ifdef NET_REFCNT_DEBUG
758        pr_debug("%s\n", __func__);
759#endif
760
761        in6_dev_put(ifp->idev);
762
763        if (cancel_delayed_work(&ifp->dad_work))
764                pr_notice("delayed DAD work was pending while freeing ifa=%p\n",
765                          ifp);
766
767        if (ifp->state != INET6_IFADDR_STATE_DEAD) {
768                pr_warn("Freeing alive inet6 address %p\n", ifp);
769                return;
770        }
771        ip6_rt_put(ifp->rt);
772
773        kfree_rcu(ifp, rcu);
774}
775
776static void
777ipv6_link_dev_addr(struct inet6_dev *idev, struct inet6_ifaddr *ifp)
778{
779        struct list_head *p;
780        int ifp_scope = ipv6_addr_src_scope(&ifp->addr);
781
782        /*
783         * Each device address list is sorted in order of scope -
784         * global before linklocal.
785         */
786        list_for_each(p, &idev->addr_list) {
787                struct inet6_ifaddr *ifa
788                        = list_entry(p, struct inet6_ifaddr, if_list);
789                if (ifp_scope >= ipv6_addr_src_scope(&ifa->addr))
790                        break;
791        }
792
793        list_add_tail(&ifp->if_list, p);
794}
795
796static u32 inet6_addr_hash(const struct in6_addr *addr)
797{
798        return hash_32(ipv6_addr_hash(addr), IN6_ADDR_HSIZE_SHIFT);
799}
800
801/* On success it returns ifp with increased reference count */
802
803static struct inet6_ifaddr *
804ipv6_add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
805              const struct in6_addr *peer_addr, int pfxlen,
806              int scope, u32 flags, u32 valid_lft, u32 prefered_lft)
807{
808        struct inet6_ifaddr *ifa = NULL;
809        struct rt6_info *rt;
810        unsigned int hash;
811        int err = 0;
812        int addr_type = ipv6_addr_type(addr);
813
814        if (addr_type == IPV6_ADDR_ANY ||
815            addr_type & IPV6_ADDR_MULTICAST ||
816            (!(idev->dev->flags & IFF_LOOPBACK) &&
817             addr_type & IPV6_ADDR_LOOPBACK))
818                return ERR_PTR(-EADDRNOTAVAIL);
819
820        rcu_read_lock_bh();
821        if (idev->dead) {
822                err = -ENODEV;                  /*XXX*/
823                goto out2;
824        }
825
826        if (idev->cnf.disable_ipv6) {
827                err = -EACCES;
828                goto out2;
829        }
830
831        spin_lock(&addrconf_hash_lock);
832
833        /* Ignore adding duplicate addresses on an interface */
834        if (ipv6_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
835                ADBG("ipv6_add_addr: already assigned\n");
836                err = -EEXIST;
837                goto out;
838        }
839
840        ifa = kzalloc(sizeof(struct inet6_ifaddr), GFP_ATOMIC);
841
842        if (ifa == NULL) {
843                ADBG("ipv6_add_addr: malloc failed\n");
844                err = -ENOBUFS;
845                goto out;
846        }
847
848        rt = addrconf_dst_alloc(idev, addr, false);
849        if (IS_ERR(rt)) {
850                err = PTR_ERR(rt);
851                goto out;
852        }
853
854        neigh_parms_data_state_setall(idev->nd_parms);
855
856        ifa->addr = *addr;
857        if (peer_addr)
858                ifa->peer_addr = *peer_addr;
859
860        spin_lock_init(&ifa->lock);
861        spin_lock_init(&ifa->state_lock);
862        INIT_DELAYED_WORK(&ifa->dad_work, addrconf_dad_work);
863        INIT_HLIST_NODE(&ifa->addr_lst);
864        ifa->scope = scope;
865        ifa->prefix_len = pfxlen;
866        ifa->flags = flags | IFA_F_TENTATIVE;
867        ifa->valid_lft = valid_lft;
868        ifa->prefered_lft = prefered_lft;
869        ifa->cstamp = ifa->tstamp = jiffies;
870        ifa->tokenized = false;
871
872        ifa->rt = rt;
873
874        ifa->idev = idev;
875        in6_dev_hold(idev);
876        /* For caller */
877        in6_ifa_hold(ifa);
878
879        /* Add to big hash table */
880        hash = inet6_addr_hash(addr);
881
882        hlist_add_head_rcu(&ifa->addr_lst, &inet6_addr_lst[hash]);
883        spin_unlock(&addrconf_hash_lock);
884
885        write_lock(&idev->lock);
886        /* Add to inet6_dev unicast addr list. */
887        ipv6_link_dev_addr(idev, ifa);
888
889        if (ifa->flags&IFA_F_TEMPORARY) {
890                list_add(&ifa->tmp_list, &idev->tempaddr_list);
891                in6_ifa_hold(ifa);
892        }
893
894        in6_ifa_hold(ifa);
895        write_unlock(&idev->lock);
896out2:
897        rcu_read_unlock_bh();
898
899        if (likely(err == 0))
900                inet6addr_notifier_call_chain(NETDEV_UP, ifa);
901        else {
902                kfree(ifa);
903                ifa = ERR_PTR(err);
904        }
905
906        return ifa;
907out:
908        spin_unlock(&addrconf_hash_lock);
909        goto out2;
910}
911
912enum cleanup_prefix_rt_t {
913        CLEANUP_PREFIX_RT_NOP,    /* no cleanup action for prefix route */
914        CLEANUP_PREFIX_RT_DEL,    /* delete the prefix route */
915        CLEANUP_PREFIX_RT_EXPIRE, /* update the lifetime of the prefix route */
916};
917
918/*
919 * Check, whether the prefix for ifp would still need a prefix route
920 * after deleting ifp. The function returns one of the CLEANUP_PREFIX_RT_*
921 * constants.
922 *
923 * 1) we don't purge prefix if address was not permanent.
924 *    prefix is managed by its own lifetime.
925 * 2) we also don't purge, if the address was IFA_F_NOPREFIXROUTE.
926 * 3) if there are no addresses, delete prefix.
927 * 4) if there are still other permanent address(es),
928 *    corresponding prefix is still permanent.
929 * 5) if there are still other addresses with IFA_F_NOPREFIXROUTE,
930 *    don't purge the prefix, assume user space is managing it.
931 * 6) otherwise, update prefix lifetime to the
932 *    longest valid lifetime among the corresponding
933 *    addresses on the device.
934 *    Note: subsequent RA will update lifetime.
935 **/
936static enum cleanup_prefix_rt_t
937check_cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long *expires)
938{
939        struct inet6_ifaddr *ifa;
940        struct inet6_dev *idev = ifp->idev;
941        unsigned long lifetime;
942        enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_DEL;
943
944        *expires = jiffies;
945
946        list_for_each_entry(ifa, &idev->addr_list, if_list) {
947                if (ifa == ifp)
948                        continue;
949                if (!ipv6_prefix_equal(&ifa->addr, &ifp->addr,
950                                       ifp->prefix_len))
951                        continue;
952                if (ifa->flags & (IFA_F_PERMANENT | IFA_F_NOPREFIXROUTE))
953                        return CLEANUP_PREFIX_RT_NOP;
954
955                action = CLEANUP_PREFIX_RT_EXPIRE;
956
957                spin_lock(&ifa->lock);
958
959                lifetime = addrconf_timeout_fixup(ifa->valid_lft, HZ);
960                /*
961                 * Note: Because this address is
962                 * not permanent, lifetime <
963                 * LONG_MAX / HZ here.
964                 */
965                if (time_before(*expires, ifa->tstamp + lifetime * HZ))
966                        *expires = ifa->tstamp + lifetime * HZ;
967                spin_unlock(&ifa->lock);
968        }
969
970        return action;
971}
972
973static void
974cleanup_prefix_route(struct inet6_ifaddr *ifp, unsigned long expires, bool del_rt)
975{
976        struct rt6_info *rt;
977
978        rt = addrconf_get_prefix_route(&ifp->addr,
979                                       ifp->prefix_len,
980                                       ifp->idev->dev,
981                                       0, RTF_GATEWAY | RTF_DEFAULT);
982        if (rt) {
983                if (del_rt)
984                        ip6_del_rt(rt);
985                else {
986                        if (!(rt->rt6i_flags & RTF_EXPIRES))
987                                rt6_set_expires(rt, expires);
988                        ip6_rt_put(rt);
989                }
990        }
991}
992
993
994/* This function wants to get referenced ifp and releases it before return */
995
996static void ipv6_del_addr(struct inet6_ifaddr *ifp)
997{
998        int state;
999        enum cleanup_prefix_rt_t action = CLEANUP_PREFIX_RT_NOP;
1000        unsigned long expires;
1001
1002        ASSERT_RTNL();
1003
1004        spin_lock_bh(&ifp->state_lock);
1005        state = ifp->state;
1006        ifp->state = INET6_IFADDR_STATE_DEAD;
1007        spin_unlock_bh(&ifp->state_lock);
1008
1009        if (state == INET6_IFADDR_STATE_DEAD)
1010                goto out;
1011
1012        spin_lock_bh(&addrconf_hash_lock);
1013        hlist_del_init_rcu(&ifp->addr_lst);
1014        spin_unlock_bh(&addrconf_hash_lock);
1015
1016        write_lock_bh(&ifp->idev->lock);
1017
1018        if (ifp->flags&IFA_F_TEMPORARY) {
1019                list_del(&ifp->tmp_list);
1020                if (ifp->ifpub) {
1021                        in6_ifa_put(ifp->ifpub);
1022                        ifp->ifpub = NULL;
1023                }
1024                __in6_ifa_put(ifp);
1025        }
1026
1027        if (ifp->flags & IFA_F_PERMANENT && !(ifp->flags & IFA_F_NOPREFIXROUTE))
1028                action = check_cleanup_prefix_route(ifp, &expires);
1029
1030        list_del_init(&ifp->if_list);
1031        __in6_ifa_put(ifp);
1032
1033        write_unlock_bh(&ifp->idev->lock);
1034
1035        addrconf_del_dad_work(ifp);
1036
1037        ipv6_ifa_notify(RTM_DELADDR, ifp);
1038
1039        inet6addr_notifier_call_chain(NETDEV_DOWN, ifp);
1040
1041        if (action != CLEANUP_PREFIX_RT_NOP) {
1042                cleanup_prefix_route(ifp, expires,
1043                        action == CLEANUP_PREFIX_RT_DEL);
1044        }
1045
1046        /* clean up prefsrc entries */
1047        rt6_remove_prefsrc(ifp);
1048out:
1049        in6_ifa_put(ifp);
1050}
1051
1052static int ipv6_create_tempaddr(struct inet6_ifaddr *ifp, struct inet6_ifaddr *ift)
1053{
1054        struct inet6_dev *idev = ifp->idev;
1055        struct in6_addr addr, *tmpaddr;
1056        unsigned long tmp_prefered_lft, tmp_valid_lft, tmp_tstamp, age;
1057        unsigned long regen_advance;
1058        int tmp_plen;
1059        int ret = 0;
1060        u32 addr_flags;
1061        unsigned long now = jiffies;
1062
1063        write_lock_bh(&idev->lock);
1064        if (ift) {
1065                spin_lock_bh(&ift->lock);
1066                memcpy(&addr.s6_addr[8], &ift->addr.s6_addr[8], 8);
1067                spin_unlock_bh(&ift->lock);
1068                tmpaddr = &addr;
1069        } else {
1070                tmpaddr = NULL;
1071        }
1072retry:
1073        in6_dev_hold(idev);
1074        if (idev->cnf.use_tempaddr <= 0) {
1075                write_unlock_bh(&idev->lock);
1076                pr_info("%s: use_tempaddr is disabled\n", __func__);
1077                in6_dev_put(idev);
1078                ret = -1;
1079                goto out;
1080        }
1081        spin_lock_bh(&ifp->lock);
1082        if (ifp->regen_count++ >= idev->cnf.regen_max_retry) {
1083                idev->cnf.use_tempaddr = -1;    /*XXX*/
1084                spin_unlock_bh(&ifp->lock);
1085                write_unlock_bh(&idev->lock);
1086                pr_warn("%s: regeneration time exceeded - disabled temporary address support\n",
1087                        __func__);
1088                in6_dev_put(idev);
1089                ret = -1;
1090                goto out;
1091        }
1092        in6_ifa_hold(ifp);
1093        memcpy(addr.s6_addr, ifp->addr.s6_addr, 8);
1094        __ipv6_try_regen_rndid(idev, tmpaddr);
1095        memcpy(&addr.s6_addr[8], idev->rndid, 8);
1096        age = (now - ifp->tstamp) / HZ;
1097        tmp_valid_lft = min_t(__u32,
1098                              ifp->valid_lft,
1099                              idev->cnf.temp_valid_lft + age);
1100        tmp_prefered_lft = min_t(__u32,
1101                                 ifp->prefered_lft,
1102                                 idev->cnf.temp_prefered_lft + age -
1103                                 idev->cnf.max_desync_factor);
1104        tmp_plen = ifp->prefix_len;
1105        tmp_tstamp = ifp->tstamp;
1106        spin_unlock_bh(&ifp->lock);
1107
1108        regen_advance = idev->cnf.regen_max_retry *
1109                        idev->cnf.dad_transmits *
1110                        NEIGH_VAR(idev->nd_parms, RETRANS_TIME) / HZ;
1111        write_unlock_bh(&idev->lock);
1112
1113        /* A temporary address is created only if this calculated Preferred
1114         * Lifetime is greater than REGEN_ADVANCE time units.  In particular,
1115         * an implementation must not create a temporary address with a zero
1116         * Preferred Lifetime.
1117         * Use age calculation as in addrconf_verify to avoid unnecessary
1118         * temporary addresses being generated.
1119         */
1120        age = (now - tmp_tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
1121        if (tmp_prefered_lft <= regen_advance + age) {
1122                in6_ifa_put(ifp);
1123                in6_dev_put(idev);
1124                ret = -1;
1125                goto out;
1126        }
1127
1128        addr_flags = IFA_F_TEMPORARY;
1129        /* set in addrconf_prefix_rcv() */
1130        if (ifp->flags & IFA_F_OPTIMISTIC)
1131                addr_flags |= IFA_F_OPTIMISTIC;
1132
1133        ift = ipv6_add_addr(idev, &addr, NULL, tmp_plen,
1134                            ipv6_addr_scope(&addr), addr_flags,
1135                            tmp_valid_lft, tmp_prefered_lft);
1136        if (IS_ERR(ift)) {
1137                in6_ifa_put(ifp);
1138                in6_dev_put(idev);
1139                pr_info("%s: retry temporary address regeneration\n", __func__);
1140                tmpaddr = &addr;
1141                write_lock_bh(&idev->lock);
1142                goto retry;
1143        }
1144
1145        spin_lock_bh(&ift->lock);
1146        ift->ifpub = ifp;
1147        ift->cstamp = now;
1148        ift->tstamp = tmp_tstamp;
1149        spin_unlock_bh(&ift->lock);
1150
1151        addrconf_dad_start(ift);
1152        in6_ifa_put(ift);
1153        in6_dev_put(idev);
1154out:
1155        return ret;
1156}
1157
1158/*
1159 *      Choose an appropriate source address (RFC3484)
1160 */
1161enum {
1162        IPV6_SADDR_RULE_INIT = 0,
1163        IPV6_SADDR_RULE_LOCAL,
1164        IPV6_SADDR_RULE_SCOPE,
1165        IPV6_SADDR_RULE_PREFERRED,
1166#ifdef CONFIG_IPV6_MIP6
1167        IPV6_SADDR_RULE_HOA,
1168#endif
1169        IPV6_SADDR_RULE_OIF,
1170        IPV6_SADDR_RULE_LABEL,
1171        IPV6_SADDR_RULE_PRIVACY,
1172        IPV6_SADDR_RULE_ORCHID,
1173        IPV6_SADDR_RULE_PREFIX,
1174        IPV6_SADDR_RULE_MAX
1175};
1176
1177struct ipv6_saddr_score {
1178        int                     rule;
1179        int                     addr_type;
1180        struct inet6_ifaddr     *ifa;
1181        DECLARE_BITMAP(scorebits, IPV6_SADDR_RULE_MAX);
1182        int                     scopedist;
1183        int                     matchlen;
1184};
1185
1186struct ipv6_saddr_dst {
1187        const struct in6_addr *addr;
1188        int ifindex;
1189        int scope;
1190        int label;
1191        unsigned int prefs;
1192};
1193
1194static inline int ipv6_saddr_preferred(int type)
1195{
1196        if (type & (IPV6_ADDR_MAPPED|IPV6_ADDR_COMPATv4|IPV6_ADDR_LOOPBACK))
1197                return 1;
1198        return 0;
1199}
1200
1201static int ipv6_get_saddr_eval(struct net *net,
1202                               struct ipv6_saddr_score *score,
1203                               struct ipv6_saddr_dst *dst,
1204                               int i)
1205{
1206        int ret;
1207
1208        if (i <= score->rule) {
1209                switch (i) {
1210                case IPV6_SADDR_RULE_SCOPE:
1211                        ret = score->scopedist;
1212                        break;
1213                case IPV6_SADDR_RULE_PREFIX:
1214                        ret = score->matchlen;
1215                        break;
1216                default:
1217                        ret = !!test_bit(i, score->scorebits);
1218                }
1219                goto out;
1220        }
1221
1222        switch (i) {
1223        case IPV6_SADDR_RULE_INIT:
1224                /* Rule 0: remember if hiscore is not ready yet */
1225                ret = !!score->ifa;
1226                break;
1227        case IPV6_SADDR_RULE_LOCAL:
1228                /* Rule 1: Prefer same address */
1229                ret = ipv6_addr_equal(&score->ifa->addr, dst->addr);
1230                break;
1231        case IPV6_SADDR_RULE_SCOPE:
1232                /* Rule 2: Prefer appropriate scope
1233                 *
1234                 *      ret
1235                 *       ^
1236                 *    -1 |  d 15
1237                 *    ---+--+-+---> scope
1238                 *       |
1239                 *       |             d is scope of the destination.
1240                 *  B-d  |  \
1241                 *       |   \      <- smaller scope is better if
1242                 *  B-15 |    \        if scope is enough for destination.
1243                 *       |             ret = B - scope (-1 <= scope >= d <= 15).
1244                 * d-C-1 | /
1245                 *       |/         <- greater is better
1246                 *   -C  /             if scope is not enough for destination.
1247                 *      /|             ret = scope - C (-1 <= d < scope <= 15).
1248                 *
1249                 * d - C - 1 < B -15 (for all -1 <= d <= 15).
1250                 * C > d + 14 - B >= 15 + 14 - B = 29 - B.
1251                 * Assume B = 0 and we get C > 29.
1252                 */
1253                ret = __ipv6_addr_src_scope(score->addr_type);
1254                if (ret >= dst->scope)
1255                        ret = -ret;
1256                else
1257                        ret -= 128;     /* 30 is enough */
1258                score->scopedist = ret;
1259                break;
1260        case IPV6_SADDR_RULE_PREFERRED:
1261                /* Rule 3: Avoid deprecated and optimistic addresses */
1262                ret = ipv6_saddr_preferred(score->addr_type) ||
1263                      !(score->ifa->flags & (IFA_F_DEPRECATED|IFA_F_OPTIMISTIC));
1264                break;
1265#ifdef CONFIG_IPV6_MIP6
1266        case IPV6_SADDR_RULE_HOA:
1267            {
1268                /* Rule 4: Prefer home address */
1269                int prefhome = !(dst->prefs & IPV6_PREFER_SRC_COA);
1270                ret = !(score->ifa->flags & IFA_F_HOMEADDRESS) ^ prefhome;
1271                break;
1272            }
1273#endif
1274        case IPV6_SADDR_RULE_OIF:
1275                /* Rule 5: Prefer outgoing interface */
1276                ret = (!dst->ifindex ||
1277                       dst->ifindex == score->ifa->idev->dev->ifindex);
1278                break;
1279        case IPV6_SADDR_RULE_LABEL:
1280                /* Rule 6: Prefer matching label */
1281                ret = ipv6_addr_label(net,
1282                                      &score->ifa->addr, score->addr_type,
1283                                      score->ifa->idev->dev->ifindex) == dst->label;
1284                break;
1285        case IPV6_SADDR_RULE_PRIVACY:
1286            {
1287                /* Rule 7: Prefer public address
1288                 * Note: prefer temporary address if use_tempaddr >= 2
1289                 */
1290                int preftmp = dst->prefs & (IPV6_PREFER_SRC_PUBLIC|IPV6_PREFER_SRC_TMP) ?
1291                                !!(dst->prefs & IPV6_PREFER_SRC_TMP) :
1292                                score->ifa->idev->cnf.use_tempaddr >= 2;
1293                ret = (!(score->ifa->flags & IFA_F_TEMPORARY)) ^ preftmp;
1294                break;
1295            }
1296        case IPV6_SADDR_RULE_ORCHID:
1297                /* Rule 8-: Prefer ORCHID vs ORCHID or
1298                 *          non-ORCHID vs non-ORCHID
1299                 */
1300                ret = !(ipv6_addr_orchid(&score->ifa->addr) ^
1301                        ipv6_addr_orchid(dst->addr));
1302                break;
1303        case IPV6_SADDR_RULE_PREFIX:
1304                /* Rule 8: Use longest matching prefix */
1305                ret = ipv6_addr_diff(&score->ifa->addr, dst->addr);
1306                if (ret > score->ifa->prefix_len)
1307                        ret = score->ifa->prefix_len;
1308                score->matchlen = ret;
1309                break;
1310        default:
1311                ret = 0;
1312        }
1313
1314        if (ret)
1315                __set_bit(i, score->scorebits);
1316        score->rule = i;
1317out:
1318        return ret;
1319}
1320
1321int ipv6_dev_get_saddr(struct net *net, const struct net_device *dst_dev,
1322                       const struct in6_addr *daddr, unsigned int prefs,
1323                       struct in6_addr *saddr)
1324{
1325        struct ipv6_saddr_score scores[2],
1326                                *score = &scores[0], *hiscore = &scores[1];
1327        struct ipv6_saddr_dst dst;
1328        struct net_device *dev;
1329        int dst_type;
1330
1331        dst_type = __ipv6_addr_type(daddr);
1332        dst.addr = daddr;
1333        dst.ifindex = dst_dev ? dst_dev->ifindex : 0;
1334        dst.scope = __ipv6_addr_src_scope(dst_type);
1335        dst.label = ipv6_addr_label(net, daddr, dst_type, dst.ifindex);
1336        dst.prefs = prefs;
1337
1338        hiscore->rule = -1;
1339        hiscore->ifa = NULL;
1340
1341        rcu_read_lock();
1342
1343        for_each_netdev_rcu(net, dev) {
1344                struct inet6_dev *idev;
1345
1346                /* Candidate Source Address (section 4)
1347                 *  - multicast and link-local destination address,
1348                 *    the set of candidate source address MUST only
1349                 *    include addresses assigned to interfaces
1350                 *    belonging to the same link as the outgoing
1351                 *    interface.
1352                 * (- For site-local destination addresses, the
1353                 *    set of candidate source addresses MUST only
1354                 *    include addresses assigned to interfaces
1355                 *    belonging to the same site as the outgoing
1356                 *    interface.)
1357                 */
1358                if (((dst_type & IPV6_ADDR_MULTICAST) ||
1359                     dst.scope <= IPV6_ADDR_SCOPE_LINKLOCAL) &&
1360                    dst.ifindex && dev->ifindex != dst.ifindex)
1361                        continue;
1362
1363                idev = __in6_dev_get(dev);
1364                if (!idev)
1365                        continue;
1366
1367                read_lock_bh(&idev->lock);
1368                list_for_each_entry(score->ifa, &idev->addr_list, if_list) {
1369                        int i;
1370
1371                        /*
1372                         * - Tentative Address (RFC2462 section 5.4)
1373                         *  - A tentative address is not considered
1374                         *    "assigned to an interface" in the traditional
1375                         *    sense, unless it is also flagged as optimistic.
1376                         * - Candidate Source Address (section 4)
1377                         *  - In any case, anycast addresses, multicast
1378                         *    addresses, and the unspecified address MUST
1379                         *    NOT be included in a candidate set.
1380                         */
1381                        if ((score->ifa->flags & IFA_F_TENTATIVE) &&
1382                            (!(score->ifa->flags & IFA_F_OPTIMISTIC)))
1383                                continue;
1384
1385                        score->addr_type = __ipv6_addr_type(&score->ifa->addr);
1386
1387                        if (unlikely(score->addr_type == IPV6_ADDR_ANY ||
1388                                     score->addr_type & IPV6_ADDR_MULTICAST)) {
1389                                LIMIT_NETDEBUG(KERN_DEBUG
1390                                               "ADDRCONF: unspecified / multicast address "
1391                                               "assigned as unicast address on %s",
1392                                               dev->name);
1393                                continue;
1394                        }
1395
1396                        score->rule = -1;
1397                        bitmap_zero(score->scorebits, IPV6_SADDR_RULE_MAX);
1398
1399                        for (i = 0; i < IPV6_SADDR_RULE_MAX; i++) {
1400                                int minihiscore, miniscore;
1401
1402                                minihiscore = ipv6_get_saddr_eval(net, hiscore, &dst, i);
1403                                miniscore = ipv6_get_saddr_eval(net, score, &dst, i);
1404
1405                                if (minihiscore > miniscore) {
1406                                        if (i == IPV6_SADDR_RULE_SCOPE &&
1407                                            score->scopedist > 0) {
1408                                                /*
1409                                                 * special case:
1410                                                 * each remaining entry
1411                                                 * has too small (not enough)
1412                                                 * scope, because ifa entries
1413                                                 * are sorted by their scope
1414                                                 * values.
1415                                                 */
1416                                                goto try_nextdev;
1417                                        }
1418                                        break;
1419                                } else if (minihiscore < miniscore) {
1420                                        if (hiscore->ifa)
1421                                                in6_ifa_put(hiscore->ifa);
1422
1423                                        in6_ifa_hold(score->ifa);
1424
1425                                        swap(hiscore, score);
1426
1427                                        /* restore our iterator */
1428                                        score->ifa = hiscore->ifa;
1429
1430                                        break;
1431                                }
1432                        }
1433                }
1434try_nextdev:
1435                read_unlock_bh(&idev->lock);
1436        }
1437        rcu_read_unlock();
1438
1439        if (!hiscore->ifa)
1440                return -EADDRNOTAVAIL;
1441
1442        *saddr = hiscore->ifa->addr;
1443        in6_ifa_put(hiscore->ifa);
1444        return 0;
1445}
1446EXPORT_SYMBOL(ipv6_dev_get_saddr);
1447
1448int __ipv6_get_lladdr(struct inet6_dev *idev, struct in6_addr *addr,
1449                      u32 banned_flags)
1450{
1451        struct inet6_ifaddr *ifp;
1452        int err = -EADDRNOTAVAIL;
1453
1454        list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
1455                if (ifp->scope > IFA_LINK)
1456                        break;
1457                if (ifp->scope == IFA_LINK &&
1458                    !(ifp->flags & banned_flags)) {
1459                        *addr = ifp->addr;
1460                        err = 0;
1461                        break;
1462                }
1463        }
1464        return err;
1465}
1466
1467int ipv6_get_lladdr(struct net_device *dev, struct in6_addr *addr,
1468                    u32 banned_flags)
1469{
1470        struct inet6_dev *idev;
1471        int err = -EADDRNOTAVAIL;
1472
1473        rcu_read_lock();
1474        idev = __in6_dev_get(dev);
1475        if (idev) {
1476                read_lock_bh(&idev->lock);
1477                err = __ipv6_get_lladdr(idev, addr, banned_flags);
1478                read_unlock_bh(&idev->lock);
1479        }
1480        rcu_read_unlock();
1481        return err;
1482}
1483
1484static int ipv6_count_addresses(struct inet6_dev *idev)
1485{
1486        int cnt = 0;
1487        struct inet6_ifaddr *ifp;
1488
1489        read_lock_bh(&idev->lock);
1490        list_for_each_entry(ifp, &idev->addr_list, if_list)
1491                cnt++;
1492        read_unlock_bh(&idev->lock);
1493        return cnt;
1494}
1495
1496int ipv6_chk_addr(struct net *net, const struct in6_addr *addr,
1497                  const struct net_device *dev, int strict)
1498{
1499        struct inet6_ifaddr *ifp;
1500        unsigned int hash = inet6_addr_hash(addr);
1501
1502        rcu_read_lock_bh();
1503        hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) {
1504                if (!net_eq(dev_net(ifp->idev->dev), net))
1505                        continue;
1506                if (ipv6_addr_equal(&ifp->addr, addr) &&
1507                    !(ifp->flags&IFA_F_TENTATIVE) &&
1508                    (dev == NULL || ifp->idev->dev == dev ||
1509                     !(ifp->scope&(IFA_LINK|IFA_HOST) || strict))) {
1510                        rcu_read_unlock_bh();
1511                        return 1;
1512                }
1513        }
1514
1515        rcu_read_unlock_bh();
1516        return 0;
1517}
1518EXPORT_SYMBOL(ipv6_chk_addr);
1519
1520static bool ipv6_chk_same_addr(struct net *net, const struct in6_addr *addr,
1521                               struct net_device *dev)
1522{
1523        unsigned int hash = inet6_addr_hash(addr);
1524        struct inet6_ifaddr *ifp;
1525
1526        hlist_for_each_entry(ifp, &inet6_addr_lst[hash], addr_lst) {
1527                if (!net_eq(dev_net(ifp->idev->dev), net))
1528                        continue;
1529                if (ipv6_addr_equal(&ifp->addr, addr)) {
1530                        if (dev == NULL || ifp->idev->dev == dev)
1531                                return true;
1532                }
1533        }
1534        return false;
1535}
1536
1537/* Compares an address/prefix_len with addresses on device @dev.
1538 * If one is found it returns true.
1539 */
1540bool ipv6_chk_custom_prefix(const struct in6_addr *addr,
1541        const unsigned int prefix_len, struct net_device *dev)
1542{
1543        struct inet6_dev *idev;
1544        struct inet6_ifaddr *ifa;
1545        bool ret = false;
1546
1547        rcu_read_lock();
1548        idev = __in6_dev_get(dev);
1549        if (idev) {
1550                read_lock_bh(&idev->lock);
1551                list_for_each_entry(ifa, &idev->addr_list, if_list) {
1552                        ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len);
1553                        if (ret)
1554                                break;
1555                }
1556                read_unlock_bh(&idev->lock);
1557        }
1558        rcu_read_unlock();
1559
1560        return ret;
1561}
1562EXPORT_SYMBOL(ipv6_chk_custom_prefix);
1563
1564int ipv6_chk_prefix(const struct in6_addr *addr, struct net_device *dev)
1565{
1566        struct inet6_dev *idev;
1567        struct inet6_ifaddr *ifa;
1568        int     onlink;
1569
1570        onlink = 0;
1571        rcu_read_lock();
1572        idev = __in6_dev_get(dev);
1573        if (idev) {
1574                read_lock_bh(&idev->lock);
1575                list_for_each_entry(ifa, &idev->addr_list, if_list) {
1576                        onlink = ipv6_prefix_equal(addr, &ifa->addr,
1577                                                   ifa->prefix_len);
1578                        if (onlink)
1579                                break;
1580                }
1581                read_unlock_bh(&idev->lock);
1582        }
1583        rcu_read_unlock();
1584        return onlink;
1585}
1586EXPORT_SYMBOL(ipv6_chk_prefix);
1587
1588struct inet6_ifaddr *ipv6_get_ifaddr(struct net *net, const struct in6_addr *addr,
1589                                     struct net_device *dev, int strict)
1590{
1591        struct inet6_ifaddr *ifp, *result = NULL;
1592        unsigned int hash = inet6_addr_hash(addr);
1593
1594        rcu_read_lock_bh();
1595        hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
1596                if (!net_eq(dev_net(ifp->idev->dev), net))
1597                        continue;
1598                if (ipv6_addr_equal(&ifp->addr, addr)) {
1599                        if (dev == NULL || ifp->idev->dev == dev ||
1600                            !(ifp->scope&(IFA_LINK|IFA_HOST) || strict)) {
1601                                result = ifp;
1602                                in6_ifa_hold(ifp);
1603                                break;
1604                        }
1605                }
1606        }
1607        rcu_read_unlock_bh();
1608
1609        return result;
1610}
1611
1612/* Gets referenced address, destroys ifaddr */
1613
1614static void addrconf_dad_stop(struct inet6_ifaddr *ifp, int dad_failed)
1615{
1616        if (ifp->flags&IFA_F_PERMANENT) {
1617                spin_lock_bh(&ifp->lock);
1618                addrconf_del_dad_work(ifp);
1619                ifp->flags |= IFA_F_TENTATIVE;
1620                if (dad_failed)
1621                        ifp->flags |= IFA_F_DADFAILED;
1622                spin_unlock_bh(&ifp->lock);
1623                if (dad_failed)
1624                        ipv6_ifa_notify(0, ifp);
1625                in6_ifa_put(ifp);
1626        } else if (ifp->flags&IFA_F_TEMPORARY) {
1627                struct inet6_ifaddr *ifpub;
1628                spin_lock_bh(&ifp->lock);
1629                ifpub = ifp->ifpub;
1630                if (ifpub) {
1631                        in6_ifa_hold(ifpub);
1632                        spin_unlock_bh(&ifp->lock);
1633                        ipv6_create_tempaddr(ifpub, ifp);
1634                        in6_ifa_put(ifpub);
1635                } else {
1636                        spin_unlock_bh(&ifp->lock);
1637                }
1638                ipv6_del_addr(ifp);
1639        } else {
1640                ipv6_del_addr(ifp);
1641        }
1642}
1643
1644static int addrconf_dad_end(struct inet6_ifaddr *ifp)
1645{
1646        int err = -ENOENT;
1647
1648        spin_lock_bh(&ifp->state_lock);
1649        if (ifp->state == INET6_IFADDR_STATE_DAD) {
1650                ifp->state = INET6_IFADDR_STATE_POSTDAD;
1651                err = 0;
1652        }
1653        spin_unlock_bh(&ifp->state_lock);
1654
1655        return err;
1656}
1657
1658void addrconf_dad_failure(struct inet6_ifaddr *ifp)
1659{
1660        struct inet6_dev *idev = ifp->idev;
1661
1662        if (addrconf_dad_end(ifp)) {
1663                in6_ifa_put(ifp);
1664                return;
1665        }
1666
1667        net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n",
1668                             ifp->idev->dev->name, &ifp->addr);
1669
1670        if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
1671                struct in6_addr addr;
1672
1673                addr.s6_addr32[0] = htonl(0xfe800000);
1674                addr.s6_addr32[1] = 0;
1675
1676                if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
1677                    ipv6_addr_equal(&ifp->addr, &addr)) {
1678                        /* DAD failed for link-local based on MAC address */
1679                        idev->cnf.disable_ipv6 = 1;
1680
1681                        pr_info("%s: IPv6 being disabled!\n",
1682                                ifp->idev->dev->name);
1683                }
1684        }
1685
1686        spin_lock_bh(&ifp->state_lock);
1687        /* transition from _POSTDAD to _ERRDAD */
1688        ifp->state = INET6_IFADDR_STATE_ERRDAD;
1689        spin_unlock_bh(&ifp->state_lock);
1690
1691        addrconf_mod_dad_work(ifp, 0);
1692        in6_ifa_put(ifp);
1693}
1694
1695/* Join to solicited addr multicast group.
1696 * caller must hold RTNL */
1697void addrconf_join_solict(struct net_device *dev, const struct in6_addr *addr)
1698{
1699        struct in6_addr maddr;
1700
1701        if (dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1702                return;
1703
1704        addrconf_addr_solict_mult(addr, &maddr);
1705        ipv6_dev_mc_inc(dev, &maddr);
1706}
1707
1708/* caller must hold RTNL */
1709void addrconf_leave_solict(struct inet6_dev *idev, const struct in6_addr *addr)
1710{
1711        struct in6_addr maddr;
1712
1713        if (idev->dev->flags&(IFF_LOOPBACK|IFF_NOARP))
1714                return;
1715
1716        addrconf_addr_solict_mult(addr, &maddr);
1717        __ipv6_dev_mc_dec(idev, &maddr);
1718}
1719
1720/* caller must hold RTNL */
1721static void addrconf_join_anycast(struct inet6_ifaddr *ifp)
1722{
1723        struct in6_addr addr;
1724
1725        if (ifp->prefix_len >= 127) /* RFC 6164 */
1726                return;
1727        ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1728        if (ipv6_addr_any(&addr))
1729                return;
1730        __ipv6_dev_ac_inc(ifp->idev, &addr);
1731}
1732
1733/* caller must hold RTNL */
1734static void addrconf_leave_anycast(struct inet6_ifaddr *ifp)
1735{
1736        struct in6_addr addr;
1737
1738        if (ifp->prefix_len >= 127) /* RFC 6164 */
1739                return;
1740        ipv6_addr_prefix(&addr, &ifp->addr, ifp->prefix_len);
1741        if (ipv6_addr_any(&addr))
1742                return;
1743        __ipv6_dev_ac_dec(ifp->idev, &addr);
1744}
1745
1746static int addrconf_ifid_eui48(u8 *eui, struct net_device *dev)
1747{
1748        if (dev->addr_len != ETH_ALEN)
1749                return -1;
1750        memcpy(eui, dev->dev_addr, 3);
1751        memcpy(eui + 5, dev->dev_addr + 3, 3);
1752
1753        /*
1754         * The zSeries OSA network cards can be shared among various
1755         * OS instances, but the OSA cards have only one MAC address.
1756         * This leads to duplicate address conflicts in conjunction
1757         * with IPv6 if more than one instance uses the same card.
1758         *
1759         * The driver for these cards can deliver a unique 16-bit
1760         * identifier for each instance sharing the same card.  It is
1761         * placed instead of 0xFFFE in the interface identifier.  The
1762         * "u" bit of the interface identifier is not inverted in this
1763         * case.  Hence the resulting interface identifier has local
1764         * scope according to RFC2373.
1765         */
1766        if (dev->dev_id) {
1767                eui[3] = (dev->dev_id >> 8) & 0xFF;
1768                eui[4] = dev->dev_id & 0xFF;
1769        } else {
1770                eui[3] = 0xFF;
1771                eui[4] = 0xFE;
1772                eui[0] ^= 2;
1773        }
1774        return 0;
1775}
1776
1777static int addrconf_ifid_eui64(u8 *eui, struct net_device *dev)
1778{
1779        if (dev->addr_len != IEEE802154_ADDR_LEN)
1780                return -1;
1781        memcpy(eui, dev->dev_addr, 8);
1782        eui[0] ^= 2;
1783        return 0;
1784}
1785
1786static int addrconf_ifid_ieee1394(u8 *eui, struct net_device *dev)
1787{
1788        union fwnet_hwaddr *ha;
1789
1790        if (dev->addr_len != FWNET_ALEN)
1791                return -1;
1792
1793        ha = (union fwnet_hwaddr *)dev->dev_addr;
1794
1795        memcpy(eui, &ha->uc.uniq_id, sizeof(ha->uc.uniq_id));
1796        eui[0] ^= 2;
1797        return 0;
1798}
1799
1800static int addrconf_ifid_arcnet(u8 *eui, struct net_device *dev)
1801{
1802        /* XXX: inherit EUI-64 from other interface -- yoshfuji */
1803        if (dev->addr_len != ARCNET_ALEN)
1804                return -1;
1805        memset(eui, 0, 7);
1806        eui[7] = *(u8 *)dev->dev_addr;
1807        return 0;
1808}
1809
1810static int addrconf_ifid_infiniband(u8 *eui, struct net_device *dev)
1811{
1812        if (dev->addr_len != INFINIBAND_ALEN)
1813                return -1;
1814        memcpy(eui, dev->dev_addr + 12, 8);
1815        eui[0] |= 2;
1816        return 0;
1817}
1818
1819static int __ipv6_isatap_ifid(u8 *eui, __be32 addr)
1820{
1821        if (addr == 0)
1822                return -1;
1823        eui[0] = (ipv4_is_zeronet(addr) || ipv4_is_private_10(addr) ||
1824                  ipv4_is_loopback(addr) || ipv4_is_linklocal_169(addr) ||
1825                  ipv4_is_private_172(addr) || ipv4_is_test_192(addr) ||
1826                  ipv4_is_anycast_6to4(addr) || ipv4_is_private_192(addr) ||
1827                  ipv4_is_test_198(addr) || ipv4_is_multicast(addr) ||
1828                  ipv4_is_lbcast(addr)) ? 0x00 : 0x02;
1829        eui[1] = 0;
1830        eui[2] = 0x5E;
1831        eui[3] = 0xFE;
1832        memcpy(eui + 4, &addr, 4);
1833        return 0;
1834}
1835
1836static int addrconf_ifid_sit(u8 *eui, struct net_device *dev)
1837{
1838        if (dev->priv_flags & IFF_ISATAP)
1839                return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
1840        return -1;
1841}
1842
1843static int addrconf_ifid_gre(u8 *eui, struct net_device *dev)
1844{
1845        return __ipv6_isatap_ifid(eui, *(__be32 *)dev->dev_addr);
1846}
1847
1848static int addrconf_ifid_ip6tnl(u8 *eui, struct net_device *dev)
1849{
1850        memcpy(eui, dev->perm_addr, 3);
1851        memcpy(eui + 5, dev->perm_addr + 3, 3);
1852        eui[3] = 0xFF;
1853        eui[4] = 0xFE;
1854        eui[0] ^= 2;
1855        return 0;
1856}
1857
1858static int ipv6_generate_eui64(u8 *eui, struct net_device *dev)
1859{
1860        switch (dev->type) {
1861        case ARPHRD_ETHER:
1862        case ARPHRD_FDDI:
1863                return addrconf_ifid_eui48(eui, dev);
1864        case ARPHRD_ARCNET:
1865                return addrconf_ifid_arcnet(eui, dev);
1866        case ARPHRD_INFINIBAND:
1867                return addrconf_ifid_infiniband(eui, dev);
1868        case ARPHRD_SIT:
1869                return addrconf_ifid_sit(eui, dev);
1870        case ARPHRD_IPGRE:
1871                return addrconf_ifid_gre(eui, dev);
1872        case ARPHRD_6LOWPAN:
1873        case ARPHRD_IEEE802154:
1874                return addrconf_ifid_eui64(eui, dev);
1875        case ARPHRD_IEEE1394:
1876                return addrconf_ifid_ieee1394(eui, dev);
1877        case ARPHRD_TUNNEL6:
1878                return addrconf_ifid_ip6tnl(eui, dev);
1879        }
1880        return -1;
1881}
1882
1883static int ipv6_inherit_eui64(u8 *eui, struct inet6_dev *idev)
1884{
1885        int err = -1;
1886        struct inet6_ifaddr *ifp;
1887
1888        read_lock_bh(&idev->lock);
1889        list_for_each_entry_reverse(ifp, &idev->addr_list, if_list) {
1890                if (ifp->scope > IFA_LINK)
1891                        break;
1892                if (ifp->scope == IFA_LINK && !(ifp->flags&IFA_F_TENTATIVE)) {
1893                        memcpy(eui, ifp->addr.s6_addr+8, 8);
1894                        err = 0;
1895                        break;
1896                }
1897        }
1898        read_unlock_bh(&idev->lock);
1899        return err;
1900}
1901
1902/* (re)generation of randomized interface identifier (RFC 3041 3.2, 3.5) */
1903static void __ipv6_regen_rndid(struct inet6_dev *idev)
1904{
1905regen:
1906        get_random_bytes(idev->rndid, sizeof(idev->rndid));
1907        idev->rndid[0] &= ~0x02;
1908
1909        /*
1910         * <draft-ietf-ipngwg-temp-addresses-v2-00.txt>:
1911         * check if generated address is not inappropriate
1912         *
1913         *  - Reserved subnet anycast (RFC 2526)
1914         *      11111101 11....11 1xxxxxxx
1915         *  - ISATAP (RFC4214) 6.1
1916         *      00-00-5E-FE-xx-xx-xx-xx
1917         *  - value 0
1918         *  - XXX: already assigned to an address on the device
1919         */
1920        if (idev->rndid[0] == 0xfd &&
1921            (idev->rndid[1]&idev->rndid[2]&idev->rndid[3]&idev->rndid[4]&idev->rndid[5]&idev->rndid[6]) == 0xff &&
1922            (idev->rndid[7]&0x80))
1923                goto regen;
1924        if ((idev->rndid[0]|idev->rndid[1]) == 0) {
1925                if (idev->rndid[2] == 0x5e && idev->rndid[3] == 0xfe)
1926                        goto regen;
1927                if ((idev->rndid[2]|idev->rndid[3]|idev->rndid[4]|idev->rndid[5]|idev->rndid[6]|idev->rndid[7]) == 0x00)
1928                        goto regen;
1929        }
1930}
1931
1932static void ipv6_regen_rndid(unsigned long data)
1933{
1934        struct inet6_dev *idev = (struct inet6_dev *) data;
1935        unsigned long expires;
1936
1937        rcu_read_lock_bh();
1938        write_lock_bh(&idev->lock);
1939
1940        if (idev->dead)
1941                goto out;
1942
1943        __ipv6_regen_rndid(idev);
1944
1945        expires = jiffies +
1946                idev->cnf.temp_prefered_lft * HZ -
1947                idev->cnf.regen_max_retry * idev->cnf.dad_transmits *
1948                NEIGH_VAR(idev->nd_parms, RETRANS_TIME) -
1949                idev->cnf.max_desync_factor * HZ;
1950        if (time_before(expires, jiffies)) {
1951                pr_warn("%s: too short regeneration interval; timer disabled for %s\n",
1952                        __func__, idev->dev->name);
1953                goto out;
1954        }
1955
1956        if (!mod_timer(&idev->regen_timer, expires))
1957                in6_dev_hold(idev);
1958
1959out:
1960        write_unlock_bh(&idev->lock);
1961        rcu_read_unlock_bh();
1962        in6_dev_put(idev);
1963}
1964
1965static void  __ipv6_try_regen_rndid(struct inet6_dev *idev, struct in6_addr *tmpaddr)
1966{
1967        if (tmpaddr && memcmp(idev->rndid, &tmpaddr->s6_addr[8], 8) == 0)
1968                __ipv6_regen_rndid(idev);
1969}
1970
1971/*
1972 *      Add prefix route.
1973 */
1974
1975static void
1976addrconf_prefix_route(struct in6_addr *pfx, int plen, struct net_device *dev,
1977                      unsigned long expires, u32 flags)
1978{
1979        struct fib6_config cfg = {
1980                .fc_table = RT6_TABLE_PREFIX,
1981                .fc_metric = IP6_RT_PRIO_ADDRCONF,
1982                .fc_ifindex = dev->ifindex,
1983                .fc_expires = expires,
1984                .fc_dst_len = plen,
1985                .fc_flags = RTF_UP | flags,
1986                .fc_nlinfo.nl_net = dev_net(dev),
1987                .fc_protocol = RTPROT_KERNEL,
1988        };
1989
1990        cfg.fc_dst = *pfx;
1991
1992        /* Prevent useless cloning on PtP SIT.
1993           This thing is done here expecting that the whole
1994           class of non-broadcast devices need not cloning.
1995         */
1996#if IS_ENABLED(CONFIG_IPV6_SIT)
1997        if (dev->type == ARPHRD_SIT && (dev->flags & IFF_POINTOPOINT))
1998                cfg.fc_flags |= RTF_NONEXTHOP;
1999#endif
2000
2001        ip6_route_add(&cfg);
2002}
2003
2004
2005static struct rt6_info *addrconf_get_prefix_route(const struct in6_addr *pfx,
2006                                                  int plen,
2007                                                  const struct net_device *dev,
2008                                                  u32 flags, u32 noflags)
2009{
2010        struct fib6_node *fn;
2011        struct rt6_info *rt = NULL;
2012        struct fib6_table *table;
2013
2014        table = fib6_get_table(dev_net(dev), RT6_TABLE_PREFIX);
2015        if (table == NULL)
2016                return NULL;
2017
2018        read_lock_bh(&table->tb6_lock);
2019        fn = fib6_locate(&table->tb6_root, pfx, plen, NULL, 0);
2020        if (!fn)
2021                goto out;
2022        for (rt = fn->leaf; rt; rt = rt->dst.rt6_next) {
2023                if (rt->dst.dev->ifindex != dev->ifindex)
2024                        continue;
2025                if ((rt->rt6i_flags & flags) != flags)
2026                        continue;
2027                if ((rt->rt6i_flags & noflags) != 0)
2028                        continue;
2029                dst_hold(&rt->dst);
2030                break;
2031        }
2032out:
2033        read_unlock_bh(&table->tb6_lock);
2034        return rt;
2035}
2036
2037
2038/* Create "default" multicast route to the interface */
2039
2040static void addrconf_add_mroute(struct net_device *dev)
2041{
2042        struct fib6_config cfg = {
2043                .fc_table = RT6_TABLE_LOCAL,
2044                .fc_metric = IP6_RT_PRIO_ADDRCONF,
2045                .fc_ifindex = dev->ifindex,
2046                .fc_dst_len = 8,
2047                .fc_flags = RTF_UP,
2048                .fc_nlinfo.nl_net = dev_net(dev),
2049        };
2050
2051        ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0);
2052
2053        ip6_route_add(&cfg);
2054}
2055
2056static struct inet6_dev *addrconf_add_dev(struct net_device *dev)
2057{
2058        struct inet6_dev *idev;
2059
2060        ASSERT_RTNL();
2061
2062        idev = ipv6_find_idev(dev);
2063        if (!idev)
2064                return ERR_PTR(-ENOBUFS);
2065
2066        if (idev->cnf.disable_ipv6)
2067                return ERR_PTR(-EACCES);
2068
2069        /* Add default multicast route */
2070        if (!(dev->flags & IFF_LOOPBACK))
2071                addrconf_add_mroute(dev);
2072
2073        return idev;
2074}
2075
2076static void manage_tempaddrs(struct inet6_dev *idev,
2077                             struct inet6_ifaddr *ifp,
2078                             __u32 valid_lft, __u32 prefered_lft,
2079                             bool create, unsigned long now)
2080{
2081        u32 flags;
2082        struct inet6_ifaddr *ift;
2083
2084        read_lock_bh(&idev->lock);
2085        /* update all temporary addresses in the list */
2086        list_for_each_entry(ift, &idev->tempaddr_list, tmp_list) {
2087                int age, max_valid, max_prefered;
2088
2089                if (ifp != ift->ifpub)
2090                        continue;
2091
2092                /* RFC 4941 section 3.3:
2093                 * If a received option will extend the lifetime of a public
2094                 * address, the lifetimes of temporary addresses should
2095                 * be extended, subject to the overall constraint that no
2096                 * temporary addresses should ever remain "valid" or "preferred"
2097                 * for a time longer than (TEMP_VALID_LIFETIME) or
2098                 * (TEMP_PREFERRED_LIFETIME - DESYNC_FACTOR), respectively.
2099                 */
2100                age = (now - ift->cstamp) / HZ;
2101                max_valid = idev->cnf.temp_valid_lft - age;
2102                if (max_valid < 0)
2103                        max_valid = 0;
2104
2105                max_prefered = idev->cnf.temp_prefered_lft -
2106                               idev->cnf.max_desync_factor - age;
2107                if (max_prefered < 0)
2108                        max_prefered = 0;
2109
2110                if (valid_lft > max_valid)
2111                        valid_lft = max_valid;
2112
2113                if (prefered_lft > max_prefered)
2114                        prefered_lft = max_prefered;
2115
2116                spin_lock(&ift->lock);
2117                flags = ift->flags;
2118                ift->valid_lft = valid_lft;
2119                ift->prefered_lft = prefered_lft;
2120                ift->tstamp = now;
2121                if (prefered_lft > 0)
2122                        ift->flags &= ~IFA_F_DEPRECATED;
2123
2124                spin_unlock(&ift->lock);
2125                if (!(flags&IFA_F_TENTATIVE))
2126                        ipv6_ifa_notify(0, ift);
2127        }
2128
2129        if ((create || list_empty(&idev->tempaddr_list)) &&
2130            idev->cnf.use_tempaddr > 0) {
2131                /* When a new public address is created as described
2132                 * in [ADDRCONF], also create a new temporary address.
2133                 * Also create a temporary address if it's enabled but
2134                 * no temporary address currently exists.
2135                 */
2136                read_unlock_bh(&idev->lock);
2137                ipv6_create_tempaddr(ifp, NULL);
2138        } else {
2139                read_unlock_bh(&idev->lock);
2140        }
2141}
2142
2143void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
2144{
2145        struct prefix_info *pinfo;
2146        __u32 valid_lft;
2147        __u32 prefered_lft;
2148        int addr_type;
2149        struct inet6_dev *in6_dev;
2150        struct net *net = dev_net(dev);
2151
2152        pinfo = (struct prefix_info *) opt;
2153
2154        if (len < sizeof(struct prefix_info)) {
2155                ADBG("addrconf: prefix option too short\n");
2156                return;
2157        }
2158
2159        /*
2160         *      Validation checks ([ADDRCONF], page 19)
2161         */
2162
2163        addr_type = ipv6_addr_type(&pinfo->prefix);
2164
2165        if (addr_type & (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL))
2166                return;
2167
2168        valid_lft = ntohl(pinfo->valid);
2169        prefered_lft = ntohl(pinfo->prefered);
2170
2171        if (prefered_lft > valid_lft) {
2172                net_warn_ratelimited("addrconf: prefix option has invalid lifetime\n");
2173                return;
2174        }
2175
2176        in6_dev = in6_dev_get(dev);
2177
2178        if (in6_dev == NULL) {
2179                net_dbg_ratelimited("addrconf: device %s not configured\n",
2180                                    dev->name);
2181                return;
2182        }
2183
2184        /*
2185         *      Two things going on here:
2186         *      1) Add routes for on-link prefixes
2187         *      2) Configure prefixes with the auto flag set
2188         */
2189
2190        if (pinfo->onlink) {
2191                struct rt6_info *rt;
2192                unsigned long rt_expires;
2193
2194                /* Avoid arithmetic overflow. Really, we could
2195                 * save rt_expires in seconds, likely valid_lft,
2196                 * but it would require division in fib gc, that it
2197                 * not good.
2198                 */
2199                if (HZ > USER_HZ)
2200                        rt_expires = addrconf_timeout_fixup(valid_lft, HZ);
2201                else
2202                        rt_expires = addrconf_timeout_fixup(valid_lft, USER_HZ);
2203
2204                if (addrconf_finite_timeout(rt_expires))
2205                        rt_expires *= HZ;
2206
2207                rt = addrconf_get_prefix_route(&pinfo->prefix,
2208                                               pinfo->prefix_len,
2209                                               dev,
2210                                               RTF_ADDRCONF | RTF_PREFIX_RT,
2211                                               RTF_GATEWAY | RTF_DEFAULT);
2212
2213                if (rt) {
2214                        /* Autoconf prefix route */
2215                        if (valid_lft == 0) {
2216                                ip6_del_rt(rt);
2217                                rt = NULL;
2218                        } else if (addrconf_finite_timeout(rt_expires)) {
2219                                /* not infinity */
2220                                rt6_set_expires(rt, jiffies + rt_expires);
2221                        } else {
2222                                rt6_clean_expires(rt);
2223                        }
2224                } else if (valid_lft) {
2225                        clock_t expires = 0;
2226                        int flags = RTF_ADDRCONF | RTF_PREFIX_RT;
2227                        if (addrconf_finite_timeout(rt_expires)) {
2228                                /* not infinity */
2229                                flags |= RTF_EXPIRES;
2230                                expires = jiffies_to_clock_t(rt_expires);
2231                        }
2232                        addrconf_prefix_route(&pinfo->prefix, pinfo->prefix_len,
2233                                              dev, expires, flags);
2234                }
2235                ip6_rt_put(rt);
2236        }
2237
2238        /* Try to figure out our local address for this prefix */
2239
2240        if (pinfo->autoconf && in6_dev->cnf.autoconf) {
2241                struct inet6_ifaddr *ifp;
2242                struct in6_addr addr;
2243                int create = 0, update_lft = 0;
2244                bool tokenized = false;
2245
2246                if (pinfo->prefix_len == 64) {
2247                        memcpy(&addr, &pinfo->prefix, 8);
2248
2249                        if (!ipv6_addr_any(&in6_dev->token)) {
2250                                read_lock_bh(&in6_dev->lock);
2251                                memcpy(addr.s6_addr + 8,
2252                                       in6_dev->token.s6_addr + 8, 8);
2253                                read_unlock_bh(&in6_dev->lock);
2254                                tokenized = true;
2255                        } else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
2256                                   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
2257                                in6_dev_put(in6_dev);
2258                                return;
2259                        }
2260                        goto ok;
2261                }
2262                net_dbg_ratelimited("IPv6 addrconf: prefix with wrong length %d\n",
2263                                    pinfo->prefix_len);
2264                in6_dev_put(in6_dev);
2265                return;
2266
2267ok:
2268
2269                ifp = ipv6_get_ifaddr(net, &addr, dev, 1);
2270
2271                if (ifp == NULL && valid_lft) {
2272                        int max_addresses = in6_dev->cnf.max_addresses;
2273                        u32 addr_flags = 0;
2274
2275#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2276                        if (in6_dev->cnf.optimistic_dad &&
2277                            !net->ipv6.devconf_all->forwarding && sllao)
2278                                addr_flags = IFA_F_OPTIMISTIC;
2279#endif
2280
2281                        /* Do not allow to create too much of autoconfigured
2282                         * addresses; this would be too easy way to crash kernel.
2283                         */
2284                        if (!max_addresses ||
2285                            ipv6_count_addresses(in6_dev) < max_addresses)
2286                                ifp = ipv6_add_addr(in6_dev, &addr, NULL,
2287                                                    pinfo->prefix_len,
2288                                                    addr_type&IPV6_ADDR_SCOPE_MASK,
2289                                                    addr_flags, valid_lft,
2290                                                    prefered_lft);
2291
2292                        if (IS_ERR_OR_NULL(ifp)) {
2293                                in6_dev_put(in6_dev);
2294                                return;
2295                        }
2296
2297                        update_lft = 0;
2298                        create = 1;
2299                        spin_lock_bh(&ifp->lock);
2300                        ifp->flags |= IFA_F_MANAGETEMPADDR;
2301                        ifp->cstamp = jiffies;
2302                        ifp->tokenized = tokenized;
2303                        spin_unlock_bh(&ifp->lock);
2304                        addrconf_dad_start(ifp);
2305                }
2306
2307                if (ifp) {
2308                        u32 flags;
2309                        unsigned long now;
2310                        u32 stored_lft;
2311
2312                        /* update lifetime (RFC2462 5.5.3 e) */
2313                        spin_lock(&ifp->lock);
2314                        now = jiffies;
2315                        if (ifp->valid_lft > (now - ifp->tstamp) / HZ)
2316                                stored_lft = ifp->valid_lft - (now - ifp->tstamp) / HZ;
2317                        else
2318                                stored_lft = 0;
2319                        if (!update_lft && !create && stored_lft) {
2320                                const u32 minimum_lft = min(
2321                                        stored_lft, (u32)MIN_VALID_LIFETIME);
2322                                valid_lft = max(valid_lft, minimum_lft);
2323
2324                                /* RFC4862 Section 5.5.3e:
2325                                 * "Note that the preferred lifetime of the
2326                                 *  corresponding address is always reset to
2327                                 *  the Preferred Lifetime in the received
2328                                 *  Prefix Information option, regardless of
2329                                 *  whether the valid lifetime is also reset or
2330                                 *  ignored."
2331                                 *
2332                                 * So we should always update prefered_lft here.
2333                                 */
2334                                update_lft = 1;
2335                        }
2336
2337                        if (update_lft) {
2338                                ifp->valid_lft = valid_lft;
2339                                ifp->prefered_lft = prefered_lft;
2340                                ifp->tstamp = now;
2341                                flags = ifp->flags;
2342                                ifp->flags &= ~IFA_F_DEPRECATED;
2343                                spin_unlock(&ifp->lock);
2344
2345                                if (!(flags&IFA_F_TENTATIVE))
2346                                        ipv6_ifa_notify(0, ifp);
2347                        } else
2348                                spin_unlock(&ifp->lock);
2349
2350                        manage_tempaddrs(in6_dev, ifp, valid_lft, prefered_lft,
2351                                         create, now);
2352
2353                        in6_ifa_put(ifp);
2354                        addrconf_verify();
2355                }
2356        }
2357        inet6_prefix_notify(RTM_NEWPREFIX, in6_dev, pinfo);
2358        in6_dev_put(in6_dev);
2359}
2360
2361/*
2362 *      Set destination address.
2363 *      Special case for SIT interfaces where we create a new "virtual"
2364 *      device.
2365 */
2366int addrconf_set_dstaddr(struct net *net, void __user *arg)
2367{
2368        struct in6_ifreq ireq;
2369        struct net_device *dev;
2370        int err = -EINVAL;
2371
2372        rtnl_lock();
2373
2374        err = -EFAULT;
2375        if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2376                goto err_exit;
2377
2378        dev = __dev_get_by_index(net, ireq.ifr6_ifindex);
2379
2380        err = -ENODEV;
2381        if (dev == NULL)
2382                goto err_exit;
2383
2384#if IS_ENABLED(CONFIG_IPV6_SIT)
2385        if (dev->type == ARPHRD_SIT) {
2386                const struct net_device_ops *ops = dev->netdev_ops;
2387                struct ifreq ifr;
2388                struct ip_tunnel_parm p;
2389
2390                err = -EADDRNOTAVAIL;
2391                if (!(ipv6_addr_type(&ireq.ifr6_addr) & IPV6_ADDR_COMPATv4))
2392                        goto err_exit;
2393
2394                memset(&p, 0, sizeof(p));
2395                p.iph.daddr = ireq.ifr6_addr.s6_addr32[3];
2396                p.iph.saddr = 0;
2397                p.iph.version = 4;
2398                p.iph.ihl = 5;
2399                p.iph.protocol = IPPROTO_IPV6;
2400                p.iph.ttl = 64;
2401                ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
2402
2403                if (ops->ndo_do_ioctl) {
2404                        mm_segment_t oldfs = get_fs();
2405
2406                        set_fs(KERNEL_DS);
2407                        err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
2408                        set_fs(oldfs);
2409                } else
2410                        err = -EOPNOTSUPP;
2411
2412                if (err == 0) {
2413                        err = -ENOBUFS;
2414                        dev = __dev_get_by_name(net, p.name);
2415                        if (!dev)
2416                                goto err_exit;
2417                        err = dev_open(dev);
2418                }
2419        }
2420#endif
2421
2422err_exit:
2423        rtnl_unlock();
2424        return err;
2425}
2426
2427/*
2428 *      Manual configuration of address on an interface
2429 */
2430static int inet6_addr_add(struct net *net, int ifindex,
2431                          const struct in6_addr *pfx,
2432                          const struct in6_addr *peer_pfx,
2433                          unsigned int plen, __u32 ifa_flags,
2434                          __u32 prefered_lft, __u32 valid_lft)
2435{
2436        struct inet6_ifaddr *ifp;
2437        struct inet6_dev *idev;
2438        struct net_device *dev;
2439        int scope;
2440        u32 flags;
2441        clock_t expires;
2442        unsigned long timeout;
2443
2444        ASSERT_RTNL();
2445
2446        if (plen > 128)
2447                return -EINVAL;
2448
2449        /* check the lifetime */
2450        if (!valid_lft || prefered_lft > valid_lft)
2451                return -EINVAL;
2452
2453        if (ifa_flags & IFA_F_MANAGETEMPADDR && plen != 64)
2454                return -EINVAL;
2455
2456        dev = __dev_get_by_index(net, ifindex);
2457        if (!dev)
2458                return -ENODEV;
2459
2460        idev = addrconf_add_dev(dev);
2461        if (IS_ERR(idev))
2462                return PTR_ERR(idev);
2463
2464        scope = ipv6_addr_scope(pfx);
2465
2466        timeout = addrconf_timeout_fixup(valid_lft, HZ);
2467        if (addrconf_finite_timeout(timeout)) {
2468                expires = jiffies_to_clock_t(timeout * HZ);
2469                valid_lft = timeout;
2470                flags = RTF_EXPIRES;
2471        } else {
2472                expires = 0;
2473                flags = 0;
2474                ifa_flags |= IFA_F_PERMANENT;
2475        }
2476
2477        timeout = addrconf_timeout_fixup(prefered_lft, HZ);
2478        if (addrconf_finite_timeout(timeout)) {
2479                if (timeout == 0)
2480                        ifa_flags |= IFA_F_DEPRECATED;
2481                prefered_lft = timeout;
2482        }
2483
2484        ifp = ipv6_add_addr(idev, pfx, peer_pfx, plen, scope, ifa_flags,
2485                            valid_lft, prefered_lft);
2486
2487        if (!IS_ERR(ifp)) {
2488                if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
2489                        addrconf_prefix_route(&ifp->addr, ifp->prefix_len, dev,
2490                                              expires, flags);
2491                }
2492
2493                /*
2494                 * Note that section 3.1 of RFC 4429 indicates
2495                 * that the Optimistic flag should not be set for
2496                 * manually configured addresses
2497                 */
2498                addrconf_dad_start(ifp);
2499                if (ifa_flags & IFA_F_MANAGETEMPADDR)
2500                        manage_tempaddrs(idev, ifp, valid_lft, prefered_lft,
2501                                         true, jiffies);
2502                in6_ifa_put(ifp);
2503                addrconf_verify_rtnl();
2504                return 0;
2505        }
2506
2507        return PTR_ERR(ifp);
2508}
2509
2510static int inet6_addr_del(struct net *net, int ifindex, u32 ifa_flags,
2511                          const struct in6_addr *pfx, unsigned int plen)
2512{
2513        struct inet6_ifaddr *ifp;
2514        struct inet6_dev *idev;
2515        struct net_device *dev;
2516
2517        if (plen > 128)
2518                return -EINVAL;
2519
2520        dev = __dev_get_by_index(net, ifindex);
2521        if (!dev)
2522                return -ENODEV;
2523
2524        if ((idev = __in6_dev_get(dev)) == NULL)
2525                return -ENXIO;
2526
2527        read_lock_bh(&idev->lock);
2528        list_for_each_entry(ifp, &idev->addr_list, if_list) {
2529                if (ifp->prefix_len == plen &&
2530                    ipv6_addr_equal(pfx, &ifp->addr)) {
2531                        in6_ifa_hold(ifp);
2532                        read_unlock_bh(&idev->lock);
2533
2534                        if (!(ifp->flags & IFA_F_TEMPORARY) &&
2535                            (ifa_flags & IFA_F_MANAGETEMPADDR))
2536                                manage_tempaddrs(idev, ifp, 0, 0, false,
2537                                                 jiffies);
2538                        ipv6_del_addr(ifp);
2539                        addrconf_verify_rtnl();
2540                        return 0;
2541                }
2542        }
2543        read_unlock_bh(&idev->lock);
2544        return -EADDRNOTAVAIL;
2545}
2546
2547
2548int addrconf_add_ifaddr(struct net *net, void __user *arg)
2549{
2550        struct in6_ifreq ireq;
2551        int err;
2552
2553        if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2554                return -EPERM;
2555
2556        if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2557                return -EFAULT;
2558
2559        rtnl_lock();
2560        err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL,
2561                             ireq.ifr6_prefixlen, IFA_F_PERMANENT,
2562                             INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2563        rtnl_unlock();
2564        return err;
2565}
2566
2567int addrconf_del_ifaddr(struct net *net, void __user *arg)
2568{
2569        struct in6_ifreq ireq;
2570        int err;
2571
2572        if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
2573                return -EPERM;
2574
2575        if (copy_from_user(&ireq, arg, sizeof(struct in6_ifreq)))
2576                return -EFAULT;
2577
2578        rtnl_lock();
2579        err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr,
2580                             ireq.ifr6_prefixlen);
2581        rtnl_unlock();
2582        return err;
2583}
2584
2585static void add_addr(struct inet6_dev *idev, const struct in6_addr *addr,
2586                     int plen, int scope)
2587{
2588        struct inet6_ifaddr *ifp;
2589
2590        ifp = ipv6_add_addr(idev, addr, NULL, plen,
2591                            scope, IFA_F_PERMANENT,
2592                            INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2593        if (!IS_ERR(ifp)) {
2594                spin_lock_bh(&ifp->lock);
2595                ifp->flags &= ~IFA_F_TENTATIVE;
2596                spin_unlock_bh(&ifp->lock);
2597                ipv6_ifa_notify(RTM_NEWADDR, ifp);
2598                in6_ifa_put(ifp);
2599        }
2600}
2601
2602#if IS_ENABLED(CONFIG_IPV6_SIT)
2603static void sit_add_v4_addrs(struct inet6_dev *idev)
2604{
2605        struct in6_addr addr;
2606        struct net_device *dev;
2607        struct net *net = dev_net(idev->dev);
2608        int scope, plen;
2609        u32 pflags = 0;
2610
2611        ASSERT_RTNL();
2612
2613        memset(&addr, 0, sizeof(struct in6_addr));
2614        memcpy(&addr.s6_addr32[3], idev->dev->dev_addr, 4);
2615
2616        if (idev->dev->flags&IFF_POINTOPOINT) {
2617                addr.s6_addr32[0] = htonl(0xfe800000);
2618                scope = IFA_LINK;
2619                plen = 64;
2620        } else {
2621                scope = IPV6_ADDR_COMPATv4;
2622                plen = 96;
2623                pflags |= RTF_NONEXTHOP;
2624        }
2625
2626        if (addr.s6_addr32[3]) {
2627                add_addr(idev, &addr, plen, scope);
2628                addrconf_prefix_route(&addr, plen, idev->dev, 0, pflags);
2629                return;
2630        }
2631
2632        for_each_netdev(net, dev) {
2633                struct in_device *in_dev = __in_dev_get_rtnl(dev);
2634                if (in_dev && (dev->flags & IFF_UP)) {
2635                        struct in_ifaddr *ifa;
2636
2637                        int flag = scope;
2638
2639                        for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
2640
2641                                addr.s6_addr32[3] = ifa->ifa_local;
2642
2643                                if (ifa->ifa_scope == RT_SCOPE_LINK)
2644                                        continue;
2645                                if (ifa->ifa_scope >= RT_SCOPE_HOST) {
2646                                        if (idev->dev->flags&IFF_POINTOPOINT)
2647                                                continue;
2648                                        flag |= IFA_HOST;
2649                                }
2650
2651                                add_addr(idev, &addr, plen, flag);
2652                                addrconf_prefix_route(&addr, plen, idev->dev, 0,
2653                                                      pflags);
2654                        }
2655                }
2656        }
2657}
2658#endif
2659
2660static void init_loopback(struct net_device *dev)
2661{
2662        struct inet6_dev  *idev;
2663        struct net_device *sp_dev;
2664        struct inet6_ifaddr *sp_ifa;
2665        struct rt6_info *sp_rt;
2666
2667        /* ::1 */
2668
2669        ASSERT_RTNL();
2670
2671        if ((idev = ipv6_find_idev(dev)) == NULL) {
2672                pr_debug("%s: add_dev failed\n", __func__);
2673                return;
2674        }
2675
2676        add_addr(idev, &in6addr_loopback, 128, IFA_HOST);
2677
2678        /* Add routes to other interface's IPv6 addresses */
2679        for_each_netdev(dev_net(dev), sp_dev) {
2680                if (!strcmp(sp_dev->name, dev->name))
2681                        continue;
2682
2683                idev = __in6_dev_get(sp_dev);
2684                if (!idev)
2685                        continue;
2686
2687                read_lock_bh(&idev->lock);
2688                list_for_each_entry(sp_ifa, &idev->addr_list, if_list) {
2689
2690                        if (sp_ifa->flags & (IFA_F_DADFAILED | IFA_F_TENTATIVE))
2691                                continue;
2692
2693                        if (sp_ifa->rt) {
2694                                /* This dst has been added to garbage list when
2695                                 * lo device down, release this obsolete dst and
2696                                 * reallocate a new router for ifa.
2697                                 */
2698                                if (!atomic_read(&sp_ifa->rt->rt6i_ref)) {
2699                                        ip6_rt_put(sp_ifa->rt);
2700                                        sp_ifa->rt = NULL;
2701                                } else {
2702                                        continue;
2703                                }
2704                        }
2705
2706                        sp_rt = addrconf_dst_alloc(idev, &sp_ifa->addr, false);
2707
2708                        /* Failure cases are ignored */
2709                        if (!IS_ERR(sp_rt)) {
2710                                sp_ifa->rt = sp_rt;
2711                                ip6_ins_rt(sp_rt);
2712                        }
2713                }
2714                read_unlock_bh(&idev->lock);
2715        }
2716}
2717
2718static void addrconf_add_linklocal(struct inet6_dev *idev, const struct in6_addr *addr)
2719{
2720        struct inet6_ifaddr *ifp;
2721        u32 addr_flags = IFA_F_PERMANENT;
2722
2723#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
2724        if (idev->cnf.optimistic_dad &&
2725            !dev_net(idev->dev)->ipv6.devconf_all->forwarding)
2726                addr_flags |= IFA_F_OPTIMISTIC;
2727#endif
2728
2729
2730        ifp = ipv6_add_addr(idev, addr, NULL, 64, IFA_LINK, addr_flags,
2731                            INFINITY_LIFE_TIME, INFINITY_LIFE_TIME);
2732        if (!IS_ERR(ifp)) {
2733                addrconf_prefix_route(&ifp->addr, ifp->prefix_len, idev->dev, 0, 0);
2734                addrconf_dad_start(ifp);
2735                in6_ifa_put(ifp);
2736        }
2737}
2738
2739static void addrconf_addr_gen(struct inet6_dev *idev, bool prefix_route)
2740{
2741        if (idev->addr_gen_mode == IN6_ADDR_GEN_MODE_EUI64) {
2742                struct in6_addr addr;
2743
2744                ipv6_addr_set(&addr,  htonl(0xFE800000), 0, 0, 0);
2745                /* addrconf_add_linklocal also adds a prefix_route and we
2746                 * only need to care about prefix routes if ipv6_generate_eui64
2747                 * couldn't generate one.
2748                 */
2749                if (ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) == 0)
2750                        addrconf_add_linklocal(idev, &addr);
2751                else if (prefix_route)
2752                        addrconf_prefix_route(&addr, 64, idev->dev, 0, 0);
2753        }
2754}
2755
2756static void addrconf_dev_config(struct net_device *dev)
2757{
2758        struct inet6_dev *idev;
2759
2760        ASSERT_RTNL();
2761
2762        if ((dev->type != ARPHRD_ETHER) &&
2763            (dev->type != ARPHRD_FDDI) &&
2764            (dev->type != ARPHRD_ARCNET) &&
2765            (dev->type != ARPHRD_INFINIBAND) &&
2766            (dev->type != ARPHRD_IEEE802154) &&
2767            (dev->type != ARPHRD_IEEE1394) &&
2768            (dev->type != ARPHRD_TUNNEL6) &&
2769            (dev->type != ARPHRD_6LOWPAN)) {
2770                /* Alas, we support only Ethernet autoconfiguration. */
2771                return;
2772        }
2773
2774        idev = addrconf_add_dev(dev);
2775        if (IS_ERR(idev))
2776                return;
2777
2778        addrconf_addr_gen(idev, false);
2779}
2780
2781#if IS_ENABLED(CONFIG_IPV6_SIT)
2782static void addrconf_sit_config(struct net_device *dev)
2783{
2784        struct inet6_dev *idev;
2785
2786        ASSERT_RTNL();
2787
2788        /*
2789         * Configure the tunnel with one of our IPv4
2790         * addresses... we should configure all of
2791         * our v4 addrs in the tunnel
2792         */
2793
2794        if ((idev = ipv6_find_idev(dev)) == NULL) {
2795                pr_debug("%s: add_dev failed\n", __func__);
2796                return;
2797        }
2798
2799        if (dev->priv_flags & IFF_ISATAP) {
2800                addrconf_addr_gen(idev, false);
2801                return;
2802        }
2803
2804        sit_add_v4_addrs(idev);
2805
2806        if (dev->flags&IFF_POINTOPOINT)
2807                addrconf_add_mroute(dev);
2808}
2809#endif
2810
2811#if IS_ENABLED(CONFIG_NET_IPGRE)
2812static void addrconf_gre_config(struct net_device *dev)
2813{
2814        struct inet6_dev *idev;
2815
2816        ASSERT_RTNL();
2817
2818        if ((idev = ipv6_find_idev(dev)) == NULL) {
2819                pr_debug("%s: add_dev failed\n", __func__);
2820                return;
2821        }
2822
2823        addrconf_addr_gen(idev, true);
2824}
2825#endif
2826
2827static int addrconf_notify(struct notifier_block *this, unsigned long event,
2828                           void *ptr)
2829{
2830        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2831        struct inet6_dev *idev = __in6_dev_get(dev);
2832        int run_pending = 0;
2833        int err;
2834
2835        switch (event) {
2836        case NETDEV_REGISTER:
2837                if (!idev && dev->mtu >= IPV6_MIN_MTU) {
2838                        idev = ipv6_add_dev(dev);
2839                        if (IS_ERR(idev))
2840                                return notifier_from_errno(PTR_ERR(idev));
2841                }
2842                break;
2843
2844        case NETDEV_UP:
2845        case NETDEV_CHANGE:
2846                if (dev->flags & IFF_SLAVE)
2847                        break;
2848
2849                if (idev && idev->cnf.disable_ipv6)
2850                        break;
2851
2852                if (event == NETDEV_UP) {
2853                        if (!addrconf_qdisc_ok(dev)) {
2854                                /* device is not ready yet. */
2855                                pr_info("ADDRCONF(NETDEV_UP): %s: link is not ready\n",
2856                                        dev->name);
2857                                break;
2858                        }
2859
2860                        if (!idev && dev->mtu >= IPV6_MIN_MTU)
2861                                idev = ipv6_add_dev(dev);
2862
2863                        if (!IS_ERR_OR_NULL(idev)) {
2864                                idev->if_flags |= IF_READY;
2865                                run_pending = 1;
2866                        }
2867                } else {
2868                        if (!addrconf_qdisc_ok(dev)) {
2869                                /* device is still not ready. */
2870                                break;
2871                        }
2872
2873                        if (idev) {
2874                                if (idev->if_flags & IF_READY)
2875                                        /* device is already configured. */
2876                                        break;
2877                                idev->if_flags |= IF_READY;
2878                        }
2879
2880                        pr_info("ADDRCONF(NETDEV_CHANGE): %s: link becomes ready\n",
2881                                dev->name);
2882
2883                        run_pending = 1;
2884                }
2885
2886                switch (dev->type) {
2887#if IS_ENABLED(CONFIG_IPV6_SIT)
2888                case ARPHRD_SIT:
2889                        addrconf_sit_config(dev);
2890                        break;
2891#endif
2892#if IS_ENABLED(CONFIG_NET_IPGRE)
2893                case ARPHRD_IPGRE:
2894                        addrconf_gre_config(dev);
2895                        break;
2896#endif
2897                case ARPHRD_LOOPBACK:
2898                        init_loopback(dev);
2899                        break;
2900
2901                default:
2902                        addrconf_dev_config(dev);
2903                        break;
2904                }
2905
2906                if (!IS_ERR_OR_NULL(idev)) {
2907                        if (run_pending)
2908                                addrconf_dad_run(idev);
2909
2910                        /*
2911                         * If the MTU changed during the interface down,
2912                         * when the interface up, the changed MTU must be
2913                         * reflected in the idev as well as routers.
2914                         */
2915                        if (idev->cnf.mtu6 != dev->mtu &&
2916                            dev->mtu >= IPV6_MIN_MTU) {
2917                                rt6_mtu_change(dev, dev->mtu);
2918                                idev->cnf.mtu6 = dev->mtu;
2919                        }
2920                        idev->tstamp = jiffies;
2921                        inet6_ifinfo_notify(RTM_NEWLINK, idev);
2922
2923                        /*
2924                         * If the changed mtu during down is lower than
2925                         * IPV6_MIN_MTU stop IPv6 on this interface.
2926                         */
2927                        if (dev->mtu < IPV6_MIN_MTU)
2928                                addrconf_ifdown(dev, 1);
2929                }
2930                break;
2931
2932        case NETDEV_CHANGEMTU:
2933                if (idev && dev->mtu >= IPV6_MIN_MTU) {
2934                        rt6_mtu_change(dev, dev->mtu);
2935                        idev->cnf.mtu6 = dev->mtu;
2936                        break;
2937                }
2938
2939                if (!idev && dev->mtu >= IPV6_MIN_MTU) {
2940                        idev = ipv6_add_dev(dev);
2941                        if (!IS_ERR(idev))
2942                                break;
2943                }
2944
2945                /*
2946                 * if MTU under IPV6_MIN_MTU.
2947                 * Stop IPv6 on this interface.
2948                 */
2949
2950        case NETDEV_DOWN:
2951        case NETDEV_UNREGISTER:
2952                /*
2953                 *      Remove all addresses from this interface.
2954                 */
2955                addrconf_ifdown(dev, event != NETDEV_DOWN);
2956                break;
2957
2958        case NETDEV_CHANGENAME:
2959                if (idev) {
2960                        snmp6_unregister_dev(idev);
2961                        addrconf_sysctl_unregister(idev);
2962                        err = addrconf_sysctl_register(idev);
2963                        if (err)
2964                                return notifier_from_errno(err);
2965                        err = snmp6_register_dev(idev);
2966                        if (err) {
2967                                addrconf_sysctl_unregister(idev);
2968                                return notifier_from_errno(err);
2969                        }
2970                }
2971                break;
2972
2973        case NETDEV_PRE_TYPE_CHANGE:
2974        case NETDEV_POST_TYPE_CHANGE:
2975                addrconf_type_change(dev, event);
2976                break;
2977        }
2978
2979        return NOTIFY_OK;
2980}
2981
2982/*
2983 *      addrconf module should be notified of a device going up
2984 */
2985static struct notifier_block ipv6_dev_notf = {
2986        .notifier_call = addrconf_notify,
2987};
2988
2989static void addrconf_type_change(struct net_device *dev, unsigned long event)
2990{
2991        struct inet6_dev *idev;
2992        ASSERT_RTNL();
2993
2994        idev = __in6_dev_get(dev);
2995
2996        if (event == NETDEV_POST_TYPE_CHANGE)
2997                ipv6_mc_remap(idev);
2998        else if (event == NETDEV_PRE_TYPE_CHANGE)
2999                ipv6_mc_unmap(idev);
3000}
3001
3002static int addrconf_ifdown(struct net_device *dev, int how)
3003{
3004        struct net *net = dev_net(dev);
3005        struct inet6_dev *idev;
3006        struct inet6_ifaddr *ifa;
3007        int state, i;
3008
3009        ASSERT_RTNL();
3010
3011        rt6_ifdown(net, dev);
3012        neigh_ifdown(&nd_tbl, dev);
3013
3014        idev = __in6_dev_get(dev);
3015        if (idev == NULL)
3016                return -ENODEV;
3017
3018        /*
3019         * Step 1: remove reference to ipv6 device from parent device.
3020         *         Do not dev_put!
3021         */
3022        if (how) {
3023                idev->dead = 1;
3024
3025                /* protected by rtnl_lock */
3026                RCU_INIT_POINTER(dev->ip6_ptr, NULL);
3027
3028                /* Step 1.5: remove snmp6 entry */
3029                snmp6_unregister_dev(idev);
3030
3031        }
3032
3033        /* Step 2: clear hash table */
3034        for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3035                struct hlist_head *h = &inet6_addr_lst[i];
3036
3037                spin_lock_bh(&addrconf_hash_lock);
3038restart:
3039                hlist_for_each_entry_rcu(ifa, h, addr_lst) {
3040                        if (ifa->idev == idev) {
3041                                hlist_del_init_rcu(&ifa->addr_lst);
3042                                addrconf_del_dad_work(ifa);
3043                                goto restart;
3044                        }
3045                }
3046                spin_unlock_bh(&addrconf_hash_lock);
3047        }
3048
3049        write_lock_bh(&idev->lock);
3050
3051        addrconf_del_rs_timer(idev);
3052
3053        /* Step 2: clear flags for stateless addrconf */
3054        if (!how)
3055                idev->if_flags &= ~(IF_RS_SENT|IF_RA_RCVD|IF_READY);
3056
3057        if (how && del_timer(&idev->regen_timer))
3058                in6_dev_put(idev);
3059
3060        /* Step 3: clear tempaddr list */
3061        while (!list_empty(&idev->tempaddr_list)) {
3062                ifa = list_first_entry(&idev->tempaddr_list,
3063                                       struct inet6_ifaddr, tmp_list);
3064                list_del(&ifa->tmp_list);
3065                write_unlock_bh(&idev->lock);
3066                spin_lock_bh(&ifa->lock);
3067
3068                if (ifa->ifpub) {
3069                        in6_ifa_put(ifa->ifpub);
3070                        ifa->ifpub = NULL;
3071                }
3072                spin_unlock_bh(&ifa->lock);
3073                in6_ifa_put(ifa);
3074                write_lock_bh(&idev->lock);
3075        }
3076
3077        while (!list_empty(&idev->addr_list)) {
3078                ifa = list_first_entry(&idev->addr_list,
3079                                       struct inet6_ifaddr, if_list);
3080                addrconf_del_dad_work(ifa);
3081
3082                list_del(&ifa->if_list);
3083
3084                write_unlock_bh(&idev->lock);
3085
3086                spin_lock_bh(&ifa->state_lock);
3087                state = ifa->state;
3088                ifa->state = INET6_IFADDR_STATE_DEAD;
3089                spin_unlock_bh(&ifa->state_lock);
3090
3091                if (state != INET6_IFADDR_STATE_DEAD) {
3092                        __ipv6_ifa_notify(RTM_DELADDR, ifa);
3093                        inet6addr_notifier_call_chain(NETDEV_DOWN, ifa);
3094                }
3095                in6_ifa_put(ifa);
3096
3097                write_lock_bh(&idev->lock);
3098        }
3099
3100        write_unlock_bh(&idev->lock);
3101
3102        /* Step 5: Discard anycast and multicast list */
3103        if (how) {
3104                ipv6_ac_destroy_dev(idev);
3105                ipv6_mc_destroy_dev(idev);
3106        } else {
3107                ipv6_mc_down(idev);
3108        }
3109
3110        idev->tstamp = jiffies;
3111
3112        /* Last: Shot the device (if unregistered) */
3113        if (how) {
3114                addrconf_sysctl_unregister(idev);
3115                neigh_parms_release(&nd_tbl, idev->nd_parms);
3116                neigh_ifdown(&nd_tbl, dev);
3117                in6_dev_put(idev);
3118        }
3119        return 0;
3120}
3121
3122static void addrconf_rs_timer(unsigned long data)
3123{
3124        struct inet6_dev *idev = (struct inet6_dev *)data;
3125        struct net_device *dev = idev->dev;
3126        struct in6_addr lladdr;
3127
3128        write_lock(&idev->lock);
3129        if (idev->dead || !(idev->if_flags & IF_READY))
3130                goto out;
3131
3132        if (!ipv6_accept_ra(idev))
3133                goto out;
3134
3135        /* Announcement received after solicitation was sent */
3136        if (idev->if_flags & IF_RA_RCVD)
3137                goto out;
3138
3139        if (idev->rs_probes++ < idev->cnf.rtr_solicits) {
3140                write_unlock(&idev->lock);
3141                if (!ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3142                        ndisc_send_rs(dev, &lladdr,
3143                                      &in6addr_linklocal_allrouters);
3144                else
3145                        goto put;
3146
3147                write_lock(&idev->lock);
3148                /* The wait after the last probe can be shorter */
3149                addrconf_mod_rs_timer(idev, (idev->rs_probes ==
3150                                             idev->cnf.rtr_solicits) ?
3151                                      idev->cnf.rtr_solicit_delay :
3152                                      idev->cnf.rtr_solicit_interval);
3153        } else {
3154                /*
3155                 * Note: we do not support deprecated "all on-link"
3156                 * assumption any longer.
3157                 */
3158                pr_debug("%s: no IPv6 routers present\n", idev->dev->name);
3159        }
3160
3161out:
3162        write_unlock(&idev->lock);
3163put:
3164        in6_dev_put(idev);
3165}
3166
3167/*
3168 *      Duplicate Address Detection
3169 */
3170static void addrconf_dad_kick(struct inet6_ifaddr *ifp)
3171{
3172        unsigned long rand_num;
3173        struct inet6_dev *idev = ifp->idev;
3174
3175        if (ifp->flags & IFA_F_OPTIMISTIC)
3176                rand_num = 0;
3177        else
3178                rand_num = prandom_u32() % (idev->cnf.rtr_solicit_delay ? : 1);
3179
3180        ifp->dad_probes = idev->cnf.dad_transmits;
3181        addrconf_mod_dad_work(ifp, rand_num);
3182}
3183
3184static void addrconf_dad_begin(struct inet6_ifaddr *ifp)
3185{
3186        struct inet6_dev *idev = ifp->idev;
3187        struct net_device *dev = idev->dev;
3188
3189        addrconf_join_solict(dev, &ifp->addr);
3190
3191        prandom_seed((__force u32) ifp->addr.s6_addr32[3]);
3192
3193        read_lock_bh(&idev->lock);
3194        spin_lock(&ifp->lock);
3195        if (ifp->state == INET6_IFADDR_STATE_DEAD)
3196                goto out;
3197
3198        if (dev->flags&(IFF_NOARP|IFF_LOOPBACK) ||
3199            idev->cnf.accept_dad < 1 ||
3200            !(ifp->flags&IFA_F_TENTATIVE) ||
3201            ifp->flags & IFA_F_NODAD) {
3202                ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3203                spin_unlock(&ifp->lock);
3204                read_unlock_bh(&idev->lock);
3205
3206                addrconf_dad_completed(ifp);
3207                return;
3208        }
3209
3210        if (!(idev->if_flags & IF_READY)) {
3211                spin_unlock(&ifp->lock);
3212                read_unlock_bh(&idev->lock);
3213                /*
3214                 * If the device is not ready:
3215                 * - keep it tentative if it is a permanent address.
3216                 * - otherwise, kill it.
3217                 */
3218                in6_ifa_hold(ifp);
3219                addrconf_dad_stop(ifp, 0);
3220                return;
3221        }
3222
3223        /*
3224         * Optimistic nodes can start receiving
3225         * Frames right away
3226         */
3227        if (ifp->flags & IFA_F_OPTIMISTIC)
3228                ip6_ins_rt(ifp->rt);
3229
3230        addrconf_dad_kick(ifp);
3231out:
3232        spin_unlock(&ifp->lock);
3233        read_unlock_bh(&idev->lock);
3234}
3235
3236static void addrconf_dad_start(struct inet6_ifaddr *ifp)
3237{
3238        bool begin_dad = false;
3239
3240        spin_lock_bh(&ifp->state_lock);
3241        if (ifp->state != INET6_IFADDR_STATE_DEAD) {
3242                ifp->state = INET6_IFADDR_STATE_PREDAD;
3243                begin_dad = true;
3244        }
3245        spin_unlock_bh(&ifp->state_lock);
3246
3247        if (begin_dad)
3248                addrconf_mod_dad_work(ifp, 0);
3249}
3250
3251static void addrconf_dad_work(struct work_struct *w)
3252{
3253        struct inet6_ifaddr *ifp = container_of(to_delayed_work(w),
3254                                                struct inet6_ifaddr,
3255                                                dad_work);
3256        struct inet6_dev *idev = ifp->idev;
3257        struct in6_addr mcaddr;
3258
3259        enum {
3260                DAD_PROCESS,
3261                DAD_BEGIN,
3262                DAD_ABORT,
3263        } action = DAD_PROCESS;
3264
3265        rtnl_lock();
3266
3267        spin_lock_bh(&ifp->state_lock);
3268        if (ifp->state == INET6_IFADDR_STATE_PREDAD) {
3269                action = DAD_BEGIN;
3270                ifp->state = INET6_IFADDR_STATE_DAD;
3271        } else if (ifp->state == INET6_IFADDR_STATE_ERRDAD) {
3272                action = DAD_ABORT;
3273                ifp->state = INET6_IFADDR_STATE_POSTDAD;
3274        }
3275        spin_unlock_bh(&ifp->state_lock);
3276
3277        if (action == DAD_BEGIN) {
3278                addrconf_dad_begin(ifp);
3279                goto out;
3280        } else if (action == DAD_ABORT) {
3281                in6_ifa_hold(ifp);
3282                addrconf_dad_stop(ifp, 1);
3283                goto out;
3284        }
3285
3286        if (!ifp->dad_probes && addrconf_dad_end(ifp))
3287                goto out;
3288
3289        write_lock_bh(&idev->lock);
3290        if (idev->dead || !(idev->if_flags & IF_READY)) {
3291                write_unlock_bh(&idev->lock);
3292                goto out;
3293        }
3294
3295        spin_lock(&ifp->lock);
3296        if (ifp->state == INET6_IFADDR_STATE_DEAD) {
3297                spin_unlock(&ifp->lock);
3298                write_unlock_bh(&idev->lock);
3299                goto out;
3300        }
3301
3302        if (ifp->dad_probes == 0) {
3303                /*
3304                 * DAD was successful
3305                 */
3306
3307                ifp->flags &= ~(IFA_F_TENTATIVE|IFA_F_OPTIMISTIC|IFA_F_DADFAILED);
3308                spin_unlock(&ifp->lock);
3309                write_unlock_bh(&idev->lock);
3310
3311                addrconf_dad_completed(ifp);
3312
3313                goto out;
3314        }
3315
3316        ifp->dad_probes--;
3317        addrconf_mod_dad_work(ifp,
3318                              NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME));
3319        spin_unlock(&ifp->lock);
3320        write_unlock_bh(&idev->lock);
3321
3322        /* send a neighbour solicitation for our addr */
3323        addrconf_addr_solict_mult(&ifp->addr, &mcaddr);
3324        ndisc_send_ns(ifp->idev->dev, NULL, &ifp->addr, &mcaddr, &in6addr_any);
3325out:
3326        in6_ifa_put(ifp);
3327        rtnl_unlock();
3328}
3329
3330/* ifp->idev must be at least read locked */
3331static bool ipv6_lonely_lladdr(struct inet6_ifaddr *ifp)
3332{
3333        struct inet6_ifaddr *ifpiter;
3334        struct inet6_dev *idev = ifp->idev;
3335
3336        list_for_each_entry_reverse(ifpiter, &idev->addr_list, if_list) {
3337                if (ifpiter->scope > IFA_LINK)
3338                        break;
3339                if (ifp != ifpiter && ifpiter->scope == IFA_LINK &&
3340                    (ifpiter->flags & (IFA_F_PERMANENT|IFA_F_TENTATIVE|
3341                                       IFA_F_OPTIMISTIC|IFA_F_DADFAILED)) ==
3342                    IFA_F_PERMANENT)
3343                        return false;
3344        }
3345        return true;
3346}
3347
3348static void addrconf_dad_completed(struct inet6_ifaddr *ifp)
3349{
3350        struct net_device *dev = ifp->idev->dev;
3351        struct in6_addr lladdr;
3352        bool send_rs, send_mld;
3353
3354        addrconf_del_dad_work(ifp);
3355
3356        /*
3357         *      Configure the address for reception. Now it is valid.
3358         */
3359
3360        ipv6_ifa_notify(RTM_NEWADDR, ifp);
3361
3362        /* If added prefix is link local and we are prepared to process
3363           router advertisements, start sending router solicitations.
3364         */
3365
3366        read_lock_bh(&ifp->idev->lock);
3367        send_mld = ifp->scope == IFA_LINK && ipv6_lonely_lladdr(ifp);
3368        send_rs = send_mld &&
3369                  ipv6_accept_ra(ifp->idev) &&
3370                  ifp->idev->cnf.rtr_solicits > 0 &&
3371                  (dev->flags&IFF_LOOPBACK) == 0;
3372        read_unlock_bh(&ifp->idev->lock);
3373
3374        /* While dad is in progress mld report's source address is in6_addrany.
3375         * Resend with proper ll now.
3376         */
3377        if (send_mld)
3378                ipv6_mc_dad_complete(ifp->idev);
3379
3380        if (send_rs) {
3381                /*
3382                 *      If a host as already performed a random delay
3383                 *      [...] as part of DAD [...] there is no need
3384                 *      to delay again before sending the first RS
3385                 */
3386                if (ipv6_get_lladdr(dev, &lladdr, IFA_F_TENTATIVE))
3387                        return;
3388                ndisc_send_rs(dev, &lladdr, &in6addr_linklocal_allrouters);
3389
3390                write_lock_bh(&ifp->idev->lock);
3391                spin_lock(&ifp->lock);
3392                ifp->idev->rs_probes = 1;
3393                ifp->idev->if_flags |= IF_RS_SENT;
3394                addrconf_mod_rs_timer(ifp->idev,
3395                                      ifp->idev->cnf.rtr_solicit_interval);
3396                spin_unlock(&ifp->lock);
3397                write_unlock_bh(&ifp->idev->lock);
3398        }
3399}
3400
3401static void addrconf_dad_run(struct inet6_dev *idev)
3402{
3403        struct inet6_ifaddr *ifp;
3404
3405        read_lock_bh(&idev->lock);
3406        list_for_each_entry(ifp, &idev->addr_list, if_list) {
3407                spin_lock(&ifp->lock);
3408                if (ifp->flags & IFA_F_TENTATIVE &&
3409                    ifp->state == INET6_IFADDR_STATE_DAD)
3410                        addrconf_dad_kick(ifp);
3411                spin_unlock(&ifp->lock);
3412        }
3413        read_unlock_bh(&idev->lock);
3414}
3415
3416#ifdef CONFIG_PROC_FS
3417struct if6_iter_state {
3418        struct seq_net_private p;
3419        int bucket;
3420        int offset;
3421};
3422
3423static struct inet6_ifaddr *if6_get_first(struct seq_file *seq, loff_t pos)
3424{
3425        struct inet6_ifaddr *ifa = NULL;
3426        struct if6_iter_state *state = seq->private;
3427        struct net *net = seq_file_net(seq);
3428        int p = 0;
3429
3430        /* initial bucket if pos is 0 */
3431        if (pos == 0) {
3432                state->bucket = 0;
3433                state->offset = 0;
3434        }
3435
3436        for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) {
3437                hlist_for_each_entry_rcu_bh(ifa, &inet6_addr_lst[state->bucket],
3438                                         addr_lst) {
3439                        if (!net_eq(dev_net(ifa->idev->dev), net))
3440                                continue;
3441                        /* sync with offset */
3442                        if (p < state->offset) {
3443                                p++;
3444                                continue;
3445                        }
3446                        state->offset++;
3447                        return ifa;
3448                }
3449
3450                /* prepare for next bucket */
3451                state->offset = 0;
3452                p = 0;
3453        }
3454        return NULL;
3455}
3456
3457static struct inet6_ifaddr *if6_get_next(struct seq_file *seq,
3458                                         struct inet6_ifaddr *ifa)
3459{
3460        struct if6_iter_state *state = seq->private;
3461        struct net *net = seq_file_net(seq);
3462
3463        hlist_for_each_entry_continue_rcu_bh(ifa, addr_lst) {
3464                if (!net_eq(dev_net(ifa->idev->dev), net))
3465                        continue;
3466                state->offset++;
3467                return ifa;
3468        }
3469
3470        while (++state->bucket < IN6_ADDR_HSIZE) {
3471                state->offset = 0;
3472                hlist_for_each_entry_rcu_bh(ifa,
3473                                     &inet6_addr_lst[state->bucket], addr_lst) {
3474                        if (!net_eq(dev_net(ifa->idev->dev), net))
3475                                continue;
3476                        state->offset++;
3477                        return ifa;
3478                }
3479        }
3480
3481        return NULL;
3482}
3483
3484static void *if6_seq_start(struct seq_file *seq, loff_t *pos)
3485        __acquires(rcu_bh)
3486{
3487        rcu_read_lock_bh();
3488        return if6_get_first(seq, *pos);
3489}
3490
3491static void *if6_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3492{
3493        struct inet6_ifaddr *ifa;
3494
3495        ifa = if6_get_next(seq, v);
3496        ++*pos;
3497        return ifa;
3498}
3499
3500static void if6_seq_stop(struct seq_file *seq, void *v)
3501        __releases(rcu_bh)
3502{
3503        rcu_read_unlock_bh();
3504}
3505
3506static int if6_seq_show(struct seq_file *seq, void *v)
3507{
3508        struct inet6_ifaddr *ifp = (struct inet6_ifaddr *)v;
3509        seq_printf(seq, "%pi6 %02x %02x %02x %02x %8s\n",
3510                   &ifp->addr,
3511                   ifp->idev->dev->ifindex,
3512                   ifp->prefix_len,
3513                   ifp->scope,
3514                   (u8) ifp->flags,
3515                   ifp->idev->dev->name);
3516        return 0;
3517}
3518
3519static const struct seq_operations if6_seq_ops = {
3520        .start  = if6_seq_start,
3521        .next   = if6_seq_next,
3522        .show   = if6_seq_show,
3523        .stop   = if6_seq_stop,
3524};
3525
3526static int if6_seq_open(struct inode *inode, struct file *file)
3527{
3528        return seq_open_net(inode, file, &if6_seq_ops,
3529                            sizeof(struct if6_iter_state));
3530}
3531
3532static const struct file_operations if6_fops = {
3533        .owner          = THIS_MODULE,
3534        .open           = if6_seq_open,
3535        .read           = seq_read,
3536        .llseek         = seq_lseek,
3537        .release        = seq_release_net,
3538};
3539
3540static int __net_init if6_proc_net_init(struct net *net)
3541{
3542        if (!proc_create("if_inet6", S_IRUGO, net->proc_net, &if6_fops))
3543                return -ENOMEM;
3544        return 0;
3545}
3546
3547static void __net_exit if6_proc_net_exit(struct net *net)
3548{
3549        remove_proc_entry("if_inet6", net->proc_net);
3550}
3551
3552static struct pernet_operations if6_proc_net_ops = {
3553        .init = if6_proc_net_init,
3554        .exit = if6_proc_net_exit,
3555};
3556
3557int __init if6_proc_init(void)
3558{
3559        return register_pernet_subsys(&if6_proc_net_ops);
3560}
3561
3562void if6_proc_exit(void)
3563{
3564        unregister_pernet_subsys(&if6_proc_net_ops);
3565}
3566#endif  /* CONFIG_PROC_FS */
3567
3568#if IS_ENABLED(CONFIG_IPV6_MIP6)
3569/* Check if address is a home address configured on any interface. */
3570int ipv6_chk_home_addr(struct net *net, const struct in6_addr *addr)
3571{
3572        int ret = 0;
3573        struct inet6_ifaddr *ifp = NULL;
3574        unsigned int hash = inet6_addr_hash(addr);
3575
3576        rcu_read_lock_bh();
3577        hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[hash], addr_lst) {
3578                if (!net_eq(dev_net(ifp->idev->dev), net))
3579                        continue;
3580                if (ipv6_addr_equal(&ifp->addr, addr) &&
3581                    (ifp->flags & IFA_F_HOMEADDRESS)) {
3582                        ret = 1;
3583                        break;
3584                }
3585        }
3586        rcu_read_unlock_bh();
3587        return ret;
3588}
3589#endif
3590
3591/*
3592 *      Periodic address status verification
3593 */
3594
3595static void addrconf_verify_rtnl(void)
3596{
3597        unsigned long now, next, next_sec, next_sched;
3598        struct inet6_ifaddr *ifp;
3599        int i;
3600
3601        ASSERT_RTNL();
3602
3603        rcu_read_lock_bh();
3604        now = jiffies;
3605        next = round_jiffies_up(now + ADDR_CHECK_FREQUENCY);
3606
3607        cancel_delayed_work(&addr_chk_work);
3608
3609        for (i = 0; i < IN6_ADDR_HSIZE; i++) {
3610restart:
3611                hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) {
3612                        unsigned long age;
3613
3614                        /* When setting preferred_lft to a value not zero or
3615                         * infinity, while valid_lft is infinity
3616                         * IFA_F_PERMANENT has a non-infinity life time.
3617                         */
3618                        if ((ifp->flags & IFA_F_PERMANENT) &&
3619                            (ifp->prefered_lft == INFINITY_LIFE_TIME))
3620                                continue;
3621
3622                        spin_lock(&ifp->lock);
3623                        /* We try to batch several events at once. */
3624                        age = (now - ifp->tstamp + ADDRCONF_TIMER_FUZZ_MINUS) / HZ;
3625
3626                        if (ifp->valid_lft != INFINITY_LIFE_TIME &&
3627                            age >= ifp->valid_lft) {
3628                                spin_unlock(&ifp->lock);
3629                                in6_ifa_hold(ifp);
3630                                ipv6_del_addr(ifp);
3631                                goto restart;
3632                        } else if (ifp->prefered_lft == INFINITY_LIFE_TIME) {
3633                                spin_unlock(&ifp->lock);
3634                                continue;
3635                        } else if (age >= ifp->prefered_lft) {
3636                                /* jiffies - ifp->tstamp > age >= ifp->prefered_lft */
3637                                int deprecate = 0;
3638
3639                                if (!(ifp->flags&IFA_F_DEPRECATED)) {
3640                                        deprecate = 1;
3641                                        ifp->flags |= IFA_F_DEPRECATED;
3642                                }
3643
3644                                if ((ifp->valid_lft != INFINITY_LIFE_TIME) &&
3645                                    (time_before(ifp->tstamp + ifp->valid_lft * HZ, next)))
3646                                        next = ifp->tstamp + ifp->valid_lft * HZ;
3647
3648                                spin_unlock(&ifp->lock);
3649
3650                                if (deprecate) {
3651                                        in6_ifa_hold(ifp);
3652
3653                                        ipv6_ifa_notify(0, ifp);
3654                                        in6_ifa_put(ifp);
3655                                        goto restart;
3656                                }
3657                        } else if ((ifp->flags&IFA_F_TEMPORARY) &&
3658                                   !(ifp->flags&IFA_F_TENTATIVE)) {
3659                                unsigned long regen_advance = ifp->idev->cnf.regen_max_retry *
3660                                        ifp->idev->cnf.dad_transmits *
3661                                        NEIGH_VAR(ifp->idev->nd_parms, RETRANS_TIME) / HZ;
3662
3663                                if (age >= ifp->prefered_lft - regen_advance) {
3664                                        struct inet6_ifaddr *ifpub = ifp->ifpub;
3665                                        if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
3666                                                next = ifp->tstamp + ifp->prefered_lft * HZ;
3667                                        if (!ifp->regen_count && ifpub) {
3668                                                ifp->regen_count++;
3669                                                in6_ifa_hold(ifp);
3670                                                in6_ifa_hold(ifpub);
3671                                                spin_unlock(&ifp->lock);
3672
3673                                                spin_lock(&ifpub->lock);
3674                                                ifpub->regen_count = 0;
3675                                                spin_unlock(&ifpub->lock);
3676                                                ipv6_create_tempaddr(ifpub, ifp);
3677                                                in6_ifa_put(ifpub);
3678                                                in6_ifa_put(ifp);
3679                                                goto restart;
3680                                        }
3681                                } else if (time_before(ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ, next))
3682                                        next = ifp->tstamp + ifp->prefered_lft * HZ - regen_advance * HZ;
3683                                spin_unlock(&ifp->lock);
3684                        } else {
3685                                /* ifp->prefered_lft <= ifp->valid_lft */
3686                                if (time_before(ifp->tstamp + ifp->prefered_lft * HZ, next))
3687                                        next = ifp->tstamp + ifp->prefered_lft * HZ;
3688                                spin_unlock(&ifp->lock);
3689                        }
3690                }
3691        }
3692
3693        next_sec = round_jiffies_up(next);
3694        next_sched = next;
3695
3696        /* If rounded timeout is accurate enough, accept it. */
3697        if (time_before(next_sec, next + ADDRCONF_TIMER_FUZZ))
3698                next_sched = next_sec;
3699
3700        /* And minimum interval is ADDRCONF_TIMER_FUZZ_MAX. */
3701        if (time_before(next_sched, jiffies + ADDRCONF_TIMER_FUZZ_MAX))
3702                next_sched = jiffies + ADDRCONF_TIMER_FUZZ_MAX;
3703
3704        ADBG(KERN_DEBUG "now = %lu, schedule = %lu, rounded schedule = %lu => %lu\n",
3705              now, next, next_sec, next_sched);
3706        mod_delayed_work(addrconf_wq, &addr_chk_work, next_sched - now);
3707        rcu_read_unlock_bh();
3708}
3709
3710static void addrconf_verify_work(struct work_struct *w)
3711{
3712        rtnl_lock();
3713        addrconf_verify_rtnl();
3714        rtnl_unlock();
3715}
3716
3717static void addrconf_verify(void)
3718{
3719        mod_delayed_work(addrconf_wq, &addr_chk_work, 0);
3720}
3721
3722static struct in6_addr *extract_addr(struct nlattr *addr, struct nlattr *local,
3723                                     struct in6_addr **peer_pfx)
3724{
3725        struct in6_addr *pfx = NULL;
3726
3727        *peer_pfx = NULL;
3728
3729        if (addr)
3730                pfx = nla_data(addr);
3731
3732        if (local) {
3733                if (pfx && nla_memcmp(local, pfx, sizeof(*pfx)))
3734                        *peer_pfx = pfx;
3735                pfx = nla_data(local);
3736        }
3737
3738        return pfx;
3739}
3740
3741static const struct nla_policy ifa_ipv6_policy[IFA_MAX+1] = {
3742        [IFA_ADDRESS]           = { .len = sizeof(struct in6_addr) },
3743        [IFA_LOCAL]             = { .len = sizeof(struct in6_addr) },
3744        [IFA_CACHEINFO]         = { .len = sizeof(struct ifa_cacheinfo) },
3745        [IFA_FLAGS]             = { .len = sizeof(u32) },
3746};
3747
3748static int
3749inet6_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh)
3750{
3751        struct net *net = sock_net(skb->sk);
3752        struct ifaddrmsg *ifm;
3753        struct nlattr *tb[IFA_MAX+1];
3754        struct in6_addr *pfx, *peer_pfx;
3755        u32 ifa_flags;
3756        int err;
3757
3758        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
3759        if (err < 0)
3760                return err;
3761
3762        ifm = nlmsg_data(nlh);
3763        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
3764        if (pfx == NULL)
3765                return -EINVAL;
3766
3767        ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
3768
3769        /* We ignore other flags so far. */
3770        ifa_flags &= IFA_F_MANAGETEMPADDR;
3771
3772        return inet6_addr_del(net, ifm->ifa_index, ifa_flags, pfx,
3773                              ifm->ifa_prefixlen);
3774}
3775
3776static int inet6_addr_modify(struct inet6_ifaddr *ifp, u32 ifa_flags,
3777                             u32 prefered_lft, u32 valid_lft)
3778{
3779        u32 flags;
3780        clock_t expires;
3781        unsigned long timeout;
3782        bool was_managetempaddr;
3783        bool had_prefixroute;
3784
3785        ASSERT_RTNL();
3786
3787        if (!valid_lft || (prefered_lft > valid_lft))
3788                return -EINVAL;
3789
3790        if (ifa_flags & IFA_F_MANAGETEMPADDR &&
3791            (ifp->flags & IFA_F_TEMPORARY || ifp->prefix_len != 64))
3792                return -EINVAL;
3793
3794        timeout = addrconf_timeout_fixup(valid_lft, HZ);
3795        if (addrconf_finite_timeout(timeout)) {
3796                expires = jiffies_to_clock_t(timeout * HZ);
3797                valid_lft = timeout;
3798                flags = RTF_EXPIRES;
3799        } else {
3800                expires = 0;
3801                flags = 0;
3802                ifa_flags |= IFA_F_PERMANENT;
3803        }
3804
3805        timeout = addrconf_timeout_fixup(prefered_lft, HZ);
3806        if (addrconf_finite_timeout(timeout)) {
3807                if (timeout == 0)
3808                        ifa_flags |= IFA_F_DEPRECATED;
3809                prefered_lft = timeout;
3810        }
3811
3812        spin_lock_bh(&ifp->lock);
3813        was_managetempaddr = ifp->flags & IFA_F_MANAGETEMPADDR;
3814        had_prefixroute = ifp->flags & IFA_F_PERMANENT &&
3815                          !(ifp->flags & IFA_F_NOPREFIXROUTE);
3816        ifp->flags &= ~(IFA_F_DEPRECATED | IFA_F_PERMANENT | IFA_F_NODAD |
3817                        IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
3818                        IFA_F_NOPREFIXROUTE);
3819        ifp->flags |= ifa_flags;
3820        ifp->tstamp = jiffies;
3821        ifp->valid_lft = valid_lft;
3822        ifp->prefered_lft = prefered_lft;
3823
3824        spin_unlock_bh(&ifp->lock);
3825        if (!(ifp->flags&IFA_F_TENTATIVE))
3826                ipv6_ifa_notify(0, ifp);
3827
3828        if (!(ifa_flags & IFA_F_NOPREFIXROUTE)) {
3829                addrconf_prefix_route(&ifp->addr, ifp->prefix_len, ifp->idev->dev,
3830                                      expires, flags);
3831        } else if (had_prefixroute) {
3832                enum cleanup_prefix_rt_t action;
3833                unsigned long rt_expires;
3834
3835                write_lock_bh(&ifp->idev->lock);
3836                action = check_cleanup_prefix_route(ifp, &rt_expires);
3837                write_unlock_bh(&ifp->idev->lock);
3838
3839                if (action != CLEANUP_PREFIX_RT_NOP) {
3840                        cleanup_prefix_route(ifp, rt_expires,
3841                                action == CLEANUP_PREFIX_RT_DEL);
3842                }
3843        }
3844
3845        if (was_managetempaddr || ifp->flags & IFA_F_MANAGETEMPADDR) {
3846                if (was_managetempaddr && !(ifp->flags & IFA_F_MANAGETEMPADDR))
3847                        valid_lft = prefered_lft = 0;
3848                manage_tempaddrs(ifp->idev, ifp, valid_lft, prefered_lft,
3849                                 !was_managetempaddr, jiffies);
3850        }
3851
3852        addrconf_verify_rtnl();
3853
3854        return 0;
3855}
3856
3857static int
3858inet6_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh)
3859{
3860        struct net *net = sock_net(skb->sk);
3861        struct ifaddrmsg *ifm;
3862        struct nlattr *tb[IFA_MAX+1];
3863        struct in6_addr *pfx, *peer_pfx;
3864        struct inet6_ifaddr *ifa;
3865        struct net_device *dev;
3866        u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME;
3867        u32 ifa_flags;
3868        int err;
3869
3870        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
3871        if (err < 0)
3872                return err;
3873
3874        ifm = nlmsg_data(nlh);
3875        pfx = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer_pfx);
3876        if (pfx == NULL)
3877                return -EINVAL;
3878
3879        if (tb[IFA_CACHEINFO]) {
3880                struct ifa_cacheinfo *ci;
3881
3882                ci = nla_data(tb[IFA_CACHEINFO]);
3883                valid_lft = ci->ifa_valid;
3884                preferred_lft = ci->ifa_prefered;
3885        } else {
3886                preferred_lft = INFINITY_LIFE_TIME;
3887                valid_lft = INFINITY_LIFE_TIME;
3888        }
3889
3890        dev =  __dev_get_by_index(net, ifm->ifa_index);
3891        if (dev == NULL)
3892                return -ENODEV;
3893
3894        ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) : ifm->ifa_flags;
3895
3896        /* We ignore other flags so far. */
3897        ifa_flags &= IFA_F_NODAD | IFA_F_HOMEADDRESS | IFA_F_MANAGETEMPADDR |
3898                     IFA_F_NOPREFIXROUTE;
3899
3900        ifa = ipv6_get_ifaddr(net, pfx, dev, 1);
3901        if (ifa == NULL) {
3902                /*
3903                 * It would be best to check for !NLM_F_CREATE here but
3904                 * userspace already relies on not having to provide this.
3905                 */
3906                return inet6_addr_add(net, ifm->ifa_index, pfx, peer_pfx,
3907                                      ifm->ifa_prefixlen, ifa_flags,
3908                                      preferred_lft, valid_lft);
3909        }
3910
3911        if (nlh->nlmsg_flags & NLM_F_EXCL ||
3912            !(nlh->nlmsg_flags & NLM_F_REPLACE))
3913                err = -EEXIST;
3914        else
3915                err = inet6_addr_modify(ifa, ifa_flags, preferred_lft, valid_lft);
3916
3917        in6_ifa_put(ifa);
3918
3919        return err;
3920}
3921
3922static void put_ifaddrmsg(struct nlmsghdr *nlh, u8 prefixlen, u32 flags,
3923                          u8 scope, int ifindex)
3924{
3925        struct ifaddrmsg *ifm;
3926
3927        ifm = nlmsg_data(nlh);
3928        ifm->ifa_family = AF_INET6;
3929        ifm->ifa_prefixlen = prefixlen;
3930        ifm->ifa_flags = flags;
3931        ifm->ifa_scope = scope;
3932        ifm->ifa_index = ifindex;
3933}
3934
3935static int put_cacheinfo(struct sk_buff *skb, unsigned long cstamp,
3936                         unsigned long tstamp, u32 preferred, u32 valid)
3937{
3938        struct ifa_cacheinfo ci;
3939
3940        ci.cstamp = cstamp_delta(cstamp);
3941        ci.tstamp = cstamp_delta(tstamp);
3942        ci.ifa_prefered = preferred;
3943        ci.ifa_valid = valid;
3944
3945        return nla_put(skb, IFA_CACHEINFO, sizeof(ci), &ci);
3946}
3947
3948static inline int rt_scope(int ifa_scope)
3949{
3950        if (ifa_scope & IFA_HOST)
3951                return RT_SCOPE_HOST;
3952        else if (ifa_scope & IFA_LINK)
3953                return RT_SCOPE_LINK;
3954        else if (ifa_scope & IFA_SITE)
3955                return RT_SCOPE_SITE;
3956        else
3957                return RT_SCOPE_UNIVERSE;
3958}
3959
3960static inline int inet6_ifaddr_msgsize(void)
3961{
3962        return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
3963               + nla_total_size(16) /* IFA_LOCAL */
3964               + nla_total_size(16) /* IFA_ADDRESS */
3965               + nla_total_size(sizeof(struct ifa_cacheinfo))
3966               + nla_total_size(4)  /* IFA_FLAGS */;
3967}
3968
3969static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
3970                             u32 portid, u32 seq, int event, unsigned int flags)
3971{
3972        struct nlmsghdr  *nlh;
3973        u32 preferred, valid;
3974
3975        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
3976        if (nlh == NULL)
3977                return -EMSGSIZE;
3978
3979        put_ifaddrmsg(nlh, ifa->prefix_len, ifa->flags, rt_scope(ifa->scope),
3980                      ifa->idev->dev->ifindex);
3981
3982        if (!((ifa->flags&IFA_F_PERMANENT) &&
3983              (ifa->prefered_lft == INFINITY_LIFE_TIME))) {
3984                preferred = ifa->prefered_lft;
3985                valid = ifa->valid_lft;
3986                if (preferred != INFINITY_LIFE_TIME) {
3987                        long tval = (jiffies - ifa->tstamp)/HZ;
3988                        if (preferred > tval)
3989                                preferred -= tval;
3990                        else
3991                                preferred = 0;
3992                        if (valid != INFINITY_LIFE_TIME) {
3993                                if (valid > tval)
3994                                        valid -= tval;
3995                                else
3996                                        valid = 0;
3997                        }
3998                }
3999        } else {
4000                preferred = INFINITY_LIFE_TIME;
4001                valid = INFINITY_LIFE_TIME;
4002        }
4003
4004        if (!ipv6_addr_any(&ifa->peer_addr)) {
4005                if (nla_put(skb, IFA_LOCAL, 16, &ifa->addr) < 0 ||
4006                    nla_put(skb, IFA_ADDRESS, 16, &ifa->peer_addr) < 0)
4007                        goto error;
4008        } else
4009                if (nla_put(skb, IFA_ADDRESS, 16, &ifa->addr) < 0)
4010                        goto error;
4011
4012        if (put_cacheinfo(skb, ifa->cstamp, ifa->tstamp, preferred, valid) < 0)
4013                goto error;
4014
4015        if (nla_put_u32(skb, IFA_FLAGS, ifa->flags) < 0)
4016                goto error;
4017
4018        return nlmsg_end(skb, nlh);
4019
4020error:
4021        nlmsg_cancel(skb, nlh);
4022        return -EMSGSIZE;
4023}
4024
4025static int inet6_fill_ifmcaddr(struct sk_buff *skb, struct ifmcaddr6 *ifmca,
4026                                u32 portid, u32 seq, int event, u16 flags)
4027{
4028        struct nlmsghdr  *nlh;
4029        u8 scope = RT_SCOPE_UNIVERSE;
4030        int ifindex = ifmca->idev->dev->ifindex;
4031
4032        if (ipv6_addr_scope(&ifmca->mca_addr) & IFA_SITE)
4033                scope = RT_SCOPE_SITE;
4034
4035        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4036        if (nlh == NULL)
4037                return -EMSGSIZE;
4038
4039        put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4040        if (nla_put(skb, IFA_MULTICAST, 16, &ifmca->mca_addr) < 0 ||
4041            put_cacheinfo(skb, ifmca->mca_cstamp, ifmca->mca_tstamp,
4042                          INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4043                nlmsg_cancel(skb, nlh);
4044                return -EMSGSIZE;
4045        }
4046
4047        return nlmsg_end(skb, nlh);
4048}
4049
4050static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
4051                                u32 portid, u32 seq, int event, unsigned int flags)
4052{
4053        struct nlmsghdr  *nlh;
4054        u8 scope = RT_SCOPE_UNIVERSE;
4055        int ifindex = ifaca->aca_idev->dev->ifindex;
4056
4057        if (ipv6_addr_scope(&ifaca->aca_addr) & IFA_SITE)
4058                scope = RT_SCOPE_SITE;
4059
4060        nlh = nlmsg_put(skb, portid, seq, event, sizeof(struct ifaddrmsg), flags);
4061        if (nlh == NULL)
4062                return -EMSGSIZE;
4063
4064        put_ifaddrmsg(nlh, 128, IFA_F_PERMANENT, scope, ifindex);
4065        if (nla_put(skb, IFA_ANYCAST, 16, &ifaca->aca_addr) < 0 ||
4066            put_cacheinfo(skb, ifaca->aca_cstamp, ifaca->aca_tstamp,
4067                          INFINITY_LIFE_TIME, INFINITY_LIFE_TIME) < 0) {
4068                nlmsg_cancel(skb, nlh);
4069                return -EMSGSIZE;
4070        }
4071
4072        return nlmsg_end(skb, nlh);
4073}
4074
4075enum addr_type_t {
4076        UNICAST_ADDR,
4077        MULTICAST_ADDR,
4078        ANYCAST_ADDR,
4079};
4080
4081/* called with rcu_read_lock() */
4082static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
4083                          struct netlink_callback *cb, enum addr_type_t type,
4084                          int s_ip_idx, int *p_ip_idx)
4085{
4086        struct ifmcaddr6 *ifmca;
4087        struct ifacaddr6 *ifaca;
4088        int err = 1;
4089        int ip_idx = *p_ip_idx;
4090
4091        read_lock_bh(&idev->lock);
4092        switch (type) {
4093        case UNICAST_ADDR: {
4094                struct inet6_ifaddr *ifa;
4095
4096                /* unicast address incl. temp addr */
4097                list_for_each_entry(ifa, &idev->addr_list, if_list) {
4098                        if (++ip_idx < s_ip_idx)
4099                                continue;
4100                        err = inet6_fill_ifaddr(skb, ifa,
4101                                                NETLINK_CB(cb->skb).portid,
4102                                                cb->nlh->nlmsg_seq,
4103                                                RTM_NEWADDR,
4104                                                NLM_F_MULTI);
4105                        if (err <= 0)
4106                                break;
4107                        nl_dump_check_consistent(cb, nlmsg_hdr(skb));
4108                }
4109                break;
4110        }
4111        case MULTICAST_ADDR:
4112                /* multicast address */
4113                for (ifmca = idev->mc_list; ifmca;
4114                     ifmca = ifmca->next, ip_idx++) {
4115                        if (ip_idx < s_ip_idx)
4116                                continue;
4117                        err = inet6_fill_ifmcaddr(skb, ifmca,
4118                                                  NETLINK_CB(cb->skb).portid,
4119                                                  cb->nlh->nlmsg_seq,
4120                                                  RTM_GETMULTICAST,
4121                                                  NLM_F_MULTI);
4122                        if (err <= 0)
4123                                break;
4124                }
4125                break;
4126        case ANYCAST_ADDR:
4127                /* anycast address */
4128                for (ifaca = idev->ac_list; ifaca;
4129                     ifaca = ifaca->aca_next, ip_idx++) {
4130                        if (ip_idx < s_ip_idx)
4131                                continue;
4132                        err = inet6_fill_ifacaddr(skb, ifaca,
4133                                                  NETLINK_CB(cb->skb).portid,
4134                                                  cb->nlh->nlmsg_seq,
4135                                                  RTM_GETANYCAST,
4136                                                  NLM_F_MULTI);
4137                        if (err <= 0)
4138                                break;
4139                }
4140                break;
4141        default:
4142                break;
4143        }
4144        read_unlock_bh(&idev->lock);
4145        *p_ip_idx = ip_idx;
4146        return err;
4147}
4148
4149static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
4150                           enum addr_type_t type)
4151{
4152        struct net *net = sock_net(skb->sk);
4153        int h, s_h;
4154        int idx, ip_idx;
4155        int s_idx, s_ip_idx;
4156        struct net_device *dev;
4157        struct inet6_dev *idev;
4158        struct hlist_head *head;
4159
4160        s_h = cb->args[0];
4161        s_idx = idx = cb->args[1];
4162        s_ip_idx = ip_idx = cb->args[2];
4163
4164        rcu_read_lock();
4165        cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ net->dev_base_seq;
4166        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4167                idx = 0;
4168                head = &net->dev_index_head[h];
4169                hlist_for_each_entry_rcu(dev, head, index_hlist) {
4170                        if (idx < s_idx)
4171                                goto cont;
4172                        if (h > s_h || idx > s_idx)
4173                                s_ip_idx = 0;
4174                        ip_idx = 0;
4175                        idev = __in6_dev_get(dev);
4176                        if (!idev)
4177                                goto cont;
4178
4179                        if (in6_dump_addrs(idev, skb, cb, type,
4180                                           s_ip_idx, &ip_idx) <= 0)
4181                                goto done;
4182cont:
4183                        idx++;
4184                }
4185        }
4186done:
4187        rcu_read_unlock();
4188        cb->args[0] = h;
4189        cb->args[1] = idx;
4190        cb->args[2] = ip_idx;
4191
4192        return skb->len;
4193}
4194
4195static int inet6_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
4196{
4197        enum addr_type_t type = UNICAST_ADDR;
4198
4199        return inet6_dump_addr(skb, cb, type);
4200}
4201
4202static int inet6_dump_ifmcaddr(struct sk_buff *skb, struct netlink_callback *cb)
4203{
4204        enum addr_type_t type = MULTICAST_ADDR;
4205
4206        return inet6_dump_addr(skb, cb, type);
4207}
4208
4209
4210static int inet6_dump_ifacaddr(struct sk_buff *skb, struct netlink_callback *cb)
4211{
4212        enum addr_type_t type = ANYCAST_ADDR;
4213
4214        return inet6_dump_addr(skb, cb, type);
4215}
4216
4217static int inet6_rtm_getaddr(struct sk_buff *in_skb, struct nlmsghdr *nlh)
4218{
4219        struct net *net = sock_net(in_skb->sk);
4220        struct ifaddrmsg *ifm;
4221        struct nlattr *tb[IFA_MAX+1];
4222        struct in6_addr *addr = NULL, *peer;
4223        struct net_device *dev = NULL;
4224        struct inet6_ifaddr *ifa;
4225        struct sk_buff *skb;
4226        int err;
4227
4228        err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv6_policy);
4229        if (err < 0)
4230                goto errout;
4231
4232        addr = extract_addr(tb[IFA_ADDRESS], tb[IFA_LOCAL], &peer);
4233        if (addr == NULL) {
4234                err = -EINVAL;
4235                goto errout;
4236        }
4237
4238        ifm = nlmsg_data(nlh);
4239        if (ifm->ifa_index)
4240                dev = __dev_get_by_index(net, ifm->ifa_index);
4241
4242        ifa = ipv6_get_ifaddr(net, addr, dev, 1);
4243        if (!ifa) {
4244                err = -EADDRNOTAVAIL;
4245                goto errout;
4246        }
4247
4248        skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_KERNEL);
4249        if (!skb) {
4250                err = -ENOBUFS;
4251                goto errout_ifa;
4252        }
4253
4254        err = inet6_fill_ifaddr(skb, ifa, NETLINK_CB(in_skb).portid,
4255                                nlh->nlmsg_seq, RTM_NEWADDR, 0);
4256        if (err < 0) {
4257                /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
4258                WARN_ON(err == -EMSGSIZE);
4259                kfree_skb(skb);
4260                goto errout_ifa;
4261        }
4262        err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
4263errout_ifa:
4264        in6_ifa_put(ifa);
4265errout:
4266        return err;
4267}
4268
4269static void inet6_ifa_notify(int event, struct inet6_ifaddr *ifa)
4270{
4271        struct sk_buff *skb;
4272        struct net *net = dev_net(ifa->idev->dev);
4273        int err = -ENOBUFS;
4274
4275        skb = nlmsg_new(inet6_ifaddr_msgsize(), GFP_ATOMIC);
4276        if (skb == NULL)
4277                goto errout;
4278
4279        err = inet6_fill_ifaddr(skb, ifa, 0, 0, event, 0);
4280        if (err < 0) {
4281                /* -EMSGSIZE implies BUG in inet6_ifaddr_msgsize() */
4282                WARN_ON(err == -EMSGSIZE);
4283                kfree_skb(skb);
4284                goto errout;
4285        }
4286        rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFADDR, NULL, GFP_ATOMIC);
4287        return;
4288errout:
4289        if (err < 0)
4290                rtnl_set_sk_err(net, RTNLGRP_IPV6_IFADDR, err);
4291}
4292
4293static inline void ipv6_store_devconf(struct ipv6_devconf *cnf,
4294                                __s32 *array, int bytes)
4295{
4296        BUG_ON(bytes < (DEVCONF_MAX * 4));
4297
4298        memset(array, 0, bytes);
4299        array[DEVCONF_FORWARDING] = cnf->forwarding;
4300        array[DEVCONF_HOPLIMIT] = cnf->hop_limit;
4301        array[DEVCONF_MTU6] = cnf->mtu6;
4302        array[DEVCONF_ACCEPT_RA] = cnf->accept_ra;
4303        array[DEVCONF_ACCEPT_REDIRECTS] = cnf->accept_redirects;
4304        array[DEVCONF_AUTOCONF] = cnf->autoconf;
4305        array[DEVCONF_DAD_TRANSMITS] = cnf->dad_transmits;
4306        array[DEVCONF_RTR_SOLICITS] = cnf->rtr_solicits;
4307        array[DEVCONF_RTR_SOLICIT_INTERVAL] =
4308                jiffies_to_msecs(cnf->rtr_solicit_interval);
4309        array[DEVCONF_RTR_SOLICIT_DELAY] =
4310                jiffies_to_msecs(cnf->rtr_solicit_delay);
4311        array[DEVCONF_FORCE_MLD_VERSION] = cnf->force_mld_version;
4312        array[DEVCONF_MLDV1_UNSOLICITED_REPORT_INTERVAL] =
4313                jiffies_to_msecs(cnf->mldv1_unsolicited_report_interval);
4314        array[DEVCONF_MLDV2_UNSOLICITED_REPORT_INTERVAL] =
4315                jiffies_to_msecs(cnf->mldv2_unsolicited_report_interval);
4316        array[DEVCONF_USE_TEMPADDR] = cnf->use_tempaddr;
4317        array[DEVCONF_TEMP_VALID_LFT] = cnf->temp_valid_lft;
4318        array[DEVCONF_TEMP_PREFERED_LFT] = cnf->temp_prefered_lft;
4319        array[DEVCONF_REGEN_MAX_RETRY] = cnf->regen_max_retry;
4320        array[DEVCONF_MAX_DESYNC_FACTOR] = cnf->max_desync_factor;
4321        array[DEVCONF_MAX_ADDRESSES] = cnf->max_addresses;
4322        array[DEVCONF_ACCEPT_RA_DEFRTR] = cnf->accept_ra_defrtr;
4323        array[DEVCONF_ACCEPT_RA_PINFO] = cnf->accept_ra_pinfo;
4324#ifdef CONFIG_IPV6_ROUTER_PREF
4325        array[DEVCONF_ACCEPT_RA_RTR_PREF] = cnf->accept_ra_rtr_pref;
4326        array[DEVCONF_RTR_PROBE_INTERVAL] =
4327                jiffies_to_msecs(cnf->rtr_probe_interval);
4328#ifdef CONFIG_IPV6_ROUTE_INFO
4329        array[DEVCONF_ACCEPT_RA_RT_INFO_MAX_PLEN] = cnf->accept_ra_rt_info_max_plen;
4330#endif
4331#endif
4332        array[DEVCONF_PROXY_NDP] = cnf->proxy_ndp;
4333        array[DEVCONF_ACCEPT_SOURCE_ROUTE] = cnf->accept_source_route;
4334#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
4335        array[DEVCONF_OPTIMISTIC_DAD] = cnf->optimistic_dad;
4336#endif
4337#ifdef CONFIG_IPV6_MROUTE
4338        array[DEVCONF_MC_FORWARDING] = cnf->mc_forwarding;
4339#endif
4340        array[DEVCONF_DISABLE_IPV6] = cnf->disable_ipv6;
4341        array[DEVCONF_ACCEPT_DAD] = cnf->accept_dad;
4342        array[DEVCONF_FORCE_TLLAO] = cnf->force_tllao;
4343        array[DEVCONF_NDISC_NOTIFY] = cnf->ndisc_notify;
4344        array[DEVCONF_SUPPRESS_FRAG_NDISC] = cnf->suppress_frag_ndisc;
4345        array[DEVCONF_ACCEPT_RA_FROM_LOCAL] = cnf->accept_ra_from_local;
4346}
4347
4348static inline size_t inet6_ifla6_size(void)
4349{
4350        return nla_total_size(4) /* IFLA_INET6_FLAGS */
4351             + nla_total_size(sizeof(struct ifla_cacheinfo))
4352             + nla_total_size(DEVCONF_MAX * 4) /* IFLA_INET6_CONF */
4353             + nla_total_size(IPSTATS_MIB_MAX * 8) /* IFLA_INET6_STATS */
4354             + nla_total_size(ICMP6_MIB_MAX * 8) /* IFLA_INET6_ICMP6STATS */
4355             + nla_total_size(sizeof(struct in6_addr)); /* IFLA_INET6_TOKEN */
4356}
4357
4358static inline size_t inet6_if_nlmsg_size(void)
4359{
4360        return NLMSG_ALIGN(sizeof(struct ifinfomsg))
4361               + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
4362               + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
4363               + nla_total_size(4) /* IFLA_MTU */
4364               + nla_total_size(4) /* IFLA_LINK */
4365               + nla_total_size(inet6_ifla6_size()); /* IFLA_PROTINFO */
4366}
4367
4368static inline void __snmp6_fill_statsdev(u64 *stats, atomic_long_t *mib,
4369                                      int items, int bytes)
4370{
4371        int i;
4372        int pad = bytes - sizeof(u64) * items;
4373        BUG_ON(pad < 0);
4374
4375        /* Use put_unaligned() because stats may not be aligned for u64. */
4376        put_unaligned(items, &stats[0]);
4377        for (i = 1; i < items; i++)
4378                put_unaligned(atomic_long_read(&mib[i]), &stats[i]);
4379
4380        memset(&stats[items], 0, pad);
4381}
4382
4383static inline void __snmp6_fill_stats64(u64 *stats, void __percpu *mib,
4384                                      int items, int bytes, size_t syncpoff)
4385{
4386        int i;
4387        int pad = bytes - sizeof(u64) * items;
4388        BUG_ON(pad < 0);
4389
4390        /* Use put_unaligned() because stats may not be aligned for u64. */
4391        put_unaligned(items, &stats[0]);
4392        for (i = 1; i < items; i++)
4393                put_unaligned(snmp_fold_field64(mib, i, syncpoff), &stats[i]);
4394
4395        memset(&stats[items], 0, pad);
4396}
4397
4398static void snmp6_fill_stats(u64 *stats, struct inet6_dev *idev, int attrtype,
4399                             int bytes)
4400{
4401        switch (attrtype) {
4402        case IFLA_INET6_STATS:
4403                __snmp6_fill_stats64(stats, idev->stats.ipv6,
4404                                     IPSTATS_MIB_MAX, bytes, offsetof(struct ipstats_mib, syncp));
4405                break;
4406        case IFLA_INET6_ICMP6STATS:
4407                __snmp6_fill_statsdev(stats, idev->stats.icmpv6dev->mibs, ICMP6_MIB_MAX, bytes);
4408                break;
4409        }
4410}
4411
4412static int inet6_fill_ifla6_attrs(struct sk_buff *skb, struct inet6_dev *idev)
4413{
4414        struct nlattr *nla;
4415        struct ifla_cacheinfo ci;
4416
4417        if (nla_put_u32(skb, IFLA_INET6_FLAGS, idev->if_flags))
4418                goto nla_put_failure;
4419        ci.max_reasm_len = IPV6_MAXPLEN;
4420        ci.tstamp = cstamp_delta(idev->tstamp);
4421        ci.reachable_time = jiffies_to_msecs(idev->nd_parms->reachable_time);
4422        ci.retrans_time = jiffies_to_msecs(NEIGH_VAR(idev->nd_parms, RETRANS_TIME));
4423        if (nla_put(skb, IFLA_INET6_CACHEINFO, sizeof(ci), &ci))
4424                goto nla_put_failure;
4425        nla = nla_reserve(skb, IFLA_INET6_CONF, DEVCONF_MAX * sizeof(s32));
4426        if (nla == NULL)
4427                goto nla_put_failure;
4428        ipv6_store_devconf(&idev->cnf, nla_data(nla), nla_len(nla));
4429
4430        /* XXX - MC not implemented */
4431
4432        nla = nla_reserve(skb, IFLA_INET6_STATS, IPSTATS_MIB_MAX * sizeof(u64));
4433        if (nla == NULL)
4434                goto nla_put_failure;
4435        snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_STATS, nla_len(nla));
4436
4437        nla = nla_reserve(skb, IFLA_INET6_ICMP6STATS, ICMP6_MIB_MAX * sizeof(u64));
4438        if (nla == NULL)
4439                goto nla_put_failure;
4440        snmp6_fill_stats(nla_data(nla), idev, IFLA_INET6_ICMP6STATS, nla_len(nla));
4441
4442        nla = nla_reserve(skb, IFLA_INET6_TOKEN, sizeof(struct in6_addr));
4443        if (nla == NULL)
4444                goto nla_put_failure;
4445
4446        if (nla_put_u8(skb, IFLA_INET6_ADDR_GEN_MODE, idev->addr_gen_mode))
4447                goto nla_put_failure;
4448
4449        read_lock_bh(&idev->lock);
4450        memcpy(nla_data(nla), idev->token.s6_addr, nla_len(nla));
4451        read_unlock_bh(&idev->lock);
4452
4453        return 0;
4454
4455nla_put_failure:
4456        return -EMSGSIZE;
4457}
4458
4459static size_t inet6_get_link_af_size(const struct net_device *dev)
4460{
4461        if (!__in6_dev_get(dev))
4462                return 0;
4463
4464        return inet6_ifla6_size();
4465}
4466
4467static int inet6_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
4468{
4469        struct inet6_dev *idev = __in6_dev_get(dev);
4470
4471        if (!idev)
4472                return -ENODATA;
4473
4474        if (inet6_fill_ifla6_attrs(skb, idev) < 0)
4475                return -EMSGSIZE;
4476
4477        return 0;
4478}
4479
4480static int inet6_set_iftoken(struct inet6_dev *idev, struct in6_addr *token)
4481{
4482        struct inet6_ifaddr *ifp;
4483        struct net_device *dev = idev->dev;
4484        bool update_rs = false;
4485        struct in6_addr ll_addr;
4486
4487        ASSERT_RTNL();
4488
4489        if (token == NULL)
4490                return -EINVAL;
4491        if (ipv6_addr_any(token))
4492                return -EINVAL;
4493        if (dev->flags & (IFF_LOOPBACK | IFF_NOARP))
4494                return -EINVAL;
4495        if (!ipv6_accept_ra(idev))
4496                return -EINVAL;
4497        if (idev->cnf.rtr_solicits <= 0)
4498                return -EINVAL;
4499
4500        write_lock_bh(&idev->lock);
4501
4502        BUILD_BUG_ON(sizeof(token->s6_addr) != 16);
4503        memcpy(idev->token.s6_addr + 8, token->s6_addr + 8, 8);
4504
4505        write_unlock_bh(&idev->lock);
4506
4507        if (!idev->dead && (idev->if_flags & IF_READY) &&
4508            !ipv6_get_lladdr(dev, &ll_addr, IFA_F_TENTATIVE |
4509                             IFA_F_OPTIMISTIC)) {
4510
4511                /* If we're not ready, then normal ifup will take care
4512                 * of this. Otherwise, we need to request our rs here.
4513                 */
4514                ndisc_send_rs(dev, &ll_addr, &in6addr_linklocal_allrouters);
4515                update_rs = true;
4516        }
4517
4518        write_lock_bh(&idev->lock);
4519
4520        if (update_rs) {
4521                idev->if_flags |= IF_RS_SENT;
4522                idev->rs_probes = 1;
4523                addrconf_mod_rs_timer(idev, idev->cnf.rtr_solicit_interval);
4524        }
4525
4526        /* Well, that's kinda nasty ... */
4527        list_for_each_entry(ifp, &idev->addr_list, if_list) {
4528                spin_lock(&ifp->lock);
4529                if (ifp->tokenized) {
4530                        ifp->valid_lft = 0;
4531                        ifp->prefered_lft = 0;
4532                }
4533                spin_unlock(&ifp->lock);
4534        }
4535
4536        write_unlock_bh(&idev->lock);
4537        inet6_ifinfo_notify(RTM_NEWLINK, idev);
4538        addrconf_verify_rtnl();
4539        return 0;
4540}
4541
4542static const struct nla_policy inet6_af_policy[IFLA_INET6_MAX + 1] = {
4543        [IFLA_INET6_ADDR_GEN_MODE]      = { .type = NLA_U8 },
4544        [IFLA_INET6_TOKEN]              = { .len = sizeof(struct in6_addr) },
4545};
4546
4547static int inet6_validate_link_af(const struct net_device *dev,
4548                                  const struct nlattr *nla)
4549{
4550        struct nlattr *tb[IFLA_INET6_MAX + 1];
4551
4552        if (dev && !__in6_dev_get(dev))
4553                return -EAFNOSUPPORT;
4554
4555        return nla_parse_nested(tb, IFLA_INET6_MAX, nla, inet6_af_policy);
4556}
4557
4558static int inet6_set_link_af(struct net_device *dev, const struct nlattr *nla)
4559{
4560        int err = -EINVAL;
4561        struct inet6_dev *idev = __in6_dev_get(dev);
4562        struct nlattr *tb[IFLA_INET6_MAX + 1];
4563
4564        if (!idev)
4565                return -EAFNOSUPPORT;
4566
4567        if (nla_parse_nested(tb, IFLA_INET6_MAX, nla, NULL) < 0)
4568                BUG();
4569
4570        if (tb[IFLA_INET6_TOKEN]) {
4571                err = inet6_set_iftoken(idev, nla_data(tb[IFLA_INET6_TOKEN]));
4572                if (err)
4573                        return err;
4574        }
4575
4576        if (tb[IFLA_INET6_ADDR_GEN_MODE]) {
4577                u8 mode = nla_get_u8(tb[IFLA_INET6_ADDR_GEN_MODE]);
4578
4579                if (mode != IN6_ADDR_GEN_MODE_EUI64 &&
4580                    mode != IN6_ADDR_GEN_MODE_NONE)
4581                        return -EINVAL;
4582                idev->addr_gen_mode = mode;
4583                err = 0;
4584        }
4585
4586        return err;
4587}
4588
4589static int inet6_fill_ifinfo(struct sk_buff *skb, struct inet6_dev *idev,
4590                             u32 portid, u32 seq, int event, unsigned int flags)
4591{
4592        struct net_device *dev = idev->dev;
4593        struct ifinfomsg *hdr;
4594        struct nlmsghdr *nlh;
4595        void *protoinfo;
4596
4597        nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
4598        if (nlh == NULL)
4599                return -EMSGSIZE;
4600
4601        hdr = nlmsg_data(nlh);
4602        hdr->ifi_family = AF_INET6;
4603        hdr->__ifi_pad = 0;
4604        hdr->ifi_type = dev->type;
4605        hdr->ifi_index = dev->ifindex;
4606        hdr->ifi_flags = dev_get_flags(dev);
4607        hdr->ifi_change = 0;
4608
4609        if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
4610            (dev->addr_len &&
4611             nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
4612            nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
4613            (dev->ifindex != dev->iflink &&
4614             nla_put_u32(skb, IFLA_LINK, dev->iflink)))
4615                goto nla_put_failure;
4616        protoinfo = nla_nest_start(skb, IFLA_PROTINFO);
4617        if (protoinfo == NULL)
4618                goto nla_put_failure;
4619
4620        if (inet6_fill_ifla6_attrs(skb, idev) < 0)
4621                goto nla_put_failure;
4622
4623        nla_nest_end(skb, protoinfo);
4624        return nlmsg_end(skb, nlh);
4625
4626nla_put_failure:
4627        nlmsg_cancel(skb, nlh);
4628        return -EMSGSIZE;
4629}
4630
4631static int inet6_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
4632{
4633        struct net *net = sock_net(skb->sk);
4634        int h, s_h;
4635        int idx = 0, s_idx;
4636        struct net_device *dev;
4637        struct inet6_dev *idev;
4638        struct hlist_head *head;
4639
4640        s_h = cb->args[0];
4641        s_idx = cb->args[1];
4642
4643        rcu_read_lock();
4644        for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
4645                idx = 0;
4646                head = &net->dev_index_head[h];
4647                hlist_for_each_entry_rcu(dev, head, index_hlist) {
4648                        if (idx < s_idx)
4649                                goto cont;
4650                        idev = __in6_dev_get(dev);
4651                        if (!idev)
4652                                goto cont;
4653                        if (inet6_fill_ifinfo(skb, idev,
4654                                              NETLINK_CB(cb->skb).portid,
4655                                              cb->nlh->nlmsg_seq,
4656                                              RTM_NEWLINK, NLM_F_MULTI) <= 0)
4657                                goto out;
4658cont:
4659                        idx++;
4660                }
4661        }
4662out:
4663        rcu_read_unlock();
4664        cb->args[1] = idx;
4665        cb->args[0] = h;
4666
4667        return skb->len;
4668}
4669
4670void inet6_ifinfo_notify(int event, struct inet6_dev *idev)
4671{
4672        struct sk_buff *skb;
4673        struct net *net = dev_net(idev->dev);
4674        int err = -ENOBUFS;
4675
4676        skb = nlmsg_new(inet6_if_nlmsg_size(), GFP_ATOMIC);
4677        if (skb == NULL)
4678                goto errout;
4679
4680        err = inet6_fill_ifinfo(skb, idev, 0, 0, event, 0);
4681        if (err < 0) {
4682                /* -EMSGSIZE implies BUG in inet6_if_nlmsg_size() */
4683                WARN_ON(err == -EMSGSIZE);
4684                kfree_skb(skb);
4685                goto errout;
4686        }
4687        rtnl_notify(skb, net, 0, RTNLGRP_IPV6_IFINFO, NULL, GFP_ATOMIC);
4688        return;
4689errout:
4690        if (err < 0)
4691                rtnl_set_sk_err(net, RTNLGRP_IPV6_IFINFO, err);
4692}
4693
4694static inline size_t inet6_prefix_nlmsg_size(void)
4695{
4696        return NLMSG_ALIGN(sizeof(struct prefixmsg))
4697               + nla_total_size(sizeof(struct in6_addr))
4698               + nla_total_size(sizeof(struct prefix_cacheinfo));
4699}
4700
4701static int inet6_fill_prefix(struct sk_buff *skb, struct inet6_dev *idev,
4702                             struct prefix_info *pinfo, u32 portid, u32 seq,
4703                             int event, unsigned int flags)
4704{
4705        struct prefixmsg *pmsg;
4706        struct nlmsghdr *nlh;
4707        struct prefix_cacheinfo ci;
4708
4709        nlh = nlmsg_put(skb, portid, seq, event, sizeof(*pmsg), flags);
4710        if (nlh == NULL)
4711                return -EMSGSIZE;
4712
4713        pmsg = nlmsg_data(nlh);
4714        pmsg->prefix_family = AF_INET6;
4715        pmsg->prefix_pad1 = 0;
4716        pmsg->prefix_pad2 = 0;
4717        pmsg->prefix_ifindex = idev->dev->ifindex;
4718        pmsg->prefix_len = pinfo->prefix_len;
4719        pmsg->prefix_type = pinfo->type;
4720        pmsg->prefix_pad3 = 0;
4721        pmsg->prefix_flags = 0;
4722        if (pinfo->onlink)
4723                pmsg->prefix_flags |= IF_PREFIX_ONLINK;
4724        if (pinfo->autoconf)
4725                pmsg->prefix_flags |= IF_PREFIX_AUTOCONF;
4726
4727        if (nla_put(skb, PREFIX_ADDRESS, sizeof(pinfo->prefix), &pinfo->prefix))
4728                goto nla_put_failure;
4729        ci.preferred_time = ntohl(pinfo->prefered);
4730        ci.valid_time = ntohl(pinfo->valid);
4731        if (nla_put(skb, PREFIX_CACHEINFO, sizeof(ci), &ci))
4732                goto nla_put_failure;
4733        return nlmsg_end(skb, nlh);
4734
4735nla_put_failure:
4736        nlmsg_cancel(skb, nlh);
4737        return -EMSGSIZE;
4738}
4739
4740static void inet6_prefix_notify(int event, struct inet6_dev *idev,
4741                         struct prefix_info *pinfo)
4742{
4743        struct sk_buff *skb;
4744        struct net *net = dev_net(idev->dev);
4745        int err = -ENOBUFS;
4746
4747        skb = nlmsg_new(inet6_prefix_nlmsg_size(), GFP_ATOMIC);
4748        if (skb == NULL)
4749                goto errout;
4750
4751        err = inet6_fill_prefix(skb, idev, pinfo, 0, 0, event, 0);
4752        if (err < 0) {
4753                /* -EMSGSIZE implies BUG in inet6_prefix_nlmsg_size() */
4754                WARN_ON(err == -EMSGSIZE);
4755                kfree_skb(skb);
4756                goto errout;
4757        }
4758        rtnl_notify(skb, net, 0, RTNLGRP_IPV6_PREFIX, NULL, GFP_ATOMIC);
4759        return;
4760errout:
4761        if (err < 0)
4762                rtnl_set_sk_err(net, RTNLGRP_IPV6_PREFIX, err);
4763}
4764
4765static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
4766{
4767        struct net *net = dev_net(ifp->idev->dev);
4768
4769        if (event)
4770                ASSERT_RTNL();
4771
4772        inet6_ifa_notify(event ? : RTM_NEWADDR, ifp);
4773
4774        switch (event) {
4775        case RTM_NEWADDR:
4776                /*
4777                 * If the address was optimistic
4778                 * we inserted the route at the start of
4779                 * our DAD process, so we don't need
4780                 * to do it again
4781                 */
4782                if (!(ifp->rt->rt6i_node))
4783                        ip6_ins_rt(ifp->rt);
4784                if (ifp->idev->cnf.forwarding)
4785                        addrconf_join_anycast(ifp);
4786                if (!ipv6_addr_any(&ifp->peer_addr))
4787                        addrconf_prefix_route(&ifp->peer_addr, 128,
4788                                              ifp->idev->dev, 0, 0);
4789                break;
4790        case RTM_DELADDR:
4791                if (ifp->idev->cnf.forwarding)
4792                        addrconf_leave_anycast(ifp);
4793                addrconf_leave_solict(ifp->idev, &ifp->addr);
4794                if (!ipv6_addr_any(&ifp->peer_addr)) {
4795                        struct rt6_info *rt;
4796
4797                        rt = addrconf_get_prefix_route(&ifp->peer_addr, 128,
4798                                                       ifp->idev->dev, 0, 0);
4799                        if (rt && ip6_del_rt(rt))
4800                                dst_free(&rt->dst);
4801                }
4802                dst_hold(&ifp->rt->dst);
4803
4804                if (ip6_del_rt(ifp->rt))
4805                        dst_free(&ifp->rt->dst);
4806
4807                rt_genid_bump_ipv6(net);
4808                break;
4809        }
4810        atomic_inc(&net->ipv6.dev_addr_genid);
4811}
4812
4813static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifp)
4814{
4815        rcu_read_lock_bh();
4816        if (likely(ifp->idev->dead == 0))
4817                __ipv6_ifa_notify(event, ifp);
4818        rcu_read_unlock_bh();
4819}
4820
4821#ifdef CONFIG_SYSCTL
4822
4823static
4824int addrconf_sysctl_forward(struct ctl_table *ctl, int write,
4825                           void __user *buffer, size_t *lenp, loff_t *ppos)
4826{
4827        int *valp = ctl->data;
4828        int val = *valp;
4829        loff_t pos = *ppos;
4830        struct ctl_table lctl;
4831        int ret;
4832
4833        /*
4834         * ctl->data points to idev->cnf.forwarding, we should
4835         * not modify it until we get the rtnl lock.
4836         */
4837        lctl = *ctl;
4838        lctl.data = &val;
4839
4840        ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
4841
4842        if (write)
4843                ret = addrconf_fixup_forwarding(ctl, valp, val);
4844        if (ret)
4845                *ppos = pos;
4846        return ret;
4847}
4848
4849static
4850int addrconf_sysctl_mtu(struct ctl_table *ctl, int write,
4851                        void __user *buffer, size_t *lenp, loff_t *ppos)
4852{
4853        struct inet6_dev *idev = ctl->extra1;
4854        int min_mtu = IPV6_MIN_MTU;
4855        struct ctl_table lctl;
4856
4857        lctl = *ctl;
4858        lctl.extra1 = &min_mtu;
4859        lctl.extra2 = idev ? &idev->dev->mtu : NULL;
4860
4861        return proc_dointvec_minmax(&lctl, write, buffer, lenp, ppos);
4862}
4863
4864static void dev_disable_change(struct inet6_dev *idev)
4865{
4866        struct netdev_notifier_info info;
4867
4868        if (!idev || !idev->dev)
4869                return;
4870
4871        netdev_notifier_info_init(&info, idev->dev);
4872        if (idev->cnf.disable_ipv6)
4873                addrconf_notify(NULL, NETDEV_DOWN, &info);
4874        else
4875                addrconf_notify(NULL, NETDEV_UP, &info);
4876}
4877
4878static void addrconf_disable_change(struct net *net, __s32 newf)
4879{
4880        struct net_device *dev;
4881        struct inet6_dev *idev;
4882
4883        rcu_read_lock();
4884        for_each_netdev_rcu(net, dev) {
4885                idev = __in6_dev_get(dev);
4886                if (idev) {
4887                        int changed = (!idev->cnf.disable_ipv6) ^ (!newf);
4888                        idev->cnf.disable_ipv6 = newf;
4889                        if (changed)
4890                                dev_disable_change(idev);
4891                }
4892        }
4893        rcu_read_unlock();
4894}
4895
4896static int addrconf_disable_ipv6(struct ctl_table *table, int *p, int newf)
4897{
4898        struct net *net;
4899        int old;
4900
4901        if (!rtnl_trylock())
4902                return restart_syscall();
4903
4904        net = (struct net *)table->extra2;
4905        old = *p;
4906        *p = newf;
4907
4908        if (p == &net->ipv6.devconf_dflt->disable_ipv6) {
4909                rtnl_unlock();
4910                return 0;
4911        }
4912
4913        if (p == &net->ipv6.devconf_all->disable_ipv6) {
4914                net->ipv6.devconf_dflt->disable_ipv6 = newf;
4915                addrconf_disable_change(net, newf);
4916        } else if ((!newf) ^ (!old))
4917                dev_disable_change((struct inet6_dev *)table->extra1);
4918
4919        rtnl_unlock();
4920        return 0;
4921}
4922
4923static
4924int addrconf_sysctl_disable(struct ctl_table *ctl, int write,
4925                            void __user *buffer, size_t *lenp, loff_t *ppos)
4926{
4927        int *valp = ctl->data;
4928        int val = *valp;
4929        loff_t pos = *ppos;
4930        struct ctl_table lctl;
4931        int ret;
4932
4933        /*
4934         * ctl->data points to idev->cnf.disable_ipv6, we should
4935         * not modify it until we get the rtnl lock.
4936         */
4937        lctl = *ctl;
4938        lctl.data = &val;
4939
4940        ret = proc_dointvec(&lctl, write, buffer, lenp, ppos);
4941
4942        if (write)
4943                ret = addrconf_disable_ipv6(ctl, valp, val);
4944        if (ret)
4945                *ppos = pos;
4946        return ret;
4947}
4948
4949static
4950int addrconf_sysctl_proxy_ndp(struct ctl_table *ctl, int write,
4951                              void __user *buffer, size_t *lenp, loff_t *ppos)
4952{
4953        int *valp = ctl->data;
4954        int ret;
4955        int old, new;
4956
4957        old = *valp;
4958        ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
4959        new = *valp;
4960
4961        if (write && old != new) {
4962                struct net *net = ctl->extra2;
4963
4964                if (!rtnl_trylock())
4965                        return restart_syscall();
4966
4967                if (valp == &net->ipv6.devconf_dflt->proxy_ndp)
4968                        inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
4969                                                     NETCONFA_IFINDEX_DEFAULT,
4970                                                     net->ipv6.devconf_dflt);
4971                else if (valp == &net->ipv6.devconf_all->proxy_ndp)
4972                        inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
4973                                                     NETCONFA_IFINDEX_ALL,
4974                                                     net->ipv6.devconf_all);
4975                else {
4976                        struct inet6_dev *idev = ctl->extra1;
4977
4978                        inet6_netconf_notify_devconf(net, NETCONFA_PROXY_NEIGH,
4979                                                     idev->dev->ifindex,
4980                                                     &idev->cnf);
4981                }
4982                rtnl_unlock();
4983        }
4984
4985        return ret;
4986}
4987
4988
4989static struct addrconf_sysctl_table
4990{
4991        struct ctl_table_header *sysctl_header;
4992        struct ctl_table addrconf_vars[DEVCONF_MAX+1];
4993} addrconf_sysctl __read_mostly = {
4994        .sysctl_header = NULL,
4995        .addrconf_vars = {
4996                {
4997                        .procname       = "forwarding",
4998                        .data           = &ipv6_devconf.forwarding,
4999                        .maxlen         = sizeof(int),
5000                        .mode           = 0644,
5001                        .proc_handler   = addrconf_sysctl_forward,
5002                },
5003                {
5004                        .procname       = "hop_limit",
5005                        .data           = &ipv6_devconf.hop_limit,
5006                        .maxlen         = sizeof(int),
5007                        .mode           = 0644,
5008                        .proc_handler   = proc_dointvec,
5009                },
5010                {
5011                        .procname       = "mtu",
5012                        .data           = &ipv6_devconf.mtu6,
5013                        .maxlen         = sizeof(int),
5014                        .mode           = 0644,
5015                        .proc_handler   = addrconf_sysctl_mtu,
5016                },
5017                {
5018                        .procname       = "accept_ra",
5019                        .data           = &ipv6_devconf.accept_ra,
5020                        .maxlen         = sizeof(int),
5021                        .mode           = 0644,
5022                        .proc_handler   = proc_dointvec,
5023                },
5024                {
5025                        .procname       = "accept_redirects",
5026                        .data           = &ipv6_devconf.accept_redirects,
5027                        .maxlen         = sizeof(int),
5028                        .mode           = 0644,
5029                        .proc_handler   = proc_dointvec,
5030                },
5031                {
5032                        .procname       = "autoconf",
5033                        .data           = &ipv6_devconf.autoconf,
5034                        .maxlen         = sizeof(int),
5035                        .mode           = 0644,
5036                        .proc_handler   = proc_dointvec,
5037                },
5038                {
5039                        .procname       = "dad_transmits",
5040                        .data           = &ipv6_devconf.dad_transmits,
5041                        .maxlen         = sizeof(int),
5042                        .mode           = 0644,
5043                        .proc_handler   = proc_dointvec,
5044                },
5045                {
5046                        .procname       = "router_solicitations",
5047                        .data           = &ipv6_devconf.rtr_solicits,
5048                        .maxlen         = sizeof(int),
5049                        .mode           = 0644,
5050                        .proc_handler   = proc_dointvec,
5051                },
5052                {
5053                        .procname       = "router_solicitation_interval",
5054                        .data           = &ipv6_devconf.rtr_solicit_interval,
5055                        .maxlen         = sizeof(int),
5056                        .mode           = 0644,
5057                        .proc_handler   = proc_dointvec_jiffies,
5058                },
5059                {
5060                        .procname       = "router_solicitation_delay",
5061                        .data           = &ipv6_devconf.rtr_solicit_delay,
5062                        .maxlen         = sizeof(int),
5063                        .mode           = 0644,
5064                        .proc_handler   = proc_dointvec_jiffies,
5065                },
5066                {
5067                        .procname       = "force_mld_version",
5068                        .data           = &ipv6_devconf.force_mld_version,
5069                        .maxlen         = sizeof(int),
5070                        .mode           = 0644,
5071                        .proc_handler   = proc_dointvec,
5072                },
5073                {
5074                        .procname       = "mldv1_unsolicited_report_interval",
5075                        .data           =
5076                                &ipv6_devconf.mldv1_unsolicited_report_interval,
5077                        .maxlen         = sizeof(int),
5078                        .mode           = 0644,
5079                        .proc_handler   = proc_dointvec_ms_jiffies,
5080                },
5081                {
5082                        .procname       = "mldv2_unsolicited_report_interval",
5083                        .data           =
5084                                &ipv6_devconf.mldv2_unsolicited_report_interval,
5085                        .maxlen         = sizeof(int),
5086                        .mode           = 0644,
5087                        .proc_handler   = proc_dointvec_ms_jiffies,
5088                },
5089                {
5090                        .procname       = "use_tempaddr",
5091                        .data           = &ipv6_devconf.use_tempaddr,
5092                        .maxlen         = sizeof(int),
5093                        .mode           = 0644,
5094                        .proc_handler   = proc_dointvec,
5095                },
5096                {
5097                        .procname       = "temp_valid_lft",
5098                        .data           = &ipv6_devconf.temp_valid_lft,
5099                        .maxlen         = sizeof(int),
5100                        .mode           = 0644,
5101                        .proc_handler   = proc_dointvec,
5102                },
5103                {
5104                        .procname       = "temp_prefered_lft",
5105                        .data           = &ipv6_devconf.temp_prefered_lft,
5106                        .maxlen         = sizeof(int),
5107                        .mode           = 0644,
5108                        .proc_handler   = proc_dointvec,
5109                },
5110                {
5111                        .procname       = "regen_max_retry",
5112                        .data           = &ipv6_devconf.regen_max_retry,
5113                        .maxlen         = sizeof(int),
5114                        .mode           = 0644,
5115                        .proc_handler   = proc_dointvec,
5116                },
5117                {
5118                        .procname       = "max_desync_factor",
5119                        .data           = &ipv6_devconf.max_desync_factor,
5120                        .maxlen         = sizeof(int),
5121                        .mode           = 0644,
5122                        .proc_handler   = proc_dointvec,
5123                },
5124                {
5125                        .procname       = "max_addresses",
5126                        .data           = &ipv6_devconf.max_addresses,
5127                        .maxlen         = sizeof(int),
5128                        .mode           = 0644,
5129                        .proc_handler   = proc_dointvec,
5130                },
5131                {
5132                        .procname       = "accept_ra_defrtr",
5133                        .data           = &ipv6_devconf.accept_ra_defrtr,
5134                        .maxlen         = sizeof(int),
5135                        .mode           = 0644,
5136                        .proc_handler   = proc_dointvec,
5137                },
5138                {
5139                        .procname       = "accept_ra_pinfo",
5140                        .data           = &ipv6_devconf.accept_ra_pinfo,
5141                        .maxlen         = sizeof(int),
5142                        .mode           = 0644,
5143                        .proc_handler   = proc_dointvec,
5144                },
5145#ifdef CONFIG_IPV6_ROUTER_PREF
5146                {
5147                        .procname       = "accept_ra_rtr_pref",
5148                        .data           = &ipv6_devconf.accept_ra_rtr_pref,
5149                        .maxlen         = sizeof(int),
5150                        .mode           = 0644,
5151                        .proc_handler   = proc_dointvec,
5152                },
5153                {
5154                        .procname       = "router_probe_interval",
5155                        .data           = &ipv6_devconf.rtr_probe_interval,
5156                        .maxlen         = sizeof(int),
5157                        .mode           = 0644,
5158                        .proc_handler   = proc_dointvec_jiffies,
5159                },
5160#ifdef CONFIG_IPV6_ROUTE_INFO
5161                {
5162                        .procname       = "accept_ra_rt_info_max_plen",
5163                        .data           = &ipv6_devconf.accept_ra_rt_info_max_plen,
5164                        .maxlen         = sizeof(int),
5165                        .mode           = 0644,
5166                        .proc_handler   = proc_dointvec,
5167                },
5168#endif
5169#endif
5170                {
5171                        .procname       = "proxy_ndp",
5172                        .data           = &ipv6_devconf.proxy_ndp,
5173                        .maxlen         = sizeof(int),
5174                        .mode           = 0644,
5175                        .proc_handler   = addrconf_sysctl_proxy_ndp,
5176                },
5177                {
5178                        .procname       = "accept_source_route",
5179                        .data           = &ipv6_devconf.accept_source_route,
5180                        .maxlen         = sizeof(int),
5181                        .mode           = 0644,
5182                        .proc_handler   = proc_dointvec,
5183                },
5184#ifdef CONFIG_IPV6_OPTIMISTIC_DAD
5185                {
5186                        .procname       = "optimistic_dad",
5187                        .data           = &ipv6_devconf.optimistic_dad,
5188                        .maxlen         = sizeof(int),
5189                        .mode           = 0644,
5190                        .proc_handler   = proc_dointvec,
5191
5192                },
5193#endif
5194#ifdef CONFIG_IPV6_MROUTE
5195                {
5196                        .procname       = "mc_forwarding",
5197                        .data           = &ipv6_devconf.mc_forwarding,
5198                        .maxlen         = sizeof(int),
5199                        .mode           = 0444,
5200                        .proc_handler   = proc_dointvec,
5201                },
5202#endif
5203                {
5204                        .procname       = "disable_ipv6",
5205                        .data           = &ipv6_devconf.disable_ipv6,
5206                        .maxlen         = sizeof(int),
5207                        .mode           = 0644,
5208                        .proc_handler   = addrconf_sysctl_disable,
5209                },
5210                {
5211                        .procname       = "accept_dad",
5212                        .data           = &ipv6_devconf.accept_dad,
5213                        .maxlen         = sizeof(int),
5214                        .mode           = 0644,
5215                        .proc_handler   = proc_dointvec,
5216                },
5217                {
5218                        .procname       = "force_tllao",
5219                        .data           = &ipv6_devconf.force_tllao,
5220                        .maxlen         = sizeof(int),
5221                        .mode           = 0644,
5222                        .proc_handler   = proc_dointvec
5223                },
5224                {
5225                        .procname       = "ndisc_notify",
5226                        .data           = &ipv6_devconf.ndisc_notify,
5227                        .maxlen         = sizeof(int),
5228                        .mode           = 0644,
5229                        .proc_handler   = proc_dointvec
5230                },
5231                {
5232                        .procname       = "suppress_frag_ndisc",
5233                        .data           = &ipv6_devconf.suppress_frag_ndisc,
5234                        .maxlen         = sizeof(int),
5235                        .mode           = 0644,
5236                        .proc_handler   = proc_dointvec
5237                },
5238                {
5239                        .procname       = "accept_ra_from_local",
5240                        .data           = &ipv6_devconf.accept_ra_from_local,
5241                        .maxlen         = sizeof(int),
5242                        .mode           = 0644,
5243                        .proc_handler   = proc_dointvec,
5244                },
5245                {
5246                        /* sentinel */
5247                }
5248        },
5249};
5250
5251static int __addrconf_sysctl_register(struct net *net, char *dev_name,
5252                struct inet6_dev *idev, struct ipv6_devconf *p)
5253{
5254        int i;
5255        struct addrconf_sysctl_table *t;
5256        char path[sizeof("net/ipv6/conf/") + IFNAMSIZ];
5257
5258        t = kmemdup(&addrconf_sysctl, sizeof(*t), GFP_KERNEL);
5259        if (t == NULL)
5260                goto out;
5261
5262        for (i = 0; t->addrconf_vars[i].data; i++) {
5263                t->addrconf_vars[i].data += (char *)p - (char *)&ipv6_devconf;
5264                t->addrconf_vars[i].extra1 = idev; /* embedded; no ref */
5265                t->addrconf_vars[i].extra2 = net;
5266        }
5267
5268        snprintf(path, sizeof(path), "net/ipv6/conf/%s", dev_name);
5269
5270        t->sysctl_header = register_net_sysctl(net, path, t->addrconf_vars);
5271        if (t->sysctl_header == NULL)
5272                goto free;
5273
5274        p->sysctl = t;
5275        return 0;
5276
5277free:
5278        kfree(t);
5279out:
5280        return -ENOBUFS;
5281}
5282
5283static void __addrconf_sysctl_unregister(struct ipv6_devconf *p)
5284{
5285        struct addrconf_sysctl_table *t;
5286
5287        if (p->sysctl == NULL)
5288                return;
5289
5290        t = p->sysctl;
5291        p->sysctl = NULL;
5292        unregister_net_sysctl_table(t->sysctl_header);
5293        kfree(t);
5294}
5295
5296static int addrconf_sysctl_register(struct inet6_dev *idev)
5297{
5298        int err;
5299
5300        if (!sysctl_dev_name_is_allowed(idev->dev->name))
5301                return -EINVAL;
5302
5303        err = neigh_sysctl_register(idev->dev, idev->nd_parms,
5304                                    &ndisc_ifinfo_sysctl_change);
5305        if (err)
5306                return err;
5307        err = __addrconf_sysctl_register(dev_net(idev->dev), idev->dev->name,
5308                                         idev, &idev->cnf);
5309        if (err)
5310                neigh_sysctl_unregister(idev->nd_parms);
5311
5312        return err;
5313}
5314
5315static void addrconf_sysctl_unregister(struct inet6_dev *idev)
5316{
5317        __addrconf_sysctl_unregister(&idev->cnf);
5318        neigh_sysctl_unregister(idev->nd_parms);
5319}
5320
5321
5322#endif
5323
5324static int __net_init addrconf_init_net(struct net *net)
5325{
5326        int err = -ENOMEM;
5327        struct ipv6_devconf *all, *dflt;
5328
5329        all = kmemdup(&ipv6_devconf, sizeof(ipv6_devconf), GFP_KERNEL);
5330        if (all == NULL)
5331                goto err_alloc_all;
5332
5333        dflt = kmemdup(&ipv6_devconf_dflt, sizeof(ipv6_devconf_dflt), GFP_KERNEL);
5334        if (dflt == NULL)
5335                goto err_alloc_dflt;
5336
5337        /* these will be inherited by all namespaces */
5338        dflt->autoconf = ipv6_defaults.autoconf;
5339        dflt->disable_ipv6 = ipv6_defaults.disable_ipv6;
5340
5341        net->ipv6.devconf_all = all;
5342        net->ipv6.devconf_dflt = dflt;
5343
5344#ifdef CONFIG_SYSCTL
5345        err = __addrconf_sysctl_register(net, "all", NULL, all);
5346        if (err < 0)
5347                goto err_reg_all;
5348
5349        err = __addrconf_sysctl_register(net, "default", NULL, dflt);
5350        if (err < 0)
5351                goto err_reg_dflt;
5352#endif
5353        return 0;
5354
5355#ifdef CONFIG_SYSCTL
5356err_reg_dflt:
5357        __addrconf_sysctl_unregister(all);
5358err_reg_all:
5359        kfree(dflt);
5360#endif
5361err_alloc_dflt:
5362        kfree(all);
5363err_alloc_all:
5364        return err;
5365}
5366
5367static void __net_exit addrconf_exit_net(struct net *net)
5368{
5369#ifdef CONFIG_SYSCTL
5370        __addrconf_sysctl_unregister(net->ipv6.devconf_dflt);
5371        __addrconf_sysctl_unregister(net->ipv6.devconf_all);
5372#endif
5373        if (!net_eq(net, &init_net)) {
5374                kfree(net->ipv6.devconf_dflt);
5375                kfree(net->ipv6.devconf_all);
5376        }
5377}
5378
5379static struct pernet_operations addrconf_ops = {
5380        .init = addrconf_init_net,
5381        .exit = addrconf_exit_net,
5382};
5383
5384static struct rtnl_af_ops inet6_ops = {
5385        .family           = AF_INET6,
5386        .fill_link_af     = inet6_fill_link_af,
5387        .get_link_af_size = inet6_get_link_af_size,
5388        .validate_link_af = inet6_validate_link_af,
5389        .set_link_af      = inet6_set_link_af,
5390};
5391
5392/*
5393 *      Init / cleanup code
5394 */
5395
5396int __init addrconf_init(void)
5397{
5398        struct inet6_dev *idev;
5399        int i, err;
5400
5401        err = ipv6_addr_label_init();
5402        if (err < 0) {
5403                pr_crit("%s: cannot initialize default policy table: %d\n",
5404                        __func__, err);
5405                goto out;
5406        }
5407
5408        err = register_pernet_subsys(&addrconf_ops);
5409        if (err < 0)
5410                goto out_addrlabel;
5411
5412        addrconf_wq = create_workqueue("ipv6_addrconf");
5413        if (!addrconf_wq) {
5414                err = -ENOMEM;
5415                goto out_nowq;
5416        }
5417
5418        /* The addrconf netdev notifier requires that loopback_dev
5419         * has it's ipv6 private information allocated and setup
5420         * before it can bring up and give link-local addresses
5421         * to other devices which are up.
5422         *
5423         * Unfortunately, loopback_dev is not necessarily the first
5424         * entry in the global dev_base list of net devices.  In fact,
5425         * it is likely to be the very last entry on that list.
5426         * So this causes the notifier registry below to try and
5427         * give link-local addresses to all devices besides loopback_dev
5428         * first, then loopback_dev, which cases all the non-loopback_dev
5429         * devices to fail to get a link-local address.
5430         *
5431         * So, as a temporary fix, allocate the ipv6 structure for
5432         * loopback_dev first by hand.
5433         * Longer term, all of the dependencies ipv6 has upon the loopback
5434         * device and it being up should be removed.
5435         */
5436        rtnl_lock();
5437        idev = ipv6_add_dev(init_net.loopback_dev);
5438        rtnl_unlock();
5439        if (IS_ERR(idev)) {
5440                err = PTR_ERR(idev);
5441                goto errlo;
5442        }
5443
5444        for (i = 0; i < IN6_ADDR_HSIZE; i++)
5445                INIT_HLIST_HEAD(&inet6_addr_lst[i]);
5446
5447        register_netdevice_notifier(&ipv6_dev_notf);
5448
5449        addrconf_verify();
5450
5451        rtnl_af_register(&inet6_ops);
5452
5453        err = __rtnl_register(PF_INET6, RTM_GETLINK, NULL, inet6_dump_ifinfo,
5454                              NULL);
5455        if (err < 0)
5456                goto errout;
5457
5458        /* Only the first call to __rtnl_register can fail */
5459        __rtnl_register(PF_INET6, RTM_NEWADDR, inet6_rtm_newaddr, NULL, NULL);
5460        __rtnl_register(PF_INET6, RTM_DELADDR, inet6_rtm_deladdr, NULL, NULL);
5461        __rtnl_register(PF_INET6, RTM_GETADDR, inet6_rtm_getaddr,
5462                        inet6_dump_ifaddr, NULL);
5463        __rtnl_register(PF_INET6, RTM_GETMULTICAST, NULL,
5464                        inet6_dump_ifmcaddr, NULL);
5465        __rtnl_register(PF_INET6, RTM_GETANYCAST, NULL,
5466                        inet6_dump_ifacaddr, NULL);
5467        __rtnl_register(PF_INET6, RTM_GETNETCONF, inet6_netconf_get_devconf,
5468                        inet6_netconf_dump_devconf, NULL);
5469
5470        ipv6_addr_label_rtnl_register();
5471
5472        return 0;
5473errout:
5474        rtnl_af_unregister(&inet6_ops);
5475        unregister_netdevice_notifier(&ipv6_dev_notf);
5476errlo:
5477        destroy_workqueue(addrconf_wq);
5478out_nowq:
5479        unregister_pernet_subsys(&addrconf_ops);
5480out_addrlabel:
5481        ipv6_addr_label_cleanup();
5482out:
5483        return err;
5484}
5485
5486void addrconf_cleanup(void)
5487{
5488        struct net_device *dev;
5489        int i;
5490
5491        unregister_netdevice_notifier(&ipv6_dev_notf);
5492        unregister_pernet_subsys(&addrconf_ops);
5493        ipv6_addr_label_cleanup();
5494
5495        rtnl_lock();
5496
5497        __rtnl_af_unregister(&inet6_ops);
5498
5499        /* clean dev list */
5500        for_each_netdev(&init_net, dev) {
5501                if (__in6_dev_get(dev) == NULL)
5502                        continue;
5503                addrconf_ifdown(dev, 1);
5504        }
5505        addrconf_ifdown(init_net.loopback_dev, 2);
5506
5507        /*
5508         *      Check hash table.
5509         */
5510        spin_lock_bh(&addrconf_hash_lock);
5511        for (i = 0; i < IN6_ADDR_HSIZE; i++)
5512                WARN_ON(!hlist_empty(&inet6_addr_lst[i]));
5513        spin_unlock_bh(&addrconf_hash_lock);
5514        cancel_delayed_work(&addr_chk_work);
5515        rtnl_unlock();
5516
5517        destroy_workqueue(addrconf_wq);
5518}
Note: See TracBrowser for help on using the repository browser.