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