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