net/econet/af_econet.c

   1 /*
   2  *      An implementation of the Acorn Econet and AUN protocols.
   3  *      Philip Blundell <philb@gnu.org>
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation; either version
   8  *      2 of the License, or (at your option) any later version.
   9  *
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/sched.h>
  18 #include <linux/string.h>
  19 #include <linux/mm.h>
  20 #include <linux/socket.h>
  21 #include <linux/sockios.h>
  22 #include <linux/in.h>
  23 #include <linux/errno.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/if_ether.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/inetdevice.h>
  28 #include <linux/route.h>
  29 #include <linux/inet.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/if_arp.h>
  32 #include <linux/wireless.h>
  33 #include <linux/skbuff.h>
  34 #include <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
  45 #include <asm/uaccess.h>
  46 #include <asm/system.h>
  47
  48 static struct proto_ops econet_ops;
  49 static struct hlist_head econet_sklist;
  50 static DEFINE_RWLOCK(econet_lock);
  51
  52 /* Since there are only 256 possible network numbers (or fewer, depends
  53    how you count) it makes sense to use a simple lookup table. */
  54 static struct net_device *net2dev_map[256];
  55
  56 #define EC_PORT_IP      0xd2
  57
  58 #ifdef CONFIG_ECONET_AUNUDP
  59 static spinlock_t aun_queue_lock;
  60 static struct socket *udpsock;
  61 #define AUN_PORT        0x8000
  62
  63
  64 struct aunhdr
  65 {
  66         unsigned char code;             /* AUN magic protocol byte */
  67         unsigned char port;
  68         unsigned char cb;
  69         unsigned char pad;
  70         unsigned long handle;
  71 };
  72
  73 static unsigned long aun_seq;
  74
  75 /* Queue of packets waiting to be transmitted. */
  76 static struct sk_buff_head aun_queue;
  77 static struct timer_list ab_cleanup_timer;
  78
  79 #endif          /* CONFIG_ECONET_AUNUDP */
  80
  81 /* Per-packet information */
  82 struct ec_cb
  83 {
  84         struct sockaddr_ec sec;
  85         unsigned long cookie;           /* Supplied by user. */
  86 #ifdef CONFIG_ECONET_AUNUDP
  87         int done;
  88         unsigned long seq;              /* Sequencing */
  89         unsigned long timeout;          /* Timeout */
  90         unsigned long start;            /* jiffies */
  91 #endif
  92 #ifdef CONFIG_ECONET_NATIVE
  93         void (*sent)(struct sk_buff *, int result);
  94 #endif
  95 };
  96
  97 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
  98 {
  99         write_lock_bh(&econet_lock);
 100         sk_del_node_init(sk);
 101         write_unlock_bh(&econet_lock);
 102 }
 103
 104 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
 105 {
 106         write_lock_bh(&econet_lock);
 107         sk_add_node(sk, list);
 108         write_unlock_bh(&econet_lock);
 109 }
 110
 111 /*
 112  *      Pull a packet from our receive queue and hand it to the user.
 113  *      If necessary we block.
 114  */
 115
 116 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
 117                           struct msghdr *msg, size_t len, int flags)
 118 {
 119         struct sock *sk = sock->sk;
 120         struct sk_buff *skb;
 121         size_t copied;
 122         int err;
 123
 124         msg->msg_namelen = sizeof(struct sockaddr_ec);
 125
 126         /*
 127          *      Call the generic datagram receiver. This handles all sorts
 128          *      of horrible races and re-entrancy so we can forget about it
 129          *      in the protocol layers.
 130          *
 131          *      Now it will return ENETDOWN, if device have just gone down,
 132          *      but then it will block.
 133          */
 134
 135         skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
 136
 137         /*
 138          *      An error occurred so return it. Because skb_recv_datagram()
 139          *      handles the blocking we don't see and worry about blocking
 140          *      retries.
 141          */
 142
 143         if(skb==NULL)
 144                 goto out;
 145
 146         /*
 147          *      You lose any data beyond the buffer you gave. If it worries a
 148          *      user program they can ask the device for its MTU anyway.
 149          */
 150
 151         copied = skb->len;
 152         if (copied > len)
 153         {
 154                 copied=len;
 155                 msg->msg_flags|=MSG_TRUNC;
 156         }
 157
 158         /* We can't use skb_copy_datagram here */
 159         err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
 160         if (err)
 161                 goto out_free;
 162         sk->sk_stamp = skb->stamp;
 163
 164         if (msg->msg_name)
 165                 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
 166
 167         /*
 168          *      Free or return the buffer as appropriate. Again this
 169          *      hides all the races and re-entrancy issues from us.
 170          */
 171         err = copied;
 172
 173 out_free:
 174         skb_free_datagram(sk, skb);
 175 out:
 176         return err;
 177 }
 178
 179 /*
 180  *      Bind an Econet socket.
 181  */
 182
 183 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 184 {
 185         struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 186         struct sock *sk=sock->sk;
 187         struct econet_opt *eo = ec_sk(sk);
 188
 189         /*
 190          *      Check legality
 191          */
 192
 193         if (addr_len < sizeof(struct sockaddr_ec) ||
 194             sec->sec_family != AF_ECONET)
 195                 return -EINVAL;
 196
 197         eo->cb      = sec->cb;
 198         eo->port    = sec->port;
 199         eo->station = sec->addr.station;
 200         eo->net     = sec->addr.net;
 201
 202         return 0;
 203 }
 204
 205 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 206 /*
 207  *      Queue a transmit result for the user to be told about.
 208  */
 209
 210 static void tx_result(struct sock *sk, unsigned long cookie, int result)
 211 {
 212         struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
 213         struct ec_cb *eb;
 214         struct sockaddr_ec *sec;
 215
 216         if (skb == NULL)
 217         {
 218                 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
 219                 return;
 220         }
 221
 222         eb = (struct ec_cb *)&skb->cb;
 223         sec = (struct sockaddr_ec *)&eb->sec;
 224         memset(sec, 0, sizeof(struct sockaddr_ec));
 225         sec->cookie = cookie;
 226         sec->type = ECTYPE_TRANSMIT_STATUS | result;
 227         sec->sec_family = AF_ECONET;
 228
 229         if (sock_queue_rcv_skb(sk, skb) < 0)
 230                 kfree_skb(skb);
 231 }
 232 #endif
 233
 234 #ifdef CONFIG_ECONET_NATIVE
 235 /*
 236  *      Called by the Econet hardware driver when a packet transmit
 237  *      has completed.  Tell the user.
 238  */
 239
 240 static void ec_tx_done(struct sk_buff *skb, int result)
 241 {
 242         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 243         tx_result(skb->sk, eb->cookie, result);
 244 }
 245 #endif
 246
 247 /*
 248  *      Send a packet.  We have to work out which device it's going out on
 249  *      and hence whether to use real Econet or the UDP emulation.
 250  */
 251
 252 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
 253                           struct msghdr *msg, size_t len)
 254 {
 255         struct sock *sk = sock->sk;
 256         struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
 257         struct net_device *dev;
 258         struct ec_addr addr;
 259         int err;
 260         unsigned char port, cb;
 261 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 262         struct sk_buff *skb;
 263         struct ec_cb *eb;
 264 #endif
 265 #ifdef CONFIG_ECONET_AUNUDP
 266         struct msghdr udpmsg;
 267         struct iovec iov[msg->msg_iovlen+1];
 268         struct aunhdr ah;
 269         struct sockaddr_in udpdest;
 270         __kernel_size_t size;
 271         int i;
 272         mm_segment_t oldfs;
 273 #endif
 274
 275         /*
 276          *      Check the flags.
 277          */
 278
 279         if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 280                 return -EINVAL;
 281
 282         /*
 283          *      Get and verify the address.
 284          */
 285
 286         if (saddr == NULL) {
 287                 struct econet_opt *eo = ec_sk(sk);
 288
 289                 addr.station = eo->station;
 290                 addr.net     = eo->net;
 291                 port         = eo->port;
 292                 cb           = eo->cb;
 293         } else {
 294                 if (msg->msg_namelen < sizeof(struct sockaddr_ec))
 295                         return -EINVAL;
 296                 addr.station = saddr->addr.station;
 297                 addr.net = saddr->addr.net;
 298                 port = saddr->port;
 299                 cb = saddr->cb;
 300         }
 301
 302         /* Look for a device with the right network number. */
 303         dev = net2dev_map[addr.net];
 304
 305         /* If not directly reachable, use some default */
 306         if (dev == NULL)
 307         {
 308                 dev = net2dev_map[0];
 309                 /* No interfaces at all? */
 310                 if (dev == NULL)
 311                         return -ENETDOWN;
 312         }
 313
 314         if (len + 15 > dev->mtu)
 315                 return -EMSGSIZE;
 316
 317         if (dev->type == ARPHRD_ECONET)
 318         {
 319                 /* Real hardware Econet.  We're not worthy etc. */
 320 #ifdef CONFIG_ECONET_NATIVE
 321                 unsigned short proto = 0;
 322
 323                 dev_hold(dev);
 324
 325                 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
 326                                           msg->msg_flags & MSG_DONTWAIT, &err);
 327                 if (skb==NULL)
 328                         goto out_unlock;
 329
 330                 skb_reserve(skb, LL_RESERVED_SPACE(dev));
 331                 skb->nh.raw = skb->data;
 332
 333                 eb = (struct ec_cb *)&skb->cb;
 334
 335                 /* BUG: saddr may be NULL */
 336                 eb->cookie = saddr->cookie;
 337                 eb->sec = *saddr;
 338                 eb->sent = ec_tx_done;
 339
 340                 if (dev->hard_header) {
 341                         int res;
 342                         struct ec_framehdr *fh;
 343                         err = -EINVAL;
 344                         res = dev->hard_header(skb, dev, ntohs(proto),
 345                                                &addr, NULL, len);
 346                         /* Poke in our control byte and
 347                            port number.  Hack, hack.  */
 348                         fh = (struct ec_framehdr *)(skb->data);
 349                         fh->cb = cb;
 350                         fh->port = port;
 351                         if (sock->type != SOCK_DGRAM) {
 352                                 skb->tail = skb->data;
 353                                 skb->len = 0;
 354                         } else if (res < 0)
 355                                 goto out_free;
 356                 }
 357
 358                 /* Copy the data. Returns -EFAULT on error */
 359                 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
 360                 skb->protocol = proto;
 361                 skb->dev = dev;
 362                 skb->priority = sk->sk_priority;
 363                 if (err)
 364                         goto out_free;
 365
 366                 err = -ENETDOWN;
 367                 if (!(dev->flags & IFF_UP))
 368                         goto out_free;
 369
 370                 /*
 371                  *      Now send it
 372                  */
 373
 374                 dev_queue_xmit(skb);
 375                 dev_put(dev);
 376                 return(len);
 377
 378         out_free:
 379                 kfree_skb(skb);
 380         out_unlock:
 381                 if (dev)
 382                         dev_put(dev);
 383 #else
 384                 err = -EPROTOTYPE;
 385 #endif
 386                 return err;
 387         }
 388
 389 #ifdef CONFIG_ECONET_AUNUDP
 390         /* AUN virtual Econet. */
 391
 392         if (udpsock == NULL)
 393                 return -ENETDOWN;               /* No socket - can't send */
 394
 395         /* Make up a UDP datagram and hand it off to some higher intellect. */
 396
 397         memset(&udpdest, 0, sizeof(udpdest));
 398         udpdest.sin_family = AF_INET;
 399         udpdest.sin_port = htons(AUN_PORT);
 400
 401         /* At the moment we use the stupid Acorn scheme of Econet address
 402            y.x maps to IP a.b.c.x.  This should be replaced with something
 403            more flexible and more aware of subnet masks.  */
 404         {
 405                 struct in_device *idev;
 406                 unsigned long network = 0;
 407
 408                 rcu_read_lock();
 409                 idev = __in_dev_get(dev);
 410                 if (idev) {
 411                         if (idev->ifa_list)
 412                                 network = ntohl(idev->ifa_list->ifa_address) &
 413                                         0xffffff00;             /* !!! */
 414                 }
 415                 rcu_read_unlock();
 416                 udpdest.sin_addr.s_addr = htonl(network | addr.station);
 417         }
 418
 419         ah.port = port;
 420         ah.cb = cb & 0x7f;
 421         ah.code = 2;            /* magic */
 422         ah.pad = 0;
 423
 424         /* tack our header on the front of the iovec */
 425         size = sizeof(struct aunhdr);
 426         /*
 427          * XXX: that is b0rken.  We can't mix userland and kernel pointers
 428          * in iovec, since on a lot of platforms copy_from_user() will
 429          * *not* work with the kernel and userland ones at the same time,
 430          * regardless of what we do with set_fs().  And we are talking about
 431          * econet-over-ethernet here, so "it's only ARM anyway" doesn't
 432          * apply.  Any suggestions on fixing that code?         -- AV
 433          */
 434         iov[0].iov_base = (void *)&ah;
 435         iov[0].iov_len = size;
 436         for (i = 0; i < msg->msg_iovlen; i++) {
 437                 void __user *base = msg->msg_iov[i].iov_base;
 438                 size_t len = msg->msg_iov[i].iov_len;
 439                 /* Check it now since we switch to KERNEL_DS later. */
 440                 if ((err = verify_area(VERIFY_READ, base, len)) < 0)
 441                         return err;
 442                 iov[i+1].iov_base = base;
 443                 iov[i+1].iov_len = len;
 444                 size += len;
 445         }
 446
 447         /* Get a skbuff (no data, just holds our cb information) */
 448         if ((skb = sock_alloc_send_skb(sk, 0,
 449                              msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
 450                 return err;
 451
 452         eb = (struct ec_cb *)&skb->cb;
 453
 454         eb->cookie = saddr->cookie;
 455         eb->timeout = (5*HZ);
 456         eb->start = jiffies;
 457         ah.handle = aun_seq;
 458         eb->seq = (aun_seq++);
 459         eb->sec = *saddr;
 460
 461         skb_queue_tail(&aun_queue, skb);
 462
 463         udpmsg.msg_name = (void *)&udpdest;
 464         udpmsg.msg_namelen = sizeof(udpdest);
 465         udpmsg.msg_iov = &iov[0];
 466         udpmsg.msg_iovlen = msg->msg_iovlen + 1;
 467         udpmsg.msg_control = NULL;
 468         udpmsg.msg_controllen = 0;
 469         udpmsg.msg_flags=0;
 470
 471         oldfs = get_fs(); set_fs(KERNEL_DS);    /* More privs :-) */
 472         err = sock_sendmsg(udpsock, &udpmsg, size);
 473         set_fs(oldfs);
 474 #else
 475         err = -EPROTOTYPE;
 476 #endif
 477         return err;
 478 }
 479
 480 /*
 481  *      Look up the address of a socket.
 482  */
 483
 484 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
 485                           int *uaddr_len, int peer)
 486 {
 487         struct sock *sk = sock->sk;
 488         struct econet_opt *eo = ec_sk(sk);
 489         struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
 490
 491         if (peer)
 492                 return -EOPNOTSUPP;
 493
 494         sec->sec_family   = AF_ECONET;
 495         sec->port         = eo->port;
 496         sec->addr.station = eo->station;
 497         sec->addr.net     = eo->net;
 498
 499         *uaddr_len = sizeof(*sec);
 500         return 0;
 501 }
 502
 503 static void econet_destroy_timer(unsigned long data)
 504 {
 505         struct sock *sk=(struct sock *)data;
 506
 507         if (!atomic_read(&sk->sk_wmem_alloc) &&
 508             !atomic_read(&sk->sk_rmem_alloc)) {
 509                 sk_free(sk);
 510                 return;
 511         }
 512
 513         sk->sk_timer.expires = jiffies + 10 * HZ;
 514         add_timer(&sk->sk_timer);
 515         printk(KERN_DEBUG "econet socket destroy delayed\n");
 516 }
 517
 518 /*
 519  *      Close an econet socket.
 520  */
 521
 522 static int econet_release(struct socket *sock)
 523 {
 524         struct sock *sk = sock->sk;
 525
 526         if (!sk)
 527                 return 0;
 528
 529         econet_remove_socket(&econet_sklist, sk);
 530
 531         /*
 532          *      Now the socket is dead. No more input will appear.
 533          */
 534
 535         sk->sk_state_change(sk);        /* It is useless. Just for sanity. */
 536
 537         sock->sk = NULL;
 538         sk->sk_socket = NULL;
 539         sock_set_flag(sk, SOCK_DEAD);
 540
 541         /* Purge queues */
 542
 543         skb_queue_purge(&sk->sk_receive_queue);
 544
 545         if (atomic_read(&sk->sk_rmem_alloc) ||
 546             atomic_read(&sk->sk_wmem_alloc)) {
 547                 sk->sk_timer.data     = (unsigned long)sk;
 548                 sk->sk_timer.expires  = jiffies + HZ;
 549                 sk->sk_timer.function = econet_destroy_timer;
 550                 add_timer(&sk->sk_timer);
 551                 return 0;
 552         }
 553
 554         sk_free(sk);
 555         return 0;
 556 }
 557
 558 /*
 559  *      Create an Econet socket
 560  */
 561
 562 static int econet_create(struct socket *sock, int protocol)
 563 {
 564         struct sock *sk;
 565         struct econet_opt *eo;
 566         int err;
 567
 568         /* Econet only provides datagram services. */
 569         if (sock->type != SOCK_DGRAM)
 570                 return -ESOCKTNOSUPPORT;
 571
 572         sock->state = SS_UNCONNECTED;
 573
 574         err = -ENOBUFS;
 575         sk = sk_alloc(PF_ECONET, GFP_KERNEL, 1, NULL);
 576         if (sk == NULL)
 577                 goto out;
 578
 579         sk->sk_reuse = 1;
 580         sock->ops = &econet_ops;
 581         sock_init_data(sock,sk);
 582         sk_set_owner(sk, THIS_MODULE);
 583
 584         eo = sk->sk_protinfo = kmalloc(sizeof(*eo), GFP_KERNEL);
 585         if (!eo)
 586                 goto out_free;
 587         memset(eo, 0, sizeof(*eo));
 588         sk->sk_zapped = 0;
 589         sk->sk_family = PF_ECONET;
 590         eo->num = protocol;
 591
 592         econet_insert_socket(&econet_sklist, sk);
 593         return(0);
 594
 595 out_free:
 596         sk_free(sk);
 597 out:
 598         return err;
 599 }
 600
 601 /*
 602  *      Handle Econet specific ioctls
 603  */
 604
 605 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
 606 {
 607         struct ifreq ifr;
 608         struct ec_device *edev;
 609         struct net_device *dev;
 610         struct sockaddr_ec *sec;
 611
 612         /*
 613          *      Fetch the caller's info block into kernel space
 614          */
 615
 616         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
 617                 return -EFAULT;
 618
 619         if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
 620                 return -ENODEV;
 621
 622         sec = (struct sockaddr_ec *)&ifr.ifr_addr;
 623
 624         switch (cmd)
 625         {
 626         case SIOCSIFADDR:
 627                 edev = dev->ec_ptr;
 628                 if (edev == NULL)
 629                 {
 630                         /* Magic up a new one. */
 631                         edev = kmalloc(sizeof(struct ec_device), GFP_KERNEL);
 632                         if (edev == NULL) {
 633                                 printk("af_ec: memory squeeze.\n");
 634                                 dev_put(dev);
 635                                 return -ENOMEM;
 636                         }
 637                         memset(edev, 0, sizeof(struct ec_device));
 638                         dev->ec_ptr = edev;
 639                 }
 640                 else
 641                         net2dev_map[edev->net] = NULL;
 642                 edev->station = sec->addr.station;
 643                 edev->net = sec->addr.net;
 644                 net2dev_map[sec->addr.net] = dev;
 645                 if (!net2dev_map[0])
 646                         net2dev_map[0] = dev;
 647                 dev_put(dev);
 648                 return 0;
 649
 650         case SIOCGIFADDR:
 651                 edev = dev->ec_ptr;
 652                 if (edev == NULL)
 653                 {
 654                         dev_put(dev);
 655                         return -ENODEV;
 656                 }
 657                 memset(sec, 0, sizeof(struct sockaddr_ec));
 658                 sec->addr.station = edev->station;
 659                 sec->addr.net = edev->net;
 660                 sec->sec_family = AF_ECONET;
 661                 dev_put(dev);
 662                 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
 663                         return -EFAULT;
 664                 return 0;
 665         }
 666
 667         dev_put(dev);
 668         return -EINVAL;
 669 }
 670
 671 /*
 672  *      Handle generic ioctls
 673  */
 674
 675 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 676 {
 677         struct sock *sk = sock->sk;
 678         void __user *argp = (void __user *)arg;
 679
 680         switch(cmd) {
 681                 case SIOCGSTAMP:
 682                         return sock_get_timestamp(sk, argp);
 683
 684                 case SIOCSIFADDR:
 685                 case SIOCGIFADDR:
 686                         return ec_dev_ioctl(sock, cmd, argp);
 687                         break;
 688
 689                 default:
 690                         return dev_ioctl(cmd, argp);
 691         }
 692         /*NOTREACHED*/
 693         return 0;
 694 }
 695
 696 static struct net_proto_family econet_family_ops = {
 697         .family =       PF_ECONET,
 698         .create =       econet_create,
 699         .owner  =       THIS_MODULE,
 700 };
 701
 702 static struct proto_ops SOCKOPS_WRAPPED(econet_ops) = {
 703         .family =       PF_ECONET,
 704         .owner =        THIS_MODULE,
 705         .release =      econet_release,
 706         .bind =         econet_bind,
 707         .connect =      sock_no_connect,
 708         .socketpair =   sock_no_socketpair,
 709         .accept =       sock_no_accept,
 710         .getname =      econet_getname,
 711         .poll =         datagram_poll,
 712         .ioctl =        econet_ioctl,
 713         .listen =       sock_no_listen,
 714         .shutdown =     sock_no_shutdown,
 715         .setsockopt =   sock_no_setsockopt,
 716         .getsockopt =   sock_no_getsockopt,
 717         .sendmsg =      econet_sendmsg,
 718         .recvmsg =      econet_recvmsg,
 719         .mmap =         sock_no_mmap,
 720         .sendpage =     sock_no_sendpage,
 721 };
 722
 723 #include <linux/smp_lock.h>
 724 SOCKOPS_WRAP(econet, PF_ECONET);
 725
 726 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
 727 /*
 728  *      Find the listening socket, if any, for the given data.
 729  */
 730
 731 static struct sock *ec_listening_socket(unsigned char port, unsigned char
 732                                  station, unsigned char net)
 733 {
 734         struct sock *sk;
 735         struct hlist_node *node;
 736
 737         sk_for_each(sk, node, &econet_sklist) {
 738                 struct econet_opt *opt = ec_sk(sk);
 739                 if ((opt->port == port || opt->port == 0) &&
 740                     (opt->station == station || opt->station == 0) &&
 741                     (opt->net == net || opt->net == 0))
 742                         goto found;
 743         }
 744         sk = NULL;
 745 found:
 746         return sk;
 747 }
 748
 749 /*
 750  *      Queue a received packet for a socket.
 751  */
 752
 753 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
 754                            unsigned char stn, unsigned char net,
 755                            unsigned char cb, unsigned char port)
 756 {
 757         struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 758         struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
 759
 760         memset(sec, 0, sizeof(struct sockaddr_ec));
 761         sec->sec_family = AF_ECONET;
 762         sec->type = ECTYPE_PACKET_RECEIVED;
 763         sec->port = port;
 764         sec->cb = cb;
 765         sec->addr.net = net;
 766         sec->addr.station = stn;
 767
 768         return sock_queue_rcv_skb(sk, skb);
 769 }
 770 #endif
 771
 772 #ifdef CONFIG_ECONET_AUNUDP
 773 /*
 774  *      Send an AUN protocol response.
 775  */
 776
 777 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
 778 {
 779         struct sockaddr_in sin = {
 780                 .sin_family = AF_INET,
 781                 .sin_port = htons(AUN_PORT),
 782                 .sin_addr = {.s_addr = addr}
 783         };
 784         struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
 785         struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
 786         struct msghdr udpmsg;
 787
 788         udpmsg.msg_name = (void *)&sin;
 789         udpmsg.msg_namelen = sizeof(sin);
 790         udpmsg.msg_control = NULL;
 791         udpmsg.msg_controllen = 0;
 792         udpmsg.msg_flags=0;
 793
 794         kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
 795 }
 796
 797
 798 /*
 799  *      Handle incoming AUN packets.  Work out if anybody wants them,
 800  *      and send positive or negative acknowledgements as appropriate.
 801  */
 802
 803 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
 804 {
 805         struct iphdr *ip = skb->nh.iph;
 806         unsigned char stn = ntohl(ip->saddr) & 0xff;
 807         struct sock *sk;
 808         struct sk_buff *newskb;
 809         struct ec_device *edev = skb->dev->ec_ptr;
 810
 811         if (! edev)
 812                 goto bad;
 813
 814         if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
 815                 goto bad;               /* Nobody wants it */
 816
 817         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
 818                            GFP_ATOMIC);
 819         if (newskb == NULL)
 820         {
 821                 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
 822                 /* Send nack and hope sender tries again */
 823                 goto bad;
 824         }
 825
 826         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
 827                len - sizeof(struct aunhdr));
 828
 829         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
 830         {
 831                 /* Socket is bankrupt. */
 832                 kfree_skb(newskb);
 833                 goto bad;
 834         }
 835
 836         aun_send_response(ip->saddr, ah->handle, 3, 0);
 837         return;
 838
 839 bad:
 840         aun_send_response(ip->saddr, ah->handle, 4, 0);
 841 }
 842
 843 /*
 844  *      Handle incoming AUN transmit acknowledgements.  If the sequence
 845  *      number matches something in our backlog then kill it and tell
 846  *      the user.  If the remote took too long to reply then we may have
 847  *      dropped the packet already.
 848  */
 849
 850 static void aun_tx_ack(unsigned long seq, int result)
 851 {
 852         struct sk_buff *skb;
 853         unsigned long flags;
 854         struct ec_cb *eb;
 855
 856         spin_lock_irqsave(&aun_queue_lock, flags);
 857         skb = skb_peek(&aun_queue);
 858         while (skb && skb != (struct sk_buff *)&aun_queue)
 859         {
 860                 struct sk_buff *newskb = skb->next;
 861                 eb = (struct ec_cb *)&skb->cb;
 862                 if (eb->seq == seq)
 863                         goto foundit;
 864
 865                 skb = newskb;
 866         }
 867         spin_unlock_irqrestore(&aun_queue_lock, flags);
 868         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
 869         return;
 870
 871 foundit:
 872         tx_result(skb->sk, eb->cookie, result);
 873         skb_unlink(skb);
 874         spin_unlock_irqrestore(&aun_queue_lock, flags);
 875         kfree_skb(skb);
 876 }
 877
 878 /*
 879  *      Deal with received AUN frames - sort out what type of thing it is
 880  *      and hand it to the right function.
 881  */
 882
 883 static void aun_data_available(struct sock *sk, int slen)
 884 {
 885         int err;
 886         struct sk_buff *skb;
 887         unsigned char *data;
 888         struct aunhdr *ah;
 889         struct iphdr *ip;
 890         size_t len;
 891
 892         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
 893                 if (err == -EAGAIN) {
 894                         printk(KERN_ERR "AUN: no data available?!");
 895                         return;
 896                 }
 897                 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
 898         }
 899
 900         data = skb->h.raw + sizeof(struct udphdr);
 901         ah = (struct aunhdr *)data;
 902         len = skb->len - sizeof(struct udphdr);
 903         ip = skb->nh.iph;
 904
 905         switch (ah->code)
 906         {
 907         case 2:
 908                 aun_incoming(skb, ah, len);
 909                 break;
 910         case 3:
 911                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
 912                 break;
 913         case 4:
 914                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
 915                 break;
 916 #if 0
 917                 /* This isn't quite right yet. */
 918         case 5:
 919                 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
 920                 break;
 921 #endif
 922         default:
 923                 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
 924         }
 925
 926         skb_free_datagram(sk, skb);
 927 }
 928
 929 /*
 930  *      Called by the timer to manage the AUN transmit queue.  If a packet
 931  *      was sent to a dead or nonexistent host then we will never get an
 932  *      acknowledgement back.  After a few seconds we need to spot this and
 933  *      drop the packet.
 934  */
 935
 936 static void ab_cleanup(unsigned long h)
 937 {
 938         struct sk_buff *skb;
 939         unsigned long flags;
 940
 941         spin_lock_irqsave(&aun_queue_lock, flags);
 942         skb = skb_peek(&aun_queue);
 943         while (skb && skb != (struct sk_buff *)&aun_queue)
 944         {
 945                 struct sk_buff *newskb = skb->next;
 946                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
 947                 if ((jiffies - eb->start) > eb->timeout)
 948                 {
 949                         tx_result(skb->sk, eb->cookie,
 950                                   ECTYPE_TRANSMIT_NOT_PRESENT);
 951                         skb_unlink(skb);
 952                         kfree_skb(skb);
 953                 }
 954                 skb = newskb;
 955         }
 956         spin_unlock_irqrestore(&aun_queue_lock, flags);
 957
 958         mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
 959 }
 960
 961 static int __init aun_udp_initialise(void)
 962 {
 963         int error;
 964         struct sockaddr_in sin;
 965
 966         skb_queue_head_init(&aun_queue);
 967         spin_lock_init(&aun_queue_lock);
 968         init_timer(&ab_cleanup_timer);
 969         ab_cleanup_timer.expires = jiffies + (HZ*2);
 970         ab_cleanup_timer.function = ab_cleanup;
 971         add_timer(&ab_cleanup_timer);
 972
 973         memset(&sin, 0, sizeof(sin));
 974         sin.sin_port = htons(AUN_PORT);
 975
 976         /* We can count ourselves lucky Acorn machines are too dim to
 977            speak IPv6. :-) */
 978         if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
 979         {
 980                 printk("AUN: socket error %d\n", -error);
 981                 return error;
 982         }
 983
 984         udpsock->sk->sk_reuse = 1;
 985         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
 986                                                     from interrupts */
 987
 988         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
 989                                 sizeof(sin));
 990         if (error < 0)
 991         {
 992                 printk("AUN: bind error %d\n", -error);
 993                 goto release;
 994         }
 995
 996         udpsock->sk->sk_data_ready = aun_data_available;
 997
 998         return 0;
 999
1000 release:
1001         sock_release(udpsock);
1002         udpsock = NULL;
1003         return error;
1004 }
1005 #endif
1006
1007 #ifdef CONFIG_ECONET_NATIVE
1008
1009 /*
1010  *      Receive an Econet frame from a device.
1011  */
1012
1013 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt)
1014 {
1015         struct ec_framehdr *hdr;
1016         struct sock *sk;
1017         struct ec_device *edev = dev->ec_ptr;
1018
1019         if (skb->pkt_type == PACKET_OTHERHOST)
1020                 goto drop;
1021
1022         if (!edev)
1023                 goto drop;
1024
1025         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1026                 return NET_RX_DROP;
1027
1028         if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1029                 goto drop;
1030
1031         hdr = (struct ec_framehdr *) skb->data;
1032
1033         /* First check for encapsulated IP */
1034         if (hdr->port == EC_PORT_IP) {
1035                 skb->protocol = htons(ETH_P_IP);
1036                 skb_pull(skb, sizeof(struct ec_framehdr));
1037                 netif_rx(skb);
1038                 return 0;
1039         }
1040
1041         sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1042         if (!sk)
1043                 goto drop;
1044
1045         if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1046                             hdr->port))
1047                 goto drop;
1048
1049         return 0;
1050
1051 drop:
1052         kfree_skb(skb);
1053         return NET_RX_DROP;
1054 }
1055
1056 static struct packet_type econet_packet_type = {
1057         .type =         __constant_htons(ETH_P_ECONET),
1058         .func =         econet_rcv,
1059 };
1060
1061 static void econet_hw_initialise(void)
1062 {
1063         dev_add_pack(&econet_packet_type);
1064 }
1065
1066 #endif
1067
1068 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1069 {
1070         struct net_device *dev = (struct net_device *)data;
1071         struct ec_device *edev;
1072
1073         switch (msg) {
1074         case NETDEV_UNREGISTER:
1075                 /* A device has gone down - kill any data we hold for it. */
1076                 edev = dev->ec_ptr;
1077                 if (edev)
1078                 {
1079                         if (net2dev_map[0] == dev)
1080                                 net2dev_map[0] = NULL;
1081                         net2dev_map[edev->net] = NULL;
1082                         kfree(edev);
1083                         dev->ec_ptr = NULL;
1084                 }
1085                 break;
1086         }
1087
1088         return NOTIFY_DONE;
1089 }
1090
1091 static struct notifier_block econet_netdev_notifier = {
1092         .notifier_call =econet_notifier,
1093 };
1094
1095 static void __exit econet_proto_exit(void)
1096 {
1097 #ifdef CONFIG_ECONET_AUNUDP
1098         del_timer(&ab_cleanup_timer);
1099         if (udpsock)
1100                 sock_release(udpsock);
1101 #endif
1102         unregister_netdevice_notifier(&econet_netdev_notifier);
1103         sock_unregister(econet_family_ops.family);
1104 }
1105
1106 static int __init econet_proto_init(void)
1107 {
1108         sock_register(&econet_family_ops);
1109 #ifdef CONFIG_ECONET_AUNUDP
1110         spin_lock_init(&aun_queue_lock);
1111         aun_udp_initialise();
1112 #endif
1113 #ifdef CONFIG_ECONET_NATIVE
1114         econet_hw_initialise();
1115 #endif
1116         register_netdevice_notifier(&econet_netdev_notifier);
1117         return 0;
1118 }
1119
1120 module_init(econet_proto_init);
1121 module_exit(econet_proto_exit);
1122
1123 MODULE_LICENSE("GPL");
1124 MODULE_ALIAS_NETPROTO(PF_ECONET);