net/appletalk/ddp.c

/* */
This source file includes following definitions.
atalk_remove_socket
atalk_insert_socket
atalk_search_socket
atalk_find_socket
atalk_destroy_timer
atalk_destroy_socket
atalk_get_info
atif_drop_device
atif_add_device
atif_probe_device
atalk_find_dev_addr
atalk_find_primary
atalk_find_dev
atalk_find_anynet
atalk_find_interface
atrtr_find
atrtr_get_dev
atrtr_set_default
atrtr_create
atrtr_delete
atrtr_device_down
ddp_device_event
atif_ioctl
atrtr_ioctl
atalk_if_get_info
atalk_rt_get_info
atalk_checksum
atalk_fcntl
atalk_setsockopt
atalk_getsockopt
atalk_listen
def_callback1
def_callback2
atalk_create
atalk_dup
atalk_release
atalk_pick_port
atalk_autobind
atalk_bind
atalk_connect
atalk_socketpair
atalk_accept
atalk_getname
atalk_rcv
atalk_sendto
atalk_send
atalk_recvfrom
atalk_write
atalk_recv
atalk_read
atalk_shutdown
atalk_select
atalk_ioctl
atalk_proto_init
   1 /*
   2  *      DDP:    An implementation of the Appletalk DDP protocol for
   3  *              ethernet 'ELAP'.
   4  *
   5  *              Alan Cox  <Alan.Cox@linux.org>
   6  *                        <iialan@www.linux.org.uk>
   7  *
   8  *              With more than a little assistance from 
   9  *      
  10  *              Wesley Craig <netatalk@umich.edu>
  11  *
  12  *              This program is free software; you can redistribute it and/or
  13  *              modify it under the terms of the GNU General Public License
  14  *              as published by the Free Software Foundation; either version
  15  *              2 of the License, or (at your option) any later version.
  16  *
  17  *      TODO
  18  *              ASYNC I/O
  19  *              Testing.
  20  */
  21  
  22 #include <asm/segment.h>
  23 #include <asm/system.h>
  24 #include <asm/bitops.h>
  25 #include <linux/config.h>
  26 #include <linux/types.h>
  27 #include <linux/kernel.h>
  28 #include <linux/sched.h>
  29 #include <linux/string.h>
  30 #include <linux/mm.h>
  31 #include <linux/socket.h>
  32 #include <linux/sockios.h>
  33 #include <linux/in.h>
  34 #include <linux/errno.h>
  35 #include <linux/interrupt.h>
  36 #include <linux/if_ether.h>
  37 #include <linux/inet.h>
  38 #include <linux/notifier.h>
  39 #include <linux/netdevice.h>
  40 #include <linux/etherdevice.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/termios.h>      /* For TIOCOUTQ/INQ */
  43 #include <net/datalink.h>
  44 #include <net/p8022.h>
  45 #include <net/psnap.h>
  46 #include <net/sock.h>
  47 #include <net/atalk.h>
  48 
  49 #ifdef CONFIG_ATALK
  50 
  51 #define APPLETALK_DEBUG
  52 
  53 
  54 #ifdef APPLETALK_DEBUG
  55 #define DPRINT(x)               print(x)
  56 #else
  57 #define DPRINT(x)
  58 #endif
  59 
  60 struct datalink_proto *ddp_dl, *aarp_dl;
  61 
  62 #define min(a,b)        (((a)<(b))?(a):(b))
  63 
  64 /***********************************************************************************************************************\
  65 *                                                                                                                       *
  66 *                                               Handlers for the socket list.                                           *
  67 *                                                                                                                       *
  68 \***********************************************************************************************************************/
  69 
  70 static atalk_socket *volatile atalk_socket_list=NULL;
  71 
  72 /*
  73  *      Note: Sockets may not be removed _during_ an interrupt or inet_bh
  74  *      handler using this technique. They can be added although we do not
  75  *      use this facility.
  76  */
  77  
  78 static void atalk_remove_socket(atalk_socket *sk)
     /*  */
  79 {
  80         unsigned long flags;
  81         atalk_socket *s;
  82         
  83         save_flags(flags);
  84         cli();
  85         
  86         s=atalk_socket_list;
  87         if(s==sk)
  88         {
  89                 atalk_socket_list=s->next;
  90                 restore_flags(flags);
  91                 return;
  92         }
  93         while(s && s->next)
  94         {
  95                 if(s->next==sk)
  96                 {
  97                         s->next=sk->next;
  98                         restore_flags(flags);
  99                         return;
 100                 }
 101                 s=s->next;
 102         }
 103         restore_flags(flags);
 104 }
 105 
 106 static void atalk_insert_socket(atalk_socket *sk)
     /*  */
 107 {
 108         unsigned long flags;
 109         save_flags(flags);
 110         cli();
 111         sk->next=atalk_socket_list;
 112         atalk_socket_list=sk;
 113         restore_flags(flags);
 114 }
 115 
 116 static atalk_socket *atalk_search_socket(struct sockaddr_at *to, struct atalk_iface *atif)
     /*  */
 117 {
 118         atalk_socket *s;
 119 
 120         for( s = atalk_socket_list; s != NULL; s = s->next ) {
 121             if ( to->sat_port != s->at.src_port ) {
 122                 continue;
 123             }
 124 
 125             if ( to->sat_addr.s_net == 0 &&
 126                     to->sat_addr.s_node == ATADDR_BCAST &&
 127                     s->at.src_net == atif->address.s_net ) {
 128                 break;
 129             }
 130 
 131             if ( to->sat_addr.s_net == s->at.src_net &&
 132                     to->sat_addr.s_node == s->at.src_node ) {
 133                 break;
 134             }
 135 
 136             /* XXXX.0 */
 137         }
 138         return( s );
 139 }
 140 
 141 /*
 142  *      Find a socket in the list.
 143  */
 144  
 145 static atalk_socket *atalk_find_socket(struct sockaddr_at *sat)
     /*  */
 146 {
 147         atalk_socket *s;
 148 
 149         for ( s = atalk_socket_list; s != NULL; s = s->next ) {
 150             if ( s->at.src_net != sat->sat_addr.s_net ) {
 151                 continue;
 152             }
 153             if ( s->at.src_node != sat->sat_addr.s_node ) {
 154                 continue;
 155             }
 156             if ( s->at.src_port != sat->sat_port ) {
 157                 continue;
 158             }
 159             break;
 160         }
 161         return( s );
 162 }
 163 
 164 /*
 165  *      This is only called from user mode. Thus it protects itself against
 166  *      interrupt users but doesn't worry about being called during work.
 167  *      Once it is removed from the queue no interrupt or bottom half will
 168  *      touch it and we are (fairly 8-) ) safe.
 169  */
 170 
 171 static void atalk_destroy_socket(atalk_socket *sk);
 172 
 173 /*
 174  *      Handler for deferred kills.
 175  */
 176  
 177 static void atalk_destroy_timer(unsigned long data)
     /*  */
 178 {
 179         atalk_destroy_socket((atalk_socket *)data);
 180 }
 181 
 182 static void atalk_destroy_socket(atalk_socket *sk)
     /*  */
 183 {
 184         struct sk_buff *skb;
 185         atalk_remove_socket(sk);
 186         
 187         while((skb=skb_dequeue(&sk->receive_queue))!=NULL)
 188         {
 189                 kfree_skb(skb,FREE_READ);
 190         }
 191         
 192         if(sk->wmem_alloc == 0 && sk->rmem_alloc == 0 && sk->dead)
 193                 kfree_s(sk,sizeof(*sk));
 194         else
 195         {
 196                 /*
 197                  *      Someone is using our buffers still.. defer
 198                  */
 199                 init_timer(&sk->timer);
 200                 sk->timer.expires=10*HZ;
 201                 sk->timer.function=atalk_destroy_timer;
 202                 sk->timer.data = (unsigned long)sk;
 203                 add_timer(&sk->timer);
 204         }
 205 }
 206 
 207 
 208 /* Called from proc fs */
 209 int atalk_get_info(char *buffer, char **start, off_t offset, int length)
     /*  */
 210 {
 211         atalk_socket *s;
 212         int len=0;
 213         off_t pos=0;
 214         off_t begin=0;
 215 
 216         /*
 217          *      Fill this in to print out the appletalk info you want
 218          */
 219 
 220         /* Theory.. Keep printing in the same place until we pass offset */
 221         
 222         len += sprintf (buffer,"Type local_addr  remote_addr tx_queue rx_queue st uid\n");
 223         for (s = atalk_socket_list; s != NULL; s = s->next)
 224         {
 225                 len += sprintf (buffer+len,"%02X   ", s->type);
 226                 len += sprintf (buffer+len,"%04X:%02X:%02X  ",
 227                         s->at.src_net,s->at.src_node,s->at.src_port);
 228                 len += sprintf (buffer+len,"%04X:%02X:%02X  ",
 229                         s->at.dest_net,s->at.dest_node,s->at.dest_port);
 230                 len += sprintf (buffer+len,"%08lX:%08lX ", s->wmem_alloc, s->rmem_alloc);
 231                 len += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
 232                 
 233                 /* Are we still dumping unwanted data then discard the record */
 234                 pos=begin+len;
 235                 
 236                 if(pos<offset)
 237                 {
 238                         len=0;                  /* Keep dumping into the buffer start */
 239                         begin=pos;
 240                 }
 241                 if(pos>offset+length)           /* We have dumped enough */
 242                         break;
 243         }
 244         
 245         /* The data in question runs from begin to begin+len */
 246         *start=buffer+(offset-begin);   /* Start of wanted data */
 247         len-=(offset-begin);            /* Remove unwanted header data from length */
 248         if(len>length)
 249                 len=length;             /* Remove unwanted tail data from length */
 250         
 251         return len;
 252 }
 253 
 254 /*******************************************************************************************************************\
 255 *                                                                                                                   *
 256 *                                       Routing tables for the Appletalk socket layer                               *
 257 *                                                                                                                   *
 258 \*******************************************************************************************************************/
 259 
 260 
 261 static struct atalk_route *atalk_router_list=NULL;
 262 static struct atalk_route atrtr_default;                /* For probing devices or in a routerless network */
 263 static struct atalk_iface *atalk_iface_list=NULL;
 264 
 265 /*
 266  *      Appletalk interface control
 267  */
 268  
 269 /*
 270  *      Drop a device. Doesn't drop any of its routes - that is the 
 271  *      the callers problem. Called when we down the interface or 
 272  *      delete the address.
 273  */
 274  
 275 static void atif_drop_device(struct device *dev)
     /*  */
 276 {
 277         struct atalk_iface **iface = &atalk_iface_list;
 278         struct atalk_iface *tmp;
 279 
 280         while ((tmp = *iface) != NULL) 
 281         {
 282                 if (tmp->dev == dev) 
 283                 {
 284                         *iface = tmp->next;
 285                         kfree_s(tmp, sizeof(struct atalk_iface));
 286                 }
 287                 else
 288                         iface = &tmp->next;
 289         }
 290 }
 291 
 292 static struct atalk_iface *atif_add_device(struct device *dev, struct at_addr *sa)
     /*  */
 293 {
 294         struct atalk_iface *iface=(struct atalk_iface *)
 295                                         kmalloc(sizeof(*iface), GFP_KERNEL);
 296         unsigned long flags;                                    
 297         if(iface==NULL)
 298                 return NULL;
 299         iface->dev=dev;
 300         iface->address= *sa;
 301         iface->status=0;
 302         save_flags(flags);
 303         cli();
 304         iface->next=atalk_iface_list;
 305         atalk_iface_list=iface;
 306         restore_flags(flags);
 307         return iface;
 308 }
 309 
 310 /*
 311  *      Perform phase 2 AARP probing on our tentative address.
 312  */
 313  
 314 static int atif_probe_device(struct atalk_iface *atif)
     /*  */
 315 {
 316         int ct;
 317         int netrange=ntohs(atif->nets.nr_lastnet)-ntohs(atif->nets.nr_firstnet)+1;
 318         int probe_net=ntohs(atif->address.s_net);
 319         int netct;
 320         int nodect;
 321         
 322         
 323         /*
 324          *      Offset the network we start probing with.
 325          */
 326          
 327         if(probe_net==ATADDR_ANYNET)
 328         {
 329                 if(!netrange)
 330                         probe_net=ntohs(atif->nets.nr_firstnet);
 331                 else
 332                         probe_net=ntohs(atif->nets.nr_firstnet) + (jiffies%netrange);
 333         }
 334         
 335         
 336         /*
 337          *      Scan the networks.
 338          */
 339          
 340         for(netct=0;netct<=netrange;netct++)
 341         {
 342                 /*
 343                  *      Sweep the available nodes from a random start.
 344                  */
 345                 int nodeoff=jiffies&255;
 346                 
 347                 atif->address.s_net=htons(probe_net);
 348                 for(nodect=0;nodect<256;nodect++)
 349                 {
 350                         atif->address.s_node=((nodect+nodeoff)&0xFF);
 351                         if(atif->address.s_node>0&&atif->address.s_node<254)
 352                         {
 353                                 /*
 354                                  *      Probe a proposed address.
 355                                  */
 356                                 for(ct=0;ct<AARP_RETRANSMIT_LIMIT;ct++)
 357                                 {
 358                                         aarp_send_probe(atif->dev, &atif->address);
 359                                         /*
 360                                          *      Defer 1/10th
 361                                          */
 362                                         current->timeout = jiffies + (HZ/10);
 363                                         current->state = TASK_INTERRUPTIBLE;
 364                                         schedule();
 365                                         if(atif->status&ATIF_PROBE_FAIL)
 366                                                 break;
 367                                 }
 368                                 if(!(atif->status&ATIF_PROBE_FAIL))
 369                                         return 0;
 370                         }
 371                         atif->status&=~ATIF_PROBE_FAIL;
 372                 }
 373                 probe_net++;
 374                 if(probe_net>ntohs(atif->nets.nr_lastnet))
 375                         probe_net=ntohs(atif->nets.nr_firstnet);
 376         }
 377         return -EADDRINUSE;     /* Network is full... */
 378 }
 379 
 380 struct at_addr *atalk_find_dev_addr(struct device *dev)
     /*  */
 381 {
 382         struct atalk_iface *iface;
 383         for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
 384                 if(iface->dev==dev)
 385                         return &iface->address;
 386         return NULL;
 387 }
 388 
 389 static struct at_addr *atalk_find_primary(void)
     /*  */
 390 {
 391         struct atalk_iface *iface;
 392         for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
 393                 if(!(iface->dev->flags&IFF_LOOPBACK))
 394                         return &iface->address;
 395         if ( atalk_iface_list != NULL ) {
 396             return &atalk_iface_list->address;
 397         } else {
 398             return NULL;
 399         }
 400 }
 401 
 402 /*
 403  *      Give a device find its atif control structure
 404  */
 405  
 406 struct atalk_iface *atalk_find_dev(struct device *dev)
     /*  */
 407 {
 408         struct atalk_iface *iface;
 409         for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
 410                 if(iface->dev==dev)
 411                         return iface;
 412         return NULL;
 413 }
 414 
 415 /*
 416  *      Find a match for 'any network' - ie any of our interfaces with that
 417  *      node number will do just nicely.
 418  */
 419  
 420 static struct atalk_iface *atalk_find_anynet(int node, struct device *dev)
     /*  */
 421 {
 422         struct atalk_iface *iface;
 423         for(iface=atalk_iface_list;iface!=NULL;iface=iface->next) {
 424                 if ( iface->dev != dev || ( iface->status & ATIF_PROBE )) {
 425                         continue;
 426                 }
 427                 if ( node == ATADDR_BCAST || iface->address.s_node == node ) {
 428                         return iface;
 429                 }
 430         }
 431         return NULL;
 432 }
 433 
 434 /*
 435  *      Find a match for a specific network:node pair
 436  */
 437  
 438 static struct atalk_iface *atalk_find_interface(int net, int node)
     /*  */
 439 {
 440         struct atalk_iface *iface;
 441         for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
 442         {
 443                 if((node==ATADDR_BCAST || iface->address.s_node==node) 
 444                         && iface->address.s_net==net && !(iface->status&ATIF_PROBE))
 445                         return iface;
 446         }
 447         return NULL;
 448 }
 449 
 450 
 451 /*
 452  *      Find a route for an appletalk packet. This ought to get cached in
 453  *      the socket (later on...). We know about host routes and the fact
 454  *      that a route must be direct to broadcast.
 455  */
 456  
 457 static struct atalk_route *atrtr_find(struct at_addr *target)
     /*  */
 458 {
 459         struct atalk_route *r;
 460         for(r=atalk_router_list;r!=NULL;r=r->next)
 461         {
 462                 if(!(r->flags&RTF_UP))
 463                         continue;
 464                 if(r->target.s_net==target->s_net)
 465                 {
 466                         if(!(r->flags&RTF_HOST) || r->target.s_node==target->s_node)
 467                                 return r;
 468                 }
 469         }
 470         if(atrtr_default.dev)
 471                 return &atrtr_default;
 472         return NULL;
 473 }
 474 
 475                         
 476 /*
 477  *      Given an appletalk network find the device to use. This can be
 478  *      a simple lookup. Funny stuff like routers can wait 8)
 479  */
 480  
 481 static struct device *atrtr_get_dev(struct at_addr *sa)
     /*  */
 482 {
 483         struct atalk_route *atr=atrtr_find(sa);
 484         if(atr==NULL)
 485                 return NULL;
 486         else
 487                 return atr->dev;
 488 }
 489 
 490 /*
 491  *      Set up a default router.
 492  */
 493  
 494 static void atrtr_set_default(struct device *dev)
     /*  */
 495 {
 496         atrtr_default.dev=dev;
 497         atrtr_default.flags= RTF_UP;
 498         atrtr_default.gateway.s_net=htons(0);
 499         atrtr_default.gateway.s_node=0;
 500 }
 501 
 502 /*
 503  *      Add a router. Basically make sure it looks valid and stuff the
 504  *      entry in the list. While it uses netranges we always set them to one
 505  *      entry to work like netatalk.
 506  */
 507  
 508 static int atrtr_create(struct rtentry *r, struct device *devhint)
     /*  */
 509 {
 510         struct sockaddr_at *ta=(struct sockaddr_at *)&r->rt_dst;
 511         struct sockaddr_at *ga=(struct sockaddr_at *)&r->rt_gateway;
 512         struct atalk_route *rt;
 513         struct atalk_iface *iface, *riface;
 514         unsigned long flags;
 515         
 516         save_flags(flags);
 517         
 518         /*
 519          *      Fixme: Raise/Lower a routing change semaphore for these
 520          *      operations.
 521          */
 522          
 523         /*
 524          *      Validate the request
 525          */     
 526         if(ta->sat_family!=AF_APPLETALK)
 527                 return -EINVAL;
 528         if(devhint == NULL && ga->sat_family != AF_APPLETALK)
 529                 return -EINVAL;
 530         
 531         /*
 532          *      Now walk the routing table and make our decisions
 533          */
 534 
 535         for(rt=atalk_router_list;rt!=NULL;rt=rt->next)
 536         {
 537                 if(r->rt_flags != rt->flags)
 538                         continue;
 539 
 540                 if(ta->sat_addr.s_net == rt->target.s_net) {
 541                     if(!(rt->flags&RTF_HOST))
 542                         break;
 543                     if(ta->sat_addr.s_node == rt->target.s_node)
 544                         break;
 545                 }
 546         }
 547 
 548         if ( devhint == NULL ) {
 549             for ( riface = NULL, iface = atalk_iface_list; iface;
 550                     iface = iface->next ) {
 551                 if ( riface == NULL && ntohs( ga->sat_addr.s_net ) >=
 552                         ntohs( iface->nets.nr_firstnet ) &&
 553                         ntohs( ga->sat_addr.s_net ) <=
 554                         ntohs( iface->nets.nr_lastnet ))
 555                     riface = iface;
 556                 if ( ga->sat_addr.s_net == iface->address.s_net &&
 557                         ga->sat_addr.s_node == iface->address.s_node )
 558                     riface = iface;
 559             }
 560             if ( riface == NULL )
 561                 return -ENETUNREACH;
 562             devhint = riface->dev;
 563         }
 564 
 565         if(rt==NULL)
 566         {
 567                 rt=(struct atalk_route *)kmalloc(sizeof(struct atalk_route), GFP_KERNEL);
 568                 if(rt==NULL)
 569                         return -ENOBUFS;
 570                 cli();
 571                 rt->next=atalk_router_list;
 572                 atalk_router_list=rt;
 573         }
 574 
 575         /*
 576          *      Fill in the entry.
 577          */
 578         rt->target=ta->sat_addr;                        
 579         rt->dev=devhint;
 580         rt->flags=r->rt_flags;
 581         rt->gateway=ga->sat_addr;
 582         
 583         restore_flags(flags);
 584         return 0;
 585 }
 586 
 587 
 588 /*
 589  *      Delete a route. Find it and discard it.
 590  */
 591  
 592 static int atrtr_delete( struct at_addr *addr )
     /*  */
 593 {
 594         struct atalk_route **r = &atalk_router_list;
 595         struct atalk_route *tmp;
 596 
 597         while ((tmp = *r) != NULL) {
 598                 if (tmp->target.s_net == addr->s_net &&
 599                             (!(tmp->flags&RTF_GATEWAY) ||
 600                             tmp->target.s_node == addr->s_node )) {
 601                         *r = tmp->next;
 602                         kfree_s(tmp, sizeof(struct atalk_route));
 603                         return 0;
 604                 }
 605                 r = &tmp->next;
 606         }
 607         return -ENOENT;
 608 }
 609 
 610 /*
 611  *      Called when a device is downed. Just throw away any routes
 612  *      via it.
 613  */
 614  
 615 void atrtr_device_down(struct device *dev)
     /*  */
 616 {
 617         struct atalk_route **r = &atalk_router_list;
 618         struct atalk_route *tmp;
 619 
 620         while ((tmp = *r) != NULL) {
 621                 if (tmp->dev == dev) {
 622                         *r = tmp->next;
 623                         kfree_s(tmp, sizeof(struct atalk_route));
 624                 }
 625                 else
 626                         r = &tmp->next;
 627         }
 628         if(atrtr_default.dev==dev)
 629                 atrtr_set_default(NULL);
 630 }
 631 
 632 /*
 633  *      A device event has occured. Watch for devices going down and
 634  *      delete our use of them (iface and route).
 635  */
 636 
 637 static int ddp_device_event(unsigned long event, void *ptr)
     /*  */
 638 {
 639         if(event==NETDEV_DOWN)
 640         {
 641                 /* Discard any use of this */
 642                 atrtr_device_down((struct device *)ptr);
 643                 atif_drop_device((struct device *)ptr);
 644         }
 645         return NOTIFY_DONE;
 646 }
 647 
 648 /*
 649  *      ioctl calls. Shouldn't even need touching.
 650  */
 651 
 652 /*
 653  *      Device configuration ioctl calls.
 654  */
 655  
 656 int atif_ioctl(int cmd, void *arg)
     /*  */
 657 {
 658         struct ifreq atreq;
 659         static char aarp_mcast[6]={0x09,0x00,0x00,0xFF,0xFF,0xFF};
 660         struct netrange *nr;
 661         struct sockaddr_at *sa;
 662         struct device *dev;
 663         struct atalk_iface *atif;
 664         int ro=(cmd==SIOCSIFADDR);
 665         int err=verify_area(ro?VERIFY_READ:VERIFY_WRITE, arg,sizeof(atreq));
 666         int ct;
 667         int limit;
 668         struct rtentry rtdef;
 669         
 670         if(err)
 671                 return err;
 672         
 673         memcpy_fromfs(&atreq,arg,sizeof(atreq));
 674         
 675         if((dev=dev_get(atreq.ifr_name))==NULL)
 676                 return -ENODEV;
 677                 
 678         sa=(struct sockaddr_at*)&atreq.ifr_addr;
 679         atif=atalk_find_dev(dev);
 680         
 681         switch(cmd)
 682         {
 683                 case SIOCSIFADDR:
 684                         if(!suser())
 685                                 return -EPERM;
 686                         if(sa->sat_family!=AF_APPLETALK)
 687                                 return -EINVAL;
 688                         if(dev->type!=ARPHRD_ETHER)
 689                                 return -EPROTONOSUPPORT;
 690                         nr=(struct netrange *)&sa->sat_zero[0];
 691                         if(nr->nr_phase!=2)
 692                                 return -EPROTONOSUPPORT;
 693                         if(sa->sat_addr.s_node==ATADDR_BCAST || sa->sat_addr.s_node == 254)
 694                                 return -EINVAL;
 695                         if(atif)
 696                         {
 697                                 /*
 698                                  *      Already setting address.
 699                                  */
 700                                 if(atif->status&ATIF_PROBE)
 701                                         return -EBUSY;
 702                                         
 703                                 atif->address.s_net=sa->sat_addr.s_net;
 704                                 atif->address.s_node=sa->sat_addr.s_node;
 705                                 atrtr_device_down(dev); /* Flush old routes */
 706                         }
 707                         else
 708                         {
 709                                 atif=atif_add_device(dev, &sa->sat_addr);
 710                         }
 711                         atif->nets= *nr;
 712 
 713                         /*
 714                          *      Check if the chosen address is used. If so we 
 715                          *      error and atalkd will try another. 
 716                          */
 717                          
 718                         if(!(dev->flags&IFF_LOOPBACK) && atif_probe_device(atif)<0)
 719                         {
 720                                 atif_drop_device(dev);
 721                                 return -EADDRINUSE;
 722                         }
 723 
 724                         /*
 725                          *      Hey it worked - add the direct
 726                          *      routes.
 727                          */
 728                                 
 729                         sa=(struct sockaddr_at *)&rtdef.rt_gateway;
 730                         sa->sat_family=AF_APPLETALK;
 731                         sa->sat_addr.s_net=atif->address.s_net;
 732                         sa->sat_addr.s_node=atif->address.s_node;
 733                         sa=(struct sockaddr_at *)&rtdef.rt_dst;
 734                         rtdef.rt_flags=RTF_UP;
 735                         sa->sat_family=AF_APPLETALK;
 736                         sa->sat_addr.s_node=ATADDR_ANYNODE;
 737                         if(dev->flags&IFF_LOOPBACK)
 738                                 rtdef.rt_flags|=RTF_HOST;
 739                         /*
 740                          *      Routerless initial state.
 741                          */
 742                         if(nr->nr_firstnet==htons(0) && nr->nr_lastnet==htons(0xFFFE)) {
 743                                 sa->sat_addr.s_net=atif->address.s_net;
 744                                 atrtr_create(&rtdef, dev);
 745                                 atrtr_set_default(dev);
 746                         } else {
 747                                 limit=ntohs(nr->nr_lastnet);
 748                                 if(limit-ntohs(nr->nr_firstnet) > 256)
 749                                 {
 750                                         printk("Too many routes/iface.\n");
 751                                         return -EINVAL;
 752                                 }
 753                                 for(ct=ntohs(nr->nr_firstnet);ct<=limit;ct++)
 754                                 {
 755                                         sa->sat_addr.s_net=htons(ct);
 756                                         atrtr_create(&rtdef, dev);
 757                                 }
 758                         }
 759                         dev_mc_add(dev, aarp_mcast, 6, 1);
 760                         return 0;
 761                 case SIOCGIFADDR:
 762                         if(atif==NULL)
 763                                 return -EADDRNOTAVAIL;
 764                         ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
 765                         ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr=atif->address;
 766                         break;
 767                 case SIOCGIFBRDADDR:
 768                         if(atif==NULL)
 769                                 return -EADDRNOTAVAIL;
 770                         ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
 771                         ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_net=atif->address.s_net;
 772                         ((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_node=ATADDR_BCAST;
 773                         break;
 774         }
 775         memcpy_tofs(arg,&atreq,sizeof(atreq));
 776         return 0;
 777 }
 778 
 779 /*
 780  *      Routing ioctl() calls
 781  */
 782   
 783 static int atrtr_ioctl(unsigned int cmd, void *arg)
     /*  */
 784 {
 785         int err;
 786         struct rtentry rt;
 787         
 788         err=verify_area(VERIFY_READ, arg, sizeof(rt));
 789         if(err)
 790                 return err;
 791         memcpy_fromfs(&rt,arg,sizeof(rt));
 792         
 793         switch(cmd)
 794         {
 795                 case SIOCDELRT:
 796                         if(rt.rt_dst.sa_family!=AF_APPLETALK)
 797                                 return -EINVAL;
 798                         return atrtr_delete(&((struct sockaddr_at *)&rt.rt_dst)->sat_addr);
 799                 case SIOCADDRT:
 800                         return atrtr_create(&rt, NULL);
 801                 default:
 802                         return -EINVAL;
 803         }
 804 }
 805 
 806 /* Called from proc fs - just make it print the ifaces neatly */
 807 
 808 int atalk_if_get_info(char *buffer, char **start, off_t offset, int length)
     /*  */
 809 {
 810         struct atalk_iface *iface;
 811         int len=0;
 812         off_t pos=0;
 813         off_t begin=0;
 814 
 815         len += sprintf (buffer,"Interface         Address   Networks   Status\n");
 816         for (iface = atalk_iface_list; iface != NULL; iface = iface->next)
 817         {
 818                 len += sprintf (buffer+len,"%-16s %04X:%02X  %04X-%04X  %d\n",
 819                         iface->dev->name,
 820                         ntohs(iface->address.s_net),iface->address.s_node,
 821                         ntohs(iface->nets.nr_firstnet),ntohs(iface->nets.nr_lastnet),
 822                         iface->status);
 823                 pos=begin+len;
 824                 if(pos<offset)
 825                 {
 826                         len=0;
 827                         begin=pos;
 828                 }
 829                 if(pos>offset+length)
 830                         break;
 831         }
 832         *start=buffer+(offset-begin);
 833         len-=(offset-begin);
 834         if(len>length)
 835                 len=length;
 836         return len;
 837 }
 838 
 839 /* Called from proc fs - just make it print the routes neatly */
 840 
 841 int atalk_rt_get_info(char *buffer, char **start, off_t offset, int length)
     /*  */
 842 {
 843         struct atalk_route *rt;
 844         int len=0;
 845         off_t pos=0;
 846         off_t begin=0;
 847 
 848         len += sprintf (buffer,"Target        Router  Flags Dev\n");
 849         if(atrtr_default.dev)
 850         {
 851                 rt=&atrtr_default;
 852                 len += sprintf (buffer+len,"Default     %5d:%-3d  %-4d  %s\n",
 853                         ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
 854                         rt->dev->name);
 855         }
 856         for (rt = atalk_router_list; rt != NULL; rt = rt->next)
 857         {
 858                 len += sprintf (buffer+len,"%04X:%02X     %5d:%-3d  %-4d  %s\n",
 859                         ntohs(rt->target.s_net),rt->target.s_node,
 860                         ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
 861                         rt->dev->name);
 862                 pos=begin+len;
 863                 if(pos<offset)
 864                 {
 865                         len=0;
 866                         begin=pos;
 867                 }
 868                 if(pos>offset+length)
 869                         break;
 870         }
 871         *start=buffer+(offset-begin);
 872         len-=(offset-begin);
 873         if(len>length)
 874                 len=length;
 875         return len;
 876 }
 877 
 878 /*******************************************************************************************************************\
 879 *                                                                                                                   *
 880 *             Handling for system calls applied via the various interfaces to an Appletalk socket object            *
 881 *                                                                                                                   *
 882 \*******************************************************************************************************************/
 883 
 884 /*
 885  *      Checksum: This is 'optional'. It's quite likely also a good
 886  *      candidate for assembler hackery 8)
 887  */
 888  
 889 unsigned short atalk_checksum(struct ddpehdr *ddp, int len)
     /*  */
 890 {
 891         unsigned long sum=0;    /* Assume unsigned long is >16 bits */
 892         unsigned char *data=(unsigned char *)ddp;
 893         
 894         len-=4;         /* skip header 4 bytes */
 895         data+=4;        
 896         
 897         /* This ought to be unwrapped neatly. I'll trust gcc for now */
 898         while(len--)
 899         {
 900                 sum+=*data;
 901                 sum<<=1;
 902                 if(sum&0x10000)
 903                 {
 904                         sum++;
 905                         sum&=0xFFFF;
 906                 }
 907                 data++;
 908         }
 909         if(sum)
 910                 return htons((unsigned short)sum);
 911         return 0xFFFF;          /* Use 0xFFFF for 0. 0 itself means none */
 912 }
 913         
 914 /*
 915  *      Generic fcntl calls are already dealt with. If we don't need funny ones
 916  *      this is the all you need. Async I/O is also seperate.
 917  */
 918   
 919 static int atalk_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
     /*  */
 920 {
 921 /*      atalk_socket *sk=(atalk_socket *)sock->data;*/
 922         switch(cmd)
 923         {
 924                 default:
 925                         return(-EINVAL);
 926         }
 927 }
 928 
 929 /*
 930  *      Set 'magic' options for appletalk. If we don't have any this is fine 
 931  *      as it is.
 932  */
 933  
 934 static int atalk_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
     /*  */
 935 {
 936         atalk_socket *sk;
 937         int err,opt;
 938         
 939         sk=(atalk_socket *)sock->data;
 940         
 941         if(optval==NULL)
 942                 return(-EINVAL);
 943 
 944         err=verify_area(VERIFY_READ,optval,sizeof(int));
 945         if(err)
 946                 return err;
 947         opt=get_fs_long((unsigned long *)optval);
 948         
 949         switch(level)
 950         {
 951                 case SOL_ATALK:
 952                         switch(optname)
 953                         {
 954                                 default:
 955                                         return -EOPNOTSUPP;
 956                         }
 957                         break;
 958                         
 959                 case SOL_SOCKET:                
 960                         return sock_setsockopt(sk,level,optname,optval,optlen);
 961 
 962                 default:
 963                         return -EOPNOTSUPP;
 964         }
 965 }
 966 
 967 
 968 /*
 969  *      Get any magic options. Comment above applies.
 970  */
 971  
 972 static int atalk_getsockopt(struct socket *sock, int level, int optname,
     /*  */
 973         char *optval, int *optlen)
 974 {
 975         atalk_socket *sk;
 976         int val=0;
 977         int err;
 978         
 979         sk=(atalk_socket *)sock->data;
 980 
 981         switch(level)
 982         {
 983 
 984                 case SOL_ATALK:
 985                         switch(optname)
 986                         {
 987                                 default:
 988                                         return -ENOPROTOOPT;
 989                         }
 990                         break;
 991                         
 992                 case SOL_SOCKET:
 993                         return sock_getsockopt(sk,level,optname,optval,optlen);
 994                         
 995                 default:
 996                         return -EOPNOTSUPP;
 997         }
 998         err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
 999         if(err)
1000                 return err;
1001         put_fs_long(sizeof(int),(unsigned long *)optlen);
1002         err=verify_area(VERIFY_WRITE,optval,sizeof(int));
1003         put_fs_long(val,(unsigned long *)optval);
1004         return(0);
1005 }
1006 
1007 /*
1008  *      Only for connection oriented sockets - ignore
1009  */
1010  
1011 static int atalk_listen(struct socket *sock, int backlog)
     /*  */
1012 {
1013         return -EOPNOTSUPP;
1014 }
1015 
1016 /*
1017  *      These are standard.
1018  */
1019  
1020 static void def_callback1(struct sock *sk)
     /*  */
1021 {
1022         if(!sk->dead)
1023                 wake_up_interruptible(sk->sleep);
1024 }
1025 
1026 static void def_callback2(struct sock *sk, int len)
     /*  */
1027 {
1028         if(!sk->dead)
1029         {
1030                 wake_up_interruptible(sk->sleep);
1031                 sock_wake_async(sk->socket,0);
1032         }
1033 }
1034 
1035 /*
1036  *      Create a socket. Initialise the socket, blank the addresses
1037  *      set the state.
1038  */
1039  
1040 static int atalk_create(struct socket *sock, int protocol)
     /*  */
1041 {
1042         atalk_socket *sk;
1043         sk=(atalk_socket *)kmalloc(sizeof(*sk),GFP_KERNEL);
1044         if(sk==NULL)
1045                 return(-ENOMEM);
1046         switch(sock->type)
1047         {
1048                 /* This RAW is an extension. It is trivial to do and gives you
1049                    the full ELAP frame. Should be handy for CAP 8) */
1050                 case SOCK_RAW:
1051                 /* We permit DDP datagram sockets */
1052                 case SOCK_DGRAM:
1053                         break;
1054                 default:
1055                         kfree_s((void *)sk,sizeof(*sk));
1056                         return(-ESOCKTNOSUPPORT);
1057         }
1058         sk->dead=0;
1059         sk->next=NULL;
1060         sk->broadcast=0;
1061         sk->no_check=0;         /* Checksums on by default */
1062         sk->rcvbuf=SK_RMEM_MAX;
1063         sk->sndbuf=SK_WMEM_MAX;
1064         sk->pair=NULL;
1065         sk->wmem_alloc=0;
1066         sk->rmem_alloc=0;
1067         sk->inuse=0;
1068         sk->proc=0;
1069         sk->priority=1;
1070         sk->shutdown=0;
1071         sk->prot=NULL;  /* So we use default free mechanisms */
1072         sk->broadcast=0;
1073         sk->err=0;
1074         skb_queue_head_init(&sk->receive_queue);
1075         skb_queue_head_init(&sk->write_queue);
1076         sk->send_head=NULL;
1077         skb_queue_head_init(&sk->back_log);
1078         sk->state=TCP_CLOSE;
1079         sk->socket=sock;
1080         sk->type=sock->type;
1081         sk->debug=0;
1082         
1083         sk->at.src_net=0;
1084         sk->at.src_node=0;
1085         sk->at.src_port=0;
1086         
1087         sk->at.dest_net=0;
1088         sk->at.dest_node=0;
1089         sk->at.dest_port=0;
1090 
1091         sk->mtu=DDP_MAXSZ;
1092         
1093         if(sock!=NULL)
1094         {
1095                 sock->data=(void *)sk;
1096                 sk->sleep=sock->wait;
1097         }
1098         
1099         sk->state_change=def_callback1;
1100         sk->data_ready=def_callback2;
1101         sk->write_space=def_callback1;
1102         sk->error_report=def_callback1;
1103 
1104         sk->zapped=1;
1105         return(0);
1106 }
1107 
1108 /*
1109  *      Copy a socket. No work needed.
1110  */
1111  
1112 static int atalk_dup(struct socket *newsock,struct socket *oldsock)
     /*  */
1113 {
1114         return(atalk_create(newsock,SOCK_DGRAM));
1115 }
1116 
1117 /*
1118  *      Free a socket. No work needed
1119  */
1120  
1121 static int atalk_release(struct socket *sock, struct socket *peer)
     /*  */
1122 {
1123         atalk_socket *sk=(atalk_socket *)sock->data;
1124         if(sk==NULL)
1125                 return(0);
1126         if(!sk->dead)
1127                 sk->state_change(sk);
1128         sk->dead=1;
1129         sock->data=NULL;
1130         atalk_destroy_socket(sk);
1131         return(0);
1132 }
1133                 
1134 /*
1135  *      Pick a source address if one is not given. Just return
1136  *      an error if not supportable.
1137  */
1138  
1139 static int atalk_pick_port(struct sockaddr_at *sat)
     /*  */
1140 {
1141         for ( sat->sat_port = ATPORT_RESERVED; sat->sat_port < ATPORT_LAST;
1142                 sat->sat_port++ )
1143             if ( atalk_find_socket( sat ) == NULL )
1144                 return sat->sat_port;
1145         return -EBUSY;
1146 }
1147                 
1148 static int atalk_autobind(atalk_socket *sk)
     /*  */
1149 {
1150         struct at_addr *ap = atalk_find_primary();
1151         struct sockaddr_at sat;
1152         int n;
1153 
1154         if ( ap == NULL || ap->s_net == htons( ATADDR_ANYNET ))
1155             return -EADDRNOTAVAIL;
1156         sk->at.src_net = sat.sat_addr.s_net = ap->s_net;
1157         sk->at.src_node = sat.sat_addr.s_node = ap->s_node;
1158 
1159         if (( n = atalk_pick_port( &sat )) < 0 )
1160             return( n );
1161         sk->at.src_port=n;
1162         atalk_insert_socket(sk);
1163         sk->zapped=0;
1164         return 0;
1165 }
1166 
1167 /*
1168  *      Set the address 'our end' of the connection.
1169  */
1170  
1171 static int atalk_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
     /*  */
1172 {
1173         atalk_socket *sk;
1174         struct sockaddr_at *addr=(struct sockaddr_at *)uaddr;
1175         
1176         sk=(atalk_socket *)sock->data;
1177         
1178         if(sk->zapped==0)
1179                 return(-EIO);
1180                 
1181         if(addr_len!=sizeof(struct sockaddr_at))
1182                 return -EINVAL;
1183 
1184         if(addr->sat_family!=AF_APPLETALK)
1185                 return -EAFNOSUPPORT;
1186 
1187         if(addr->sat_addr.s_net==htons(ATADDR_ANYNET))
1188         {
1189                 struct at_addr *ap=atalk_find_primary();
1190                 if(ap==NULL)
1191                         return -EADDRNOTAVAIL;
1192                 sk->at.src_net=addr->sat_addr.s_net=ap->s_net;
1193                 sk->at.src_node=addr->sat_addr.s_node=ap->s_node;
1194         }
1195         else
1196         {                       
1197                 if ( atalk_find_interface( addr->sat_addr.s_net,
1198                         addr->sat_addr.s_node ) == NULL )
1199                     return -EADDRNOTAVAIL;
1200                 sk->at.src_net=addr->sat_addr.s_net;
1201                 sk->at.src_node=addr->sat_addr.s_node;
1202         }
1203 
1204         if(addr->sat_port == ATADDR_ANYPORT)
1205         {
1206                 int n = atalk_pick_port(addr);
1207                 if(n < 0)
1208                         return n;
1209                 sk->at.src_port=addr->sat_port=n;
1210         }
1211         else
1212                 sk->at.src_port=addr->sat_port;
1213 
1214         if(atalk_find_socket(addr)!=NULL)
1215                 return -EADDRINUSE;        
1216 
1217         atalk_insert_socket(sk);
1218         sk->zapped=0;
1219         return(0);
1220 }
1221 
1222 /*
1223  *      Set the address we talk to.
1224  */
1225  
1226 static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
     /*  */
1227         int addr_len, int flags)
1228 {
1229         atalk_socket *sk=(atalk_socket *)sock->data;
1230         struct sockaddr_at *addr;
1231         
1232         sk->state = TCP_CLOSE;  
1233         sock->state = SS_UNCONNECTED;
1234 
1235         if(addr_len!=sizeof(*addr))
1236                 return(-EINVAL);
1237         addr=(struct sockaddr_at *)uaddr;
1238         
1239         if(addr->sat_family!=AF_APPLETALK)
1240                 return -EAFNOSUPPORT;
1241 #if 0   /* Netatalk doesnt check this */
1242         if(addr->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
1243                 return -EPERM;
1244 #endif          
1245         if(sk->zapped)
1246         {
1247                 if(atalk_autobind(sk)<0)
1248                         return -EBUSY;
1249         }       
1250         
1251         if(atrtr_get_dev(&addr->sat_addr)==NULL)
1252                 return -ENETUNREACH;
1253                 
1254         sk->at.dest_port=addr->sat_port;
1255         sk->at.dest_net=addr->sat_addr.s_net;
1256         sk->at.dest_node=addr->sat_addr.s_node;
1257         sock->state = SS_CONNECTED;
1258         sk->state=TCP_ESTABLISHED;
1259         return(0);
1260 }
1261 
1262 /*
1263  *      Not relevant
1264  */
1265  
1266 static int atalk_socketpair(struct socket *sock1, struct socket *sock2)
     /*  */
1267 {
1268         return(-EOPNOTSUPP);
1269 }
1270 
1271 /*
1272  *      Not relevant
1273  */
1274  
1275 static int atalk_accept(struct socket *sock, struct socket *newsock, int flags)
     /*  */
1276 {
1277         if(newsock->data)
1278                 kfree_s(newsock->data,sizeof(atalk_socket));
1279         return -EOPNOTSUPP;
1280 }
1281 
1282 /*
1283  *      Find the name of an appletalk socket. Just copy the right
1284  *      fields into the sockaddr.
1285  */
1286  
1287 static int atalk_getname(struct socket *sock, struct sockaddr *uaddr,
     /*  */
1288         int *uaddr_len, int peer)
1289 {
1290         struct sockaddr_at sat;
1291         atalk_socket *sk;
1292         
1293         sk=(atalk_socket *)sock->data;
1294         if(sk->zapped)
1295         {
1296                 if(atalk_autobind(sk)<0)
1297                         return -EBUSY;
1298         }       
1299         
1300         *uaddr_len = sizeof(struct sockaddr_at);
1301                 
1302         if(peer)
1303         {
1304                 if(sk->state!=TCP_ESTABLISHED)
1305                         return -ENOTCONN;
1306                 sat.sat_addr.s_net=sk->at.dest_net;
1307                 sat.sat_addr.s_node=sk->at.dest_node;
1308                 sat.sat_port=sk->at.dest_port;
1309         }
1310         else
1311         {
1312                 sat.sat_addr.s_net=sk->at.src_net;
1313                 sat.sat_addr.s_node=sk->at.src_node;
1314                 sat.sat_port=sk->at.src_port;
1315         }
1316         sat.sat_family = AF_APPLETALK;
1317         memcpy(uaddr,&sat,sizeof(sat));
1318         return(0);
1319 }
1320 
1321 /*
1322  *      Receive a packet (in skb) from device dev. This has come from the SNAP decoder, and on entry
1323  *      skb->h.raw is the DDP header, skb->len is the DDP length. The physical headers have been 
1324  *      extracted.
1325  */
1326  
1327 int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
     /*  */
1328 {
1329         atalk_socket *sock;
1330         struct ddpehdr *ddp=(void *)skb->h.raw;
1331         struct atalk_iface *atif;
1332         struct sockaddr_at tosat;
1333         
1334         /* Size check */
1335         if(skb->len<sizeof(*ddp))
1336         {
1337                 kfree_skb(skb,FREE_READ);
1338                 return(0);
1339         }
1340         
1341         
1342         /*
1343          *      Fix up the length field [Ok this is horrible but otherwise
1344          *      I end up with unions of bit fields and messy bit field order
1345          *      compiler/endian dependancies..]
1346          */
1347 
1348         *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
1349 
1350         /*
1351          *      Trim buffer in case of stray trailing data
1352          */
1353            
1354         skb->len=min(skb->len,ddp->deh_len);
1355 
1356         /*
1357          *      Size check to see if ddp->deh_len was crap
1358          *      (Otherwise we'll detonate most spectacularly
1359          *       in the middle of recvfrom()).
1360          */
1361          
1362         if(skb->len<sizeof(*ddp))
1363         {
1364                 kfree_skb(skb,FREE_READ);
1365                 return(0);
1366         }
1367 
1368         /*
1369          *      Any checksums. Note we don't do htons() on this == is assumed to be
1370          *      valid for net byte orders all over the networking code... 
1371          */
1372 
1373         if(ddp->deh_sum && atalk_checksum(ddp, ddp->deh_len)!= ddp->deh_sum)
1374         {
1375                 /* Not a valid appletalk frame - dustbin time */
1376                 kfree_skb(skb,FREE_READ);
1377                 return(0);
1378         }
1379         
1380         /* Check the packet is aimed at us */
1381 
1382         if(ddp->deh_dnet == 0)  /* Net 0 is 'this network' */
1383                 atif=atalk_find_anynet(ddp->deh_dnode, dev);
1384         else
1385                 atif=atalk_find_interface(ddp->deh_dnet,ddp->deh_dnode);
1386 
1387         /* Not ours */
1388         if(atif==NULL)          
1389         {
1390                 struct atalk_route *rt;
1391                 struct at_addr ta;
1392                 ta.s_net=ddp->deh_dnet;
1393                 ta.s_node=ddp->deh_dnode;
1394                 /* Route the packet */
1395                 rt=atrtr_find(&ta);
1396                 if(rt==NULL || ddp->deh_hops==15)
1397                 {
1398                         kfree_skb(skb, FREE_READ);
1399                         return(0);
1400                 }
1401                 ddp->deh_hops++;
1402                 *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));         /* Mend the byte order */
1403                 /*
1404                  *      Send the buffer onwards
1405                  */
1406                 if(aarp_send_ddp(dev,skb, &ta, NULL)==-1)
1407                         kfree_skb(skb, FREE_READ);
1408                 return 0;
1409         }
1410 
1411         /* Which socket - atalk_search_socket() looks for a *full match*
1412            of the <net,node,port> tuple */
1413         tosat.sat_addr.s_net = ddp->deh_dnet;
1414         tosat.sat_addr.s_node = ddp->deh_dnode;
1415         tosat.sat_port = ddp->deh_dport;
1416 
1417         sock=atalk_search_socket( &tosat, atif );
1418         
1419         if(sock==NULL)  /* But not one of our sockets */
1420         {
1421                 kfree_skb(skb,FREE_READ);
1422                 return(0);
1423         }
1424 
1425         
1426         /*
1427          *      Queue packet (standard)
1428          */
1429          
1430         skb->sk = sock;
1431 
1432         if(sock_queue_rcv_skb(sock,skb)<0)
1433         {
1434                 skb->sk=NULL;
1435                 kfree_skb(skb, FREE_WRITE);
1436         }
1437         return(0);
1438 }
1439 
1440 static int atalk_sendto(struct socket *sock, void *ubuf, int len, int noblock,
     /*  */
1441         unsigned flags, struct sockaddr *sat, int addr_len)
1442 {
1443         atalk_socket *sk=(atalk_socket *)sock->data;
1444         struct sockaddr_at *usat=(struct sockaddr_at *)sat;
1445         struct sockaddr_at local_satalk, gsat;
1446         struct sk_buff *skb;
1447         struct device *dev;
1448         struct ddpehdr *ddp;
1449         int size;
1450         struct atalk_route *rt;
1451         int loopback=0;
1452         int err;
1453         
1454         if(flags)
1455                 return -EINVAL;
1456                 
1457         if(len>587)
1458                 return -EMSGSIZE;
1459                 
1460         if(usat)
1461         {
1462                 if(sk->zapped)
1463                 /* put the autobinding in */
1464                 {
1465                         if(atalk_autobind(sk)<0)
1466                                 return -EBUSY;
1467                 }
1468 
1469                 if(addr_len <sizeof(*usat))
1470                         return(-EINVAL);
1471                 if(usat->sat_family != AF_APPLETALK)
1472                         return -EINVAL;
1473 #if 0   /* netatalk doesnt implement this check */
1474                 if(usat->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
1475                         return -EPERM;
1476 #endif                  
1477         }
1478         else
1479         {
1480                 if(sk->state!=TCP_ESTABLISHED)
1481                         return -ENOTCONN;
1482                 usat=&local_satalk;
1483                 usat->sat_family=AF_APPLETALK;
1484                 usat->sat_port=sk->at.dest_port;
1485                 usat->sat_addr.s_node=sk->at.dest_node;
1486                 usat->sat_addr.s_net=sk->at.dest_net;
1487         }
1488         
1489         /* Build a packet */
1490         
1491         if(sk->debug)
1492                 printk("SK %p: Got address.\n",sk);
1493         
1494         size=sizeof(struct ddpehdr)+len+ddp_dl->header_length;  /* For headers */
1495 
1496         if(usat->sat_addr.s_net!=0 || usat->sat_addr.s_node == ATADDR_ANYNODE)
1497         {
1498                 rt=atrtr_find(&usat->sat_addr);
1499                 if(rt==NULL)
1500                         return -ENETUNREACH;    
1501                 dev=rt->dev;
1502         }
1503         else
1504         {
1505                 struct at_addr at_hint;
1506                 at_hint.s_node=0;
1507                 at_hint.s_net=sk->at.src_net;
1508                 rt=atrtr_find(&at_hint);
1509                 if(rt==NULL)
1510                         return -ENETUNREACH;
1511                 dev=rt->dev;
1512         }
1513 
1514         if(sk->debug)
1515                 printk("SK %p: Size needed %d, device %s\n", sk, size, dev->name);
1516         
1517         size += dev->hard_header_len;
1518 
1519         skb = sock_alloc_send_skb(sk, size, 0 , &err);
1520         if(skb==NULL)
1521                 return err;
1522 
1523         skb->sk=sk;
1524         skb->free=1;
1525         skb->arp=1;
1526         skb->len=size;
1527 
1528         skb->dev=dev;
1529         
1530         if(sk->debug)
1531                 printk("SK %p: Begin build.\n", sk);
1532         
1533         skb->h.raw=skb->data+ddp_dl->header_length+dev->hard_header_len;        
1534         
1535         ddp=(struct ddpehdr *)skb->h.raw;
1536         ddp->deh_pad=0;
1537         ddp->deh_hops=0;
1538         ddp->deh_len=len+sizeof(*ddp);
1539         /*
1540          *      Fix up the length field [Ok this is horrible but otherwise
1541          *      I end up with unions of bit fields and messy bit field order
1542          *      compiler/endian dependancies..
1543          */
1544         *((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
1545 
1546         ddp->deh_dnet=usat->sat_addr.s_net;
1547         ddp->deh_snet=sk->at.src_net;
1548         ddp->deh_dnode=usat->sat_addr.s_node;
1549         ddp->deh_snode=sk->at.src_node;
1550         ddp->deh_dport=usat->sat_port;
1551         ddp->deh_sport=sk->at.src_port;
1552 
1553         if(sk->debug)
1554                 printk("SK %p: Copy user data (%d bytes).\n", sk, len);
1555                 
1556         memcpy_fromfs((char *)(ddp+1),ubuf,len);
1557 
1558         if(sk->no_check==1)
1559                 ddp->deh_sum=0;
1560         else
1561                 ddp->deh_sum=atalk_checksum(ddp, len+sizeof(*ddp));
1562         
1563         /*
1564          *      Loopback broadcast packets to non gateway targets (ie routes
1565          *      to group we are in)
1566          */
1567          
1568         if(ddp->deh_dnode==ATADDR_BCAST)
1569         {
1570                 if((!(rt->flags&RTF_GATEWAY))&&(!(dev->flags&IFF_LOOPBACK)))
1571                 {
1572                         struct sk_buff *skb2=skb_clone(skb, GFP_KERNEL);
1573                         if(skb2)
1574                         {
1575                                 loopback=1;
1576                                 if(sk->debug)
1577                                         printk("SK %p: send out(copy).\n", sk);
1578                                 if(aarp_send_ddp(dev,skb2,&usat->sat_addr, NULL)==-1)
1579                                         kfree_skb(skb2, FREE_WRITE);
1580                                 /* else queued/sent above in the aarp queue */
1581                         }
1582                 }
1583         }
1584 
1585         if((dev->flags&IFF_LOOPBACK) || loopback) 
1586         {
1587                 if(sk->debug)
1588                         printk("SK %p: Loop back.\n", sk);
1589                 /* loop back */
1590                 sk->wmem_alloc-=skb->mem_len;
1591                 ddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
1592                 skb->sk = NULL;
1593                 skb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
1594                 skb->len -= ddp_dl->header_length ;
1595                 skb->len -= dev->hard_header_len ;
1596                 atalk_rcv(skb,dev,NULL);
1597         }
1598         else 
1599         {
1600                 if(sk->debug)
1601                         printk("SK %p: send out.\n", sk);
1602 
1603                 if ( rt->flags & RTF_GATEWAY ) {
1604                     gsat.sat_addr = rt->gateway;
1605                     usat = &gsat;
1606                 }
1607         
1608                 if(aarp_send_ddp(dev,skb,&usat->sat_addr, NULL)==-1)
1609                         kfree_skb(skb, FREE_WRITE);
1610                 /* else queued/sent above in the aarp queue */
1611         }
1612         if(sk->debug)
1613                 printk("SK %p: Done write (%d).\n", sk, len);
1614         return len;
1615 }
1616 
1617 static int atalk_send(struct socket *sock, void *ubuf, int size, int noblock, unsigned flags)
     /*  */
1618 {
1619         return atalk_sendto(sock,ubuf,size,noblock,flags,NULL,0);
1620 }
1621 
1622 static int atalk_recvfrom(struct socket *sock, void *ubuf, int size, int noblock,
     /*  */
1623                    unsigned flags, struct sockaddr *sip, int *addr_len)
1624 {
1625         atalk_socket *sk=(atalk_socket *)sock->data;
1626         struct sockaddr_at *sat=(struct sockaddr_at *)sip;
1627         struct ddpehdr  *ddp = NULL;
1628         int copied = 0;
1629         struct sk_buff *skb;
1630         int er;
1631         
1632         if(sk->err)
1633         {
1634                 er= -sk->err;
1635                 sk->err=0;
1636                 return er;
1637         }
1638         
1639         if(addr_len)
1640                 *addr_len=sizeof(*sat);
1641 
1642         skb=skb_recv_datagram(sk,flags,noblock,&er);
1643         if(skb==NULL)
1644                 return er;
1645 
1646         ddp = (struct ddpehdr *)(skb->h.raw);
1647         if(sk->type==SOCK_RAW)
1648         {
1649                 copied=ddp->deh_len;
1650                 if(copied > size)
1651                         copied=size;
1652                 skb_copy_datagram(skb,0,ubuf,copied);
1653         }
1654         else
1655         {
1656                 copied=ddp->deh_len - sizeof(*ddp);
1657                 if (copied > size)
1658                         copied = size;
1659                 skb_copy_datagram(skb,sizeof(*ddp),ubuf,copied);
1660         }
1661         if(sat)
1662         {
1663                 sat->sat_family=AF_APPLETALK;
1664                 sat->sat_port=ddp->deh_sport;
1665                 sat->sat_addr.s_node=ddp->deh_snode;
1666                 sat->sat_addr.s_net=ddp->deh_snet;
1667         }
1668         skb_free_datagram(skb);
1669         return(copied);
1670 }               
1671 
1672 
1673 static int atalk_write(struct socket *sock, char *ubuf, int size, int noblock)
     /*  */
1674 {
1675         return atalk_send(sock,ubuf,size,noblock,0);
1676 }
1677 
1678 
1679 static int atalk_recv(struct socket *sock, void *ubuf, int size , int noblock,
     /*  */
1680         unsigned flags)
1681 {
1682         atalk_socket *sk=(atalk_socket *)sock->data;
1683         if(sk->zapped)
1684                 return -ENOTCONN;
1685         return atalk_recvfrom(sock,ubuf,size,noblock,flags,NULL, NULL);
1686 }
1687 
1688 static int atalk_read(struct socket *sock, char *ubuf, int size, int noblock)
     /*  */
1689 {
1690         return atalk_recv(sock,ubuf,size,noblock,0);
1691 }
1692 
1693 
1694 static int atalk_shutdown(struct socket *sk,int how)
     /*  */
1695 {
1696         return -EOPNOTSUPP;
1697 }
1698 
1699 static int atalk_select(struct socket *sock , int sel_type, select_table *wait)
     /*  */
1700 {
1701         atalk_socket *sk=(atalk_socket *)sock->data;
1702         
1703         return datagram_select(sk,sel_type,wait);
1704 }
1705 
1706 /*
1707  *      Appletalk ioctl calls.
1708  */
1709 
1710 static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
     /*  */
1711 {
1712         int err;
1713         long amount=0;
1714         atalk_socket *sk=(atalk_socket *)sock->data;
1715         int v;
1716         
1717         switch(cmd)
1718         {
1719                 /*
1720                  *      Protocol layer
1721                  */
1722                 case TIOCOUTQ:
1723                         v=sk->sndbuf-sk->wmem_alloc;
1724                         if(v<0)
1725                                 v=0;
1726                         break;
1727                 case TIOCINQ:
1728                 {
1729                         struct sk_buff *skb;
1730                         /* These two are safe on a single CPU system as only user tasks fiddle here */
1731                         if((skb=skb_peek(&sk->receive_queue))!=NULL)
1732                                 v=skb->len-sizeof(struct ddpehdr);
1733                         break;
1734                 }
1735                 case SIOCGSTAMP:
1736                         if (sk)
1737                         {
1738                                 if(sk->stamp.tv_sec==0)
1739                                         return -ENOENT;
1740                                 err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
1741                                 if(err)
1742                                         return err;
1743                                         memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
1744                                 return 0;
1745                         }
1746                         return -EINVAL;
1747                 /*
1748                  *      Routing
1749                  */
1750                 case SIOCADDRT:
1751                 case SIOCDELRT:
1752                         if(!suser())
1753                                 return -EPERM;
1754                         return(atrtr_ioctl(cmd,(void *)arg));
1755                 /*
1756                  *      Interface
1757                  */                     
1758                 case SIOCGIFADDR:
1759                 case SIOCSIFADDR:
1760                 case SIOCGIFBRDADDR:
1761                         return atif_ioctl(cmd,(void *)arg);
1762                 /*
1763                  *      Physical layer ioctl calls
1764                  */
1765                 case SIOCSIFLINK:
1766                 case SIOCGIFHWADDR:
1767                 case SIOCSIFHWADDR:
1768                 case OLD_SIOCGIFHWADDR:
1769                 case SIOCGIFFLAGS:
1770                 case SIOCSIFFLAGS:
1771                 case SIOCGIFMTU:
1772                 case SIOCGIFCONF:
1773                 case SIOCADDMULTI:
1774                 case SIOCDELMULTI:
1775 
1776                         return(dev_ioctl(cmd,(void *) arg));
1777 
1778                 case SIOCSIFMETRIC:
1779                 case SIOCSIFBRDADDR:
1780                 case SIOCGIFNETMASK:
1781                 case SIOCSIFNETMASK:
1782                 case SIOCGIFMEM:
1783                 case SIOCSIFMEM:
1784                 case SIOCGIFDSTADDR:
1785                 case SIOCSIFDSTADDR:
1786                         return -EINVAL;
1787 
1788                 default:
1789                         return -EINVAL;
1790         }
1791         err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
1792         if(err)
1793                 return err;
1794         put_fs_long(amount,(unsigned long *)arg);
1795         return(0);
1796 }
1797 
1798 static struct proto_ops atalk_proto_ops = {
1799         AF_APPLETALK,
1800         
1801         atalk_create,
1802         atalk_dup,
1803         atalk_release,
1804         atalk_bind,
1805         atalk_connect,
1806         atalk_socketpair,
1807         atalk_accept,
1808         atalk_getname,
1809         atalk_read,
1810         atalk_write,
1811         atalk_select,
1812         atalk_ioctl,
1813         atalk_listen,
1814         atalk_send,
1815         atalk_recv,
1816         atalk_sendto,
1817         atalk_recvfrom,
1818         atalk_shutdown,
1819         atalk_setsockopt,
1820         atalk_getsockopt,
1821         atalk_fcntl,
1822 };
1823 
1824 static struct notifier_block ddp_notifier={
1825         ddp_device_event,
1826         NULL,
1827         0
1828 };
1829 
1830 /* Called by proto.c on kernel start up */
1831 
1832 void atalk_proto_init(struct net_proto *pro)
     /*  */
1833 {
1834         static char ddp_snap_id[]={0x08,0x00,0x07,0x80,0x9B};
1835         (void) sock_register(atalk_proto_ops.family, &atalk_proto_ops);
1836         if((ddp_dl=register_snap_client(ddp_snap_id, atalk_rcv))==NULL)
1837                 printk("Unable to register DDP with SNAP.\n");
1838         register_netdevice_notifier(&ddp_notifier);
1839         aarp_proto_init();
1840         printk("Appletalk ALPHA 0.08 for Linux NET3.029\n");
1841         
1842 }
1843 #endif
/* */
root/net/appletalk/ddp.c

DEFINITIONS
