Loading...
Note: File does not exist in v3.15.
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#define pr_fmt(fmt) fmt
13
14#include <linux/module.h>
15
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>
48
49#include <linux/uaccess.h>
50#include <asm/system.h>
51
52static const struct proto_ops econet_ops;
53static struct hlist_head econet_sklist;
54static DEFINE_SPINLOCK(econet_lock);
55static DEFINE_MUTEX(econet_mutex);
56
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. */
59static struct net_device *net2dev_map[256];
60
61#define EC_PORT_IP 0xd2
62
63#ifdef CONFIG_ECONET_AUNUDP
64static DEFINE_SPINLOCK(aun_queue_lock);
65static struct socket *udpsock;
66#define AUN_PORT 0x8000
67
68struct 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;
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 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
97};
98
99static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
100{
101 spin_lock_bh(&econet_lock);
102 sk_del_node_init(sk);
103 spin_unlock_bh(&econet_lock);
104}
105
106static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
107{
108 spin_lock_bh(&econet_lock);
109 sk_add_node(sk, list);
110 spin_unlock_bh(&econet_lock);
111}
112
113/*
114 * Pull a packet from our receive queue and hand it to the user.
115 * If necessary we block.
116 */
117
118static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
119 struct msghdr *msg, size_t len, int flags)
120{
121 struct sock *sk = sock->sk;
122 struct sk_buff *skb;
123 size_t copied;
124 int err;
125
126 msg->msg_namelen = sizeof(struct sockaddr_ec);
127
128 mutex_lock(&econet_mutex);
129
130 /*
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.
134 *
135 * Now it will return ENETDOWN, if device have just gone down,
136 * but then it will block.
137 */
138
139 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
140
141 /*
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.
145 */
146
147 if (skb == NULL)
148 goto out;
149
150 /*
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.
153 */
154
155 copied = skb->len;
156 if (copied > len) {
157 copied = len;
158 msg->msg_flags |= MSG_TRUNC;
159 }
160
161 /* We can't use skb_copy_datagram here */
162 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
163 if (err)
164 goto out_free;
165 sk->sk_stamp = skb->tstamp;
166
167 if (msg->msg_name)
168 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
169
170 /*
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
173 */
174 err = copied;
175
176out_free:
177 skb_free_datagram(sk, skb);
178out:
179 mutex_unlock(&econet_mutex);
180 return err;
181}
182
183/*
184 * Bind an Econet socket.
185 */
186
187static int econet_bind(struct socket *sock, struct sockaddr *uaddr,
188 int addr_len)
189{
190 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
191 struct sock *sk;
192 struct econet_sock *eo;
193
194 /*
195 * Check legality
196 */
197
198 if (addr_len < sizeof(struct sockaddr_ec) ||
199 sec->sec_family != AF_ECONET)
200 return -EINVAL;
201
202 mutex_lock(&econet_mutex);
203
204 sk = sock->sk;
205 eo = ec_sk(sk);
206
207 eo->cb = sec->cb;
208 eo->port = sec->port;
209 eo->station = sec->addr.station;
210 eo->net = sec->addr.net;
211
212 mutex_unlock(&econet_mutex);
213
214 return 0;
215}
216
217#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
218/*
219 * Queue a transmit result for the user to be told about.
220 */
221
222static void tx_result(struct sock *sk, unsigned long cookie, int result)
223{
224 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
225 struct ec_cb *eb;
226 struct sockaddr_ec *sec;
227
228 if (skb == NULL) {
229 pr_debug("econet: 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
251static 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
263static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
264 struct msghdr *msg, size_t len)
265{
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
285
286 /*
287 * Check the flags.
288 */
289
290 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
291 return -EINVAL;
292
293 /*
294 * Get and verify the address.
295 */
296
297 mutex_lock(&econet_mutex);
298
299 if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
300 mutex_unlock(&econet_mutex);
301 return -EINVAL;
302 }
303 addr.station = saddr->addr.station;
304 addr.net = saddr->addr.net;
305 port = saddr->port;
306 cb = saddr->cb;
307
308 /* Look for a device with the right network number. */
309 dev = net2dev_map[addr.net];
310
311 /* If not directly reachable, use some default */
312 if (dev == NULL) {
313 dev = net2dev_map[0];
314 /* No interfaces at all? */
315 if (dev == NULL) {
316 mutex_unlock(&econet_mutex);
317 return -ENETDOWN;
318 }
319 }
320
321 if (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;
326
327 if (len + 15 > dev->mtu) {
328 mutex_unlock(&econet_mutex);
329 return -EMSGSIZE;
330 }
331
332 dev_hold(dev);
333
334 skb = sock_alloc_send_skb(sk, len + LL_ALLOCATED_SPACE(dev),
335 msg->msg_flags & MSG_DONTWAIT, &err);
336 if (skb == NULL)
337 goto out_unlock;
338
339 skb_reserve(skb, LL_RESERVED_SPACE(dev));
340 skb_reset_network_header(skb);
341
342 eb = (struct ec_cb *)&skb->cb;
343
344 eb->cookie = saddr->cookie;
345 eb->sec = *saddr;
346 eb->sent = ec_tx_done;
347
348 err = -EINVAL;
349 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
350 if (res < 0)
351 goto out_free;
352 if (res > 0) {
353 struct ec_framehdr *fh;
354 /* Poke in our control byte and
355 port number. Hack, hack. */
356 fh = (struct ec_framehdr *)skb->data;
357 fh->cb = cb;
358 fh->port = port;
359 if (sock->type != SOCK_DGRAM) {
360 skb_reset_tail_pointer(skb);
361 skb->len = 0;
362 }
363 }
364
365 /* Copy the data. Returns -EFAULT on error */
366 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
367 skb->protocol = proto;
368 skb->dev = dev;
369 skb->priority = sk->sk_priority;
370 if (err)
371 goto out_free;
372
373 err = -ENETDOWN;
374 if (!(dev->flags & IFF_UP))
375 goto out_free;
376
377 /*
378 * Now send it
379 */
380
381 dev_queue_xmit(skb);
382 dev_put(dev);
383 mutex_unlock(&econet_mutex);
384 return len;
385
386out_free:
387 kfree_skb(skb);
388out_unlock:
389 if (dev)
390 dev_put(dev);
391#else
392 err = -EPROTOTYPE;
393#endif
394 mutex_unlock(&econet_mutex);
395
396 return err;
397 }
398
399#ifdef CONFIG_ECONET_AUNUDP
400 /* AUN virtual Econet. */
401
402 if (udpsock == NULL) {
403 mutex_unlock(&econet_mutex);
404 return -ENETDOWN; /* No socket - can't send */
405 }
406
407 if (len > 32768) {
408 err = -E2BIG;
409 goto error;
410 }
411
412 /* Make up a UDP datagram and hand it off to some higher intellect. */
413
414 memset(&udpdest, 0, sizeof(udpdest));
415 udpdest.sin_family = AF_INET;
416 udpdest.sin_port = htons(AUN_PORT);
417
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. */
421 {
422 struct in_device *idev;
423 unsigned long network = 0;
424
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; /* !!! */
431 }
432 rcu_read_unlock();
433 udpdest.sin_addr.s_addr = htonl(network | addr.station);
434 }
435
436 memset(&ah, 0, sizeof(ah));
437 ah.port = port;
438 ah.cb = cb & 0x7f;
439 ah.code = 2; /* magic */
440
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;
445
446 userbuf = vmalloc(len);
447 if (userbuf == NULL) {
448 err = -ENOMEM;
449 goto error;
450 }
451
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;
457
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;
462
463 eb = (struct ec_cb *)&skb->cb;
464
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;
471
472 skb_queue_tail(&aun_queue, skb);
473
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;
481
482 oldfs = get_fs();
483 set_fs(KERNEL_DS); /* More privs :-) */
484 err = sock_sendmsg(udpsock, &udpmsg, size);
485 set_fs(oldfs);
486
487error_free_buf:
488 vfree(userbuf);
489error:
490#else
491 err = -EPROTOTYPE;
492#endif
493 mutex_unlock(&econet_mutex);
494
495 return err;
496}
497
498/*
499 * Look up the address of a socket.
500 */
501
502static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
503 int *uaddr_len, int peer)
504{
505 struct sock *sk;
506 struct econet_sock *eo;
507 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
508
509 if (peer)
510 return -EOPNOTSUPP;
511
512 memset(sec, 0, sizeof(*sec));
513 mutex_lock(&econet_mutex);
514
515 sk = sock->sk;
516 eo = ec_sk(sk);
517
518 sec->sec_family = AF_ECONET;
519 sec->port = eo->port;
520 sec->addr.station = eo->station;
521 sec->addr.net = eo->net;
522
523 mutex_unlock(&econet_mutex);
524
525 *uaddr_len = sizeof(*sec);
526 return 0;
527}
528
529static void econet_destroy_timer(unsigned long data)
530{
531 struct sock *sk = (struct sock *)data;
532
533 if (!sk_has_allocations(sk)) {
534 sk_free(sk);
535 return;
536 }
537
538 sk->sk_timer.expires = jiffies + 10 * HZ;
539 add_timer(&sk->sk_timer);
540 pr_debug("econet: socket destroy delayed\n");
541}
542
543/*
544 * Close an econet socket.
545 */
546
547static int econet_release(struct socket *sock)
548{
549 struct sock *sk;
550
551 mutex_lock(&econet_mutex);
552
553 sk = sock->sk;
554 if (!sk)
555 goto out_unlock;
556
557 econet_remove_socket(&econet_sklist, sk);
558
559 /*
560 * Now the socket is dead. No more input will appear.
561 */
562
563 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
564
565 sock_orphan(sk);
566
567 /* Purge queues */
568
569 skb_queue_purge(&sk->sk_receive_queue);
570
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);
576
577 goto out_unlock;
578 }
579
580 sk_free(sk);
581
582out_unlock:
583 mutex_unlock(&econet_mutex);
584 return 0;
585}
586
587static struct proto econet_proto = {
588 .name = "ECONET",
589 .owner = THIS_MODULE,
590 .obj_size = sizeof(struct econet_sock),
591};
592
593/*
594 * Create an Econet socket
595 */
596
597static int econet_create(struct net *net, struct socket *sock, int protocol,
598 int kern)
599{
600 struct sock *sk;
601 struct econet_sock *eo;
602 int err;
603
604 if (!net_eq(net, &init_net))
605 return -EAFNOSUPPORT;
606
607 /* Econet only provides datagram services. */
608 if (sock->type != SOCK_DGRAM)
609 return -ESOCKTNOSUPPORT;
610
611 sock->state = SS_UNCONNECTED;
612
613 err = -ENOBUFS;
614 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
615 if (sk == NULL)
616 goto out;
617
618 sk->sk_reuse = 1;
619 sock->ops = &econet_ops;
620 sock_init_data(sock, sk);
621
622 eo = ec_sk(sk);
623 sock_reset_flag(sk, SOCK_ZAPPED);
624 sk->sk_family = PF_ECONET;
625 eo->num = protocol;
626
627 econet_insert_socket(&econet_sklist, sk);
628 return 0;
629out:
630 return err;
631}
632
633/*
634 * Handle Econet specific ioctls
635 */
636
637static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
638{
639 struct ifreq ifr;
640 struct ec_device *edev;
641 struct net_device *dev;
642 struct sockaddr_ec *sec;
643 int err;
644
645 /*
646 * Fetch the caller's info block into kernel space
647 */
648
649 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
650 return -EFAULT;
651
652 dev = dev_get_by_name(&init_net, ifr.ifr_name);
653 if (dev == NULL)
654 return -ENODEV;
655
656 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
657
658 mutex_lock(&econet_mutex);
659
660 err = 0;
661 switch (cmd) {
662 case SIOCSIFADDR:
663 if (!capable(CAP_NET_ADMIN)) {
664 err = -EPERM;
665 break;
666 }
667
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;
675 }
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;
685
686 case SIOCGIFADDR:
687 edev = dev->ec_ptr;
688 if (edev == NULL) {
689 err = -ENODEV;
690 break;
691 }
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;
700
701 default:
702 err = -EINVAL;
703 break;
704 }
705
706 mutex_unlock(&econet_mutex);
707
708 dev_put(dev);
709
710 return err;
711}
712
713/*
714 * Handle generic ioctls
715 */
716
717static int econet_ioctl(struct socket *sock, unsigned int cmd,
718 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
734 }
735
736 return -ENOIOCTLCMD;
737}
738
739static const struct net_proto_family econet_family_ops = {
740 .family = PF_ECONET,
741 .create = econet_create,
742 .owner = THIS_MODULE,
743};
744
745static 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,
764};
765
766#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
767/*
768 * Find the listening socket, if any, for the given data.
769 */
770
771static struct sock *ec_listening_socket(unsigned char port, unsigned char
772 station, unsigned char net)
773{
774 struct sock *sk;
775 struct hlist_node *node;
776
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;
785 }
786 }
787 sk = NULL;
788found:
789 spin_unlock(&econet_lock);
790 return sk;
791}
792
793/*
794 * Queue a received packet for a socket.
795 */
796
797static 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)
800{
801 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
802 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
803
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;
811
812 return sock_queue_rcv_skb(sk, skb);
813}
814#endif
815
816#ifdef CONFIG_ECONET_AUNUDP
817/*
818 * Send an AUN protocol response.
819 */
820
821static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
822{
823 struct sockaddr_in sin = {
824 .sin_family = AF_INET,
825 .sin_port = htons(AUN_PORT),
826 .sin_addr = {.s_addr = addr}
827 };
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;
831
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;
837
838 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
839}
840
841
842/*
843 * Handle incoming AUN packets. Work out if anybody wants them,
844 * and send positive or negative acknowledgements as appropriate.
845 */
846
847static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
848{
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;
855
856 if (dst)
857 edev = dst->dev->ec_ptr;
858
859 if (!edev)
860 goto bad;
861
862 sk = ec_listening_socket(ah->port, stn, edev->net);
863 if (sk == NULL)
864 goto bad; /* Nobody wants it */
865
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;
872 }
873
874 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah + 1),
875 len - sizeof(struct aunhdr));
876
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;
881 }
882
883 aun_send_response(ip->saddr, ah->handle, 3, 0);
884 sock_put(sk);
885 return;
886
887bad:
888 aun_send_response(ip->saddr, ah->handle, 4, 0);
889 if (sk)
890 sock_put(sk);
891}
892
893/*
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.
898 */
899
900static void aun_tx_ack(unsigned long seq, int result)
901{
902 struct sk_buff *skb;
903 unsigned long flags;
904 struct ec_cb *eb;
905
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;
911 }
912 spin_unlock_irqrestore(&aun_queue_lock, flags);
913 pr_debug("AUN: unknown sequence %ld\n", seq);
914 return;
915
916foundit:
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);
921}
922
923/*
924 * Deal with received AUN frames - sort out what type of thing it is
925 * and hand it to the right function.
926 */
927
928static void aun_data_available(struct sock *sk, int slen)
929{
930 int err;
931 struct sk_buff *skb;
932 unsigned char *data;
933 struct aunhdr *ah;
934 size_t len;
935
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;
940 }
941 pr_debug("AUN: recvfrom() error %d\n", -err);
942 }
943
944 data = skb_transport_header(skb) + sizeof(struct udphdr);
945 ah = (struct aunhdr *)data;
946 len = skb->len - sizeof(struct udphdr);
947
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]);
960 }
961
962 skb_free_datagram(sk, skb);
963}
964
965/*
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.
970 */
971
972static void ab_cleanup(unsigned long h)
973{
974 struct sk_buff *skb, *n;
975 unsigned long flags;
976
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);
985 }
986 }
987 spin_unlock_irqrestore(&aun_queue_lock, flags);
988
989 mod_timer(&ab_cleanup_timer, jiffies + (HZ * 2));
990}
991
992static int __init aun_udp_initialise(void)
993{
994 int error;
995 struct sockaddr_in sin;
996
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);
1001
1002 memset(&sin, 0, sizeof(sin));
1003 sin.sin_port = htons(AUN_PORT);
1004
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;
1011 }
1012
1013 udpsock->sk->sk_reuse = 1;
1014 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1015 from interrupts */
1016
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;
1022 }
1023
1024 udpsock->sk->sk_data_ready = aun_data_available;
1025
1026 return 0;
1027
1028release:
1029 sock_release(udpsock);
1030 udpsock = NULL;
1031 return error;
1032}
1033#endif
1034
1035#ifdef CONFIG_ECONET_NATIVE
1036
1037/*
1038 * Receive an Econet frame from a device.
1039 */
1040
1041static int econet_rcv(struct sk_buff *skb, struct net_device *dev,
1042 struct packet_type *pt, struct net_device *orig_dev)
1043{
1044 struct ec_framehdr *hdr;
1045 struct sock *sk = NULL;
1046 struct ec_device *edev = dev->ec_ptr;
1047
1048 if (!net_eq(dev_net(dev), &init_net))
1049 goto drop;
1050
1051 if (skb->pkt_type == PACKET_OTHERHOST)
1052 goto drop;
1053
1054 if (!edev)
1055 goto drop;
1056
1057 skb = skb_share_check(skb, GFP_ATOMIC);
1058 if (skb == NULL)
1059 return NET_RX_DROP;
1060
1061 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1062 goto drop;
1063
1064 hdr = (struct ec_framehdr *)skb->data;
1065
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;
1072 }
1073
1074 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1075 if (!sk)
1076 goto drop;
1077
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;
1083
1084drop:
1085 if (sk)
1086 sock_put(sk);
1087 kfree_skb(skb);
1088 return NET_RX_DROP;
1089}
1090
1091static struct packet_type econet_packet_type __read_mostly = {
1092 .type = cpu_to_be16(ETH_P_ECONET),
1093 .func = econet_rcv,
1094};
1095
1096static void econet_hw_initialise(void)
1097{
1098 dev_add_pack(&econet_packet_type);
1099}
1100
1101#endif
1102
1103static int econet_notifier(struct notifier_block *this, unsigned long msg,
1104 void *data)
1105{
1106 struct net_device *dev = data;
1107 struct ec_device *edev;
1108
1109 if (!net_eq(dev_net(dev), &init_net))
1110 return NOTIFY_DONE;
1111
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;
1122 }
1123 break;
1124 }
1125
1126 return NOTIFY_DONE;
1127}
1128
1129static struct notifier_block econet_netdev_notifier = {
1130 .notifier_call = econet_notifier,
1131};
1132
1133static void __exit econet_proto_exit(void)
1134{
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);
1146}
1147
1148static int __init econet_proto_init(void)
1149{
1150 int err = proto_register(&econet_proto, 0);
1151
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);
1162out:
1163 return err;
1164}
1165
1166module_init(econet_proto_init);
1167module_exit(econet_proto_exit);
1168
1169MODULE_LICENSE("GPL");
1170MODULE_ALIAS_NETPROTO(PF_ECONET);