blob: 4d66aac134835fb082044c26041c6f6039e3ba24 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#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>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020033#include <linux/udp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#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>
David S. Miller1d181832006-03-28 00:01:55 -080044#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#include <asm/uaccess.h>
47#include <asm/system.h>
48
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080049static const struct proto_ops econet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050static struct hlist_head econet_sklist;
51static DEFINE_RWLOCK(econet_lock);
David S. Miller1d181832006-03-28 00:01:55 -080052static DEFINE_MUTEX(econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
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. */
56static struct net_device *net2dev_map[256];
57
58#define EC_PORT_IP 0xd2
59
60#ifdef CONFIG_ECONET_AUNUDP
YOSHIFUJI Hideakica403302006-01-04 13:56:08 -080061static DEFINE_SPINLOCK(aun_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062static struct socket *udpsock;
63#define AUN_PORT 0x8000
64
65
66struct 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
75static unsigned long aun_seq;
76
77/* Queue of packets waiting to be transmitted. */
78static struct sk_buff_head aun_queue;
79static struct timer_list ab_cleanup_timer;
80
81#endif /* CONFIG_ECONET_AUNUDP */
82
83/* Per-packet information */
84struct 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
99static 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
106static 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
118static 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
David S. Miller1d181832006-03-28 00:01:55 -0800128 mutex_lock(&econet_mutex);
129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 /*
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;
Patrick McHardya61bbcf2005-08-14 17:24:31 -0700166 skb_get_timestamp(skb, &sk->sk_stamp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
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
177out_free:
178 skb_free_datagram(sk, skb);
179out:
David S. Miller1d181832006-03-28 00:01:55 -0800180 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 return err;
182}
183
184/*
185 * Bind an Econet socket.
186 */
187
188static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
189{
190 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
David S. Miller1d181832006-03-28 00:01:55 -0800191 struct sock *sk;
192 struct econet_sock *eo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
194 /*
195 * Check legality
196 */
197
198 if (addr_len < sizeof(struct sockaddr_ec) ||
199 sec->sec_family != AF_ECONET)
200 return -EINVAL;
201
David S. Miller1d181832006-03-28 00:01:55 -0800202 mutex_lock(&econet_mutex);
203
204 sk = sock->sk;
205 eo = ec_sk(sk);
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 eo->cb = sec->cb;
208 eo->port = sec->port;
209 eo->station = sec->addr.station;
210 eo->net = sec->addr.net;
211
David S. Miller1d181832006-03-28 00:01:55 -0800212 mutex_unlock(&econet_mutex);
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 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
222static 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
252static 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
264static 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
David S. Miller1d181832006-03-28 00:01:55 -0800298 mutex_lock(&econet_mutex);
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 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 {
David S. Miller1d181832006-03-28 00:01:55 -0800308 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
309 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return -EINVAL;
David S. Miller1d181832006-03-28 00:01:55 -0800311 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 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 */
David S. Miller1d181832006-03-28 00:01:55 -0800322 if (dev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 dev = net2dev_map[0];
324 /* No interfaces at all? */
David S. Miller1d181832006-03-28 00:01:55 -0800325 if (dev == NULL) {
326 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 return -ENETDOWN;
David S. Miller1d181832006-03-28 00:01:55 -0800328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
330
David S. Miller1d181832006-03-28 00:01:55 -0800331 if (len + 15 > dev->mtu) {
332 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return -EMSGSIZE;
David S. Miller1d181832006-03-28 00:01:55 -0800334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335
David S. Miller1d181832006-03-28 00:01:55 -0800336 if (dev->type == ARPHRD_ECONET) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 /* 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);
David S. Miller1d181832006-03-28 00:01:55 -0800394 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 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
David S. Miller1d181832006-03-28 00:01:55 -0800405 mutex_unlock(&econet_mutex);
406
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return err;
408 }
409
410#ifdef CONFIG_ECONET_AUNUDP
411 /* AUN virtual Econet. */
412
David S. Miller1d181832006-03-28 00:01:55 -0800413 if (udpsock == NULL) {
414 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 return -ENETDOWN; /* No socket - can't send */
David S. Miller1d181832006-03-28 00:01:55 -0800416 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
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();
Herbert Xue5ed6392005-10-03 14:35:55 -0700432 idev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 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. */
David S. Miller1d181832006-03-28 00:01:55 -0800463 if (!access_ok(VERIFY_READ, base, len)) {
464 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 return -EFAULT;
David S. Miller1d181832006-03-28 00:01:55 -0800466 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 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,
David S. Miller1d181832006-03-28 00:01:55 -0800474 msg->msg_flags & MSG_DONTWAIT,
475 &err)) == NULL) {
476 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 return err;
David S. Miller1d181832006-03-28 00:01:55 -0800478 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479
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
David S. Miller1d181832006-03-28 00:01:55 -0800505 mutex_unlock(&econet_mutex);
506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return err;
508}
509
510/*
511 * Look up the address of a socket.
512 */
513
514static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
515 int *uaddr_len, int peer)
516{
David S. Miller1d181832006-03-28 00:01:55 -0800517 struct sock *sk;
518 struct econet_sock *eo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
520
521 if (peer)
522 return -EOPNOTSUPP;
523
David S. Miller1d181832006-03-28 00:01:55 -0800524 mutex_lock(&econet_mutex);
525
526 sk = sock->sk;
527 eo = ec_sk(sk);
528
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 sec->sec_family = AF_ECONET;
530 sec->port = eo->port;
531 sec->addr.station = eo->station;
532 sec->addr.net = eo->net;
533
David S. Miller1d181832006-03-28 00:01:55 -0800534 mutex_unlock(&econet_mutex);
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 *uaddr_len = sizeof(*sec);
537 return 0;
538}
539
540static 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
559static int econet_release(struct socket *sock)
560{
David S. Miller1d181832006-03-28 00:01:55 -0800561 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562
David S. Miller1d181832006-03-28 00:01:55 -0800563 mutex_lock(&econet_mutex);
564
565 sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (!sk)
David S. Miller1d181832006-03-28 00:01:55 -0800567 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
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);
David S. Miller1d181832006-03-28 00:01:55 -0800591
592 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 }
594
595 sk_free(sk);
David S. Miller1d181832006-03-28 00:01:55 -0800596
597out_unlock:
598 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 return 0;
600}
601
602static 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
612static 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);
640out:
641 return err;
642}
643
644/*
645 * Handle Econet specific ioctls
646 */
647
648static 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;
David S. Miller1d181832006-03-28 00:01:55 -0800654 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
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
David S. Miller1d181832006-03-28 00:01:55 -0800668 mutex_lock(&econet_mutex);
669
670 err = 0;
671 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 case SIOCSIFADDR:
673 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800674 if (edev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 /* Magic up a new one. */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700676 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 if (edev == NULL) {
David S. Miller1d181832006-03-28 00:01:55 -0800678 err = -ENOMEM;
679 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 dev->ec_ptr = edev;
David S. Miller1d181832006-03-28 00:01:55 -0800682 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 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;
David S. Miller1d181832006-03-28 00:01:55 -0800689 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 case SIOCGIFADDR:
692 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800693 if (edev == NULL) {
694 err = -ENODEV;
695 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 }
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)))
David S. Miller1d181832006-03-28 00:01:55 -0800703 err = -EFAULT;
704 break;
705
706 default:
707 err = -EINVAL;
708 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 }
710
David S. Miller1d181832006-03-28 00:01:55 -0800711 mutex_unlock(&econet_mutex);
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800714
715 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
718/*
719 * Handle generic ioctls
720 */
721
722static 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:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -0800737 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739 /*NOTREACHED*/
740 return 0;
741}
742
743static struct net_proto_family econet_family_ops = {
744 .family = PF_ECONET,
745 .create = econet_create,
746 .owner = THIS_MODULE,
747};
748
David S. Miller1d181832006-03-28 00:01:55 -0800749static const struct proto_ops econet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 .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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
771/*
772 * Find the listening socket, if any, for the given data.
773 */
774
775static 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;
789found:
790 return sk;
791}
792
793/*
794 * Queue a received packet for a socket.
795 */
796
797static 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
821static 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
847static 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
883bad:
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
894static 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
915foundit:
916 tx_result(skb->sk, eb->cookie, result);
David S. Miller8728b832005-08-09 19:25:21 -0700917 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 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
927static 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
980static 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);
David S. Miller8728b832005-08-09 19:25:21 -0700995 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 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
1005static 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
1044release:
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
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001057static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058{
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
1095drop:
1096 kfree_skb(skb);
1097 return NET_RX_DROP;
1098}
1099
1100static struct packet_type econet_packet_type = {
1101 .type = __constant_htons(ETH_P_ECONET),
1102 .func = econet_rcv,
1103};
1104
1105static void econet_hw_initialise(void)
1106{
1107 dev_add_pack(&econet_packet_type);
1108}
1109
1110#endif
1111
1112static 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
1135static struct notifier_block econet_netdev_notifier = {
1136 .notifier_call =econet_notifier,
1137};
1138
1139static 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
1151static 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);
1166out:
1167 return err;
1168}
1169
1170module_init(econet_proto_init);
1171module_exit(econet_proto_exit);
1172
1173MODULE_LICENSE("GPL");
1174MODULE_ALIAS_NETPROTO(PF_ECONET);