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