Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / net / econet / af_econet.c
blob1c1f26c5d672034973187409c94688e59bf03e55
1 /*
2 * An implementation of the Acorn Econet and AUN protocols.
3 * Philip Blundell <philb@gnu.org>
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.
12 #define pr_fmt(fmt) fmt
14 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
19 #include <linux/mm.h>
20 #include <linux/socket.h>
21 #include <linux/sockios.h>
22 #include <linux/in.h>
23 #include <linux/errno.h>
24 #include <linux/interrupt.h>
25 #include <linux/if_ether.h>
26 #include <linux/netdevice.h>
27 #include <linux/inetdevice.h>
28 #include <linux/route.h>
29 #include <linux/inet.h>
30 #include <linux/etherdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/wireless.h>
33 #include <linux/skbuff.h>
34 #include <linux/udp.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
37 #include <net/sock.h>
38 #include <net/inet_common.h>
39 #include <linux/stat.h>
40 #include <linux/init.h>
41 #include <linux/if_ec.h>
42 #include <net/udp.h>
43 #include <net/ip.h>
44 #include <linux/spinlock.h>
45 #include <linux/rcupdate.h>
46 #include <linux/bitops.h>
47 #include <linux/mutex.h>
49 #include <linux/uaccess.h>
50 #include <asm/system.h>
52 static const struct proto_ops econet_ops;
53 static struct hlist_head econet_sklist;
54 static DEFINE_SPINLOCK(econet_lock);
55 static DEFINE_MUTEX(econet_mutex);
57 /* Since there are only 256 possible network numbers (or fewer, depends
58 how you count) it makes sense to use a simple lookup table. */
59 static struct net_device *net2dev_map[256];
61 #define EC_PORT_IP 0xd2
63 #ifdef CONFIG_ECONET_AUNUDP
64 static DEFINE_SPINLOCK(aun_queue_lock);
65 static struct socket *udpsock;
66 #define AUN_PORT 0x8000
68 struct aunhdr {
69 unsigned char code; /* AUN magic protocol byte */
70 unsigned char port;
71 unsigned char cb;
72 unsigned char pad;
73 unsigned long handle;
76 static unsigned long aun_seq;
78 /* Queue of packets waiting to be transmitted. */
79 static struct sk_buff_head aun_queue;
80 static struct timer_list ab_cleanup_timer;
82 #endif /* CONFIG_ECONET_AUNUDP */
84 /* Per-packet information */
85 struct ec_cb {
86 struct sockaddr_ec sec;
87 unsigned long cookie; /* Supplied by user. */
88 #ifdef CONFIG_ECONET_AUNUDP
89 int done;
90 unsigned long seq; /* Sequencing */
91 unsigned long timeout; /* Timeout */
92 unsigned long start; /* jiffies */
93 #endif
94 #ifdef CONFIG_ECONET_NATIVE
95 void (*sent)(struct sk_buff *, int result);
96 #endif
99 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
101 spin_lock_bh(&econet_lock);
102 sk_del_node_init(sk);
103 spin_unlock_bh(&econet_lock);
106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
108 spin_lock_bh(&econet_lock);
109 sk_add_node(sk, list);
110 spin_unlock_bh(&econet_lock);
114 * Pull a packet from our receive queue and hand it to the user.
115 * If necessary we block.
118 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
119 struct msghdr *msg, size_t len, int flags)
121 struct sock *sk = sock->sk;
122 struct sk_buff *skb;
123 size_t copied;
124 int err;
126 msg->msg_namelen = sizeof(struct sockaddr_ec);
128 mutex_lock(&econet_mutex);
131 * Call the generic datagram receiver. This handles all sorts
132 * of horrible races and re-entrancy so we can forget about it
133 * in the protocol layers.
135 * Now it will return ENETDOWN, if device have just gone down,
136 * but then it will block.
139 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
142 * An error occurred so return it. Because skb_recv_datagram()
143 * handles the blocking we don't see and worry about blocking
144 * retries.
147 if (skb == NULL)
148 goto out;
151 * You lose any data beyond the buffer you gave. If it worries a
152 * user program they can ask the device for its MTU anyway.
155 copied = skb->len;
156 if (copied > len) {
157 copied = len;
158 msg->msg_flags |= MSG_TRUNC;
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;
167 if (msg->msg_name)
168 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
174 err = copied;
176 out_free:
177 skb_free_datagram(sk, skb);
178 out:
179 mutex_unlock(&econet_mutex);
180 return err;
184 * Bind an Econet socket.
187 static int econet_bind(struct socket *sock, struct sockaddr *uaddr,
188 int addr_len)
190 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
191 struct sock *sk;
192 struct econet_sock *eo;
195 * Check legality
198 if (addr_len < sizeof(struct sockaddr_ec) ||
199 sec->sec_family != AF_ECONET)
200 return -EINVAL;
202 mutex_lock(&econet_mutex);
204 sk = sock->sk;
205 eo = ec_sk(sk);
207 eo->cb = sec->cb;
208 eo->port = sec->port;
209 eo->station = sec->addr.station;
210 eo->net = sec->addr.net;
212 mutex_unlock(&econet_mutex);
214 return 0;
217 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
219 * Queue a transmit result for the user to be told about.
222 static void tx_result(struct sock *sk, unsigned long cookie, int result)
224 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
225 struct ec_cb *eb;
226 struct sockaddr_ec *sec;
228 if (skb == NULL) {
229 pr_debug("econet: memory squeeze, transmit result dropped\n");
230 return;
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;
240 if (sock_queue_rcv_skb(sk, skb) < 0)
241 kfree_skb(skb);
243 #endif
245 #ifdef CONFIG_ECONET_NATIVE
247 * Called by the Econet hardware driver when a packet transmit
248 * has completed. Tell the user.
251 static void ec_tx_done(struct sk_buff *skb, int result)
253 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
254 tx_result(skb->sk, eb->cookie, result);
256 #endif
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.
263 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
264 struct msghdr *msg, size_t len)
266 struct sockaddr_ec *saddr = (struct sockaddr_ec *)msg->msg_name;
267 struct net_device *dev;
268 struct ec_addr addr;
269 int err;
270 unsigned char port, cb;
271 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
272 struct sock *sk = sock->sk;
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[2];
279 struct aunhdr ah;
280 struct sockaddr_in udpdest;
281 __kernel_size_t size;
282 mm_segment_t oldfs;
283 char *userbuf;
284 #endif
287 * Check the flags.
290 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
291 return -EINVAL;
294 * Get and verify the address.
297 mutex_lock(&econet_mutex);
299 if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
300 mutex_unlock(&econet_mutex);
301 return -EINVAL;
303 addr.station = saddr->addr.station;
304 addr.net = saddr->addr.net;
305 port = saddr->port;
306 cb = saddr->cb;
308 /* Look for a device with the right network number. */
309 dev = net2dev_map[addr.net];
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;
321 if (dev->type == ARPHRD_ECONET) {
322 /* Real hardware Econet. We're not worthy etc. */
323 #ifdef CONFIG_ECONET_NATIVE
324 unsigned short proto = 0;
325 int res;
327 if (len + 15 > dev->mtu) {
328 mutex_unlock(&econet_mutex);
329 return -EMSGSIZE;
332 dev_hold(dev);
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;
339 skb_reserve(skb, LL_RESERVED_SPACE(dev));
340 skb_reset_network_header(skb);
342 eb = (struct ec_cb *)&skb->cb;
344 eb->cookie = saddr->cookie;
345 eb->sec = *saddr;
346 eb->sent = ec_tx_done;
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;
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;
373 err = -ENETDOWN;
374 if (!(dev->flags & IFF_UP))
375 goto out_free;
378 * Now send it
381 dev_queue_xmit(skb);
382 dev_put(dev);
383 mutex_unlock(&econet_mutex);
384 return len;
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);
396 return err;
399 #ifdef CONFIG_ECONET_AUNUDP
400 /* AUN virtual Econet. */
402 if (udpsock == NULL) {
403 mutex_unlock(&econet_mutex);
404 return -ENETDOWN; /* No socket - can't send */
407 if (len > 32768) {
408 err = -E2BIG;
409 goto error;
412 /* Make up a UDP datagram and hand it off to some higher intellect. */
414 memset(&udpdest, 0, sizeof(udpdest));
415 udpdest.sin_family = AF_INET;
416 udpdest.sin_port = htons(AUN_PORT);
418 /* At the moment we use the stupid Acorn scheme of Econet address
419 y.x maps to IP a.b.c.x. This should be replaced with something
420 more flexible and more aware of subnet masks. */
422 struct in_device *idev;
423 unsigned long network = 0;
425 rcu_read_lock();
426 idev = __in_dev_get_rcu(dev);
427 if (idev) {
428 if (idev->ifa_list)
429 network = ntohl(idev->ifa_list->ifa_address) &
430 0xffffff00; /* !!! */
432 rcu_read_unlock();
433 udpdest.sin_addr.s_addr = htonl(network | addr.station);
436 memset(&ah, 0, sizeof(ah));
437 ah.port = port;
438 ah.cb = cb & 0x7f;
439 ah.code = 2; /* magic */
441 /* tack our header on the front of the iovec */
442 size = sizeof(struct aunhdr);
443 iov[0].iov_base = (void *)&ah;
444 iov[0].iov_len = size;
446 userbuf = vmalloc(len);
447 if (userbuf == NULL) {
448 err = -ENOMEM;
449 goto error;
452 iov[1].iov_base = userbuf;
453 iov[1].iov_len = len;
454 err = memcpy_fromiovec(userbuf, msg->msg_iov, len);
455 if (err)
456 goto error_free_buf;
458 /* Get a skbuff (no data, just holds our cb information) */
459 skb = sock_alloc_send_skb(sk, 0, msg->msg_flags & MSG_DONTWAIT, &err);
460 if (skb == NULL)
461 goto error_free_buf;
463 eb = (struct ec_cb *)&skb->cb;
465 eb->cookie = saddr->cookie;
466 eb->timeout = 5 * HZ;
467 eb->start = jiffies;
468 ah.handle = aun_seq;
469 eb->seq = (aun_seq++);
470 eb->sec = *saddr;
472 skb_queue_tail(&aun_queue, skb);
474 udpmsg.msg_name = (void *)&udpdest;
475 udpmsg.msg_namelen = sizeof(udpdest);
476 udpmsg.msg_iov = &iov[0];
477 udpmsg.msg_iovlen = 2;
478 udpmsg.msg_control = NULL;
479 udpmsg.msg_controllen = 0;
480 udpmsg.msg_flags = 0;
482 oldfs = get_fs();
483 set_fs(KERNEL_DS); /* More privs :-) */
484 err = sock_sendmsg(udpsock, &udpmsg, size);
485 set_fs(oldfs);
487 error_free_buf:
488 vfree(userbuf);
489 error:
490 #else
491 err = -EPROTOTYPE;
492 #endif
493 mutex_unlock(&econet_mutex);
495 return err;
499 * Look up the address of a socket.
502 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
503 int *uaddr_len, int peer)
505 struct sock *sk;
506 struct econet_sock *eo;
507 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
509 if (peer)
510 return -EOPNOTSUPP;
512 memset(sec, 0, sizeof(*sec));
513 mutex_lock(&econet_mutex);
515 sk = sock->sk;
516 eo = ec_sk(sk);
518 sec->sec_family = AF_ECONET;
519 sec->port = eo->port;
520 sec->addr.station = eo->station;
521 sec->addr.net = eo->net;
523 mutex_unlock(&econet_mutex);
525 *uaddr_len = sizeof(*sec);
526 return 0;
529 static void econet_destroy_timer(unsigned long data)
531 struct sock *sk = (struct sock *)data;
533 if (!sk_has_allocations(sk)) {
534 sk_free(sk);
535 return;
538 sk->sk_timer.expires = jiffies + 10 * HZ;
539 add_timer(&sk->sk_timer);
540 pr_debug("econet: socket destroy delayed\n");
544 * Close an econet socket.
547 static int econet_release(struct socket *sock)
549 struct sock *sk;
551 mutex_lock(&econet_mutex);
553 sk = sock->sk;
554 if (!sk)
555 goto out_unlock;
557 econet_remove_socket(&econet_sklist, sk);
560 * Now the socket is dead. No more input will appear.
563 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
565 sock_orphan(sk);
567 /* Purge queues */
569 skb_queue_purge(&sk->sk_receive_queue);
571 if (sk_has_allocations(sk)) {
572 sk->sk_timer.data = (unsigned long)sk;
573 sk->sk_timer.expires = jiffies + HZ;
574 sk->sk_timer.function = econet_destroy_timer;
575 add_timer(&sk->sk_timer);
577 goto out_unlock;
580 sk_free(sk);
582 out_unlock:
583 mutex_unlock(&econet_mutex);
584 return 0;
587 static struct proto econet_proto = {
588 .name = "ECONET",
589 .owner = THIS_MODULE,
590 .obj_size = sizeof(struct econet_sock),
594 * Create an Econet socket
597 static int econet_create(struct net *net, struct socket *sock, int protocol,
598 int kern)
600 struct sock *sk;
601 struct econet_sock *eo;
602 int err;
604 if (!net_eq(net, &init_net))
605 return -EAFNOSUPPORT;
607 /* Econet only provides datagram services. */
608 if (sock->type != SOCK_DGRAM)
609 return -ESOCKTNOSUPPORT;
611 sock->state = SS_UNCONNECTED;
613 err = -ENOBUFS;
614 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
615 if (sk == NULL)
616 goto out;
618 sk->sk_reuse = 1;
619 sock->ops = &econet_ops;
620 sock_init_data(sock, sk);
622 eo = ec_sk(sk);
623 sock_reset_flag(sk, SOCK_ZAPPED);
624 sk->sk_family = PF_ECONET;
625 eo->num = protocol;
627 econet_insert_socket(&econet_sklist, sk);
628 return 0;
629 out:
630 return err;
634 * Handle Econet specific ioctls
637 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
639 struct ifreq ifr;
640 struct ec_device *edev;
641 struct net_device *dev;
642 struct sockaddr_ec *sec;
643 int err;
646 * Fetch the caller's info block into kernel space
649 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
650 return -EFAULT;
652 dev = dev_get_by_name(&init_net, ifr.ifr_name);
653 if (dev == NULL)
654 return -ENODEV;
656 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
658 mutex_lock(&econet_mutex);
660 err = 0;
661 switch (cmd) {
662 case SIOCSIFADDR:
663 if (!capable(CAP_NET_ADMIN)) {
664 err = -EPERM;
665 break;
668 edev = dev->ec_ptr;
669 if (edev == NULL) {
670 /* Magic up a new one. */
671 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
672 if (edev == NULL) {
673 err = -ENOMEM;
674 break;
676 dev->ec_ptr = edev;
677 } else
678 net2dev_map[edev->net] = NULL;
679 edev->station = sec->addr.station;
680 edev->net = sec->addr.net;
681 net2dev_map[sec->addr.net] = dev;
682 if (!net2dev_map[0])
683 net2dev_map[0] = dev;
684 break;
686 case SIOCGIFADDR:
687 edev = dev->ec_ptr;
688 if (edev == NULL) {
689 err = -ENODEV;
690 break;
692 memset(sec, 0, sizeof(struct sockaddr_ec));
693 sec->addr.station = edev->station;
694 sec->addr.net = edev->net;
695 sec->sec_family = AF_ECONET;
696 dev_put(dev);
697 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
698 err = -EFAULT;
699 break;
701 default:
702 err = -EINVAL;
703 break;
706 mutex_unlock(&econet_mutex);
708 dev_put(dev);
710 return err;
714 * Handle generic ioctls
717 static int econet_ioctl(struct socket *sock, unsigned int cmd,
718 unsigned long arg)
720 struct sock *sk = sock->sk;
721 void __user *argp = (void __user *)arg;
723 switch (cmd) {
724 case SIOCGSTAMP:
725 return sock_get_timestamp(sk, argp);
727 case SIOCGSTAMPNS:
728 return sock_get_timestampns(sk, argp);
730 case SIOCSIFADDR:
731 case SIOCGIFADDR:
732 return ec_dev_ioctl(sock, cmd, argp);
736 return -ENOIOCTLCMD;
739 static const struct net_proto_family econet_family_ops = {
740 .family = PF_ECONET,
741 .create = econet_create,
742 .owner = THIS_MODULE,
745 static const struct proto_ops econet_ops = {
746 .family = PF_ECONET,
747 .owner = THIS_MODULE,
748 .release = econet_release,
749 .bind = econet_bind,
750 .connect = sock_no_connect,
751 .socketpair = sock_no_socketpair,
752 .accept = sock_no_accept,
753 .getname = econet_getname,
754 .poll = datagram_poll,
755 .ioctl = econet_ioctl,
756 .listen = sock_no_listen,
757 .shutdown = sock_no_shutdown,
758 .setsockopt = sock_no_setsockopt,
759 .getsockopt = sock_no_getsockopt,
760 .sendmsg = econet_sendmsg,
761 .recvmsg = econet_recvmsg,
762 .mmap = sock_no_mmap,
763 .sendpage = sock_no_sendpage,
766 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
768 * Find the listening socket, if any, for the given data.
771 static struct sock *ec_listening_socket(unsigned char port, unsigned char
772 station, unsigned char net)
774 struct sock *sk;
775 struct hlist_node *node;
777 spin_lock(&econet_lock);
778 sk_for_each(sk, node, &econet_sklist) {
779 struct econet_sock *opt = ec_sk(sk);
780 if ((opt->port == port || opt->port == 0) &&
781 (opt->station == station || opt->station == 0) &&
782 (opt->net == net || opt->net == 0)) {
783 sock_hold(sk);
784 goto found;
787 sk = NULL;
788 found:
789 spin_unlock(&econet_lock);
790 return sk;
794 * Queue a received packet for a socket.
797 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
798 unsigned char stn, unsigned char net,
799 unsigned char cb, unsigned char port)
801 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
802 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
804 memset(sec, 0, sizeof(struct sockaddr_ec));
805 sec->sec_family = AF_ECONET;
806 sec->type = ECTYPE_PACKET_RECEIVED;
807 sec->port = port;
808 sec->cb = cb;
809 sec->addr.net = net;
810 sec->addr.station = stn;
812 return sock_queue_rcv_skb(sk, skb);
814 #endif
816 #ifdef CONFIG_ECONET_AUNUDP
818 * Send an AUN protocol response.
821 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
823 struct sockaddr_in sin = {
824 .sin_family = AF_INET,
825 .sin_port = htons(AUN_PORT),
826 .sin_addr = {.s_addr = addr}
828 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
829 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
830 struct msghdr udpmsg;
832 udpmsg.msg_name = (void *)&sin;
833 udpmsg.msg_namelen = sizeof(sin);
834 udpmsg.msg_control = NULL;
835 udpmsg.msg_controllen = 0;
836 udpmsg.msg_flags = 0;
838 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
843 * Handle incoming AUN packets. Work out if anybody wants them,
844 * and send positive or negative acknowledgements as appropriate.
847 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
849 struct iphdr *ip = ip_hdr(skb);
850 unsigned char stn = ntohl(ip->saddr) & 0xff;
851 struct dst_entry *dst = skb_dst(skb);
852 struct ec_device *edev = NULL;
853 struct sock *sk = NULL;
854 struct sk_buff *newskb;
856 if (dst)
857 edev = dst->dev->ec_ptr;
859 if (!edev)
860 goto bad;
862 sk = ec_listening_socket(ah->port, stn, edev->net);
863 if (sk == NULL)
864 goto bad; /* Nobody wants it */
866 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
867 GFP_ATOMIC);
868 if (newskb == NULL) {
869 pr_debug("AUN: memory squeeze, dropping packet\n");
870 /* Send nack and hope sender tries again */
871 goto bad;
874 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah + 1),
875 len - sizeof(struct aunhdr));
877 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port)) {
878 /* Socket is bankrupt. */
879 kfree_skb(newskb);
880 goto bad;
883 aun_send_response(ip->saddr, ah->handle, 3, 0);
884 sock_put(sk);
885 return;
887 bad:
888 aun_send_response(ip->saddr, ah->handle, 4, 0);
889 if (sk)
890 sock_put(sk);
894 * Handle incoming AUN transmit acknowledgements. If the sequence
895 * number matches something in our backlog then kill it and tell
896 * the user. If the remote took too long to reply then we may have
897 * dropped the packet already.
900 static void aun_tx_ack(unsigned long seq, int result)
902 struct sk_buff *skb;
903 unsigned long flags;
904 struct ec_cb *eb;
906 spin_lock_irqsave(&aun_queue_lock, flags);
907 skb_queue_walk(&aun_queue, skb) {
908 eb = (struct ec_cb *)&skb->cb;
909 if (eb->seq == seq)
910 goto foundit;
912 spin_unlock_irqrestore(&aun_queue_lock, flags);
913 pr_debug("AUN: unknown sequence %ld\n", seq);
914 return;
916 foundit:
917 tx_result(skb->sk, eb->cookie, result);
918 skb_unlink(skb, &aun_queue);
919 spin_unlock_irqrestore(&aun_queue_lock, flags);
920 kfree_skb(skb);
924 * Deal with received AUN frames - sort out what type of thing it is
925 * and hand it to the right function.
928 static void aun_data_available(struct sock *sk, int slen)
930 int err;
931 struct sk_buff *skb;
932 unsigned char *data;
933 struct aunhdr *ah;
934 size_t len;
936 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
937 if (err == -EAGAIN) {
938 pr_err("AUN: no data available?!\n");
939 return;
941 pr_debug("AUN: recvfrom() error %d\n", -err);
944 data = skb_transport_header(skb) + sizeof(struct udphdr);
945 ah = (struct aunhdr *)data;
946 len = skb->len - sizeof(struct udphdr);
948 switch (ah->code) {
949 case 2:
950 aun_incoming(skb, ah, len);
951 break;
952 case 3:
953 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
954 break;
955 case 4:
956 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
957 break;
958 default:
959 pr_debug("AUN: unknown packet type: %d\n", data[0]);
962 skb_free_datagram(sk, skb);
966 * Called by the timer to manage the AUN transmit queue. If a packet
967 * was sent to a dead or nonexistent host then we will never get an
968 * acknowledgement back. After a few seconds we need to spot this and
969 * drop the packet.
972 static void ab_cleanup(unsigned long h)
974 struct sk_buff *skb, *n;
975 unsigned long flags;
977 spin_lock_irqsave(&aun_queue_lock, flags);
978 skb_queue_walk_safe(&aun_queue, skb, n) {
979 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
980 if ((jiffies - eb->start) > eb->timeout) {
981 tx_result(skb->sk, eb->cookie,
982 ECTYPE_TRANSMIT_NOT_PRESENT);
983 skb_unlink(skb, &aun_queue);
984 kfree_skb(skb);
987 spin_unlock_irqrestore(&aun_queue_lock, flags);
989 mod_timer(&ab_cleanup_timer, jiffies + (HZ * 2));
992 static int __init aun_udp_initialise(void)
994 int error;
995 struct sockaddr_in sin;
997 skb_queue_head_init(&aun_queue);
998 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
999 ab_cleanup_timer.expires = jiffies + (HZ * 2);
1000 add_timer(&ab_cleanup_timer);
1002 memset(&sin, 0, sizeof(sin));
1003 sin.sin_port = htons(AUN_PORT);
1005 /* We can count ourselves lucky Acorn machines are too dim to
1006 speak IPv6. :-) */
1007 error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock);
1008 if (error < 0) {
1009 pr_err("AUN: socket error %d\n", -error);
1010 return error;
1013 udpsock->sk->sk_reuse = 1;
1014 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1015 from interrupts */
1017 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1018 sizeof(sin));
1019 if (error < 0) {
1020 pr_err("AUN: bind error %d\n", -error);
1021 goto release;
1024 udpsock->sk->sk_data_ready = aun_data_available;
1026 return 0;
1028 release:
1029 sock_release(udpsock);
1030 udpsock = NULL;
1031 return error;
1033 #endif
1035 #ifdef CONFIG_ECONET_NATIVE
1038 * Receive an Econet frame from a device.
1041 static int econet_rcv(struct sk_buff *skb, struct net_device *dev,
1042 struct packet_type *pt, struct net_device *orig_dev)
1044 struct ec_framehdr *hdr;
1045 struct sock *sk = NULL;
1046 struct ec_device *edev = dev->ec_ptr;
1048 if (!net_eq(dev_net(dev), &init_net))
1049 goto drop;
1051 if (skb->pkt_type == PACKET_OTHERHOST)
1052 goto drop;
1054 if (!edev)
1055 goto drop;
1057 skb = skb_share_check(skb, GFP_ATOMIC);
1058 if (skb == NULL)
1059 return NET_RX_DROP;
1061 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1062 goto drop;
1064 hdr = (struct ec_framehdr *)skb->data;
1066 /* First check for encapsulated IP */
1067 if (hdr->port == EC_PORT_IP) {
1068 skb->protocol = htons(ETH_P_IP);
1069 skb_pull(skb, sizeof(struct ec_framehdr));
1070 netif_rx(skb);
1071 return NET_RX_SUCCESS;
1074 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1075 if (!sk)
1076 goto drop;
1078 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1079 hdr->port))
1080 goto drop;
1081 sock_put(sk);
1082 return NET_RX_SUCCESS;
1084 drop:
1085 if (sk)
1086 sock_put(sk);
1087 kfree_skb(skb);
1088 return NET_RX_DROP;
1091 static struct packet_type econet_packet_type __read_mostly = {
1092 .type = cpu_to_be16(ETH_P_ECONET),
1093 .func = econet_rcv,
1096 static void econet_hw_initialise(void)
1098 dev_add_pack(&econet_packet_type);
1101 #endif
1103 static int econet_notifier(struct notifier_block *this, unsigned long msg,
1104 void *data)
1106 struct net_device *dev = data;
1107 struct ec_device *edev;
1109 if (!net_eq(dev_net(dev), &init_net))
1110 return NOTIFY_DONE;
1112 switch (msg) {
1113 case NETDEV_UNREGISTER:
1114 /* A device has gone down - kill any data we hold for it. */
1115 edev = dev->ec_ptr;
1116 if (edev) {
1117 if (net2dev_map[0] == dev)
1118 net2dev_map[0] = NULL;
1119 net2dev_map[edev->net] = NULL;
1120 kfree(edev);
1121 dev->ec_ptr = NULL;
1123 break;
1126 return NOTIFY_DONE;
1129 static struct notifier_block econet_netdev_notifier = {
1130 .notifier_call = econet_notifier,
1133 static void __exit econet_proto_exit(void)
1135 #ifdef CONFIG_ECONET_AUNUDP
1136 del_timer(&ab_cleanup_timer);
1137 if (udpsock)
1138 sock_release(udpsock);
1139 #endif
1140 unregister_netdevice_notifier(&econet_netdev_notifier);
1141 #ifdef CONFIG_ECONET_NATIVE
1142 dev_remove_pack(&econet_packet_type);
1143 #endif
1144 sock_unregister(econet_family_ops.family);
1145 proto_unregister(&econet_proto);
1148 static int __init econet_proto_init(void)
1150 int err = proto_register(&econet_proto, 0);
1152 if (err != 0)
1153 goto out;
1154 sock_register(&econet_family_ops);
1155 #ifdef CONFIG_ECONET_AUNUDP
1156 aun_udp_initialise();
1157 #endif
1158 #ifdef CONFIG_ECONET_NATIVE
1159 econet_hw_initialise();
1160 #endif
1161 register_netdevice_notifier(&econet_netdev_notifier);
1162 out:
1163 return err;
1166 module_init(econet_proto_init);
1167 module_exit(econet_proto_exit);
1169 MODULE_LICENSE("GPL");
1170 MODULE_ALIAS_NETPROTO(PF_ECONET);