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