1/* 2 * Implements an IPX socket layer. 3 * 4 * This code is derived from work by 5 * Ross Biro : Writing the original IP stack 6 * Fred Van Kempen : Tidying up the TCP/IP 7 * 8 * Many thanks go to Keith Baker, Institute For Industrial Information 9 * Technology Ltd, Swansea University for allowing me to work on this 10 * in my own time even though it was in some ways related to commercial 11 * work I am currently employed to do there. 12 * 13 * All the material in this file is subject to the Gnu license version 2. 14 * Neither Alan Cox nor the Swansea University Computer Society admit 15 * liability nor provide warranty for any of this software. This material 16 * is provided as is and at no charge. 17 * 18 * Portions Copyright (c) 2000-2003 Conectiva, Inc. <acme@conectiva.com.br> 19 * Neither Arnaldo Carvalho de Melo nor Conectiva, Inc. admit liability nor 20 * provide warranty for any of this software. This material is provided 21 * "AS-IS" and at no charge. 22 * 23 * Portions Copyright (c) 1995 Caldera, Inc. <greg@caldera.com> 24 * Neither Greg Page nor Caldera, Inc. admit liability nor provide 25 * warranty for any of this software. This material is provided 26 * "AS-IS" and at no charge. 27 * 28 * See net/ipx/ChangeLog. 29 */ 30 31#include <linux/capability.h> 32#include <linux/errno.h> 33#include <linux/if_arp.h> 34#include <linux/if_ether.h> 35#include <linux/init.h> 36#include <linux/ipx.h> 37#include <linux/kernel.h> 38#include <linux/list.h> 39#include <linux/module.h> 40#include <linux/net.h> 41#include <linux/netdevice.h> 42#include <linux/uio.h> 43#include <linux/skbuff.h> 44#include <linux/socket.h> 45#include <linux/sockios.h> 46#include <linux/string.h> 47#include <linux/types.h> 48#include <linux/termios.h> 49 50#include <net/ipx.h> 51#include <net/p8022.h> 52#include <net/psnap.h> 53#include <net/sock.h> 54#include <net/tcp_states.h> 55 56#include <asm/uaccess.h> 57 58#ifdef CONFIG_SYSCTL 59extern void ipx_register_sysctl(void); 60extern void ipx_unregister_sysctl(void); 61#else 62#define ipx_register_sysctl() 63#define ipx_unregister_sysctl() 64#endif 65 66/* Configuration Variables */ 67static unsigned char ipxcfg_max_hops = 16; 68static char ipxcfg_auto_select_primary; 69static char ipxcfg_auto_create_interfaces; 70int sysctl_ipx_pprop_broadcasting = 1; 71 72/* Global Variables */ 73static struct datalink_proto *p8022_datalink; 74static struct datalink_proto *pEII_datalink; 75static struct datalink_proto *p8023_datalink; 76static struct datalink_proto *pSNAP_datalink; 77 78static const struct proto_ops ipx_dgram_ops; 79 80LIST_HEAD(ipx_interfaces); 81DEFINE_SPINLOCK(ipx_interfaces_lock); 82 83struct ipx_interface *ipx_primary_net; 84struct ipx_interface *ipx_internal_net; 85 86extern int ipxrtr_add_route(__be32 network, struct ipx_interface *intrfc, 87 unsigned char *node); 88extern void ipxrtr_del_routes(struct ipx_interface *intrfc); 89extern int ipxrtr_route_packet(struct sock *sk, struct sockaddr_ipx *usipx, 90 struct iovec *iov, size_t len, int noblock); 91extern int ipxrtr_route_skb(struct sk_buff *skb); 92extern struct ipx_route *ipxrtr_lookup(__be32 net); 93extern int ipxrtr_ioctl(unsigned int cmd, void __user *arg); 94 95#undef IPX_REFCNT_DEBUG 96#ifdef IPX_REFCNT_DEBUG 97atomic_t ipx_sock_nr; 98#endif 99 100struct ipx_interface *ipx_interfaces_head(void) 101{ 102 struct ipx_interface *rc = NULL; 103 104 if (!list_empty(&ipx_interfaces)) 105 rc = list_entry(ipx_interfaces.next, 106 struct ipx_interface, node); 107 return rc; 108} 109 110static void ipxcfg_set_auto_select(char val) 111{ 112 ipxcfg_auto_select_primary = val; 113 if (val && !ipx_primary_net) 114 ipx_primary_net = ipx_interfaces_head(); 115} 116 117static int ipxcfg_get_config_data(struct ipx_config_data __user *arg) 118{ 119 struct ipx_config_data vals; 120 121 vals.ipxcfg_auto_create_interfaces = ipxcfg_auto_create_interfaces; 122 vals.ipxcfg_auto_select_primary = ipxcfg_auto_select_primary; 123 124 return copy_to_user(arg, &vals, sizeof(vals)) ? -EFAULT : 0; 125} 126 127/* 128 * Note: Sockets may not be removed _during_ an interrupt or inet_bh 129 * handler using this technique. They can be added although we do not 130 * use this facility. 131 */ 132 133static void ipx_remove_socket(struct sock *sk) 134{ 135 /* Determine interface with which socket is associated */ 136 struct ipx_interface *intrfc = ipx_sk(sk)->intrfc; 137 138 if (!intrfc) 139 goto out; 140 141 ipxitf_hold(intrfc); 142 spin_lock_bh(&intrfc->if_sklist_lock); 143 sk_del_node_init(sk); 144 spin_unlock_bh(&intrfc->if_sklist_lock); 145 ipxitf_put(intrfc); 146out: 147 return; 148} 149 150static void ipx_destroy_socket(struct sock *sk) 151{ 152 ipx_remove_socket(sk); 153 skb_queue_purge(&sk->sk_receive_queue); 154#ifdef IPX_REFCNT_DEBUG 155 atomic_dec(&ipx_sock_nr); 156 printk(KERN_DEBUG "IPX socket %p released, %d are still alive\n", sk, 157 atomic_read(&ipx_sock_nr)); 158 if (atomic_read(&sk->sk_refcnt) != 1) 159 printk(KERN_DEBUG "Destruction sock ipx %p delayed, cnt=%d\n", 160 sk, atomic_read(&sk->sk_refcnt)); 161#endif 162 sock_put(sk); 163} 164 165/* 166 * The following code is used to support IPX Interfaces (IPXITF). An 167 * IPX interface is defined by a physical device and a frame type. 168 */ 169 170/* ipxitf_clear_primary_net has to be called with ipx_interfaces_lock held */ 171 172static void ipxitf_clear_primary_net(void) 173{ 174 ipx_primary_net = NULL; 175 if (ipxcfg_auto_select_primary) 176 ipx_primary_net = ipx_interfaces_head(); 177} 178 179static struct ipx_interface *__ipxitf_find_using_phys(struct net_device *dev, 180 __be16 datalink) 181{ 182 struct ipx_interface *i; 183 184 list_for_each_entry(i, &ipx_interfaces, node) 185 if (i->if_dev == dev && i->if_dlink_type == datalink) 186 goto out; 187 i = NULL; 188out: 189 return i; 190} 191 192static struct ipx_interface *ipxitf_find_using_phys(struct net_device *dev, 193 __be16 datalink) 194{ 195 struct ipx_interface *i; 196 197 spin_lock_bh(&ipx_interfaces_lock); 198 i = __ipxitf_find_using_phys(dev, datalink); 199 if (i) 200 ipxitf_hold(i); 201 spin_unlock_bh(&ipx_interfaces_lock); 202 return i; 203} 204 205struct ipx_interface *ipxitf_find_using_net(__be32 net) 206{ 207 struct ipx_interface *i; 208 209 spin_lock_bh(&ipx_interfaces_lock); 210 if (net) { 211 list_for_each_entry(i, &ipx_interfaces, node) 212 if (i->if_netnum == net) 213 goto hold; 214 i = NULL; 215 goto unlock; 216 } 217 218 i = ipx_primary_net; 219 if (i) 220hold: 221 ipxitf_hold(i); 222unlock: 223 spin_unlock_bh(&ipx_interfaces_lock); 224 return i; 225} 226 227/* Sockets are bound to a particular IPX interface. */ 228static void ipxitf_insert_socket(struct ipx_interface *intrfc, struct sock *sk) 229{ 230 ipxitf_hold(intrfc); 231 spin_lock_bh(&intrfc->if_sklist_lock); 232 ipx_sk(sk)->intrfc = intrfc; 233 sk_add_node(sk, &intrfc->if_sklist); 234 spin_unlock_bh(&intrfc->if_sklist_lock); 235 ipxitf_put(intrfc); 236} 237 238/* caller must hold intrfc->if_sklist_lock */ 239static struct sock *__ipxitf_find_socket(struct ipx_interface *intrfc, 240 __be16 port) 241{ 242 struct sock *s; 243 struct hlist_node *node; 244 245 sk_for_each(s, node, &intrfc->if_sklist) 246 if (ipx_sk(s)->port == port) 247 goto found; 248 s = NULL; 249found: 250 return s; 251} 252 253/* caller must hold a reference to intrfc */ 254static struct sock *ipxitf_find_socket(struct ipx_interface *intrfc, 255 __be16 port) 256{ 257 struct sock *s; 258 259 spin_lock_bh(&intrfc->if_sklist_lock); 260 s = __ipxitf_find_socket(intrfc, port); 261 if (s) 262 sock_hold(s); 263 spin_unlock_bh(&intrfc->if_sklist_lock); 264 265 return s; 266} 267 268#ifdef CONFIG_IPX_INTERN 269static struct sock *ipxitf_find_internal_socket(struct ipx_interface *intrfc, 270 unsigned char *ipx_node, 271 __be16 port) 272{ 273 struct sock *s; 274 struct hlist_node *node; 275 276 ipxitf_hold(intrfc); 277 spin_lock_bh(&intrfc->if_sklist_lock); 278 279 sk_for_each(s, node, &intrfc->if_sklist) { 280 struct ipx_sock *ipxs = ipx_sk(s); 281 282 if (ipxs->port == port && 283 !memcmp(ipx_node, ipxs->node, IPX_NODE_LEN)) 284 goto found; 285 } 286 s = NULL; 287found: 288 spin_unlock_bh(&intrfc->if_sklist_lock); 289 ipxitf_put(intrfc); 290 return s; 291} 292#endif 293 294static void __ipxitf_down(struct ipx_interface *intrfc) 295{ 296 struct sock *s; 297 struct hlist_node *node, *t; 298 299 /* Delete all routes associated with this interface */ 300 ipxrtr_del_routes(intrfc); 301 302 spin_lock_bh(&intrfc->if_sklist_lock); 303 /* error sockets */ 304 sk_for_each_safe(s, node, t, &intrfc->if_sklist) { 305 struct ipx_sock *ipxs = ipx_sk(s); 306 307 s->sk_err = ENOLINK; 308 s->sk_error_report(s); 309 ipxs->intrfc = NULL; 310 ipxs->port = 0; 311 sock_set_flag(s, SOCK_ZAPPED); /* Indicates it is no longer bound */ 312 sk_del_node_init(s); 313 } 314 INIT_HLIST_HEAD(&intrfc->if_sklist); 315 spin_unlock_bh(&intrfc->if_sklist_lock); 316 317 /* remove this interface from list */ 318 list_del(&intrfc->node); 319 320 /* remove this interface from *special* networks */ 321 if (intrfc == ipx_primary_net) 322 ipxitf_clear_primary_net(); 323 if (intrfc == ipx_internal_net) 324 ipx_internal_net = NULL; 325 326 if (intrfc->if_dev) 327 dev_put(intrfc->if_dev); 328 kfree(intrfc); 329} 330 331void ipxitf_down(struct ipx_interface *intrfc) 332{ 333 spin_lock_bh(&ipx_interfaces_lock); 334 __ipxitf_down(intrfc); 335 spin_unlock_bh(&ipx_interfaces_lock); 336} 337 338static __inline__ void __ipxitf_put(struct ipx_interface *intrfc) 339{ 340 if (atomic_dec_and_test(&intrfc->refcnt)) 341 __ipxitf_down(intrfc); 342} 343 344static int ipxitf_device_event(struct notifier_block *notifier, 345 unsigned long event, void *ptr) 346{ 347 struct net_device *dev = ptr; 348 struct ipx_interface *i, *tmp; 349 350 if (event != NETDEV_DOWN && event != NETDEV_UP) 351 goto out; 352 353 spin_lock_bh(&ipx_interfaces_lock); 354 list_for_each_entry_safe(i, tmp, &ipx_interfaces, node) 355 if (i->if_dev == dev) { 356 if (event == NETDEV_UP) 357 ipxitf_hold(i); 358 else 359 __ipxitf_put(i); 360 } 361 spin_unlock_bh(&ipx_interfaces_lock); 362out: 363 return NOTIFY_DONE; 364} 365 366 367static __exit void ipxitf_cleanup(void) 368{ 369 struct ipx_interface *i, *tmp; 370 371 spin_lock_bh(&ipx_interfaces_lock); 372 list_for_each_entry_safe(i, tmp, &ipx_interfaces, node) 373 __ipxitf_put(i); 374 spin_unlock_bh(&ipx_interfaces_lock); 375} 376 377static void ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb) 378{ 379 if (sock_queue_rcv_skb(sock, skb) < 0) 380 kfree_skb(skb); 381} 382 383/* 384 * On input skb->sk is NULL. Nobody is charged for the memory. 385 */ 386 387/* caller must hold a reference to intrfc */ 388 389#ifdef CONFIG_IPX_INTERN 390static int ipxitf_demux_socket(struct ipx_interface *intrfc, 391 struct sk_buff *skb, int copy) 392{ 393 struct ipxhdr *ipx = ipx_hdr(skb); 394 int is_broadcast = !memcmp(ipx->ipx_dest.node, ipx_broadcast_node, 395 IPX_NODE_LEN); 396 struct sock *s; 397 struct hlist_node *node; 398 int rc; 399 400 spin_lock_bh(&intrfc->if_sklist_lock); 401 402 sk_for_each(s, node, &intrfc->if_sklist) { 403 struct ipx_sock *ipxs = ipx_sk(s); 404 405 if (ipxs->port == ipx->ipx_dest.sock && 406 (is_broadcast || !memcmp(ipx->ipx_dest.node, 407 ipxs->node, IPX_NODE_LEN))) { 408 /* We found a socket to which to send */ 409 struct sk_buff *skb1; 410 411 if (copy) { 412 skb1 = skb_clone(skb, GFP_ATOMIC); 413 rc = -ENOMEM; 414 if (!skb1) 415 goto out; 416 } else { 417 skb1 = skb; 418 copy = 1; /* skb may only be used once */ 419 } 420 ipxitf_def_skb_handler(s, skb1); 421 422 /* On an external interface, one socket can listen */ 423 if (intrfc != ipx_internal_net) 424 break; 425 } 426 } 427 428 /* skb was solely for us, and we did not make a copy, so free it. */ 429 if (!copy) 430 kfree_skb(skb); 431 432 rc = 0; 433out: 434 spin_unlock_bh(&intrfc->if_sklist_lock); 435 return rc; 436} 437#else 438static struct sock *ncp_connection_hack(struct ipx_interface *intrfc, 439 struct ipxhdr *ipx) 440{ 441 /* The packet's target is a NCP connection handler. We want to hand it 442 * to the correct socket directly within the kernel, so that the 443 * mars_nwe packet distribution process does not have to do it. Here we 444 * only care about NCP and BURST packets. 445 * 446 * You might call this a hack, but believe me, you do not want a 447 * complete NCP layer in the kernel, and this is VERY fast as well. */ 448 struct sock *sk = NULL; 449 int connection = 0; 450 u8 *ncphdr = (u8 *)(ipx + 1); 451 452 if (*ncphdr == 0x22 && *(ncphdr + 1) == 0x22) /* NCP request */ 453 connection = (((int) *(ncphdr + 5)) << 8) | (int) *(ncphdr + 3); 454 else if (*ncphdr == 0x77 && *(ncphdr + 1) == 0x77) /* BURST packet */ 455 connection = (((int) *(ncphdr + 9)) << 8) | (int) *(ncphdr + 8); 456 457 if (connection) { 458 struct hlist_node *node; 459 /* Now we have to look for a special NCP connection handling 460 * socket. Only these sockets have ipx_ncp_conn != 0, set by 461 * SIOCIPXNCPCONN. */ 462 spin_lock_bh(&intrfc->if_sklist_lock); 463 sk_for_each(sk, node, &intrfc->if_sklist) 464 if (ipx_sk(sk)->ipx_ncp_conn == connection) { 465 sock_hold(sk); 466 goto found; 467 } 468 sk = NULL; 469 found: 470 spin_unlock_bh(&intrfc->if_sklist_lock); 471 } 472 return sk; 473} 474 475static int ipxitf_demux_socket(struct ipx_interface *intrfc, 476 struct sk_buff *skb, int copy) 477{ 478 struct ipxhdr *ipx = ipx_hdr(skb); 479 struct sock *sock1 = NULL, *sock2 = NULL; 480 struct sk_buff *skb1 = NULL, *skb2 = NULL; 481 int rc; 482 483 if (intrfc == ipx_primary_net && ntohs(ipx->ipx_dest.sock) == 0x451) 484 sock1 = ncp_connection_hack(intrfc, ipx); 485 if (!sock1) 486 /* No special socket found, forward the packet the normal way */ 487 sock1 = ipxitf_find_socket(intrfc, ipx->ipx_dest.sock); 488 489 /* 490 * We need to check if there is a primary net and if 491 * this is addressed to one of the *SPECIAL* sockets because 492 * these need to be propagated to the primary net. 493 * The *SPECIAL* socket list contains: 0x452(SAP), 0x453(RIP) and 494 * 0x456(Diagnostic). 495 */ 496 497 if (ipx_primary_net && intrfc != ipx_primary_net) { 498 const int dsock = ntohs(ipx->ipx_dest.sock); 499 500 if (dsock == 0x452 || dsock == 0x453 || dsock == 0x456) 501 /* The appropriate thing to do here is to dup the 502 * packet and route to the primary net interface via 503 * ipxitf_send; however, we'll cheat and just demux it 504 * here. */ 505 sock2 = ipxitf_find_socket(ipx_primary_net, 506 ipx->ipx_dest.sock); 507 } 508 509 /* 510 * If there is nothing to do return. The kfree will cancel any charging. 511 */ 512 rc = 0; 513 if (!sock1 && !sock2) { 514 if (!copy) 515 kfree_skb(skb); 516 goto out; 517 } 518 519 /* 520 * This next segment of code is a little awkward, but it sets it up 521 * so that the appropriate number of copies of the SKB are made and 522 * that skb1 and skb2 point to it (them) so that it (they) can be 523 * demuxed to sock1 and/or sock2. If we are unable to make enough 524 * copies, we do as much as is possible. 525 */ 526 527 if (copy) 528 skb1 = skb_clone(skb, GFP_ATOMIC); 529 else 530 skb1 = skb; 531 532 rc = -ENOMEM; 533 if (!skb1) 534 goto out_put; 535 536 /* Do we need 2 SKBs? */ 537 if (sock1 && sock2) 538 skb2 = skb_clone(skb1, GFP_ATOMIC); 539 else 540 skb2 = skb1; 541 542 if (sock1) 543 ipxitf_def_skb_handler(sock1, skb1); 544 545 if (!skb2) 546 goto out_put; 547 548 if (sock2) 549 ipxitf_def_skb_handler(sock2, skb2); 550 551 rc = 0; 552out_put: 553 if (sock1) 554 sock_put(sock1); 555 if (sock2) 556 sock_put(sock2); 557out: 558 return rc; 559} 560#endif /* CONFIG_IPX_INTERN */ 561 562static struct sk_buff *ipxitf_adjust_skbuff(struct ipx_interface *intrfc, 563 struct sk_buff *skb) 564{ 565 struct sk_buff *skb2; 566 int in_offset = (unsigned char *)ipx_hdr(skb) - skb->head; 567 int out_offset = intrfc->if_ipx_offset; 568 int len; 569 570 /* Hopefully, most cases */ 571 if (in_offset >= out_offset) 572 return skb; 573 574 /* Need new SKB */ 575 len = skb->len + out_offset; 576 skb2 = alloc_skb(len, GFP_ATOMIC); 577 if (skb2) { 578 skb_reserve(skb2, out_offset); 579 skb_reset_network_header(skb2); 580 skb_reset_transport_header(skb2); 581 skb_put(skb2, skb->len); 582 memcpy(ipx_hdr(skb2), ipx_hdr(skb), skb->len); 583 memcpy(skb2->cb, skb->cb, sizeof(skb->cb)); 584 } 585 kfree_skb(skb); 586 return skb2; 587} 588 589/* caller must hold a reference to intrfc and the skb has to be unshared */ 590int ipxitf_send(struct ipx_interface *intrfc, struct sk_buff *skb, char *node) 591{ 592 struct ipxhdr *ipx = ipx_hdr(skb); 593 struct net_device *dev = intrfc->if_dev; 594 struct datalink_proto *dl = intrfc->if_dlink; 595 char dest_node[IPX_NODE_LEN]; 596 int send_to_wire = 1; 597 int addr_len; 598 599 ipx->ipx_tctrl = IPX_SKB_CB(skb)->ipx_tctrl; 600 ipx->ipx_dest.net = IPX_SKB_CB(skb)->ipx_dest_net; 601 ipx->ipx_source.net = IPX_SKB_CB(skb)->ipx_source_net; 602 603 /* see if we need to include the netnum in the route list */ 604 if (IPX_SKB_CB(skb)->last_hop.index >= 0) { 605 __be32 *last_hop = (__be32 *)(((u8 *) skb->data) + 606 sizeof(struct ipxhdr) + 607 IPX_SKB_CB(skb)->last_hop.index * 608 sizeof(__be32)); 609 *last_hop = IPX_SKB_CB(skb)->last_hop.netnum; 610 IPX_SKB_CB(skb)->last_hop.index = -1; 611 } 612 613 /* 614 * We need to know how many skbuffs it will take to send out this 615 * packet to avoid unnecessary copies. 616 */ 617 618 if (!dl || !dev || dev->flags & IFF_LOOPBACK) 619 send_to_wire = 0; /* No non looped */ 620 621 /* 622 * See if this should be demuxed to sockets on this interface 623 * 624 * We want to ensure the original was eaten or that we only use 625 * up clones. 626 */ 627 628 if (ipx->ipx_dest.net == intrfc->if_netnum) { 629 /* 630 * To our own node, loop and free the original. 631 * The internal net will receive on all node address. 632 */ 633 if (intrfc == ipx_internal_net || 634 !memcmp(intrfc->if_node, node, IPX_NODE_LEN)) { 635 /* Don't charge sender */ 636 skb_orphan(skb); 637 638 /* Will charge receiver */ 639 return ipxitf_demux_socket(intrfc, skb, 0); 640 } 641 642 /* Broadcast, loop and possibly keep to send on. */ 643 if (!memcmp(ipx_broadcast_node, node, IPX_NODE_LEN)) { 644 if (!send_to_wire) 645 skb_orphan(skb); 646 ipxitf_demux_socket(intrfc, skb, send_to_wire); 647 if (!send_to_wire) 648 goto out; 649 } 650 } 651 652 /* 653 * If the originating net is not equal to our net; this is routed 654 * We are still charging the sender. Which is right - the driver 655 * free will handle this fairly. 656 */ 657 if (ipx->ipx_source.net != intrfc->if_netnum) { 658 /* 659 * Unshare the buffer before modifying the count in 660 * case it's a flood or tcpdump 661 */ 662 skb = skb_unshare(skb, GFP_ATOMIC); 663 if (!skb) 664 goto out; 665 if (++ipx->ipx_tctrl > ipxcfg_max_hops) 666 send_to_wire = 0; 667 } 668 669 if (!send_to_wire) { 670 kfree_skb(skb); 671 goto out; 672 } 673 674 /* Determine the appropriate hardware address */ 675 addr_len = dev->addr_len; 676 if (!memcmp(ipx_broadcast_node, node, IPX_NODE_LEN)) 677 memcpy(dest_node, dev->broadcast, addr_len); 678 else 679 memcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len); 680 681 /* Make any compensation for differing physical/data link size */ 682 skb = ipxitf_adjust_skbuff(intrfc, skb); 683 if (!skb) 684 goto out; 685 686 /* set up data link and physical headers */ 687 skb->dev = dev; 688 skb->protocol = htons(ETH_P_IPX); 689 690 /* Send it out */ 691 dl->request(dl, skb, dest_node); 692out: 693 return 0; 694} 695 696static int ipxitf_add_local_route(struct ipx_interface *intrfc) 697{ 698 return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL); 699} 700 701static void ipxitf_discover_netnum(struct ipx_interface *intrfc, 702 struct sk_buff *skb); 703static int ipxitf_pprop(struct ipx_interface *intrfc, struct sk_buff *skb); 704 705static int ipxitf_rcv(struct ipx_interface *intrfc, struct sk_buff *skb) 706{ 707 struct ipxhdr *ipx = ipx_hdr(skb); 708 int rc = 0; 709 710 ipxitf_hold(intrfc); 711 712 /* See if we should update our network number */ 713 if (!intrfc->if_netnum) /* net number of intrfc not known yet */ 714 ipxitf_discover_netnum(intrfc, skb); 715 716 IPX_SKB_CB(skb)->last_hop.index = -1; 717 if (ipx->ipx_type == IPX_TYPE_PPROP) { 718 rc = ipxitf_pprop(intrfc, skb); 719 if (rc) 720 goto out_free_skb; 721 } 722 723 /* local processing follows */ 724 if (!IPX_SKB_CB(skb)->ipx_dest_net) 725 IPX_SKB_CB(skb)->ipx_dest_net = intrfc->if_netnum; 726 if (!IPX_SKB_CB(skb)->ipx_source_net) 727 IPX_SKB_CB(skb)->ipx_source_net = intrfc->if_netnum; 728 729 /* it doesn't make sense to route a pprop packet, there's no meaning 730 * in the ipx_dest_net for such packets */ 731 if (ipx->ipx_type != IPX_TYPE_PPROP && 732 intrfc->if_netnum != IPX_SKB_CB(skb)->ipx_dest_net) { 733 /* We only route point-to-point packets. */ 734 if (skb->pkt_type == PACKET_HOST) { 735 skb = skb_unshare(skb, GFP_ATOMIC); 736 if (skb) 737 rc = ipxrtr_route_skb(skb); 738 goto out_intrfc; 739 } 740 741 goto out_free_skb; 742 } 743 744 /* see if we should keep it */ 745 if (!memcmp(ipx_broadcast_node, ipx->ipx_dest.node, IPX_NODE_LEN) || 746 !memcmp(intrfc->if_node, ipx->ipx_dest.node, IPX_NODE_LEN)) { 747 rc = ipxitf_demux_socket(intrfc, skb, 0); 748 goto out_intrfc; 749 } 750 751 /* we couldn't pawn it off so unload it */ 752out_free_skb: 753 kfree_skb(skb); 754out_intrfc: 755 ipxitf_put(intrfc); 756 return rc; 757} 758 759static void ipxitf_discover_netnum(struct ipx_interface *intrfc, 760 struct sk_buff *skb) 761{ 762 const struct ipx_cb *cb = IPX_SKB_CB(skb); 763 764 /* see if this is an intra packet: source_net == dest_net */ 765 if (cb->ipx_source_net == cb->ipx_dest_net && cb->ipx_source_net) { 766 struct ipx_interface *i = 767 ipxitf_find_using_net(cb->ipx_source_net); 768 /* NB: NetWare servers lie about their hop count so we 769 * dropped the test based on it. This is the best way 770 * to determine this is a 0 hop count packet. */ 771 if (!i) { 772 intrfc->if_netnum = cb->ipx_source_net; 773 ipxitf_add_local_route(intrfc); 774 } else { 775 printk(KERN_WARNING "IPX: Network number collision " 776 "%lx\n %s %s and %s %s\n", 777 (unsigned long) ntohl(cb->ipx_source_net), 778 ipx_device_name(i), 779 ipx_frame_name(i->if_dlink_type), 780 ipx_device_name(intrfc), 781 ipx_frame_name(intrfc->if_dlink_type)); 782 ipxitf_put(i); 783 } 784 } 785} 786 787/** 788 * ipxitf_pprop - Process packet propagation IPX packet type 0x14, used for 789 * NetBIOS broadcasts 790 * @intrfc: IPX interface receiving this packet 791 * @skb: Received packet 792 * 793 * Checks if packet is valid: if its more than %IPX_MAX_PPROP_HOPS hops or if it 794 * is smaller than a IPX header + the room for %IPX_MAX_PPROP_HOPS hops we drop 795 * it, not even processing it locally, if it has exact %IPX_MAX_PPROP_HOPS we 796 * don't broadcast it, but process it locally. See chapter 5 of Novell's "IPX 797 * RIP and SAP Router Specification", Part Number 107-000029-001. 798 * 799 * If it is valid, check if we have pprop broadcasting enabled by the user, 800 * if not, just return zero for local processing. 801 * 802 * If it is enabled check the packet and don't broadcast it if we have already 803 * seen this packet. 804 * 805 * Broadcast: send it to the interfaces that aren't on the packet visited nets 806 * array, just after the IPX header. 807 * 808 * Returns -EINVAL for invalid packets, so that the calling function drops 809 * the packet without local processing. 0 if packet is to be locally processed. 810 */ 811static int ipxitf_pprop(struct ipx_interface *intrfc, struct sk_buff *skb) 812{ 813 struct ipxhdr *ipx = ipx_hdr(skb); 814 int i, rc = -EINVAL; 815 struct ipx_interface *ifcs; 816 char *c; 817 __be32 *l; 818 819 /* Illegal packet - too many hops or too short */ 820 /* We decide to throw it away: no broadcasting, no local processing. 821 * NetBIOS unaware implementations route them as normal packets - 822 * tctrl <= 15, any data payload... */ 823 if (IPX_SKB_CB(skb)->ipx_tctrl > IPX_MAX_PPROP_HOPS || 824 ntohs(ipx->ipx_pktsize) < sizeof(struct ipxhdr) + 825 IPX_MAX_PPROP_HOPS * sizeof(u32)) 826 goto out; 827 /* are we broadcasting this damn thing? */ 828 rc = 0; 829 if (!sysctl_ipx_pprop_broadcasting) 830 goto out; 831 /* We do broadcast packet on the IPX_MAX_PPROP_HOPS hop, but we 832 * process it locally. All previous hops broadcasted it, and process it 833 * locally. */ 834 if (IPX_SKB_CB(skb)->ipx_tctrl == IPX_MAX_PPROP_HOPS) 835 goto out; 836 837 c = ((u8 *) ipx) + sizeof(struct ipxhdr); 838 l = (__be32 *) c; 839 840 /* Don't broadcast packet if already seen this net */ 841 for (i = 0; i < IPX_SKB_CB(skb)->ipx_tctrl; i++) 842 if (*l++ == intrfc->if_netnum) 843 goto out; 844 845 /* < IPX_MAX_PPROP_HOPS hops && input interface not in list. Save the 846 * position where we will insert recvd netnum into list, later on, 847 * in ipxitf_send */ 848 IPX_SKB_CB(skb)->last_hop.index = i; 849 IPX_SKB_CB(skb)->last_hop.netnum = intrfc->if_netnum; 850 /* xmit on all other interfaces... */ 851 spin_lock_bh(&ipx_interfaces_lock); 852 list_for_each_entry(ifcs, &ipx_interfaces, node) { 853 /* Except unconfigured interfaces */ 854 if (!ifcs->if_netnum) 855 continue; 856 857 /* That aren't in the list */ 858 if (ifcs == intrfc) 859 continue; 860 l = (__be32 *) c; 861 /* don't consider the last entry in the packet list, 862 * it is our netnum, and it is not there yet */ 863 for (i = 0; i < IPX_SKB_CB(skb)->ipx_tctrl; i++) 864 if (ifcs->if_netnum == *l++) 865 break; 866 if (i == IPX_SKB_CB(skb)->ipx_tctrl) { 867 struct sk_buff *s = skb_copy(skb, GFP_ATOMIC); 868 869 if (s) { 870 IPX_SKB_CB(s)->ipx_dest_net = ifcs->if_netnum; 871 ipxrtr_route_skb(s); 872 } 873 } 874 } 875 spin_unlock_bh(&ipx_interfaces_lock); 876out: 877 return rc; 878} 879 880static void ipxitf_insert(struct ipx_interface *intrfc) 881{ 882 spin_lock_bh(&ipx_interfaces_lock); 883 list_add_tail(&intrfc->node, &ipx_interfaces); 884 spin_unlock_bh(&ipx_interfaces_lock); 885 886 if (ipxcfg_auto_select_primary && !ipx_primary_net) 887 ipx_primary_net = intrfc; 888} 889 890static struct ipx_interface *ipxitf_alloc(struct net_device *dev, __be32 netnum, 891 __be16 dlink_type, 892 struct datalink_proto *dlink, 893 unsigned char internal, 894 int ipx_offset) 895{ 896 struct ipx_interface *intrfc = kmalloc(sizeof(*intrfc), GFP_ATOMIC); 897 898 if (intrfc) { 899 intrfc->if_dev = dev; 900 intrfc->if_netnum = netnum; 901 intrfc->if_dlink_type = dlink_type; 902 intrfc->if_dlink = dlink; 903 intrfc->if_internal = internal; 904 intrfc->if_ipx_offset = ipx_offset; 905 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET; 906 INIT_HLIST_HEAD(&intrfc->if_sklist); 907 atomic_set(&intrfc->refcnt, 1); 908 spin_lock_init(&intrfc->if_sklist_lock); 909 } 910 911 return intrfc; 912} 913 914static int ipxitf_create_internal(struct ipx_interface_definition *idef) 915{ 916 struct ipx_interface *intrfc; 917 int rc = -EEXIST; 918 919 /* Only one primary network allowed */ 920 if (ipx_primary_net) 921 goto out; 922 923 /* Must have a valid network number */ 924 rc = -EADDRNOTAVAIL; 925 if (!idef->ipx_network) 926 goto out; 927 intrfc = ipxitf_find_using_net(idef->ipx_network); 928 rc = -EADDRINUSE; 929 if (intrfc) { 930 ipxitf_put(intrfc); 931 goto out; 932 } 933 intrfc = ipxitf_alloc(NULL, idef->ipx_network, 0, NULL, 1, 0); 934 rc = -EAGAIN; 935 if (!intrfc) 936 goto out; 937 memcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN); 938 ipx_internal_net = ipx_primary_net = intrfc; 939 ipxitf_hold(intrfc); 940 ipxitf_insert(intrfc); 941 942 rc = ipxitf_add_local_route(intrfc); 943 ipxitf_put(intrfc); 944out: 945 return rc; 946} 947 948static __be16 ipx_map_frame_type(unsigned char type) 949{ 950 __be16 rc = 0; 951 952 switch (type) { 953 case IPX_FRAME_ETHERII: rc = htons(ETH_P_IPX); break; 954 case IPX_FRAME_8022: rc = htons(ETH_P_802_2); break; 955 case IPX_FRAME_SNAP: rc = htons(ETH_P_SNAP); break; 956 case IPX_FRAME_8023: rc = htons(ETH_P_802_3); break; 957 } 958 959 return rc; 960} 961 962static int ipxitf_create(struct ipx_interface_definition *idef) 963{ 964 struct net_device *dev; 965 __be16 dlink_type = 0; 966 struct datalink_proto *datalink = NULL; 967 struct ipx_interface *intrfc; 968 int rc; 969 970 if (idef->ipx_special == IPX_INTERNAL) { 971 rc = ipxitf_create_internal(idef); 972 goto out; 973 } 974 975 rc = -EEXIST; 976 if (idef->ipx_special == IPX_PRIMARY && ipx_primary_net) 977 goto out; 978 979 intrfc = ipxitf_find_using_net(idef->ipx_network); 980 rc = -EADDRINUSE; 981 if (idef->ipx_network && intrfc) { 982 ipxitf_put(intrfc); 983 goto out; 984 } 985 986 if (intrfc) 987 ipxitf_put(intrfc); 988 989 dev = dev_get_by_name(idef->ipx_device); 990 rc = -ENODEV; 991 if (!dev) 992 goto out; 993 994 switch (idef->ipx_dlink_type) { 995 case IPX_FRAME_TR_8022: 996 printk(KERN_WARNING "IPX frame type 802.2TR is " 997 "obsolete Use 802.2 instead.\n"); 998 /* fall through */ 999 case IPX_FRAME_8022: 1000 dlink_type = htons(ETH_P_802_2); 1001 datalink = p8022_datalink; 1002 break; 1003 case IPX_FRAME_ETHERII: 1004 if (dev->type != ARPHRD_IEEE802) { 1005 dlink_type = htons(ETH_P_IPX); 1006 datalink = pEII_datalink; 1007 break; 1008 } else 1009 printk(KERN_WARNING "IPX frame type EtherII over " 1010 "token-ring is obsolete. Use SNAP " 1011 "instead.\n"); 1012 /* fall through */ 1013 case IPX_FRAME_SNAP: 1014 dlink_type = htons(ETH_P_SNAP); 1015 datalink = pSNAP_datalink; 1016 break; 1017 case IPX_FRAME_8023: 1018 dlink_type = htons(ETH_P_802_3); 1019 datalink = p8023_datalink; 1020 break; 1021 case IPX_FRAME_NONE: 1022 default: 1023 rc = -EPROTONOSUPPORT; 1024 goto out_dev; 1025 } 1026 1027 rc = -ENETDOWN; 1028 if (!(dev->flags & IFF_UP)) 1029 goto out_dev; 1030 1031 /* Check addresses are suitable */ 1032 rc = -EINVAL; 1033 if (dev->addr_len > IPX_NODE_LEN) 1034 goto out_dev; 1035 1036 intrfc = ipxitf_find_using_phys(dev, dlink_type); 1037 if (!intrfc) { 1038 /* Ok now create */ 1039 intrfc = ipxitf_alloc(dev, idef->ipx_network, dlink_type, 1040 datalink, 0, dev->hard_header_len + 1041 datalink->header_length); 1042 rc = -EAGAIN; 1043 if (!intrfc) 1044 goto out_dev; 1045 /* Setup primary if necessary */ 1046 if (idef->ipx_special == IPX_PRIMARY) 1047 ipx_primary_net = intrfc; 1048 if (!memcmp(idef->ipx_node, "\000\000\000\000\000\000", 1049 IPX_NODE_LEN)) { 1050 memset(intrfc->if_node, 0, IPX_NODE_LEN); 1051 memcpy(intrfc->if_node + IPX_NODE_LEN - dev->addr_len, 1052 dev->dev_addr, dev->addr_len); 1053 } else 1054 memcpy(intrfc->if_node, idef->ipx_node, IPX_NODE_LEN); 1055 ipxitf_hold(intrfc); 1056 ipxitf_insert(intrfc); 1057 } 1058 1059 1060 /* If the network number is known, add a route */ 1061 rc = 0; 1062 if (!intrfc->if_netnum) 1063 goto out_intrfc; 1064 1065 rc = ipxitf_add_local_route(intrfc); 1066out_intrfc: 1067 ipxitf_put(intrfc); 1068 goto out; 1069out_dev: 1070 dev_put(dev); 1071out: 1072 return rc; 1073} 1074 1075static int ipxitf_delete(struct ipx_interface_definition *idef) 1076{ 1077 struct net_device *dev = NULL; 1078 __be16 dlink_type = 0; 1079 struct ipx_interface *intrfc; 1080 int rc = 0; 1081 1082 spin_lock_bh(&ipx_interfaces_lock); 1083 if (idef->ipx_special == IPX_INTERNAL) { 1084 if (ipx_internal_net) { 1085 __ipxitf_put(ipx_internal_net); 1086 goto out; 1087 } 1088 rc = -ENOENT; 1089 goto out; 1090 } 1091 1092 dlink_type = ipx_map_frame_type(idef->ipx_dlink_type); 1093 rc = -EPROTONOSUPPORT; 1094 if (!dlink_type) 1095 goto out; 1096 1097 dev = __dev_get_by_name(idef->ipx_device); 1098 rc = -ENODEV; 1099 if (!dev) 1100 goto out; 1101 1102 intrfc = __ipxitf_find_using_phys(dev, dlink_type); 1103 rc = -EINVAL; 1104 if (!intrfc) 1105 goto out; 1106 __ipxitf_put(intrfc); 1107 1108 rc = 0; 1109out: 1110 spin_unlock_bh(&ipx_interfaces_lock); 1111 return rc; 1112} 1113 1114static struct ipx_interface *ipxitf_auto_create(struct net_device *dev, 1115 __be16 dlink_type) 1116{ 1117 struct ipx_interface *intrfc = NULL; 1118 struct datalink_proto *datalink; 1119 1120 if (!dev) 1121 goto out; 1122 1123 /* Check addresses are suitable */ 1124 if (dev->addr_len > IPX_NODE_LEN) 1125 goto out; 1126 1127 switch (ntohs(dlink_type)) { 1128 case ETH_P_IPX: datalink = pEII_datalink; break; 1129 case ETH_P_802_2: datalink = p8022_datalink; break; 1130 case ETH_P_SNAP: datalink = pSNAP_datalink; break; 1131 case ETH_P_802_3: datalink = p8023_datalink; break; 1132 default: goto out; 1133 } 1134 1135 intrfc = ipxitf_alloc(dev, 0, dlink_type, datalink, 0, 1136 dev->hard_header_len + datalink->header_length); 1137 1138 if (intrfc) { 1139 memset(intrfc->if_node, 0, IPX_NODE_LEN); 1140 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 1141 dev->dev_addr, dev->addr_len); 1142 spin_lock_init(&intrfc->if_sklist_lock); 1143 atomic_set(&intrfc->refcnt, 1); 1144 ipxitf_insert(intrfc); 1145 dev_hold(dev); 1146 } 1147 1148out: 1149 return intrfc; 1150} 1151 1152static int ipxitf_ioctl(unsigned int cmd, void __user *arg) 1153{ 1154 int rc = -EINVAL; 1155 struct ifreq ifr; 1156 int val; 1157 1158 switch (cmd) { 1159 case SIOCSIFADDR: { 1160 struct sockaddr_ipx *sipx; 1161 struct ipx_interface_definition f; 1162 1163 rc = -EFAULT; 1164 if (copy_from_user(&ifr, arg, sizeof(ifr))) 1165 break; 1166 sipx = (struct sockaddr_ipx *)&ifr.ifr_addr; 1167 rc = -EINVAL; 1168 if (sipx->sipx_family != AF_IPX) 1169 break; 1170 f.ipx_network = sipx->sipx_network; 1171 memcpy(f.ipx_device, ifr.ifr_name, 1172 sizeof(f.ipx_device)); 1173 memcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN); 1174 f.ipx_dlink_type = sipx->sipx_type; 1175 f.ipx_special = sipx->sipx_special; 1176 1177 if (sipx->sipx_action == IPX_DLTITF) 1178 rc = ipxitf_delete(&f); 1179 else 1180 rc = ipxitf_create(&f); 1181 break; 1182 } 1183 case SIOCGIFADDR: { 1184 struct sockaddr_ipx *sipx; 1185 struct ipx_interface *ipxif; 1186 struct net_device *dev; 1187 1188 rc = -EFAULT; 1189 if (copy_from_user(&ifr, arg, sizeof(ifr))) 1190 break; 1191 sipx = (struct sockaddr_ipx *)&ifr.ifr_addr; 1192 dev = __dev_get_by_name(ifr.ifr_name); 1193 rc = -ENODEV; 1194 if (!dev) 1195 break; 1196 ipxif = ipxitf_find_using_phys(dev, 1197 ipx_map_frame_type(sipx->sipx_type)); 1198 rc = -EADDRNOTAVAIL; 1199 if (!ipxif) 1200 break; 1201 1202 sipx->sipx_family = AF_IPX; 1203 sipx->sipx_network = ipxif->if_netnum; 1204 memcpy(sipx->sipx_node, ipxif->if_node, 1205 sizeof(sipx->sipx_node)); 1206 rc = -EFAULT; 1207 if (copy_to_user(arg, &ifr, sizeof(ifr))) 1208 break; 1209 ipxitf_put(ipxif); 1210 rc = 0; 1211 break; 1212 } 1213 case SIOCAIPXITFCRT: 1214 rc = -EFAULT; 1215 if (get_user(val, (unsigned char __user *) arg)) 1216 break; 1217 rc = 0; 1218 ipxcfg_auto_create_interfaces = val; 1219 break; 1220 case SIOCAIPXPRISLT: 1221 rc = -EFAULT; 1222 if (get_user(val, (unsigned char __user *) arg)) 1223 break; 1224 rc = 0; 1225 ipxcfg_set_auto_select(val); 1226 break; 1227 } 1228 1229 return rc; 1230} 1231 1232/* 1233 * Checksum routine for IPX 1234 */ 1235 1236/* Note: We assume ipx_tctrl==0 and htons(length)==ipx_pktsize */ 1237/* This functions should *not* mess with packet contents */ 1238 1239__be16 ipx_cksum(struct ipxhdr *packet, int length) 1240{ 1241 /* 1242 * NOTE: sum is a net byte order quantity, which optimizes the 1243 * loop. This only works on big and little endian machines. (I 1244 * don't know of a machine that isn't.) 1245 */ 1246 /* handle the first 3 words separately; checksum should be skipped 1247 * and ipx_tctrl masked out */ 1248 __u16 *p = (__u16 *)packet; 1249 __u32 sum = p[1] + (p[2] & (__force u16)htons(0x00ff)); 1250 __u32 i = (length >> 1) - 3; /* Number of remaining complete words */ 1251 1252 /* Loop through them */ 1253 p += 3; 1254 while (i--) 1255 sum += *p++; 1256 1257 /* Add on the last part word if it exists */ 1258 if (packet->ipx_pktsize & htons(1)) 1259 sum += (__force u16)htons(0xff00) & *p; 1260 1261 /* Do final fixup */ 1262 sum = (sum & 0xffff) + (sum >> 16); 1263 1264 /* It's a pity there's no concept of carry in C */ 1265 if (sum >= 0x10000) 1266 sum++; 1267 1268 /* 1269 * Leave 0 alone; we don't want 0xffff here. Note that we can't get 1270 * here with 0x10000, so this check is the same as ((__u16)sum) 1271 */ 1272 if (sum) 1273 sum = ~sum; 1274 1275 return (__force __be16)sum; 1276} 1277 1278const char *ipx_frame_name(__be16 frame) 1279{ 1280 char* rc = "None"; 1281 1282 switch (ntohs(frame)) { 1283 case ETH_P_IPX: rc = "EtherII"; break; 1284 case ETH_P_802_2: rc = "802.2"; break; 1285 case ETH_P_SNAP: rc = "SNAP"; break; 1286 case ETH_P_802_3: rc = "802.3"; break; 1287 case ETH_P_TR_802_2: rc = "802.2TR"; break; 1288 } 1289 1290 return rc; 1291} 1292 1293const char *ipx_device_name(struct ipx_interface *intrfc) 1294{ 1295 return intrfc->if_internal ? "Internal" : 1296 intrfc->if_dev ? intrfc->if_dev->name : "Unknown"; 1297} 1298 1299/* Handling for system calls applied via the various interfaces to an IPX 1300 * socket object. */ 1301 1302static int ipx_setsockopt(struct socket *sock, int level, int optname, 1303 char __user *optval, int optlen) 1304{ 1305 struct sock *sk = sock->sk; 1306 int opt; 1307 int rc = -EINVAL; 1308 1309 if (optlen != sizeof(int)) 1310 goto out; 1311 1312 rc = -EFAULT; 1313 if (get_user(opt, (unsigned int __user *)optval)) 1314 goto out; 1315 1316 rc = -ENOPROTOOPT; 1317 if (!(level == SOL_IPX && optname == IPX_TYPE)) 1318 goto out; 1319 1320 ipx_sk(sk)->type = opt; 1321 rc = 0; 1322out: 1323 return rc; 1324} 1325 1326static int ipx_getsockopt(struct socket *sock, int level, int optname, 1327 char __user *optval, int __user *optlen) 1328{ 1329 struct sock *sk = sock->sk; 1330 int val = 0; 1331 int len; 1332 int rc = -ENOPROTOOPT; 1333 1334 if (!(level == SOL_IPX && optname == IPX_TYPE)) 1335 goto out; 1336 1337 val = ipx_sk(sk)->type; 1338 1339 rc = -EFAULT; 1340 if (get_user(len, optlen)) 1341 goto out; 1342 1343 len = min_t(unsigned int, len, sizeof(int)); 1344 rc = -EINVAL; 1345 if(len < 0) 1346 goto out; 1347 1348 rc = -EFAULT; 1349 if (put_user(len, optlen) || copy_to_user(optval, &val, len)) 1350 goto out; 1351 1352 rc = 0; 1353out: 1354 return rc; 1355} 1356 1357static struct proto ipx_proto = { 1358 .name = "IPX", 1359 .owner = THIS_MODULE, 1360 .obj_size = sizeof(struct ipx_sock), 1361}; 1362 1363static int ipx_create(struct socket *sock, int protocol) 1364{ 1365 int rc = -ESOCKTNOSUPPORT; 1366 struct sock *sk; 1367 1368 /* 1369 * SPX support is not anymore in the kernel sources. If you want to 1370 * ressurrect it, completing it and making it understand shared skbs, 1371 * be fully multithreaded, etc, grab the sources in an early 2.5 kernel 1372 * tree. 1373 */ 1374 if (sock->type != SOCK_DGRAM) 1375 goto out; 1376 1377 rc = -ENOMEM; 1378 sk = sk_alloc(PF_IPX, GFP_KERNEL, &ipx_proto, 1); 1379 if (!sk) 1380 goto out; 1381#ifdef IPX_REFCNT_DEBUG 1382 atomic_inc(&ipx_sock_nr); 1383 printk(KERN_DEBUG "IPX socket %p created, now we have %d alive\n", sk, 1384 atomic_read(&ipx_sock_nr)); 1385#endif 1386 sock_init_data(sock, sk); 1387 sk->sk_no_check = 1; /* Checksum off by default */ 1388 sock->ops = &ipx_dgram_ops; 1389 rc = 0; 1390out: 1391 return rc; 1392} 1393 1394static int ipx_release(struct socket *sock) 1395{ 1396 struct sock *sk = sock->sk; 1397 1398 if (!sk) 1399 goto out; 1400 1401 if (!sock_flag(sk, SOCK_DEAD)) 1402 sk->sk_state_change(sk); 1403 1404 sock_set_flag(sk, SOCK_DEAD); 1405 sock->sk = NULL; 1406 ipx_destroy_socket(sk); 1407out: 1408 return 0; 1409} 1410 1411/* caller must hold a reference to intrfc */ 1412 1413static __be16 ipx_first_free_socketnum(struct ipx_interface *intrfc) 1414{ 1415 unsigned short socketNum = intrfc->if_sknum; 1416 1417 spin_lock_bh(&intrfc->if_sklist_lock); 1418 1419 if (socketNum < IPX_MIN_EPHEMERAL_SOCKET) 1420 socketNum = IPX_MIN_EPHEMERAL_SOCKET; 1421 1422 while (__ipxitf_find_socket(intrfc, htons(socketNum))) 1423 if (socketNum > IPX_MAX_EPHEMERAL_SOCKET) 1424 socketNum = IPX_MIN_EPHEMERAL_SOCKET; 1425 else 1426 socketNum++; 1427 1428 spin_unlock_bh(&intrfc->if_sklist_lock); 1429 intrfc->if_sknum = socketNum; 1430 1431 return htons(socketNum); 1432} 1433 1434static int ipx_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len) 1435{ 1436 struct sock *sk = sock->sk; 1437 struct ipx_sock *ipxs = ipx_sk(sk); 1438 struct ipx_interface *intrfc; 1439 struct sockaddr_ipx *addr = (struct sockaddr_ipx *)uaddr; 1440 int rc = -EINVAL; 1441 1442 if (!sock_flag(sk, SOCK_ZAPPED) || addr_len != sizeof(struct sockaddr_ipx)) 1443 goto out; 1444 1445 intrfc = ipxitf_find_using_net(addr->sipx_network); 1446 rc = -EADDRNOTAVAIL; 1447 if (!intrfc) 1448 goto out; 1449 1450 if (!addr->sipx_port) { 1451 addr->sipx_port = ipx_first_free_socketnum(intrfc); 1452 rc = -EINVAL; 1453 if (!addr->sipx_port) 1454 goto out_put; 1455 } 1456 1457 /* protect IPX system stuff like routing/sap */ 1458 rc = -EACCES; 1459 if (ntohs(addr->sipx_port) < IPX_MIN_EPHEMERAL_SOCKET && 1460 !capable(CAP_NET_ADMIN)) 1461 goto out_put; 1462 1463 ipxs->port = addr->sipx_port; 1464 1465#ifdef CONFIG_IPX_INTERN 1466 if (intrfc == ipx_internal_net) { 1467 /* The source address is to be set explicitly if the 1468 * socket is to be bound on the internal network. If a 1469 * node number 0 was specified, the default is used. 1470 */ 1471 1472 rc = -EINVAL; 1473 if (!memcmp(addr->sipx_node, ipx_broadcast_node, IPX_NODE_LEN)) 1474 goto out_put; 1475 if (!memcmp(addr->sipx_node, ipx_this_node, IPX_NODE_LEN)) 1476 memcpy(ipxs->node, intrfc->if_node, IPX_NODE_LEN); 1477 else 1478 memcpy(ipxs->node, addr->sipx_node, IPX_NODE_LEN); 1479 1480 rc = -EADDRINUSE; 1481 if (ipxitf_find_internal_socket(intrfc, ipxs->node, 1482 ipxs->port)) { 1483 SOCK_DEBUG(sk, 1484 "IPX: bind failed because port %X in use.\n", 1485 ntohs(addr->sipx_port)); 1486 goto out_put; 1487 } 1488 } else { 1489 /* Source addresses are easy. It must be our 1490 * network:node pair for an interface routed to IPX 1491 * with the ipx routing ioctl() 1492 */ 1493 1494 memcpy(ipxs->node, intrfc->if_node, IPX_NODE_LEN); 1495 1496 rc = -EADDRINUSE; 1497 if (ipxitf_find_socket(intrfc, addr->sipx_port)) { 1498 SOCK_DEBUG(sk, 1499 "IPX: bind failed because port %X in use.\n", 1500 ntohs(addr->sipx_port)); 1501 goto out_put; 1502 } 1503 } 1504 1505#else /* !def CONFIG_IPX_INTERN */ 1506 1507 /* Source addresses are easy. It must be our network:node pair for 1508 an interface routed to IPX with the ipx routing ioctl() */ 1509 1510 rc = -EADDRINUSE; 1511 if (ipxitf_find_socket(intrfc, addr->sipx_port)) { 1512 SOCK_DEBUG(sk, "IPX: bind failed because port %X in use.\n", 1513 ntohs((int)addr->sipx_port)); 1514 goto out_put; 1515 } 1516 1517#endif /* CONFIG_IPX_INTERN */ 1518 1519 ipxitf_insert_socket(intrfc, sk); 1520 sock_reset_flag(sk, SOCK_ZAPPED); 1521 1522 rc = 0; 1523out_put: 1524 ipxitf_put(intrfc); 1525out: 1526 return rc; 1527} 1528 1529static int ipx_connect(struct socket *sock, struct sockaddr *uaddr, 1530 int addr_len, int flags) 1531{ 1532 struct sock *sk = sock->sk; 1533 struct ipx_sock *ipxs = ipx_sk(sk); 1534 struct sockaddr_ipx *addr; 1535 int rc = -EINVAL; 1536 struct ipx_route *rt; 1537 1538 sk->sk_state = TCP_CLOSE; 1539 sock->state = SS_UNCONNECTED; 1540 1541 if (addr_len != sizeof(*addr)) 1542 goto out; 1543 addr = (struct sockaddr_ipx *)uaddr; 1544 1545 /* put the autobinding in */ 1546 if (!ipxs->port) { 1547 struct sockaddr_ipx uaddr; 1548 1549 uaddr.sipx_port = 0; 1550 uaddr.sipx_network = 0; 1551 1552#ifdef CONFIG_IPX_INTERN 1553 rc = -ENETDOWN; 1554 if (!ipxs->intrfc) 1555 goto out; /* Someone zonked the iface */ 1556 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node, 1557 IPX_NODE_LEN); 1558#endif /* CONFIG_IPX_INTERN */ 1559 1560 rc = ipx_bind(sock, (struct sockaddr *)&uaddr, 1561 sizeof(struct sockaddr_ipx)); 1562 if (rc) 1563 goto out; 1564 } 1565 1566 /* We can either connect to primary network or somewhere 1567 * we can route to */ 1568 rt = ipxrtr_lookup(addr->sipx_network); 1569 rc = -ENETUNREACH; 1570 if (!rt && !(!addr->sipx_network && ipx_primary_net)) 1571 goto out; 1572 1573 ipxs->dest_addr.net = addr->sipx_network; 1574 ipxs->dest_addr.sock = addr->sipx_port; 1575 memcpy(ipxs->dest_addr.node, addr->sipx_node, IPX_NODE_LEN); 1576 ipxs->type = addr->sipx_type; 1577 1578 if (sock->type == SOCK_DGRAM) { 1579 sock->state = SS_CONNECTED; 1580 sk->sk_state = TCP_ESTABLISHED; 1581 } 1582 1583 if (rt) 1584 ipxrtr_put(rt); 1585 rc = 0; 1586out: 1587 return rc; 1588} 1589 1590 1591static int ipx_getname(struct socket *sock, struct sockaddr *uaddr, 1592 int *uaddr_len, int peer) 1593{ 1594 struct ipx_address *addr; 1595 struct sockaddr_ipx sipx; 1596 struct sock *sk = sock->sk; 1597 struct ipx_sock *ipxs = ipx_sk(sk); 1598 int rc; 1599 1600 *uaddr_len = sizeof(struct sockaddr_ipx); 1601 1602 if (peer) { 1603 rc = -ENOTCONN; 1604 if (sk->sk_state != TCP_ESTABLISHED) 1605 goto out; 1606 1607 addr = &ipxs->dest_addr; 1608 sipx.sipx_network = addr->net; 1609 sipx.sipx_port = addr->sock; 1610 memcpy(sipx.sipx_node, addr->node, IPX_NODE_LEN); 1611 } else { 1612 if (ipxs->intrfc) { 1613 sipx.sipx_network = ipxs->intrfc->if_netnum; 1614#ifdef CONFIG_IPX_INTERN 1615 memcpy(sipx.sipx_node, ipxs->node, IPX_NODE_LEN); 1616#else 1617 memcpy(sipx.sipx_node, ipxs->intrfc->if_node, 1618 IPX_NODE_LEN); 1619#endif /* CONFIG_IPX_INTERN */ 1620 1621 } else { 1622 sipx.sipx_network = 0; 1623 memset(sipx.sipx_node, '\0', IPX_NODE_LEN); 1624 } 1625 1626 sipx.sipx_port = ipxs->port; 1627 } 1628 1629 sipx.sipx_family = AF_IPX; 1630 sipx.sipx_type = ipxs->type; 1631 sipx.sipx_zero = 0; 1632 memcpy(uaddr, &sipx, sizeof(sipx)); 1633 1634 rc = 0; 1635out: 1636 return rc; 1637} 1638 1639static int ipx_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev) 1640{ 1641 /* NULL here for pt means the packet was looped back */ 1642 struct ipx_interface *intrfc; 1643 struct ipxhdr *ipx; 1644 u16 ipx_pktsize; 1645 int rc = 0; 1646 1647 /* Not ours */ 1648 if (skb->pkt_type == PACKET_OTHERHOST) 1649 goto drop; 1650 1651 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) 1652 goto out; 1653 1654 if (!pskb_may_pull(skb, sizeof(struct ipxhdr))) 1655 goto drop; 1656 1657 ipx_pktsize = ntohs(ipx_hdr(skb)->ipx_pktsize); 1658 1659 /* Too small or invalid header? */ 1660 if (ipx_pktsize < sizeof(struct ipxhdr) || 1661 !pskb_may_pull(skb, ipx_pktsize)) 1662 goto drop; 1663 1664 ipx = ipx_hdr(skb); 1665 if (ipx->ipx_checksum != IPX_NO_CHECKSUM && 1666 ipx->ipx_checksum != ipx_cksum(ipx, ipx_pktsize)) 1667 goto drop; 1668 1669 IPX_SKB_CB(skb)->ipx_tctrl = ipx->ipx_tctrl; 1670 IPX_SKB_CB(skb)->ipx_dest_net = ipx->ipx_dest.net; 1671 IPX_SKB_CB(skb)->ipx_source_net = ipx->ipx_source.net; 1672 1673 /* Determine what local ipx endpoint this is */ 1674 intrfc = ipxitf_find_using_phys(dev, pt->type); 1675 if (!intrfc) { 1676 if (ipxcfg_auto_create_interfaces && 1677 IPX_SKB_CB(skb)->ipx_dest_net) { 1678 intrfc = ipxitf_auto_create(dev, pt->type); 1679 if (intrfc) 1680 ipxitf_hold(intrfc); 1681 } 1682 1683 if (!intrfc) /* Not one of ours */ 1684 /* or invalid packet for auto creation */ 1685 goto drop; 1686 } 1687 1688 rc = ipxitf_rcv(intrfc, skb); 1689 ipxitf_put(intrfc); 1690 goto out; 1691drop: 1692 kfree_skb(skb); 1693out: 1694 return rc; 1695} 1696 1697static int ipx_sendmsg(struct kiocb *iocb, struct socket *sock, 1698 struct msghdr *msg, size_t len) 1699{ 1700 struct sock *sk = sock->sk; 1701 struct ipx_sock *ipxs = ipx_sk(sk); 1702 struct sockaddr_ipx *usipx = (struct sockaddr_ipx *)msg->msg_name; 1703 struct sockaddr_ipx local_sipx; 1704 int rc = -EINVAL; 1705 int flags = msg->msg_flags; 1706 1707 /* Socket gets bound below anyway */ 1708/* if (sk->sk_zapped) 1709 return -EIO; */ /* Socket not bound */ 1710 if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT)) 1711 goto out; 1712 1713 /* Max possible packet size limited by 16 bit pktsize in header */ 1714 if (len >= 65535 - sizeof(struct ipxhdr)) 1715 goto out; 1716 1717 if (usipx) { 1718 if (!ipxs->port) { 1719 struct sockaddr_ipx uaddr; 1720 1721 uaddr.sipx_port = 0; 1722 uaddr.sipx_network = 0; 1723#ifdef CONFIG_IPX_INTERN 1724 rc = -ENETDOWN; 1725 if (!ipxs->intrfc) 1726 goto out; /* Someone zonked the iface */ 1727 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node, 1728 IPX_NODE_LEN); 1729#endif 1730 rc = ipx_bind(sock, (struct sockaddr *)&uaddr, 1731 sizeof(struct sockaddr_ipx)); 1732 if (rc) 1733 goto out; 1734 } 1735 1736 rc = -EINVAL; 1737 if (msg->msg_namelen < sizeof(*usipx) || 1738 usipx->sipx_family != AF_IPX) 1739 goto out; 1740 } else { 1741 rc = -ENOTCONN; 1742 if (sk->sk_state != TCP_ESTABLISHED) 1743 goto out; 1744 1745 usipx = &local_sipx; 1746 usipx->sipx_family = AF_IPX; 1747 usipx->sipx_type = ipxs->type; 1748 usipx->sipx_port = ipxs->dest_addr.sock; 1749 usipx->sipx_network = ipxs->dest_addr.net; 1750 memcpy(usipx->sipx_node, ipxs->dest_addr.node, IPX_NODE_LEN); 1751 } 1752 1753 rc = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len, 1754 flags & MSG_DONTWAIT); 1755 if (rc >= 0) 1756 rc = len; 1757out: 1758 return rc; 1759} 1760 1761 1762static int ipx_recvmsg(struct kiocb *iocb, struct socket *sock, 1763 struct msghdr *msg, size_t size, int flags) 1764{ 1765 struct sock *sk = sock->sk; 1766 struct ipx_sock *ipxs = ipx_sk(sk); 1767 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *)msg->msg_name; 1768 struct ipxhdr *ipx = NULL; 1769 struct sk_buff *skb; 1770 int copied, rc; 1771 1772 /* put the autobinding in */ 1773 if (!ipxs->port) { 1774 struct sockaddr_ipx uaddr; 1775 1776 uaddr.sipx_port = 0; 1777 uaddr.sipx_network = 0; 1778 1779#ifdef CONFIG_IPX_INTERN 1780 rc = -ENETDOWN; 1781 if (!ipxs->intrfc) 1782 goto out; /* Someone zonked the iface */ 1783 memcpy(uaddr.sipx_node, ipxs->intrfc->if_node, IPX_NODE_LEN); 1784#endif /* CONFIG_IPX_INTERN */ 1785 1786 rc = ipx_bind(sock, (struct sockaddr *)&uaddr, 1787 sizeof(struct sockaddr_ipx)); 1788 if (rc) 1789 goto out; 1790 } 1791 1792 rc = -ENOTCONN; 1793 if (sock_flag(sk, SOCK_ZAPPED)) 1794 goto out; 1795 1796 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, 1797 flags & MSG_DONTWAIT, &rc); 1798 if (!skb) 1799 goto out; 1800 1801 ipx = ipx_hdr(skb); 1802 copied = ntohs(ipx->ipx_pktsize) - sizeof(struct ipxhdr); 1803 if (copied > size) { 1804 copied = size; 1805 msg->msg_flags |= MSG_TRUNC; 1806 } 1807 1808 rc = skb_copy_datagram_iovec(skb, sizeof(struct ipxhdr), msg->msg_iov, 1809 copied); 1810 if (rc) 1811 goto out_free; 1812 if (skb->tstamp.tv64) 1813 sk->sk_stamp = skb->tstamp; 1814 1815 msg->msg_namelen = sizeof(*sipx); 1816 1817 if (sipx) { 1818 sipx->sipx_family = AF_IPX; 1819 sipx->sipx_port = ipx->ipx_source.sock; 1820 memcpy(sipx->sipx_node, ipx->ipx_source.node, IPX_NODE_LEN); 1821 sipx->sipx_network = IPX_SKB_CB(skb)->ipx_source_net; 1822 sipx->sipx_type = ipx->ipx_type; 1823 sipx->sipx_zero = 0; 1824 } 1825 rc = copied; 1826 1827out_free: 1828 skb_free_datagram(sk, skb); 1829out: 1830 return rc; 1831} 1832 1833 1834static int ipx_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1835{ 1836 int rc = 0; 1837 long amount = 0; 1838 struct sock *sk = sock->sk; 1839 void __user *argp = (void __user *)arg; 1840 1841 switch (cmd) { 1842 case TIOCOUTQ: 1843 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); 1844 if (amount < 0) 1845 amount = 0; 1846 rc = put_user(amount, (int __user *)argp); 1847 break; 1848 case TIOCINQ: { 1849 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue); 1850 /* These two are safe on a single CPU system as only 1851 * user tasks fiddle here */ 1852 if (skb) 1853 amount = skb->len - sizeof(struct ipxhdr); 1854 rc = put_user(amount, (int __user *)argp); 1855 break; 1856 } 1857 case SIOCADDRT: 1858 case SIOCDELRT: 1859 rc = -EPERM; 1860 if (capable(CAP_NET_ADMIN)) 1861 rc = ipxrtr_ioctl(cmd, argp); 1862 break; 1863 case SIOCSIFADDR: 1864 case SIOCAIPXITFCRT: 1865 case SIOCAIPXPRISLT: 1866 rc = -EPERM; 1867 if (!capable(CAP_NET_ADMIN)) 1868 break; 1869 case SIOCGIFADDR: 1870 rc = ipxitf_ioctl(cmd, argp); 1871 break; 1872 case SIOCIPXCFGDATA: 1873 rc = ipxcfg_get_config_data(argp); 1874 break; 1875 case SIOCIPXNCPCONN: 1876 /* 1877 * This socket wants to take care of the NCP connection 1878 * handed to us in arg. 1879 */ 1880 rc = -EPERM; 1881 if (!capable(CAP_NET_ADMIN)) 1882 break; 1883 rc = get_user(ipx_sk(sk)->ipx_ncp_conn, 1884 (const unsigned short __user *)argp); 1885 break; 1886 case SIOCGSTAMP: 1887 rc = -EINVAL; 1888 if (sk) 1889 rc = sock_get_timestamp(sk, argp); 1890 break; 1891 case SIOCGIFDSTADDR: 1892 case SIOCSIFDSTADDR: 1893 case SIOCGIFBRDADDR: 1894 case SIOCSIFBRDADDR: 1895 case SIOCGIFNETMASK: 1896 case SIOCSIFNETMASK: 1897 rc = -EINVAL; 1898 break; 1899 default: 1900 rc = -ENOIOCTLCMD; 1901 break; 1902 } 1903 1904 return rc; 1905} 1906 1907 1908#ifdef CONFIG_COMPAT 1909static int ipx_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1910{ 1911 /* 1912 * These 4 commands use same structure on 32bit and 64bit. Rest of IPX 1913 * commands is handled by generic ioctl code. As these commands are 1914 * SIOCPROTOPRIVATE..SIOCPROTOPRIVATE+3, they cannot be handled by generic 1915 * code. 1916 */ 1917 switch (cmd) { 1918 case SIOCAIPXITFCRT: 1919 case SIOCAIPXPRISLT: 1920 case SIOCIPXCFGDATA: 1921 case SIOCIPXNCPCONN: 1922 return ipx_ioctl(sock, cmd, arg); 1923 default: 1924 return -ENOIOCTLCMD; 1925 } 1926} 1927#endif 1928 1929 1930/* 1931 * Socket family declarations 1932 */ 1933 1934static struct net_proto_family ipx_family_ops = { 1935 .family = PF_IPX, 1936 .create = ipx_create, 1937 .owner = THIS_MODULE, 1938}; 1939 1940static const struct proto_ops SOCKOPS_WRAPPED(ipx_dgram_ops) = { 1941 .family = PF_IPX, 1942 .owner = THIS_MODULE, 1943 .release = ipx_release, 1944 .bind = ipx_bind, 1945 .connect = ipx_connect, 1946 .socketpair = sock_no_socketpair, 1947 .accept = sock_no_accept, 1948 .getname = ipx_getname, 1949 .poll = datagram_poll, 1950 .ioctl = ipx_ioctl, 1951#ifdef CONFIG_COMPAT 1952 .compat_ioctl = ipx_compat_ioctl, 1953#endif 1954 .listen = sock_no_listen, 1955 .shutdown = sock_no_shutdown, 1956 .setsockopt = ipx_setsockopt, 1957 .getsockopt = ipx_getsockopt, 1958 .sendmsg = ipx_sendmsg, 1959 .recvmsg = ipx_recvmsg, 1960 .mmap = sock_no_mmap, 1961 .sendpage = sock_no_sendpage, 1962}; 1963 1964SOCKOPS_WRAP(ipx_dgram, PF_IPX); 1965 1966static struct packet_type ipx_8023_packet_type = { 1967 .type = __constant_htons(ETH_P_802_3), 1968 .func = ipx_rcv, 1969}; 1970 1971static struct packet_type ipx_dix_packet_type = { 1972 .type = __constant_htons(ETH_P_IPX), 1973 .func = ipx_rcv, 1974}; 1975 1976static struct notifier_block ipx_dev_notifier = { 1977 .notifier_call = ipxitf_device_event, 1978}; 1979 1980extern struct datalink_proto *make_EII_client(void); 1981extern void destroy_EII_client(struct datalink_proto *); 1982 1983static unsigned char ipx_8022_type = 0xE0; 1984static unsigned char ipx_snap_id[5] = { 0x0, 0x0, 0x0, 0x81, 0x37 }; 1985static char ipx_EII_err_msg[] __initdata = 1986 KERN_CRIT "IPX: Unable to register with Ethernet II\n"; 1987static char ipx_8023_err_msg[] __initdata = 1988 KERN_CRIT "IPX: Unable to register with 802.3\n"; 1989static char ipx_llc_err_msg[] __initdata = 1990 KERN_CRIT "IPX: Unable to register with 802.2\n"; 1991static char ipx_snap_err_msg[] __initdata = 1992 KERN_CRIT "IPX: Unable to register with SNAP\n"; 1993 1994static int __init ipx_init(void) 1995{ 1996 int rc = proto_register(&ipx_proto, 1); 1997 1998 if (rc != 0) 1999 goto out; 2000 2001 sock_register(&ipx_family_ops); 2002 2003 pEII_datalink = make_EII_client(); 2004 if (pEII_datalink) 2005 dev_add_pack(&ipx_dix_packet_type); 2006 else 2007 printk(ipx_EII_err_msg); 2008 2009 p8023_datalink = make_8023_client(); 2010 if (p8023_datalink) 2011 dev_add_pack(&ipx_8023_packet_type); 2012 else 2013 printk(ipx_8023_err_msg); 2014 2015 p8022_datalink = register_8022_client(ipx_8022_type, ipx_rcv); 2016 if (!p8022_datalink) 2017 printk(ipx_llc_err_msg); 2018 2019 pSNAP_datalink = register_snap_client(ipx_snap_id, ipx_rcv); 2020 if (!pSNAP_datalink) 2021 printk(ipx_snap_err_msg); 2022 2023 register_netdevice_notifier(&ipx_dev_notifier); 2024 ipx_register_sysctl(); 2025 ipx_proc_init(); 2026out: 2027 return rc; 2028} 2029 2030static void __exit ipx_proto_finito(void) 2031{ 2032 ipx_proc_exit(); 2033 ipx_unregister_sysctl(); 2034 2035 unregister_netdevice_notifier(&ipx_dev_notifier); 2036 2037 ipxitf_cleanup(); 2038 2039 if (pSNAP_datalink) { 2040 unregister_snap_client(pSNAP_datalink); 2041 pSNAP_datalink = NULL; 2042 } 2043 2044 if (p8022_datalink) { 2045 unregister_8022_client(p8022_datalink); 2046 p8022_datalink = NULL; 2047 } 2048 2049 dev_remove_pack(&ipx_8023_packet_type); 2050 if (p8023_datalink) { 2051 destroy_8023_client(p8023_datalink); 2052 p8023_datalink = NULL; 2053 } 2054 2055 dev_remove_pack(&ipx_dix_packet_type); 2056 if (pEII_datalink) { 2057 destroy_EII_client(pEII_datalink); 2058 pEII_datalink = NULL; 2059 } 2060 2061 proto_unregister(&ipx_proto); 2062 sock_unregister(ipx_family_ops.family); 2063} 2064 2065module_init(ipx_init); 2066module_exit(ipx_proto_finito); 2067MODULE_LICENSE("GPL"); 2068MODULE_ALIAS_NETPROTO(PF_IPX); 2069