1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Based on net/ipv6/addrconf.c
4 * Authors:
5 * Pedro Roque <roque@di.fc.ul.pt>
6 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
7 *
8 * Changes:
9 *
10 * Janos Farkas : delete timer on ifdown
11 * <chexum@bankinf.banki.hu>
12 * Andi Kleen : kill double kfree on module
13 * unload.
14 * Maciej W. Rozycki : FDDI support
15 * sekiya@USAGI : Don't send too many RS
16 * packets.
17 * yoshfuji@USAGI : Fixed interval between DAD
18 * packets.
19 * YOSHIFUJI Hideaki @USAGI : improved accuracy of
20 * address validation timer.
21 * YOSHIFUJI Hideaki @USAGI : Privacy Extensions (RFC3041)
22 * support.
23 * Yuji SEKIYA @USAGI : Don't assign a same IPv6
24 * address on a same interface.
25 * YOSHIFUJI Hideaki @USAGI : ARCnet support
26 * YOSHIFUJI Hideaki @USAGI : convert /proc/net/if_inet6 to
27 * seq_file.
28 * YOSHIFUJI Hideaki @USAGI : improved source address
29 * selection; consider scope,
30 * status etc.
31 *
32 * NewIP Address [auto]configuration
33 * Linux NewIP INET implementation
34 */
35 #define pr_fmt(fmt) KBUILD_MODNAME ": [%s:%d] " fmt, __func__, __LINE__
36
37 #include <linux/errno.h>
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/socket.h>
41 #include <linux/sockios.h>
42 #include <linux/net.h>
43
44 #include <linux/netdevice.h>
45 #include <linux/route.h>
46 #include <linux/inetdevice.h>
47 #include <linux/init.h>
48 #include <linux/string.h>
49 #include <linux/hash.h>
50 #include <linux/proc_fs.h>
51
52 #include <net/net_namespace.h>
53 #include <net/sock.h>
54 #include <net/nip.h>
55 #include <net/protocol.h>
56 #include <net/ndisc.h>
57 #include <net/nip_route.h>
58 #include <net/nip_addrconf.h>
59 #include <net/tcp.h>
60 #include <net/ip.h>
61 #include <net/netlink.h>
62 #include <net/pkt_sched.h>
63 #include <net/addrconf.h>
64 #include <linux/rtnetlink.h>
65 #include <linux/export.h>
66
67 #include "nip_hdr.h"
68 #include "tcp_nip_parameter.h"
69
70 #define INFINITY_LIFE_TIME 0xFFFFFFFF
71
72 /* Configured unicast address hash table */
73 static struct hlist_head ninet_addr_lst[NIN_ADDR_HSIZE];
74 static DEFINE_SPINLOCK(addrconf_hash_lock);
75
76 static bool nip_chk_same_addr(struct net *net, const struct nip_addr *addr,
77 const struct net_device *dev);
78 static int nip_get_firstaddr(const struct net_device *dev,
79 struct nip_addr *addr);
80 static int nip_addrconf_ifdown(struct net_device *dev, bool unregister);
81
82 static struct nip_devconf newip_devconf_dflt __read_mostly = {
83 .forwarding = 0,
84 .mtu = NIP_MIN_MTU,
85 .disable_nip = 0,
86 .ignore_routes_with_linkdown = 0,
87 };
88
89 /* Check if link is ready: is it up and is a valid qdisc available */
nip_addrconf_link_ready(const struct net_device * dev)90 static inline bool nip_addrconf_link_ready(const struct net_device *dev)
91 {
92 return netif_oper_up(dev) && !qdisc_tx_is_noop(dev);
93 }
94
nip_link_dev_addr(struct ninet_dev * idev,struct ninet_ifaddr * ifp)95 static void nip_link_dev_addr(struct ninet_dev *idev, struct ninet_ifaddr *ifp)
96 {
97 list_add_tail(&ifp->if_list, &idev->addr_list);
98 }
99
ninet_addr_hash(const struct nip_addr * addr)100 static u32 ninet_addr_hash(const struct nip_addr *addr)
101 {
102 return hash_32(nip_addr_hash(addr), NIN_ADDR_HSIZE_SHIFT);
103 }
104
nip_add_addr(struct ninet_dev * idev,const struct nip_addr * addr,u32 flags,u32 valid_lft,u32 preferred_lft)105 static struct ninet_ifaddr *nip_add_addr(struct ninet_dev *idev,
106 const struct nip_addr *addr,
107 u32 flags, u32 valid_lft,
108 u32 preferred_lft)
109 {
110 struct ninet_ifaddr *ifa = NULL;
111 struct nip_rt_info *rt = NULL;
112 unsigned int hash;
113 int err = 0;
114
115 rcu_read_lock_bh();
116
117 nin_dev_hold(idev);
118
119 if (idev->dead) {
120 err = -ENODEV;
121 goto rcu_lock_out;
122 }
123
124 if (!netif_running(idev->dev)) {
125 nip_dbg("network interface is not running");
126 err = -ENODEV;
127 goto rcu_lock_out;
128 }
129
130 if (idev->cnf.disable_nip) {
131 err = -EACCES;
132 goto rcu_lock_out;
133 }
134
135 spin_lock(&addrconf_hash_lock);
136
137 /* Do not configure two same addresses in a netdevice */
138 if (nip_chk_same_addr(dev_net(idev->dev), addr, idev->dev)) {
139 nip_dbg("already assigned");
140 err = -EEXIST;
141 goto spin_lock_out;
142 }
143
144 ifa = kzalloc(sizeof(*ifa), GFP_ATOMIC);
145 if (!ifa) {
146 /* If you add log here, there will be an alarm:
147 * WARNING: Possible unnecessary 'out of memory' message
148 */
149 err = -ENOBUFS;
150 goto spin_lock_out;
151 }
152
153 rt = nip_addrconf_dst_alloc(idev, addr);
154 if (IS_ERR(rt)) {
155 err = PTR_ERR(rt);
156 goto spin_lock_out;
157 }
158
159 neigh_parms_data_state_setall(idev->nd_parms);
160
161 ifa->addr = *addr;
162
163 spin_lock_init(&ifa->lock);
164 INIT_HLIST_NODE(&ifa->addr_lst);
165 ifa->flags = flags;
166 ifa->valid_lft = valid_lft;
167 ifa->preferred_lft = preferred_lft;
168 ifa->tstamp = jiffies;
169 ifa->cstamp = ifa->tstamp;
170
171 ifa->rt = rt;
172
173 ifa->idev = idev;
174 refcount_set(&ifa->refcnt, 1);
175
176 /* Add to big hash table */
177 hash = ninet_addr_hash(addr);
178
179 hlist_add_head_rcu(&ifa->addr_lst, &ninet_addr_lst[hash]);
180 spin_unlock(&addrconf_hash_lock);
181
182 write_lock(&idev->lock);
183 /* Add to ninet_dev unicast addr list. */
184 nip_link_dev_addr(idev, ifa);
185
186 nin_ifa_hold(ifa);
187 write_unlock(&idev->lock);
188
189 rcu_lock_out:
190 rcu_read_unlock_bh();
191
192 if (likely(err == 0)) {
193 char add_addr[NIP_ADDR_BIT_LEN_MAX] = {0};
194
195 nip_addr_to_str(addr, add_addr, NIP_ADDR_BIT_LEN_MAX);
196 nip_dbg("success, %s ifindex=%u (addr=%s, idev->refcnt=%u, ifa->refcnt=%u)",
197 idev->dev->name, idev->dev->ifindex, add_addr,
198 refcount_read(&idev->refcnt), refcount_read(&ifa->refcnt));
199 } else {
200 kfree(ifa);
201 nin_dev_put(idev);
202 ifa = ERR_PTR(err);
203 }
204
205 return ifa;
206 spin_lock_out:
207 spin_unlock(&addrconf_hash_lock);
208 goto rcu_lock_out;
209 }
210
nip_add_dev(struct net_device * dev)211 static struct ninet_dev *nip_add_dev(struct net_device *dev)
212 {
213 struct ninet_dev *ndev;
214 int err = -ENOMEM;
215
216 ASSERT_RTNL();
217
218 if (dev->mtu < NIP_MIN_MTU)
219 return ERR_PTR(-EINVAL);
220
221 ndev = kzalloc(sizeof(*ndev), GFP_KERNEL);
222 if (!ndev)
223 return ERR_PTR(err);
224
225 rwlock_init(&ndev->lock);
226 ndev->dev = dev;
227 INIT_LIST_HEAD(&ndev->addr_list);
228 memcpy(&ndev->cnf, dev_net(dev)->newip.devconf_dflt, sizeof(ndev->cnf));
229
230 ndev->cnf.mtu = dev->mtu;
231 ndev->nd_parms = neigh_parms_alloc(dev, &nnd_tbl);
232 if (!ndev->nd_parms) {
233 kfree(ndev);
234 return ERR_PTR(err);
235 }
236
237 /* We refer to the device */
238 dev_hold(dev);
239
240 refcount_set(&ndev->refcnt, 1);
241
242 nip_dbg("init ninet_dev success, set ndev->refcnt=1");
243
244 if (netif_running(dev) && nip_addrconf_link_ready(dev))
245 ndev->if_flags |= IF_READY;
246
247 /* protected by rtnl_lock */
248 rcu_assign_pointer(dev->nip_ptr, ndev);
249 return ndev;
250 }
251
nip_find_idev(struct net_device * dev)252 static struct ninet_dev *nip_find_idev(struct net_device *dev)
253 {
254 struct ninet_dev *idev;
255
256 ASSERT_RTNL();
257
258 idev = __nin_dev_get(dev);
259 if (!idev) {
260 idev = nip_add_dev(dev);
261 if (IS_ERR(idev))
262 return NULL;
263 }
264 return idev;
265 }
266
nip_addrconf_add_dev(struct net_device * dev)267 static struct ninet_dev *nip_addrconf_add_dev(struct net_device *dev)
268 {
269 struct ninet_dev *idev;
270
271 ASSERT_RTNL();
272
273 idev = nip_find_idev(dev);
274 if (!idev)
275 return ERR_PTR(-ENOBUFS);
276
277 if (idev->cnf.disable_nip)
278 return ERR_PTR(-EACCES);
279
280 return idev;
281 }
282
283 /* Manual configuration of address on an interface */
ninet_addr_add(struct net * net,int ifindex,const struct nip_addr * pfx,__u32 ifa_flags,__u32 preferred_lft,__u32 valid_lft)284 static int ninet_addr_add(struct net *net, int ifindex,
285 const struct nip_addr *pfx,
286 __u32 ifa_flags, __u32 preferred_lft, __u32 valid_lft)
287 {
288 struct ninet_ifaddr *ifp;
289 struct ninet_dev *idev;
290 struct net_device *dev;
291 unsigned long timeout;
292 __u32 ifa_flags_tmp = ifa_flags;
293 __u32 valid_lft_tmp = valid_lft;
294
295 ASSERT_RTNL();
296
297 /* check the lifetime */
298 if (!valid_lft_tmp || preferred_lft > valid_lft_tmp)
299 return -EINVAL;
300
301 dev = __dev_get_by_index(net, ifindex);
302 if (!dev)
303 return -ENODEV;
304
305 idev = nip_addrconf_add_dev(dev);
306 if (IS_ERR(idev))
307 return PTR_ERR(idev);
308
309 timeout = addrconf_timeout_fixup(valid_lft_tmp, HZ);
310 if (addrconf_finite_timeout(timeout))
311 valid_lft_tmp = timeout;
312 else
313 ifa_flags_tmp |= IFA_F_PERMANENT;
314
315 timeout = addrconf_timeout_fixup(preferred_lft, HZ);
316 if (addrconf_finite_timeout(timeout)) {
317 if (timeout == 0)
318 ifa_flags_tmp |= IFA_F_DEPRECATED;
319 preferred_lft = timeout;
320 }
321
322 ifp = nip_add_addr(idev, pfx, ifa_flags_tmp,
323 valid_lft_tmp,
324 preferred_lft);
325 if (!IS_ERR(ifp)) {
326 nin_ifa_put(ifp);
327 nip_ins_rt(ifp->rt);
328 nip_dbg("success, ifp->refcnt=%u", refcount_read(&ifp->refcnt));
329 return 0;
330 }
331
332 return PTR_ERR(ifp);
333 }
334
335 /* Nobody refers to this ifaddr, destroy it */
ninet_ifa_finish_destroy(struct ninet_ifaddr * ifp)336 void ninet_ifa_finish_destroy(struct ninet_ifaddr *ifp)
337 {
338 WARN_ON(!hlist_unhashed(&ifp->addr_lst));
339
340 nip_dbg("before idev put. idev->refcnt=%u", refcount_read(&ifp->idev->refcnt));
341 nin_dev_put(ifp->idev);
342 nip_rt_put(ifp->rt);
343 kfree_rcu(ifp, rcu);
344 }
345
nip_del_addr(struct ninet_ifaddr * ifp)346 static void nip_del_addr(struct ninet_ifaddr *ifp)
347 {
348 int state;
349
350 ASSERT_RTNL();
351
352 spin_lock_bh(&ifp->lock);
353 state = ifp->state;
354 ifp->state = NINET_IFADDR_STATE_DEAD;
355 spin_unlock_bh(&ifp->lock);
356
357 if (state == NINET_IFADDR_STATE_DEAD)
358 goto out;
359
360 spin_lock_bh(&addrconf_hash_lock);
361 hlist_del_init_rcu(&ifp->addr_lst);
362 spin_unlock_bh(&addrconf_hash_lock);
363
364 write_lock_bh(&ifp->idev->lock);
365
366 list_del_init(&ifp->if_list);
367 __nin_ifa_put(ifp);
368
369 write_unlock_bh(&ifp->idev->lock);
370
371 if (ifp->rt) {
372 /* If the ifp - & gt; Rt does not belong to any NIP_FIB_node.
373 * The DST reference count does not change
374 */
375 if (dst_hold_safe(&ifp->rt->dst))
376 nip_del_rt(ifp->rt);
377 }
378
379 out:
380 nin_ifa_put(ifp);
381 }
382
ninet_addr_del(struct net * net,int ifindex,u32 ifa_flags,const struct nip_addr * pfx)383 static int ninet_addr_del(struct net *net, int ifindex, u32 ifa_flags,
384 const struct nip_addr *pfx)
385 {
386 struct ninet_ifaddr *ifp;
387 struct ninet_dev *idev;
388 struct net_device *dev;
389
390 dev = __dev_get_by_index(net, ifindex);
391 if (!dev)
392 return -ENODEV;
393
394 idev = __nin_dev_get(dev);
395 if (!idev)
396 return -ENXIO;
397
398 read_lock_bh(&idev->lock);
399 list_for_each_entry(ifp, &idev->addr_list, if_list) {
400 if (nip_addr_eq(pfx, &ifp->addr)) {
401 char addr[NIP_ADDR_BIT_LEN_MAX] = {0};
402
403 nin_ifa_hold(ifp);
404 read_unlock_bh(&idev->lock);
405
406 nip_addr_to_str(&ifp->addr, addr, NIP_ADDR_BIT_LEN_MAX);
407 nip_del_addr(ifp);
408 nip_dbg("success, %s ifindex=%u (addr=%s, ifp->refcnt=%u, idev->refcnt=%u)",
409 idev->dev->name, ifindex, addr, refcount_read(&ifp->refcnt),
410 refcount_read(&idev->refcnt));
411 return 0;
412 }
413 }
414 read_unlock_bh(&idev->lock);
415 return -EADDRNOTAVAIL;
416 }
417
nip_addrconf_ifaddr_check(struct net * net,void __user * arg,struct nip_ifreq * ireq)418 int nip_addrconf_ifaddr_check(struct net *net, void __user *arg, struct nip_ifreq *ireq)
419 {
420 if (copy_from_user(ireq, arg, sizeof(struct nip_ifreq))) {
421 nip_dbg("fail to copy cfg data");
422 return -EFAULT;
423 }
424
425 if (nip_addr_invalid(&ireq->ifrn_addr)) {
426 nip_dbg("nip addr invalid, bitlen=%u", ireq->ifrn_addr.bitlen);
427 return -EFAULT;
428 }
429
430 if (nip_addr_public(&ireq->ifrn_addr)) {
431 nip_dbg("The public address cannot be configured");
432 return -EFAULT;
433 }
434 return 0;
435 }
436
nip_addrconf_add_ifaddr(struct net * net,void __user * arg)437 int nip_addrconf_add_ifaddr(struct net *net, void __user *arg)
438 {
439 struct nip_ifreq ireq;
440 int err;
441
442 err = nip_addrconf_ifaddr_check(net, arg, &ireq);
443 if (err < 0) {
444 nip_dbg("The ifaddr check failed");
445 return err;
446 }
447
448 rtnl_lock();
449 err = ninet_addr_add(net, ireq.ifrn_ifindex, &ireq.ifrn_addr,
450 IFA_F_PERMANENT, INFINITY_LIFE_TIME,
451 INFINITY_LIFE_TIME);
452 rtnl_unlock();
453 return err;
454 }
455
nip_addrconf_del_ifaddr(struct net * net,void __user * arg)456 int nip_addrconf_del_ifaddr(struct net *net, void __user *arg)
457 {
458 struct nip_ifreq ireq;
459 int err;
460
461 err = nip_addrconf_ifaddr_check(net, arg, &ireq);
462 if (err < 0) {
463 nip_dbg("The ifaddr check failed");
464 return err;
465 }
466
467 rtnl_lock();
468 err = ninet_addr_del(net, ireq.ifrn_ifindex, 0, &ireq.ifrn_addr);
469 rtnl_unlock();
470 return err;
471 }
472
nip_chk_same_addr(struct net * net,const struct nip_addr * addr,const struct net_device * dev)473 static bool nip_chk_same_addr(struct net *net, const struct nip_addr *addr,
474 const struct net_device *dev)
475 {
476 unsigned int hash = ninet_addr_hash(addr);
477 struct ninet_ifaddr *ifp;
478
479 hlist_for_each_entry(ifp, &ninet_addr_lst[hash], addr_lst) {
480 if (!net_eq(dev_net(ifp->idev->dev), net))
481 continue;
482 if (nip_addr_eq(&ifp->addr, addr)) {
483 if (!dev || ifp->idev->dev == dev)
484 return true;
485 }
486 }
487 return false;
488 }
489
__nip_get_firstaddr(struct ninet_dev * idev,struct nip_addr * addr)490 static int __nip_get_firstaddr(struct ninet_dev *idev, struct nip_addr *addr)
491 {
492 struct ninet_ifaddr *ifp;
493 int err = -EADDRNOTAVAIL;
494
495 list_for_each_entry(ifp, &idev->addr_list, if_list) {
496 *addr = ifp->addr;
497 err = 0;
498 break;
499 }
500 return err;
501 }
502
nip_get_firstaddr(const struct net_device * dev,struct nip_addr * addr)503 static int nip_get_firstaddr(const struct net_device *dev,
504 struct nip_addr *addr)
505 {
506 struct ninet_dev *idev;
507 int err = -EADDRNOTAVAIL;
508
509 rcu_read_lock();
510 idev = __nin_dev_get(dev);
511 if (idev) {
512 read_lock_bh(&idev->lock);
513 err = __nip_get_firstaddr(idev, addr);
514 read_unlock_bh(&idev->lock);
515 }
516 rcu_read_unlock();
517 return err;
518 }
519
nip_dev_get_saddr(struct net * net,const struct net_device * dev,const struct nip_addr * daddr,struct nip_addr * saddr)520 int nip_dev_get_saddr(struct net *net, const struct net_device *dev,
521 const struct nip_addr *daddr, struct nip_addr *saddr)
522 {
523 if (!dev || !saddr)
524 return -EADDRNOTAVAIL;
525
526 return nip_get_firstaddr(dev, saddr);
527 }
528
nip_addrconf_notify(struct notifier_block * this,unsigned long event,void * ptr)529 static int nip_addrconf_notify(struct notifier_block *this, unsigned long event,
530 void *ptr)
531 {
532 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
533 struct ninet_dev *idev = __nin_dev_get(dev);
534 struct net *net = dev_net(dev);
535
536 switch (event) {
537 case NETDEV_REGISTER:
538 if (!idev && dev->mtu >= NIP_MIN_MTU) {
539 nip_dbg("NIP_ADDRCONF(NETDEV_REGISTER): ");
540 idev = nip_add_dev(dev);
541 if (IS_ERR(idev))
542 return notifier_from_errno(PTR_ERR(idev));
543 }
544 break;
545
546 case NETDEV_CHANGEMTU:
547 /* if MTU under NIP_MIN_MTU stop New IP on this interface. */
548 if (dev->mtu < NIP_MIN_MTU) {
549 nip_addrconf_ifdown(dev, dev != net->loopback_dev);
550 break;
551 }
552
553 if (idev) {
554 idev->cnf.mtu = dev->mtu;
555 break;
556 }
557
558 /* allocate new idev */
559 idev = nip_add_dev(dev);
560 if (IS_ERR_OR_NULL(idev))
561 break;
562
563 /* device is still not ready */
564 if (!(idev->if_flags & IF_READY))
565 break;
566
567 fallthrough;
568 case NETDEV_UP:
569 case NETDEV_CHANGE:
570 if (dev->flags & IFF_SLAVE)
571 break;
572
573 if (idev && idev->cnf.disable_nip)
574 break;
575
576 if (event == NETDEV_UP) {
577 if (!nip_addrconf_link_ready(dev)) {
578 /* device is not ready yet. */
579 nip_dbg("NIP_ADDRCONF(NETDEV_UP)");
580 nip_dbg("%s:link is not ready", dev->name);
581 break;
582 }
583
584 if (!idev && dev->mtu >= NIP_MIN_MTU)
585 idev = nip_add_dev(dev);
586
587 if (!IS_ERR_OR_NULL(idev))
588 idev->if_flags |= IF_READY;
589 } else if (event == NETDEV_CHANGE) {
590 if (!nip_addrconf_link_ready(dev))
591 /* device is still not ready. */
592 break;
593
594 if (idev)
595 idev->if_flags |= IF_READY;
596
597 nip_dbg("NIP_ADDRCONF(NETDEV_CHANGE)");
598 nip_dbg("%s:link becomes ready", dev->name);
599 }
600
601 if (!IS_ERR_OR_NULL(idev)) {
602 /* If the MTU changed during the interface down,
603 * when the interface up, the changed MTU must be
604 * reflected in the idev as well as routers.
605 */
606 if (idev->cnf.mtu != dev->mtu && dev->mtu >= NIP_MIN_MTU)
607 idev->cnf.mtu = dev->mtu;
608 idev->tstamp = jiffies;
609
610 /* If the changed mtu during down is lower than
611 * NIP_MIN_MTU stop New IP on this interface.
612 */
613 if (dev->mtu < NIP_MIN_MTU)
614 nip_addrconf_ifdown(dev, dev != net->loopback_dev);
615 }
616 break;
617
618 case NETDEV_DOWN:
619 case NETDEV_UNREGISTER:
620 /* Remove all addresses from this interface. */
621 nip_addrconf_ifdown(dev, event != NETDEV_DOWN);
622 break;
623 default:
624 break;
625 }
626
627 return NOTIFY_OK;
628 }
629
nip_addrconf_ifdown(struct net_device * dev,bool unregister)630 static int nip_addrconf_ifdown(struct net_device *dev, bool unregister)
631 {
632 struct net *net = dev_net(dev);
633 struct ninet_dev *idev = __nin_dev_get(dev);
634 struct ninet_ifaddr *ifa, *tmp;
635 struct list_head del_list;
636 int i;
637
638 ASSERT_RTNL();
639
640 nip_dbg("%s ifindex=%u, unregister=%u (unregister:1, down:0)",
641 dev->name, dev->ifindex, unregister);
642
643 nip_rt_ifdown(net, dev);
644 neigh_ifdown(&nnd_tbl, dev);
645 if (!idev)
646 return -ENODEV;
647
648 /* Step 1: remove reference to newip device from parent device.
649 * Do not dev_put!
650 */
651 if (unregister) {
652 idev->dead = 1;
653
654 /* protected by rtnl_lock */
655 RCU_INIT_POINTER(dev->nip_ptr, NULL);
656 }
657
658 /* Step 2: clear hash table */
659 for (i = 0; i < NIN_ADDR_HSIZE; i++) {
660 struct hlist_head *h = &ninet_addr_lst[i];
661
662 spin_lock_bh(&addrconf_hash_lock);
663 hlist_for_each_entry_rcu(ifa, h, addr_lst) {
664 if (ifa->idev == idev) {
665 char addr[NIP_ADDR_BIT_LEN_MAX] = {0};
666
667 nip_addr_to_str(&ifa->addr, addr, NIP_ADDR_BIT_LEN_MAX);
668 nip_dbg("clear addr hash table.(addr=%s)", addr);
669 hlist_del_init_rcu(&ifa->addr_lst);
670 }
671 }
672 spin_unlock_bh(&addrconf_hash_lock);
673 }
674
675 write_lock_bh(&idev->lock);
676
677 /* Step 2: clear flags for stateless addrconf */
678 if (!unregister)
679 idev->if_flags &= ~(IF_RS_SENT | IF_RA_RCVD | IF_READY);
680
681 /* Step 3: Remove address node from ifa->if_list
682 * and insert it into the list to be del_list
683 */
684 INIT_LIST_HEAD(&del_list);
685 list_for_each_entry_safe(ifa, tmp, &idev->addr_list, if_list) {
686 list_move(&ifa->if_list, &del_list);
687
688 write_unlock_bh(&idev->lock);
689 spin_lock_bh(&ifa->lock);
690 ifa->state = NINET_IFADDR_STATE_DEAD;
691 spin_unlock_bh(&ifa->lock);
692 write_lock_bh(&idev->lock);
693 }
694 write_unlock_bh(&idev->lock);
695
696 /* Step 4: Unchain the node to be deleted and release IFA */
697 while (!list_empty(&del_list)) {
698 ifa = list_first_entry(&del_list, struct ninet_ifaddr, if_list);
699 list_del(&ifa->if_list);
700 nin_ifa_put(ifa);
701 }
702
703 /* Last: Shot the device (if unregistered) */
704 if (unregister) {
705 neigh_parms_release(&nnd_tbl, idev->nd_parms);
706 neigh_ifdown(&nnd_tbl, dev);
707 nip_dbg("%s (ifindex=%u) before idev put. idev->refcnt=%u",
708 dev->name, dev->ifindex, refcount_read(&idev->refcnt));
709 nin_dev_put(idev);
710 }
711 return 0;
712 }
713
nip_addr_proc_show(struct seq_file * seq,void * v)714 static int nip_addr_proc_show(struct seq_file *seq, void *v)
715 {
716 struct net *net = seq->private;
717 struct ninet_ifaddr *ifp;
718 int i, j;
719
720 rcu_read_lock();
721 for (i = 0; i < NIN_ADDR_HSIZE; i++)
722 hlist_for_each_entry_rcu(ifp, &ninet_addr_lst[i], addr_lst) {
723 if (!net_eq(dev_net(ifp->idev->dev), net))
724 continue;
725
726 for (j = 0; j < ifp->addr.bitlen / NIP_ADDR_BIT_LEN_8; j++)
727 seq_printf(seq, "%02x", ifp->addr.NIP_ADDR_FIELD8[j]);
728 seq_printf(seq, "\t%8s\n", ifp->idev->dev ? ifp->idev->dev->name : "");
729 }
730
731 rcu_read_unlock();
732 return 0;
733 }
734
nip_addr_net_init(struct net * net)735 static int __net_init nip_addr_net_init(struct net *net)
736 {
737 int err = -ENOMEM;
738 struct nip_devconf *dflt;
739
740 dflt = kmemdup(&newip_devconf_dflt,
741 sizeof(newip_devconf_dflt),
742 GFP_KERNEL);
743 if (!dflt)
744 goto err_alloc_dflt;
745
746 net->newip.devconf_dflt = dflt;
747
748 if (!proc_create_net_single("nip_addr", 0444, net->proc_net,
749 nip_addr_proc_show, NULL)) {
750 goto err_addr_proc;
751 }
752
753 return 0;
754
755 err_addr_proc:
756 kfree(dflt);
757 err_alloc_dflt:
758 return err;
759 }
760
nip_addr_net_exit(struct net * net)761 static void __net_exit nip_addr_net_exit(struct net *net)
762 {
763 kfree(net->newip.devconf_dflt);
764 remove_proc_entry("nip_addr", net->proc_net);
765 }
766
767 static struct pernet_operations nip_route_proc_net_ops = {
768 .init = nip_addr_net_init,
769 .exit = nip_addr_net_exit,
770 };
771
772 /* addrconf module should be notified of a device going up
773 */
774 static struct notifier_block nip_dev_notf = {
775 .notifier_call = nip_addrconf_notify,
776 .priority = ADDRCONF_NOTIFY_PRIORITY,
777 };
778
nip_addrconf_init(void)779 int __init nip_addrconf_init(void)
780 {
781 int err;
782
783 err = register_pernet_subsys(&nip_route_proc_net_ops);
784 if (err < 0) {
785 nip_dbg("register_pernet_subsys failed");
786 goto out;
787 }
788
789 register_netdevice_notifier(&nip_dev_notf);
790
791 out:
792 return err;
793 }
794
nip_addrconf_cleanup(void)795 void nip_addrconf_cleanup(void)
796 {
797 struct net_device *dev;
798 int i;
799
800 unregister_netdevice_notifier(&nip_dev_notf);
801 unregister_pernet_subsys(&nip_route_proc_net_ops);
802
803 rtnl_lock();
804
805 /* clean dev list */
806 for_each_netdev(&init_net, dev) {
807 if (!__nin_dev_get(dev))
808 continue;
809 nip_addrconf_ifdown(dev, 1);
810 }
811
812 /* Check hash table. */
813 spin_lock_bh(&addrconf_hash_lock);
814 for (i = 0; i < NIN_ADDR_HSIZE; i++)
815 WARN_ON(!hlist_empty(&ninet_addr_lst[i]));
816 spin_unlock_bh(&addrconf_hash_lock);
817 rtnl_unlock();
818 }
819
ninet_addr_get(const struct net_device * dev,struct ninet_ifaddr * ifa)820 static int ninet_addr_get(const struct net_device *dev, struct ninet_ifaddr *ifa)
821 {
822 int err;
823 struct nip_addr addr;
824
825 err = nip_get_firstaddr(dev, &addr);
826 if (!err)
827 ifa->addr = addr;
828
829 return err;
830 }
831
nip_addrconf_get_ifaddr(struct net * net,unsigned int cmd,void __user * arg)832 int nip_addrconf_get_ifaddr(struct net *net, unsigned int cmd, void __user *arg)
833 {
834 struct nip_devreq ifr;
835 struct sockaddr_nin *snin;
836 struct ninet_ifaddr ifa;
837 struct net_device *dev;
838 void __user *p = (void __user *)arg;
839 int ret = -EFAULT;
840
841 if (copy_from_user(&ifr, p, sizeof(struct nip_ifreq)))
842 goto out;
843
844 ifr.nip_ifr_name[IFNAMSIZ - 1] = 0;
845 snin = (struct sockaddr_nin *)&ifr.NIP_DEV_ADDR;
846
847 nip_dbg("dev name is %s", ifr.nip_ifr_name);
848 dev_load(net, ifr.nip_ifr_name);
849
850 if (cmd == SIOCGIFADDR) {
851 memset(snin, 0, sizeof(*snin));
852 snin->sin_family = AF_NINET;
853 } else {
854 goto out;
855 }
856
857 rtnl_lock();
858
859 dev = __dev_get_by_name(net, ifr.nip_ifr_name);
860 if (!dev)
861 goto done;
862
863 ret = ninet_addr_get(dev, &ifa);
864 if (ret)
865 goto done;
866 /* Get interface address */
867 snin->sin_addr = ifa.addr;
868
869 if (copy_to_user(p, &ifr, sizeof(struct nip_devreq)))
870 ret = -EFAULT;
871
872 done:
873 rtnl_unlock();
874 out:
875 return ret;
876 }
877
nip_addr_to_str(const struct nip_addr * addr,unsigned char * buf,int buf_len)878 void nip_addr_to_str(const struct nip_addr *addr, unsigned char *buf, int buf_len)
879 {
880 int i;
881 int total_len = 0;
882 int addr_num = addr->bitlen / NIP_ADDR_BIT_LEN_8;
883
884 if (!buf)
885 return;
886
887 total_len = sprintf(buf, "%s", "0x");
888 for (i = 0; (i < addr_num) && (total_len < buf_len); i++) {
889 int len = sprintf(buf + total_len, "%02x", addr->NIP_ADDR_FIELD8[i]);
890
891 if (len <= 0)
892 break;
893 total_len += len;
894 }
895
896 switch (addr_num) {
897 case NIP_ADDR_LEN_1:
898 buf[INDEX_2] = '*'; /* 0x*0 ~ 0x*C */
899 break;
900 case NIP_ADDR_LEN_2:
901 buf[INDEX_2] = '*'; /* 0x**DD ~ 0x**FF */
902 buf[INDEX_3] = '*';
903 break;
904 case NIP_ADDR_LEN_3:
905 buf[INDEX_4] = '*'; /* 0xF1**00 ~ 0xF1**FF */
906 buf[INDEX_5] = '*';
907 break;
908 case NIP_ADDR_LEN_5:
909 buf[INDEX_4] = '*'; /* 0xF2 **** 0000 ~ 0xF2 **** FFFF */
910 buf[INDEX_5] = '*';
911 buf[INDEX_6] = '*';
912 buf[INDEX_7] = '*';
913 break;
914 case NIP_ADDR_LEN_7:
915 buf[INDEX_4] = '*'; /* 0xF3 **** 0000 0000 ~ 0xF3 **** FFFF FFFF */
916 buf[INDEX_5] = '*';
917 buf[INDEX_6] = '*';
918 buf[INDEX_7] = '*';
919 break;
920 case NIP_ADDR_LEN_8:
921 buf[INDEX_4] = '*'; /* 0xF4** **** 0000 0000 ~ 0xF4** **** FFFF FFFF */
922 buf[INDEX_5] = '*';
923 buf[INDEX_6] = '*';
924 buf[INDEX_7] = '*';
925 buf[INDEX_8] = '*';
926 buf[INDEX_9] = '*';
927 break;
928 default:
929 break;
930 }
931 }
932
933