[PATCH] Add retain_initrd boot option
[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 #include <linux/module.h>
13
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/string.h>
18 #include <linux/mm.h>
19 #include <linux/socket.h>
20 #include <linux/sockios.h>
21 #include <linux/in.h>
22 #include <linux/errno.h>
23 #include <linux/interrupt.h>
24 #include <linux/if_ether.h>
25 #include <linux/netdevice.h>
26 #include <linux/inetdevice.h>
27 #include <linux/route.h>
28 #include <linux/inet.h>
29 #include <linux/etherdevice.h>
30 #include <linux/if_arp.h>
31 #include <linux/wireless.h>
32 #include <linux/skbuff.h>
33 #include <linux/udp.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_RWLOCK(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         write_lock_bh(&econet_lock);
102         sk_del_node_init(sk);
103         write_unlock_bh(&econet_lock);
104 }
105
106 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
107 {
108         write_lock_bh(&econet_lock);
109         sk_add_node(sk, list);
110         write_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         skb_get_timestamp(skb, &sk->sk_stamp);
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
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->nh.raw = skb->data;
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                 if (dev->hard_header) {
359                         int res;
360                         struct ec_framehdr *fh;
361                         err = -EINVAL;
362                         res = dev->hard_header(skb, dev, ntohs(proto), 
363                                                &addr, NULL, len);
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->tail = skb->data;
371                                 skb->len = 0;
372                         } else if (res < 0)
373                                 goto out_free;
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 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, len)) {
464                         mutex_unlock(&econet_mutex);
465                         return -EFAULT;
466                 }
467                 iov[i+1].iov_base = base;
468                 iov[i+1].iov_len = len;
469                 size += 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         mutex_lock(&econet_mutex);
525
526         sk = sock->sk;
527         eo = ec_sk(sk);
528
529         sec->sec_family   = AF_ECONET;
530         sec->port         = eo->port;
531         sec->addr.station = eo->station;
532         sec->addr.net     = eo->net;
533
534         mutex_unlock(&econet_mutex);
535
536         *uaddr_len = sizeof(*sec);
537         return 0;
538 }
539
540 static void econet_destroy_timer(unsigned long data)
541 {
542         struct sock *sk=(struct sock *)data;
543
544         if (!atomic_read(&sk->sk_wmem_alloc) &&
545             !atomic_read(&sk->sk_rmem_alloc)) {
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->sk = NULL;
578         sk->sk_socket = NULL;
579         sock_set_flag(sk, SOCK_DEAD);
580
581         /* Purge queues */
582
583         skb_queue_purge(&sk->sk_receive_queue);
584
585         if (atomic_read(&sk->sk_rmem_alloc) ||
586             atomic_read(&sk->sk_wmem_alloc)) {
587                 sk->sk_timer.data     = (unsigned long)sk;
588                 sk->sk_timer.expires  = jiffies + HZ;
589                 sk->sk_timer.function = econet_destroy_timer;
590                 add_timer(&sk->sk_timer);
591
592                 goto out_unlock;
593         }
594
595         sk_free(sk);
596
597 out_unlock:
598         mutex_unlock(&econet_mutex);
599         return 0;
600 }
601
602 static struct proto econet_proto = {
603         .name     = "ECONET",
604         .owner    = THIS_MODULE,
605         .obj_size = sizeof(struct econet_sock),
606 };
607
608 /*
609  *      Create an Econet socket
610  */
611
612 static int econet_create(struct socket *sock, int protocol)
613 {
614         struct sock *sk;
615         struct econet_sock *eo;
616         int err;
617
618         /* Econet only provides datagram services. */
619         if (sock->type != SOCK_DGRAM)
620                 return -ESOCKTNOSUPPORT;
621
622         sock->state = SS_UNCONNECTED;
623
624         err = -ENOBUFS;
625         sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
626         if (sk == NULL)
627                 goto out;
628
629         sk->sk_reuse = 1;
630         sock->ops = &econet_ops;
631         sock_init_data(sock, sk);
632
633         eo = ec_sk(sk);
634         sock_reset_flag(sk, SOCK_ZAPPED);
635         sk->sk_family = PF_ECONET;
636         eo->num = protocol;
637
638         econet_insert_socket(&econet_sklist, sk);
639         return(0);
640 out:
641         return err;
642 }
643
644 /*
645  *      Handle Econet specific ioctls
646  */
647
648 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
649 {
650         struct ifreq ifr;
651         struct ec_device *edev;
652         struct net_device *dev;
653         struct sockaddr_ec *sec;
654         int err;
655
656         /*
657          *      Fetch the caller's info block into kernel space
658          */
659
660         if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
661                 return -EFAULT;
662
663         if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL) 
664                 return -ENODEV;
665
666         sec = (struct sockaddr_ec *)&ifr.ifr_addr;
667
668         mutex_lock(&econet_mutex);
669
670         err = 0;
671         switch (cmd) {
672         case SIOCSIFADDR:
673                 edev = dev->ec_ptr;
674                 if (edev == NULL) {
675                         /* Magic up a new one. */
676                         edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
677                         if (edev == NULL) {
678                                 err = -ENOMEM;
679                                 break;
680                         }
681                         dev->ec_ptr = edev;
682                 } else
683                         net2dev_map[edev->net] = NULL;
684                 edev->station = sec->addr.station;
685                 edev->net = sec->addr.net;
686                 net2dev_map[sec->addr.net] = dev;
687                 if (!net2dev_map[0])
688                         net2dev_map[0] = dev;
689                 break;
690
691         case SIOCGIFADDR:
692                 edev = dev->ec_ptr;
693                 if (edev == NULL) {
694                         err = -ENODEV;
695                         break;
696                 }
697                 memset(sec, 0, sizeof(struct sockaddr_ec));
698                 sec->addr.station = edev->station;
699                 sec->addr.net = edev->net;
700                 sec->sec_family = AF_ECONET;
701                 dev_put(dev);
702                 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
703                         err = -EFAULT;
704                 break;
705
706         default:
707                 err = -EINVAL;
708                 break;
709         }
710
711         mutex_unlock(&econet_mutex);
712
713         dev_put(dev);
714
715         return err;
716 }
717
718 /*
719  *      Handle generic ioctls
720  */
721
722 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
723 {
724         struct sock *sk = sock->sk;
725         void __user *argp = (void __user *)arg;
726
727         switch(cmd) {
728                 case SIOCGSTAMP:
729                         return sock_get_timestamp(sk, argp);
730
731                 case SIOCSIFADDR:
732                 case SIOCGIFADDR:
733                         return ec_dev_ioctl(sock, cmd, argp);
734                         break;
735
736                 default:
737                         return -ENOIOCTLCMD;
738         }
739         /*NOTREACHED*/
740         return 0;
741 }
742
743 static struct net_proto_family econet_family_ops = {
744         .family =       PF_ECONET,
745         .create =       econet_create,
746         .owner  =       THIS_MODULE,
747 };
748
749 static const struct proto_ops econet_ops = {
750         .family =       PF_ECONET,
751         .owner =        THIS_MODULE,
752         .release =      econet_release,
753         .bind =         econet_bind,
754         .connect =      sock_no_connect,
755         .socketpair =   sock_no_socketpair,
756         .accept =       sock_no_accept,
757         .getname =      econet_getname, 
758         .poll =         datagram_poll,
759         .ioctl =        econet_ioctl,
760         .listen =       sock_no_listen,
761         .shutdown =     sock_no_shutdown,
762         .setsockopt =   sock_no_setsockopt,
763         .getsockopt =   sock_no_getsockopt,
764         .sendmsg =      econet_sendmsg,
765         .recvmsg =      econet_recvmsg,
766         .mmap =         sock_no_mmap,
767         .sendpage =     sock_no_sendpage,
768 };
769
770 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
771 /*
772  *      Find the listening socket, if any, for the given data.
773  */
774
775 static struct sock *ec_listening_socket(unsigned char port, unsigned char
776                                  station, unsigned char net)
777 {
778         struct sock *sk;
779         struct hlist_node *node;
780
781         sk_for_each(sk, node, &econet_sklist) {
782                 struct econet_sock *opt = ec_sk(sk);
783                 if ((opt->port == port || opt->port == 0) && 
784                     (opt->station == station || opt->station == 0) &&
785                     (opt->net == net || opt->net == 0))
786                         goto found;
787         }
788         sk = NULL;
789 found:
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 = skb->nh.iph;
850         unsigned char stn = ntohl(ip->saddr) & 0xff;
851         struct sock *sk;
852         struct sk_buff *newskb;
853         struct ec_device *edev = skb->dev->ec_ptr;
854
855         if (! edev)
856                 goto bad;
857
858         if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
859                 goto bad;               /* Nobody wants it */
860
861         newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15, 
862                            GFP_ATOMIC);
863         if (newskb == NULL)
864         {
865                 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
866                 /* Send nack and hope sender tries again */
867                 goto bad;
868         }
869
870         memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1), 
871                len - sizeof(struct aunhdr));
872
873         if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
874         {
875                 /* Socket is bankrupt. */
876                 kfree_skb(newskb);
877                 goto bad;
878         }
879
880         aun_send_response(ip->saddr, ah->handle, 3, 0);
881         return;
882
883 bad:
884         aun_send_response(ip->saddr, ah->handle, 4, 0);
885 }
886
887 /*
888  *      Handle incoming AUN transmit acknowledgements.  If the sequence
889  *      number matches something in our backlog then kill it and tell
890  *      the user.  If the remote took too long to reply then we may have
891  *      dropped the packet already.
892  */
893
894 static void aun_tx_ack(unsigned long seq, int result)
895 {
896         struct sk_buff *skb;
897         unsigned long flags;
898         struct ec_cb *eb;
899
900         spin_lock_irqsave(&aun_queue_lock, flags);
901         skb = skb_peek(&aun_queue);
902         while (skb && skb != (struct sk_buff *)&aun_queue)
903         {
904                 struct sk_buff *newskb = skb->next;
905                 eb = (struct ec_cb *)&skb->cb;
906                 if (eb->seq == seq)
907                         goto foundit;
908
909                 skb = newskb;
910         }
911         spin_unlock_irqrestore(&aun_queue_lock, flags);
912         printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
913         return;
914
915 foundit:
916         tx_result(skb->sk, eb->cookie, result);
917         skb_unlink(skb, &aun_queue);
918         spin_unlock_irqrestore(&aun_queue_lock, flags);
919         kfree_skb(skb);
920 }
921
922 /*
923  *      Deal with received AUN frames - sort out what type of thing it is
924  *      and hand it to the right function.
925  */
926
927 static void aun_data_available(struct sock *sk, int slen)
928 {
929         int err;
930         struct sk_buff *skb;
931         unsigned char *data;
932         struct aunhdr *ah;
933         struct iphdr *ip;
934         size_t len;
935
936         while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
937                 if (err == -EAGAIN) {
938                         printk(KERN_ERR "AUN: no data available?!");
939                         return;
940                 }
941                 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
942         }
943
944         data = skb->h.raw + sizeof(struct udphdr);
945         ah = (struct aunhdr *)data;
946         len = skb->len - sizeof(struct udphdr);
947         ip = skb->nh.iph;
948
949         switch (ah->code)
950         {
951         case 2:
952                 aun_incoming(skb, ah, len);
953                 break;
954         case 3:
955                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
956                 break;
957         case 4:
958                 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
959                 break;
960 #if 0
961                 /* This isn't quite right yet. */
962         case 5:
963                 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
964                 break;
965 #endif
966         default:
967                 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
968         }
969
970         skb_free_datagram(sk, skb);
971 }
972
973 /*
974  *      Called by the timer to manage the AUN transmit queue.  If a packet
975  *      was sent to a dead or nonexistent host then we will never get an
976  *      acknowledgement back.  After a few seconds we need to spot this and
977  *      drop the packet.
978  */
979
980 static void ab_cleanup(unsigned long h)
981 {
982         struct sk_buff *skb;
983         unsigned long flags;
984
985         spin_lock_irqsave(&aun_queue_lock, flags);
986         skb = skb_peek(&aun_queue);
987         while (skb && skb != (struct sk_buff *)&aun_queue)
988         {
989                 struct sk_buff *newskb = skb->next;
990                 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
991                 if ((jiffies - eb->start) > eb->timeout)
992                 {
993                         tx_result(skb->sk, eb->cookie, 
994                                   ECTYPE_TRANSMIT_NOT_PRESENT);
995                         skb_unlink(skb, &aun_queue);
996                         kfree_skb(skb);
997                 }
998                 skb = newskb;
999         }
1000         spin_unlock_irqrestore(&aun_queue_lock, flags);
1001
1002         mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1003 }
1004
1005 static int __init aun_udp_initialise(void)
1006 {
1007         int error;
1008         struct sockaddr_in sin;
1009
1010         skb_queue_head_init(&aun_queue);
1011         spin_lock_init(&aun_queue_lock);
1012         init_timer(&ab_cleanup_timer);
1013         ab_cleanup_timer.expires = jiffies + (HZ*2);
1014         ab_cleanup_timer.function = ab_cleanup;
1015         add_timer(&ab_cleanup_timer);
1016
1017         memset(&sin, 0, sizeof(sin));
1018         sin.sin_port = htons(AUN_PORT);
1019
1020         /* We can count ourselves lucky Acorn machines are too dim to
1021            speak IPv6. :-) */
1022         if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1023         {
1024                 printk("AUN: socket error %d\n", -error);
1025                 return error;
1026         }
1027         
1028         udpsock->sk->sk_reuse = 1;
1029         udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1030                                                     from interrupts */
1031         
1032         error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1033                                 sizeof(sin));
1034         if (error < 0)
1035         {
1036                 printk("AUN: bind error %d\n", -error);
1037                 goto release;
1038         }
1039
1040         udpsock->sk->sk_data_ready = aun_data_available;
1041
1042         return 0;
1043
1044 release:
1045         sock_release(udpsock);
1046         udpsock = NULL;
1047         return error;
1048 }
1049 #endif
1050
1051 #ifdef CONFIG_ECONET_NATIVE
1052
1053 /*
1054  *      Receive an Econet frame from a device.
1055  */
1056
1057 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1058 {
1059         struct ec_framehdr *hdr;
1060         struct sock *sk;
1061         struct ec_device *edev = dev->ec_ptr;
1062
1063         if (skb->pkt_type == PACKET_OTHERHOST)
1064                 goto drop;
1065
1066         if (!edev)
1067                 goto drop;
1068
1069         if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1070                 return NET_RX_DROP;
1071
1072         if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1073                 goto drop;
1074
1075         hdr = (struct ec_framehdr *) skb->data;
1076
1077         /* First check for encapsulated IP */
1078         if (hdr->port == EC_PORT_IP) {
1079                 skb->protocol = htons(ETH_P_IP);
1080                 skb_pull(skb, sizeof(struct ec_framehdr));
1081                 netif_rx(skb);
1082                 return 0;
1083         }
1084
1085         sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1086         if (!sk)
1087                 goto drop;
1088
1089         if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1090                             hdr->port))
1091                 goto drop;
1092
1093         return 0;
1094
1095 drop:
1096         kfree_skb(skb);
1097         return NET_RX_DROP;
1098 }
1099
1100 static struct packet_type econet_packet_type = {
1101         .type =         __constant_htons(ETH_P_ECONET),
1102         .func =         econet_rcv,
1103 };
1104
1105 static void econet_hw_initialise(void)
1106 {
1107         dev_add_pack(&econet_packet_type);
1108 }
1109
1110 #endif
1111
1112 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1113 {
1114         struct net_device *dev = (struct net_device *)data;
1115         struct ec_device *edev;
1116
1117         switch (msg) {
1118         case NETDEV_UNREGISTER:
1119                 /* A device has gone down - kill any data we hold for it. */
1120                 edev = dev->ec_ptr;
1121                 if (edev)
1122                 {
1123                         if (net2dev_map[0] == dev)
1124                                 net2dev_map[0] = NULL;
1125                         net2dev_map[edev->net] = NULL;
1126                         kfree(edev);
1127                         dev->ec_ptr = NULL;
1128                 }
1129                 break;
1130         }
1131
1132         return NOTIFY_DONE;
1133 }
1134
1135 static struct notifier_block econet_netdev_notifier = {
1136         .notifier_call =econet_notifier,
1137 };
1138
1139 static void __exit econet_proto_exit(void)
1140 {
1141 #ifdef CONFIG_ECONET_AUNUDP
1142         del_timer(&ab_cleanup_timer);
1143         if (udpsock)
1144                 sock_release(udpsock);
1145 #endif
1146         unregister_netdevice_notifier(&econet_netdev_notifier);
1147         sock_unregister(econet_family_ops.family);
1148         proto_unregister(&econet_proto);
1149 }
1150
1151 static int __init econet_proto_init(void)
1152 {
1153         int err = proto_register(&econet_proto, 0);
1154
1155         if (err != 0)
1156                 goto out;
1157         sock_register(&econet_family_ops);
1158 #ifdef CONFIG_ECONET_AUNUDP
1159         spin_lock_init(&aun_queue_lock);
1160         aun_udp_initialise();
1161 #endif
1162 #ifdef CONFIG_ECONET_NATIVE
1163         econet_hw_initialise();
1164 #endif
1165         register_netdevice_notifier(&econet_netdev_notifier);
1166 out:
1167         return err;
1168 }
1169
1170 module_init(econet_proto_init);
1171 module_exit(econet_proto_exit);
1172
1173 MODULE_LICENSE("GPL");
1174 MODULE_ALIAS_NETPROTO(PF_ECONET);