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