net/ipx/af

/* */
This source file includes following definitions.
ipxcfg_set_auto_create
ipxcfg_set_auto_select
ipxcfg_get_config_data
ipx_remove_socket
ipx_destroy_socket
ipxitf_clear_primary_net
ipxitf_find_using_phys
ipxitf_find_using_net
ipxitf_insert_socket
ipxitf_find_socket
ipxitf_find_internal_socket
ipxitf_down
ipxitf_device_event
ipxitf_def_skb_handler
ipxitf_demux_socket
ipxitf_demux_socket
ipxitf_adjust_skbuff
ipxitf_send
ipxitf_add_local_route
ipxitf_rcv
ipxitf_insert
ipxitf_create_internal
ipx_map_frame_type
ipxitf_create
ipxitf_delete
ipxitf_auto_create
ipxitf_ioctl
ipxrtr_lookup
ipxrtr_add_route
ipxrtr_del_routes
ipxrtr_create
ipxrtr_delete
ipxrtr_route_packet
ipxrtr_route_skb
ipxrtr_ioctl
ipx_frame_name
ipx_device_name
ipx_interface_get_info
ipx_get_info
ipx_rt_get_info
ipx_fcntl
ipx_setsockopt
ipx_getsockopt
ipx_listen
def_callback1
def_callback2
ipx_create
ipx_release
ipx_dup
ipx_first_free_socketnum
ipx_bind
ipx_connect
ipx_socketpair
ipx_accept
ipx_getname
dump_data
dump_addr
dump_hdr
dump_pkt
ipx_rcv
ipx_sendmsg
ipx_recvmsg
ipx_shutdown
ipx_select
ipx_ioctl
ipx_proto_init
   1 /*
   2  *      Implements an IPX socket layer (badly - but I'm working on it).
   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 liability
  15  *      nor provide warranty for any of this software. This material is provided 
  16  *      as is and at no charge.         
  17  *
  18  *      Revision 0.21:  Uses the new generic socket option code.
  19  *      Revision 0.22:  Gcc clean ups and drop out device registration. Use the
  20  *                      new multi-protocol edition of hard_header 
  21  *      Revision 0.23:  IPX /proc by Mark Evans.
  22  *                      Adding a route will overwrite any existing route to the same
  23  *                      network.
  24  *      Revision 0.24:  Supports new /proc with no 4K limit
  25  *      Revision 0.25:  Add ephemeral sockets, passive local network 
  26  *                      identification, support for local net 0 and
  27  *                      multiple datalinks <Greg Page>
  28  *      Revision 0.26:  Device drop kills IPX routes via it. (needed for modules)
  29  *      Revision 0.27:  Autobind <Mark Evans>
  30  *      Revision 0.28:  Small fix for multiple local networks <Thomas Winder>
  31  *      Revision 0.29:  Assorted major errors removed <Mark Evans>
  32  *                      Small correction to promisc mode error fix <Alan Cox>
  33  *                      Asynchronous I/O support.
  34  *                      Changed to use notifiers and the newer packet_type stuff.
  35  *                      Assorted major fixes <Alejandro Liu>
  36  *      Revision 0.30:  Moved to net/ipx/...    <Alan Cox>
  37  *                      Don't set address length on recvfrom that errors.
  38  *                      Incorrect verify_area.
  39  *      Revision 0.31:  New sk_buffs. This still needs a lot of testing. <Alan Cox>
  40  *      Revision 0.32:  Using sock_alloc_send_skb, firewall hooks. <Alan Cox>
  41  *                      Supports sendmsg/recvmsg
  42  *
  43  *      Portions Copyright (c) 1995 Caldera, Inc. <greg@caldera.com>
  44  *      Neither Greg Page nor Caldera, Inc. admit liability nor provide 
  45  *      warranty for any of this software. This material is provided 
  46  *      "AS-IS" and at no charge.               
  47  */
  48   
  49 #include <linux/config.h>
  50 #include <linux/errno.h>
  51 #include <linux/types.h>
  52 #include <linux/socket.h>
  53 #include <linux/in.h>
  54 #include <linux/kernel.h>
  55 #include <linux/sched.h>
  56 #include <linux/timer.h>
  57 #include <linux/string.h>
  58 #include <linux/sockios.h>
  59 #include <linux/net.h>
  60 #include <linux/ipx.h>
  61 #include <linux/inet.h>
  62 #include <linux/netdevice.h>
  63 #include <linux/route.h>
  64 #include <linux/skbuff.h>
  65 #include <net/sock.h>
  66 #include <asm/segment.h>
  67 #include <asm/system.h>
  68 #include <linux/fcntl.h>
  69 #include <linux/mm.h>
  70 #include <linux/termios.h>      /* For TIOCOUTQ/INQ */
  71 #include <linux/interrupt.h>
  72 #include <net/p8022.h>
  73 #include <net/psnap.h>
  74 #include <linux/proc_fs.h>
  75 #include <linux/stat.h>
  76 #include <linux/firewall.h>
  77 
  78 #ifdef CONFIG_IPX
  79 /* Configuration Variables */
  80 static unsigned char    ipxcfg_max_hops = 16;
  81 static char             ipxcfg_auto_select_primary = 0;
  82 static char             ipxcfg_auto_create_interfaces = 0;
  83 
  84 /* Global Variables */
  85 static struct datalink_proto    *p8022_datalink = NULL;
  86 static struct datalink_proto    *pEII_datalink = NULL;
  87 static struct datalink_proto    *p8023_datalink = NULL;
  88 static struct datalink_proto    *pSNAP_datalink = NULL;
  89 
  90 static ipx_interface    *ipx_interfaces = NULL;
  91 static ipx_route        *ipx_routes = NULL;
  92 static ipx_interface    *ipx_internal_net = NULL;
  93 static ipx_interface    *ipx_primary_net = NULL;
  94 
  95 static int
  96 ipxcfg_set_auto_create(char val)
     /*  */
  97 {
  98         ipxcfg_auto_create_interfaces = val;
  99         return 0;
 100 }
 101                 
 102 static int
 103 ipxcfg_set_auto_select(char val)
     /*  */
 104 {
 105         ipxcfg_auto_select_primary = val;
 106         if (val && (ipx_primary_net == NULL))
 107                 ipx_primary_net = ipx_interfaces;
 108         return 0;
 109 }
 110 
 111 static int
 112 ipxcfg_get_config_data(ipx_config_data *arg)
     /*  */
 113 {
 114         ipx_config_data vals;
 115         
 116         vals.ipxcfg_auto_create_interfaces = ipxcfg_auto_create_interfaces;
 117         vals.ipxcfg_auto_select_primary = ipxcfg_auto_select_primary;
 118         memcpy_tofs(arg, &vals, sizeof(vals));
 119         return 0;
 120 }
 121 
 122 
 123 /***********************************************************************************************************************\
 124 *                                                                                                                       *
 125 *                                               Handlers for the socket list.                                           *
 126 *                                                                                                                       *
 127 \***********************************************************************************************************************/
 128 
 129 /*
 130  *      Note: Sockets may not be removed _during_ an interrupt or inet_bh
 131  *      handler using this technique. They can be added although we do not
 132  *      use this facility.
 133  */
 134  
 135 static void 
 136 ipx_remove_socket(ipx_socket *sk)
     /*  */
 137 {
 138         ipx_socket      *s;
 139         ipx_interface   *intrfc;
 140         unsigned long   flags;
 141 
 142         save_flags(flags);
 143         cli();
 144         
 145         /* Determine interface with which socket is associated */
 146         intrfc = sk->ipx_intrfc;
 147         if (intrfc == NULL) {
 148                 restore_flags(flags);
 149                 return;
 150         }
 151 
 152         s=intrfc->if_sklist;
 153         if(s==sk) {
 154                 intrfc->if_sklist=s->next;
 155                 restore_flags(flags);
 156                 return;
 157         } 
 158 
 159         while(s && s->next) {
 160                 if(s->next==sk) {
 161                         s->next=sk->next;
 162                         restore_flags(flags);
 163                         return;
 164                 }
 165                 s=s->next;
 166         }
 167         restore_flags(flags);
 168 }
 169 
 170 /*
 171  *      This is only called from user mode. Thus it protects itself against
 172  *      interrupt users but doesn't worry about being called during work.
 173  *      Once it is removed from the queue no interrupt or bottom half will
 174  *      touch it and we are (fairly 8-) ) safe.
 175  */
 176  
 177 static void 
 178 ipx_destroy_socket(ipx_socket *sk)
     /*  */
 179 {
 180         struct sk_buff  *skb;
 181 
 182         ipx_remove_socket(sk);
 183         while((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
 184                 kfree_skb(skb,FREE_READ);
 185         }
 186         
 187         kfree_s(sk,sizeof(*sk));
 188 }
 189         
 190 /* The following code is used to support IPX Interfaces (IPXITF).  An
 191  * IPX interface is defined by a physical device and a frame type.
 192  */
 193 
 194 static ipx_route * ipxrtr_lookup(unsigned long);
 195  
 196 static void
 197 ipxitf_clear_primary_net(void)
     /*  */
 198 {
 199         if (ipxcfg_auto_select_primary && (ipx_interfaces != NULL))
 200                 ipx_primary_net = ipx_interfaces;
 201         else
 202                 ipx_primary_net = NULL;
 203 }
 204 
 205 static ipx_interface *
 206 ipxitf_find_using_phys(struct device *dev, unsigned short datalink)
     /*  */
 207 {
 208         ipx_interface   *i;
 209 
 210         for (i=ipx_interfaces; 
 211                 i && ((i->if_dev!=dev) || (i->if_dlink_type!=datalink)); 
 212                 i=i->if_next)
 213                 ;
 214         return i;
 215 }
 216 
 217 static ipx_interface *
 218 ipxitf_find_using_net(unsigned long net)
     /*  */
 219 {
 220         ipx_interface   *i;
 221 
 222         if (net == 0L)
 223                 return ipx_primary_net;
 224 
 225         for (i=ipx_interfaces; i && (i->if_netnum!=net); i=i->if_next)
 226                 ;
 227 
 228         return i;
 229 }
 230 
 231 /* Sockets are bound to a particular IPX interface. */
 232 static void
 233 ipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
     /*  */
 234 {
 235         ipx_socket      *s;
 236 
 237         sk->ipx_intrfc = intrfc;
 238         sk->next = NULL;
 239         if (intrfc->if_sklist == NULL) {
 240                 intrfc->if_sklist = sk;
 241         } else {
 242                 for (s = intrfc->if_sklist; s->next != NULL; s = s->next)
 243                         ;
 244                 s->next = sk;
 245         }
 246 }
 247 
 248 static ipx_socket *
 249 ipxitf_find_socket(ipx_interface *intrfc, unsigned short port)
     /*  */
 250 {
 251         ipx_socket      *s;
 252 
 253         for (s=intrfc->if_sklist; 
 254                 (s != NULL) && (s->ipx_port != port); 
 255                 s=s->next)
 256                 ;
 257 
 258         return s;
 259 }
 260 
 261 #ifdef CONFIG_IPX_INTERN
 262 
 263 static ipx_socket *
 264 ipxitf_find_internal_socket(ipx_interface *intrfc,
     /*  */
 265                             unsigned char *node, unsigned short port)
 266 {
 267         ipx_socket *s = intrfc->if_sklist;
 268 
 269         while (s != NULL)
 270         {
 271                 if (   (s->ipx_port == port)
 272                     && (memcmp(node, s->ipx_node, IPX_NODE_LEN) == 0))
 273                 {
 274                         break;
 275                 }
 276                 s = s->next;
 277         }
 278         return s;
 279 }       
 280 #endif
 281 
 282 static void ipxrtr_del_routes(ipx_interface *);
 283 
 284 static void
 285 ipxitf_down(ipx_interface *intrfc)
     /*  */
 286 {
 287         ipx_interface   *i;
 288         ipx_socket      *s, *t;
 289 
 290         /* Delete all routes associated with this interface */
 291         ipxrtr_del_routes(intrfc);
 292 
 293         /* error sockets */
 294         for (s = intrfc->if_sklist; s != NULL; ) {
 295                 s->err = ENOLINK;
 296                 s->error_report(s);
 297                 s->ipx_intrfc = NULL;
 298                 s->ipx_port = 0;
 299                 s->zapped=1;    /* Indicates it is no longer bound */
 300                 t = s;
 301                 s = s->next;
 302                 t->next = NULL;
 303         }
 304         intrfc->if_sklist = NULL;
 305 
 306         /* remove this interface from list */
 307         if (intrfc == ipx_interfaces) {
 308                 ipx_interfaces = intrfc->if_next;
 309         } else {
 310                 for (i = ipx_interfaces; 
 311                         (i != NULL) && (i->if_next != intrfc);
 312                         i = i->if_next)
 313                         ;
 314                 if ((i != NULL) && (i->if_next == intrfc)) 
 315                         i->if_next = intrfc->if_next;
 316         }
 317 
 318         /* remove this interface from *special* networks */
 319         if (intrfc == ipx_primary_net)
 320                 ipxitf_clear_primary_net();
 321         if (intrfc == ipx_internal_net)
 322                 ipx_internal_net = NULL;
 323 
 324         kfree_s(intrfc, sizeof(*intrfc));
 325 }
 326 
 327 static int 
 328 ipxitf_device_event(struct notifier_block *notifier, unsigned long event, void *ptr)
     /*  */
 329 {
 330         struct device *dev = ptr;
 331         ipx_interface *i, *tmp;
 332 
 333         if(event!=NETDEV_DOWN)
 334                 return NOTIFY_DONE;
 335 
 336         for (i = ipx_interfaces; i != NULL; ) {
 337         
 338                 tmp = i->if_next;
 339                 if (i->if_dev == dev) 
 340                         ipxitf_down(i);
 341                 i = tmp;
 342 
 343         }
 344 
 345         return NOTIFY_DONE;
 346 }
 347 
 348 static int ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
     /*  */
 349 {
 350         int     retval;
 351 
 352         if((retval = sock_queue_rcv_skb(sock, skb))<0) 
 353         {
 354                 /*
 355                  * skb->sk is NULL here, so FREE_WRITE does not hurt
 356                  * the sending socket.
 357                  */
 358                 kfree_skb(skb,FREE_WRITE);
 359         }
 360         return retval;
 361 }
 362 
 363 /*
 364  * On input skb->sk is NULL. Nobody is charged for the memory.
 365  */
 366 
 367 #ifdef CONFIG_IPX_INTERN
 368 static int
 369 ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
     /*  */
 370 {
 371         ipx_packet      *ipx = (ipx_packet *)(skb->h.raw);
 372         ipx_socket      *s;
 373 
 374         int is_broadcast = (memcmp(ipx->ipx_dest.node, ipx_broadcast_node,
 375                                    IPX_NODE_LEN) == 0);
 376 
 377         s = intrfc->if_sklist;
 378 
 379         while (s != NULL)
 380         {
 381                 if (   (s->ipx_port == ipx->ipx_dest.sock)
 382                     && (   is_broadcast
 383                         || (memcmp(ipx->ipx_dest.node, s->ipx_node,
 384                                    IPX_NODE_LEN) == 0)))
 385                 {
 386                         /* We found a socket to which to send */
 387                         struct sk_buff *skb1;
 388 
 389                         if (copy != 0)
 390                         {
 391                                 skb1 = skb_clone(skb, GFP_ATOMIC);
 392                                 if (skb1 != NULL)
 393                                 {
 394                                         skb1->arp = skb1->free = 1;
 395                                 }
 396                                 else
 397                                 {
 398                                         return -ENOMEM;
 399                                 }
 400                         }
 401                         else
 402                         {
 403                                 skb1 = skb;
 404                                 copy = 1; /* skb may only be used once */
 405                         }
 406                         ipxitf_def_skb_handler(s, skb1);
 407 
 408                         if (intrfc != ipx_internal_net)
 409                         {
 410                                 /* on an external interface, at most
 411                                  * one socket can listen.
 412                                  */
 413                                 break;
 414                         }
 415                 }
 416                 s = s->next;
 417         }
 418 
 419         if (copy == 0)
 420         {
 421                 /* skb was solely for us, and we did not make a copy,
 422                  * so free it. FREE_WRITE does not hurt, because
 423                  * skb->sk is NULL here.
 424                  */
 425                 kfree_skb(skb, FREE_WRITE);
 426         }
 427         return 0;
 428 }
 429 
 430 #else
 431 
 432 static int
 433 ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
     /*  */
 434 {
 435         ipx_packet      *ipx = (ipx_packet *)(skb->h.raw);
 436         ipx_socket      *sock1 = NULL, *sock2 = NULL;
 437         struct sk_buff  *skb1 = NULL, *skb2 = NULL;
 438 
 439         sock1 = ipxitf_find_socket(intrfc, ipx->ipx_dest.sock);
 440 
 441         /*
 442          *      We need to check if there is a primary net and if
 443          *      this is addressed to one of the *SPECIAL* sockets because
 444          *      these need to be propagated to the primary net.
 445          *      The *SPECIAL* socket list contains: 0x452(SAP), 0x453(RIP) and
 446          *      0x456(Diagnostic).
 447          */
 448          
 449         if (ipx_primary_net && (intrfc != ipx_primary_net)) 
 450         {
 451                 switch (ntohs(ipx->ipx_dest.sock)) 
 452                 {
 453                         case 0x452:
 454                         case 0x453:
 455                         case 0x456:
 456                                 /*
 457                                  *      The appropriate thing to do here is to
 458                                  *      dup the packet and route to the primary net
 459                                  *      interface via ipxitf_send; however, we'll cheat
 460                                  *      and just demux it here.
 461                                  */
 462                                 sock2 = ipxitf_find_socket(ipx_primary_net, 
 463                                         ipx->ipx_dest.sock);
 464                                 break;
 465                         default:
 466                                 break;
 467                 }
 468         }
 469 
 470         /* 
 471          *      if there is nothing to do, return. The kfree will
 472          *      cancel any charging.
 473          */
 474          
 475         if (sock1 == NULL && sock2 == NULL) 
 476         {
 477                 if (!copy) 
 478                         kfree_skb(skb,FREE_WRITE);
 479                 return 0;
 480         }
 481 
 482         /*
 483          * This next segment of code is a little awkward, but it sets it up
 484          * so that the appropriate number of copies of the SKB are made and 
 485          * that skb1 and skb2 point to it (them) so that it (they) can be 
 486          * demuxed to sock1 and/or sock2.  If we are unable to make enough
 487          * copies, we do as much as is possible.
 488          */
 489          
 490         if (copy) 
 491         {
 492                 skb1 = skb_clone(skb, GFP_ATOMIC);
 493                 if (skb1 != NULL) 
 494                         skb1->arp = skb1->free = 1;
 495         } 
 496         else 
 497         {
 498                 skb1 = skb;
 499         }
 500         
 501         if (skb1 == NULL) 
 502                 return -ENOMEM; 
 503 
 504         /*
 505          *      Do we need 2 SKBs? 
 506          */
 507          
 508         if (sock1 && sock2) 
 509         {
 510                 skb2 = skb_clone(skb1, GFP_ATOMIC);
 511                 if (skb2 != NULL) 
 512                         skb2->arp = skb2->free = 1;
 513         }
 514         else 
 515                 skb2 = skb1;
 516                 
 517         if (sock1)
 518                 (void) ipxitf_def_skb_handler(sock1, skb1);
 519 
 520         if (skb2 == NULL) 
 521                 return -ENOMEM;
 522 
 523         if (sock2)
 524                 (void) ipxitf_def_skb_handler(sock2, skb2);
 525 
 526         return 0;
 527 }
 528 #endif
 529 
 530 static struct sk_buff *
 531 ipxitf_adjust_skbuff(ipx_interface *intrfc, struct sk_buff *skb)
     /*  */
 532 {
 533         struct sk_buff  *skb2;
 534         int     in_offset = skb->h.raw - skb->head;
 535         int     out_offset = intrfc->if_ipx_offset;
 536         int     len;
 537 
 538         /* Hopefully, most cases */
 539         if (in_offset >= out_offset) {
 540                 skb->arp = skb->free = 1;
 541                 return skb;
 542         }
 543 
 544         /* Need new SKB */
 545         len = skb->len + out_offset;
 546         skb2 = alloc_skb(len, GFP_ATOMIC);
 547         if (skb2 != NULL) {
 548                 skb_reserve(skb2,out_offset);
 549                 skb2->h.raw=skb_put(skb2,skb->len);
 550                 skb2->free=1;
 551                 skb2->arp=1;
 552                 memcpy(skb2->h.raw, skb->h.raw, skb->len);
 553         }
 554         kfree_skb(skb, FREE_WRITE);
 555         return skb2;
 556 }
 557 
 558 static int ipxitf_send(ipx_interface *intrfc, struct sk_buff *skb, char *node)
     /*  */
 559 {
 560         ipx_packet      *ipx = (ipx_packet *)(skb->h.raw);
 561         struct device   *dev = intrfc->if_dev;
 562         struct datalink_proto   *dl = intrfc->if_dlink;
 563         char            dest_node[IPX_NODE_LEN];
 564         int             send_to_wire = 1;
 565         int             addr_len;
 566         
 567         /* 
 568          *      We need to know how many skbuffs it will take to send out this
 569          *      packet to avoid unnecessary copies.
 570          */
 571          
 572         if ((dl == NULL) || (dev == NULL) || (dev->flags & IFF_LOOPBACK)) 
 573                 send_to_wire = 0;       /* No non looped */
 574 
 575         /*
 576          *      See if this should be demuxed to sockets on this interface 
 577          *
 578          *      We want to ensure the original was eaten or that we only use
 579          *      up clones.
 580          */
 581          
 582         if (ipx->ipx_dest.net == intrfc->if_netnum) 
 583         {
 584                 /*
 585                  *      To our own node, loop and free the original.
 586                  */
 587                 if (memcmp(intrfc->if_node, node, IPX_NODE_LEN) == 0) 
 588                 {
 589                         /*
 590                          *      Don't charge sender
 591                          */
 592                         if(skb->sk)
 593                         {
 594                                 skb->sk->wmem_alloc-=skb->truesize;
 595                                 skb->sk=NULL;
 596                         }
 597                         /*
 598                          *      Will charge receiver
 599                          */
 600                         return ipxitf_demux_socket(intrfc, skb, 0);
 601                 }
 602                 /*
 603                  *      Broadcast, loop and possibly keep to send on.
 604                  */
 605                 if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0) 
 606                 {
 607                         if (!send_to_wire && skb->sk)
 608                         {
 609                                 skb->sk->wmem_alloc-=skb->truesize;
 610                                 skb->sk=NULL;
 611                         }
 612                         ipxitf_demux_socket(intrfc, skb, send_to_wire);
 613                         if (!send_to_wire) 
 614                                 return 0;
 615                 }
 616         }
 617 
 618         /*
 619          *      If the originating net is not equal to our net; this is routed 
 620          *      We are still charging the sender. Which is right - the driver
 621          *      free will handle this fairly.
 622          */
 623          
 624         if (ipx->ipx_source.net != intrfc->if_netnum) 
 625         {
 626                 if (++(ipx->ipx_tctrl) > ipxcfg_max_hops) 
 627                         send_to_wire = 0;
 628         }
 629 
 630         if (!send_to_wire) 
 631         {
 632                 /*
 633                  *      We do a FREE_WRITE here because this indicates how
 634                  *      to treat the socket with which the packet is 
 635                  *      associated.  If this packet is associated with a
 636                  *      socket at all, it must be the originator of the 
 637                  *      packet.   Routed packets will have no socket associated
 638                  *      with them.
 639                  */
 640                 kfree_skb(skb,FREE_WRITE);
 641                 return 0;
 642         }
 643 
 644         /*
 645          *      Determine the appropriate hardware address 
 646          */
 647          
 648         addr_len = dev->addr_len;
 649         if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0) 
 650                 memcpy(dest_node, dev->broadcast, addr_len);
 651         else
 652                 memcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
 653 
 654         /*
 655          *      Make any compensation for differing physical/data link size 
 656          */
 657          
 658         skb = ipxitf_adjust_skbuff(intrfc, skb);
 659         if (skb == NULL) 
 660                 return 0;
 661 
 662         /* set up data link and physical headers */
 663         skb->dev = dev;
 664         skb->protocol = htons(ETH_P_IPX);
 665         dl->datalink_header(dl, skb, dest_node);
 666 #if 0
 667         /* 
 668          *      Now log the packet just before transmission 
 669          */
 670          
 671         dump_pkt("IPX snd:", (ipx_packet *)skb->h.raw);
 672         dump_data("ETH hdr:", skb->data, skb->h.raw - skb->data);
 673 #endif
 674 
 675         /*
 676          *      Send it out 
 677          */
 678          
 679         dev_queue_xmit(skb, dev, SOPRI_NORMAL);
 680         return 0;
 681 }
 682 
 683 static int ipxrtr_add_route(unsigned long, ipx_interface *, unsigned char *);
 684 
 685 static int ipxitf_add_local_route(ipx_interface *intrfc)
     /*  */
 686 {
 687         return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL);
 688 }
 689 
 690 static const char * ipx_frame_name(unsigned short);
 691 static const char * ipx_device_name(ipx_interface *);
 692 static int ipxrtr_route_skb(struct sk_buff *);
 693 
 694 static int ipxitf_rcv(ipx_interface *intrfc, struct sk_buff *skb)
     /*  */
 695 {
 696         ipx_packet      *ipx = (ipx_packet *) (skb->h.raw);
 697         ipx_interface   *i;
 698 
 699 #ifdef CONFIG_FIREWALL  
 700         /*
 701          *      We firewall first, ask questions later.
 702          */
 703          
 704         if (call_in_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
 705         {
 706                 kfree_skb(skb, FREE_READ);
 707                 return 0;
 708         }
 709         
 710 #endif  
 711 
 712         /* See if we should update our network number */
 713         if ((intrfc->if_netnum == 0L) && 
 714                 (ipx->ipx_source.net == ipx->ipx_dest.net) &&
 715                 (ipx->ipx_source.net != 0L)) 
 716         {
 717                 /* NB: NetWare servers lie about their hop count so we
 718                  * dropped the test based on it.  This is the best way
 719                  * to determine this is a 0 hop count packet.
 720                  */
 721                 if ((i=ipxitf_find_using_net(ipx->ipx_source.net))==NULL) 
 722                 {
 723                         intrfc->if_netnum = ipx->ipx_source.net;
 724                         (void) ipxitf_add_local_route(intrfc);
 725                 } 
 726                 else 
 727                 {
 728                         printk("IPX: Network number collision %lx\n\t%s %s and %s %s\n",
 729                                 htonl(ipx->ipx_source.net), 
 730                                 ipx_device_name(i),
 731                                 ipx_frame_name(i->if_dlink_type),
 732                                 ipx_device_name(intrfc),
 733                                 ipx_frame_name(intrfc->if_dlink_type));
 734                 }
 735         }
 736 
 737         if (ipx->ipx_dest.net == 0L)
 738                 ipx->ipx_dest.net = intrfc->if_netnum;
 739         if (ipx->ipx_source.net == 0L)
 740                 ipx->ipx_source.net = intrfc->if_netnum;
 741 
 742         if (intrfc->if_netnum != ipx->ipx_dest.net) 
 743         {
 744 #ifdef CONFIG_FIREWALL  
 745                 /*
 746                  *      See if we are allowed to firewall forward
 747                  */
 748                 if (call_fw_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
 749                 {
 750                         kfree_skb(skb, FREE_READ);
 751                         return 0;
 752                 }
 753 #endif          
 754                 /* We only route point-to-point packets. */
 755                 if ((skb->pkt_type != PACKET_BROADCAST) &&
 756                         (skb->pkt_type != PACKET_MULTICAST))
 757                         return ipxrtr_route_skb(skb);
 758                 
 759                 kfree_skb(skb,FREE_READ);
 760                 return 0;
 761         }
 762 
 763         /* see if we should keep it */
 764         if ((memcmp(ipx_broadcast_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0) 
 765                 || (memcmp(intrfc->if_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0)) 
 766         {
 767                 return ipxitf_demux_socket(intrfc, skb, 0);
 768         }
 769 
 770         /* we couldn't pawn it off so unload it */
 771         kfree_skb(skb,FREE_READ);
 772         return 0;
 773 }
 774 
 775 static void
 776 ipxitf_insert(ipx_interface *intrfc)
     /*  */
 777 {
 778         ipx_interface   *i;
 779 
 780         intrfc->if_next = NULL;
 781         if (ipx_interfaces == NULL) {
 782                 ipx_interfaces = intrfc;
 783         } else {
 784                 for (i = ipx_interfaces; i->if_next != NULL; i = i->if_next)
 785                         ;
 786                 i->if_next = intrfc;
 787         }
 788 
 789         if (ipxcfg_auto_select_primary && (ipx_primary_net == NULL))
 790                 ipx_primary_net = intrfc;
 791 }
 792 
 793 static int 
 794 ipxitf_create_internal(ipx_interface_definition *idef)
     /*  */
 795 {
 796         ipx_interface   *intrfc;
 797 
 798         /* Only one primary network allowed */
 799         if (ipx_primary_net != NULL) return -EEXIST;
 800 
 801         /* Must have a valid network number */
 802         if (idef->ipx_network == 0L) return -EADDRNOTAVAIL;
 803         if (ipxitf_find_using_net(idef->ipx_network) != NULL)
 804                 return -EADDRINUSE;
 805 
 806         intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
 807         if (intrfc==NULL)
 808                 return -EAGAIN;
 809         intrfc->if_dev=NULL;
 810         intrfc->if_netnum=idef->ipx_network;
 811         intrfc->if_dlink_type = 0;
 812         intrfc->if_dlink = NULL;
 813         intrfc->if_sklist = NULL;
 814         intrfc->if_internal = 1;
 815         intrfc->if_ipx_offset = 0;
 816         intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
 817         memcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
 818         ipx_internal_net = intrfc;
 819         ipx_primary_net = intrfc;
 820         ipxitf_insert(intrfc);
 821         return ipxitf_add_local_route(intrfc);
 822 }
 823 
 824 static int
 825 ipx_map_frame_type(unsigned char type)
     /*  */
 826 {
 827         switch (type) {
 828         case IPX_FRAME_ETHERII: return htons(ETH_P_IPX);
 829         case IPX_FRAME_8022: return htons(ETH_P_802_2);
 830         case IPX_FRAME_SNAP: return htons(ETH_P_SNAP);
 831         case IPX_FRAME_8023: return htons(ETH_P_802_3);
 832         }
 833         return 0;
 834 }
 835 
 836 static int 
 837 ipxitf_create(ipx_interface_definition *idef)
     /*  */
 838 {
 839         struct device   *dev;
 840         unsigned short  dlink_type = 0;
 841         struct datalink_proto   *datalink = NULL;
 842         ipx_interface   *intrfc;
 843 
 844         if (idef->ipx_special == IPX_INTERNAL) 
 845                 return ipxitf_create_internal(idef);
 846 
 847         if ((idef->ipx_special == IPX_PRIMARY) && (ipx_primary_net != NULL))
 848                 return -EEXIST;
 849 
 850         if ((idef->ipx_network != 0L) &&
 851                 (ipxitf_find_using_net(idef->ipx_network) != NULL))
 852                 return -EADDRINUSE;
 853 
 854         switch (idef->ipx_dlink_type) {
 855         case IPX_FRAME_ETHERII: 
 856                 dlink_type = htons(ETH_P_IPX);
 857                 datalink = pEII_datalink;
 858                 break;
 859         case IPX_FRAME_8022:
 860                 dlink_type = htons(ETH_P_802_2);
 861                 datalink = p8022_datalink;
 862                 break;
 863         case IPX_FRAME_SNAP:
 864                 dlink_type = htons(ETH_P_SNAP);
 865                 datalink = pSNAP_datalink;
 866                 break;
 867         case IPX_FRAME_8023:
 868                 dlink_type = htons(ETH_P_802_3);
 869                 datalink = p8023_datalink;
 870                 break;
 871         case IPX_FRAME_NONE:
 872         default:
 873                 break;
 874         }
 875 
 876         if (datalink == NULL) 
 877                 return -EPROTONOSUPPORT;
 878 
 879         dev=dev_get(idef->ipx_device);
 880         if (dev==NULL) 
 881                 return -ENODEV;
 882 
 883         if (!(dev->flags & IFF_UP))
 884                 return -ENETDOWN;
 885 
 886         /* Check addresses are suitable */
 887         if(dev->addr_len>IPX_NODE_LEN)
 888                 return -EINVAL;
 889 
 890         if ((intrfc = ipxitf_find_using_phys(dev, dlink_type)) == NULL) {
 891 
 892                 /* Ok now create */
 893                 intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
 894                 if (intrfc==NULL)
 895                         return -EAGAIN;
 896                 intrfc->if_dev=dev;
 897                 intrfc->if_netnum=idef->ipx_network;
 898                 intrfc->if_dlink_type = dlink_type;
 899                 intrfc->if_dlink = datalink;
 900                 intrfc->if_sklist = NULL;
 901                 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
 902                 /* Setup primary if necessary */
 903                 if ((idef->ipx_special == IPX_PRIMARY)) 
 904                         ipx_primary_net = intrfc;
 905                 intrfc->if_internal = 0;
 906                 intrfc->if_ipx_offset = dev->hard_header_len + datalink->header_length;
 907                 memset(intrfc->if_node, 0, IPX_NODE_LEN);
 908                 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), dev->dev_addr, dev->addr_len);
 909 
 910                 ipxitf_insert(intrfc);
 911         }
 912 
 913         /* If the network number is known, add a route */
 914         if (intrfc->if_netnum == 0L) 
 915                 return 0;
 916 
 917         return ipxitf_add_local_route(intrfc);
 918 }
 919 
 920 static int 
 921 ipxitf_delete(ipx_interface_definition *idef)
     /*  */
 922 {
 923         struct device   *dev = NULL;
 924         unsigned short  dlink_type = 0;
 925         ipx_interface   *intrfc;
 926 
 927         if (idef->ipx_special == IPX_INTERNAL) {
 928                 if (ipx_internal_net != NULL) {
 929                         ipxitf_down(ipx_internal_net);
 930                         return 0;
 931                 }
 932                 return -ENOENT;
 933         }
 934 
 935         dlink_type = ipx_map_frame_type(idef->ipx_dlink_type);
 936         if (dlink_type == 0)
 937                 return -EPROTONOSUPPORT;
 938 
 939         dev=dev_get(idef->ipx_device);
 940         if(dev==NULL) return -ENODEV;
 941 
 942         intrfc = ipxitf_find_using_phys(dev, dlink_type);
 943         if (intrfc != NULL) {
 944                 ipxitf_down(intrfc);
 945                 return 0;
 946         }
 947         return -EINVAL;
 948 }
 949 
 950 static ipx_interface *
 951 ipxitf_auto_create(struct device *dev, unsigned short dlink_type)
     /*  */
 952 {
 953         struct datalink_proto *datalink = NULL;
 954         ipx_interface   *intrfc;
 955 
 956         switch (htons(dlink_type)) {
 957         case ETH_P_IPX: datalink = pEII_datalink; break;
 958         case ETH_P_802_2: datalink = p8022_datalink; break;
 959         case ETH_P_SNAP: datalink = pSNAP_datalink; break;
 960         case ETH_P_802_3: datalink = p8023_datalink; break;
 961         default: return NULL;
 962         }
 963         
 964         if (dev == NULL)
 965                 return NULL;
 966 
 967         /* Check addresses are suitable */
 968         if(dev->addr_len>IPX_NODE_LEN) return NULL;
 969 
 970         intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
 971         if (intrfc!=NULL) {
 972                 intrfc->if_dev=dev;
 973                 intrfc->if_netnum=0L;
 974                 intrfc->if_dlink_type = dlink_type;
 975                 intrfc->if_dlink = datalink;
 976                 intrfc->if_sklist = NULL;
 977                 intrfc->if_internal = 0;
 978                 intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
 979                 intrfc->if_ipx_offset = dev->hard_header_len + 
 980                         datalink->header_length;
 981                 memset(intrfc->if_node, 0, IPX_NODE_LEN);
 982                 memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
 983                         dev->dev_addr, dev->addr_len);
 984                 ipxitf_insert(intrfc);
 985         }
 986 
 987         return intrfc;
 988 }
 989 
 990 static int 
 991 ipxitf_ioctl(unsigned int cmd, void *arg)
     /*  */
 992 {
 993         int err;
 994         switch(cmd)
 995         {
 996                 case SIOCSIFADDR:
 997                 {
 998                         struct ifreq ifr;
 999                         struct sockaddr_ipx *sipx;
1000                         ipx_interface_definition f;
1001                         err=verify_area(VERIFY_READ,arg,sizeof(ifr));
1002                         if(err)
1003                                 return err;
1004                         memcpy_fromfs(&ifr,arg,sizeof(ifr));
1005                         sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
1006                         if(sipx->sipx_family!=AF_IPX)
1007                                 return -EINVAL;
1008                         f.ipx_network=sipx->sipx_network;
1009                         memcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
1010                         memcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
1011                         f.ipx_dlink_type=sipx->sipx_type;
1012                         f.ipx_special=sipx->sipx_special;
1013                         if(sipx->sipx_action==IPX_DLTITF)
1014                                 return ipxitf_delete(&f);
1015                         else
1016                                 return ipxitf_create(&f);
1017                 }
1018                 case SIOCGIFADDR:
1019                 {
1020                         struct ifreq ifr;
1021                         struct sockaddr_ipx *sipx;
1022                         ipx_interface *ipxif;
1023                         struct device *dev;
1024                         err=verify_area(VERIFY_WRITE,arg,sizeof(ifr));
1025                         if(err)
1026                                 return err;
1027                         memcpy_fromfs(&ifr,arg,sizeof(ifr));
1028                         sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
1029                         dev=dev_get(ifr.ifr_name);
1030                         if(!dev)
1031                                 return -ENODEV;
1032                         ipxif=ipxitf_find_using_phys(dev, ipx_map_frame_type(sipx->sipx_type));
1033                         if(ipxif==NULL)
1034                                 return -EADDRNOTAVAIL;
1035                         sipx->sipx_family=AF_IPX;
1036                         sipx->sipx_network=ipxif->if_netnum;
1037                         memcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
1038                         memcpy_tofs(arg,&ifr,sizeof(ifr));
1039                         return 0;
1040                 }
1041                 case SIOCAIPXITFCRT:
1042                         err=verify_area(VERIFY_READ,arg,sizeof(char));
1043                         if(err)
1044                                 return err;
1045                         return ipxcfg_set_auto_create(get_fs_byte(arg));
1046                 case SIOCAIPXPRISLT:
1047                         err=verify_area(VERIFY_READ,arg,sizeof(char));
1048                         if(err)
1049                                 return err;
1050                         return ipxcfg_set_auto_select(get_fs_byte(arg));
1051                 default:
1052                         return -EINVAL;
1053         }
1054 }
1055 
1056 /*******************************************************************************************************************\
1057 *                                                                                                                   *
1058 *                                       Routing tables for the IPX socket layer                                     *
1059 *                                                                                                                   *
1060 \*******************************************************************************************************************/
1061 
1062 static ipx_route *
1063 ipxrtr_lookup(unsigned long net)
     /*  */
1064 {
1065         ipx_route *r;
1066 
1067         for (r=ipx_routes; (r!=NULL) && (r->ir_net!=net); r=r->ir_next)
1068                 ;
1069 
1070         return r;
1071 }
1072 
1073 static int
1074 ipxrtr_add_route(unsigned long network, ipx_interface *intrfc, unsigned char *node)
     /*  */
1075 {
1076         ipx_route       *rt;
1077 
1078         /* Get a route structure; either existing or create */
1079         rt = ipxrtr_lookup(network);
1080         if (rt==NULL) {
1081                 rt=(ipx_route *)kmalloc(sizeof(ipx_route),GFP_ATOMIC);
1082                 if(rt==NULL)
1083                         return -EAGAIN;
1084                 rt->ir_next=ipx_routes;
1085                 ipx_routes=rt;
1086         }
1087         else if (intrfc == ipx_internal_net)
1088                 return(-EINVAL);
1089 
1090         rt->ir_net = network;
1091         rt->ir_intrfc = intrfc;
1092         if (node == NULL) {
1093                 memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
1094                 rt->ir_routed = 0;
1095         } else {
1096                 memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
1097                 rt->ir_routed=1;
1098         }
1099         return 0;
1100 }
1101 
1102 static void
1103 ipxrtr_del_routes(ipx_interface *intrfc)
     /*  */
1104 {
1105         ipx_route       **r, *tmp;
1106 
1107         for (r = &ipx_routes; (tmp = *r) != NULL; ) {
1108                 if (tmp->ir_intrfc == intrfc) {
1109                         *r = tmp->ir_next;
1110                         kfree_s(tmp, sizeof(ipx_route));
1111                 } else {
1112                         r = &(tmp->ir_next);
1113                 }
1114         }
1115 }
1116 
1117 static int 
1118 ipxrtr_create(ipx_route_definition *rd)
     /*  */
1119 {
1120         ipx_interface *intrfc;
1121 
1122         /* Find the appropriate interface */
1123         intrfc = ipxitf_find_using_net(rd->ipx_router_network);
1124         if (intrfc == NULL)
1125                 return -ENETUNREACH;
1126 
1127         return ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
1128 }
1129 
1130 
1131 static int 
1132 ipxrtr_delete(long net)
     /*  */
1133 {
1134         ipx_route       **r;
1135         ipx_route       *tmp;
1136 
1137         for (r = &ipx_routes; (tmp = *r) != NULL; ) {
1138                 if (tmp->ir_net == net) {
1139                         if (!(tmp->ir_routed)) {
1140                                 /* Directly connected; can't lose route */
1141                                 return -EPERM;
1142                         }
1143                         *r = tmp->ir_next;
1144                         kfree_s(tmp, sizeof(ipx_route));
1145                         return 0;
1146                 } 
1147                 r = &(tmp->ir_next);
1148         }
1149 
1150         return -ENOENT;
1151 }
1152 
1153 /*
1154  *      Route an outgoing frame from a socket.
1155  */
1156  
1157 static int ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, struct iovec *iov, int len)
     /*  */
1158 {
1159         struct sk_buff *skb;
1160         ipx_interface *intrfc;
1161         ipx_packet *ipx;
1162         int size;
1163         int ipx_offset;
1164         ipx_route *rt = NULL;
1165         int err;
1166         
1167         /* Find the appropriate interface on which to send packet */
1168         if ((usipx->sipx_network == 0L) && (ipx_primary_net != NULL)) 
1169         {
1170                 usipx->sipx_network = ipx_primary_net->if_netnum;
1171                 intrfc = ipx_primary_net;
1172         } 
1173         else 
1174         {
1175                 rt = ipxrtr_lookup(usipx->sipx_network);
1176                 if (rt==NULL) {
1177                         return -ENETUNREACH;
1178                 }
1179                 intrfc = rt->ir_intrfc;
1180         }
1181         
1182         ipx_offset = intrfc->if_ipx_offset;
1183         size=sizeof(ipx_packet)+len;
1184         size += ipx_offset;
1185 
1186         skb=sock_alloc_send_skb(sk, size, 0, 0, &err);
1187         if(skb==NULL)
1188                 return err;
1189 
1190         skb_reserve(skb,ipx_offset);
1191         skb->free=1;
1192         skb->arp=1;
1193         skb->sk=sk;
1194 
1195         /* Fill in IPX header */
1196         ipx=(ipx_packet *)skb_put(skb,sizeof(ipx_packet));
1197         ipx->ipx_checksum=0xFFFF;
1198         ipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
1199         ipx->ipx_tctrl=0;
1200         ipx->ipx_type=usipx->sipx_type;
1201         skb->h.raw = (unsigned char *)ipx;
1202 
1203         ipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
1204 #ifdef CONFIG_IPX_INTERN
1205         memcpy(ipx->ipx_source.node, sk->ipx_node, IPX_NODE_LEN);
1206 #else
1207         if ((err = ntohs(sk->ipx_port)) == 0x453 || err == 0x452)  
1208         {
1209                 /* RIP/SAP special handling for mars_nwe */
1210                 ipx->ipx_source.net = intrfc->if_netnum;
1211                 memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
1212         }
1213         else
1214         {
1215                 ipx->ipx_source.net = sk->ipx_intrfc->if_netnum;
1216                 memcpy(ipx->ipx_source.node, sk->ipx_intrfc->if_node, IPX_NODE_LEN);
1217         }
1218 #endif
1219         ipx->ipx_source.sock = sk->ipx_port;
1220         ipx->ipx_dest.net=usipx->sipx_network;
1221         memcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
1222         ipx->ipx_dest.sock=usipx->sipx_port;
1223 
1224         memcpy_fromiovec(skb_put(skb,len),iov,len);
1225 
1226 #ifdef CONFIG_FIREWALL  
1227         if(call_out_firewall(PF_IPX, skb, ipx)!=FW_ACCEPT)
1228         {
1229                 kfree_skb(skb, FREE_WRITE);
1230                 return -EPERM;
1231         }
1232 #endif
1233         
1234         return ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ? 
1235                                 rt->ir_router_node : ipx->ipx_dest.node);
1236 }
1237         
1238 static int
1239 ipxrtr_route_skb(struct sk_buff *skb)
     /*  */
1240 {
1241         ipx_packet      *ipx = (ipx_packet *) (skb->h.raw);
1242         ipx_route       *r;
1243         ipx_interface   *i;
1244 
1245         r = ipxrtr_lookup(ipx->ipx_dest.net);
1246         if (r == NULL) {
1247                 /* no known route */
1248                 kfree_skb(skb,FREE_READ);
1249                 return 0;
1250         }
1251         i = r->ir_intrfc;
1252         (void)ipxitf_send(i, skb, (r->ir_routed) ? 
1253                         r->ir_router_node : ipx->ipx_dest.node);
1254         return 0;
1255 }
1256 
1257 /*
1258  *      We use a normal struct rtentry for route handling
1259  */
1260  
1261 static int ipxrtr_ioctl(unsigned int cmd, void *arg)
     /*  */
1262 {
1263         int err;
1264         struct rtentry rt;      /* Use these to behave like 'other' stacks */
1265         struct sockaddr_ipx *sg,*st;
1266 
1267         err=verify_area(VERIFY_READ,arg,sizeof(rt));
1268         if(err)
1269                 return err;
1270                 
1271         memcpy_fromfs(&rt,arg,sizeof(rt));
1272         
1273         sg=(struct sockaddr_ipx *)&rt.rt_gateway;
1274         st=(struct sockaddr_ipx *)&rt.rt_dst;
1275         
1276         if(!(rt.rt_flags&RTF_GATEWAY))
1277                 return -EINVAL;         /* Direct routes are fixed */
1278         if(sg->sipx_family!=AF_IPX)
1279                 return -EINVAL;
1280         if(st->sipx_family!=AF_IPX)
1281                 return -EINVAL;
1282                 
1283         switch(cmd)
1284         {
1285                 case SIOCDELRT:
1286                         return ipxrtr_delete(st->sipx_network);
1287                 case SIOCADDRT:
1288                 {
1289                         struct ipx_route_definition f;
1290                         f.ipx_network=st->sipx_network;
1291                         f.ipx_router_network=sg->sipx_network;
1292                         memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
1293                         return ipxrtr_create(&f);
1294                 }
1295                 default:
1296                         return -EINVAL;
1297         }
1298 }
1299 
1300 static const char *
1301 ipx_frame_name(unsigned short frame)
     /*  */
1302 {
1303         switch (ntohs(frame)) {
1304         case ETH_P_IPX: return "EtherII";
1305         case ETH_P_802_2: return "802.2";
1306         case ETH_P_SNAP: return "SNAP";
1307         case ETH_P_802_3: return "802.3";
1308         default: return "None";
1309         }
1310 }
1311 
1312 static const char *
1313 ipx_device_name(ipx_interface *intrfc)
     /*  */
1314 {
1315         return (intrfc->if_internal ? "Internal" :
1316                 (intrfc->if_dev ? intrfc->if_dev->name : "Unknown"));
1317 }
1318 
1319 /* Called from proc fs */
1320 static int ipx_interface_get_info(char *buffer, char **start, off_t offset,
     /*  */
1321                                   int length, int dummy)
1322 {
1323         ipx_interface *i;
1324         int len=0;
1325         off_t pos=0;
1326         off_t begin=0;
1327 
1328         /* Theory.. Keep printing in the same place until we pass offset */
1329 
1330         len += sprintf (buffer,"%-11s%-15s%-9s%-11s%s\n", "Network", 
1331                 "Node_Address", "Primary", "Device", "Frame_Type");
1332         for (i = ipx_interfaces; i != NULL; i = i->if_next) {
1333                 len += sprintf(buffer+len, "%08lX   ", ntohl(i->if_netnum));
1334                 len += sprintf (buffer+len,"%02X%02X%02X%02X%02X%02X   ", 
1335                                 i->if_node[0], i->if_node[1], i->if_node[2],
1336                                 i->if_node[3], i->if_node[4], i->if_node[5]);
1337                 len += sprintf(buffer+len, "%-9s", (i == ipx_primary_net) ?
1338                         "Yes" : "No");
1339                 len += sprintf (buffer+len, "%-11s", ipx_device_name(i));
1340                 len += sprintf (buffer+len, "%s\n", 
1341                         ipx_frame_name(i->if_dlink_type));
1342 
1343                 /* Are we still dumping unwanted data then discard the record */
1344                 pos=begin+len;
1345                 
1346                 if(pos<offset) {
1347                         len=0;                  /* Keep dumping into the buffer start */
1348                         begin=pos;
1349                 }
1350                 if(pos>offset+length)           /* We have dumped enough */
1351                         break;
1352         }
1353         
1354         /* The data in question runs from begin to begin+len */
1355         *start=buffer+(offset-begin);   /* Start of wanted data */
1356         len-=(offset-begin);            /* Remove unwanted header data from length */
1357         if(len>length)
1358                 len=length;             /* Remove unwanted tail data from length */
1359         
1360         return len;
1361 }
1362 
1363 static int ipx_get_info(char *buffer, char **start, off_t offset,
     /*  */
1364                         int length, int dummy)
1365 {
1366         ipx_socket *s;
1367         ipx_interface *i;
1368         int len=0;
1369         off_t pos=0;
1370         off_t begin=0;
1371 
1372         /* Theory.. Keep printing in the same place until we pass offset */
1373 
1374 #ifdef CONFIG_IPX_INTERN        
1375         len += sprintf (buffer,"%-28s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
1376 #else
1377         len += sprintf (buffer,"%-15s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
1378 #endif
1379                         "Remote_Address", "Tx_Queue", "Rx_Queue", 
1380                         "State", "Uid");
1381         for (i = ipx_interfaces; i != NULL; i = i->if_next) {
1382                 for (s = i->if_sklist; s != NULL; s = s->next) {
1383 #ifdef CONFIG_IPX_INTERN
1384                         len += sprintf(buffer+len,
1385                                        "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ", 
1386                                        htonl(s->ipx_intrfc->if_netnum),
1387                                        s->ipx_node[0], s->ipx_node[1], 
1388                                        s->ipx_node[2], s->ipx_node[3], 
1389                                        s->ipx_node[4], s->ipx_node[5],
1390                                        htons(s->ipx_port));
1391 #else
1392                         len += sprintf(buffer+len,"%08lX:%04X  ", 
1393                                        htonl(i->if_netnum),
1394                                        htons(s->ipx_port));
1395 #endif
1396                         if (s->state!=TCP_ESTABLISHED) {
1397                                 len += sprintf(buffer+len, "%-28s", "Not_Connected");
1398                         } else {
1399                                 len += sprintf (buffer+len,
1400                                         "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ", 
1401                                         htonl(s->ipx_dest_addr.net),
1402                                         s->ipx_dest_addr.node[0], s->ipx_dest_addr.node[1], 
1403                                         s->ipx_dest_addr.node[2], s->ipx_dest_addr.node[3], 
1404                                         s->ipx_dest_addr.node[4], s->ipx_dest_addr.node[5],
1405                                         htons(s->ipx_dest_addr.sock));
1406                         }
1407                         len += sprintf (buffer+len,"%08lX  %08lX  ", 
1408                                 s->wmem_alloc, s->rmem_alloc);
1409                         len += sprintf (buffer+len,"%02X     %03d\n", 
1410                                 s->state, SOCK_INODE(s->socket)->i_uid);
1411                 
1412                         /* Are we still dumping unwanted data then discard the record */
1413                         pos=begin+len;
1414                 
1415                         if(pos<offset)
1416                         {
1417                                 len=0;                  /* Keep dumping into the buffer start */
1418                                 begin=pos;
1419                         }
1420                         if(pos>offset+length)           /* We have dumped enough */
1421                                 break;
1422                 }
1423         }
1424         
1425         /* The data in question runs from begin to begin+len */
1426         *start=buffer+(offset-begin);   /* Start of wanted data */
1427         len-=(offset-begin);            /* Remove unwanted header data from length */
1428         if(len>length)
1429                 len=length;             /* Remove unwanted tail data from length */
1430         
1431         return len;
1432 }
1433 
1434 static int ipx_rt_get_info(char *buffer, char **start, off_t offset,
     /*  */
1435                            int length, int dummy)
1436 {
1437         ipx_route *rt;
1438         int len=0;
1439         off_t pos=0;
1440         off_t begin=0;
1441 
1442         len += sprintf (buffer,"%-11s%-13s%s\n", 
1443                         "Network", "Router_Net", "Router_Node");
1444         for (rt = ipx_routes; rt != NULL; rt = rt->ir_next)
1445         {
1446                 len += sprintf (buffer+len,"%08lX   ", ntohl(rt->ir_net));
1447                 if (rt->ir_routed) {
1448                         len += sprintf (buffer+len,"%08lX     %02X%02X%02X%02X%02X%02X\n", 
1449                                 ntohl(rt->ir_intrfc->if_netnum), 
1450                                 rt->ir_router_node[0], rt->ir_router_node[1], 
1451                                 rt->ir_router_node[2], rt->ir_router_node[3], 
1452                                 rt->ir_router_node[4], rt->ir_router_node[5]);
1453                 } else {
1454                         len += sprintf (buffer+len, "%-13s%s\n",
1455                                         "Directly", "Connected");
1456                 }
1457                 pos=begin+len;
1458                 if(pos<offset)
1459                 {
1460                         len=0;
1461                         begin=pos;
1462                 }
1463                 if(pos>offset+length)
1464                         break;
1465         }
1466         *start=buffer+(offset-begin);
1467         len-=(offset-begin);
1468         if(len>length)
1469                 len=length;
1470         return len;
1471 }
1472 
1473 /*******************************************************************************************************************\
1474 *                                                                                                                   *
1475 *             Handling for system calls applied via the various interfaces to an IPX socket object                  *
1476 *                                                                                                                   *
1477 \*******************************************************************************************************************/
1478  
1479 static int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /*  */
1480 {
1481         switch(cmd)
1482         {
1483                 default:
1484                         return(-EINVAL);
1485         }
1486 }
1487 
1488 static int ipx_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
     /*  */
1489 {
1490         ipx_socket *sk;
1491         int err,opt;
1492         
1493         sk=(ipx_socket *)sock->data;
1494         
1495         if(optval==NULL)
1496                 return(-EINVAL);
1497 
1498         err=verify_area(VERIFY_READ,optval,sizeof(int));
1499         if(err)
1500                 return err;
1501         opt=get_fs_long((unsigned long *)optval);
1502         
1503         switch(level)
1504         {
1505                 case SOL_IPX:
1506                         switch(optname)
1507                         {
1508                                 case IPX_TYPE:
1509                                         sk->ipx_type=opt;
1510                                         return 0;
1511                                 default:
1512                                         return -EOPNOTSUPP;
1513                         }
1514                         break;
1515                         
1516                 case SOL_SOCKET:
1517                         return sock_setsockopt(sk,level,optname,optval,optlen);
1518 
1519                 default:
1520                         return -EOPNOTSUPP;
1521         }
1522 }
1523 
1524 static int ipx_getsockopt(struct socket *sock, int level, int optname,
     /*  */
1525         char *optval, int *optlen)
1526 {
1527         ipx_socket *sk;
1528         int val=0;
1529         int err;
1530         
1531         sk=(ipx_socket *)sock->data;
1532 
1533         switch(level)
1534         {
1535 
1536                 case SOL_IPX:
1537                         switch(optname)
1538                         {
1539                                 case IPX_TYPE:
1540                                         val=sk->ipx_type;
1541                                         break;
1542                                 default:
1543                                         return -ENOPROTOOPT;
1544                         }
1545                         break;
1546                         
1547                 case SOL_SOCKET:
1548                         return sock_getsockopt(sk,level,optname,optval,optlen);
1549                         
1550                 default:
1551                         return -EOPNOTSUPP;
1552         }
1553         err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
1554         if(err)
1555                 return err;
1556         put_fs_long(sizeof(int),(unsigned long *)optlen);
1557         err=verify_area(VERIFY_WRITE,optval,sizeof(int));
1558         if (err) return err;
1559         put_fs_long(val,(unsigned long *)optval);
1560         return(0);
1561 }
1562 
1563 static int ipx_listen(struct socket *sock, int backlog)
     /*  */
1564 {
1565         return -EOPNOTSUPP;
1566 }
1567 
1568 static void def_callback1(struct sock *sk)
     /*  */
1569 {
1570         if(!sk->dead)
1571                 wake_up_interruptible(sk->sleep);
1572 }
1573 
1574 static void def_callback2(struct sock *sk, int len)
     /*  */
1575 {
1576         if(!sk->dead)
1577         {
1578                 wake_up_interruptible(sk->sleep);
1579                 sock_wake_async(sk->socket, 1);
1580         }
1581 }
1582 
1583 static int 
1584 ipx_create(struct socket *sock, int protocol)
     /*  */
1585 {
1586         ipx_socket *sk;
1587         sk=(ipx_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
1588         if(sk==NULL)
1589                 return(-ENOMEM);
1590         switch(sock->type)
1591         {
1592                 case SOCK_DGRAM:
1593                         break;
1594                 default:
1595                         kfree_s((void *)sk,sizeof(*sk));
1596                         return(-ESOCKTNOSUPPORT);
1597         }
1598         sk->dead=0;
1599         sk->next=NULL;
1600         sk->broadcast=0;
1601         sk->rcvbuf=SK_RMEM_MAX;
1602         sk->sndbuf=SK_WMEM_MAX;
1603         sk->wmem_alloc=0;
1604         sk->rmem_alloc=0;
1605         sk->users=0;
1606         sk->shutdown=0;
1607         sk->prot=NULL;  /* So we use default free mechanisms */
1608         sk->err=0;
1609         skb_queue_head_init(&sk->receive_queue);
1610         skb_queue_head_init(&sk->write_queue);
1611         sk->send_head=NULL;
1612         skb_queue_head_init(&sk->back_log);
1613         sk->state=TCP_CLOSE;
1614         sk->socket=sock;
1615         sk->type=sock->type;
1616         sk->ipx_type=0;         /* General user level IPX */
1617         sk->ipx_ncp_server = NULL;
1618         sk->debug=0;
1619         sk->ipx_intrfc = NULL;
1620         memset(&sk->ipx_dest_addr,'\0',sizeof(sk->ipx_dest_addr));
1621         sk->ipx_port = 0;
1622         sk->mtu=IPX_MTU;
1623         
1624         if(sock!=NULL)
1625         {
1626                 sock->data=(void *)sk;
1627                 sk->sleep=sock->wait;
1628         }
1629         
1630         sk->state_change=def_callback1;
1631         sk->data_ready=def_callback2;
1632         sk->write_space=def_callback1;
1633         sk->error_report=def_callback1;
1634 
1635         sk->zapped=1;
1636         return 0;
1637 }
1638 
1639 static int ipx_release(struct socket *sock, struct socket *peer)
     /*  */
1640 {
1641         ipx_socket *sk=(ipx_socket *)sock->data;
1642         if(sk==NULL)
1643                 return(0);
1644         if(!sk->dead)
1645                 sk->state_change(sk);
1646         sk->dead=1;
1647         sock->data=NULL;
1648         ipx_destroy_socket(sk);
1649         return(0);
1650 }
1651 
1652 static int ipx_dup(struct socket *newsock,struct socket *oldsock)
     /*  */
1653 {
1654         return(ipx_create(newsock,SOCK_DGRAM));
1655 }
1656 
1657 static unsigned short 
1658 ipx_first_free_socketnum(ipx_interface *intrfc)
     /*  */
1659 {
1660         unsigned short  socketNum = intrfc->if_sknum;
1661 
1662         if (socketNum < IPX_MIN_EPHEMERAL_SOCKET)
1663                 socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1664 
1665         while (ipxitf_find_socket(intrfc, ntohs(socketNum)) != NULL)
1666                 if (socketNum > IPX_MAX_EPHEMERAL_SOCKET)
1667                         socketNum = IPX_MIN_EPHEMERAL_SOCKET;
1668                 else
1669                         socketNum++;
1670 
1671         intrfc->if_sknum = socketNum;
1672         return  ntohs(socketNum);
1673 }
1674         
1675 static int ipx_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
     /*  */
1676 {
1677         ipx_socket *sk;
1678         ipx_interface *intrfc;
1679         struct sockaddr_ipx *addr=(struct sockaddr_ipx *)uaddr;
1680         
1681         sk=(ipx_socket *)sock->data;
1682         
1683         if(sk->zapped==0)
1684                 return -EIO;
1685                 
1686         if(addr_len!=sizeof(struct sockaddr_ipx))
1687                 return -EINVAL;
1688         
1689         intrfc = ipxitf_find_using_net(addr->sipx_network);
1690         if (intrfc == NULL)
1691                 return -EADDRNOTAVAIL;
1692 
1693         if (addr->sipx_port == 0) {
1694                 addr->sipx_port = ipx_first_free_socketnum(intrfc);
1695                 if (addr->sipx_port == 0)
1696                         return -EINVAL;
1697         }
1698 
1699         if(ntohs(addr->sipx_port)<IPX_MIN_EPHEMERAL_SOCKET && !suser())
1700                 return -EPERM;  /* protect IPX system stuff like routing/sap */
1701 
1702         sk->ipx_port=addr->sipx_port;
1703 
1704 #ifdef CONFIG_IPX_INTERN
1705         if (intrfc == ipx_internal_net)
1706         {
1707                 /* The source address is to be set explicitly if the
1708                  * socket is to be bound on the internal network. If a
1709                  * node number 0 was specified, the default is used.
1710                  */
1711 
1712                 if (memcmp(addr->sipx_node, ipx_broadcast_node,
1713                            IPX_NODE_LEN) == 0)
1714                 {
1715                         return -EINVAL;
1716                 }
1717                 if (memcmp(addr->sipx_node, ipx_this_node, IPX_NODE_LEN) == 0)
1718                 {
1719                         memcpy(sk->ipx_node, intrfc->if_node,
1720                                IPX_NODE_LEN);
1721                 }
1722                 else
1723                 {
1724                         memcpy(sk->ipx_node, addr->sipx_node, IPX_NODE_LEN);
1725                 }
1726                 if (ipxitf_find_internal_socket(intrfc, sk->ipx_node,
1727                                                 sk->ipx_port) != NULL)
1728                 {
1729                         if(sk->debug)
1730                                 printk("IPX: bind failed because port %X in"
1731                                        " use.\n", (int)addr->sipx_port);
1732                         return -EADDRINUSE;
1733                 }
1734         }
1735         else
1736         {
1737                 /* Source addresses are easy. It must be our
1738                  * network:node pair for an interface routed to IPX
1739                  * with the ipx routing ioctl()
1740                  */
1741 
1742                 memcpy(sk->ipx_node, intrfc->if_node, IPX_NODE_LEN);
1743                 
1744                 if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
1745                         if(sk->debug)
1746                                 printk("IPX: bind failed because port %X in"
1747                                        " use.\n", (int)addr->sipx_port);
1748                         return -EADDRINUSE;        
1749                 }
1750         }
1751 
1752 #else
1753 
1754         /* Source addresses are easy. It must be our network:node pair for
1755            an interface routed to IPX with the ipx routing ioctl() */
1756 
1757         if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
1758                 if(sk->debug)
1759                         printk("IPX: bind failed because port %X in use.\n",
1760                                 (int)addr->sipx_port);
1761                 return -EADDRINUSE;        
1762         }
1763 
1764 #endif
1765 
1766         ipxitf_insert_socket(intrfc, sk);
1767         sk->zapped=0;
1768         if(sk->debug)
1769                 printk("IPX: socket is bound.\n");
1770         return 0;
1771 }
1772 
1773 static int ipx_connect(struct socket *sock, struct sockaddr *uaddr,
     /*  */
1774         int addr_len, int flags)
1775 {
1776         ipx_socket *sk=(ipx_socket *)sock->data;
1777         struct sockaddr_ipx *addr;
1778         
1779         sk->state = TCP_CLOSE;  
1780         sock->state = SS_UNCONNECTED;
1781 
1782         if(addr_len!=sizeof(*addr))
1783                 return(-EINVAL);
1784         addr=(struct sockaddr_ipx *)uaddr;
1785         
1786         if(sk->ipx_port==0)
1787         /* put the autobinding in */
1788         {
1789                 struct sockaddr_ipx uaddr;
1790                 int ret;
1791         
1792                 uaddr.sipx_port = 0;
1793                 uaddr.sipx_network = 0L;
1794 #ifdef CONFIG_IPX_INTERN
1795                 memcpy(uaddr.sipx_node, sk->ipx_intrfc->if_node,
1796                        IPX_NODE_LEN);
1797 #endif
1798                 ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
1799                                 sizeof(struct sockaddr_ipx));
1800                 if (ret != 0) return (ret);
1801         }
1802         
1803         if(ipxrtr_lookup(addr->sipx_network)==NULL)
1804                 return -ENETUNREACH;
1805         sk->ipx_dest_addr.net=addr->sipx_network;
1806         sk->ipx_dest_addr.sock=addr->sipx_port;
1807         memcpy(sk->ipx_dest_addr.node,addr->sipx_node,IPX_NODE_LEN);
1808         sk->ipx_type=addr->sipx_type;
1809         sock->state = SS_CONNECTED;
1810         sk->state=TCP_ESTABLISHED;
1811         return 0;
1812 }
1813 
1814 static int ipx_socketpair(struct socket *sock1, struct socket *sock2)
     /*  */
1815 {
1816         return(-EOPNOTSUPP);
1817 }
1818 
1819 static int ipx_accept(struct socket *sock, struct socket *newsock, int flags)
     /*  */
1820 {
1821         if(newsock->data)
1822                 kfree_s(newsock->data,sizeof(ipx_socket));
1823         return -EOPNOTSUPP;
1824 }
1825 
1826 static int ipx_getname(struct socket *sock, struct sockaddr *uaddr,
     /*  */
1827         int *uaddr_len, int peer)
1828 {
1829         ipx_address *addr;
1830         struct sockaddr_ipx sipx;
1831         ipx_socket *sk;
1832         
1833         sk=(ipx_socket *)sock->data;
1834         
1835         *uaddr_len = sizeof(struct sockaddr_ipx);
1836                 
1837         if(peer) {
1838                 if(sk->state!=TCP_ESTABLISHED)
1839                         return -ENOTCONN;
1840                 addr=&sk->ipx_dest_addr;
1841                 sipx.sipx_network = addr->net;
1842                 memcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
1843                 sipx.sipx_port = addr->sock;
1844         } else {
1845                 if (sk->ipx_intrfc != NULL) {
1846                         sipx.sipx_network = sk->ipx_intrfc->if_netnum;
1847 #ifdef CONFIG_IPX_INTERN
1848                         memcpy(sipx.sipx_node, sk->ipx_node, IPX_NODE_LEN);
1849 #else
1850                         memcpy(sipx.sipx_node, sk->ipx_intrfc->if_node,
1851                                IPX_NODE_LEN);
1852 #endif
1853 
1854                 } else {
1855                         sipx.sipx_network = 0L;
1856                         memset(sipx.sipx_node, '\0', IPX_NODE_LEN);
1857                 }
1858                 sipx.sipx_port = sk->ipx_port;
1859         }
1860                 
1861         sipx.sipx_family = AF_IPX;
1862         sipx.sipx_type = sk->ipx_type;
1863         memcpy(uaddr,&sipx,sizeof(sipx));
1864         return 0;
1865 }
1866 
1867 #if 0
1868 /*
1869  * User to dump IPX packets (debugging)
1870  */
1871 void dump_data(char *str,unsigned char *d, int len) {
     /*  */
1872   static char h2c[] = "0123456789ABCDEF";
1873   int l,i;
1874   char *p, b[64];
1875   for (l=0;len > 0 && l<16;l++) {
1876     p = b;
1877     for (i=0; i < 8 ; i++, --len) {
1878           if (len > 0) {
1879               *(p++) = h2c[(d[i] >> 4) & 0x0f];
1880               *(p++) = h2c[d[i] & 0x0f];
1881           }
1882           else {
1883               *(p++) = ' ';
1884               *(p++) = ' ';
1885           }
1886       *(p++) = ' ';
1887     }
1888     *(p++) = '-';
1889     *(p++) = ' ';
1890         len += 8;
1891     for (i=0; i < 8 ; i++, --len)
1892                 if (len > 0)
1893                         *(p++) = ' '<= d[i] && d[i]<'\177' ? d[i] : '.';
1894                 else
1895                         *(p++) = ' ';
1896     *p = '\000';
1897     d += i;
1898     printk("%s-%04X: %s\n",str,l*8,b);
1899   }
1900 }
1901 
1902 void dump_addr(char *str,ipx_address *p) {
     /*  */
1903   printk("%s: %08X:%02X%02X%02X%02X%02X%02X:%04X\n",
1904    str,ntohl(p->net),p->node[0],p->node[1],p->node[2],
1905    p->node[3],p->node[4],p->node[5],ntohs(p->sock));
1906 }
1907 
1908 void dump_hdr(char *str,ipx_packet *p) {
     /*  */
1909   printk("%s: CHKSUM=%04X SIZE=%d (%04X) HOPS=%d (%02X) TYPE=%02X\n",
1910    str,p->ipx_checksum,ntohs(p->ipx_pktsize),ntohs(p->ipx_pktsize),
1911    p->ipx_tctrl,p->ipx_tctrl,p->ipx_type);
1912   dump_addr("  IPX-DST",&p->ipx_dest);
1913   dump_addr("  IPX-SRC",&p->ipx_source);
1914 }
1915 
1916 void dump_pkt(char *str,ipx_packet *p) {
     /*  */
1917   int len = ntohs(p->ipx_pktsize);
1918   dump_hdr(str,p);
1919   if (len > 30)
1920           dump_data(str,(unsigned char *)p + 30, len - 30);
1921 }
1922 #endif
1923 
1924 int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
     /*  */
1925 {
1926         /* NULL here for pt means the packet was looped back */
1927         ipx_interface   *intrfc;
1928         ipx_packet *ipx;
1929         
1930         
1931         ipx=(ipx_packet *)skb->h.raw;
1932         
1933         if(ipx->ipx_checksum!=IPX_NO_CHECKSUM) {
1934                 /* We don't do checksum options. We can't really. Novell don't seem to have documented them.
1935                    If you need them try the XNS checksum since IPX is basically XNS in disguise. It might be
1936                    the same... */
1937                 kfree_skb(skb,FREE_READ);
1938                 return 0;
1939         }
1940         
1941         /* Too small */
1942         if(htons(ipx->ipx_pktsize)<sizeof(ipx_packet)) {
1943                 kfree_skb(skb,FREE_READ);
1944                 return 0;
1945         }
1946         
1947         /* Determine what local ipx endpoint this is */
1948         intrfc = ipxitf_find_using_phys(dev, pt->type);
1949         if (intrfc == NULL) {
1950                 if (ipxcfg_auto_create_interfaces) {
1951                         intrfc = ipxitf_auto_create(dev, pt->type);
1952                 }
1953 
1954                 if (intrfc == NULL) {
1955                         /* Not one of ours */
1956                         kfree_skb(skb,FREE_READ);
1957                         return 0;
1958                 }
1959         }
1960 
1961         return ipxitf_rcv(intrfc, skb);
1962 }
1963 
1964 static int ipx_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock,
     /*  */
1965         int flags)
1966 {
1967         ipx_socket *sk=(ipx_socket *)sock->data;
1968         struct sockaddr_ipx *usipx=(struct sockaddr_ipx *)msg->msg_name;
1969         struct sockaddr_ipx local_sipx;
1970         int retval;
1971 
1972         if (sk->zapped) return -EIO; /* Socket not bound */
1973         if(flags) return -EINVAL;
1974                 
1975         if(usipx) 
1976         {
1977                 if(sk->ipx_port == 0) 
1978                 {
1979                         struct sockaddr_ipx uaddr;
1980                         int ret;
1981 
1982                         uaddr.sipx_port = 0;
1983                         uaddr.sipx_network = 0L; 
1984 #ifdef CONFIG_IPX_INTERN
1985                         memcpy(uaddr.sipx_node, sk->ipx_intrfc->if_node,
1986                                IPX_NODE_LEN);
1987 #endif
1988                         ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
1989                                         sizeof(struct sockaddr_ipx));
1990                         if (ret != 0) return ret;
1991                 }
1992 
1993                 if(msg->msg_namelen <sizeof(*usipx))
1994                         return -EINVAL;
1995                 if(usipx->sipx_family != AF_IPX)
1996                         return -EINVAL;
1997         }
1998         else 
1999         {
2000                 if(sk->state!=TCP_ESTABLISHED)
2001                         return -ENOTCONN;
2002                 usipx=&local_sipx;
2003                 usipx->sipx_family=AF_IPX;
2004                 usipx->sipx_type=sk->ipx_type;
2005                 usipx->sipx_port=sk->ipx_dest_addr.sock;
2006                 usipx->sipx_network=sk->ipx_dest_addr.net;
2007                 memcpy(usipx->sipx_node,sk->ipx_dest_addr.node,IPX_NODE_LEN);
2008         }
2009         
2010         retval = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len);
2011         if (retval < 0) return retval;
2012 
2013         return len;
2014 }
2015 
2016 
2017 static int ipx_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
     /*  */
2018                  int flags, int *addr_len)
2019 {
2020         ipx_socket *sk=(ipx_socket *)sock->data;
2021         struct sockaddr_ipx *sipx=(struct sockaddr_ipx *)msg->msg_name;
2022         struct ipx_packet *ipx = NULL;
2023         int copied = 0;
2024         int truesize;
2025         struct sk_buff *skb;
2026         int er;
2027         
2028         if(sk->err)
2029                 return sock_error(sk);
2030         
2031         if (sk->zapped)
2032                 return -EIO;
2033 
2034 
2035         skb=skb_recv_datagram(sk,flags,noblock,&er);
2036         if(skb==NULL)
2037                 return er;
2038         
2039         if(addr_len)
2040                 *addr_len=sizeof(*sipx);
2041 
2042         ipx = (ipx_packet *)(skb->h.raw);
2043         truesize=ntohs(ipx->ipx_pktsize) - sizeof(ipx_packet);
2044         copied = (truesize > size) ? size : truesize;
2045         skb_copy_datagram_iovec(skb,sizeof(struct ipx_packet),msg->msg_iov,copied);
2046         
2047         if(sipx)
2048         {
2049                 sipx->sipx_family=AF_IPX;
2050                 sipx->sipx_port=ipx->ipx_source.sock;
2051                 memcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
2052                 sipx->sipx_network=ipx->ipx_source.net;
2053                 sipx->sipx_type = ipx->ipx_type;
2054         }
2055         skb_free_datagram(sk, skb);
2056         return(truesize);
2057 }               
2058 
2059 static int ipx_shutdown(struct socket *sk,int how)
     /*  */
2060 {
2061         return -EOPNOTSUPP;
2062 }
2063 
2064 static int ipx_select(struct socket *sock , int sel_type, select_table *wait)
     /*  */
2065 {
2066         ipx_socket *sk=(ipx_socket *)sock->data;
2067         
2068         return datagram_select(sk,sel_type,wait);
2069 }
2070 
2071 static int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
     /*  */
2072 {
2073         int err;
2074         long amount=0;
2075         ipx_socket *sk=(ipx_socket *)sock->data;
2076         
2077         switch(cmd)
2078         {
2079                 case TIOCOUTQ:
2080                         err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
2081                         if(err)
2082                                 return err;
2083                         amount=sk->sndbuf-sk->wmem_alloc;
2084                         if(amount<0)
2085                                 amount=0;
2086                         put_fs_long(amount,(unsigned long *)arg);
2087                         return 0;
2088                 case TIOCINQ:
2089                 {
2090                         struct sk_buff *skb;
2091                         /* These two are safe on a single CPU system as only user tasks fiddle here */
2092                         if((skb=skb_peek(&sk->receive_queue))!=NULL)
2093                                 amount=skb->len-sizeof(struct ipx_packet);
2094                         err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
2095                         if(err)
2096                                 return err;
2097                         put_fs_long(amount,(unsigned long *)arg);
2098                         return 0;
2099                 }
2100                 case SIOCADDRT:
2101                 case SIOCDELRT:
2102                         if(!suser())
2103                                 return -EPERM;
2104                         return(ipxrtr_ioctl(cmd,(void *)arg));
2105                 case SIOCSIFADDR:
2106                 case SIOCGIFADDR:
2107                 case SIOCAIPXITFCRT:
2108                 case SIOCAIPXPRISLT:
2109                         if(!suser())
2110                                 return -EPERM;
2111                         return(ipxitf_ioctl(cmd,(void *)arg));
2112                 case SIOCIPXCFGDATA: 
2113                 {
2114                         err=verify_area(VERIFY_WRITE,(void *)arg,
2115                                 sizeof(ipx_config_data));
2116                         if(err) return err;
2117                         return(ipxcfg_get_config_data((void *)arg));
2118                 }
2119                 case SIOCGSTAMP:
2120                         if (sk)
2121                         {
2122                                 if(sk->stamp.tv_sec==0)
2123                                         return -ENOENT;
2124                                 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
2125                                 if(err)
2126                                         return err;
2127                                 memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
2128                                 return 0;
2129                         }
2130                         return -EINVAL;
2131                 case SIOCGIFDSTADDR:
2132                 case SIOCSIFDSTADDR:
2133                 case SIOCGIFBRDADDR:
2134                 case SIOCSIFBRDADDR:
2135                 case SIOCGIFNETMASK:
2136                 case SIOCSIFNETMASK:
2137                         return -EINVAL;
2138                 default:
2139                         return(dev_ioctl(cmd,(void *) arg));
2140         }
2141         /*NOTREACHED*/
2142         return(0);
2143 }
2144 
2145 static struct proto_ops ipx_proto_ops = {
2146         AF_IPX,
2147         
2148         ipx_create,
2149         ipx_dup,
2150         ipx_release,
2151         ipx_bind,
2152         ipx_connect,
2153         ipx_socketpair,
2154         ipx_accept,
2155         ipx_getname,
2156         ipx_select,
2157         ipx_ioctl,
2158         ipx_listen,
2159         ipx_shutdown,
2160         ipx_setsockopt,
2161         ipx_getsockopt,
2162         ipx_fcntl,
2163         ipx_sendmsg,
2164         ipx_recvmsg
2165 };
2166 
2167 /* Called by protocol.c on kernel start up */
2168 
2169 static struct packet_type ipx_8023_packet_type = 
2170 
2171 {
2172         0,      /* MUTTER ntohs(ETH_P_8023),*/
2173         NULL,           /* All devices */
2174         ipx_rcv,
2175         NULL,
2176         NULL,
2177 };
2178  
2179 static struct packet_type ipx_dix_packet_type = 
2180 {
2181         0,      /* MUTTER ntohs(ETH_P_IPX),*/
2182         NULL,           /* All devices */
2183         ipx_rcv,
2184         NULL,
2185         NULL,
2186 };
2187  
2188 static struct notifier_block ipx_dev_notifier={
2189         ipxitf_device_event,
2190         NULL,
2191         0
2192 };
2193 
2194 
2195 extern struct datalink_proto    *make_EII_client(void);
2196 extern struct datalink_proto    *make_8023_client(void);
2197 
2198 void ipx_proto_init(struct net_proto *pro)
     /*  */
2199 {
2200         unsigned char   val = 0xE0;
2201         unsigned char   snapval[5] =  { 0x0, 0x0, 0x0, 0x81, 0x37 };
2202 
2203         (void) sock_register(ipx_proto_ops.family, &ipx_proto_ops);
2204 
2205         pEII_datalink = make_EII_client();
2206         ipx_dix_packet_type.type=htons(ETH_P_IPX);
2207         dev_add_pack(&ipx_dix_packet_type);
2208 
2209         p8023_datalink = make_8023_client();
2210         ipx_8023_packet_type.type=htons(ETH_P_802_3);
2211         dev_add_pack(&ipx_8023_packet_type);
2212         
2213         if ((p8022_datalink = register_8022_client(val, ipx_rcv)) == NULL)
2214                 printk("IPX: Unable to register with 802.2\n");
2215 
2216         if ((pSNAP_datalink = register_snap_client(snapval, ipx_rcv)) == NULL)
2217                 printk("IPX: Unable to register with SNAP\n");
2218         
2219         register_netdevice_notifier(&ipx_dev_notifier);
2220 
2221         proc_net_register(&(struct proc_dir_entry) {
2222                 PROC_NET_IPX, 3, "ipx",
2223                 S_IFREG | S_IRUGO, 1, 0, 0,
2224                 0, &proc_net_inode_operations,
2225                 ipx_get_info
2226         });
2227         proc_net_register(&(struct proc_dir_entry) {
2228                 PROC_NET_IPX_INTERFACE, 13, "ipx_interface",
2229                 S_IFREG | S_IRUGO, 1, 0, 0,
2230                 0, &proc_net_inode_operations,
2231                 ipx_interface_get_info
2232         });
2233         proc_net_register(&(struct proc_dir_entry) {
2234                 PROC_NET_IPX_ROUTE, 9, "ipx_route",
2235                 S_IFREG | S_IRUGO, 1, 0, 0,
2236                 0, &proc_net_inode_operations,
2237                 ipx_rt_get_info
2238         });
2239                 
2240         printk("Swansea University Computer Society IPX 0.33 for NET3.032\n");
2241         printk("IPX Portions Copyright (c) 1995 Caldera, Inc.\n");
2242 }
2243 #endif
/* */
root/net/ipx/af_ipx.c

DEFINITIONS
