blob: 71b5edcee4016948f2075decbdc692d345dfc192 [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
Joe Perchesee9c88f2011-07-03 08:28:33 +000012#define pr_fmt(fmt) fmt
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/module.h>
15
16#include <linux/types.h>
17#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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>
Arnaldo Carvalho de Melo14c85022005-12-27 02:43:12 -020034#include <linux/udp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
Phil Blundella27e13d2010-11-24 11:51:47 -080036#include <linux/vmalloc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <net/sock.h>
38#include <net/inet_common.h>
39#include <linux/stat.h>
40#include <linux/init.h>
41#include <linux/if_ec.h>
42#include <net/udp.h>
43#include <net/ip.h>
44#include <linux/spinlock.h>
45#include <linux/rcupdate.h>
46#include <linux/bitops.h>
David S. Miller1d181832006-03-28 00:01:55 -080047#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Joe Perchesee9c88f2011-07-03 08:28:33 +000049#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Eric Dumazet90ddc4f2005-12-22 12:49:22 -080051static const struct proto_ops econet_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052static struct hlist_head econet_sklist;
Eric Dumazet0c78a922010-06-09 16:33:05 +000053static DEFINE_SPINLOCK(econet_lock);
David S. Miller1d181832006-03-28 00:01:55 -080054static DEFINE_MUTEX(econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56/* Since there are only 256 possible network numbers (or fewer, depends
57 how you count) it makes sense to use a simple lookup table. */
58static struct net_device *net2dev_map[256];
59
60#define EC_PORT_IP 0xd2
61
62#ifdef CONFIG_ECONET_AUNUDP
YOSHIFUJI Hideakica403302006-01-04 13:56:08 -080063static DEFINE_SPINLOCK(aun_queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static struct socket *udpsock;
65#define AUN_PORT 0x8000
66
Joe Perchesee9c88f2011-07-03 08:28:33 +000067struct aunhdr {
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 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 */
Joe Perchesee9c88f2011-07-03 08:28:33 +000084struct ec_cb {
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 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{
Eric Dumazet0c78a922010-06-09 16:33:05 +0000100 spin_lock_bh(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 sk_del_node_init(sk);
Eric Dumazet0c78a922010-06-09 16:33:05 +0000102 spin_unlock_bh(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103}
104
105static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
106{
Eric Dumazet0c78a922010-06-09 16:33:05 +0000107 spin_lock_bh(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 sk_add_node(sk, list);
Eric Dumazet0c78a922010-06-09 16:33:05 +0000109 spin_unlock_bh(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
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
Joe Perchesee9c88f2011-07-03 08:28:33 +0000138 skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
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
Joe Perchesee9c88f2011-07-03 08:28:33 +0000146 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 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;
Joe Perchesee9c88f2011-07-03 08:28:33 +0000155 if (copied > len) {
156 copied = len;
157 msg->msg_flags |= MSG_TRUNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159
160 /* We can't use skb_copy_datagram here */
161 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
162 if (err)
163 goto out_free;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700164 sk->sk_stamp = skb->tstamp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
166 if (msg->msg_name)
167 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
168
169 /*
170 * Free or return the buffer as appropriate. Again this
171 * hides all the races and re-entrancy issues from us.
172 */
173 err = copied;
174
175out_free:
176 skb_free_datagram(sk, skb);
177out:
David S. Miller1d181832006-03-28 00:01:55 -0800178 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 return err;
180}
181
182/*
183 * Bind an Econet socket.
184 */
185
Joe Perchesee9c88f2011-07-03 08:28:33 +0000186static int econet_bind(struct socket *sock, struct sockaddr *uaddr,
187 int addr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
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
Joe Perchesee9c88f2011-07-03 08:28:33 +0000227 if (skb == NULL) {
228 pr_debug("econet: memory squeeze, transmit result dropped\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return;
230 }
231
232 eb = (struct ec_cb *)&skb->cb;
233 sec = (struct sockaddr_ec *)&eb->sec;
234 memset(sec, 0, sizeof(struct sockaddr_ec));
235 sec->cookie = cookie;
236 sec->type = ECTYPE_TRANSMIT_STATUS | result;
237 sec->sec_family = AF_ECONET;
238
239 if (sock_queue_rcv_skb(sk, skb) < 0)
240 kfree_skb(skb);
241}
242#endif
243
244#ifdef CONFIG_ECONET_NATIVE
245/*
246 * Called by the Econet hardware driver when a packet transmit
247 * has completed. Tell the user.
248 */
249
250static void ec_tx_done(struct sk_buff *skb, int result)
251{
252 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
253 tx_result(skb->sk, eb->cookie, result);
254}
255#endif
256
257/*
258 * Send a packet. We have to work out which device it's going out on
259 * and hence whether to use real Econet or the UDP emulation.
260 */
261
262static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
263 struct msghdr *msg, size_t len)
264{
Joe Perchesee9c88f2011-07-03 08:28:33 +0000265 struct sockaddr_ec *saddr = (struct sockaddr_ec *)msg->msg_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 struct net_device *dev;
267 struct ec_addr addr;
268 int err;
269 unsigned char port, cb;
270#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
Eric Dumazet389f2a12011-01-26 00:04:18 +0000271 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 struct sk_buff *skb;
273 struct ec_cb *eb;
274#endif
275#ifdef CONFIG_ECONET_AUNUDP
276 struct msghdr udpmsg;
Phil Blundella27e13d2010-11-24 11:51:47 -0800277 struct iovec iov[2];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 struct aunhdr ah;
279 struct sockaddr_in udpdest;
280 __kernel_size_t size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 mm_segment_t oldfs;
Phil Blundella27e13d2010-11-24 11:51:47 -0800282 char *userbuf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283#endif
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900286 * Check the flags.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 */
288
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900289 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return -EINVAL;
291
292 /*
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900293 * Get and verify the address.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900295
David S. Miller1d181832006-03-28 00:01:55 -0800296 mutex_lock(&econet_mutex);
297
Joe Perchesee9c88f2011-07-03 08:28:33 +0000298 if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
299 mutex_unlock(&econet_mutex);
300 return -EINVAL;
301 }
302 addr.station = saddr->addr.station;
303 addr.net = saddr->addr.net;
304 port = saddr->port;
305 cb = saddr->cb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
307 /* Look for a device with the right network number. */
308 dev = net2dev_map[addr.net];
309
310 /* If not directly reachable, use some default */
David S. Miller1d181832006-03-28 00:01:55 -0800311 if (dev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 dev = net2dev_map[0];
313 /* No interfaces at all? */
David S. Miller1d181832006-03-28 00:01:55 -0800314 if (dev == NULL) {
315 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 return -ENETDOWN;
David S. Miller1d181832006-03-28 00:01:55 -0800317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319
David S. Miller1d181832006-03-28 00:01:55 -0800320 if (dev->type == ARPHRD_ECONET) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 /* Real hardware Econet. We're not worthy etc. */
322#ifdef CONFIG_ECONET_NATIVE
323 unsigned short proto = 0;
Herbert Xuae641942011-11-18 02:20:04 +0000324 int hlen, tlen;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700325 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
Phil Blundella27e13d2010-11-24 11:51:47 -0800327 if (len + 15 > dev->mtu) {
328 mutex_unlock(&econet_mutex);
329 return -EMSGSIZE;
330 }
331
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 dev_hold(dev);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900333
Herbert Xuae641942011-11-18 02:20:04 +0000334 hlen = LL_RESERVED_SPACE(dev);
335 tlen = dev->needed_tailroom;
336 skb = sock_alloc_send_skb(sk, len + hlen + tlen,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 msg->msg_flags & MSG_DONTWAIT, &err);
Joe Perchesee9c88f2011-07-03 08:28:33 +0000338 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 goto out_unlock;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900340
Herbert Xuae641942011-11-18 02:20:04 +0000341 skb_reserve(skb, hlen);
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700342 skb_reset_network_header(skb);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 eb = (struct ec_cb *)&skb->cb;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 eb->cookie = saddr->cookie;
347 eb->sec = *saddr;
348 eb->sent = ec_tx_done;
349
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700350 err = -EINVAL;
351 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
352 if (res < 0)
353 goto out_free;
354 if (res > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 struct ec_framehdr *fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 /* Poke in our control byte and
357 port number. Hack, hack. */
Joe Perchesee9c88f2011-07-03 08:28:33 +0000358 fh = (struct ec_framehdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 fh->cb = cb;
360 fh->port = port;
361 if (sock->type != SOCK_DGRAM) {
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700362 skb_reset_tail_pointer(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 skb->len = 0;
Stephen Hemminger0c4e8582007-10-09 01:36:32 -0700364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 /* Copy the data. Returns -EFAULT on error */
Joe Perchesee9c88f2011-07-03 08:28:33 +0000368 err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 skb->protocol = proto;
370 skb->dev = dev;
371 skb->priority = sk->sk_priority;
372 if (err)
373 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 err = -ENETDOWN;
376 if (!(dev->flags & IFF_UP))
377 goto out_free;
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 /*
380 * Now send it
381 */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 dev_queue_xmit(skb);
384 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800385 mutex_unlock(&econet_mutex);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000386 return len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Joe Perchesee9c88f2011-07-03 08:28:33 +0000388out_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 kfree_skb(skb);
Joe Perchesee9c88f2011-07-03 08:28:33 +0000390out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (dev)
392 dev_put(dev);
393#else
394 err = -EPROTOTYPE;
395#endif
David S. Miller1d181832006-03-28 00:01:55 -0800396 mutex_unlock(&econet_mutex);
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 return err;
399 }
400
401#ifdef CONFIG_ECONET_AUNUDP
402 /* AUN virtual Econet. */
403
David S. Miller1d181832006-03-28 00:01:55 -0800404 if (udpsock == NULL) {
405 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return -ENETDOWN; /* No socket - can't send */
David S. Miller1d181832006-03-28 00:01:55 -0800407 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900408
Phil Blundella27e13d2010-11-24 11:51:47 -0800409 if (len > 32768) {
410 err = -E2BIG;
411 goto error;
412 }
413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 /* Make up a UDP datagram and hand it off to some higher intellect. */
415
416 memset(&udpdest, 0, sizeof(udpdest));
417 udpdest.sin_family = AF_INET;
418 udpdest.sin_port = htons(AUN_PORT);
419
420 /* At the moment we use the stupid Acorn scheme of Econet address
421 y.x maps to IP a.b.c.x. This should be replaced with something
422 more flexible and more aware of subnet masks. */
423 {
424 struct in_device *idev;
425 unsigned long network = 0;
426
427 rcu_read_lock();
Herbert Xue5ed6392005-10-03 14:35:55 -0700428 idev = __in_dev_get_rcu(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 if (idev) {
430 if (idev->ifa_list)
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900431 network = ntohl(idev->ifa_list->ifa_address) &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 0xffffff00; /* !!! */
433 }
434 rcu_read_unlock();
435 udpdest.sin_addr.s_addr = htonl(network | addr.station);
436 }
437
Vasiliy Kulikov67c5c6c2011-03-17 01:40:10 +0000438 memset(&ah, 0, sizeof(ah));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 ah.port = port;
440 ah.cb = cb & 0x7f;
441 ah.code = 2; /* magic */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442
443 /* tack our header on the front of the iovec */
444 size = sizeof(struct aunhdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 iov[0].iov_base = (void *)&ah;
446 iov[0].iov_len = size;
Phil Blundella27e13d2010-11-24 11:51:47 -0800447
448 userbuf = vmalloc(len);
449 if (userbuf == NULL) {
450 err = -ENOMEM;
451 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453
Phil Blundella27e13d2010-11-24 11:51:47 -0800454 iov[1].iov_base = userbuf;
455 iov[1].iov_len = len;
456 err = memcpy_fromiovec(userbuf, msg->msg_iov, len);
457 if (err)
458 goto error_free_buf;
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 /* Get a skbuff (no data, just holds our cb information) */
Joe Perchesee9c88f2011-07-03 08:28:33 +0000461 skb = sock_alloc_send_skb(sk, 0, msg->msg_flags & MSG_DONTWAIT, &err);
462 if (skb == NULL)
Phil Blundella27e13d2010-11-24 11:51:47 -0800463 goto error_free_buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465 eb = (struct ec_cb *)&skb->cb;
466
467 eb->cookie = saddr->cookie;
Joe Perchesee9c88f2011-07-03 08:28:33 +0000468 eb->timeout = 5 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 eb->start = jiffies;
470 ah.handle = aun_seq;
471 eb->seq = (aun_seq++);
472 eb->sec = *saddr;
473
474 skb_queue_tail(&aun_queue, skb);
475
476 udpmsg.msg_name = (void *)&udpdest;
477 udpmsg.msg_namelen = sizeof(udpdest);
478 udpmsg.msg_iov = &iov[0];
Phil Blundella27e13d2010-11-24 11:51:47 -0800479 udpmsg.msg_iovlen = 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 udpmsg.msg_control = NULL;
481 udpmsg.msg_controllen = 0;
Joe Perchesee9c88f2011-07-03 08:28:33 +0000482 udpmsg.msg_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Joe Perchesee9c88f2011-07-03 08:28:33 +0000484 oldfs = get_fs();
485 set_fs(KERNEL_DS); /* More privs :-) */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 err = sock_sendmsg(udpsock, &udpmsg, size);
487 set_fs(oldfs);
Phil Blundella27e13d2010-11-24 11:51:47 -0800488
489error_free_buf:
490 vfree(userbuf);
Eric Dumazet389f2a12011-01-26 00:04:18 +0000491error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492#else
493 err = -EPROTOTYPE;
494#endif
David S. Miller1d181832006-03-28 00:01:55 -0800495 mutex_unlock(&econet_mutex);
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 return err;
498}
499
500/*
501 * Look up the address of a socket.
502 */
503
504static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
505 int *uaddr_len, int peer)
506{
David S. Miller1d181832006-03-28 00:01:55 -0800507 struct sock *sk;
508 struct econet_sock *eo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
510
511 if (peer)
512 return -EOPNOTSUPP;
513
Eric Dumazet80922bb2009-08-06 03:48:36 +0000514 memset(sec, 0, sizeof(*sec));
David S. Miller1d181832006-03-28 00:01:55 -0800515 mutex_lock(&econet_mutex);
516
517 sk = sock->sk;
518 eo = ec_sk(sk);
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 sec->sec_family = AF_ECONET;
521 sec->port = eo->port;
522 sec->addr.station = eo->station;
523 sec->addr.net = eo->net;
524
David S. Miller1d181832006-03-28 00:01:55 -0800525 mutex_unlock(&econet_mutex);
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 *uaddr_len = sizeof(*sec);
528 return 0;
529}
530
531static void econet_destroy_timer(unsigned long data)
532{
Joe Perchesee9c88f2011-07-03 08:28:33 +0000533 struct sock *sk = (struct sock *)data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Eric Dumazetc5640392009-06-16 10:12:03 +0000535 if (!sk_has_allocations(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 sk_free(sk);
537 return;
538 }
539
540 sk->sk_timer.expires = jiffies + 10 * HZ;
541 add_timer(&sk->sk_timer);
Joe Perchesee9c88f2011-07-03 08:28:33 +0000542 pr_debug("econet: socket destroy delayed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
545/*
546 * Close an econet socket.
547 */
548
549static int econet_release(struct socket *sock)
550{
David S. Miller1d181832006-03-28 00:01:55 -0800551 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
David S. Miller1d181832006-03-28 00:01:55 -0800553 mutex_lock(&econet_mutex);
554
555 sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (!sk)
David S. Miller1d181832006-03-28 00:01:55 -0800557 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 econet_remove_socket(&econet_sklist, sk);
560
561 /*
562 * Now the socket is dead. No more input will appear.
563 */
564
565 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
566
David S. Miller0efffaf2008-06-17 03:01:47 -0700567 sock_orphan(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
569 /* Purge queues */
570
571 skb_queue_purge(&sk->sk_receive_queue);
572
Eric Dumazetc5640392009-06-16 10:12:03 +0000573 if (sk_has_allocations(sk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 sk->sk_timer.data = (unsigned long)sk;
575 sk->sk_timer.expires = jiffies + HZ;
576 sk->sk_timer.function = econet_destroy_timer;
577 add_timer(&sk->sk_timer);
David S. Miller1d181832006-03-28 00:01:55 -0800578
579 goto out_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581
582 sk_free(sk);
David S. Miller1d181832006-03-28 00:01:55 -0800583
584out_unlock:
585 mutex_unlock(&econet_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 return 0;
587}
588
589static struct proto econet_proto = {
590 .name = "ECONET",
591 .owner = THIS_MODULE,
592 .obj_size = sizeof(struct econet_sock),
593};
594
595/*
596 * Create an Econet socket
597 */
598
Eric Paris3f378b62009-11-05 22:18:14 -0800599static int econet_create(struct net *net, struct socket *sock, int protocol,
600 int kern)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
602 struct sock *sk;
603 struct econet_sock *eo;
604 int err;
605
Octavian Purdila09ad9bc2009-11-25 15:14:13 -0800606 if (!net_eq(net, &init_net))
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700607 return -EAFNOSUPPORT;
608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 /* Econet only provides datagram services. */
610 if (sock->type != SOCK_DGRAM)
611 return -ESOCKTNOSUPPORT;
612
613 sock->state = SS_UNCONNECTED;
614
615 err = -ENOBUFS;
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700616 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 if (sk == NULL)
618 goto out;
619
620 sk->sk_reuse = 1;
621 sock->ops = &econet_ops;
622 sock_init_data(sock, sk);
623
624 eo = ec_sk(sk);
625 sock_reset_flag(sk, SOCK_ZAPPED);
626 sk->sk_family = PF_ECONET;
627 eo->num = protocol;
628
629 econet_insert_socket(&econet_sklist, sk);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000630 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631out:
632 return err;
633}
634
635/*
636 * Handle Econet specific ioctls
637 */
638
639static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
640{
641 struct ifreq ifr;
642 struct ec_device *edev;
643 struct net_device *dev;
644 struct sockaddr_ec *sec;
David S. Miller1d181832006-03-28 00:01:55 -0800645 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 /*
648 * Fetch the caller's info block into kernel space
649 */
650
651 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
652 return -EFAULT;
653
Joe Perchesee9c88f2011-07-03 08:28:33 +0000654 dev = dev_get_by_name(&init_net, ifr.ifr_name);
655 if (dev == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return -ENODEV;
657
658 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
659
David S. Miller1d181832006-03-28 00:01:55 -0800660 mutex_lock(&econet_mutex);
661
662 err = 0;
663 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 case SIOCSIFADDR:
Nelson Elhage0c62fc62010-12-08 10:13:55 -0800665 if (!capable(CAP_NET_ADMIN)) {
666 err = -EPERM;
667 break;
668 }
Phil Blundell16c41742010-11-24 11:49:53 -0800669
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800671 if (edev == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 /* Magic up a new one. */
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700673 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 if (edev == NULL) {
David S. Miller1d181832006-03-28 00:01:55 -0800675 err = -ENOMEM;
676 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 dev->ec_ptr = edev;
David S. Miller1d181832006-03-28 00:01:55 -0800679 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 net2dev_map[edev->net] = NULL;
681 edev->station = sec->addr.station;
682 edev->net = sec->addr.net;
683 net2dev_map[sec->addr.net] = dev;
684 if (!net2dev_map[0])
685 net2dev_map[0] = dev;
David S. Miller1d181832006-03-28 00:01:55 -0800686 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
688 case SIOCGIFADDR:
689 edev = dev->ec_ptr;
David S. Miller1d181832006-03-28 00:01:55 -0800690 if (edev == NULL) {
691 err = -ENODEV;
692 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
694 memset(sec, 0, sizeof(struct sockaddr_ec));
695 sec->addr.station = edev->station;
696 sec->addr.net = edev->net;
697 sec->sec_family = AF_ECONET;
698 dev_put(dev);
699 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
David S. Miller1d181832006-03-28 00:01:55 -0800700 err = -EFAULT;
701 break;
702
703 default:
704 err = -EINVAL;
705 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
707
David S. Miller1d181832006-03-28 00:01:55 -0800708 mutex_unlock(&econet_mutex);
709
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 dev_put(dev);
David S. Miller1d181832006-03-28 00:01:55 -0800711
712 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713}
714
715/*
716 * Handle generic ioctls
717 */
718
Joe Perchesee9c88f2011-07-03 08:28:33 +0000719static int econet_ioctl(struct socket *sock, unsigned int cmd,
720 unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 struct sock *sk = sock->sk;
723 void __user *argp = (void __user *)arg;
724
Joe Perches075e1912011-07-01 09:43:04 +0000725 switch (cmd) {
726 case SIOCGSTAMP:
727 return sock_get_timestamp(sk, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
Joe Perches075e1912011-07-01 09:43:04 +0000729 case SIOCGSTAMPNS:
730 return sock_get_timestampns(sk, argp);
Eric Dumazetae40eb12007-03-18 17:33:16 -0700731
Joe Perches075e1912011-07-01 09:43:04 +0000732 case SIOCSIFADDR:
733 case SIOCGIFADDR:
734 return ec_dev_ioctl(sock, cmd, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
Joe Perches075e1912011-07-01 09:43:04 +0000737
738 return -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739}
740
Stephen Hemmingerec1b4cf2009-10-05 05:58:39 +0000741static const struct net_proto_family econet_family_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 .family = PF_ECONET,
743 .create = econet_create,
744 .owner = THIS_MODULE,
745};
746
David S. Miller1d181832006-03-28 00:01:55 -0800747static const struct proto_ops econet_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 .family = PF_ECONET,
749 .owner = THIS_MODULE,
750 .release = econet_release,
751 .bind = econet_bind,
752 .connect = sock_no_connect,
753 .socketpair = sock_no_socketpair,
754 .accept = sock_no_accept,
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900755 .getname = econet_getname,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 .poll = datagram_poll,
757 .ioctl = econet_ioctl,
758 .listen = sock_no_listen,
759 .shutdown = sock_no_shutdown,
760 .setsockopt = sock_no_setsockopt,
761 .getsockopt = sock_no_getsockopt,
762 .sendmsg = econet_sendmsg,
763 .recvmsg = econet_recvmsg,
764 .mmap = sock_no_mmap,
765 .sendpage = sock_no_sendpage,
766};
767
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
769/*
770 * Find the listening socket, if any, for the given data.
771 */
772
773static struct sock *ec_listening_socket(unsigned char port, unsigned char
774 station, unsigned char net)
775{
776 struct sock *sk;
777 struct hlist_node *node;
778
Eric Dumazet0c78a922010-06-09 16:33:05 +0000779 spin_lock(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 sk_for_each(sk, node, &econet_sklist) {
781 struct econet_sock *opt = ec_sk(sk);
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900782 if ((opt->port == port || opt->port == 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 (opt->station == station || opt->station == 0) &&
Eric Dumazet0c78a922010-06-09 16:33:05 +0000784 (opt->net == net || opt->net == 0)) {
785 sock_hold(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 goto found;
Eric Dumazet0c78a922010-06-09 16:33:05 +0000787 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 }
789 sk = NULL;
790found:
Eric Dumazet0c78a922010-06-09 16:33:05 +0000791 spin_unlock(&econet_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 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;
Joe Perchesee9c88f2011-07-03 08:28:33 +0000838 udpmsg.msg_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
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;
David S. Miller4e085e72010-12-08 18:42:23 -0800853 struct dst_entry *dst = skb_dst(skb);
854 struct ec_device *edev = NULL;
Eric Dumazet0c78a922010-06-09 16:33:05 +0000855 struct sock *sk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 struct sk_buff *newskb;
David S. Miller4e085e72010-12-08 18:42:23 -0800857
858 if (dst)
859 edev = dst->dev->ec_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Joe Perchesee9c88f2011-07-03 08:28:33 +0000861 if (!edev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 goto bad;
863
Joe Perchesee9c88f2011-07-03 08:28:33 +0000864 sk = ec_listening_socket(ah->port, stn, edev->net);
865 if (sk == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 goto bad; /* Nobody wants it */
867
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900868 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 GFP_ATOMIC);
Joe Perchesee9c88f2011-07-03 08:28:33 +0000870 if (newskb == NULL) {
871 pr_debug("AUN: memory squeeze, dropping packet\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 /* Send nack and hope sender tries again */
873 goto bad;
874 }
875
Joe Perchesee9c88f2011-07-03 08:28:33 +0000876 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah + 1),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 len - sizeof(struct aunhdr));
878
Joe Perchesee9c88f2011-07-03 08:28:33 +0000879 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 /* Socket is bankrupt. */
881 kfree_skb(newskb);
882 goto bad;
883 }
884
885 aun_send_response(ip->saddr, ah->handle, 3, 0);
Eric Dumazet0c78a922010-06-09 16:33:05 +0000886 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 return;
888
889bad:
890 aun_send_response(ip->saddr, ah->handle, 4, 0);
Eric Dumazet0c78a922010-06-09 16:33:05 +0000891 if (sk)
892 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893}
894
895/*
896 * Handle incoming AUN transmit acknowledgements. If the sequence
897 * number matches something in our backlog then kill it and tell
898 * the user. If the remote took too long to reply then we may have
899 * dropped the packet already.
900 */
901
902static void aun_tx_ack(unsigned long seq, int result)
903{
904 struct sk_buff *skb;
905 unsigned long flags;
906 struct ec_cb *eb;
907
908 spin_lock_irqsave(&aun_queue_lock, flags);
David S. Millerde103342009-05-28 16:46:29 -0700909 skb_queue_walk(&aun_queue, skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 eb = (struct ec_cb *)&skb->cb;
911 if (eb->seq == seq)
912 goto foundit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914 spin_unlock_irqrestore(&aun_queue_lock, flags);
Joe Perchesee9c88f2011-07-03 08:28:33 +0000915 pr_debug("AUN: unknown sequence %ld\n", seq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 return;
917
918foundit:
919 tx_result(skb->sk, eb->cookie, result);
David S. Miller8728b832005-08-09 19:25:21 -0700920 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 spin_unlock_irqrestore(&aun_queue_lock, flags);
922 kfree_skb(skb);
923}
924
925/*
926 * Deal with received AUN frames - sort out what type of thing it is
927 * and hand it to the right function.
928 */
929
930static void aun_data_available(struct sock *sk, int slen)
931{
932 int err;
933 struct sk_buff *skb;
934 unsigned char *data;
935 struct aunhdr *ah;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 size_t len;
937
938 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
939 if (err == -EAGAIN) {
Joe Perchesee9c88f2011-07-03 08:28:33 +0000940 pr_err("AUN: no data available?!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 return;
942 }
Joe Perchesee9c88f2011-07-03 08:28:33 +0000943 pr_debug("AUN: recvfrom() error %d\n", -err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 }
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
Joe Perchesee9c88f2011-07-03 08:28:33 +0000950 switch (ah->code) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 default:
Joe Perchesee9c88f2011-07-03 08:28:33 +0000961 pr_debug("AUN: unknown packet type: %d\n", data[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 }
963
964 skb_free_datagram(sk, skb);
965}
966
967/*
968 * Called by the timer to manage the AUN transmit queue. If a packet
969 * was sent to a dead or nonexistent host then we will never get an
970 * acknowledgement back. After a few seconds we need to spot this and
971 * drop the packet.
972 */
973
974static void ab_cleanup(unsigned long h)
975{
David S. Millerde103342009-05-28 16:46:29 -0700976 struct sk_buff *skb, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 unsigned long flags;
978
979 spin_lock_irqsave(&aun_queue_lock, flags);
David S. Millerde103342009-05-28 16:46:29 -0700980 skb_queue_walk_safe(&aun_queue, skb, n) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
David S. Millerde103342009-05-28 16:46:29 -0700982 if ((jiffies - eb->start) > eb->timeout) {
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +0900983 tx_result(skb->sk, eb->cookie,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 ECTYPE_TRANSMIT_NOT_PRESENT);
David S. Miller8728b832005-08-09 19:25:21 -0700985 skb_unlink(skb, &aun_queue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 kfree_skb(skb);
987 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989 spin_unlock_irqrestore(&aun_queue_lock, flags);
990
Joe Perchesee9c88f2011-07-03 08:28:33 +0000991 mod_timer(&ab_cleanup_timer, jiffies + (HZ * 2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992}
993
994static int __init aun_udp_initialise(void)
995{
996 int error;
997 struct sockaddr_in sin;
998
999 skb_queue_head_init(&aun_queue);
Pavel Emelyanovb24b8a22008-01-23 21:20:07 -08001000 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
Joe Perchesee9c88f2011-07-03 08:28:33 +00001001 ab_cleanup_timer.expires = jiffies + (HZ * 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 add_timer(&ab_cleanup_timer);
1003
1004 memset(&sin, 0, sizeof(sin));
1005 sin.sin_port = htons(AUN_PORT);
1006
1007 /* We can count ourselves lucky Acorn machines are too dim to
1008 speak IPv6. :-) */
Joe Perchesee9c88f2011-07-03 08:28:33 +00001009 error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock);
1010 if (error < 0) {
1011 pr_err("AUN: socket error %d\n", -error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 return error;
1013 }
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 udpsock->sk->sk_reuse = 1;
1016 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1017 from interrupts */
YOSHIFUJI Hideakic9b6aab2007-02-09 23:24:42 +09001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
Joe Perchesee9c88f2011-07-03 08:28:33 +00001020 sizeof(sin));
1021 if (error < 0) {
1022 pr_err("AUN: bind error %d\n", -error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 goto release;
1024 }
1025
1026 udpsock->sk->sk_data_ready = aun_data_available;
1027
1028 return 0;
1029
1030release:
1031 sock_release(udpsock);
1032 udpsock = NULL;
1033 return error;
1034}
1035#endif
1036
1037#ifdef CONFIG_ECONET_NATIVE
1038
1039/*
1040 * Receive an Econet frame from a device.
1041 */
1042
Joe Perchesee9c88f2011-07-03 08:28:33 +00001043static int econet_rcv(struct sk_buff *skb, struct net_device *dev,
1044 struct packet_type *pt, struct net_device *orig_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045{
1046 struct ec_framehdr *hdr;
Eric Dumazet0c78a922010-06-09 16:33:05 +00001047 struct sock *sk = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 struct ec_device *edev = dev->ec_ptr;
1049
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -07001050 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane730c152007-09-17 11:53:39 -07001051 goto drop;
1052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (skb->pkt_type == PACKET_OTHERHOST)
1054 goto drop;
1055
1056 if (!edev)
1057 goto drop;
1058
Joe Perchesee9c88f2011-07-03 08:28:33 +00001059 skb = skb_share_check(skb, GFP_ATOMIC);
1060 if (skb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 return NET_RX_DROP;
1062
1063 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1064 goto drop;
1065
Joe Perchesee9c88f2011-07-03 08:28:33 +00001066 hdr = (struct ec_framehdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
1068 /* First check for encapsulated IP */
1069 if (hdr->port == EC_PORT_IP) {
1070 skb->protocol = htons(ETH_P_IP);
1071 skb_pull(skb, sizeof(struct ec_framehdr));
1072 netif_rx(skb);
Mark Smith482d8042009-07-06 11:05:58 +00001073 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075
1076 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1077 if (!sk)
1078 goto drop;
1079
1080 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1081 hdr->port))
1082 goto drop;
Eric Dumazet0c78a922010-06-09 16:33:05 +00001083 sock_put(sk);
Mark Smith482d8042009-07-06 11:05:58 +00001084 return NET_RX_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085
1086drop:
Eric Dumazet0c78a922010-06-09 16:33:05 +00001087 if (sk)
1088 sock_put(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 kfree_skb(skb);
1090 return NET_RX_DROP;
1091}
1092
Stephen Hemminger7546dd92009-03-09 08:18:29 +00001093static struct packet_type econet_packet_type __read_mostly = {
Joe Perchesee9c88f2011-07-03 08:28:33 +00001094 .type = cpu_to_be16(ETH_P_ECONET),
1095 .func = econet_rcv,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096};
1097
1098static void econet_hw_initialise(void)
1099{
1100 dev_add_pack(&econet_packet_type);
1101}
1102
1103#endif
1104
Joe Perchesee9c88f2011-07-03 08:28:33 +00001105static int econet_notifier(struct notifier_block *this, unsigned long msg,
1106 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107{
Joe Perchesee9c88f2011-07-03 08:28:33 +00001108 struct net_device *dev = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 struct ec_device *edev;
1110
YOSHIFUJI Hideaki721499e2008-07-19 22:34:43 -07001111 if (!net_eq(dev_net(dev), &init_net))
Eric W. Biedermane9dc8652007-09-12 13:02:17 +02001112 return NOTIFY_DONE;
1113
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 switch (msg) {
1115 case NETDEV_UNREGISTER:
1116 /* A device has gone down - kill any data we hold for it. */
1117 edev = dev->ec_ptr;
Joe Perchesee9c88f2011-07-03 08:28:33 +00001118 if (edev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 if (net2dev_map[0] == dev)
1120 net2dev_map[0] = NULL;
1121 net2dev_map[edev->net] = NULL;
1122 kfree(edev);
1123 dev->ec_ptr = NULL;
1124 }
1125 break;
1126 }
1127
1128 return NOTIFY_DONE;
1129}
1130
1131static struct notifier_block econet_netdev_notifier = {
Joe Perchesee9c88f2011-07-03 08:28:33 +00001132 .notifier_call = econet_notifier,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133};
1134
1135static void __exit econet_proto_exit(void)
1136{
1137#ifdef CONFIG_ECONET_AUNUDP
1138 del_timer(&ab_cleanup_timer);
1139 if (udpsock)
1140 sock_release(udpsock);
1141#endif
1142 unregister_netdevice_notifier(&econet_netdev_notifier);
Alexey Dobriyan9c29a372007-08-14 17:25:20 -07001143#ifdef CONFIG_ECONET_NATIVE
1144 dev_remove_pack(&econet_packet_type);
1145#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 sock_unregister(econet_family_ops.family);
1147 proto_unregister(&econet_proto);
1148}
1149
1150static int __init econet_proto_init(void)
1151{
1152 int err = proto_register(&econet_proto, 0);
1153
1154 if (err != 0)
1155 goto out;
1156 sock_register(&econet_family_ops);
1157#ifdef CONFIG_ECONET_AUNUDP
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 aun_udp_initialise();
1159#endif
1160#ifdef CONFIG_ECONET_NATIVE
1161 econet_hw_initialise();
1162#endif
1163 register_netdevice_notifier(&econet_netdev_notifier);
1164out:
1165 return err;
1166}
1167
1168module_init(econet_proto_init);
1169module_exit(econet_proto_exit);
1170
1171MODULE_LICENSE("GPL");
1172MODULE_ALIAS_NETPROTO(PF_ECONET);