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

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