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