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