blob: b5524f32ac2d5128aa0f3513c3fb45e3f52fe215 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/string.h>
17#include <linux/mm.h>
18#include <linux/socket.h>
19#include <linux/sockios.h>
20#include <linux/in.h>
21#include <linux/errno.h>
22#include <linux/interrupt.h>
23#include <linux/if_ether.h>
24#include <linux/netdevice.h>
25#include <linux/inetdevice.h>
26#include <linux/route.h>
27#include <linux/inet.h>
28#include <linux/etherdevice.h>
29#include <linux/if_arp.h>
30#include <linux/wireless.h>
31#include <linux/skbuff.h>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020032#include <linux/udp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <net/sock.h>
34#include <net/inet_common.h>
35#include <linux/stat.h>
36#include <linux/init.h>
37#include <linux/if_ec.h>
38#include <net/udp.h>
39#include <net/ip.h>
40#include <linux/spinlock.h>
41#include <linux/rcupdate.h>
42#include <linux/bitops.h>
David S. Miller1d181832006-03-28 00:01:55 -080043#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#include <asm/uaccess.h>
46#include <asm/system.h>
47
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080048static const struct proto_ops econet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049static struct hlist_head econet_sklist;
50static DEFINE_RWLOCK(econet_lock);
David S. Miller1d181832006-03-28 00:01:55 -080051static DEFINE_MUTEX(econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
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. */
55static struct net_device *net2dev_map[256];
56
57#define EC_PORT_IP 0xd2
58
59#ifdef CONFIG_ECONET_AUNUDP
YOSHIFUJI Hideakica403302006-01-04 13:56:08 -080060static DEFINE_SPINLOCK(aun_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static struct socket *udpsock;
62#define AUN_PORT 0x8000
63
64
65struct 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
74static unsigned long aun_seq;
75
76/* Queue of packets waiting to be transmitted. */
77static struct sk_buff_head aun_queue;
78static struct timer_list ab_cleanup_timer;
79
80#endif /* CONFIG_ECONET_AUNUDP */
81
82/* Per-packet information */
83struct 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
98static 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
105static 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
117static 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
David S. Miller1d181832006-03-28 00:01:55 -0800127 mutex_lock(&econet_mutex);
128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 /*
130 * Call the generic datagram receiver. This handles all sorts
131 * of horrible races and re-entrancy so we can forget about it
132 * in the protocol layers.
133 *
134 * Now it will return ENETDOWN, if device have just gone down,
135 * but then it will block.
136 */
137
138 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
139
140 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900141 * An error occurred so return it. Because skb_recv_datagram()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 * handles the blocking we don't see and worry about blocking
143 * retries.
144 */
145
146 if(skb==NULL)
147 goto out;
148
149 /*
150 * You lose any data beyond the buffer you gave. If it worries a
151 * user program they can ask the device for its MTU anyway.
152 */
153
154 copied = skb->len;
155 if (copied > len)
156 {
157 copied=len;
158 msg->msg_flags|=MSG_TRUNC;
159 }
160
161 /* We can't use skb_copy_datagram here */
162 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
163 if (err)
164 goto out_free;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700165 sk->sk_stamp = skb->tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
167 if (msg->msg_name)
168 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
169
170 /*
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
173 */
174 err = copied;
175
176out_free:
177 skb_free_datagram(sk, skb);
178out:
David S. Miller1d181832006-03-28 00:01:55 -0800179 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return err;
181}
182
183/*
184 * Bind an Econet socket.
185 */
186
187static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
188{
189 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
David S. Miller1d181832006-03-28 00:01:55 -0800190 struct sock *sk;
191 struct econet_sock *eo;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 /*
194 * Check legality
195 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (addr_len < sizeof(struct sockaddr_ec) ||
198 sec->sec_family != AF_ECONET)
199 return -EINVAL;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900200
David S. Miller1d181832006-03-28 00:01:55 -0800201 mutex_lock(&econet_mutex);
202
203 sk = sock->sk;
204 eo = ec_sk(sk);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 eo->cb = sec->cb;
207 eo->port = sec->port;
208 eo->station = sec->addr.station;
209 eo->net = sec->addr.net;
210
David S. Miller1d181832006-03-28 00:01:55 -0800211 mutex_unlock(&econet_mutex);
212
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 return 0;
214}
215
216#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
217/*
218 * Queue a transmit result for the user to be told about.
219 */
220
221static void tx_result(struct sock *sk, unsigned long cookie, int result)
222{
223 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
224 struct ec_cb *eb;
225 struct sockaddr_ec *sec;
226
227 if (skb == NULL)
228 {
229 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
230 return;
231 }
232
233 eb = (struct ec_cb *)&skb->cb;
234 sec = (struct sockaddr_ec *)&eb->sec;
235 memset(sec, 0, sizeof(struct sockaddr_ec));
236 sec->cookie = cookie;
237 sec->type = ECTYPE_TRANSMIT_STATUS | result;
238 sec->sec_family = AF_ECONET;
239
240 if (sock_queue_rcv_skb(sk, skb) < 0)
241 kfree_skb(skb);
242}
243#endif
244
245#ifdef CONFIG_ECONET_NATIVE
246/*
247 * Called by the Econet hardware driver when a packet transmit
248 * has completed. Tell the user.
249 */
250
251static void ec_tx_done(struct sk_buff *skb, int result)
252{
253 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
254 tx_result(skb->sk, eb->cookie, result);
255}
256#endif
257
258/*
259 * Send a packet. We have to work out which device it's going out on
260 * and hence whether to use real Econet or the UDP emulation.
261 */
262
263static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
264 struct msghdr *msg, size_t len)
265{
266 struct sock *sk = sock->sk;
267 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
268 struct net_device *dev;
269 struct ec_addr addr;
270 int err;
271 unsigned char port, cb;
272#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
273 struct sk_buff *skb;
274 struct ec_cb *eb;
275#endif
276#ifdef CONFIG_ECONET_AUNUDP
277 struct msghdr udpmsg;
278 struct iovec iov[msg->msg_iovlen+1];
279 struct aunhdr ah;
280 struct sockaddr_in udpdest;
281 __kernel_size_t size;
282 int i;
283 mm_segment_t oldfs;
284#endif
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900287 * Check the flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 */
289
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900290 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 return -EINVAL;
292
293 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900294 * Get and verify the address.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900296
David S. Miller1d181832006-03-28 00:01:55 -0800297 mutex_lock(&econet_mutex);
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 if (saddr == NULL) {
300 struct econet_sock *eo = ec_sk(sk);
301
302 addr.station = eo->station;
303 addr.net = eo->net;
304 port = eo->port;
305 cb = eo->cb;
306 } else {
David S. Miller1d181832006-03-28 00:01:55 -0800307 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
308 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 return -EINVAL;
David S. Miller1d181832006-03-28 00:01:55 -0800310 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 addr.station = saddr->addr.station;
312 addr.net = saddr->addr.net;
313 port = saddr->port;
314 cb = saddr->cb;
315 }
316
317 /* Look for a device with the right network number. */
318 dev = net2dev_map[addr.net];
319
320 /* If not directly reachable, use some default */
David S. Miller1d181832006-03-28 00:01:55 -0800321 if (dev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 dev = net2dev_map[0];
323 /* No interfaces at all? */
David S. Miller1d181832006-03-28 00:01:55 -0800324 if (dev == NULL) {
325 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 return -ENETDOWN;
David S. Miller1d181832006-03-28 00:01:55 -0800327 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 }
329
David S. Miller1d181832006-03-28 00:01:55 -0800330 if (len + 15 > dev->mtu) {
331 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 return -EMSGSIZE;
David S. Miller1d181832006-03-28 00:01:55 -0800333 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
David S. Miller1d181832006-03-28 00:01:55 -0800335 if (dev->type == ARPHRD_ECONET) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 /* Real hardware Econet. We're not worthy etc. */
337#ifdef CONFIG_ECONET_NATIVE
338 unsigned short proto = 0;
339
340 dev_hold(dev);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900341
342 skb = sock_alloc_send_skb(sk, len+LL_RESERVED_SPACE(dev),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 msg->msg_flags & MSG_DONTWAIT, &err);
344 if (skb==NULL)
345 goto out_unlock;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 skb_reserve(skb, LL_RESERVED_SPACE(dev));
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700348 skb_reset_network_header(skb);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 eb = (struct ec_cb *)&skb->cb;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 /* BUG: saddr may be NULL */
353 eb->cookie = saddr->cookie;
354 eb->sec = *saddr;
355 eb->sent = ec_tx_done;
356
357 if (dev->hard_header) {
358 int res;
359 struct ec_framehdr *fh;
360 err = -EINVAL;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900361 res = dev->hard_header(skb, dev, ntohs(proto),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 &addr, NULL, len);
363 /* Poke in our control byte and
364 port number. Hack, hack. */
365 fh = (struct ec_framehdr *)(skb->data);
366 fh->cb = cb;
367 fh->port = port;
368 if (sock->type != SOCK_DGRAM) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700369 skb_reset_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 skb->len = 0;
371 } else if (res < 0)
372 goto out_free;
373 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 /* Copy the data. Returns -EFAULT on error */
376 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
377 skb->protocol = proto;
378 skb->dev = dev;
379 skb->priority = sk->sk_priority;
380 if (err)
381 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 err = -ENETDOWN;
384 if (!(dev->flags & IFF_UP))
385 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 /*
388 * Now send it
389 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 dev_queue_xmit(skb);
392 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800393 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 return(len);
395
396 out_free:
397 kfree_skb(skb);
398 out_unlock:
399 if (dev)
400 dev_put(dev);
401#else
402 err = -EPROTOTYPE;
403#endif
David S. Miller1d181832006-03-28 00:01:55 -0800404 mutex_unlock(&econet_mutex);
405
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return err;
407 }
408
409#ifdef CONFIG_ECONET_AUNUDP
410 /* AUN virtual Econet. */
411
David S. Miller1d181832006-03-28 00:01:55 -0800412 if (udpsock == NULL) {
413 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 return -ENETDOWN; /* No socket - can't send */
David S. Miller1d181832006-03-28 00:01:55 -0800415 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900416
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 /* Make up a UDP datagram and hand it off to some higher intellect. */
418
419 memset(&udpdest, 0, sizeof(udpdest));
420 udpdest.sin_family = AF_INET;
421 udpdest.sin_port = htons(AUN_PORT);
422
423 /* At the moment we use the stupid Acorn scheme of Econet address
424 y.x maps to IP a.b.c.x. This should be replaced with something
425 more flexible and more aware of subnet masks. */
426 {
427 struct in_device *idev;
428 unsigned long network = 0;
429
430 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700431 idev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 if (idev) {
433 if (idev->ifa_list)
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900434 network = ntohl(idev->ifa_list->ifa_address) &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 0xffffff00; /* !!! */
436 }
437 rcu_read_unlock();
438 udpdest.sin_addr.s_addr = htonl(network | addr.station);
439 }
440
441 ah.port = port;
442 ah.cb = cb & 0x7f;
443 ah.code = 2; /* magic */
444 ah.pad = 0;
445
446 /* tack our header on the front of the iovec */
447 size = sizeof(struct aunhdr);
448 /*
449 * XXX: that is b0rken. We can't mix userland and kernel pointers
450 * in iovec, since on a lot of platforms copy_from_user() will
451 * *not* work with the kernel and userland ones at the same time,
452 * regardless of what we do with set_fs(). And we are talking about
453 * econet-over-ethernet here, so "it's only ARM anyway" doesn't
454 * apply. Any suggestions on fixing that code? -- AV
455 */
456 iov[0].iov_base = (void *)&ah;
457 iov[0].iov_len = size;
458 for (i = 0; i < msg->msg_iovlen; i++) {
459 void __user *base = msg->msg_iov[i].iov_base;
460 size_t len = msg->msg_iov[i].iov_len;
461 /* Check it now since we switch to KERNEL_DS later. */
David S. Miller1d181832006-03-28 00:01:55 -0800462 if (!access_ok(VERIFY_READ, base, len)) {
463 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return -EFAULT;
David S. Miller1d181832006-03-28 00:01:55 -0800465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 iov[i+1].iov_base = base;
467 iov[i+1].iov_len = len;
468 size += len;
469 }
470
471 /* Get a skbuff (no data, just holds our cb information) */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900472 if ((skb = sock_alloc_send_skb(sk, 0,
David S. Miller1d181832006-03-28 00:01:55 -0800473 msg->msg_flags & MSG_DONTWAIT,
474 &err)) == NULL) {
475 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return err;
David S. Miller1d181832006-03-28 00:01:55 -0800477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
479 eb = (struct ec_cb *)&skb->cb;
480
481 eb->cookie = saddr->cookie;
482 eb->timeout = (5*HZ);
483 eb->start = jiffies;
484 ah.handle = aun_seq;
485 eb->seq = (aun_seq++);
486 eb->sec = *saddr;
487
488 skb_queue_tail(&aun_queue, skb);
489
490 udpmsg.msg_name = (void *)&udpdest;
491 udpmsg.msg_namelen = sizeof(udpdest);
492 udpmsg.msg_iov = &iov[0];
493 udpmsg.msg_iovlen = msg->msg_iovlen + 1;
494 udpmsg.msg_control = NULL;
495 udpmsg.msg_controllen = 0;
496 udpmsg.msg_flags=0;
497
498 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
499 err = sock_sendmsg(udpsock, &udpmsg, size);
500 set_fs(oldfs);
501#else
502 err = -EPROTOTYPE;
503#endif
David S. Miller1d181832006-03-28 00:01:55 -0800504 mutex_unlock(&econet_mutex);
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return err;
507}
508
509/*
510 * Look up the address of a socket.
511 */
512
513static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
514 int *uaddr_len, int peer)
515{
David S. Miller1d181832006-03-28 00:01:55 -0800516 struct sock *sk;
517 struct econet_sock *eo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
519
520 if (peer)
521 return -EOPNOTSUPP;
522
David S. Miller1d181832006-03-28 00:01:55 -0800523 mutex_lock(&econet_mutex);
524
525 sk = sock->sk;
526 eo = ec_sk(sk);
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 sec->sec_family = AF_ECONET;
529 sec->port = eo->port;
530 sec->addr.station = eo->station;
531 sec->addr.net = eo->net;
532
David S. Miller1d181832006-03-28 00:01:55 -0800533 mutex_unlock(&econet_mutex);
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 *uaddr_len = sizeof(*sec);
536 return 0;
537}
538
539static void econet_destroy_timer(unsigned long data)
540{
541 struct sock *sk=(struct sock *)data;
542
543 if (!atomic_read(&sk->sk_wmem_alloc) &&
544 !atomic_read(&sk->sk_rmem_alloc)) {
545 sk_free(sk);
546 return;
547 }
548
549 sk->sk_timer.expires = jiffies + 10 * HZ;
550 add_timer(&sk->sk_timer);
551 printk(KERN_DEBUG "econet socket destroy delayed\n");
552}
553
554/*
555 * Close an econet socket.
556 */
557
558static int econet_release(struct socket *sock)
559{
David S. Miller1d181832006-03-28 00:01:55 -0800560 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
David S. Miller1d181832006-03-28 00:01:55 -0800562 mutex_lock(&econet_mutex);
563
564 sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 if (!sk)
David S. Miller1d181832006-03-28 00:01:55 -0800566 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568 econet_remove_socket(&econet_sklist, sk);
569
570 /*
571 * Now the socket is dead. No more input will appear.
572 */
573
574 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
575
576 sock->sk = NULL;
577 sk->sk_socket = NULL;
578 sock_set_flag(sk, SOCK_DEAD);
579
580 /* Purge queues */
581
582 skb_queue_purge(&sk->sk_receive_queue);
583
584 if (atomic_read(&sk->sk_rmem_alloc) ||
585 atomic_read(&sk->sk_wmem_alloc)) {
586 sk->sk_timer.data = (unsigned long)sk;
587 sk->sk_timer.expires = jiffies + HZ;
588 sk->sk_timer.function = econet_destroy_timer;
589 add_timer(&sk->sk_timer);
David S. Miller1d181832006-03-28 00:01:55 -0800590
591 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
593
594 sk_free(sk);
David S. Miller1d181832006-03-28 00:01:55 -0800595
596out_unlock:
597 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 return 0;
599}
600
601static struct proto econet_proto = {
602 .name = "ECONET",
603 .owner = THIS_MODULE,
604 .obj_size = sizeof(struct econet_sock),
605};
606
607/*
608 * Create an Econet socket
609 */
610
611static int econet_create(struct socket *sock, int protocol)
612{
613 struct sock *sk;
614 struct econet_sock *eo;
615 int err;
616
617 /* Econet only provides datagram services. */
618 if (sock->type != SOCK_DGRAM)
619 return -ESOCKTNOSUPPORT;
620
621 sock->state = SS_UNCONNECTED;
622
623 err = -ENOBUFS;
624 sk = sk_alloc(PF_ECONET, GFP_KERNEL, &econet_proto, 1);
625 if (sk == NULL)
626 goto out;
627
628 sk->sk_reuse = 1;
629 sock->ops = &econet_ops;
630 sock_init_data(sock, sk);
631
632 eo = ec_sk(sk);
633 sock_reset_flag(sk, SOCK_ZAPPED);
634 sk->sk_family = PF_ECONET;
635 eo->num = protocol;
636
637 econet_insert_socket(&econet_sklist, sk);
638 return(0);
639out:
640 return err;
641}
642
643/*
644 * Handle Econet specific ioctls
645 */
646
647static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
648{
649 struct ifreq ifr;
650 struct ec_device *edev;
651 struct net_device *dev;
652 struct sockaddr_ec *sec;
David S. Miller1d181832006-03-28 00:01:55 -0800653 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
655 /*
656 * Fetch the caller's info block into kernel space
657 */
658
659 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
660 return -EFAULT;
661
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900662 if ((dev = dev_get_by_name(ifr.ifr_name)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 return -ENODEV;
664
665 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
666
David S. Miller1d181832006-03-28 00:01:55 -0800667 mutex_lock(&econet_mutex);
668
669 err = 0;
670 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 case SIOCSIFADDR:
672 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800673 if (edev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 /* Magic up a new one. */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700675 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 if (edev == NULL) {
David S. Miller1d181832006-03-28 00:01:55 -0800677 err = -ENOMEM;
678 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 dev->ec_ptr = edev;
David S. Miller1d181832006-03-28 00:01:55 -0800681 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 net2dev_map[edev->net] = NULL;
683 edev->station = sec->addr.station;
684 edev->net = sec->addr.net;
685 net2dev_map[sec->addr.net] = dev;
686 if (!net2dev_map[0])
687 net2dev_map[0] = dev;
David S. Miller1d181832006-03-28 00:01:55 -0800688 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 case SIOCGIFADDR:
691 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800692 if (edev == NULL) {
693 err = -ENODEV;
694 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 }
696 memset(sec, 0, sizeof(struct sockaddr_ec));
697 sec->addr.station = edev->station;
698 sec->addr.net = edev->net;
699 sec->sec_family = AF_ECONET;
700 dev_put(dev);
701 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
David S. Miller1d181832006-03-28 00:01:55 -0800702 err = -EFAULT;
703 break;
704
705 default:
706 err = -EINVAL;
707 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 }
709
David S. Miller1d181832006-03-28 00:01:55 -0800710 mutex_unlock(&econet_mutex);
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800713
714 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715}
716
717/*
718 * Handle generic ioctls
719 */
720
721static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
722{
723 struct sock *sk = sock->sk;
724 void __user *argp = (void __user *)arg;
725
726 switch(cmd) {
727 case SIOCGSTAMP:
728 return sock_get_timestamp(sk, argp);
729
Eric Dumazetae40eb12007-03-18 17:33:16 -0700730 case SIOCGSTAMPNS:
731 return sock_get_timestampns(sk, argp);
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 case SIOCSIFADDR:
734 case SIOCGIFADDR:
735 return ec_dev_ioctl(sock, cmd, argp);
736 break;
737
738 default:
Christoph Hellwigb5e5fa52006-01-03 14:18:33 -0800739 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 }
741 /*NOTREACHED*/
742 return 0;
743}
744
745static struct net_proto_family econet_family_ops = {
746 .family = PF_ECONET,
747 .create = econet_create,
748 .owner = THIS_MODULE,
749};
750
David S. Miller1d181832006-03-28 00:01:55 -0800751static const struct proto_ops econet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 .family = PF_ECONET,
753 .owner = THIS_MODULE,
754 .release = econet_release,
755 .bind = econet_bind,
756 .connect = sock_no_connect,
757 .socketpair = sock_no_socketpair,
758 .accept = sock_no_accept,
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900759 .getname = econet_getname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 .poll = datagram_poll,
761 .ioctl = econet_ioctl,
762 .listen = sock_no_listen,
763 .shutdown = sock_no_shutdown,
764 .setsockopt = sock_no_setsockopt,
765 .getsockopt = sock_no_getsockopt,
766 .sendmsg = econet_sendmsg,
767 .recvmsg = econet_recvmsg,
768 .mmap = sock_no_mmap,
769 .sendpage = sock_no_sendpage,
770};
771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
773/*
774 * Find the listening socket, if any, for the given data.
775 */
776
777static struct sock *ec_listening_socket(unsigned char port, unsigned char
778 station, unsigned char net)
779{
780 struct sock *sk;
781 struct hlist_node *node;
782
783 sk_for_each(sk, node, &econet_sklist) {
784 struct econet_sock *opt = ec_sk(sk);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900785 if ((opt->port == port || opt->port == 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 (opt->station == station || opt->station == 0) &&
787 (opt->net == net || opt->net == 0))
788 goto found;
789 }
790 sk = NULL;
791found:
792 return sk;
793}
794
795/*
796 * Queue a received packet for a socket.
797 */
798
799static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
800 unsigned char stn, unsigned char net,
801 unsigned char cb, unsigned char port)
802{
803 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
804 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
805
806 memset(sec, 0, sizeof(struct sockaddr_ec));
807 sec->sec_family = AF_ECONET;
808 sec->type = ECTYPE_PACKET_RECEIVED;
809 sec->port = port;
810 sec->cb = cb;
811 sec->addr.net = net;
812 sec->addr.station = stn;
813
814 return sock_queue_rcv_skb(sk, skb);
815}
816#endif
817
818#ifdef CONFIG_ECONET_AUNUDP
819/*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900820 * Send an AUN protocol response.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 */
822
823static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
824{
825 struct sockaddr_in sin = {
826 .sin_family = AF_INET,
827 .sin_port = htons(AUN_PORT),
828 .sin_addr = {.s_addr = addr}
829 };
830 struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
831 struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
832 struct msghdr udpmsg;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900833
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 udpmsg.msg_name = (void *)&sin;
835 udpmsg.msg_namelen = sizeof(sin);
836 udpmsg.msg_control = NULL;
837 udpmsg.msg_controllen = 0;
838 udpmsg.msg_flags=0;
839
840 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
841}
842
843
844/*
845 * Handle incoming AUN packets. Work out if anybody wants them,
846 * and send positive or negative acknowledgements as appropriate.
847 */
848
849static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
850{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700851 struct iphdr *ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 unsigned char stn = ntohl(ip->saddr) & 0xff;
853 struct sock *sk;
854 struct sk_buff *newskb;
855 struct ec_device *edev = skb->dev->ec_ptr;
856
857 if (! edev)
858 goto bad;
859
860 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
861 goto bad; /* Nobody wants it */
862
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900863 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 GFP_ATOMIC);
865 if (newskb == NULL)
866 {
867 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
868 /* Send nack and hope sender tries again */
869 goto bad;
870 }
871
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900872 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 len - sizeof(struct aunhdr));
874
875 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
876 {
877 /* Socket is bankrupt. */
878 kfree_skb(newskb);
879 goto bad;
880 }
881
882 aun_send_response(ip->saddr, ah->handle, 3, 0);
883 return;
884
885bad:
886 aun_send_response(ip->saddr, ah->handle, 4, 0);
887}
888
889/*
890 * Handle incoming AUN transmit acknowledgements. If the sequence
891 * number matches something in our backlog then kill it and tell
892 * the user. If the remote took too long to reply then we may have
893 * dropped the packet already.
894 */
895
896static void aun_tx_ack(unsigned long seq, int result)
897{
898 struct sk_buff *skb;
899 unsigned long flags;
900 struct ec_cb *eb;
901
902 spin_lock_irqsave(&aun_queue_lock, flags);
903 skb = skb_peek(&aun_queue);
904 while (skb && skb != (struct sk_buff *)&aun_queue)
905 {
906 struct sk_buff *newskb = skb->next;
907 eb = (struct ec_cb *)&skb->cb;
908 if (eb->seq == seq)
909 goto foundit;
910
911 skb = newskb;
912 }
913 spin_unlock_irqrestore(&aun_queue_lock, flags);
914 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
915 return;
916
917foundit:
918 tx_result(skb->sk, eb->cookie, result);
David S. Miller8728b832005-08-09 19:25:21 -0700919 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 spin_unlock_irqrestore(&aun_queue_lock, flags);
921 kfree_skb(skb);
922}
923
924/*
925 * Deal with received AUN frames - sort out what type of thing it is
926 * and hand it to the right function.
927 */
928
929static void aun_data_available(struct sock *sk, int slen)
930{
931 int err;
932 struct sk_buff *skb;
933 unsigned char *data;
934 struct aunhdr *ah;
935 struct iphdr *ip;
936 size_t len;
937
938 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
939 if (err == -EAGAIN) {
940 printk(KERN_ERR "AUN: no data available?!");
941 return;
942 }
943 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
944 }
945
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700946 data = skb_transport_header(skb) + sizeof(struct udphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 ah = (struct aunhdr *)data;
948 len = skb->len - sizeof(struct udphdr);
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700949 ip = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
951 switch (ah->code)
952 {
953 case 2:
954 aun_incoming(skb, ah, len);
955 break;
956 case 3:
957 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
958 break;
959 case 4:
960 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
961 break;
962#if 0
963 /* This isn't quite right yet. */
964 case 5:
965 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
966 break;
967#endif
968 default:
969 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
970 }
971
972 skb_free_datagram(sk, skb);
973}
974
975/*
976 * Called by the timer to manage the AUN transmit queue. If a packet
977 * was sent to a dead or nonexistent host then we will never get an
978 * acknowledgement back. After a few seconds we need to spot this and
979 * drop the packet.
980 */
981
982static void ab_cleanup(unsigned long h)
983{
984 struct sk_buff *skb;
985 unsigned long flags;
986
987 spin_lock_irqsave(&aun_queue_lock, flags);
988 skb = skb_peek(&aun_queue);
989 while (skb && skb != (struct sk_buff *)&aun_queue)
990 {
991 struct sk_buff *newskb = skb->next;
992 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
993 if ((jiffies - eb->start) > eb->timeout)
994 {
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900995 tx_result(skb->sk, eb->cookie,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 ECTYPE_TRANSMIT_NOT_PRESENT);
David S. Miller8728b832005-08-09 19:25:21 -0700997 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 kfree_skb(skb);
999 }
1000 skb = newskb;
1001 }
1002 spin_unlock_irqrestore(&aun_queue_lock, flags);
1003
1004 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1005}
1006
1007static int __init aun_udp_initialise(void)
1008{
1009 int error;
1010 struct sockaddr_in sin;
1011
1012 skb_queue_head_init(&aun_queue);
1013 spin_lock_init(&aun_queue_lock);
1014 init_timer(&ab_cleanup_timer);
1015 ab_cleanup_timer.expires = jiffies + (HZ*2);
1016 ab_cleanup_timer.function = ab_cleanup;
1017 add_timer(&ab_cleanup_timer);
1018
1019 memset(&sin, 0, sizeof(sin));
1020 sin.sin_port = htons(AUN_PORT);
1021
1022 /* We can count ourselves lucky Acorn machines are too dim to
1023 speak IPv6. :-) */
1024 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1025 {
1026 printk("AUN: socket error %d\n", -error);
1027 return error;
1028 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001029
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 udpsock->sk->sk_reuse = 1;
1031 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1032 from interrupts */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1035 sizeof(sin));
1036 if (error < 0)
1037 {
1038 printk("AUN: bind error %d\n", -error);
1039 goto release;
1040 }
1041
1042 udpsock->sk->sk_data_ready = aun_data_available;
1043
1044 return 0;
1045
1046release:
1047 sock_release(udpsock);
1048 udpsock = NULL;
1049 return error;
1050}
1051#endif
1052
1053#ifdef CONFIG_ECONET_NATIVE
1054
1055/*
1056 * Receive an Econet frame from a device.
1057 */
1058
David S. Millerf2ccd8f2005-08-09 19:34:12 -07001059static 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 -07001060{
1061 struct ec_framehdr *hdr;
1062 struct sock *sk;
1063 struct ec_device *edev = dev->ec_ptr;
1064
1065 if (skb->pkt_type == PACKET_OTHERHOST)
1066 goto drop;
1067
1068 if (!edev)
1069 goto drop;
1070
1071 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1072 return NET_RX_DROP;
1073
1074 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1075 goto drop;
1076
1077 hdr = (struct ec_framehdr *) skb->data;
1078
1079 /* First check for encapsulated IP */
1080 if (hdr->port == EC_PORT_IP) {
1081 skb->protocol = htons(ETH_P_IP);
1082 skb_pull(skb, sizeof(struct ec_framehdr));
1083 netif_rx(skb);
1084 return 0;
1085 }
1086
1087 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1088 if (!sk)
1089 goto drop;
1090
1091 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1092 hdr->port))
1093 goto drop;
1094
1095 return 0;
1096
1097drop:
1098 kfree_skb(skb);
1099 return NET_RX_DROP;
1100}
1101
1102static struct packet_type econet_packet_type = {
1103 .type = __constant_htons(ETH_P_ECONET),
1104 .func = econet_rcv,
1105};
1106
1107static void econet_hw_initialise(void)
1108{
1109 dev_add_pack(&econet_packet_type);
1110}
1111
1112#endif
1113
1114static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1115{
1116 struct net_device *dev = (struct net_device *)data;
1117 struct ec_device *edev;
1118
1119 switch (msg) {
1120 case NETDEV_UNREGISTER:
1121 /* A device has gone down - kill any data we hold for it. */
1122 edev = dev->ec_ptr;
1123 if (edev)
1124 {
1125 if (net2dev_map[0] == dev)
1126 net2dev_map[0] = NULL;
1127 net2dev_map[edev->net] = NULL;
1128 kfree(edev);
1129 dev->ec_ptr = NULL;
1130 }
1131 break;
1132 }
1133
1134 return NOTIFY_DONE;
1135}
1136
1137static struct notifier_block econet_netdev_notifier = {
1138 .notifier_call =econet_notifier,
1139};
1140
1141static void __exit econet_proto_exit(void)
1142{
1143#ifdef CONFIG_ECONET_AUNUDP
1144 del_timer(&ab_cleanup_timer);
1145 if (udpsock)
1146 sock_release(udpsock);
1147#endif
1148 unregister_netdevice_notifier(&econet_netdev_notifier);
1149 sock_unregister(econet_family_ops.family);
1150 proto_unregister(&econet_proto);
1151}
1152
1153static int __init econet_proto_init(void)
1154{
1155 int err = proto_register(&econet_proto, 0);
1156
1157 if (err != 0)
1158 goto out;
1159 sock_register(&econet_family_ops);
1160#ifdef CONFIG_ECONET_AUNUDP
1161 spin_lock_init(&aun_queue_lock);
1162 aun_udp_initialise();
1163#endif
1164#ifdef CONFIG_ECONET_NATIVE
1165 econet_hw_initialise();
1166#endif
1167 register_netdevice_notifier(&econet_netdev_notifier);
1168out:
1169 return err;
1170}
1171
1172module_init(econet_proto_init);
1173module_exit(econet_proto_exit);
1174
1175MODULE_LICENSE("GPL");
1176MODULE_ALIAS_NETPROTO(PF_ECONET);