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