net/appletalk/ddp.c

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