net/econet/af_econet.c

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