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. ltalk_rcv
  46. atalk_sendmsg
  47. atalk_recvmsg
  48. atalk_shutdown
  49. atalk_select
  50. atalk_ioctl
  51. atalk_proto_init
  52. init_module
  53. free_route_list
  54. free_interface_list
  55. cleanup_module

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

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