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