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

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

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