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