git.oblomov.eu Git - linux-2.6/blob - 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/config.h>
  13 #include <linux/module.h>
  14
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/string.h>
  19 #include <linux/mm.h>
  20 #include <linux/socket.h>
  21 #include <linux/sockios.h>
  22 #include <linux/in.h>
  23 #include <linux/errno.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/if_ether.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/inetdevice.h>
  28 #include <linux/route.h>
  29 #include <linux/inet.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/if_arp.h>
  32 #include <linux/wireless.h>
  33 #include <linux/skbuff.h>
  34 #include <linux/udp.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
  50 static const struct proto_ops econet_ops;
  51 static struct hlist_head econet_sklist;
  52 static DEFINE_RWLOCK(econet_lock);
  53 static 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. */
  57 static struct net_device *net2dev_map[256];
  58
  59 #define EC_PORT_IP      0xd2
  60
  61 #ifdef CONFIG_ECONET_AUNUDP
  62 static DEFINE_SPINLOCK(aun_queue_lock);
  63 static struct socket *udpsock;
  64 #define AUN_PORT        0x8000
  65
  66
  67 struct 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
  76 static unsigned long aun_seq;
  77
  78 /* Queue of packets waiting to be transmitted. */
  79 static struct sk_buff_head aun_queue;
  80 static struct timer_list ab_cleanup_timer;
  81
  82 #endif          /* CONFIG_ECONET_AUNUDP */
  83
  84 /* Per-packet information */
  85 struct 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
 100 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
 101 {
 102         write_lock_bh(&econet_lock);
 103         sk_del_node_init(sk);
 104         write_unlock_bh(&econet_lock);
 105 }
 106
 107 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
 108 {
 109         write_lock_bh(&econet_lock);
 110         sk_add_node(sk, list);
 111         write_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
 119 static 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         skb_get_timestamp(skb, &sk->sk_stamp);
 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
 178 out_free:
 179         skb_free_datagram(sk, skb);
 180 out:
 181         mutex_unlock(&econet_mutex);
 182         return err;
 183 }
 184
 185 /*
 186  *      Bind an Econet socket.
 187  */
 188
 189 static 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
 223 static 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
 253 static 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
 265 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
 266                           struct msghdr *msg, size_t len)
 267 {
 268         struct sock *sk = sock->sk;
 269         struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
 270         struct net_device *dev;
 271         struct ec_addr addr;
 272         int err;
 273         unsigned char port, cb;
 274 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 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[msg->msg_iovlen+1];
 281         struct aunhdr ah;
 282         struct sockaddr_in udpdest;
 283         __kernel_size_t size;
 284         int i;
 285         mm_segment_t oldfs;
 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) {
 302                 struct econet_sock *eo = ec_sk(sk);
 303
 304                 addr.station = eo->station;
 305                 addr.net     = eo->net;
 306                 port         = eo->port;
 307                 cb           = eo->cb;
 308         } else {
 309                 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
 310                         mutex_unlock(&econet_mutex);
 311                         return -EINVAL;
 312                 }
 313                 addr.station = saddr->addr.station;
 314                 addr.net = saddr->addr.net;
 315                 port = saddr->port;
 316                 cb = saddr->cb;
 317         }
 318
 319         /* Look for a device with the right network number. */
 320         dev = net2dev_map[addr.net];
 321
 322         /* If not directly reachable, use some default */
 323         if (dev == NULL) {
 324                 dev = net2dev_map[0];
 325                 /* No interfaces at all? */
 326                 if (dev == NULL) {
 327                         mutex_unlock(&econet_mutex);
 328                         return -ENETDOWN;
 329                 }
 330         }
 331
 332         if (len + 15 > dev->mtu) {
 333                 mutex_unlock(&econet_mutex);
 334                 return -EMSGSIZE;
 335         }
 336
 337         if (dev->type == ARPHRD_ECONET) {
 338                 /* Real hardware Econet.  We're not worthy etc. */
 339 #ifdef CONFIG_ECONET_NATIVE
 340                 unsigned short proto = 0;
 341
 342                 dev_hold(dev);
 343
 344                 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_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->nh.raw = skb->data;
 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                 if (dev->hard_header) {
 360                         int res;
 361                         struct ec_framehdr *fh;
 362                         err = -EINVAL;
 363                         res = dev->hard_header(skb, dev, ntohs(proto),
 364                                                &addr, NULL, len);
 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->tail = skb->data;
 372                                 skb->len = 0;
 373                         } else if (res < 0)
 374                                 goto out_free;
 375                 }
 376
 377                 /* Copy the data. Returns -EFAULT on error */
 378                 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 379                 skb->protocol = proto;
 380                 skb->dev = dev;
 381                 skb->priority = sk->sk_priority;
 382                 if (err)
 383                         goto out_free;
 384
 385                 err = -ENETDOWN;
 386                 if (!(dev->flags & IFF_UP))
 387                         goto out_free;
 388
 389                 /*
 390                  *      Now send it
 391                  */
 392
 393                 dev_queue_xmit(skb);
 394                 dev_put(dev);
 395                 mutex_unlock(&econet_mutex);
 396                 return(len);
 397
 398         out_free:
 399                 kfree_skb(skb);
 400         out_unlock:
 401                 if (dev)
 402                         dev_put(dev);
 403 #else
 404                 err = -EPROTOTYPE;
 405 #endif
 406                 mutex_unlock(&econet_mutex);
 407
 408                 return err;
 409         }
 410
 411 #ifdef CONFIG_ECONET_AUNUDP
 412         /* AUN virtual Econet. */
 413
 414         if (udpsock == NULL) {
 415                 mutex_unlock(&econet_mutex);
 416                 return -ENETDOWN;               /* No socket - can't send */
 417         }
 418
 419         /* Make up a UDP datagram and hand it off to some higher intellect. */
 420
 421         memset(&udpdest, 0, sizeof(udpdest));
 422         udpdest.sin_family = AF_INET;
 423         udpdest.sin_port = htons(AUN_PORT);
 424
 425         /* At the moment we use the stupid Acorn scheme of Econet address
 426            y.x maps to IP a.b.c.x.  This should be replaced with something
 427            more flexible and more aware of subnet masks.  */
 428         {
 429                 struct in_device *idev;
 430                 unsigned long network = 0;
 431
 432                 rcu_read_lock();
 433                 idev = __in_dev_get_rcu(dev);
 434                 if (idev) {
 435                         if (idev->ifa_list)
 436                                 network = ntohl(idev->ifa_list->ifa_address) &
 437                                         0xffffff00;             /* !!! */
 438                 }
 439                 rcu_read_unlock();
 440                 udpdest.sin_addr.s_addr = htonl(network | addr.station);
 441         }
 442
 443         ah.port = port;
 444         ah.cb = cb & 0x7f;
 445         ah.code = 2;            /* magic */
 446         ah.pad = 0;
 447
 448         /* tack our header on the front of the iovec */
 449         size = sizeof(struct aunhdr);
 450         /*
 451          * XXX: that is b0rken.  We can't mix userland and kernel pointers
 452          * in iovec, since on a lot of platforms copy_from_user() will
 453          * *not* work with the kernel and userland ones at the same time,
 454          * regardless of what we do with set_fs().  And we are talking about
 455          * econet-over-ethernet here, so "it's only ARM anyway" doesn't
 456          * apply.  Any suggestions on fixing that code?         -- AV
 457          */
 458         iov[0].iov_base = (void *)&ah;
 459         iov[0].iov_len = size;
 460         for (i = 0; i < msg->msg_iovlen; i++) {
 461                 void __user *base = msg->msg_iov[i].iov_base;
 462                 size_t len = msg->msg_iov[i].iov_len;
 463                 /* Check it now since we switch to KERNEL_DS later. */
 464                 if (!access_ok(VERIFY_READ, base, len)) {
 465                         mutex_unlock(&econet_mutex);
 466                         return -EFAULT;
 467                 }
 468                 iov[i+1].iov_base = base;
 469                 iov[i+1].iov_len = len;
 470                 size += len;
 471         }
 472
 473         /* Get a skbuff (no data, just holds our cb information) */
 474         if ((skb = sock_alloc_send_skb(sk, 0,
 475                                        msg->msg_flags & MSG_DONTWAIT,
 476                                        &err)) == NULL) {
 477                 mutex_unlock(&econet_mutex);
 478                 return err;
 479         }
 480
 481         eb = (struct ec_cb *)&skb->cb;
 482
 483         eb->cookie = saddr->cookie;
 484         eb->timeout = (5*HZ);
 485         eb->start = jiffies;
 486         ah.handle = aun_seq;
 487         eb->seq = (aun_seq++);
 488         eb->sec = *saddr;
 489
 490         skb_queue_tail(&aun_queue, skb);
 491
 492         udpmsg.msg_name = (void *)&udpdest;
 493         udpmsg.msg_namelen = sizeof(udpdest);
 494         udpmsg.msg_iov = &iov[0];
 495         udpmsg.msg_iovlen = msg->msg_iovlen + 1;
 496         udpmsg.msg_control = NULL;
 497         udpmsg.msg_controllen = 0;
 498         udpmsg.msg_flags=0;
 499
 500         oldfs = get_fs(); set_fs(KERNEL_DS);    /* More privs :-) */
 501         err = sock_sendmsg(udpsock, &udpmsg, size);
 502         set_fs(oldfs);
 503 #else
 504         err = -EPROTOTYPE;
 505 #endif
 506         mutex_unlock(&econet_mutex);
 507
 508         return err;
 509 }
 510
 511 /*
 512  *      Look up the address of a socket.
 513  */
 514
 515 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
 516                           int *uaddr_len, int peer)
 517 {
 518         struct sock *sk;
 519         struct econet_sock *eo;
 520         struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 521
 522         if (peer)
 523                 return -EOPNOTSUPP;
 524
 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
 541 static void econet_destroy_timer(unsigned long data)
 542 {
 543         struct sock *sk=(struct sock *)data;
 544
 545         if (!atomic_read(&sk->sk_wmem_alloc) &&
 546             !atomic_read(&sk->sk_rmem_alloc)) {
 547                 sk_free(sk);
 548                 return;
 549         }
 550
 551         sk->sk_timer.expires = jiffies + 10 * HZ;
 552         add_timer(&sk->sk_timer);
 553         printk(KERN_DEBUG "econet socket destroy delayed\n");
 554 }
 555
 556 /*
 557  *      Close an econet socket.
 558  */
 559
 560 static int econet_release(struct socket *sock)
 561 {
 562         struct sock *sk;
 563
 564         mutex_lock(&econet_mutex);
 565
 566         sk = sock->sk;
 567         if (!sk)
 568                 goto out_unlock;
 569
 570         econet_remove_socket(&econet_sklist, sk);
 571
 572         /*
 573          *      Now the socket is dead. No more input will appear.
 574          */
 575
 576         sk->sk_state_change(sk);        /* It is useless. Just for sanity. */
 577
 578         sock->sk = NULL;
 579         sk->sk_socket = NULL;
 580         sock_set_flag(sk, SOCK_DEAD);
 581
 582         /* Purge queues */
 583
 584         skb_queue_purge(&sk->sk_receive_queue);
 585
 586         if (atomic_read(&sk->sk_rmem_alloc) ||
 587             atomic_read(&sk->sk_wmem_alloc)) {
 588                 sk->sk_timer.data     = (unsigned long)sk;
 589                 sk->sk_timer.expires  = jiffies + HZ;
 590                 sk->sk_timer.function = econet_destroy_timer;
 591                 add_timer(&sk->sk_timer);
 592
 593                 goto out_unlock;
 594         }
 595
 596         sk_free(sk);
 597
 598 out_unlock:
 599         mutex_unlock(&econet_mutex);
 600         return 0;
 601 }
 602
 603 static struct proto econet_proto = {
 604         .name     = "ECONET",
 605         .owner    = THIS_MODULE,
 606         .obj_size = sizeof(struct econet_sock),
 607 };
 608
 609 /*
 610  *      Create an Econet socket
 611  */
 612
 613 static int econet_create(struct socket *sock, int protocol)
 614 {
 615         struct sock *sk;
 616         struct econet_sock *eo;
 617         int err;
 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(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
 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);
 641 out:
 642         return err;
 643 }
 644
 645 /*
 646  *      Handle Econet specific ioctls
 647  */
 648
 649 static 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(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 = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
 678                         if (edev == NULL) {
 679                                 err = -ENOMEM;
 680                                 break;
 681                         }
 682                         memset(edev, 0, sizeof(struct ec_device));
 683                         dev->ec_ptr = edev;
 684                 } else
 685                         net2dev_map[edev->net] = NULL;
 686                 edev->station = sec->addr.station;
 687                 edev->net = sec->addr.net;
 688                 net2dev_map[sec->addr.net] = dev;
 689                 if (!net2dev_map[0])
 690                         net2dev_map[0] = dev;
 691                 break;
 692
 693         case SIOCGIFADDR:
 694                 edev = dev->ec_ptr;
 695                 if (edev == NULL) {
 696                         err = -ENODEV;
 697                         break;
 698                 }
 699                 memset(sec, 0, sizeof(struct sockaddr_ec));
 700                 sec->addr.station = edev->station;
 701                 sec->addr.net = edev->net;
 702                 sec->sec_family = AF_ECONET;
 703                 dev_put(dev);
 704                 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 705                         err = -EFAULT;
 706                 break;
 707
 708         default:
 709                 err = -EINVAL;
 710                 break;
 711         }
 712
 713         mutex_unlock(&econet_mutex);
 714
 715         dev_put(dev);
 716
 717         return err;
 718 }
 719
 720 /*
 721  *      Handle generic ioctls
 722  */
 723
 724 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 725 {
 726         struct sock *sk = sock->sk;
 727         void __user *argp = (void __user *)arg;
 728
 729         switch(cmd) {
 730                 case SIOCGSTAMP:
 731                         return sock_get_timestamp(sk, argp);
 732
 733                 case SIOCSIFADDR:
 734                 case SIOCGIFADDR:
 735                         return ec_dev_ioctl(sock, cmd, argp);
 736                         break;
 737
 738                 default:
 739                         return -ENOIOCTLCMD;
 740         }
 741         /*NOTREACHED*/
 742         return 0;
 743 }
 744
 745 static struct net_proto_family econet_family_ops = {
 746         .family =       PF_ECONET,
 747         .create =       econet_create,
 748         .owner  =       THIS_MODULE,
 749 };
 750
 751 static const struct proto_ops econet_ops = {
 752         .family =       PF_ECONET,
 753         .owner =        THIS_MODULE,
 754         .release =      econet_release,
 755         .bind =         econet_bind,
 756         .connect =      sock_no_connect,
 757         .socketpair =   sock_no_socketpair,
 758         .accept =       sock_no_accept,
 759         .getname =      econet_getname,
 760         .poll =         datagram_poll,
 761         .ioctl =        econet_ioctl,
 762         .listen =       sock_no_listen,
 763         .shutdown =     sock_no_shutdown,
 764         .setsockopt =   sock_no_setsockopt,
 765         .getsockopt =   sock_no_getsockopt,
 766         .sendmsg =      econet_sendmsg,
 767         .recvmsg =      econet_recvmsg,
 768         .mmap =         sock_no_mmap,
 769         .sendpage =     sock_no_sendpage,
 770 };
 771
 772 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 773 /*
 774  *      Find the listening socket, if any, for the given data.
 775  */
 776
 777 static struct sock *ec_listening_socket(unsigned char port, unsigned char
 778                                  station, unsigned char net)
 779 {
 780         struct sock *sk;
 781         struct hlist_node *node;
 782
 783         sk_for_each(sk, node, &econet_sklist) {
 784                 struct econet_sock *opt = ec_sk(sk);
 785                 if ((opt->port == port || opt->port == 0) &&
 786                     (opt->station == station || opt->station == 0) &&
 787                     (opt->net == net || opt->net == 0))
 788                         goto found;
 789         }
 790         sk = NULL;
 791 found:
 792         return sk;
 793 }
 794
 795 /*
 796  *      Queue a received packet for a socket.
 797  */
 798
 799 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 800                            unsigned char stn, unsigned char net,
 801                            unsigned char cb, unsigned char port)
 802 {
 803         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 804         struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 805
 806         memset(sec, 0, sizeof(struct sockaddr_ec));
 807         sec->sec_family = AF_ECONET;
 808         sec->type = ECTYPE_PACKET_RECEIVED;
 809         sec->port = port;
 810         sec->cb = cb;
 811         sec->addr.net = net;
 812         sec->addr.station = stn;
 813
 814         return sock_queue_rcv_skb(sk, skb);
 815 }
 816 #endif
 817
 818 #ifdef CONFIG_ECONET_AUNUDP
 819 /*
 820  *      Send an AUN protocol response.
 821  */
 822
 823 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 824 {
 825         struct sockaddr_in sin = {
 826                 .sin_family = AF_INET,
 827                 .sin_port = htons(AUN_PORT),
 828                 .sin_addr = {.s_addr = addr}
 829         };
 830         struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 831         struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 832         struct msghdr udpmsg;
 833
 834         udpmsg.msg_name = (void *)&sin;
 835         udpmsg.msg_namelen = sizeof(sin);
 836         udpmsg.msg_control = NULL;
 837         udpmsg.msg_controllen = 0;
 838         udpmsg.msg_flags=0;
 839
 840         kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 841 }
 842
 843
 844 /*
 845  *      Handle incoming AUN packets.  Work out if anybody wants them,
 846  *      and send positive or negative acknowledgements as appropriate.
 847  */
 848
 849 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 850 {
 851         struct iphdr *ip = skb->nh.iph;
 852         unsigned char stn = ntohl(ip->saddr) & 0xff;
 853         struct sock *sk;
 854         struct sk_buff *newskb;
 855         struct ec_device *edev = skb->dev->ec_ptr;
 856
 857         if (! edev)
 858                 goto bad;
 859
 860         if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
 861                 goto bad;               /* Nobody wants it */
 862
 863         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 864                            GFP_ATOMIC);
 865         if (newskb == NULL)
 866         {
 867                 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
 868                 /* Send nack and hope sender tries again */
 869                 goto bad;
 870         }
 871
 872         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
 873                len - sizeof(struct aunhdr));
 874
 875         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
 876         {
 877                 /* Socket is bankrupt. */
 878                 kfree_skb(newskb);
 879                 goto bad;
 880         }
 881
 882         aun_send_response(ip->saddr, ah->handle, 3, 0);
 883         return;
 884
 885 bad:
 886         aun_send_response(ip->saddr, ah->handle, 4, 0);
 887 }
 888
 889 /*
 890  *      Handle incoming AUN transmit acknowledgements.  If the sequence
 891  *      number matches something in our backlog then kill it and tell
 892  *      the user.  If the remote took too long to reply then we may have
 893  *      dropped the packet already.
 894  */
 895
 896 static void aun_tx_ack(unsigned long seq, int result)
 897 {
 898         struct sk_buff *skb;
 899         unsigned long flags;
 900         struct ec_cb *eb;
 901
 902         spin_lock_irqsave(&aun_queue_lock, flags);
 903         skb = skb_peek(&aun_queue);
 904         while (skb && skb != (struct sk_buff *)&aun_queue)
 905         {
 906                 struct sk_buff *newskb = skb->next;
 907                 eb = (struct ec_cb *)&skb->cb;
 908                 if (eb->seq == seq)
 909                         goto foundit;
 910
 911                 skb = newskb;
 912         }
 913         spin_unlock_irqrestore(&aun_queue_lock, flags);
 914         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
 915         return;
 916
 917 foundit:
 918         tx_result(skb->sk, eb->cookie, result);
 919         skb_unlink(skb, &aun_queue);
 920         spin_unlock_irqrestore(&aun_queue_lock, flags);
 921         kfree_skb(skb);
 922 }
 923
 924 /*
 925  *      Deal with received AUN frames - sort out what type of thing it is
 926  *      and hand it to the right function.
 927  */
 928
 929 static void aun_data_available(struct sock *sk, int slen)
 930 {
 931         int err;
 932         struct sk_buff *skb;
 933         unsigned char *data;
 934         struct aunhdr *ah;
 935         struct iphdr *ip;
 936         size_t len;
 937
 938         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 939                 if (err == -EAGAIN) {
 940                         printk(KERN_ERR "AUN: no data available?!");
 941                         return;
 942                 }
 943                 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
 944         }
 945
 946         data = skb->h.raw + sizeof(struct udphdr);
 947         ah = (struct aunhdr *)data;
 948         len = skb->len - sizeof(struct udphdr);
 949         ip = skb->nh.iph;
 950
 951         switch (ah->code)
 952         {
 953         case 2:
 954                 aun_incoming(skb, ah, len);
 955                 break;
 956         case 3:
 957                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 958                 break;
 959         case 4:
 960                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 961                 break;
 962 #if 0
 963                 /* This isn't quite right yet. */
 964         case 5:
 965                 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
 966                 break;
 967 #endif
 968         default:
 969                 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
 970         }
 971
 972         skb_free_datagram(sk, skb);
 973 }
 974
 975 /*
 976  *      Called by the timer to manage the AUN transmit queue.  If a packet
 977  *      was sent to a dead or nonexistent host then we will never get an
 978  *      acknowledgement back.  After a few seconds we need to spot this and
 979  *      drop the packet.
 980  */
 981
 982 static void ab_cleanup(unsigned long h)
 983 {
 984         struct sk_buff *skb;
 985         unsigned long flags;
 986
 987         spin_lock_irqsave(&aun_queue_lock, flags);
 988         skb = skb_peek(&aun_queue);
 989         while (skb && skb != (struct sk_buff *)&aun_queue)
 990         {
 991                 struct sk_buff *newskb = skb->next;
 992                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 993                 if ((jiffies - eb->start) > eb->timeout)
 994                 {
 995                         tx_result(skb->sk, eb->cookie,
 996                                   ECTYPE_TRANSMIT_NOT_PRESENT);
 997                         skb_unlink(skb, &aun_queue);
 998                         kfree_skb(skb);
 999                 }
1000                 skb = newskb;
1001         }
1002         spin_unlock_irqrestore(&aun_queue_lock, flags);
1003
1004         mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1005 }
1006
1007 static int __init aun_udp_initialise(void)
1008 {
1009         int error;
1010         struct sockaddr_in sin;
1011
1012         skb_queue_head_init(&aun_queue);
1013         spin_lock_init(&aun_queue_lock);
1014         init_timer(&ab_cleanup_timer);
1015         ab_cleanup_timer.expires = jiffies + (HZ*2);
1016         ab_cleanup_timer.function = ab_cleanup;
1017         add_timer(&ab_cleanup_timer);
1018
1019         memset(&sin, 0, sizeof(sin));
1020         sin.sin_port = htons(AUN_PORT);
1021
1022         /* We can count ourselves lucky Acorn machines are too dim to
1023            speak IPv6. :-) */
1024         if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1025         {
1026                 printk("AUN: socket error %d\n", -error);
1027                 return error;
1028         }
1029
1030         udpsock->sk->sk_reuse = 1;
1031         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1032                                                     from interrupts */
1033
1034         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1035                                 sizeof(sin));
1036         if (error < 0)
1037         {
1038                 printk("AUN: bind error %d\n", -error);
1039                 goto release;
1040         }
1041
1042         udpsock->sk->sk_data_ready = aun_data_available;
1043
1044         return 0;
1045
1046 release:
1047         sock_release(udpsock);
1048         udpsock = NULL;
1049         return error;
1050 }
1051 #endif
1052
1053 #ifdef CONFIG_ECONET_NATIVE
1054
1055 /*
1056  *      Receive an Econet frame from a device.
1057  */
1058
1059 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1060 {
1061         struct ec_framehdr *hdr;
1062         struct sock *sk;
1063         struct ec_device *edev = dev->ec_ptr;
1064
1065         if (skb->pkt_type == PACKET_OTHERHOST)
1066                 goto drop;
1067
1068         if (!edev)
1069                 goto drop;
1070
1071         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1072                 return NET_RX_DROP;
1073
1074         if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1075                 goto drop;
1076
1077         hdr = (struct ec_framehdr *) skb->data;
1078
1079         /* First check for encapsulated IP */
1080         if (hdr->port == EC_PORT_IP) {
1081                 skb->protocol = htons(ETH_P_IP);
1082                 skb_pull(skb, sizeof(struct ec_framehdr));
1083                 netif_rx(skb);
1084                 return 0;
1085         }
1086
1087         sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1088         if (!sk)
1089                 goto drop;
1090
1091         if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1092                             hdr->port))
1093                 goto drop;
1094
1095         return 0;
1096
1097 drop:
1098         kfree_skb(skb);
1099         return NET_RX_DROP;
1100 }
1101
1102 static struct packet_type econet_packet_type = {
1103         .type =         __constant_htons(ETH_P_ECONET),
1104         .func =         econet_rcv,
1105 };
1106
1107 static void econet_hw_initialise(void)
1108 {
1109         dev_add_pack(&econet_packet_type);
1110 }
1111
1112 #endif
1113
1114 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1115 {
1116         struct net_device *dev = (struct net_device *)data;
1117         struct ec_device *edev;
1118
1119         switch (msg) {
1120         case NETDEV_UNREGISTER:
1121                 /* A device has gone down - kill any data we hold for it. */
1122                 edev = dev->ec_ptr;
1123                 if (edev)
1124                 {
1125                         if (net2dev_map[0] == dev)
1126                                 net2dev_map[0] = NULL;
1127                         net2dev_map[edev->net] = NULL;
1128                         kfree(edev);
1129                         dev->ec_ptr = NULL;
1130                 }
1131                 break;
1132         }
1133
1134         return NOTIFY_DONE;
1135 }
1136
1137 static struct notifier_block econet_netdev_notifier = {
1138         .notifier_call =econet_notifier,
1139 };
1140
1141 static void __exit econet_proto_exit(void)
1142 {
1143 #ifdef CONFIG_ECONET_AUNUDP
1144         del_timer(&ab_cleanup_timer);
1145         if (udpsock)
1146                 sock_release(udpsock);
1147 #endif
1148         unregister_netdevice_notifier(&econet_netdev_notifier);
1149         sock_unregister(econet_family_ops.family);
1150         proto_unregister(&econet_proto);
1151 }
1152
1153 static 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);
1168 out:
1169         return err;
1170 }
1171
1172 module_init(econet_proto_init);
1173 module_exit(econet_proto_exit);
1174
1175 MODULE_LICENSE("GPL");
1176 MODULE_ALIAS_NETPROTO(PF_ECONET);