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