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 #define pr_fmt(fmt) fmt
  13
  14 #include <linux/module.h>
  15
  16 #include <linux/types.h>
  17 #include <linux/kernel.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 <linux/slab.h>
  36 #include <linux/vmalloc.h>
  37 #include <net/sock.h>
  38 #include <net/inet_common.h>
  39 #include <linux/stat.h>
  40 #include <linux/init.h>
  41 #include <linux/if_ec.h>
  42 #include <net/udp.h>
  43 #include <net/ip.h>
  44 #include <linux/spinlock.h>
  45 #include <linux/rcupdate.h>
  46 #include <linux/bitops.h>
  47 #include <linux/mutex.h>
  48
  49 #include <linux/uaccess.h>
  50 #include <asm/system.h>
  51
  52 static const struct proto_ops econet_ops;
  53 static struct hlist_head econet_sklist;
  54 static DEFINE_SPINLOCK(econet_lock);
  55 static DEFINE_MUTEX(econet_mutex);
  56
  57 /* Since there are only 256 possible network numbers (or fewer, depends
  58    how you count) it makes sense to use a simple lookup table. */
  59 static struct net_device *net2dev_map[256];
  60
  61 #define EC_PORT_IP      0xd2
  62
  63 #ifdef CONFIG_ECONET_AUNUDP
  64 static DEFINE_SPINLOCK(aun_queue_lock);
  65 static struct socket *udpsock;
  66 #define AUN_PORT        0x8000
  67
  68 struct aunhdr {
  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         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         spin_lock_bh(&econet_lock);
 102         sk_del_node_init(sk);
 103         spin_unlock_bh(&econet_lock);
 104 }
 105
 106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
 107 {
 108         spin_lock_bh(&econet_lock);
 109         sk_add_node(sk, list);
 110         spin_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                 copied = len;
 158                 msg->msg_flags |= MSG_TRUNC;
 159         }
 160
 161         /* We can't use skb_copy_datagram here */
 162         err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
 163         if (err)
 164                 goto out_free;
 165         sk->sk_stamp = skb->tstamp;
 166
 167         if (msg->msg_name)
 168                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 169
 170         /*
 171          *      Free or return the buffer as appropriate. Again this
 172          *      hides all the races and re-entrancy issues from us.
 173          */
 174         err = copied;
 175
 176 out_free:
 177         skb_free_datagram(sk, skb);
 178 out:
 179         mutex_unlock(&econet_mutex);
 180         return err;
 181 }
 182
 183 /*
 184  *      Bind an Econet socket.
 185  */
 186
 187 static int econet_bind(struct socket *sock, struct sockaddr *uaddr,
 188                        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                 pr_debug("econet: memory squeeze, transmit result dropped\n");
 230                 return;
 231         }
 232
 233         eb = (struct ec_cb *)&skb->cb;
 234         sec = (struct sockaddr_ec *)&eb->sec;
 235         memset(sec, 0, sizeof(struct sockaddr_ec));
 236         sec->cookie = cookie;
 237         sec->type = ECTYPE_TRANSMIT_STATUS | result;
 238         sec->sec_family = AF_ECONET;
 239
 240         if (sock_queue_rcv_skb(sk, skb) < 0)
 241                 kfree_skb(skb);
 242 }
 243 #endif
 244
 245 #ifdef CONFIG_ECONET_NATIVE
 246 /*
 247  *      Called by the Econet hardware driver when a packet transmit
 248  *      has completed.  Tell the user.
 249  */
 250
 251 static void ec_tx_done(struct sk_buff *skb, int result)
 252 {
 253         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 254         tx_result(skb->sk, eb->cookie, result);
 255 }
 256 #endif
 257
 258 /*
 259  *      Send a packet.  We have to work out which device it's going out on
 260  *      and hence whether to use real Econet or the UDP emulation.
 261  */
 262
 263 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
 264                           struct msghdr *msg, size_t len)
 265 {
 266         struct sockaddr_ec *saddr = (struct sockaddr_ec *)msg->msg_name;
 267         struct net_device *dev;
 268         struct ec_addr addr;
 269         int err;
 270         unsigned char port, cb;
 271 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 272         struct sock *sk = sock->sk;
 273         struct sk_buff *skb;
 274         struct ec_cb *eb;
 275 #endif
 276 #ifdef CONFIG_ECONET_AUNUDP
 277         struct msghdr udpmsg;
 278         struct iovec iov[2];
 279         struct aunhdr ah;
 280         struct sockaddr_in udpdest;
 281         __kernel_size_t size;
 282         mm_segment_t oldfs;
 283         char *userbuf;
 284 #endif
 285
 286         /*
 287          *      Check the flags.
 288          */
 289
 290         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 291                 return -EINVAL;
 292
 293         /*
 294          *      Get and verify the address.
 295          */
 296
 297         mutex_lock(&econet_mutex);
 298
 299         if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
 300                 mutex_unlock(&econet_mutex);
 301                 return -EINVAL;
 302         }
 303         addr.station = saddr->addr.station;
 304         addr.net = saddr->addr.net;
 305         port = saddr->port;
 306         cb = saddr->cb;
 307
 308         /* Look for a device with the right network number. */
 309         dev = net2dev_map[addr.net];
 310
 311         /* If not directly reachable, use some default */
 312         if (dev == NULL) {
 313                 dev = net2dev_map[0];
 314                 /* No interfaces at all? */
 315                 if (dev == NULL) {
 316                         mutex_unlock(&econet_mutex);
 317                         return -ENETDOWN;
 318                 }
 319         }
 320
 321         if (dev->type == ARPHRD_ECONET) {
 322                 /* Real hardware Econet.  We're not worthy etc. */
 323 #ifdef CONFIG_ECONET_NATIVE
 324                 unsigned short proto = 0;
 325                 int res;
 326
 327                 if (len + 15 > dev->mtu) {
 328                         mutex_unlock(&econet_mutex);
 329                         return -EMSGSIZE;
 330                 }
 331
 332                 dev_hold(dev);
 333
 334                 skb = sock_alloc_send_skb(sk, len + LL_ALLOCATED_SPACE(dev),
 335                                           msg->msg_flags & MSG_DONTWAIT, &err);
 336                 if (skb == NULL)
 337                         goto out_unlock;
 338
 339                 skb_reserve(skb, LL_RESERVED_SPACE(dev));
 340                 skb_reset_network_header(skb);
 341
 342                 eb = (struct ec_cb *)&skb->cb;
 343
 344                 eb->cookie = saddr->cookie;
 345                 eb->sec = *saddr;
 346                 eb->sent = ec_tx_done;
 347
 348                 err = -EINVAL;
 349                 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
 350                 if (res < 0)
 351                         goto out_free;
 352                 if (res > 0) {
 353                         struct ec_framehdr *fh;
 354                         /* Poke in our control byte and
 355                            port number.  Hack, hack.  */
 356                         fh = (struct ec_framehdr *)skb->data;
 357                         fh->cb = cb;
 358                         fh->port = port;
 359                         if (sock->type != SOCK_DGRAM) {
 360                                 skb_reset_tail_pointer(skb);
 361                                 skb->len = 0;
 362                         }
 363                 }
 364
 365                 /* Copy the data. Returns -EFAULT on error */
 366                 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
 367                 skb->protocol = proto;
 368                 skb->dev = dev;
 369                 skb->priority = sk->sk_priority;
 370                 if (err)
 371                         goto out_free;
 372
 373                 err = -ENETDOWN;
 374                 if (!(dev->flags & IFF_UP))
 375                         goto out_free;
 376
 377                 /*
 378                  *      Now send it
 379                  */
 380
 381                 dev_queue_xmit(skb);
 382                 dev_put(dev);
 383                 mutex_unlock(&econet_mutex);
 384                 return len;
 385
 386 out_free:
 387                 kfree_skb(skb);
 388 out_unlock:
 389                 if (dev)
 390                         dev_put(dev);
 391 #else
 392                 err = -EPROTOTYPE;
 393 #endif
 394                 mutex_unlock(&econet_mutex);
 395
 396                 return err;
 397         }
 398
 399 #ifdef CONFIG_ECONET_AUNUDP
 400         /* AUN virtual Econet. */
 401
 402         if (udpsock == NULL) {
 403                 mutex_unlock(&econet_mutex);
 404                 return -ENETDOWN;               /* No socket - can't send */
 405         }
 406
 407         if (len > 32768) {
 408                 err = -E2BIG;
 409                 goto error;
 410         }
 411
 412         /* Make up a UDP datagram and hand it off to some higher intellect. */
 413
 414         memset(&udpdest, 0, sizeof(udpdest));
 415         udpdest.sin_family = AF_INET;
 416         udpdest.sin_port = htons(AUN_PORT);
 417
 418         /* At the moment we use the stupid Acorn scheme of Econet address
 419            y.x maps to IP a.b.c.x.  This should be replaced with something
 420            more flexible and more aware of subnet masks.  */
 421         {
 422                 struct in_device *idev;
 423                 unsigned long network = 0;
 424
 425                 rcu_read_lock();
 426                 idev = __in_dev_get_rcu(dev);
 427                 if (idev) {
 428                         if (idev->ifa_list)
 429                                 network = ntohl(idev->ifa_list->ifa_address) &
 430                                         0xffffff00;             /* !!! */
 431                 }
 432                 rcu_read_unlock();
 433                 udpdest.sin_addr.s_addr = htonl(network | addr.station);
 434         }
 435
 436         memset(&ah, 0, sizeof(ah));
 437         ah.port = port;
 438         ah.cb = cb & 0x7f;
 439         ah.code = 2;            /* magic */
 440
 441         /* tack our header on the front of the iovec */
 442         size = sizeof(struct aunhdr);
 443         iov[0].iov_base = (void *)&ah;
 444         iov[0].iov_len = size;
 445
 446         userbuf = vmalloc(len);
 447         if (userbuf == NULL) {
 448                 err = -ENOMEM;
 449                 goto error;
 450         }
 451
 452         iov[1].iov_base = userbuf;
 453         iov[1].iov_len = len;
 454         err = memcpy_fromiovec(userbuf, msg->msg_iov, len);
 455         if (err)
 456                 goto error_free_buf;
 457
 458         /* Get a skbuff (no data, just holds our cb information) */
 459         skb = sock_alloc_send_skb(sk, 0, msg->msg_flags & MSG_DONTWAIT, &err);
 460         if (skb == NULL)
 461                 goto error_free_buf;
 462
 463         eb = (struct ec_cb *)&skb->cb;
 464
 465         eb->cookie = saddr->cookie;
 466         eb->timeout = 5 * HZ;
 467         eb->start = jiffies;
 468         ah.handle = aun_seq;
 469         eb->seq = (aun_seq++);
 470         eb->sec = *saddr;
 471
 472         skb_queue_tail(&aun_queue, skb);
 473
 474         udpmsg.msg_name = (void *)&udpdest;
 475         udpmsg.msg_namelen = sizeof(udpdest);
 476         udpmsg.msg_iov = &iov[0];
 477         udpmsg.msg_iovlen = 2;
 478         udpmsg.msg_control = NULL;
 479         udpmsg.msg_controllen = 0;
 480         udpmsg.msg_flags = 0;
 481
 482         oldfs = get_fs();
 483         set_fs(KERNEL_DS);              /* More privs :-) */
 484         err = sock_sendmsg(udpsock, &udpmsg, size);
 485         set_fs(oldfs);
 486
 487 error_free_buf:
 488         vfree(userbuf);
 489 error:
 490 #else
 491         err = -EPROTOTYPE;
 492 #endif
 493         mutex_unlock(&econet_mutex);
 494
 495         return err;
 496 }
 497
 498 /*
 499  *      Look up the address of a socket.
 500  */
 501
 502 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
 503                           int *uaddr_len, int peer)
 504 {
 505         struct sock *sk;
 506         struct econet_sock *eo;
 507         struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 508
 509         if (peer)
 510                 return -EOPNOTSUPP;
 511
 512         memset(sec, 0, sizeof(*sec));
 513         mutex_lock(&econet_mutex);
 514
 515         sk = sock->sk;
 516         eo = ec_sk(sk);
 517
 518         sec->sec_family   = AF_ECONET;
 519         sec->port         = eo->port;
 520         sec->addr.station = eo->station;
 521         sec->addr.net     = eo->net;
 522
 523         mutex_unlock(&econet_mutex);
 524
 525         *uaddr_len = sizeof(*sec);
 526         return 0;
 527 }
 528
 529 static void econet_destroy_timer(unsigned long data)
 530 {
 531         struct sock *sk = (struct sock *)data;
 532
 533         if (!sk_has_allocations(sk)) {
 534                 sk_free(sk);
 535                 return;
 536         }
 537
 538         sk->sk_timer.expires = jiffies + 10 * HZ;
 539         add_timer(&sk->sk_timer);
 540         pr_debug("econet: socket destroy delayed\n");
 541 }
 542
 543 /*
 544  *      Close an econet socket.
 545  */
 546
 547 static int econet_release(struct socket *sock)
 548 {
 549         struct sock *sk;
 550
 551         mutex_lock(&econet_mutex);
 552
 553         sk = sock->sk;
 554         if (!sk)
 555                 goto out_unlock;
 556
 557         econet_remove_socket(&econet_sklist, sk);
 558
 559         /*
 560          *      Now the socket is dead. No more input will appear.
 561          */
 562
 563         sk->sk_state_change(sk);        /* It is useless. Just for sanity. */
 564
 565         sock_orphan(sk);
 566
 567         /* Purge queues */
 568
 569         skb_queue_purge(&sk->sk_receive_queue);
 570
 571         if (sk_has_allocations(sk)) {
 572                 sk->sk_timer.data     = (unsigned long)sk;
 573                 sk->sk_timer.expires  = jiffies + HZ;
 574                 sk->sk_timer.function = econet_destroy_timer;
 575                 add_timer(&sk->sk_timer);
 576
 577                 goto out_unlock;
 578         }
 579
 580         sk_free(sk);
 581
 582 out_unlock:
 583         mutex_unlock(&econet_mutex);
 584         return 0;
 585 }
 586
 587 static struct proto econet_proto = {
 588         .name     = "ECONET",
 589         .owner    = THIS_MODULE,
 590         .obj_size = sizeof(struct econet_sock),
 591 };
 592
 593 /*
 594  *      Create an Econet socket
 595  */
 596
 597 static int econet_create(struct net *net, struct socket *sock, int protocol,
 598                          int kern)
 599 {
 600         struct sock *sk;
 601         struct econet_sock *eo;
 602         int err;
 603
 604         if (!net_eq(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         dev = dev_get_by_name(&init_net, ifr.ifr_name);
 653         if (dev == NULL)
 654                 return -ENODEV;
 655
 656         sec = (struct sockaddr_ec *)&ifr.ifr_addr;
 657
 658         mutex_lock(&econet_mutex);
 659
 660         err = 0;
 661         switch (cmd) {
 662         case SIOCSIFADDR:
 663                 if (!capable(CAP_NET_ADMIN)) {
 664                         err = -EPERM;
 665                         break;
 666                 }
 667
 668                 edev = dev->ec_ptr;
 669                 if (edev == NULL) {
 670                         /* Magic up a new one. */
 671                         edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
 672                         if (edev == NULL) {
 673                                 err = -ENOMEM;
 674                                 break;
 675                         }
 676                         dev->ec_ptr = edev;
 677                 } else
 678                         net2dev_map[edev->net] = NULL;
 679                 edev->station = sec->addr.station;
 680                 edev->net = sec->addr.net;
 681                 net2dev_map[sec->addr.net] = dev;
 682                 if (!net2dev_map[0])
 683                         net2dev_map[0] = dev;
 684                 break;
 685
 686         case SIOCGIFADDR:
 687                 edev = dev->ec_ptr;
 688                 if (edev == NULL) {
 689                         err = -ENODEV;
 690                         break;
 691                 }
 692                 memset(sec, 0, sizeof(struct sockaddr_ec));
 693                 sec->addr.station = edev->station;
 694                 sec->addr.net = edev->net;
 695                 sec->sec_family = AF_ECONET;
 696                 dev_put(dev);
 697                 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 698                         err = -EFAULT;
 699                 break;
 700
 701         default:
 702                 err = -EINVAL;
 703                 break;
 704         }
 705
 706         mutex_unlock(&econet_mutex);
 707
 708         dev_put(dev);
 709
 710         return err;
 711 }
 712
 713 /*
 714  *      Handle generic ioctls
 715  */
 716
 717 static int econet_ioctl(struct socket *sock, unsigned int cmd,
 718                         unsigned long arg)
 719 {
 720         struct sock *sk = sock->sk;
 721         void __user *argp = (void __user *)arg;
 722
 723         switch (cmd) {
 724         case SIOCGSTAMP:
 725                 return sock_get_timestamp(sk, argp);
 726
 727         case SIOCGSTAMPNS:
 728                 return sock_get_timestampns(sk, argp);
 729
 730         case SIOCSIFADDR:
 731         case SIOCGIFADDR:
 732                 return ec_dev_ioctl(sock, cmd, argp);
 733
 734         }
 735
 736         return -ENOIOCTLCMD;
 737 }
 738
 739 static const struct net_proto_family econet_family_ops = {
 740         .family =       PF_ECONET,
 741         .create =       econet_create,
 742         .owner  =       THIS_MODULE,
 743 };
 744
 745 static const struct proto_ops econet_ops = {
 746         .family =       PF_ECONET,
 747         .owner =        THIS_MODULE,
 748         .release =      econet_release,
 749         .bind =         econet_bind,
 750         .connect =      sock_no_connect,
 751         .socketpair =   sock_no_socketpair,
 752         .accept =       sock_no_accept,
 753         .getname =      econet_getname,
 754         .poll =         datagram_poll,
 755         .ioctl =        econet_ioctl,
 756         .listen =       sock_no_listen,
 757         .shutdown =     sock_no_shutdown,
 758         .setsockopt =   sock_no_setsockopt,
 759         .getsockopt =   sock_no_getsockopt,
 760         .sendmsg =      econet_sendmsg,
 761         .recvmsg =      econet_recvmsg,
 762         .mmap =         sock_no_mmap,
 763         .sendpage =     sock_no_sendpage,
 764 };
 765
 766 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 767 /*
 768  *      Find the listening socket, if any, for the given data.
 769  */
 770
 771 static struct sock *ec_listening_socket(unsigned char port, unsigned char
 772                                  station, unsigned char net)
 773 {
 774         struct sock *sk;
 775         struct hlist_node *node;
 776
 777         spin_lock(&econet_lock);
 778         sk_for_each(sk, node, &econet_sklist) {
 779                 struct econet_sock *opt = ec_sk(sk);
 780                 if ((opt->port == port || opt->port == 0) &&
 781                     (opt->station == station || opt->station == 0) &&
 782                     (opt->net == net || opt->net == 0)) {
 783                         sock_hold(sk);
 784                         goto found;
 785                 }
 786         }
 787         sk = NULL;
 788 found:
 789         spin_unlock(&econet_lock);
 790         return sk;
 791 }
 792
 793 /*
 794  *      Queue a received packet for a socket.
 795  */
 796
 797 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 798                            unsigned char stn, unsigned char net,
 799                            unsigned char cb, unsigned char port)
 800 {
 801         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 802         struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 803
 804         memset(sec, 0, sizeof(struct sockaddr_ec));
 805         sec->sec_family = AF_ECONET;
 806         sec->type = ECTYPE_PACKET_RECEIVED;
 807         sec->port = port;
 808         sec->cb = cb;
 809         sec->addr.net = net;
 810         sec->addr.station = stn;
 811
 812         return sock_queue_rcv_skb(sk, skb);
 813 }
 814 #endif
 815
 816 #ifdef CONFIG_ECONET_AUNUDP
 817 /*
 818  *      Send an AUN protocol response.
 819  */
 820
 821 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 822 {
 823         struct sockaddr_in sin = {
 824                 .sin_family = AF_INET,
 825                 .sin_port = htons(AUN_PORT),
 826                 .sin_addr = {.s_addr = addr}
 827         };
 828         struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 829         struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 830         struct msghdr udpmsg;
 831
 832         udpmsg.msg_name = (void *)&sin;
 833         udpmsg.msg_namelen = sizeof(sin);
 834         udpmsg.msg_control = NULL;
 835         udpmsg.msg_controllen = 0;
 836         udpmsg.msg_flags = 0;
 837
 838         kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 839 }
 840
 841
 842 /*
 843  *      Handle incoming AUN packets.  Work out if anybody wants them,
 844  *      and send positive or negative acknowledgements as appropriate.
 845  */
 846
 847 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 848 {
 849         struct iphdr *ip = ip_hdr(skb);
 850         unsigned char stn = ntohl(ip->saddr) & 0xff;
 851         struct dst_entry *dst = skb_dst(skb);
 852         struct ec_device *edev = NULL;
 853         struct sock *sk = NULL;
 854         struct sk_buff *newskb;
 855
 856         if (dst)
 857                 edev = dst->dev->ec_ptr;
 858
 859         if (!edev)
 860                 goto bad;
 861
 862         sk = ec_listening_socket(ah->port, stn, edev->net);
 863         if (sk == NULL)
 864                 goto bad;               /* Nobody wants it */
 865
 866         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 867                            GFP_ATOMIC);
 868         if (newskb == NULL) {
 869                 pr_debug("AUN: memory squeeze, dropping packet\n");
 870                 /* Send nack and hope sender tries again */
 871                 goto bad;
 872         }
 873
 874         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah + 1),
 875                len - sizeof(struct aunhdr));
 876
 877         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port)) {
 878                 /* Socket is bankrupt. */
 879                 kfree_skb(newskb);
 880                 goto bad;
 881         }
 882
 883         aun_send_response(ip->saddr, ah->handle, 3, 0);
 884         sock_put(sk);
 885         return;
 886
 887 bad:
 888         aun_send_response(ip->saddr, ah->handle, 4, 0);
 889         if (sk)
 890                 sock_put(sk);
 891 }
 892
 893 /*
 894  *      Handle incoming AUN transmit acknowledgements.  If the sequence
 895  *      number matches something in our backlog then kill it and tell
 896  *      the user.  If the remote took too long to reply then we may have
 897  *      dropped the packet already.
 898  */
 899
 900 static void aun_tx_ack(unsigned long seq, int result)
 901 {
 902         struct sk_buff *skb;
 903         unsigned long flags;
 904         struct ec_cb *eb;
 905
 906         spin_lock_irqsave(&aun_queue_lock, flags);
 907         skb_queue_walk(&aun_queue, skb) {
 908                 eb = (struct ec_cb *)&skb->cb;
 909                 if (eb->seq == seq)
 910                         goto foundit;
 911         }
 912         spin_unlock_irqrestore(&aun_queue_lock, flags);
 913         pr_debug("AUN: unknown sequence %ld\n", seq);
 914         return;
 915
 916 foundit:
 917         tx_result(skb->sk, eb->cookie, result);
 918         skb_unlink(skb, &aun_queue);
 919         spin_unlock_irqrestore(&aun_queue_lock, flags);
 920         kfree_skb(skb);
 921 }
 922
 923 /*
 924  *      Deal with received AUN frames - sort out what type of thing it is
 925  *      and hand it to the right function.
 926  */
 927
 928 static void aun_data_available(struct sock *sk, int slen)
 929 {
 930         int err;
 931         struct sk_buff *skb;
 932         unsigned char *data;
 933         struct aunhdr *ah;
 934         size_t len;
 935
 936         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 937                 if (err == -EAGAIN) {
 938                         pr_err("AUN: no data available?!\n");
 939                         return;
 940                 }
 941                 pr_debug("AUN: recvfrom() error %d\n", -err);
 942         }
 943
 944         data = skb_transport_header(skb) + sizeof(struct udphdr);
 945         ah = (struct aunhdr *)data;
 946         len = skb->len - sizeof(struct udphdr);
 947
 948         switch (ah->code) {
 949         case 2:
 950                 aun_incoming(skb, ah, len);
 951                 break;
 952         case 3:
 953                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 954                 break;
 955         case 4:
 956                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 957                 break;
 958         default:
 959                 pr_debug("AUN: unknown packet type: %d\n", data[0]);
 960         }
 961
 962         skb_free_datagram(sk, skb);
 963 }
 964
 965 /*
 966  *      Called by the timer to manage the AUN transmit queue.  If a packet
 967  *      was sent to a dead or nonexistent host then we will never get an
 968  *      acknowledgement back.  After a few seconds we need to spot this and
 969  *      drop the packet.
 970  */
 971
 972 static void ab_cleanup(unsigned long h)
 973 {
 974         struct sk_buff *skb, *n;
 975         unsigned long flags;
 976
 977         spin_lock_irqsave(&aun_queue_lock, flags);
 978         skb_queue_walk_safe(&aun_queue, skb, n) {
 979                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 980                 if ((jiffies - eb->start) > eb->timeout) {
 981                         tx_result(skb->sk, eb->cookie,
 982                                   ECTYPE_TRANSMIT_NOT_PRESENT);
 983                         skb_unlink(skb, &aun_queue);
 984                         kfree_skb(skb);
 985                 }
 986         }
 987         spin_unlock_irqrestore(&aun_queue_lock, flags);
 988
 989         mod_timer(&ab_cleanup_timer, jiffies + (HZ * 2));
 990 }
 991
 992 static int __init aun_udp_initialise(void)
 993 {
 994         int error;
 995         struct sockaddr_in sin;
 996
 997         skb_queue_head_init(&aun_queue);
 998         setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
 999         ab_cleanup_timer.expires = jiffies + (HZ * 2);
1000         add_timer(&ab_cleanup_timer);
1001
1002         memset(&sin, 0, sizeof(sin));
1003         sin.sin_port = htons(AUN_PORT);
1004
1005         /* We can count ourselves lucky Acorn machines are too dim to
1006            speak IPv6. :-) */
1007         error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock);
1008         if (error < 0) {
1009                 pr_err("AUN: socket error %d\n", -error);
1010                 return error;
1011         }
1012
1013         udpsock->sk->sk_reuse = 1;
1014         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1015                                                     from interrupts */
1016
1017         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1018                                    sizeof(sin));
1019         if (error < 0) {
1020                 pr_err("AUN: bind error %d\n", -error);
1021                 goto release;
1022         }
1023
1024         udpsock->sk->sk_data_ready = aun_data_available;
1025
1026         return 0;
1027
1028 release:
1029         sock_release(udpsock);
1030         udpsock = NULL;
1031         return error;
1032 }
1033 #endif
1034
1035 #ifdef CONFIG_ECONET_NATIVE
1036
1037 /*
1038  *      Receive an Econet frame from a device.
1039  */
1040
1041 static int econet_rcv(struct sk_buff *skb, struct net_device *dev,
1042                       struct packet_type *pt, struct net_device *orig_dev)
1043 {
1044         struct ec_framehdr *hdr;
1045         struct sock *sk = NULL;
1046         struct ec_device *edev = dev->ec_ptr;
1047
1048         if (!net_eq(dev_net(dev), &init_net))
1049                 goto drop;
1050
1051         if (skb->pkt_type == PACKET_OTHERHOST)
1052                 goto drop;
1053
1054         if (!edev)
1055                 goto drop;
1056
1057         skb = skb_share_check(skb, GFP_ATOMIC);
1058         if (skb == NULL)
1059                 return NET_RX_DROP;
1060
1061         if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1062                 goto drop;
1063
1064         hdr = (struct ec_framehdr *)skb->data;
1065
1066         /* First check for encapsulated IP */
1067         if (hdr->port == EC_PORT_IP) {
1068                 skb->protocol = htons(ETH_P_IP);
1069                 skb_pull(skb, sizeof(struct ec_framehdr));
1070                 netif_rx(skb);
1071                 return NET_RX_SUCCESS;
1072         }
1073
1074         sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1075         if (!sk)
1076                 goto drop;
1077
1078         if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1079                             hdr->port))
1080                 goto drop;
1081         sock_put(sk);
1082         return NET_RX_SUCCESS;
1083
1084 drop:
1085         if (sk)
1086                 sock_put(sk);
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,
1104                            void *data)
1105 {
1106         struct net_device *dev = data;
1107         struct ec_device *edev;
1108
1109         if (!net_eq(dev_net(dev), &init_net))
1110                 return NOTIFY_DONE;
1111
1112         switch (msg) {
1113         case NETDEV_UNREGISTER:
1114                 /* A device has gone down - kill any data we hold for it. */
1115                 edev = dev->ec_ptr;
1116                 if (edev) {
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         aun_udp_initialise();
1157 #endif
1158 #ifdef CONFIG_ECONET_NATIVE
1159         econet_hw_initialise();
1160 #endif
1161         register_netdevice_notifier(&econet_netdev_notifier);
1162 out:
1163         return err;
1164 }
1165
1166 module_init(econet_proto_init);
1167 module_exit(econet_proto_exit);
1168
1169 MODULE_LICENSE("GPL");
1170 MODULE_ALIAS_NETPROTO(PF_ECONET);