root/net/appletalk/ddp.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

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

/* [previous][next][first][last][top][bottom][index][help] */