linux/net/econet/af_econet.c
<<
>>
Prefs
   1/*
   2 *      An implementation of the Acorn Econet and AUN protocols.
   3 *      Philip Blundell <philb@gnu.org>
   4 *
   5 *      This program is free software; you can redistribute it and/or
   6 *      modify it under the terms of the GNU General Public License
   7 *      as published by the Free Software Foundation; either version
   8 *      2 of the License, or (at your option) any later version.
   9 *
  10 */
  11
  12#include <linux/module.h>
  13
  14#include <linux/types.h>
  15#include <linux/kernel.h>
  16#include <linux/string.h>
  17#include <linux/mm.h>
  18#include <linux/socket.h>
  19#include <linux/sockios.h>
  20#include <linux/in.h>
  21#include <linux/errno.h>
  22#include <linux/interrupt.h>
  23#include <linux/if_ether.h>
  24#include <linux/netdevice.h>
  25#include <linux/inetdevice.h>
  26#include <linux/route.h>
  27#include <linux/inet.h>
  28#include <linux/etherdevice.h>
  29#include <linux/if_arp.h>
  30#include <linux/wireless.h>
  31#include <linux/skbuff.h>
  32#include <linux/udp.h>
  33#include <linux/slab.h>
  34#include <linux/vmalloc.h>
  35#include <net/sock.h>
  36#include <net/inet_common.h>
  37#include <linux/stat.h>
  38#include <linux/init.h>
  39#include <linux/if_ec.h>
  40#include <net/udp.h>
  41#include <net/ip.h>
  42#include <linux/spinlock.h>
  43#include <linux/rcupdate.h>
  44#include <linux/bitops.h>
  45#include <linux/mutex.h>
  46
  47#include <asm/uaccess.h>
  48#include <asm/system.h>
  49
  50static const struct proto_ops econet_ops;
  51static struct hlist_head econet_sklist;
  52static DEFINE_SPINLOCK(econet_lock);
  53static DEFINE_MUTEX(econet_mutex);
  54
  55/* Since there are only 256 possible network numbers (or fewer, depends
  56   how you count) it makes sense to use a simple lookup table. */
  57static struct net_device *net2dev_map[256];
  58
  59#define EC_PORT_IP      0xd2
  60
  61#ifdef CONFIG_ECONET_AUNUDP
  62static DEFINE_SPINLOCK(aun_queue_lock);
  63static struct socket *udpsock;
  64#define AUN_PORT        0x8000
  65
  66
  67struct aunhdr
  68{
  69        unsigned char code;             /* AUN magic protocol byte */
  70        unsigned char port;
  71        unsigned char cb;
  72        unsigned char pad;
  73        unsigned long handle;
  74};
  75
  76static unsigned long aun_seq;
  77
  78/* Queue of packets waiting to be transmitted. */
  79static struct sk_buff_head aun_queue;
  80static struct timer_list ab_cleanup_timer;
  81
  82#endif          /* CONFIG_ECONET_AUNUDP */
  83
  84/* Per-packet information */
  85struct ec_cb
  86{
  87        struct sockaddr_ec sec;
  88        unsigned long cookie;           /* Supplied by user. */
  89#ifdef CONFIG_ECONET_AUNUDP
  90        int done;
  91        unsigned long seq;              /* Sequencing */
  92        unsigned long timeout;          /* Timeout */
  93        unsigned long start;            /* jiffies */
  94#endif
  95#ifdef CONFIG_ECONET_NATIVE
  96        void (*sent)(struct sk_buff *, int result);
  97#endif
  98};
  99
 100static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
 101{
 102        spin_lock_bh(&econet_lock);
 103        sk_del_node_init(sk);
 104        spin_unlock_bh(&econet_lock);
 105}
 106
 107static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
 108{
 109        spin_lock_bh(&econet_lock);
 110        sk_add_node(sk, list);
 111        spin_unlock_bh(&econet_lock);
 112}
 113
 114/*
 115 *      Pull a packet from our receive queue and hand it to the user.
 116 *      If necessary we block.
 117 */
 118
 119static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
 120                          struct msghdr *msg, size_t len, int flags)
 121{
 122        struct sock *sk = sock->sk;
 123        struct sk_buff *skb;
 124        size_t copied;
 125        int err;
 126
 127        msg->msg_namelen = sizeof(struct sockaddr_ec);
 128
 129        mutex_lock(&econet_mutex);
 130
 131        /*
 132         *      Call the generic datagram receiver. This handles all sorts
 133         *      of horrible races and re-entrancy so we can forget about it
 134         *      in the protocol layers.
 135         *
 136         *      Now it will return ENETDOWN, if device have just gone down,
 137         *      but then it will block.
 138         */
 139
 140        skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
 141
 142        /*
 143         *      An error occurred so return it. Because skb_recv_datagram()
 144         *      handles the blocking we don't see and worry about blocking
 145         *      retries.
 146         */
 147
 148        if(skb==NULL)
 149                goto out;
 150
 151        /*
 152         *      You lose any data beyond the buffer you gave. If it worries a
 153         *      user program they can ask the device for its MTU anyway.
 154         */
 155
 156        copied = skb->len;
 157        if (copied > len)
 158        {
 159                copied=len;
 160                msg->msg_flags|=MSG_TRUNC;
 161        }
 162
 163        /* We can't use skb_copy_datagram here */
 164        err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
 165        if (err)
 166                goto out_free;
 167        sk->sk_stamp = skb->tstamp;
 168
 169        if (msg->msg_name)
 170                memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 171
 172        /*
 173         *      Free or return the buffer as appropriate. Again this
 174         *      hides all the races and re-entrancy issues from us.
 175         */
 176        err = copied;
 177
 178out_free:
 179        skb_free_datagram(sk, skb);
 180out:
 181        mutex_unlock(&econet_mutex);
 182        return err;
 183}
 184
 185/*
 186 *      Bind an Econet socket.
 187 */
 188
 189static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 190{
 191        struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 192        struct sock *sk;
 193        struct econet_sock *eo;
 194
 195        /*
 196         *      Check legality
 197         */
 198
 199        if (addr_len < sizeof(struct sockaddr_ec) ||
 200            sec->sec_family != AF_ECONET)
 201                return -EINVAL;
 202
 203        mutex_lock(&econet_mutex);
 204
 205        sk = sock->sk;
 206        eo = ec_sk(sk);
 207
 208        eo->cb      = sec->cb;
 209        eo->port    = sec->port;
 210        eo->station = sec->addr.station;
 211        eo->net     = sec->addr.net;
 212
 213        mutex_unlock(&econet_mutex);
 214
 215        return 0;
 216}
 217
 218#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 219/*
 220 *      Queue a transmit result for the user to be told about.
 221 */
 222
 223static void tx_result(struct sock *sk, unsigned long cookie, int result)
 224{
 225        struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
 226        struct ec_cb *eb;
 227        struct sockaddr_ec *sec;
 228
 229        if (skb == NULL)
 230        {
 231                printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
 232                return;
 233        }
 234
 235        eb = (struct ec_cb *)&skb->cb;
 236        sec = (struct sockaddr_ec *)&eb->sec;
 237        memset(sec, 0, sizeof(struct sockaddr_ec));
 238        sec->cookie = cookie;
 239        sec->type = ECTYPE_TRANSMIT_STATUS | result;
 240        sec->sec_family = AF_ECONET;
 241
 242        if (sock_queue_rcv_skb(sk, skb) < 0)
 243                kfree_skb(skb);
 244}
 245#endif
 246
 247#ifdef CONFIG_ECONET_NATIVE
 248/*
 249 *      Called by the Econet hardware driver when a packet transmit
 250 *      has completed.  Tell the user.
 251 */
 252
 253static void ec_tx_done(struct sk_buff *skb, int result)
 254{
 255        struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 256        tx_result(skb->sk, eb->cookie, result);
 257}
 258#endif
 259
 260/*
 261 *      Send a packet.  We have to work out which device it's going out on
 262 *      and hence whether to use real Econet or the UDP emulation.
 263 */
 264
 265static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
 266                          struct msghdr *msg, size_t len)
 267{
 268        struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
 269        struct net_device *dev;
 270        struct ec_addr addr;
 271        int err;
 272        unsigned char port, cb;
 273#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 274        struct sock *sk = sock->sk;
 275        struct sk_buff *skb;
 276        struct ec_cb *eb;
 277#endif
 278#ifdef CONFIG_ECONET_AUNUDP
 279        struct msghdr udpmsg;
 280        struct iovec iov[2];
 281        struct aunhdr ah;
 282        struct sockaddr_in udpdest;
 283        __kernel_size_t size;
 284        mm_segment_t oldfs;
 285        char *userbuf;
 286#endif
 287
 288        /*
 289         *      Check the flags.
 290         */
 291
 292        if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 293                return -EINVAL;
 294
 295        /*
 296         *      Get and verify the address.
 297         */
 298
 299        mutex_lock(&econet_mutex);
 300
 301        if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
 302                mutex_unlock(&econet_mutex);
 303                return -EINVAL;
 304        }
 305        addr.station = saddr->addr.station;
 306        addr.net = saddr->addr.net;
 307        port = saddr->port;
 308        cb = saddr->cb;
 309
 310        /* Look for a device with the right network number. */
 311        dev = net2dev_map[addr.net];
 312
 313        /* If not directly reachable, use some default */
 314        if (dev == NULL) {
 315                dev = net2dev_map[0];
 316                /* No interfaces at all? */
 317                if (dev == NULL) {
 318                        mutex_unlock(&econet_mutex);
 319                        return -ENETDOWN;
 320                }
 321        }
 322
 323        if (dev->type == ARPHRD_ECONET) {
 324                /* Real hardware Econet.  We're not worthy etc. */
 325#ifdef CONFIG_ECONET_NATIVE
 326                unsigned short proto = 0;
 327                int res;
 328
 329                if (len + 15 > dev->mtu) {
 330                        mutex_unlock(&econet_mutex);
 331                        return -EMSGSIZE;
 332                }
 333
 334                dev_hold(dev);
 335
 336                skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
 337                                          msg->msg_flags & MSG_DONTWAIT, &err);
 338                if (skb==NULL)
 339                        goto out_unlock;
 340
 341                skb_reserve(skb, LL_RESERVED_SPACE(dev));
 342                skb_reset_network_header(skb);
 343
 344                eb = (struct ec_cb *)&skb->cb;
 345
 346                eb->cookie = saddr->cookie;
 347                eb->sec = *saddr;
 348                eb->sent = ec_tx_done;
 349
 350                err = -EINVAL;
 351                res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
 352                if (res < 0)
 353                        goto out_free;
 354                if (res > 0) {
 355                        struct ec_framehdr *fh;
 356                        /* Poke in our control byte and
 357                           port number.  Hack, hack.  */
 358                        fh = (struct ec_framehdr *)(skb->data);
 359                        fh->cb = cb;
 360                        fh->port = port;
 361                        if (sock->type != SOCK_DGRAM) {
 362                                skb_reset_tail_pointer(skb);
 363                                skb->len = 0;
 364                        }
 365                }
 366
 367                /* Copy the data. Returns -EFAULT on error */
 368                err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 369                skb->protocol = proto;
 370                skb->dev = dev;
 371                skb->priority = sk->sk_priority;
 372                if (err)
 373                        goto out_free;
 374
 375                err = -ENETDOWN;
 376                if (!(dev->flags & IFF_UP))
 377                        goto out_free;
 378
 379                /*
 380                 *      Now send it
 381                 */
 382
 383                dev_queue_xmit(skb);
 384                dev_put(dev);
 385                mutex_unlock(&econet_mutex);
 386                return len;
 387
 388        out_free:
 389                kfree_skb(skb);
 390        out_unlock:
 391                if (dev)
 392                        dev_put(dev);
 393#else
 394                err = -EPROTOTYPE;
 395#endif
 396                mutex_unlock(&econet_mutex);
 397
 398                return err;
 399        }
 400
 401#ifdef CONFIG_ECONET_AUNUDP
 402        /* AUN virtual Econet. */
 403
 404        if (udpsock == NULL) {
 405                mutex_unlock(&econet_mutex);
 406                return -ENETDOWN;               /* No socket - can't send */
 407        }
 408
 409        if (len > 32768) {
 410                err = -E2BIG;
 411                goto error;
 412        }
 413
 414        /* Make up a UDP datagram and hand it off to some higher intellect. */
 415
 416        memset(&udpdest, 0, sizeof(udpdest));
 417        udpdest.sin_family = AF_INET;
 418        udpdest.sin_port = htons(AUN_PORT);
 419
 420        /* At the moment we use the stupid Acorn scheme of Econet address
 421           y.x maps to IP a.b.c.x.  This should be replaced with something
 422           more flexible and more aware of subnet masks.  */
 423        {
 424                struct in_device *idev;
 425                unsigned long network = 0;
 426
 427                rcu_read_lock();
 428                idev = __in_dev_get_rcu(dev);
 429                if (idev) {
 430                        if (idev->ifa_list)
 431                                network = ntohl(idev->ifa_list->ifa_address) &
 432                                        0xffffff00;             /* !!! */
 433                }
 434                rcu_read_unlock();
 435                udpdest.sin_addr.s_addr = htonl(network | addr.station);
 436        }
 437
 438        memset(&ah, 0, sizeof(ah));
 439        ah.port = port;
 440        ah.cb = cb & 0x7f;
 441        ah.code = 2;            /* magic */
 442
 443        /* tack our header on the front of the iovec */
 444        size = sizeof(struct aunhdr);
 445        iov[0].iov_base = (void *)&ah;
 446        iov[0].iov_len = size;
 447
 448        userbuf = vmalloc(len);
 449        if (userbuf == NULL) {
 450                err = -ENOMEM;
 451                goto error;
 452        }
 453
 454        iov[1].iov_base = userbuf;
 455        iov[1].iov_len = len;
 456        err = memcpy_fromiovec(userbuf, msg->msg_iov, len);
 457        if (err)
 458                goto error_free_buf;
 459
 460        /* Get a skbuff (no data, just holds our cb information) */
 461        if ((skb = sock_alloc_send_skb(sk, 0,
 462                                       msg->msg_flags & MSG_DONTWAIT,
 463                                       &err)) == NULL)
 464                goto error_free_buf;
 465
 466        eb = (struct ec_cb *)&skb->cb;
 467
 468        eb->cookie = saddr->cookie;
 469        eb->timeout = (5*HZ);
 470        eb->start = jiffies;
 471        ah.handle = aun_seq;
 472        eb->seq = (aun_seq++);
 473        eb->sec = *saddr;
 474
 475        skb_queue_tail(&aun_queue, skb);
 476
 477        udpmsg.msg_name = (void *)&udpdest;
 478        udpmsg.msg_namelen = sizeof(udpdest);
 479        udpmsg.msg_iov = &iov[0];
 480        udpmsg.msg_iovlen = 2;
 481        udpmsg.msg_control = NULL;
 482        udpmsg.msg_controllen = 0;
 483        udpmsg.msg_flags=0;
 484
 485        oldfs = get_fs(); set_fs(KERNEL_DS);    /* More privs :-) */
 486        err = sock_sendmsg(udpsock, &udpmsg, size);
 487        set_fs(oldfs);
 488
 489error_free_buf:
 490        vfree(userbuf);
 491error:
 492#else
 493        err = -EPROTOTYPE;
 494#endif
 495        mutex_unlock(&econet_mutex);
 496
 497        return err;
 498}
 499
 500/*
 501 *      Look up the address of a socket.
 502 */
 503
 504static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
 505                          int *uaddr_len, int peer)
 506{
 507        struct sock *sk;
 508        struct econet_sock *eo;
 509        struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 510
 511        if (peer)
 512                return -EOPNOTSUPP;
 513
 514        memset(sec, 0, sizeof(*sec));
 515        mutex_lock(&econet_mutex);
 516
 517        sk = sock->sk;
 518        eo = ec_sk(sk);
 519
 520        sec->sec_family   = AF_ECONET;
 521        sec->port         = eo->port;
 522        sec->addr.station = eo->station;
 523        sec->addr.net     = eo->net;
 524
 525        mutex_unlock(&econet_mutex);
 526
 527        *uaddr_len = sizeof(*sec);
 528        return 0;
 529}
 530
 531static void econet_destroy_timer(unsigned long data)
 532{
 533        struct sock *sk=(struct sock *)data;
 534
 535        if (!sk_has_allocations(sk)) {
 536                sk_free(sk);
 537                return;
 538        }
 539
 540        sk->sk_timer.expires = jiffies + 10 * HZ;
 541        add_timer(&sk->sk_timer);
 542        printk(KERN_DEBUG "econet socket destroy delayed\n");
 543}
 544
 545/*
 546 *      Close an econet socket.
 547 */
 548
 549static int econet_release(struct socket *sock)
 550{
 551        struct sock *sk;
 552
 553        mutex_lock(&econet_mutex);
 554
 555        sk = sock->sk;
 556        if (!sk)
 557                goto out_unlock;
 558
 559        econet_remove_socket(&econet_sklist, sk);
 560
 561        /*
 562         *      Now the socket is dead. No more input will appear.
 563         */
 564
 565        sk->sk_state_change(sk);        /* It is useless. Just for sanity. */
 566
 567        sock_orphan(sk);
 568
 569        /* Purge queues */
 570
 571        skb_queue_purge(&sk->sk_receive_queue);
 572
 573        if (sk_has_allocations(sk)) {
 574                sk->sk_timer.data     = (unsigned long)sk;
 575                sk->sk_timer.expires  = jiffies + HZ;
 576                sk->sk_timer.function = econet_destroy_timer;
 577                add_timer(&sk->sk_timer);
 578
 579                goto out_unlock;
 580        }
 581
 582        sk_free(sk);
 583
 584out_unlock:
 585        mutex_unlock(&econet_mutex);
 586        return 0;
 587}
 588
 589static struct proto econet_proto = {
 590        .name     = "ECONET",
 591        .owner    = THIS_MODULE,
 592        .obj_size = sizeof(struct econet_sock),
 593};
 594
 595/*
 596 *      Create an Econet socket
 597 */
 598
 599static int econet_create(struct net *net, struct socket *sock, int protocol,
 600                         int kern)
 601{
 602        struct sock *sk;
 603        struct econet_sock *eo;
 604        int err;
 605
 606        if (!net_eq(net, &init_net))
 607                return -EAFNOSUPPORT;
 608
 609        /* Econet only provides datagram services. */
 610        if (sock->type != SOCK_DGRAM)
 611                return -ESOCKTNOSUPPORT;
 612
 613        sock->state = SS_UNCONNECTED;
 614
 615        err = -ENOBUFS;
 616        sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
 617        if (sk == NULL)
 618                goto out;
 619
 620        sk->sk_reuse = 1;
 621        sock->ops = &econet_ops;
 622        sock_init_data(sock, sk);
 623
 624        eo = ec_sk(sk);
 625        sock_reset_flag(sk, SOCK_ZAPPED);
 626        sk->sk_family = PF_ECONET;
 627        eo->num = protocol;
 628
 629        econet_insert_socket(&econet_sklist, sk);
 630        return 0;
 631out:
 632        return err;
 633}
 634
 635/*
 636 *      Handle Econet specific ioctls
 637 */
 638
 639static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
 640{
 641        struct ifreq ifr;
 642        struct ec_device *edev;
 643        struct net_device *dev;
 644        struct sockaddr_ec *sec;
 645        int err;
 646
 647        /*
 648         *      Fetch the caller's info block into kernel space
 649         */
 650
 651        if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 652                return -EFAULT;
 653
 654        if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
 655                return -ENODEV;
 656
 657        sec = (struct sockaddr_ec *)&ifr.ifr_addr;
 658
 659        mutex_lock(&econet_mutex);
 660
 661        err = 0;
 662        switch (cmd) {
 663        case SIOCSIFADDR:
 664                if (!capable(CAP_NET_ADMIN)) {
 665                        err = -EPERM;
 666                        break;
 667                }
 668
 669                edev = dev->ec_ptr;
 670                if (edev == NULL) {
 671                        /* Magic up a new one. */
 672                        edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
 673                        if (edev == NULL) {
 674                                err = -ENOMEM;
 675                                break;
 676                        }
 677                        dev->ec_ptr = edev;
 678                } else
 679                        net2dev_map[edev->net] = NULL;
 680                edev->station = sec->addr.station;
 681                edev->net = sec->addr.net;
 682                net2dev_map[sec->addr.net] = dev;
 683                if (!net2dev_map[0])
 684                        net2dev_map[0] = dev;
 685                break;
 686
 687        case SIOCGIFADDR:
 688                edev = dev->ec_ptr;
 689                if (edev == NULL) {
 690                        err = -ENODEV;
 691                        break;
 692                }
 693                memset(sec, 0, sizeof(struct sockaddr_ec));
 694                sec->addr.station = edev->station;
 695                sec->addr.net = edev->net;
 696                sec->sec_family = AF_ECONET;
 697                dev_put(dev);
 698                if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 699                        err = -EFAULT;
 700                break;
 701
 702        default:
 703                err = -EINVAL;
 704                break;
 705        }
 706
 707        mutex_unlock(&econet_mutex);
 708
 709        dev_put(dev);
 710
 711        return err;
 712}
 713
 714/*
 715 *      Handle generic ioctls
 716 */
 717
 718static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 719{
 720        struct sock *sk = sock->sk;
 721        void __user *argp = (void __user *)arg;
 722
 723        switch(cmd) {
 724                case SIOCGSTAMP:
 725                        return sock_get_timestamp(sk, argp);
 726
 727                case SIOCGSTAMPNS:
 728                        return sock_get_timestampns(sk, argp);
 729
 730                case SIOCSIFADDR:
 731                case SIOCGIFADDR:
 732                        return ec_dev_ioctl(sock, cmd, argp);
 733                        break;
 734
 735                default:
 736                        return -ENOIOCTLCMD;
 737        }
 738        /*NOTREACHED*/
 739        return 0;
 740}
 741
 742static const struct net_proto_family econet_family_ops = {
 743        .family =       PF_ECONET,
 744        .create =       econet_create,
 745        .owner  =       THIS_MODULE,
 746};
 747
 748static const struct proto_ops econet_ops = {
 749        .family =       PF_ECONET,
 750        .owner =        THIS_MODULE,
 751        .release =      econet_release,
 752        .bind =         econet_bind,
 753        .connect =      sock_no_connect,
 754        .socketpair =   sock_no_socketpair,
 755        .accept =       sock_no_accept,
 756        .getname =      econet_getname,
 757        .poll =         datagram_poll,
 758        .ioctl =        econet_ioctl,
 759        .listen =       sock_no_listen,
 760        .shutdown =     sock_no_shutdown,
 761        .setsockopt =   sock_no_setsockopt,
 762        .getsockopt =   sock_no_getsockopt,
 763        .sendmsg =      econet_sendmsg,
 764        .recvmsg =      econet_recvmsg,
 765        .mmap =         sock_no_mmap,
 766        .sendpage =     sock_no_sendpage,
 767};
 768
 769#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 770/*
 771 *      Find the listening socket, if any, for the given data.
 772 */
 773
 774static struct sock *ec_listening_socket(unsigned char port, unsigned char
 775                                 station, unsigned char net)
 776{
 777        struct sock *sk;
 778        struct hlist_node *node;
 779
 780        spin_lock(&econet_lock);
 781        sk_for_each(sk, node, &econet_sklist) {
 782                struct econet_sock *opt = ec_sk(sk);
 783                if ((opt->port == port || opt->port == 0) &&
 784                    (opt->station == station || opt->station == 0) &&
 785                    (opt->net == net || opt->net == 0)) {
 786                        sock_hold(sk);
 787                        goto found;
 788                }
 789        }
 790        sk = NULL;
 791found:
 792        spin_unlock(&econet_lock);
 793        return sk;
 794}
 795
 796/*
 797 *      Queue a received packet for a socket.
 798 */
 799
 800static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 801                           unsigned char stn, unsigned char net,
 802                           unsigned char cb, unsigned char port)
 803{
 804        struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 805        struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 806
 807        memset(sec, 0, sizeof(struct sockaddr_ec));
 808        sec->sec_family = AF_ECONET;
 809        sec->type = ECTYPE_PACKET_RECEIVED;
 810        sec->port = port;
 811        sec->cb = cb;
 812        sec->addr.net = net;
 813        sec->addr.station = stn;
 814
 815        return sock_queue_rcv_skb(sk, skb);
 816}
 817#endif
 818
 819#ifdef CONFIG_ECONET_AUNUDP
 820/*
 821 *      Send an AUN protocol response.
 822 */
 823
 824static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 825{
 826        struct sockaddr_in sin = {
 827                .sin_family = AF_INET,
 828                .sin_port = htons(AUN_PORT),
 829                .sin_addr = {.s_addr = addr}
 830        };
 831        struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 832        struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 833        struct msghdr udpmsg;
 834
 835        udpmsg.msg_name = (void *)&sin;
 836        udpmsg.msg_namelen = sizeof(sin);
 837        udpmsg.msg_control = NULL;
 838        udpmsg.msg_controllen = 0;
 839        udpmsg.msg_flags=0;
 840
 841        kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 842}
 843
 844
 845/*
 846 *      Handle incoming AUN packets.  Work out if anybody wants them,
 847 *      and send positive or negative acknowledgements as appropriate.
 848 */
 849
 850static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 851{
 852        struct iphdr *ip = ip_hdr(skb);
 853        unsigned char stn = ntohl(ip->saddr) & 0xff;
 854        struct dst_entry *dst = skb_dst(skb);
 855        struct ec_device *edev = NULL;
 856        struct sock *sk = NULL;
 857        struct sk_buff *newskb;
 858
 859        if (dst)
 860                edev = dst->dev->ec_ptr;
 861
 862        if (! edev)
 863                goto bad;
 864
 865        if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
 866                goto bad;               /* Nobody wants it */
 867
 868        newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 869                           GFP_ATOMIC);
 870        if (newskb == NULL)
 871        {
 872                printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
 873                /* Send nack and hope sender tries again */
 874                goto bad;
 875        }
 876
 877        memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
 878               len - sizeof(struct aunhdr));
 879
 880        if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
 881        {
 882                /* Socket is bankrupt. */
 883                kfree_skb(newskb);
 884                goto bad;
 885        }
 886
 887        aun_send_response(ip->saddr, ah->handle, 3, 0);
 888        sock_put(sk);
 889        return;
 890
 891bad:
 892        aun_send_response(ip->saddr, ah->handle, 4, 0);
 893        if (sk)
 894                sock_put(sk);
 895}
 896
 897/*
 898 *      Handle incoming AUN transmit acknowledgements.  If the sequence
 899 *      number matches something in our backlog then kill it and tell
 900 *      the user.  If the remote took too long to reply then we may have
 901 *      dropped the packet already.
 902 */
 903
 904static void aun_tx_ack(unsigned long seq, int result)
 905{
 906        struct sk_buff *skb;
 907        unsigned long flags;
 908        struct ec_cb *eb;
 909
 910        spin_lock_irqsave(&aun_queue_lock, flags);
 911        skb_queue_walk(&aun_queue, skb) {
 912                eb = (struct ec_cb *)&skb->cb;
 913                if (eb->seq == seq)
 914                        goto foundit;
 915        }
 916        spin_unlock_irqrestore(&aun_queue_lock, flags);
 917        printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
 918        return;
 919
 920foundit:
 921        tx_result(skb->sk, eb->cookie, result);
 922        skb_unlink(skb, &aun_queue);
 923        spin_unlock_irqrestore(&aun_queue_lock, flags);
 924        kfree_skb(skb);
 925}
 926
 927/*
 928 *      Deal with received AUN frames - sort out what type of thing it is
 929 *      and hand it to the right function.
 930 */
 931
 932static void aun_data_available(struct sock *sk, int slen)
 933{
 934        int err;
 935        struct sk_buff *skb;
 936        unsigned char *data;
 937        struct aunhdr *ah;
 938        struct iphdr *ip;
 939        size_t len;
 940
 941        while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 942                if (err == -EAGAIN) {
 943                        printk(KERN_ERR "AUN: no data available?!");
 944                        return;
 945                }
 946                printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
 947        }
 948
 949        data = skb_transport_header(skb) + sizeof(struct udphdr);
 950        ah = (struct aunhdr *)data;
 951        len = skb->len - sizeof(struct udphdr);
 952        ip = ip_hdr(skb);
 953
 954        switch (ah->code)
 955        {
 956        case 2:
 957                aun_incoming(skb, ah, len);
 958                break;
 959        case 3:
 960                aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 961                break;
 962        case 4:
 963                aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 964                break;
 965#if 0
 966                /* This isn't quite right yet. */
 967        case 5:
 968                aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
 969                break;
 970#endif
 971        default:
 972                printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
 973        }
 974
 975        skb_free_datagram(sk, skb);
 976}
 977
 978/*
 979 *      Called by the timer to manage the AUN transmit queue.  If a packet
 980 *      was sent to a dead or nonexistent host then we will never get an
 981 *      acknowledgement back.  After a few seconds we need to spot this and
 982 *      drop the packet.
 983 */
 984
 985static void ab_cleanup(unsigned long h)
 986{
 987        struct sk_buff *skb, *n;
 988        unsigned long flags;
 989
 990        spin_lock_irqsave(&aun_queue_lock, flags);
 991        skb_queue_walk_safe(&aun_queue, skb, n) {
 992                struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 993                if ((jiffies - eb->start) > eb->timeout) {
 994                        tx_result(skb->sk, eb->cookie,
 995                                  ECTYPE_TRANSMIT_NOT_PRESENT);
 996                        skb_unlink(skb, &aun_queue);
 997                        kfree_skb(skb);
 998                }
 999        }
1000        spin_unlock_irqrestore(&aun_queue_lock, flags);
1001
1002        mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1003}
1004
1005static int __init aun_udp_initialise(void)
1006{
1007        int error;
1008        struct sockaddr_in sin;
1009
1010        skb_queue_head_init(&aun_queue);
1011        setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
1012        ab_cleanup_timer.expires = jiffies + (HZ*2);
1013        add_timer(&ab_cleanup_timer);
1014
1015        memset(&sin, 0, sizeof(sin));
1016        sin.sin_port = htons(AUN_PORT);
1017
1018        /* We can count ourselves lucky Acorn machines are too dim to
1019           speak IPv6. :-) */
1020        if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1021        {
1022                printk("AUN: socket error %d\n", -error);
1023                return error;
1024        }
1025
1026        udpsock->sk->sk_reuse = 1;
1027        udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1028                                                    from interrupts */
1029
1030        error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1031                                sizeof(sin));
1032        if (error < 0)
1033        {
1034                printk("AUN: bind error %d\n", -error);
1035                goto release;
1036        }
1037
1038        udpsock->sk->sk_data_ready = aun_data_available;
1039
1040        return 0;
1041
1042release:
1043        sock_release(udpsock);
1044        udpsock = NULL;
1045        return error;
1046}
1047#endif
1048
1049#ifdef CONFIG_ECONET_NATIVE
1050
1051/*
1052 *      Receive an Econet frame from a device.
1053 */
1054
1055static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1056{
1057        struct ec_framehdr *hdr;
1058        struct sock *sk = NULL;
1059        struct ec_device *edev = dev->ec_ptr;
1060
1061        if (!net_eq(dev_net(dev), &init_net))
1062                goto drop;
1063
1064        if (skb->pkt_type == PACKET_OTHERHOST)
1065                goto drop;
1066
1067        if (!edev)
1068                goto drop;
1069
1070        if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1071                return NET_RX_DROP;
1072
1073        if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1074                goto drop;
1075
1076        hdr = (struct ec_framehdr *) skb->data;
1077
1078        /* First check for encapsulated IP */
1079        if (hdr->port == EC_PORT_IP) {
1080                skb->protocol = htons(ETH_P_IP);
1081                skb_pull(skb, sizeof(struct ec_framehdr));
1082                netif_rx(skb);
1083                return NET_RX_SUCCESS;
1084        }
1085
1086        sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1087        if (!sk)
1088                goto drop;
1089
1090        if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1091                            hdr->port))
1092                goto drop;
1093        sock_put(sk);
1094        return NET_RX_SUCCESS;
1095
1096drop:
1097        if (sk)
1098                sock_put(sk);
1099        kfree_skb(skb);
1100        return NET_RX_DROP;
1101}
1102
1103static struct packet_type econet_packet_type __read_mostly = {
1104        .type =         cpu_to_be16(ETH_P_ECONET),
1105        .func =         econet_rcv,
1106};
1107
1108static void econet_hw_initialise(void)
1109{
1110        dev_add_pack(&econet_packet_type);
1111}
1112
1113#endif
1114
1115static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1116{
1117        struct net_device *dev = (struct net_device *)data;
1118        struct ec_device *edev;
1119
1120        if (!net_eq(dev_net(dev), &init_net))
1121                return NOTIFY_DONE;
1122
1123        switch (msg) {
1124        case NETDEV_UNREGISTER:
1125                /* A device has gone down - kill any data we hold for it. */
1126                edev = dev->ec_ptr;
1127                if (edev)
1128                {
1129                        if (net2dev_map[0] == dev)
1130                                net2dev_map[0] = NULL;
1131                        net2dev_map[edev->net] = NULL;
1132                        kfree(edev);
1133                        dev->ec_ptr = NULL;
1134                }
1135                break;
1136        }
1137
1138        return NOTIFY_DONE;
1139}
1140
1141static struct notifier_block econet_netdev_notifier = {
1142        .notifier_call =econet_notifier,
1143};
1144
1145static void __exit econet_proto_exit(void)
1146{
1147#ifdef CONFIG_ECONET_AUNUDP
1148        del_timer(&ab_cleanup_timer);
1149        if (udpsock)
1150                sock_release(udpsock);
1151#endif
1152        unregister_netdevice_notifier(&econet_netdev_notifier);
1153#ifdef CONFIG_ECONET_NATIVE
1154        dev_remove_pack(&econet_packet_type);
1155#endif
1156        sock_unregister(econet_family_ops.family);
1157        proto_unregister(&econet_proto);
1158}
1159
1160static int __init econet_proto_init(void)
1161{
1162        int err = proto_register(&econet_proto, 0);
1163
1164        if (err != 0)
1165                goto out;
1166        sock_register(&econet_family_ops);
1167#ifdef CONFIG_ECONET_AUNUDP
1168        aun_udp_initialise();
1169#endif
1170#ifdef CONFIG_ECONET_NATIVE
1171        econet_hw_initialise();
1172#endif
1173        register_netdevice_notifier(&econet_netdev_notifier);
1174out:
1175        return err;
1176}
1177
1178module_init(econet_proto_init);
1179module_exit(econet_proto_exit);
1180
1181MODULE_LICENSE("GPL");
1182MODULE_ALIAS_NETPROTO(PF_ECONET);
1183