mac80211 & nl80211: add support to abort a scan request on tx
[linux-2.6.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 #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
52 static const struct proto_ops econet_ops;
53 static struct hlist_head econet_sklist;
54 static DEFINE_SPINLOCK(econet_lock);
55 static DEFINE_MUTEX(econet_mutex);
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. */
59 static struct net_device *net2dev_map[256];
60
61 #define EC_PORT_IP      0xd2
62
63 #ifdef CONFIG_ECONET_AUNUDP
64 static DEFINE_SPINLOCK(aun_queue_lock);
65 static struct socket *udpsock;
66 #define AUN_PORT        0x8000
67
68 struct aunhdr {
69         unsigned char code;             /* AUN magic protocol byte */
70         unsigned char port;
71         unsigned char cb;
72         unsigned char pad;
73         unsigned long handle;
74 };
75
76 static unsigned long aun_seq;
77
78 /* Queue of packets waiting to be transmitted. */
79 static struct sk_buff_head aun_queue;
80 static struct timer_list ab_cleanup_timer;
81
82 #endif          /* CONFIG_ECONET_AUNUDP */
83
84 /* Per-packet information */
85 struct ec_cb {
86         struct sockaddr_ec sec;
87         unsigned long cookie;           /* Supplied by user. */
88 #ifdef CONFIG_ECONET_AUNUDP
89         int done;
90         unsigned long seq;              /* Sequencing */
91         unsigned long timeout;          /* Timeout */
92         unsigned long start;            /* jiffies */
93 #endif
94 #ifdef CONFIG_ECONET_NATIVE
95         void (*sent)(struct sk_buff *, int result);
96 #endif
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                 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,
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
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                 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
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 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
386 out_free:
387                 kfree_skb(skb);
388 out_unlock:
389                 if (dev)
390                         dev_put(dev);
391 #else
392                 err = -EPROTOTYPE;
393 #endif
394                 mutex_unlock(&econet_mutex);
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
487 error_free_buf:
488         vfree(userbuf);
489 error:
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
502 static 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
529 static 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
547 static 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
582 out_unlock:
583         mutex_unlock(&econet_mutex);
584         return 0;
585 }
586
587 static 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
597 static 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;
629 out:
630         return err;
631 }
632
633 /*
634  *      Handle Econet specific ioctls
635  */
636
637 static 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
717 static 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
739 static const struct net_proto_family econet_family_ops = {
740         .family =       PF_ECONET,
741         .create =       econet_create,
742         .owner  =       THIS_MODULE,
743 };
744
745 static const struct proto_ops econet_ops = {
746         .family =       PF_ECONET,
747         .owner =        THIS_MODULE,
748         .release =      econet_release,
749         .bind =         econet_bind,
750         .connect =      sock_no_connect,
751         .socketpair =   sock_no_socketpair,
752         .accept =       sock_no_accept,
753         .getname =      econet_getname,
754         .poll =         datagram_poll,
755         .ioctl =        econet_ioctl,
756         .listen =       sock_no_listen,
757         .shutdown =     sock_no_shutdown,
758         .setsockopt =   sock_no_setsockopt,
759         .getsockopt =   sock_no_getsockopt,
760         .sendmsg =      econet_sendmsg,
761         .recvmsg =      econet_recvmsg,
762         .mmap =         sock_no_mmap,
763         .sendpage =     sock_no_sendpage,
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
771 static 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;
788 found:
789         spin_unlock(&econet_lock);
790         return sk;
791 }
792
793 /*
794  *      Queue a received packet for a socket.
795  */
796
797 static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
798                            unsigned char stn, unsigned char net,
799                            unsigned char cb, unsigned char port)
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
821 static 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
847 static 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
887 bad:
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
900 static 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
916 foundit:
917         tx_result(skb->sk, eb->cookie, result);
918         skb_unlink(skb, &aun_queue);
919         spin_unlock_irqrestore(&aun_queue_lock, flags);
920         kfree_skb(skb);
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
928 static 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
972 static 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
992 static 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
1028 release:
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
1041 static 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
1084 drop:
1085         if (sk)
1086                 sock_put(sk);
1087         kfree_skb(skb);
1088         return NET_RX_DROP;
1089 }
1090
1091 static struct packet_type econet_packet_type __read_mostly = {
1092         .type = cpu_to_be16(ETH_P_ECONET),
1093         .func = econet_rcv,
1094 };
1095
1096 static void econet_hw_initialise(void)
1097 {
1098         dev_add_pack(&econet_packet_type);
1099 }
1100
1101 #endif
1102
1103 static 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
1129 static struct notifier_block econet_netdev_notifier = {
1130         .notifier_call = econet_notifier,
1131 };
1132
1133 static 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
1148 static 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);
1162 out:
1163         return err;
1164 }
1165
1166 module_init(econet_proto_init);
1167 module_exit(econet_proto_exit);
1168
1169 MODULE_LICENSE("GPL");
1170 MODULE_ALIAS_NETPROTO(PF_ECONET);