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/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/vmalloc.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         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
 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[2];
 280         struct aunhdr ah;
 281         struct sockaddr_in udpdest;
 282         __kernel_size_t size;
 283         mm_segment_t oldfs;
 284         char *userbuf;
 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 || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
 301                 mutex_unlock(&econet_mutex);
 302                 return -EINVAL;
 303         }
 304         addr.station = saddr->addr.station;
 305         addr.net = saddr->addr.net;
 306         port = saddr->port;
 307         cb = saddr->cb;
 308
 309         /* Look for a device with the right network number. */
 310         dev = net2dev_map[addr.net];
 311
 312         /* If not directly reachable, use some default */
 313         if (dev == NULL) {
 314                 dev = net2dev_map[0];
 315                 /* No interfaces at all? */
 316                 if (dev == NULL) {
 317                         mutex_unlock(&econet_mutex);
 318                         return -ENETDOWN;
 319                 }
 320         }
 321
 322         if (dev->type == ARPHRD_ECONET) {
 323                 /* Real hardware Econet.  We're not worthy etc. */
 324 #ifdef CONFIG_ECONET_NATIVE
 325                 unsigned short proto = 0;
 326                 int res;
 327
 328                 if (len + 15 > dev->mtu) {
 329                         mutex_unlock(&econet_mutex);
 330                         return -EMSGSIZE;
 331                 }
 332
 333                 dev_hold(dev);
 334
 335                 skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
 336                                           msg->msg_flags & MSG_DONTWAIT, &err);
 337                 if (skb==NULL)
 338                         goto out_unlock;
 339
 340                 skb_reserve(skb, LL_RESERVED_SPACE(dev));
 341                 skb_reset_network_header(skb);
 342
 343                 eb = (struct ec_cb *)&skb->cb;
 344
 345                 eb->cookie = saddr->cookie;
 346                 eb->sec = *saddr;
 347                 eb->sent = ec_tx_done;
 348
 349                 err = -EINVAL;
 350                 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
 351                 if (res < 0)
 352                         goto out_free;
 353                 if (res > 0) {
 354                         struct ec_framehdr *fh;
 355                         /* Poke in our control byte and
 356                            port number.  Hack, hack.  */
 357                         fh = (struct ec_framehdr *)(skb->data);
 358                         fh->cb = cb;
 359                         fh->port = port;
 360                         if (sock->type != SOCK_DGRAM) {
 361                                 skb_reset_tail_pointer(skb);
 362                                 skb->len = 0;
 363                         }
 364                 }
 365
 366                 /* Copy the data. Returns -EFAULT on error */
 367                 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 368                 skb->protocol = proto;
 369                 skb->dev = dev;
 370                 skb->priority = sk->sk_priority;
 371                 if (err)
 372                         goto out_free;
 373
 374                 err = -ENETDOWN;
 375                 if (!(dev->flags & IFF_UP))
 376                         goto out_free;
 377
 378                 /*
 379                  *      Now send it
 380                  */
 381
 382                 dev_queue_xmit(skb);
 383                 dev_put(dev);
 384                 mutex_unlock(&econet_mutex);
 385                 return(len);
 386
 387         out_free:
 388                 kfree_skb(skb);
 389         out_unlock:
 390                 if (dev)
 391                         dev_put(dev);
 392 #else
 393                 err = -EPROTOTYPE;
 394 #endif
 395                 mutex_unlock(&econet_mutex);
 396
 397                 return err;
 398         }
 399
 400 #ifdef CONFIG_ECONET_AUNUDP
 401         /* AUN virtual Econet. */
 402
 403         if (udpsock == NULL) {
 404                 mutex_unlock(&econet_mutex);
 405                 return -ENETDOWN;               /* No socket - can't send */
 406         }
 407
 408         if (len > 32768) {
 409                 err = -E2BIG;
 410                 goto error;
 411         }
 412
 413         /* Make up a UDP datagram and hand it off to some higher intellect. */
 414
 415         memset(&udpdest, 0, sizeof(udpdest));
 416         udpdest.sin_family = AF_INET;
 417         udpdest.sin_port = htons(AUN_PORT);
 418
 419         /* At the moment we use the stupid Acorn scheme of Econet address
 420            y.x maps to IP a.b.c.x.  This should be replaced with something
 421            more flexible and more aware of subnet masks.  */
 422         {
 423                 struct in_device *idev;
 424                 unsigned long network = 0;
 425
 426                 rcu_read_lock();
 427                 idev = __in_dev_get_rcu(dev);
 428                 if (idev) {
 429                         if (idev->ifa_list)
 430                                 network = ntohl(idev->ifa_list->ifa_address) &
 431                                         0xffffff00;             /* !!! */
 432                 }
 433                 rcu_read_unlock();
 434                 udpdest.sin_addr.s_addr = htonl(network | addr.station);
 435         }
 436
 437         memset(&ah, 0, sizeof(ah));
 438         ah.port = port;
 439         ah.cb = cb & 0x7f;
 440         ah.code = 2;            /* magic */
 441
 442         /* tack our header on the front of the iovec */
 443         size = sizeof(struct aunhdr);
 444         iov[0].iov_base = (void *)&ah;
 445         iov[0].iov_len = size;
 446
 447         userbuf = vmalloc(len);
 448         if (userbuf == NULL) {
 449                 err = -ENOMEM;
 450                 goto error;
 451         }
 452
 453         iov[1].iov_base = userbuf;
 454         iov[1].iov_len = len;
 455         err = memcpy_fromiovec(userbuf, msg->msg_iov, len);
 456         if (err)
 457                 goto error_free_buf;
 458
 459         /* Get a skbuff (no data, just holds our cb information) */
 460         if ((skb = sock_alloc_send_skb(sk, 0,
 461                                        msg->msg_flags & MSG_DONTWAIT,
 462                                        &err)) == NULL)
 463                 goto error_free_buf;
 464
 465         eb = (struct ec_cb *)&skb->cb;
 466
 467         eb->cookie = saddr->cookie;
 468         eb->timeout = (5*HZ);
 469         eb->start = jiffies;
 470         ah.handle = aun_seq;
 471         eb->seq = (aun_seq++);
 472         eb->sec = *saddr;
 473
 474         skb_queue_tail(&aun_queue, skb);
 475
 476         udpmsg.msg_name = (void *)&udpdest;
 477         udpmsg.msg_namelen = sizeof(udpdest);
 478         udpmsg.msg_iov = &iov[0];
 479         udpmsg.msg_iovlen = 2;
 480         udpmsg.msg_control = NULL;
 481         udpmsg.msg_controllen = 0;
 482         udpmsg.msg_flags=0;
 483
 484         oldfs = get_fs(); set_fs(KERNEL_DS);    /* More privs :-) */
 485         err = sock_sendmsg(udpsock, &udpmsg, size);
 486         set_fs(oldfs);
 487
 488 error_free_buf:
 489         vfree(userbuf);
 490 #else
 491         err = -EPROTOTYPE;
 492 #endif
 493         error:
 494         mutex_unlock(&econet_mutex);
 495
 496         return err;
 497 }
 498
 499 /*
 500  *      Look up the address of a socket.
 501  */
 502
 503 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
 504                           int *uaddr_len, int peer)
 505 {
 506         struct sock *sk;
 507         struct econet_sock *eo;
 508         struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 509
 510         if (peer)
 511                 return -EOPNOTSUPP;
 512
 513         memset(sec, 0, sizeof(*sec));
 514         mutex_lock(&econet_mutex);
 515
 516         sk = sock->sk;
 517         eo = ec_sk(sk);
 518
 519         sec->sec_family   = AF_ECONET;
 520         sec->port         = eo->port;
 521         sec->addr.station = eo->station;
 522         sec->addr.net     = eo->net;
 523
 524         mutex_unlock(&econet_mutex);
 525
 526         *uaddr_len = sizeof(*sec);
 527         return 0;
 528 }
 529
 530 static void econet_destroy_timer(unsigned long data)
 531 {
 532         struct sock *sk=(struct sock *)data;
 533
 534         if (!sk_has_allocations(sk)) {
 535                 sk_free(sk);
 536                 return;
 537         }
 538
 539         sk->sk_timer.expires = jiffies + 10 * HZ;
 540         add_timer(&sk->sk_timer);
 541         printk(KERN_DEBUG "econet socket destroy delayed\n");
 542 }
 543
 544 /*
 545  *      Close an econet socket.
 546  */
 547
 548 static int econet_release(struct socket *sock)
 549 {
 550         struct sock *sk;
 551
 552         mutex_lock(&econet_mutex);
 553
 554         sk = sock->sk;
 555         if (!sk)
 556                 goto out_unlock;
 557
 558         econet_remove_socket(&econet_sklist, sk);
 559
 560         /*
 561          *      Now the socket is dead. No more input will appear.
 562          */
 563
 564         sk->sk_state_change(sk);        /* It is useless. Just for sanity. */
 565
 566         sock_orphan(sk);
 567
 568         /* Purge queues */
 569
 570         skb_queue_purge(&sk->sk_receive_queue);
 571
 572         if (sk_has_allocations(sk)) {
 573                 sk->sk_timer.data     = (unsigned long)sk;
 574                 sk->sk_timer.expires  = jiffies + HZ;
 575                 sk->sk_timer.function = econet_destroy_timer;
 576                 add_timer(&sk->sk_timer);
 577
 578                 goto out_unlock;
 579         }
 580
 581         sk_free(sk);
 582
 583 out_unlock:
 584         mutex_unlock(&econet_mutex);
 585         return 0;
 586 }
 587
 588 static struct proto econet_proto = {
 589         .name     = "ECONET",
 590         .owner    = THIS_MODULE,
 591         .obj_size = sizeof(struct econet_sock),
 592 };
 593
 594 /*
 595  *      Create an Econet socket
 596  */
 597
 598 static int econet_create(struct net *net, struct socket *sock, int protocol)
 599 {
 600         struct sock *sk;
 601         struct econet_sock *eo;
 602         int err;
 603
 604         if (net != &init_net)
 605                 return -EAFNOSUPPORT;
 606
 607         /* Econet only provides datagram services. */
 608         if (sock->type != SOCK_DGRAM)
 609                 return -ESOCKTNOSUPPORT;
 610
 611         sock->state = SS_UNCONNECTED;
 612
 613         err = -ENOBUFS;
 614         sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
 615         if (sk == NULL)
 616                 goto out;
 617
 618         sk->sk_reuse = 1;
 619         sock->ops = &econet_ops;
 620         sock_init_data(sock, sk);
 621
 622         eo = ec_sk(sk);
 623         sock_reset_flag(sk, SOCK_ZAPPED);
 624         sk->sk_family = PF_ECONET;
 625         eo->num = protocol;
 626
 627         econet_insert_socket(&econet_sklist, sk);
 628         return(0);
 629 out:
 630         return err;
 631 }
 632
 633 /*
 634  *      Handle Econet specific ioctls
 635  */
 636
 637 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
 638 {
 639         struct ifreq ifr;
 640         struct ec_device *edev;
 641         struct net_device *dev;
 642         struct sockaddr_ec *sec;
 643         int err;
 644
 645         /*
 646          *      Fetch the caller's info block into kernel space
 647          */
 648
 649         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 650                 return -EFAULT;
 651
 652         if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
 653                 return -ENODEV;
 654
 655         sec = (struct sockaddr_ec *)&ifr.ifr_addr;
 656
 657         mutex_lock(&econet_mutex);
 658
 659         err = 0;
 660         switch (cmd) {
 661         case SIOCSIFADDR:
 662                 if (!capable(CAP_NET_ADMIN))
 663                         return -EPERM;
 664
 665                 edev = dev->ec_ptr;
 666                 if (edev == NULL) {
 667                         /* Magic up a new one. */
 668                         edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
 669                         if (edev == NULL) {
 670                                 err = -ENOMEM;
 671                                 break;
 672                         }
 673                         dev->ec_ptr = edev;
 674                 } else
 675                         net2dev_map[edev->net] = NULL;
 676                 edev->station = sec->addr.station;
 677                 edev->net = sec->addr.net;
 678                 net2dev_map[sec->addr.net] = dev;
 679                 if (!net2dev_map[0])
 680                         net2dev_map[0] = dev;
 681                 break;
 682
 683         case SIOCGIFADDR:
 684                 edev = dev->ec_ptr;
 685                 if (edev == NULL) {
 686                         err = -ENODEV;
 687                         break;
 688                 }
 689                 memset(sec, 0, sizeof(struct sockaddr_ec));
 690                 sec->addr.station = edev->station;
 691                 sec->addr.net = edev->net;
 692                 sec->sec_family = AF_ECONET;
 693                 dev_put(dev);
 694                 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 695                         err = -EFAULT;
 696                 break;
 697
 698         default:
 699                 err = -EINVAL;
 700                 break;
 701         }
 702
 703         mutex_unlock(&econet_mutex);
 704
 705         dev_put(dev);
 706
 707         return err;
 708 }
 709
 710 /*
 711  *      Handle generic ioctls
 712  */
 713
 714 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 715 {
 716         struct sock *sk = sock->sk;
 717         void __user *argp = (void __user *)arg;
 718
 719         switch(cmd) {
 720                 case SIOCGSTAMP:
 721                         return sock_get_timestamp(sk, argp);
 722
 723                 case SIOCGSTAMPNS:
 724                         return sock_get_timestampns(sk, argp);
 725
 726                 case SIOCSIFADDR:
 727                 case SIOCGIFADDR:
 728                         return ec_dev_ioctl(sock, cmd, argp);
 729                         break;
 730
 731                 default:
 732                         return -ENOIOCTLCMD;
 733         }
 734         /*NOTREACHED*/
 735         return 0;
 736 }
 737
 738 static struct net_proto_family econet_family_ops = {
 739         .family =       PF_ECONET,
 740         .create =       econet_create,
 741         .owner  =       THIS_MODULE,
 742 };
 743
 744 static const struct proto_ops econet_ops = {
 745         .family =       PF_ECONET,
 746         .owner =        THIS_MODULE,
 747         .release =      econet_release,
 748         .bind =         econet_bind,
 749         .connect =      sock_no_connect,
 750         .socketpair =   sock_no_socketpair,
 751         .accept =       sock_no_accept,
 752         .getname =      econet_getname,
 753         .poll =         datagram_poll,
 754         .ioctl =        econet_ioctl,
 755         .listen =       sock_no_listen,
 756         .shutdown =     sock_no_shutdown,
 757         .setsockopt =   sock_no_setsockopt,
 758         .getsockopt =   sock_no_getsockopt,
 759         .sendmsg =      econet_sendmsg,
 760         .recvmsg =      econet_recvmsg,
 761         .mmap =         sock_no_mmap,
 762         .sendpage =     sock_no_sendpage,
 763 };
 764
 765 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 766 /*
 767  *      Find the listening socket, if any, for the given data.
 768  */
 769
 770 static struct sock *ec_listening_socket(unsigned char port, unsigned char
 771                                  station, unsigned char net)
 772 {
 773         struct sock *sk;
 774         struct hlist_node *node;
 775
 776         sk_for_each(sk, node, &econet_sklist) {
 777                 struct econet_sock *opt = ec_sk(sk);
 778                 if ((opt->port == port || opt->port == 0) &&
 779                     (opt->station == station || opt->station == 0) &&
 780                     (opt->net == net || opt->net == 0))
 781                         goto found;
 782         }
 783         sk = NULL;
 784 found:
 785         return sk;
 786 }
 787
 788 /*
 789  *      Queue a received packet for a socket.
 790  */
 791
 792 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 793                            unsigned char stn, unsigned char net,
 794                            unsigned char cb, unsigned char port)
 795 {
 796         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 797         struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 798
 799         memset(sec, 0, sizeof(struct sockaddr_ec));
 800         sec->sec_family = AF_ECONET;
 801         sec->type = ECTYPE_PACKET_RECEIVED;
 802         sec->port = port;
 803         sec->cb = cb;
 804         sec->addr.net = net;
 805         sec->addr.station = stn;
 806
 807         return sock_queue_rcv_skb(sk, skb);
 808 }
 809 #endif
 810
 811 #ifdef CONFIG_ECONET_AUNUDP
 812 /*
 813  *      Send an AUN protocol response.
 814  */
 815
 816 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 817 {
 818         struct sockaddr_in sin = {
 819                 .sin_family = AF_INET,
 820                 .sin_port = htons(AUN_PORT),
 821                 .sin_addr = {.s_addr = addr}
 822         };
 823         struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 824         struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 825         struct msghdr udpmsg;
 826
 827         udpmsg.msg_name = (void *)&sin;
 828         udpmsg.msg_namelen = sizeof(sin);
 829         udpmsg.msg_control = NULL;
 830         udpmsg.msg_controllen = 0;
 831         udpmsg.msg_flags=0;
 832
 833         kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 834 }
 835
 836
 837 /*
 838  *      Handle incoming AUN packets.  Work out if anybody wants them,
 839  *      and send positive or negative acknowledgements as appropriate.
 840  */
 841
 842 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 843 {
 844         struct iphdr *ip = ip_hdr(skb);
 845         unsigned char stn = ntohl(ip->saddr) & 0xff;
 846         struct dst_entry *dst = skb_dst(skb);
 847         struct ec_device *edev = NULL;
 848         struct sock *sk;
 849         struct sk_buff *newskb;
 850
 851         if (dst)
 852                 edev = dst->dev->ec_ptr;
 853
 854         if (! edev)
 855                 goto bad;
 856
 857         if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
 858                 goto bad;               /* Nobody wants it */
 859
 860         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 861                            GFP_ATOMIC);
 862         if (newskb == NULL)
 863         {
 864                 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
 865                 /* Send nack and hope sender tries again */
 866                 goto bad;
 867         }
 868
 869         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
 870                len - sizeof(struct aunhdr));
 871
 872         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
 873         {
 874                 /* Socket is bankrupt. */
 875                 kfree_skb(newskb);
 876                 goto bad;
 877         }
 878
 879         aun_send_response(ip->saddr, ah->handle, 3, 0);
 880         return;
 881
 882 bad:
 883         aun_send_response(ip->saddr, ah->handle, 4, 0);
 884 }
 885
 886 /*
 887  *      Handle incoming AUN transmit acknowledgements.  If the sequence
 888  *      number matches something in our backlog then kill it and tell
 889  *      the user.  If the remote took too long to reply then we may have
 890  *      dropped the packet already.
 891  */
 892
 893 static void aun_tx_ack(unsigned long seq, int result)
 894 {
 895         struct sk_buff *skb;
 896         unsigned long flags;
 897         struct ec_cb *eb;
 898
 899         spin_lock_irqsave(&aun_queue_lock, flags);
 900         skb_queue_walk(&aun_queue, skb) {
 901                 eb = (struct ec_cb *)&skb->cb;
 902                 if (eb->seq == seq)
 903                         goto foundit;
 904         }
 905         spin_unlock_irqrestore(&aun_queue_lock, flags);
 906         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
 907         return;
 908
 909 foundit:
 910         tx_result(skb->sk, eb->cookie, result);
 911         skb_unlink(skb, &aun_queue);
 912         spin_unlock_irqrestore(&aun_queue_lock, flags);
 913         kfree_skb(skb);
 914 }
 915
 916 /*
 917  *      Deal with received AUN frames - sort out what type of thing it is
 918  *      and hand it to the right function.
 919  */
 920
 921 static void aun_data_available(struct sock *sk, int slen)
 922 {
 923         int err;
 924         struct sk_buff *skb;
 925         unsigned char *data;
 926         struct aunhdr *ah;
 927         struct iphdr *ip;
 928         size_t len;
 929
 930         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 931                 if (err == -EAGAIN) {
 932                         printk(KERN_ERR "AUN: no data available?!");
 933                         return;
 934                 }
 935                 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
 936         }
 937
 938         data = skb_transport_header(skb) + sizeof(struct udphdr);
 939         ah = (struct aunhdr *)data;
 940         len = skb->len - sizeof(struct udphdr);
 941         ip = ip_hdr(skb);
 942
 943         switch (ah->code)
 944         {
 945         case 2:
 946                 aun_incoming(skb, ah, len);
 947                 break;
 948         case 3:
 949                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 950                 break;
 951         case 4:
 952                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 953                 break;
 954 #if 0
 955                 /* This isn't quite right yet. */
 956         case 5:
 957                 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
 958                 break;
 959 #endif
 960         default:
 961                 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
 962         }
 963
 964         skb_free_datagram(sk, skb);
 965 }
 966
 967 /*
 968  *      Called by the timer to manage the AUN transmit queue.  If a packet
 969  *      was sent to a dead or nonexistent host then we will never get an
 970  *      acknowledgement back.  After a few seconds we need to spot this and
 971  *      drop the packet.
 972  */
 973
 974 static void ab_cleanup(unsigned long h)
 975 {
 976         struct sk_buff *skb, *n;
 977         unsigned long flags;
 978
 979         spin_lock_irqsave(&aun_queue_lock, flags);
 980         skb_queue_walk_safe(&aun_queue, skb, n) {
 981                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 982                 if ((jiffies - eb->start) > eb->timeout) {
 983                         tx_result(skb->sk, eb->cookie,
 984                                   ECTYPE_TRANSMIT_NOT_PRESENT);
 985                         skb_unlink(skb, &aun_queue);
 986                         kfree_skb(skb);
 987                 }
 988         }
 989         spin_unlock_irqrestore(&aun_queue_lock, flags);
 990
 991         mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
 992 }
 993
 994 static int __init aun_udp_initialise(void)
 995 {
 996         int error;
 997         struct sockaddr_in sin;
 998
 999         skb_queue_head_init(&aun_queue);
1000         spin_lock_init(&aun_queue_lock);
1001         setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
1002         ab_cleanup_timer.expires = jiffies + (HZ*2);
1003         add_timer(&ab_cleanup_timer);
1004
1005         memset(&sin, 0, sizeof(sin));
1006         sin.sin_port = htons(AUN_PORT);
1007
1008         /* We can count ourselves lucky Acorn machines are too dim to
1009            speak IPv6. :-) */
1010         if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1011         {
1012                 printk("AUN: socket error %d\n", -error);
1013                 return error;
1014         }
1015
1016         udpsock->sk->sk_reuse = 1;
1017         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1018                                                     from interrupts */
1019
1020         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1021                                 sizeof(sin));
1022         if (error < 0)
1023         {
1024                 printk("AUN: bind error %d\n", -error);
1025                 goto release;
1026         }
1027
1028         udpsock->sk->sk_data_ready = aun_data_available;
1029
1030         return 0;
1031
1032 release:
1033         sock_release(udpsock);
1034         udpsock = NULL;
1035         return error;
1036 }
1037 #endif
1038
1039 #ifdef CONFIG_ECONET_NATIVE
1040
1041 /*
1042  *      Receive an Econet frame from a device.
1043  */
1044
1045 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1046 {
1047         struct ec_framehdr *hdr;
1048         struct sock *sk;
1049         struct ec_device *edev = dev->ec_ptr;
1050
1051         if (!net_eq(dev_net(dev), &init_net))
1052                 goto drop;
1053
1054         if (skb->pkt_type == PACKET_OTHERHOST)
1055                 goto drop;
1056
1057         if (!edev)
1058                 goto drop;
1059
1060         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1061                 return NET_RX_DROP;
1062
1063         if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1064                 goto drop;
1065
1066         hdr = (struct ec_framehdr *) skb->data;
1067
1068         /* First check for encapsulated IP */
1069         if (hdr->port == EC_PORT_IP) {
1070                 skb->protocol = htons(ETH_P_IP);
1071                 skb_pull(skb, sizeof(struct ec_framehdr));
1072                 netif_rx(skb);
1073                 return NET_RX_SUCCESS;
1074         }
1075
1076         sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1077         if (!sk)
1078                 goto drop;
1079
1080         if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1081                             hdr->port))
1082                 goto drop;
1083
1084         return NET_RX_SUCCESS;
1085
1086 drop:
1087         kfree_skb(skb);
1088         return NET_RX_DROP;
1089 }
1090
1091 static struct packet_type econet_packet_type __read_mostly = {
1092         .type =         cpu_to_be16(ETH_P_ECONET),
1093         .func =         econet_rcv,
1094 };
1095
1096 static void econet_hw_initialise(void)
1097 {
1098         dev_add_pack(&econet_packet_type);
1099 }
1100
1101 #endif
1102
1103 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1104 {
1105         struct net_device *dev = (struct net_device *)data;
1106         struct ec_device *edev;
1107
1108         if (!net_eq(dev_net(dev), &init_net))
1109                 return NOTIFY_DONE;
1110
1111         switch (msg) {
1112         case NETDEV_UNREGISTER:
1113                 /* A device has gone down - kill any data we hold for it. */
1114                 edev = dev->ec_ptr;
1115                 if (edev)
1116                 {
1117                         if (net2dev_map[0] == dev)
1118                                 net2dev_map[0] = NULL;
1119                         net2dev_map[edev->net] = NULL;
1120                         kfree(edev);
1121                         dev->ec_ptr = NULL;
1122                 }
1123                 break;
1124         }
1125
1126         return NOTIFY_DONE;
1127 }
1128
1129 static struct notifier_block econet_netdev_notifier = {
1130         .notifier_call =econet_notifier,
1131 };
1132
1133 static void __exit econet_proto_exit(void)
1134 {
1135 #ifdef CONFIG_ECONET_AUNUDP
1136         del_timer(&ab_cleanup_timer);
1137         if (udpsock)
1138                 sock_release(udpsock);
1139 #endif
1140         unregister_netdevice_notifier(&econet_netdev_notifier);
1141 #ifdef CONFIG_ECONET_NATIVE
1142         dev_remove_pack(&econet_packet_type);
1143 #endif
1144         sock_unregister(econet_family_ops.family);
1145         proto_unregister(&econet_proto);
1146 }
1147
1148 static int __init econet_proto_init(void)
1149 {
1150         int err = proto_register(&econet_proto, 0);
1151
1152         if (err != 0)
1153                 goto out;
1154         sock_register(&econet_family_ops);
1155 #ifdef CONFIG_ECONET_AUNUDP
1156         spin_lock_init(&aun_queue_lock);
1157         aun_udp_initialise();
1158 #endif
1159 #ifdef CONFIG_ECONET_NATIVE
1160         econet_hw_initialise();
1161 #endif
1162         register_netdevice_notifier(&econet_netdev_notifier);
1163 out:
1164         return err;
1165 }
1166
1167 module_init(econet_proto_init);
1168 module_exit(econet_proto_exit);
1169
1170 MODULE_LICENSE("GPL");
1171 MODULE_ALIAS_NETPROTO(PF_ECONET);