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

DEFINITIONS
