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 <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
45 #include <asm/uaccess.h>
46 #include <asm/system.h>
47
48 static struct proto_ops econet_ops;
49 static struct hlist_head econet_sklist;
50 static DEFINE_RWLOCK(econet_lock);
51
52 /* Since there are only 256 possible network numbers (or fewer, depends
53 how you count) it makes sense to use a simple lookup table. */
54 static struct net_device *net2dev_map[256];
55
56 #define EC_PORT_IP 0xd2
57
58 #ifdef CONFIG_ECONET_AUNUDP
59 static spinlock_t aun_queue_lock;
60 static struct socket *udpsock;
61 #define AUN_PORT 0x8000
62
63
64 struct aunhdr
65 {
66 unsigned char code; /* AUN magic protocol byte */
67 unsigned char port;
68 unsigned char cb;
69 unsigned char pad;
70 unsigned long handle;
71 };
72
73 static unsigned long aun_seq;
74
75 /* Queue of packets waiting to be transmitted. */
76 static struct sk_buff_head aun_queue;
77 static struct timer_list ab_cleanup_timer;
78
79 #endif /* CONFIG_ECONET_AUNUDP */
80
81 /* Per-packet information */
82 struct ec_cb
83 {
84 struct sockaddr_ec sec;
85 unsigned long cookie; /* Supplied by user. */
86 #ifdef CONFIG_ECONET_AUNUDP
87 int done;
88 unsigned long seq; /* Sequencing */
89 unsigned long timeout; /* Timeout */
90 unsigned long start; /* jiffies */
91 #endif
92 #ifdef CONFIG_ECONET_NATIVE
93 void (*sent)(struct sk_buff *, int result);
94 #endif
95 };
96
97 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
98 {
99 write_lock_bh(&econet_lock);
100 sk_del_node_init(sk);
101 write_unlock_bh(&econet_lock);
102 }
103
104 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
105 {
106 write_lock_bh(&econet_lock);
107 sk_add_node(sk, list);
108 write_unlock_bh(&econet_lock);
109 }
110
111 /*
112 * Pull a packet from our receive queue and hand it to the user.
113 * If necessary we block.
114 */
115
116 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
117 struct msghdr *msg, size_t len, int flags)
118 {
119 struct sock *sk = sock->sk;
120 struct sk_buff *skb;
121 size_t copied;
122 int err;
123
124 msg->msg_namelen = sizeof(struct sockaddr_ec);
125
126 /*
127 * Call the generic datagram receiver. This handles all sorts
128 * of horrible races and re-entrancy so we can forget about it
129 * in the protocol layers.
130 *
131 * Now it will return ENETDOWN, if device have just gone down,
132 * but then it will block.
133 */
134
135 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
136
137 /*
138 * An error occurred so return it. Because skb_recv_datagram()
139 * handles the blocking we don't see and worry about blocking
140 * retries.
141 */
142
143 if(skb==NULL)
144 goto out;
145
146 /*
147 * You lose any data beyond the buffer you gave. If it worries a
148 * user program they can ask the device for its MTU anyway.
149 */
150
151 copied = skb->len;
152 if (copied > len)
153 {
154 copied=len;
155 msg->msg_flags|=MSG_TRUNC;
156 }
157
158 /* We can't use skb_copy_datagram here */
159 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
160 if (err)
161 goto out_free;
162 sk->sk_stamp = skb->stamp;
163
164 if (msg->msg_name)
165 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
166
167 /*
168 * Free or return the buffer as appropriate. Again this
169 * hides all the races and re-entrancy issues from us.
170 */
171 err = copied;
172
173 out_free:
174 skb_free_datagram(sk, skb);
175 out:
176 return err;
177 }
178
179 /*
180 * Bind an Econet socket.
181 */
182
183 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
184 {
185 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
186 struct sock *sk=sock->sk;
187 struct econet_opt *eo = ec_sk(sk);
188
189 /*
190 * Check legality
191 */
192
193 if (addr_len < sizeof(struct sockaddr_ec) ||
194 sec->sec_family != AF_ECONET)
195 return -EINVAL;
196
197 eo->cb = sec->cb;
198 eo->port = sec->port;
199 eo->station = sec->addr.station;
200 eo->net = sec->addr.net;
201
202 return 0;
203 }
204
205 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
206 /*
207 * Queue a transmit result for the user to be told about.
208 */
209
210 static void tx_result(struct sock *sk, unsigned long cookie, int result)
211 {
212 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
213 struct ec_cb *eb;
214 struct sockaddr_ec *sec;
215
216 if (skb == NULL)
217 {
218 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
219 return;
220 }
221
222 eb = (struct ec_cb *)&skb->cb;
223 sec = (struct sockaddr_ec *)&eb->sec;
224 memset(sec, 0, sizeof(struct sockaddr_ec));
225 sec->cookie = cookie;
226 sec->type = ECTYPE_TRANSMIT_STATUS | result;
227 sec->sec_family = AF_ECONET;
228
229 if (sock_queue_rcv_skb(sk, skb) < 0)
230 kfree_skb(skb);
231 }
232 #endif
233
234 #ifdef CONFIG_ECONET_NATIVE
235 /*
236 * Called by the Econet hardware driver when a packet transmit
237 * has completed. Tell the user.
238 */
239
240 static void ec_tx_done(struct sk_buff *skb, int result)
241 {
242 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
243 tx_result(skb->sk, eb->cookie, result);
244 }
245 #endif
246
247 /*
248 * Send a packet. We have to work out which device it's going out on
249 * and hence whether to use real Econet or the UDP emulation.
250 */
251
252 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
253 struct msghdr *msg, size_t len)
254 {
255 struct sock *sk = sock->sk;
256 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
257 struct net_device *dev;
258 struct ec_addr addr;
259 int err;
260 unsigned char port, cb;
261 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
262 struct sk_buff *skb;
263 struct ec_cb *eb;
264 #endif
265 #ifdef CONFIG_ECONET_AUNUDP
266 struct msghdr udpmsg;
267 struct iovec iov[msg->msg_iovlen+1];
268 struct aunhdr ah;
269 struct sockaddr_in udpdest;
270 __kernel_size_t size;
271 int i;
272 mm_segment_t oldfs;
273 #endif
274
275 /*
276 * Check the flags.
277 */
278
279 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
280 return -EINVAL;
281
282 /*
283 * Get and verify the address.
284 */
285
286 if (saddr == NULL) {
287 struct econet_opt *eo = ec_sk(sk);
288
289 addr.station = eo->station;
290 addr.net = eo->net;
291 port = eo->port;
292 cb = eo->cb;
293 } else {
294 if (msg->msg_namelen < sizeof(struct sockaddr_ec))
295 return -EINVAL;
296 addr.station = saddr->addr.station;
297 addr.net = saddr->addr.net;
298 port = saddr->port;
299 cb = saddr->cb;
300 }
301
302 /* Look for a device with the right network number. */
303 dev = net2dev_map[addr.net];
304
305 /* If not directly reachable, use some default */
306 if (dev == NULL)
307 {
308 dev = net2dev_map[0];
309 /* No interfaces at all? */
310 if (dev == NULL)
311 return -ENETDOWN;
312 }
313
314 if (len + 15 > dev->mtu)
315 return -EMSGSIZE;
316
317 if (dev->type == ARPHRD_ECONET)
318 {
319 /* Real hardware Econet. We're not worthy etc. */
320 #ifdef CONFIG_ECONET_NATIVE
321 unsigned short proto = 0;
322
323 dev_hold(dev);
324
325 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
326 msg->msg_flags & MSG_DONTWAIT, &err);
327 if (skb==NULL)
328 goto out_unlock;
329
330 skb_reserve(skb, LL_RESERVED_SPACE(dev));
331 skb->nh.raw = skb->data;
332
333 eb = (struct ec_cb *)&skb->cb;
334
335 /* BUG: saddr may be NULL */
336 eb->cookie = saddr->cookie;
337 eb->sec = *saddr;
338 eb->sent = ec_tx_done;
339
340 if (dev->hard_header) {
341 int res;
342 struct ec_framehdr *fh;
343 err = -EINVAL;
344 res = dev->hard_header(skb, dev, ntohs(proto),
345 &addr, NULL, len);
346 /* Poke in our control byte and
347 port number. Hack, hack. */
348 fh = (struct ec_framehdr *)(skb->data);
349 fh->cb = cb;
350 fh->port = port;
351 if (sock->type != SOCK_DGRAM) {
352 skb->tail = skb->data;
353 skb->len = 0;
354 } else if (res < 0)
355 goto out_free;
356 }
357
358 /* Copy the data. Returns -EFAULT on error */
359 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
360 skb->protocol = proto;
361 skb->dev = dev;
362 skb->priority = sk->sk_priority;
363 if (err)
364 goto out_free;
365
366 err = -ENETDOWN;
367 if (!(dev->flags & IFF_UP))
368 goto out_free;
369
370 /*
371 * Now send it
372 */
373
374 dev_queue_xmit(skb);
375 dev_put(dev);
376 return(len);
377
378 out_free:
379 kfree_skb(skb);
380 out_unlock:
381 if (dev)
382 dev_put(dev);
383 #else
384 err = -EPROTOTYPE;
385 #endif
386 return err;
387 }
388
389 #ifdef CONFIG_ECONET_AUNUDP
390 /* AUN virtual Econet. */
391
392 if (udpsock == NULL)
393 return -ENETDOWN; /* No socket - can't send */
394
395 /* Make up a UDP datagram and hand it off to some higher intellect. */
396
397 memset(&udpdest, 0, sizeof(udpdest));
398 udpdest.sin_family = AF_INET;
399 udpdest.sin_port = htons(AUN_PORT);
400
401 /* At the moment we use the stupid Acorn scheme of Econet address
402 y.x maps to IP a.b.c.x. This should be replaced with something
403 more flexible and more aware of subnet masks. */
404 {
405 struct in_device *idev;
406 unsigned long network = 0;
407
408 rcu_read_lock();
409 idev = __in_dev_get(dev);
410 if (idev) {
411 if (idev->ifa_list)
412 network = ntohl(idev->ifa_list->ifa_address) &
413 0xffffff00; /* !!! */
414 }
415 rcu_read_unlock();
416 udpdest.sin_addr.s_addr = htonl(network | addr.station);
417 }
418
419 ah.port = port;
420 ah.cb = cb & 0x7f;
421 ah.code = 2; /* magic */
422 ah.pad = 0;
423
424 /* tack our header on the front of the iovec */
425 size = sizeof(struct aunhdr);
426 /*
427 * XXX: that is b0rken. We can't mix userland and kernel pointers
428 * in iovec, since on a lot of platforms copy_from_user() will
429 * *not* work with the kernel and userland ones at the same time,
430 * regardless of what we do with set_fs(). And we are talking about
431 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
432 * apply. Any suggestions on fixing that code? -- AV
433 */
434 iov[0].iov_base = (void *)&ah;
435 iov[0].iov_len = size;
436 for (i = 0; i < msg->msg_iovlen; i++) {
437 void __user *base = msg->msg_iov[i].iov_base;
438 size_t len = msg->msg_iov[i].iov_len;
439 /* Check it now since we switch to KERNEL_DS later. */
440 if ((err = verify_area(VERIFY_READ, base, len)) < 0)
441 return err;
442 iov[i+1].iov_base = base;
443 iov[i+1].iov_len = len;
444 size += len;
445 }
446
447 /* Get a skbuff (no data, just holds our cb information) */
448 if ((skb = sock_alloc_send_skb(sk, 0,
449 msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
450 return err;
451
452 eb = (struct ec_cb *)&skb->cb;
453
454 eb->cookie = saddr->cookie;
455 eb->timeout = (5*HZ);
456 eb->start = jiffies;
457 ah.handle = aun_seq;
458 eb->seq = (aun_seq++);
459 eb->sec = *saddr;
460
461 skb_queue_tail(&aun_queue, skb);
462
463 udpmsg.msg_name = (void *)&udpdest;
464 udpmsg.msg_namelen = sizeof(udpdest);
465 udpmsg.msg_iov = &iov[0];
466 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
467 udpmsg.msg_control = NULL;
468 udpmsg.msg_controllen = 0;
469 udpmsg.msg_flags=0;
470
471 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
472 err = sock_sendmsg(udpsock, &udpmsg, size);
473 set_fs(oldfs);
474 #else
475 err = -EPROTOTYPE;
476 #endif
477 return err;
478 }
479
480 /*
481 * Look up the address of a socket.
482 */
483
484 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
485 int *uaddr_len, int peer)
486 {
487 struct sock *sk = sock->sk;
488 struct econet_opt *eo = ec_sk(sk);
489 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
490
491 if (peer)
492 return -EOPNOTSUPP;
493
494 sec->sec_family = AF_ECONET;
495 sec->port = eo->port;
496 sec->addr.station = eo->station;
497 sec->addr.net = eo->net;
498
499 *uaddr_len = sizeof(*sec);
500 return 0;
501 }
502
503 static void econet_destroy_timer(unsigned long data)
504 {
505 struct sock *sk=(struct sock *)data;
506
507 if (!atomic_read(&sk->sk_wmem_alloc) &&
508 !atomic_read(&sk->sk_rmem_alloc)) {
509 sk_free(sk);
510 return;
511 }
512
513 sk->sk_timer.expires = jiffies + 10 * HZ;
514 add_timer(&sk->sk_timer);
515 printk(KERN_DEBUG "econet socket destroy delayed\n");
516 }
517
518 /*
519 * Close an econet socket.
520 */
521
522 static int econet_release(struct socket *sock)
523 {
524 struct sock *sk = sock->sk;
525
526 if (!sk)
527 return 0;
528
529 econet_remove_socket(&econet_sklist, sk);
530
531 /*
532 * Now the socket is dead. No more input will appear.
533 */
534
535 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
536
537 sock->sk = NULL;
538 sk->sk_socket = NULL;
539 sock_set_flag(sk, SOCK_DEAD);
540
541 /* Purge queues */
542
543 skb_queue_purge(&sk->sk_receive_queue);
544
545 if (atomic_read(&sk->sk_rmem_alloc) ||
546 atomic_read(&sk->sk_wmem_alloc)) {
547 sk->sk_timer.data = (unsigned long)sk;
548 sk->sk_timer.expires = jiffies + HZ;
549 sk->sk_timer.function = econet_destroy_timer;
550 add_timer(&sk->sk_timer);
551 return 0;
552 }
553
554 sk_free(sk);
555 return 0;
556 }
557
558 /*
559 * Create an Econet socket
560 */
561
562 static int econet_create(struct socket *sock, int protocol)
563 {
564 struct sock *sk;
565 struct econet_opt *eo;
566 int err;
567
568 /* Econet only provides datagram services. */
569 if (sock->type != SOCK_DGRAM)
570 return -ESOCKTNOSUPPORT;
571
572 sock->state = SS_UNCONNECTED;
573
574 err = -ENOBUFS;
575 sk = sk_alloc(PF_ECONET, GFP_KERNEL, 1, NULL);
576 if (sk == NULL)
577 goto out;
578
579 sk->sk_reuse = 1;
580 sock->ops = &econet_ops;
581 sock_init_data(sock,sk);
582 sk_set_owner(sk, THIS_MODULE);
583
584 eo = sk->sk_protinfo = kmalloc(sizeof(*eo), GFP_KERNEL);
585 if (!eo)
586 goto out_free;
587 memset(eo, 0, sizeof(*eo));
588 sk->sk_zapped = 0;
589 sk->sk_family = PF_ECONET;
590 eo->num = protocol;
591
592 econet_insert_socket(&econet_sklist, sk);
593 return(0);
594
595 out_free:
596 sk_free(sk);
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 dev_ioctl(cmd, argp);
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 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_opt *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);
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);
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)
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 }
1105
1106 static int __init econet_proto_init(void)
1107 {
1108 sock_register(&econet_family_ops);
1109 #ifdef CONFIG_ECONET_AUNUDP
1110 spin_lock_init(&aun_queue_lock);
1111 aun_udp_initialise();
1112 #endif
1113 #ifdef CONFIG_ECONET_NATIVE
1114 econet_hw_initialise();
1115 #endif
1116 register_netdevice_notifier(&econet_netdev_notifier);
1117 return 0;
1118 }
1119
1120 module_init(econet_proto_init);
1121 module_exit(econet_proto_exit);
1122
1123 MODULE_LICENSE("GPL");
1124 MODULE_ALIAS_NETPROTO(PF_ECONET);
1125
|
This page was automatically generated by the
LXR engine.
|