GNU Linux-libre 4.19.211-gnu1
[releases.git] / net / decnet / dn_dev.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * DECnet       An implementation of the DECnet protocol suite for the LINUX
4  *              operating system.  DECnet is implemented using the  BSD Socket
5  *              interface as the means of communication with the user level.
6  *
7  *              DECnet Device Layer
8  *
9  * Authors:     Steve Whitehouse <SteveW@ACM.org>
10  *              Eduardo Marcelo Serrat <emserrat@geocities.com>
11  *
12  * Changes:
13  *          Steve Whitehouse : Devices now see incoming frames so they
14  *                             can mark on who it came from.
15  *          Steve Whitehouse : Fixed bug in creating neighbours. Each neighbour
16  *                             can now have a device specific setup func.
17  *          Steve Whitehouse : Added /proc/sys/net/decnet/conf/<dev>/
18  *          Steve Whitehouse : Fixed bug which sometimes killed timer
19  *          Steve Whitehouse : Multiple ifaddr support
20  *          Steve Whitehouse : SIOCGIFCONF is now a compile time option
21  *          Steve Whitehouse : /proc/sys/net/decnet/conf/<sys>/forwarding
22  *          Steve Whitehouse : Removed timer1 - it's a user space issue now
23  *         Patrick Caulfield : Fixed router hello message format
24  *          Steve Whitehouse : Got rid of constant sizes for blksize for
25  *                             devices. All mtu based now.
26  */
27
28 #include <linux/capability.h>
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
31 #include <linux/init.h>
32 #include <linux/net.h>
33 #include <linux/netdevice.h>
34 #include <linux/proc_fs.h>
35 #include <linux/seq_file.h>
36 #include <linux/timer.h>
37 #include <linux/string.h>
38 #include <linux/if_addr.h>
39 #include <linux/if_arp.h>
40 #include <linux/if_ether.h>
41 #include <linux/skbuff.h>
42 #include <linux/sysctl.h>
43 #include <linux/notifier.h>
44 #include <linux/slab.h>
45 #include <linux/jiffies.h>
46 #include <linux/uaccess.h>
47 #include <net/net_namespace.h>
48 #include <net/neighbour.h>
49 #include <net/dst.h>
50 #include <net/flow.h>
51 #include <net/fib_rules.h>
52 #include <net/netlink.h>
53 #include <net/dn.h>
54 #include <net/dn_dev.h>
55 #include <net/dn_route.h>
56 #include <net/dn_neigh.h>
57 #include <net/dn_fib.h>
58
59 #define DN_IFREQ_SIZE (offsetof(struct ifreq, ifr_ifru) + sizeof(struct sockaddr_dn))
60
61 static char dn_rt_all_end_mcast[ETH_ALEN] = {0xAB,0x00,0x00,0x04,0x00,0x00};
62 static char dn_rt_all_rt_mcast[ETH_ALEN]  = {0xAB,0x00,0x00,0x03,0x00,0x00};
63 static char dn_hiord[ETH_ALEN]            = {0xAA,0x00,0x04,0x00,0x00,0x00};
64 static unsigned char dn_eco_version[3]    = {0x02,0x00,0x00};
65
66 extern struct neigh_table dn_neigh_table;
67
68 /*
69  * decnet_address is kept in network order.
70  */
71 __le16 decnet_address = 0;
72
73 static DEFINE_SPINLOCK(dndev_lock);
74 static struct net_device *decnet_default_device;
75 static BLOCKING_NOTIFIER_HEAD(dnaddr_chain);
76
77 static struct dn_dev *dn_dev_create(struct net_device *dev, int *err);
78 static void dn_dev_delete(struct net_device *dev);
79 static void dn_ifaddr_notify(int event, struct dn_ifaddr *ifa);
80
81 static int dn_eth_up(struct net_device *);
82 static void dn_eth_down(struct net_device *);
83 static void dn_send_brd_hello(struct net_device *dev, struct dn_ifaddr *ifa);
84 static void dn_send_ptp_hello(struct net_device *dev, struct dn_ifaddr *ifa);
85
86 static struct dn_dev_parms dn_dev_list[] =  {
87 {
88         .type =         ARPHRD_ETHER, /* Ethernet */
89         .mode =         DN_DEV_BCAST,
90         .state =        DN_DEV_S_RU,
91         .t2 =           1,
92         .t3 =           10,
93         .name =         "ethernet",
94         .up =           dn_eth_up,
95         .down =         dn_eth_down,
96         .timer3 =       dn_send_brd_hello,
97 },
98 {
99         .type =         ARPHRD_IPGRE, /* DECnet tunneled over GRE in IP */
100         .mode =         DN_DEV_BCAST,
101         .state =        DN_DEV_S_RU,
102         .t2 =           1,
103         .t3 =           10,
104         .name =         "ipgre",
105         .timer3 =       dn_send_brd_hello,
106 },
107 #if 0
108 {
109         .type =         ARPHRD_X25, /* Bog standard X.25 */
110         .mode =         DN_DEV_UCAST,
111         .state =        DN_DEV_S_DS,
112         .t2 =           1,
113         .t3 =           120,
114         .name =         "x25",
115         .timer3 =       dn_send_ptp_hello,
116 },
117 #endif
118 #if 0
119 {
120         .type =         ARPHRD_PPP, /* DECnet over PPP */
121         .mode =         DN_DEV_BCAST,
122         .state =        DN_DEV_S_RU,
123         .t2 =           1,
124         .t3 =           10,
125         .name =         "ppp",
126         .timer3 =       dn_send_brd_hello,
127 },
128 #endif
129 {
130         .type =         ARPHRD_DDCMP, /* DECnet over DDCMP */
131         .mode =         DN_DEV_UCAST,
132         .state =        DN_DEV_S_DS,
133         .t2 =           1,
134         .t3 =           120,
135         .name =         "ddcmp",
136         .timer3 =       dn_send_ptp_hello,
137 },
138 {
139         .type =         ARPHRD_LOOPBACK, /* Loopback interface - always last */
140         .mode =         DN_DEV_BCAST,
141         .state =        DN_DEV_S_RU,
142         .t2 =           1,
143         .t3 =           10,
144         .name =         "loopback",
145         .timer3 =       dn_send_brd_hello,
146 }
147 };
148
149 #define DN_DEV_LIST_SIZE ARRAY_SIZE(dn_dev_list)
150
151 #define DN_DEV_PARMS_OFFSET(x) offsetof(struct dn_dev_parms, x)
152
153 #ifdef CONFIG_SYSCTL
154
155 static int min_t2[] = { 1 };
156 static int max_t2[] = { 60 }; /* No max specified, but this seems sensible */
157 static int min_t3[] = { 1 };
158 static int max_t3[] = { 8191 }; /* Must fit in 16 bits when multiplied by BCT3MULT or T3MULT */
159
160 static int min_priority[1];
161 static int max_priority[] = { 127 }; /* From DECnet spec */
162
163 static int dn_forwarding_proc(struct ctl_table *, int,
164                         void __user *, size_t *, loff_t *);
165 static struct dn_dev_sysctl_table {
166         struct ctl_table_header *sysctl_header;
167         struct ctl_table dn_dev_vars[5];
168 } dn_dev_sysctl = {
169         NULL,
170         {
171         {
172                 .procname = "forwarding",
173                 .data = (void *)DN_DEV_PARMS_OFFSET(forwarding),
174                 .maxlen = sizeof(int),
175                 .mode = 0644,
176                 .proc_handler = dn_forwarding_proc,
177         },
178         {
179                 .procname = "priority",
180                 .data = (void *)DN_DEV_PARMS_OFFSET(priority),
181                 .maxlen = sizeof(int),
182                 .mode = 0644,
183                 .proc_handler = proc_dointvec_minmax,
184                 .extra1 = &min_priority,
185                 .extra2 = &max_priority
186         },
187         {
188                 .procname = "t2",
189                 .data = (void *)DN_DEV_PARMS_OFFSET(t2),
190                 .maxlen = sizeof(int),
191                 .mode = 0644,
192                 .proc_handler = proc_dointvec_minmax,
193                 .extra1 = &min_t2,
194                 .extra2 = &max_t2
195         },
196         {
197                 .procname = "t3",
198                 .data = (void *)DN_DEV_PARMS_OFFSET(t3),
199                 .maxlen = sizeof(int),
200                 .mode = 0644,
201                 .proc_handler = proc_dointvec_minmax,
202                 .extra1 = &min_t3,
203                 .extra2 = &max_t3
204         },
205         { }
206         },
207 };
208
209 static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *parms)
210 {
211         struct dn_dev_sysctl_table *t;
212         int i;
213
214         char path[sizeof("net/decnet/conf/") + IFNAMSIZ];
215
216         t = kmemdup(&dn_dev_sysctl, sizeof(*t), GFP_KERNEL);
217         if (t == NULL)
218                 return;
219
220         for(i = 0; i < ARRAY_SIZE(t->dn_dev_vars) - 1; i++) {
221                 long offset = (long)t->dn_dev_vars[i].data;
222                 t->dn_dev_vars[i].data = ((char *)parms) + offset;
223         }
224
225         snprintf(path, sizeof(path), "net/decnet/conf/%s",
226                 dev? dev->name : parms->name);
227
228         t->dn_dev_vars[0].extra1 = (void *)dev;
229
230         t->sysctl_header = register_net_sysctl(&init_net, path, t->dn_dev_vars);
231         if (t->sysctl_header == NULL)
232                 kfree(t);
233         else
234                 parms->sysctl = t;
235 }
236
237 static void dn_dev_sysctl_unregister(struct dn_dev_parms *parms)
238 {
239         if (parms->sysctl) {
240                 struct dn_dev_sysctl_table *t = parms->sysctl;
241                 parms->sysctl = NULL;
242                 unregister_net_sysctl_table(t->sysctl_header);
243                 kfree(t);
244         }
245 }
246
247 static int dn_forwarding_proc(struct ctl_table *table, int write,
248                                 void __user *buffer,
249                                 size_t *lenp, loff_t *ppos)
250 {
251 #ifdef CONFIG_DECNET_ROUTER
252         struct net_device *dev = table->extra1;
253         struct dn_dev *dn_db;
254         int err;
255         int tmp, old;
256
257         if (table->extra1 == NULL)
258                 return -EINVAL;
259
260         dn_db = rcu_dereference_raw(dev->dn_ptr);
261         old = dn_db->parms.forwarding;
262
263         err = proc_dointvec(table, write, buffer, lenp, ppos);
264
265         if ((err >= 0) && write) {
266                 if (dn_db->parms.forwarding < 0)
267                         dn_db->parms.forwarding = 0;
268                 if (dn_db->parms.forwarding > 2)
269                         dn_db->parms.forwarding = 2;
270                 /*
271                  * What an ugly hack this is... its works, just. It
272                  * would be nice if sysctl/proc were just that little
273                  * bit more flexible so I don't have to write a special
274                  * routine, or suffer hacks like this - SJW
275                  */
276                 tmp = dn_db->parms.forwarding;
277                 dn_db->parms.forwarding = old;
278                 if (dn_db->parms.down)
279                         dn_db->parms.down(dev);
280                 dn_db->parms.forwarding = tmp;
281                 if (dn_db->parms.up)
282                         dn_db->parms.up(dev);
283         }
284
285         return err;
286 #else
287         return -EINVAL;
288 #endif
289 }
290
291 #else /* CONFIG_SYSCTL */
292 static void dn_dev_sysctl_unregister(struct dn_dev_parms *parms)
293 {
294 }
295 static void dn_dev_sysctl_register(struct net_device *dev, struct dn_dev_parms *parms)
296 {
297 }
298
299 #endif /* CONFIG_SYSCTL */
300
301 static inline __u16 mtu2blksize(struct net_device *dev)
302 {
303         u32 blksize = dev->mtu;
304         if (blksize > 0xffff)
305                 blksize = 0xffff;
306
307         if (dev->type == ARPHRD_ETHER ||
308             dev->type == ARPHRD_PPP ||
309             dev->type == ARPHRD_IPGRE ||
310             dev->type == ARPHRD_LOOPBACK)
311                 blksize -= 2;
312
313         return (__u16)blksize;
314 }
315
316 static struct dn_ifaddr *dn_dev_alloc_ifa(void)
317 {
318         struct dn_ifaddr *ifa;
319
320         ifa = kzalloc(sizeof(*ifa), GFP_KERNEL);
321
322         return ifa;
323 }
324
325 static void dn_dev_free_ifa(struct dn_ifaddr *ifa)
326 {
327         kfree_rcu(ifa, rcu);
328 }
329
330 static void dn_dev_del_ifa(struct dn_dev *dn_db, struct dn_ifaddr __rcu **ifap, int destroy)
331 {
332         struct dn_ifaddr *ifa1 = rtnl_dereference(*ifap);
333         unsigned char mac_addr[6];
334         struct net_device *dev = dn_db->dev;
335
336         ASSERT_RTNL();
337
338         *ifap = ifa1->ifa_next;
339
340         if (dn_db->dev->type == ARPHRD_ETHER) {
341                 if (ifa1->ifa_local != dn_eth2dn(dev->dev_addr)) {
342                         dn_dn2eth(mac_addr, ifa1->ifa_local);
343                         dev_mc_del(dev, mac_addr);
344                 }
345         }
346
347         dn_ifaddr_notify(RTM_DELADDR, ifa1);
348         blocking_notifier_call_chain(&dnaddr_chain, NETDEV_DOWN, ifa1);
349         if (destroy) {
350                 dn_dev_free_ifa(ifa1);
351
352                 if (dn_db->ifa_list == NULL)
353                         dn_dev_delete(dn_db->dev);
354         }
355 }
356
357 static int dn_dev_insert_ifa(struct dn_dev *dn_db, struct dn_ifaddr *ifa)
358 {
359         struct net_device *dev = dn_db->dev;
360         struct dn_ifaddr *ifa1;
361         unsigned char mac_addr[6];
362
363         ASSERT_RTNL();
364
365         /* Check for duplicates */
366         for (ifa1 = rtnl_dereference(dn_db->ifa_list);
367              ifa1 != NULL;
368              ifa1 = rtnl_dereference(ifa1->ifa_next)) {
369                 if (ifa1->ifa_local == ifa->ifa_local)
370                         return -EEXIST;
371         }
372
373         if (dev->type == ARPHRD_ETHER) {
374                 if (ifa->ifa_local != dn_eth2dn(dev->dev_addr)) {
375                         dn_dn2eth(mac_addr, ifa->ifa_local);
376                         dev_mc_add(dev, mac_addr);
377                 }
378         }
379
380         ifa->ifa_next = dn_db->ifa_list;
381         rcu_assign_pointer(dn_db->ifa_list, ifa);
382
383         dn_ifaddr_notify(RTM_NEWADDR, ifa);
384         blocking_notifier_call_chain(&dnaddr_chain, NETDEV_UP, ifa);
385
386         return 0;
387 }
388
389 static int dn_dev_set_ifa(struct net_device *dev, struct dn_ifaddr *ifa)
390 {
391         struct dn_dev *dn_db = rtnl_dereference(dev->dn_ptr);
392         int rv;
393
394         if (dn_db == NULL) {
395                 int err;
396                 dn_db = dn_dev_create(dev, &err);
397                 if (dn_db == NULL)
398                         return err;
399         }
400
401         ifa->ifa_dev = dn_db;
402
403         if (dev->flags & IFF_LOOPBACK)
404                 ifa->ifa_scope = RT_SCOPE_HOST;
405
406         rv = dn_dev_insert_ifa(dn_db, ifa);
407         if (rv)
408                 dn_dev_free_ifa(ifa);
409         return rv;
410 }
411
412
413 int dn_dev_ioctl(unsigned int cmd, void __user *arg)
414 {
415         char buffer[DN_IFREQ_SIZE];
416         struct ifreq *ifr = (struct ifreq *)buffer;
417         struct sockaddr_dn *sdn = (struct sockaddr_dn *)&ifr->ifr_addr;
418         struct dn_dev *dn_db;
419         struct net_device *dev;
420         struct dn_ifaddr *ifa = NULL;
421         struct dn_ifaddr __rcu **ifap = NULL;
422         int ret = 0;
423
424         if (copy_from_user(ifr, arg, DN_IFREQ_SIZE))
425                 return -EFAULT;
426         ifr->ifr_name[IFNAMSIZ-1] = 0;
427
428         dev_load(&init_net, ifr->ifr_name);
429
430         switch (cmd) {
431         case SIOCGIFADDR:
432                 break;
433         case SIOCSIFADDR:
434                 if (!capable(CAP_NET_ADMIN))
435                         return -EACCES;
436                 if (sdn->sdn_family != AF_DECnet)
437                         return -EINVAL;
438                 break;
439         default:
440                 return -EINVAL;
441         }
442
443         rtnl_lock();
444
445         if ((dev = __dev_get_by_name(&init_net, ifr->ifr_name)) == NULL) {
446                 ret = -ENODEV;
447                 goto done;
448         }
449
450         if ((dn_db = rtnl_dereference(dev->dn_ptr)) != NULL) {
451                 for (ifap = &dn_db->ifa_list;
452                      (ifa = rtnl_dereference(*ifap)) != NULL;
453                      ifap = &ifa->ifa_next)
454                         if (strcmp(ifr->ifr_name, ifa->ifa_label) == 0)
455                                 break;
456         }
457
458         if (ifa == NULL && cmd != SIOCSIFADDR) {
459                 ret = -EADDRNOTAVAIL;
460                 goto done;
461         }
462
463         switch (cmd) {
464         case SIOCGIFADDR:
465                 *((__le16 *)sdn->sdn_nodeaddr) = ifa->ifa_local;
466                 goto rarok;
467
468         case SIOCSIFADDR:
469                 if (!ifa) {
470                         if ((ifa = dn_dev_alloc_ifa()) == NULL) {
471                                 ret = -ENOBUFS;
472                                 break;
473                         }
474                         memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
475                 } else {
476                         if (ifa->ifa_local == dn_saddr2dn(sdn))
477                                 break;
478                         dn_dev_del_ifa(dn_db, ifap, 0);
479                 }
480
481                 ifa->ifa_local = ifa->ifa_address = dn_saddr2dn(sdn);
482
483                 ret = dn_dev_set_ifa(dev, ifa);
484         }
485 done:
486         rtnl_unlock();
487
488         return ret;
489 rarok:
490         if (copy_to_user(arg, ifr, DN_IFREQ_SIZE))
491                 ret = -EFAULT;
492         goto done;
493 }
494
495 struct net_device *dn_dev_get_default(void)
496 {
497         struct net_device *dev;
498
499         spin_lock(&dndev_lock);
500         dev = decnet_default_device;
501         if (dev) {
502                 if (dev->dn_ptr)
503                         dev_hold(dev);
504                 else
505                         dev = NULL;
506         }
507         spin_unlock(&dndev_lock);
508
509         return dev;
510 }
511
512 int dn_dev_set_default(struct net_device *dev, int force)
513 {
514         struct net_device *old = NULL;
515         int rv = -EBUSY;
516         if (!dev->dn_ptr)
517                 return -ENODEV;
518
519         spin_lock(&dndev_lock);
520         if (force || decnet_default_device == NULL) {
521                 old = decnet_default_device;
522                 decnet_default_device = dev;
523                 rv = 0;
524         }
525         spin_unlock(&dndev_lock);
526
527         if (old)
528                 dev_put(old);
529         return rv;
530 }
531
532 static void dn_dev_check_default(struct net_device *dev)
533 {
534         spin_lock(&dndev_lock);
535         if (dev == decnet_default_device) {
536                 decnet_default_device = NULL;
537         } else {
538                 dev = NULL;
539         }
540         spin_unlock(&dndev_lock);
541
542         if (dev)
543                 dev_put(dev);
544 }
545
546 /*
547  * Called with RTNL
548  */
549 static struct dn_dev *dn_dev_by_index(int ifindex)
550 {
551         struct net_device *dev;
552         struct dn_dev *dn_dev = NULL;
553
554         dev = __dev_get_by_index(&init_net, ifindex);
555         if (dev)
556                 dn_dev = rtnl_dereference(dev->dn_ptr);
557
558         return dn_dev;
559 }
560
561 static const struct nla_policy dn_ifa_policy[IFA_MAX+1] = {
562         [IFA_ADDRESS]           = { .type = NLA_U16 },
563         [IFA_LOCAL]             = { .type = NLA_U16 },
564         [IFA_LABEL]             = { .type = NLA_STRING,
565                                     .len = IFNAMSIZ - 1 },
566         [IFA_FLAGS]             = { .type = NLA_U32 },
567 };
568
569 static int dn_nl_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
570                          struct netlink_ext_ack *extack)
571 {
572         struct net *net = sock_net(skb->sk);
573         struct nlattr *tb[IFA_MAX+1];
574         struct dn_dev *dn_db;
575         struct ifaddrmsg *ifm;
576         struct dn_ifaddr *ifa;
577         struct dn_ifaddr __rcu **ifap;
578         int err = -EINVAL;
579
580         if (!netlink_capable(skb, CAP_NET_ADMIN))
581                 return -EPERM;
582
583         if (!net_eq(net, &init_net))
584                 goto errout;
585
586         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy,
587                           extack);
588         if (err < 0)
589                 goto errout;
590
591         err = -ENODEV;
592         ifm = nlmsg_data(nlh);
593         if ((dn_db = dn_dev_by_index(ifm->ifa_index)) == NULL)
594                 goto errout;
595
596         err = -EADDRNOTAVAIL;
597         for (ifap = &dn_db->ifa_list;
598              (ifa = rtnl_dereference(*ifap)) != NULL;
599              ifap = &ifa->ifa_next) {
600                 if (tb[IFA_LOCAL] &&
601                     nla_memcmp(tb[IFA_LOCAL], &ifa->ifa_local, 2))
602                         continue;
603
604                 if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
605                         continue;
606
607                 dn_dev_del_ifa(dn_db, ifap, 1);
608                 return 0;
609         }
610
611 errout:
612         return err;
613 }
614
615 static int dn_nl_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
616                          struct netlink_ext_ack *extack)
617 {
618         struct net *net = sock_net(skb->sk);
619         struct nlattr *tb[IFA_MAX+1];
620         struct net_device *dev;
621         struct dn_dev *dn_db;
622         struct ifaddrmsg *ifm;
623         struct dn_ifaddr *ifa;
624         int err;
625
626         if (!netlink_capable(skb, CAP_NET_ADMIN))
627                 return -EPERM;
628
629         if (!net_eq(net, &init_net))
630                 return -EINVAL;
631
632         err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, dn_ifa_policy,
633                           extack);
634         if (err < 0)
635                 return err;
636
637         if (tb[IFA_LOCAL] == NULL)
638                 return -EINVAL;
639
640         ifm = nlmsg_data(nlh);
641         if ((dev = __dev_get_by_index(&init_net, ifm->ifa_index)) == NULL)
642                 return -ENODEV;
643
644         if ((dn_db = rtnl_dereference(dev->dn_ptr)) == NULL) {
645                 dn_db = dn_dev_create(dev, &err);
646                 if (!dn_db)
647                         return err;
648         }
649
650         if ((ifa = dn_dev_alloc_ifa()) == NULL)
651                 return -ENOBUFS;
652
653         if (tb[IFA_ADDRESS] == NULL)
654                 tb[IFA_ADDRESS] = tb[IFA_LOCAL];
655
656         ifa->ifa_local = nla_get_le16(tb[IFA_LOCAL]);
657         ifa->ifa_address = nla_get_le16(tb[IFA_ADDRESS]);
658         ifa->ifa_flags = tb[IFA_FLAGS] ? nla_get_u32(tb[IFA_FLAGS]) :
659                                          ifm->ifa_flags;
660         ifa->ifa_scope = ifm->ifa_scope;
661         ifa->ifa_dev = dn_db;
662
663         if (tb[IFA_LABEL])
664                 nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
665         else
666                 memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
667
668         err = dn_dev_insert_ifa(dn_db, ifa);
669         if (err)
670                 dn_dev_free_ifa(ifa);
671
672         return err;
673 }
674
675 static inline size_t dn_ifaddr_nlmsg_size(void)
676 {
677         return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
678                + nla_total_size(IFNAMSIZ) /* IFA_LABEL */
679                + nla_total_size(2) /* IFA_ADDRESS */
680                + nla_total_size(2) /* IFA_LOCAL */
681                + nla_total_size(4); /* IFA_FLAGS */
682 }
683
684 static int dn_nl_fill_ifaddr(struct sk_buff *skb, struct dn_ifaddr *ifa,
685                              u32 portid, u32 seq, int event, unsigned int flags)
686 {
687         struct ifaddrmsg *ifm;
688         struct nlmsghdr *nlh;
689         u32 ifa_flags = ifa->ifa_flags | IFA_F_PERMANENT;
690
691         nlh = nlmsg_put(skb, portid, seq, event, sizeof(*ifm), flags);
692         if (nlh == NULL)
693                 return -EMSGSIZE;
694
695         ifm = nlmsg_data(nlh);
696         ifm->ifa_family = AF_DECnet;
697         ifm->ifa_prefixlen = 16;
698         ifm->ifa_flags = ifa_flags;
699         ifm->ifa_scope = ifa->ifa_scope;
700         ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
701
702         if ((ifa->ifa_address &&
703              nla_put_le16(skb, IFA_ADDRESS, ifa->ifa_address)) ||
704             (ifa->ifa_local &&
705              nla_put_le16(skb, IFA_LOCAL, ifa->ifa_local)) ||
706             (ifa->ifa_label[0] &&
707              nla_put_string(skb, IFA_LABEL, ifa->ifa_label)) ||
708              nla_put_u32(skb, IFA_FLAGS, ifa_flags))
709                 goto nla_put_failure;
710         nlmsg_end(skb, nlh);
711         return 0;
712
713 nla_put_failure:
714         nlmsg_cancel(skb, nlh);
715         return -EMSGSIZE;
716 }
717
718 static void dn_ifaddr_notify(int event, struct dn_ifaddr *ifa)
719 {
720         struct sk_buff *skb;
721         int err = -ENOBUFS;
722
723         skb = alloc_skb(dn_ifaddr_nlmsg_size(), GFP_KERNEL);
724         if (skb == NULL)
725                 goto errout;
726
727         err = dn_nl_fill_ifaddr(skb, ifa, 0, 0, event, 0);
728         if (err < 0) {
729                 /* -EMSGSIZE implies BUG in dn_ifaddr_nlmsg_size() */
730                 WARN_ON(err == -EMSGSIZE);
731                 kfree_skb(skb);
732                 goto errout;
733         }
734         rtnl_notify(skb, &init_net, 0, RTNLGRP_DECnet_IFADDR, NULL, GFP_KERNEL);
735         return;
736 errout:
737         if (err < 0)
738                 rtnl_set_sk_err(&init_net, RTNLGRP_DECnet_IFADDR, err);
739 }
740
741 static int dn_nl_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
742 {
743         struct net *net = sock_net(skb->sk);
744         int idx, dn_idx = 0, skip_ndevs, skip_naddr;
745         struct net_device *dev;
746         struct dn_dev *dn_db;
747         struct dn_ifaddr *ifa;
748
749         if (!net_eq(net, &init_net))
750                 return 0;
751
752         skip_ndevs = cb->args[0];
753         skip_naddr = cb->args[1];
754
755         idx = 0;
756         rcu_read_lock();
757         for_each_netdev_rcu(&init_net, dev) {
758                 if (idx < skip_ndevs)
759                         goto cont;
760                 else if (idx > skip_ndevs) {
761                         /* Only skip over addresses for first dev dumped
762                          * in this iteration (idx == skip_ndevs) */
763                         skip_naddr = 0;
764                 }
765
766                 if ((dn_db = rcu_dereference(dev->dn_ptr)) == NULL)
767                         goto cont;
768
769                 for (ifa = rcu_dereference(dn_db->ifa_list), dn_idx = 0; ifa;
770                      ifa = rcu_dereference(ifa->ifa_next), dn_idx++) {
771                         if (dn_idx < skip_naddr)
772                                 continue;
773
774                         if (dn_nl_fill_ifaddr(skb, ifa, NETLINK_CB(cb->skb).portid,
775                                               cb->nlh->nlmsg_seq, RTM_NEWADDR,
776                                               NLM_F_MULTI) < 0)
777                                 goto done;
778                 }
779 cont:
780                 idx++;
781         }
782 done:
783         rcu_read_unlock();
784         cb->args[0] = idx;
785         cb->args[1] = dn_idx;
786
787         return skb->len;
788 }
789
790 static int dn_dev_get_first(struct net_device *dev, __le16 *addr)
791 {
792         struct dn_dev *dn_db;
793         struct dn_ifaddr *ifa;
794         int rv = -ENODEV;
795
796         rcu_read_lock();
797         dn_db = rcu_dereference(dev->dn_ptr);
798         if (dn_db == NULL)
799                 goto out;
800
801         ifa = rcu_dereference(dn_db->ifa_list);
802         if (ifa != NULL) {
803                 *addr = ifa->ifa_local;
804                 rv = 0;
805         }
806 out:
807         rcu_read_unlock();
808         return rv;
809 }
810
811 /*
812  * Find a default address to bind to.
813  *
814  * This is one of those areas where the initial VMS concepts don't really
815  * map onto the Linux concepts, and since we introduced multiple addresses
816  * per interface we have to cope with slightly odd ways of finding out what
817  * "our address" really is. Mostly it's not a problem; for this we just guess
818  * a sensible default. Eventually the routing code will take care of all the
819  * nasties for us I hope.
820  */
821 int dn_dev_bind_default(__le16 *addr)
822 {
823         struct net_device *dev;
824         int rv;
825         dev = dn_dev_get_default();
826 last_chance:
827         if (dev) {
828                 rv = dn_dev_get_first(dev, addr);
829                 dev_put(dev);
830                 if (rv == 0 || dev == init_net.loopback_dev)
831                         return rv;
832         }
833         dev = init_net.loopback_dev;
834         dev_hold(dev);
835         goto last_chance;
836 }
837
838 static void dn_send_endnode_hello(struct net_device *dev, struct dn_ifaddr *ifa)
839 {
840         struct endnode_hello_message *msg;
841         struct sk_buff *skb = NULL;
842         __le16 *pktlen;
843         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
844
845         if ((skb = dn_alloc_skb(NULL, sizeof(*msg), GFP_ATOMIC)) == NULL)
846                 return;
847
848         skb->dev = dev;
849
850         msg = skb_put(skb, sizeof(*msg));
851
852         msg->msgflg  = 0x0D;
853         memcpy(msg->tiver, dn_eco_version, 3);
854         dn_dn2eth(msg->id, ifa->ifa_local);
855         msg->iinfo   = DN_RT_INFO_ENDN;
856         msg->blksize = cpu_to_le16(mtu2blksize(dev));
857         msg->area    = 0x00;
858         memset(msg->seed, 0, 8);
859         memcpy(msg->neighbor, dn_hiord, ETH_ALEN);
860
861         if (dn_db->router) {
862                 struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
863                 dn_dn2eth(msg->neighbor, dn->addr);
864         }
865
866         msg->timer   = cpu_to_le16((unsigned short)dn_db->parms.t3);
867         msg->mpd     = 0x00;
868         msg->datalen = 0x02;
869         memset(msg->data, 0xAA, 2);
870
871         pktlen = skb_push(skb, 2);
872         *pktlen = cpu_to_le16(skb->len - 2);
873
874         skb_reset_network_header(skb);
875
876         dn_rt_finish_output(skb, dn_rt_all_rt_mcast, msg->id);
877 }
878
879
880 #define DRDELAY (5 * HZ)
881
882 static int dn_am_i_a_router(struct dn_neigh *dn, struct dn_dev *dn_db, struct dn_ifaddr *ifa)
883 {
884         /* First check time since device went up */
885         if (time_before(jiffies, dn_db->uptime + DRDELAY))
886                 return 0;
887
888         /* If there is no router, then yes... */
889         if (!dn_db->router)
890                 return 1;
891
892         /* otherwise only if we have a higher priority or.. */
893         if (dn->priority < dn_db->parms.priority)
894                 return 1;
895
896         /* if we have equal priority and a higher node number */
897         if (dn->priority != dn_db->parms.priority)
898                 return 0;
899
900         if (le16_to_cpu(dn->addr) < le16_to_cpu(ifa->ifa_local))
901                 return 1;
902
903         return 0;
904 }
905
906 static void dn_send_router_hello(struct net_device *dev, struct dn_ifaddr *ifa)
907 {
908         int n;
909         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
910         struct dn_neigh *dn = (struct dn_neigh *)dn_db->router;
911         struct sk_buff *skb;
912         size_t size;
913         unsigned char *ptr;
914         unsigned char *i1, *i2;
915         __le16 *pktlen;
916         char *src;
917
918         if (mtu2blksize(dev) < (26 + 7))
919                 return;
920
921         n = mtu2blksize(dev) - 26;
922         n /= 7;
923
924         if (n > 32)
925                 n = 32;
926
927         size = 2 + 26 + 7 * n;
928
929         if ((skb = dn_alloc_skb(NULL, size, GFP_ATOMIC)) == NULL)
930                 return;
931
932         skb->dev = dev;
933         ptr = skb_put(skb, size);
934
935         *ptr++ = DN_RT_PKT_CNTL | DN_RT_PKT_ERTH;
936         *ptr++ = 2; /* ECO */
937         *ptr++ = 0;
938         *ptr++ = 0;
939         dn_dn2eth(ptr, ifa->ifa_local);
940         src = ptr;
941         ptr += ETH_ALEN;
942         *ptr++ = dn_db->parms.forwarding == 1 ?
943                         DN_RT_INFO_L1RT : DN_RT_INFO_L2RT;
944         *((__le16 *)ptr) = cpu_to_le16(mtu2blksize(dev));
945         ptr += 2;
946         *ptr++ = dn_db->parms.priority; /* Priority */
947         *ptr++ = 0; /* Area: Reserved */
948         *((__le16 *)ptr) = cpu_to_le16((unsigned short)dn_db->parms.t3);
949         ptr += 2;
950         *ptr++ = 0; /* MPD: Reserved */
951         i1 = ptr++;
952         memset(ptr, 0, 7); /* Name: Reserved */
953         ptr += 7;
954         i2 = ptr++;
955
956         n = dn_neigh_elist(dev, ptr, n);
957
958         *i2 = 7 * n;
959         *i1 = 8 + *i2;
960
961         skb_trim(skb, (27 + *i2));
962
963         pktlen = skb_push(skb, 2);
964         *pktlen = cpu_to_le16(skb->len - 2);
965
966         skb_reset_network_header(skb);
967
968         if (dn_am_i_a_router(dn, dn_db, ifa)) {
969                 struct sk_buff *skb2 = skb_copy(skb, GFP_ATOMIC);
970                 if (skb2) {
971                         dn_rt_finish_output(skb2, dn_rt_all_end_mcast, src);
972                 }
973         }
974
975         dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
976 }
977
978 static void dn_send_brd_hello(struct net_device *dev, struct dn_ifaddr *ifa)
979 {
980         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
981
982         if (dn_db->parms.forwarding == 0)
983                 dn_send_endnode_hello(dev, ifa);
984         else
985                 dn_send_router_hello(dev, ifa);
986 }
987
988 static void dn_send_ptp_hello(struct net_device *dev, struct dn_ifaddr *ifa)
989 {
990         int tdlen = 16;
991         int size = dev->hard_header_len + 2 + 4 + tdlen;
992         struct sk_buff *skb = dn_alloc_skb(NULL, size, GFP_ATOMIC);
993         int i;
994         unsigned char *ptr;
995         char src[ETH_ALEN];
996
997         if (skb == NULL)
998                 return ;
999
1000         skb->dev = dev;
1001         skb_push(skb, dev->hard_header_len);
1002         ptr = skb_put(skb, 2 + 4 + tdlen);
1003
1004         *ptr++ = DN_RT_PKT_HELO;
1005         *((__le16 *)ptr) = ifa->ifa_local;
1006         ptr += 2;
1007         *ptr++ = tdlen;
1008
1009         for(i = 0; i < tdlen; i++)
1010                 *ptr++ = 0252;
1011
1012         dn_dn2eth(src, ifa->ifa_local);
1013         dn_rt_finish_output(skb, dn_rt_all_rt_mcast, src);
1014 }
1015
1016 static int dn_eth_up(struct net_device *dev)
1017 {
1018         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
1019
1020         if (dn_db->parms.forwarding == 0)
1021                 dev_mc_add(dev, dn_rt_all_end_mcast);
1022         else
1023                 dev_mc_add(dev, dn_rt_all_rt_mcast);
1024
1025         dn_db->use_long = 1;
1026
1027         return 0;
1028 }
1029
1030 static void dn_eth_down(struct net_device *dev)
1031 {
1032         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
1033
1034         if (dn_db->parms.forwarding == 0)
1035                 dev_mc_del(dev, dn_rt_all_end_mcast);
1036         else
1037                 dev_mc_del(dev, dn_rt_all_rt_mcast);
1038 }
1039
1040 static void dn_dev_set_timer(struct net_device *dev);
1041
1042 static void dn_dev_timer_func(struct timer_list *t)
1043 {
1044         struct dn_dev *dn_db = from_timer(dn_db, t, timer);
1045         struct net_device *dev;
1046         struct dn_ifaddr *ifa;
1047
1048         rcu_read_lock();
1049         dev = dn_db->dev;
1050         if (dn_db->t3 <= dn_db->parms.t2) {
1051                 if (dn_db->parms.timer3) {
1052                         for (ifa = rcu_dereference(dn_db->ifa_list);
1053                              ifa;
1054                              ifa = rcu_dereference(ifa->ifa_next)) {
1055                                 if (!(ifa->ifa_flags & IFA_F_SECONDARY))
1056                                         dn_db->parms.timer3(dev, ifa);
1057                         }
1058                 }
1059                 dn_db->t3 = dn_db->parms.t3;
1060         } else {
1061                 dn_db->t3 -= dn_db->parms.t2;
1062         }
1063         rcu_read_unlock();
1064         dn_dev_set_timer(dev);
1065 }
1066
1067 static void dn_dev_set_timer(struct net_device *dev)
1068 {
1069         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
1070
1071         if (dn_db->parms.t2 > dn_db->parms.t3)
1072                 dn_db->parms.t2 = dn_db->parms.t3;
1073
1074         dn_db->timer.expires = jiffies + (dn_db->parms.t2 * HZ);
1075
1076         add_timer(&dn_db->timer);
1077 }
1078
1079 static struct dn_dev *dn_dev_create(struct net_device *dev, int *err)
1080 {
1081         int i;
1082         struct dn_dev_parms *p = dn_dev_list;
1083         struct dn_dev *dn_db;
1084
1085         for(i = 0; i < DN_DEV_LIST_SIZE; i++, p++) {
1086                 if (p->type == dev->type)
1087                         break;
1088         }
1089
1090         *err = -ENODEV;
1091         if (i == DN_DEV_LIST_SIZE)
1092                 return NULL;
1093
1094         *err = -ENOBUFS;
1095         if ((dn_db = kzalloc(sizeof(struct dn_dev), GFP_ATOMIC)) == NULL)
1096                 return NULL;
1097
1098         memcpy(&dn_db->parms, p, sizeof(struct dn_dev_parms));
1099
1100         rcu_assign_pointer(dev->dn_ptr, dn_db);
1101         dn_db->dev = dev;
1102         timer_setup(&dn_db->timer, dn_dev_timer_func, 0);
1103
1104         dn_db->uptime = jiffies;
1105
1106         dn_db->neigh_parms = neigh_parms_alloc(dev, &dn_neigh_table);
1107         if (!dn_db->neigh_parms) {
1108                 RCU_INIT_POINTER(dev->dn_ptr, NULL);
1109                 kfree(dn_db);
1110                 return NULL;
1111         }
1112
1113         if (dn_db->parms.up) {
1114                 if (dn_db->parms.up(dev) < 0) {
1115                         neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1116                         dev->dn_ptr = NULL;
1117                         kfree(dn_db);
1118                         return NULL;
1119                 }
1120         }
1121
1122         dn_dev_sysctl_register(dev, &dn_db->parms);
1123
1124         dn_dev_set_timer(dev);
1125
1126         *err = 0;
1127         return dn_db;
1128 }
1129
1130
1131 /*
1132  * This processes a device up event. We only start up
1133  * the loopback device & ethernet devices with correct
1134  * MAC addresses automatically. Others must be started
1135  * specifically.
1136  *
1137  * FIXME: How should we configure the loopback address ? If we could dispense
1138  * with using decnet_address here and for autobind, it will be one less thing
1139  * for users to worry about setting up.
1140  */
1141
1142 void dn_dev_up(struct net_device *dev)
1143 {
1144         struct dn_ifaddr *ifa;
1145         __le16 addr = decnet_address;
1146         int maybe_default = 0;
1147         struct dn_dev *dn_db = rtnl_dereference(dev->dn_ptr);
1148
1149         if ((dev->type != ARPHRD_ETHER) && (dev->type != ARPHRD_LOOPBACK))
1150                 return;
1151
1152         /*
1153          * Need to ensure that loopback device has a dn_db attached to it
1154          * to allow creation of neighbours against it, even though it might
1155          * not have a local address of its own. Might as well do the same for
1156          * all autoconfigured interfaces.
1157          */
1158         if (dn_db == NULL) {
1159                 int err;
1160                 dn_db = dn_dev_create(dev, &err);
1161                 if (dn_db == NULL)
1162                         return;
1163         }
1164
1165         if (dev->type == ARPHRD_ETHER) {
1166                 if (memcmp(dev->dev_addr, dn_hiord, 4) != 0)
1167                         return;
1168                 addr = dn_eth2dn(dev->dev_addr);
1169                 maybe_default = 1;
1170         }
1171
1172         if (addr == 0)
1173                 return;
1174
1175         if ((ifa = dn_dev_alloc_ifa()) == NULL)
1176                 return;
1177
1178         ifa->ifa_local = ifa->ifa_address = addr;
1179         ifa->ifa_flags = 0;
1180         ifa->ifa_scope = RT_SCOPE_UNIVERSE;
1181         strcpy(ifa->ifa_label, dev->name);
1182
1183         dn_dev_set_ifa(dev, ifa);
1184
1185         /*
1186          * Automagically set the default device to the first automatically
1187          * configured ethernet card in the system.
1188          */
1189         if (maybe_default) {
1190                 dev_hold(dev);
1191                 if (dn_dev_set_default(dev, 0))
1192                         dev_put(dev);
1193         }
1194 }
1195
1196 static void dn_dev_delete(struct net_device *dev)
1197 {
1198         struct dn_dev *dn_db = rtnl_dereference(dev->dn_ptr);
1199
1200         if (dn_db == NULL)
1201                 return;
1202
1203         del_timer_sync(&dn_db->timer);
1204         dn_dev_sysctl_unregister(&dn_db->parms);
1205         dn_dev_check_default(dev);
1206         neigh_ifdown(&dn_neigh_table, dev);
1207
1208         if (dn_db->parms.down)
1209                 dn_db->parms.down(dev);
1210
1211         dev->dn_ptr = NULL;
1212
1213         neigh_parms_release(&dn_neigh_table, dn_db->neigh_parms);
1214         neigh_ifdown(&dn_neigh_table, dev);
1215
1216         if (dn_db->router)
1217                 neigh_release(dn_db->router);
1218         if (dn_db->peer)
1219                 neigh_release(dn_db->peer);
1220
1221         kfree(dn_db);
1222 }
1223
1224 void dn_dev_down(struct net_device *dev)
1225 {
1226         struct dn_dev *dn_db = rtnl_dereference(dev->dn_ptr);
1227         struct dn_ifaddr *ifa;
1228
1229         if (dn_db == NULL)
1230                 return;
1231
1232         while ((ifa = rtnl_dereference(dn_db->ifa_list)) != NULL) {
1233                 dn_dev_del_ifa(dn_db, &dn_db->ifa_list, 0);
1234                 dn_dev_free_ifa(ifa);
1235         }
1236
1237         dn_dev_delete(dev);
1238 }
1239
1240 void dn_dev_init_pkt(struct sk_buff *skb)
1241 {
1242 }
1243
1244 void dn_dev_veri_pkt(struct sk_buff *skb)
1245 {
1246 }
1247
1248 void dn_dev_hello(struct sk_buff *skb)
1249 {
1250 }
1251
1252 void dn_dev_devices_off(void)
1253 {
1254         struct net_device *dev;
1255
1256         rtnl_lock();
1257         for_each_netdev(&init_net, dev)
1258                 dn_dev_down(dev);
1259         rtnl_unlock();
1260
1261 }
1262
1263 void dn_dev_devices_on(void)
1264 {
1265         struct net_device *dev;
1266
1267         rtnl_lock();
1268         for_each_netdev(&init_net, dev) {
1269                 if (dev->flags & IFF_UP)
1270                         dn_dev_up(dev);
1271         }
1272         rtnl_unlock();
1273 }
1274
1275 int register_dnaddr_notifier(struct notifier_block *nb)
1276 {
1277         return blocking_notifier_chain_register(&dnaddr_chain, nb);
1278 }
1279
1280 int unregister_dnaddr_notifier(struct notifier_block *nb)
1281 {
1282         return blocking_notifier_chain_unregister(&dnaddr_chain, nb);
1283 }
1284
1285 #ifdef CONFIG_PROC_FS
1286 static inline int is_dn_dev(struct net_device *dev)
1287 {
1288         return dev->dn_ptr != NULL;
1289 }
1290
1291 static void *dn_dev_seq_start(struct seq_file *seq, loff_t *pos)
1292         __acquires(RCU)
1293 {
1294         int i;
1295         struct net_device *dev;
1296
1297         rcu_read_lock();
1298
1299         if (*pos == 0)
1300                 return SEQ_START_TOKEN;
1301
1302         i = 1;
1303         for_each_netdev_rcu(&init_net, dev) {
1304                 if (!is_dn_dev(dev))
1305                         continue;
1306
1307                 if (i++ == *pos)
1308                         return dev;
1309         }
1310
1311         return NULL;
1312 }
1313
1314 static void *dn_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1315 {
1316         struct net_device *dev;
1317
1318         ++*pos;
1319
1320         dev = v;
1321         if (v == SEQ_START_TOKEN)
1322                 dev = net_device_entry(&init_net.dev_base_head);
1323
1324         for_each_netdev_continue_rcu(&init_net, dev) {
1325                 if (!is_dn_dev(dev))
1326                         continue;
1327
1328                 return dev;
1329         }
1330
1331         return NULL;
1332 }
1333
1334 static void dn_dev_seq_stop(struct seq_file *seq, void *v)
1335         __releases(RCU)
1336 {
1337         rcu_read_unlock();
1338 }
1339
1340 static char *dn_type2asc(char type)
1341 {
1342         switch (type) {
1343         case DN_DEV_BCAST:
1344                 return "B";
1345         case DN_DEV_UCAST:
1346                 return "U";
1347         case DN_DEV_MPOINT:
1348                 return "M";
1349         }
1350
1351         return "?";
1352 }
1353
1354 static int dn_dev_seq_show(struct seq_file *seq, void *v)
1355 {
1356         if (v == SEQ_START_TOKEN)
1357                 seq_puts(seq, "Name     Flags T1   Timer1 T3   Timer3 BlkSize Pri State DevType    Router Peer\n");
1358         else {
1359                 struct net_device *dev = v;
1360                 char peer_buf[DN_ASCBUF_LEN];
1361                 char router_buf[DN_ASCBUF_LEN];
1362                 struct dn_dev *dn_db = rcu_dereference(dev->dn_ptr);
1363
1364                 seq_printf(seq, "%-8s %1s     %04u %04u   %04lu %04lu"
1365                                 "   %04hu    %03d %02x    %-10s %-7s %-7s\n",
1366                                 dev->name ? dev->name : "???",
1367                                 dn_type2asc(dn_db->parms.mode),
1368                                 0, 0,
1369                                 dn_db->t3, dn_db->parms.t3,
1370                                 mtu2blksize(dev),
1371                                 dn_db->parms.priority,
1372                                 dn_db->parms.state, dn_db->parms.name,
1373                                 dn_db->router ? dn_addr2asc(le16_to_cpu(*(__le16 *)dn_db->router->primary_key), router_buf) : "",
1374                                 dn_db->peer ? dn_addr2asc(le16_to_cpu(*(__le16 *)dn_db->peer->primary_key), peer_buf) : "");
1375         }
1376         return 0;
1377 }
1378
1379 static const struct seq_operations dn_dev_seq_ops = {
1380         .start  = dn_dev_seq_start,
1381         .next   = dn_dev_seq_next,
1382         .stop   = dn_dev_seq_stop,
1383         .show   = dn_dev_seq_show,
1384 };
1385 #endif /* CONFIG_PROC_FS */
1386
1387 static int addr[2];
1388 module_param_array(addr, int, NULL, 0444);
1389 MODULE_PARM_DESC(addr, "The DECnet address of this machine: area,node");
1390
1391 void __init dn_dev_init(void)
1392 {
1393         if (addr[0] > 63 || addr[0] < 0) {
1394                 printk(KERN_ERR "DECnet: Area must be between 0 and 63");
1395                 return;
1396         }
1397
1398         if (addr[1] > 1023 || addr[1] < 0) {
1399                 printk(KERN_ERR "DECnet: Node must be between 0 and 1023");
1400                 return;
1401         }
1402
1403         decnet_address = cpu_to_le16((addr[0] << 10) | addr[1]);
1404
1405         dn_dev_devices_on();
1406
1407         rtnl_register_module(THIS_MODULE, PF_DECnet, RTM_NEWADDR,
1408                              dn_nl_newaddr, NULL, 0);
1409         rtnl_register_module(THIS_MODULE, PF_DECnet, RTM_DELADDR,
1410                              dn_nl_deladdr, NULL, 0);
1411         rtnl_register_module(THIS_MODULE, PF_DECnet, RTM_GETADDR,
1412                              NULL, dn_nl_dump_ifaddr, 0);
1413
1414         proc_create_seq("decnet_dev", 0444, init_net.proc_net, &dn_dev_seq_ops);
1415
1416 #ifdef CONFIG_SYSCTL
1417         {
1418                 int i;
1419                 for(i = 0; i < DN_DEV_LIST_SIZE; i++)
1420                         dn_dev_sysctl_register(NULL, &dn_dev_list[i]);
1421         }
1422 #endif /* CONFIG_SYSCTL */
1423 }
1424
1425 void __exit dn_dev_cleanup(void)
1426 {
1427 #ifdef CONFIG_SYSCTL
1428         {
1429                 int i;
1430                 for(i = 0; i < DN_DEV_LIST_SIZE; i++)
1431                         dn_dev_sysctl_unregister(&dn_dev_list[i]);
1432         }
1433 #endif /* CONFIG_SYSCTL */
1434
1435         remove_proc_entry("decnet_dev", init_net.proc_net);
1436
1437         dn_dev_devices_off();
1438 }