net/econet/af_econet.c

   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/sched.h>
  17 #include <linux/string.h>
  18 #include <linux/mm.h>
  19 #include <linux/socket.h>
  20 #include <linux/sockios.h>
  21 #include <linux/in.h>
  22 #include <linux/errno.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/if_ether.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/inetdevice.h>
  27 #include <linux/route.h>
  28 #include <linux/inet.h>
  29 #include <linux/etherdevice.h>
  30 #include <linux/if_arp.h>
  31 #include <linux/wireless.h>
  32 #include <linux/skbuff.h>
  33 #include <linux/udp.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
  49 static const struct proto_ops econet_ops;
  50 static struct hlist_head econet_sklist;
  51 static DEFINE_RWLOCK(econet_lock);
  52 static 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. */
  56 static struct net_device *net2dev_map[256];
  57
  58 #define EC_PORT_IP      0xd2
  59
  60 #ifdef CONFIG_ECONET_AUNUDP
  61 static DEFINE_SPINLOCK(aun_queue_lock);
  62 static struct socket *udpsock;
  63 #define AUN_PORT        0x8000
  64
  65
  66 struct 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
  75 static unsigned long aun_seq;
  76
  77 /* Queue of packets waiting to be transmitted. */
  78 static struct sk_buff_head aun_queue;
  79 static struct timer_list ab_cleanup_timer;
  80
  81 #endif          /* CONFIG_ECONET_AUNUDP */
  82
  83 /* Per-packet information */
  84 struct 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
  99 static 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
 106 static 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
 118 static 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         skb_get_timestamp(skb, &sk->sk_stamp);
 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
 177 out_free:
 178         skb_free_datagram(sk, skb);
 179 out:
 180         mutex_unlock(&econet_mutex);
 181         return err;
 182 }
 183
 184 /*
 185  *      Bind an Econet socket.
 186  */
 187
 188 static 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
 222 static 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
 252 static 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
 264 static 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
 341                 dev_hold(dev);
 342
 343                 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
 344                                           msg->msg_flags & MSG_DONTWAIT, &err);
 345                 if (skb==NULL)
 346                         goto out_unlock;
 347
 348                 skb_reserve(skb, LL_RESERVED_SPACE(dev));
 349                 skb->nh.raw = skb->data;
 350
 351                 eb = (struct ec_cb *)&skb->cb;
 352
 353                 /* BUG: saddr may be NULL */
 354                 eb->cookie = saddr->cookie;
 355                 eb->sec = *saddr;
 356                 eb->sent = ec_tx_done;
 357
 358                 if (dev->hard_header) {
 359                         int res;
 360                         struct ec_framehdr *fh;
 361                         err = -EINVAL;
 362                         res = dev->hard_header(skb, dev, ntohs(proto),
 363                                                &addr, NULL, len);
 364                         /* Poke in our control byte and
 365                            port number.  Hack, hack.  */
 366                         fh = (struct ec_framehdr *)(skb->data);
 367                         fh->cb = cb;
 368                         fh->port = port;
 369                         if (sock->type != SOCK_DGRAM) {
 370                                 skb->tail = skb->data;
 371                                 skb->len = 0;
 372                         } else if (res < 0)
 373                                 goto out_free;
 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 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, len)) {
 464                         mutex_unlock(&econet_mutex);
 465                         return -EFAULT;
 466                 }
 467                 iov[i+1].iov_base = base;
 468                 iov[i+1].iov_len = len;
 469                 size += 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
 514 static 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         mutex_lock(&econet_mutex);
 525
 526         sk = sock->sk;
 527         eo = ec_sk(sk);
 528
 529         sec->sec_family   = AF_ECONET;
 530         sec->port         = eo->port;
 531         sec->addr.station = eo->station;
 532         sec->addr.net     = eo->net;
 533
 534         mutex_unlock(&econet_mutex);
 535
 536         *uaddr_len = sizeof(*sec);
 537         return 0;
 538 }
 539
 540 static void econet_destroy_timer(unsigned long data)
 541 {
 542         struct sock *sk=(struct sock *)data;
 543
 544         if (!atomic_read(&sk->sk_wmem_alloc) &&
 545             !atomic_read(&sk->sk_rmem_alloc)) {
 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
 559 static 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->sk = NULL;
 578         sk->sk_socket = NULL;
 579         sock_set_flag(sk, SOCK_DEAD);
 580
 581         /* Purge queues */
 582
 583         skb_queue_purge(&sk->sk_receive_queue);
 584
 585         if (atomic_read(&sk->sk_rmem_alloc) ||
 586             atomic_read(&sk->sk_wmem_alloc)) {
 587                 sk->sk_timer.data     = (unsigned long)sk;
 588                 sk->sk_timer.expires  = jiffies + HZ;
 589                 sk->sk_timer.function = econet_destroy_timer;
 590                 add_timer(&sk->sk_timer);
 591
 592                 goto out_unlock;
 593         }
 594
 595         sk_free(sk);
 596
 597 out_unlock:
 598         mutex_unlock(&econet_mutex);
 599         return 0;
 600 }
 601
 602 static struct proto econet_proto = {
 603         .name     = "ECONET",
 604         .owner    = THIS_MODULE,
 605         .obj_size = sizeof(struct econet_sock),
 606 };
 607
 608 /*
 609  *      Create an Econet socket
 610  */
 611
 612 static int econet_create(struct socket *sock, int protocol)
 613 {
 614         struct sock *sk;
 615         struct econet_sock *eo;
 616         int err;
 617
 618         /* Econet only provides datagram services. */
 619         if (sock->type != SOCK_DGRAM)
 620                 return -ESOCKTNOSUPPORT;
 621
 622         sock->state = SS_UNCONNECTED;
 623
 624         err = -ENOBUFS;
 625         sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
 626         if (sk == NULL)
 627                 goto out;
 628
 629         sk->sk_reuse = 1;
 630         sock->ops = &econet_ops;
 631         sock_init_data(sock, sk);
 632
 633         eo = ec_sk(sk);
 634         sock_reset_flag(sk, SOCK_ZAPPED);
 635         sk->sk_family = PF_ECONET;
 636         eo->num = protocol;
 637
 638         econet_insert_socket(&econet_sklist, sk);
 639         return(0);
 640 out:
 641         return err;
 642 }
 643
 644 /*
 645  *      Handle Econet specific ioctls
 646  */
 647
 648 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
 649 {
 650         struct ifreq ifr;
 651         struct ec_device *edev;
 652         struct net_device *dev;
 653         struct sockaddr_ec *sec;
 654         int err;
 655
 656         /*
 657          *      Fetch the caller's info block into kernel space
 658          */
 659
 660         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 661                 return -EFAULT;
 662
 663         if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
 664                 return -ENODEV;
 665
 666         sec = (struct sockaddr_ec *)&ifr.ifr_addr;
 667
 668         mutex_lock(&econet_mutex);
 669
 670         err = 0;
 671         switch (cmd) {
 672         case SIOCSIFADDR:
 673                 edev = dev->ec_ptr;
 674                 if (edev == NULL) {
 675                         /* Magic up a new one. */
 676                         edev = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
 677                         if (edev == NULL) {
 678                                 err = -ENOMEM;
 679                                 break;
 680                         }
 681                         memset(edev, 0, sizeof(struct ec_device));
 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
 723 static 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 SIOCSIFADDR:
 733                 case SIOCGIFADDR:
 734                         return ec_dev_ioctl(sock, cmd, argp);
 735                         break;
 736
 737                 default:
 738                         return -ENOIOCTLCMD;
 739         }
 740         /*NOTREACHED*/
 741         return 0;
 742 }
 743
 744 static struct net_proto_family econet_family_ops = {
 745         .family =       PF_ECONET,
 746         .create =       econet_create,
 747         .owner  =       THIS_MODULE,
 748 };
 749
 750 static const struct proto_ops econet_ops = {
 751         .family =       PF_ECONET,
 752         .owner =        THIS_MODULE,
 753         .release =      econet_release,
 754         .bind =         econet_bind,
 755         .connect =      sock_no_connect,
 756         .socketpair =   sock_no_socketpair,
 757         .accept =       sock_no_accept,
 758         .getname =      econet_getname,
 759         .poll =         datagram_poll,
 760         .ioctl =        econet_ioctl,
 761         .listen =       sock_no_listen,
 762         .shutdown =     sock_no_shutdown,
 763         .setsockopt =   sock_no_setsockopt,
 764         .getsockopt =   sock_no_getsockopt,
 765         .sendmsg =      econet_sendmsg,
 766         .recvmsg =      econet_recvmsg,
 767         .mmap =         sock_no_mmap,
 768         .sendpage =     sock_no_sendpage,
 769 };
 770
 771 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 772 /*
 773  *      Find the listening socket, if any, for the given data.
 774  */
 775
 776 static struct sock *ec_listening_socket(unsigned char port, unsigned char
 777                                  station, unsigned char net)
 778 {
 779         struct sock *sk;
 780         struct hlist_node *node;
 781
 782         sk_for_each(sk, node, &econet_sklist) {
 783                 struct econet_sock *opt = ec_sk(sk);
 784                 if ((opt->port == port || opt->port == 0) &&
 785                     (opt->station == station || opt->station == 0) &&
 786                     (opt->net == net || opt->net == 0))
 787                         goto found;
 788         }
 789         sk = NULL;
 790 found:
 791         return sk;
 792 }
 793
 794 /*
 795  *      Queue a received packet for a socket.
 796  */
 797
 798 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 799                            unsigned char stn, unsigned char net,
 800                            unsigned char cb, unsigned char port)
 801 {
 802         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 803         struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 804
 805         memset(sec, 0, sizeof(struct sockaddr_ec));
 806         sec->sec_family = AF_ECONET;
 807         sec->type = ECTYPE_PACKET_RECEIVED;
 808         sec->port = port;
 809         sec->cb = cb;
 810         sec->addr.net = net;
 811         sec->addr.station = stn;
 812
 813         return sock_queue_rcv_skb(sk, skb);
 814 }
 815 #endif
 816
 817 #ifdef CONFIG_ECONET_AUNUDP
 818 /*
 819  *      Send an AUN protocol response.
 820  */
 821
 822 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 823 {
 824         struct sockaddr_in sin = {
 825                 .sin_family = AF_INET,
 826                 .sin_port = htons(AUN_PORT),
 827                 .sin_addr = {.s_addr = addr}
 828         };
 829         struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 830         struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 831         struct msghdr udpmsg;
 832
 833         udpmsg.msg_name = (void *)&sin;
 834         udpmsg.msg_namelen = sizeof(sin);
 835         udpmsg.msg_control = NULL;
 836         udpmsg.msg_controllen = 0;
 837         udpmsg.msg_flags=0;
 838
 839         kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 840 }
 841
 842
 843 /*
 844  *      Handle incoming AUN packets.  Work out if anybody wants them,
 845  *      and send positive or negative acknowledgements as appropriate.
 846  */
 847
 848 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 849 {
 850         struct iphdr *ip = skb->nh.iph;
 851         unsigned char stn = ntohl(ip->saddr) & 0xff;
 852         struct sock *sk;
 853         struct sk_buff *newskb;
 854         struct ec_device *edev = skb->dev->ec_ptr;
 855
 856         if (! edev)
 857                 goto bad;
 858
 859         if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
 860                 goto bad;               /* Nobody wants it */
 861
 862         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 863                            GFP_ATOMIC);
 864         if (newskb == NULL)
 865         {
 866                 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
 867                 /* Send nack and hope sender tries again */
 868                 goto bad;
 869         }
 870
 871         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
 872                len - sizeof(struct aunhdr));
 873
 874         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
 875         {
 876                 /* Socket is bankrupt. */
 877                 kfree_skb(newskb);
 878                 goto bad;
 879         }
 880
 881         aun_send_response(ip->saddr, ah->handle, 3, 0);
 882         return;
 883
 884 bad:
 885         aun_send_response(ip->saddr, ah->handle, 4, 0);
 886 }
 887
 888 /*
 889  *      Handle incoming AUN transmit acknowledgements.  If the sequence
 890  *      number matches something in our backlog then kill it and tell
 891  *      the user.  If the remote took too long to reply then we may have
 892  *      dropped the packet already.
 893  */
 894
 895 static void aun_tx_ack(unsigned long seq, int result)
 896 {
 897         struct sk_buff *skb;
 898         unsigned long flags;
 899         struct ec_cb *eb;
 900
 901         spin_lock_irqsave(&aun_queue_lock, flags);
 902         skb = skb_peek(&aun_queue);
 903         while (skb && skb != (struct sk_buff *)&aun_queue)
 904         {
 905                 struct sk_buff *newskb = skb->next;
 906                 eb = (struct ec_cb *)&skb->cb;
 907                 if (eb->seq == seq)
 908                         goto foundit;
 909
 910                 skb = newskb;
 911         }
 912         spin_unlock_irqrestore(&aun_queue_lock, flags);
 913         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
 914         return;
 915
 916 foundit:
 917         tx_result(skb->sk, eb->cookie, result);
 918         skb_unlink(skb, &aun_queue);
 919         spin_unlock_irqrestore(&aun_queue_lock, flags);
 920         kfree_skb(skb);
 921 }
 922
 923 /*
 924  *      Deal with received AUN frames - sort out what type of thing it is
 925  *      and hand it to the right function.
 926  */
 927
 928 static void aun_data_available(struct sock *sk, int slen)
 929 {
 930         int err;
 931         struct sk_buff *skb;
 932         unsigned char *data;
 933         struct aunhdr *ah;
 934         struct iphdr *ip;
 935         size_t len;
 936
 937         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 938                 if (err == -EAGAIN) {
 939                         printk(KERN_ERR "AUN: no data available?!");
 940                         return;
 941                 }
 942                 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
 943         }
 944
 945         data = skb->h.raw + sizeof(struct udphdr);
 946         ah = (struct aunhdr *)data;
 947         len = skb->len - sizeof(struct udphdr);
 948         ip = skb->nh.iph;
 949
 950         switch (ah->code)
 951         {
 952         case 2:
 953                 aun_incoming(skb, ah, len);
 954                 break;
 955         case 3:
 956                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 957                 break;
 958         case 4:
 959                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 960                 break;
 961 #if 0
 962                 /* This isn't quite right yet. */
 963         case 5:
 964                 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
 965                 break;
 966 #endif
 967         default:
 968                 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
 969         }
 970
 971         skb_free_datagram(sk, skb);
 972 }
 973
 974 /*
 975  *      Called by the timer to manage the AUN transmit queue.  If a packet
 976  *      was sent to a dead or nonexistent host then we will never get an
 977  *      acknowledgement back.  After a few seconds we need to spot this and
 978  *      drop the packet.
 979  */
 980
 981 static void ab_cleanup(unsigned long h)
 982 {
 983         struct sk_buff *skb;
 984         unsigned long flags;
 985
 986         spin_lock_irqsave(&aun_queue_lock, flags);
 987         skb = skb_peek(&aun_queue);
 988         while (skb && skb != (struct sk_buff *)&aun_queue)
 989         {
 990                 struct sk_buff *newskb = skb->next;
 991                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 992                 if ((jiffies - eb->start) > eb->timeout)
 993                 {
 994                         tx_result(skb->sk, eb->cookie,
 995                                   ECTYPE_TRANSMIT_NOT_PRESENT);
 996                         skb_unlink(skb, &aun_queue);
 997                         kfree_skb(skb);
 998                 }
 999                 skb = newskb;
1000         }
1001         spin_unlock_irqrestore(&aun_queue_lock, flags);
1002
1003         mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1004 }
1005
1006 static int __init aun_udp_initialise(void)
1007 {
1008         int error;
1009         struct sockaddr_in sin;
1010
1011         skb_queue_head_init(&aun_queue);
1012         spin_lock_init(&aun_queue_lock);
1013         init_timer(&ab_cleanup_timer);
1014         ab_cleanup_timer.expires = jiffies + (HZ*2);
1015         ab_cleanup_timer.function = ab_cleanup;
1016         add_timer(&ab_cleanup_timer);
1017
1018         memset(&sin, 0, sizeof(sin));
1019         sin.sin_port = htons(AUN_PORT);
1020
1021         /* We can count ourselves lucky Acorn machines are too dim to
1022            speak IPv6. :-) */
1023         if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1024         {
1025                 printk("AUN: socket error %d\n", -error);
1026                 return error;
1027         }
1028
1029         udpsock->sk->sk_reuse = 1;
1030         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1031                                                     from interrupts */
1032
1033         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1034                                 sizeof(sin));
1035         if (error < 0)
1036         {
1037                 printk("AUN: bind error %d\n", -error);
1038                 goto release;
1039         }
1040
1041         udpsock->sk->sk_data_ready = aun_data_available;
1042
1043         return 0;
1044
1045 release:
1046         sock_release(udpsock);
1047         udpsock = NULL;
1048         return error;
1049 }
1050 #endif
1051
1052 #ifdef CONFIG_ECONET_NATIVE
1053
1054 /*
1055  *      Receive an Econet frame from a device.
1056  */
1057
1058 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1059 {
1060         struct ec_framehdr *hdr;
1061         struct sock *sk;
1062         struct ec_device *edev = dev->ec_ptr;
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 0;
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
1094         return 0;
1095
1096 drop:
1097         kfree_skb(skb);
1098         return NET_RX_DROP;
1099 }
1100
1101 static struct packet_type econet_packet_type = {
1102         .type =         __constant_htons(ETH_P_ECONET),
1103         .func =         econet_rcv,
1104 };
1105
1106 static void econet_hw_initialise(void)
1107 {
1108         dev_add_pack(&econet_packet_type);
1109 }
1110
1111 #endif
1112
1113 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1114 {
1115         struct net_device *dev = (struct net_device *)data;
1116         struct ec_device *edev;
1117
1118         switch (msg) {
1119         case NETDEV_UNREGISTER:
1120                 /* A device has gone down - kill any data we hold for it. */
1121                 edev = dev->ec_ptr;
1122                 if (edev)
1123                 {
1124                         if (net2dev_map[0] == dev)
1125                                 net2dev_map[0] = NULL;
1126                         net2dev_map[edev->net] = NULL;
1127                         kfree(edev);
1128                         dev->ec_ptr = NULL;
1129                 }
1130                 break;
1131         }
1132
1133         return NOTIFY_DONE;
1134 }
1135
1136 static struct notifier_block econet_netdev_notifier = {
1137         .notifier_call =econet_notifier,
1138 };
1139
1140 static void __exit econet_proto_exit(void)
1141 {
1142 #ifdef CONFIG_ECONET_AUNUDP
1143         del_timer(&ab_cleanup_timer);
1144         if (udpsock)
1145                 sock_release(udpsock);
1146 #endif
1147         unregister_netdevice_notifier(&econet_netdev_notifier);
1148         sock_unregister(econet_family_ops.family);
1149         proto_unregister(&econet_proto);
1150 }
1151
1152 static int __init econet_proto_init(void)
1153 {
1154         int err = proto_register(&econet_proto, 0);
1155
1156         if (err != 0)
1157                 goto out;
1158         sock_register(&econet_family_ops);
1159 #ifdef CONFIG_ECONET_AUNUDP
1160         spin_lock_init(&aun_queue_lock);
1161         aun_udp_initialise();
1162 #endif
1163 #ifdef CONFIG_ECONET_NATIVE
1164         econet_hw_initialise();
1165 #endif
1166         register_netdevice_notifier(&econet_netdev_notifier);
1167 out:
1168         return err;
1169 }
1170
1171 module_init(econet_proto_init);
1172 module_exit(econet_proto_exit);
1173
1174 MODULE_LICENSE("GPL");
1175 MODULE_ALIAS_NETPROTO(PF_ECONET);