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