1/*
2 *	An implementation of the Acorn Econet and AUN protocols.
3 *	Philip Blundell <philb@gnu.org>
4 *
5 *	This program is free software; you can redistribute it and/or
6 *	modify it under the terms of the GNU General Public License
7 *	as published by the Free Software Foundation; either version
8 *	2 of the License, or (at your option) any later version.
9 *
10 */
11
12#include <linux/module.h>
13
14#include <linux/types.h>
15#include <linux/kernel.h>
16#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>
32#include <linux/udp.h>
33#include <linux/slab.h>
34#include <linux/vmalloc.h>
35#include <net/sock.h>
36#include <net/inet_common.h>
37#include <linux/stat.h>
38#include <linux/init.h>
39#include <linux/if_ec.h>
40#include <net/udp.h>
41#include <net/ip.h>
42#include <linux/spinlock.h>
43#include <linux/rcupdate.h>
44#include <linux/bitops.h>
45#include <linux/mutex.h>
46
47#include <asm/uaccess.h>
48#include <asm/system.h>
49
50static const struct proto_ops econet_ops;
51static struct hlist_head econet_sklist;
52static DEFINE_SPINLOCK(econet_lock);
53static DEFINE_MUTEX(econet_mutex);
54
55/* Since there are only 256 possible network numbers (or fewer, depends
56   how you count) it makes sense to use a simple lookup table. */
57static struct net_device *net2dev_map[256];
58
59#define EC_PORT_IP	0xd2
60
61#ifdef CONFIG_ECONET_AUNUDP
62static DEFINE_SPINLOCK(aun_queue_lock);
63static struct socket *udpsock;
64#define AUN_PORT	0x8000
65
66
67struct aunhdr
68{
69	unsigned char code;		/* AUN magic protocol byte */
70	unsigned char port;
71	unsigned char cb;
72	unsigned char pad;
73	unsigned long handle;
74};
75
76static unsigned long aun_seq;
77
78/* Queue of packets waiting to be transmitted. */
79static struct sk_buff_head aun_queue;
80static struct timer_list ab_cleanup_timer;
81
82#endif		/* CONFIG_ECONET_AUNUDP */
83
84/* Per-packet information */
85struct ec_cb
86{
87	struct sockaddr_ec sec;
88	unsigned long cookie;		/* Supplied by user. */
89#ifdef CONFIG_ECONET_AUNUDP
90	int done;
91	unsigned long seq;		/* Sequencing */
92	unsigned long timeout;		/* Timeout */
93	unsigned long start;		/* jiffies */
94#endif
95#ifdef CONFIG_ECONET_NATIVE
96	void (*sent)(struct sk_buff *, int result);
97#endif
98};
99
100static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
101{
102	spin_lock_bh(&econet_lock);
103	sk_del_node_init(sk);
104	spin_unlock_bh(&econet_lock);
105}
106
107static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
108{
109	spin_lock_bh(&econet_lock);
110	sk_add_node(sk, list);
111	spin_unlock_bh(&econet_lock);
112}
113
114/*
115 *	Pull a packet from our receive queue and hand it to the user.
116 *	If necessary we block.
117 */
118
119static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
120			  struct msghdr *msg, size_t len, int flags)
121{
122	struct sock *sk = sock->sk;
123	struct sk_buff *skb;
124	size_t copied;
125	int err;
126
127	msg->msg_namelen = sizeof(struct sockaddr_ec);
128
129	mutex_lock(&econet_mutex);
130
131	/*
132	 *	Call the generic datagram receiver. This handles all sorts
133	 *	of horrible races and re-entrancy so we can forget about it
134	 *	in the protocol layers.
135	 *
136	 *	Now it will return ENETDOWN, if device have just gone down,
137	 *	but then it will block.
138	 */
139
140	skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
141
142	/*
143	 *	An error occurred so return it. Because skb_recv_datagram()
144	 *	handles the blocking we don't see and worry about blocking
145	 *	retries.
146	 */
147
148	if(skb==NULL)
149		goto out;
150
151	/*
152	 *	You lose any data beyond the buffer you gave. If it worries a
153	 *	user program they can ask the device for its MTU anyway.
154	 */
155
156	copied = skb->len;
157	if (copied > len)
158	{
159		copied=len;
160		msg->msg_flags|=MSG_TRUNC;
161	}
162
163	/* We can't use skb_copy_datagram here */
164	err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
165	if (err)
166		goto out_free;
167	sk->sk_stamp = skb->tstamp;
168
169	if (msg->msg_name)
170		memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
171
172	/*
173	 *	Free or return the buffer as appropriate. Again this
174	 *	hides all the races and re-entrancy issues from us.
175	 */
176	err = copied;
177
178out_free:
179	skb_free_datagram(sk, skb);
180out:
181	mutex_unlock(&econet_mutex);
182	return err;
183}
184
185/*
186 *	Bind an Econet socket.
187 */
188
189static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
190{
191	struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
192	struct sock *sk;
193	struct econet_sock *eo;
194
195	/*
196	 *	Check legality
197	 */
198
199	if (addr_len < sizeof(struct sockaddr_ec) ||
200	    sec->sec_family != AF_ECONET)
201		return -EINVAL;
202
203	mutex_lock(&econet_mutex);
204
205	sk = sock->sk;
206	eo = ec_sk(sk);
207
208	eo->cb	    = sec->cb;
209	eo->port    = sec->port;
210	eo->station = sec->addr.station;
211	eo->net	    = sec->addr.net;
212
213	mutex_unlock(&econet_mutex);
214
215	return 0;
216}
217
218#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
219/*
220 *	Queue a transmit result for the user to be told about.
221 */
222
223static void tx_result(struct sock *sk, unsigned long cookie, int result)
224{
225	struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
226	struct ec_cb *eb;
227	struct sockaddr_ec *sec;
228
229	if (skb == NULL)
230	{
231		printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
232		return;
233	}
234
235	eb = (struct ec_cb *)&skb->cb;
236	sec = (struct sockaddr_ec *)&eb->sec;
237	memset(sec, 0, sizeof(struct sockaddr_ec));
238	sec->cookie = cookie;
239	sec->type = ECTYPE_TRANSMIT_STATUS | result;
240	sec->sec_family = AF_ECONET;
241
242	if (sock_queue_rcv_skb(sk, skb) < 0)
243		kfree_skb(skb);
244}
245#endif
246
247#ifdef CONFIG_ECONET_NATIVE
248/*
249 *	Called by the Econet hardware driver when a packet transmit
250 *	has completed.  Tell the user.
251 */
252
253static void ec_tx_done(struct sk_buff *skb, int result)
254{
255	struct ec_cb *eb = (struct ec_cb *)&skb->cb;
256	tx_result(skb->sk, eb->cookie, result);
257}
258#endif
259
260/*
261 *	Send a packet.  We have to work out which device it's going out on
262 *	and hence whether to use real Econet or the UDP emulation.
263 */
264
265static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
266			  struct msghdr *msg, size_t len)
267{
268	struct sock *sk = sock->sk;
269	struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
270	struct net_device *dev;
271	struct ec_addr addr;
272	int err;
273	unsigned char port, cb;
274#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
275	struct sk_buff *skb;
276	struct ec_cb *eb;
277#endif
278#ifdef CONFIG_ECONET_AUNUDP
279	struct msghdr udpmsg;
280	struct iovec iov[2];
281	struct aunhdr ah;
282	struct sockaddr_in udpdest;
283	__kernel_size_t size;
284	mm_segment_t oldfs;
285	char *userbuf;
286#endif
287
288	/*
289	 *	Check the flags.
290	 */
291
292	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
293		return -EINVAL;
294
295	/*
296	 *	Get and verify the address.
297	 */
298
299	mutex_lock(&econet_mutex);
300
301        if (saddr == NULL || msg->msg_namelen < sizeof(struct sockaddr_ec)) {
302                mutex_unlock(&econet_mutex);
303                return -EINVAL;
304        }
305        addr.station = saddr->addr.station;
306        addr.net = saddr->addr.net;
307        port = saddr->port;
308        cb = saddr->cb;
309
310	/* Look for a device with the right network number. */
311	dev = net2dev_map[addr.net];
312
313	/* If not directly reachable, use some default */
314	if (dev == NULL) {
315		dev = net2dev_map[0];
316		/* No interfaces at all? */
317		if (dev == NULL) {
318			mutex_unlock(&econet_mutex);
319			return -ENETDOWN;
320		}
321	}
322
323	if (dev->type == ARPHRD_ECONET) {
324		/* Real hardware Econet.  We're not worthy etc. */
325#ifdef CONFIG_ECONET_NATIVE
326		unsigned short proto = 0;
327		int res;
328
329		if (len + 15 > dev->mtu) {
330			mutex_unlock(&econet_mutex);
331			return -EMSGSIZE;
332		}
333
334		dev_hold(dev);
335
336		skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
337					  msg->msg_flags & MSG_DONTWAIT, &err);
338		if (skb==NULL)
339			goto out_unlock;
340
341		skb_reserve(skb, LL_RESERVED_SPACE(dev));
342		skb_reset_network_header(skb);
343
344		eb = (struct ec_cb *)&skb->cb;
345
346		eb->cookie = saddr->cookie;
347		eb->sec = *saddr;
348		eb->sent = ec_tx_done;
349
350		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) {
355			struct ec_framehdr *fh;
356			/* Poke in our control byte and
357			   port number.  Hack, hack.  */
358			fh = (struct ec_framehdr *)(skb->data);
359			fh->cb = cb;
360			fh->port = port;
361			if (sock->type != SOCK_DGRAM) {
362				skb_reset_tail_pointer(skb);
363				skb->len = 0;
364			}
365		}
366
367		/* Copy the data. Returns -EFAULT on error */
368		err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
369		skb->protocol = proto;
370		skb->dev = dev;
371		skb->priority = sk->sk_priority;
372		if (err)
373			goto out_free;
374
375		err = -ENETDOWN;
376		if (!(dev->flags & IFF_UP))
377			goto out_free;
378
379		/*
380		 *	Now send it
381		 */
382
383		dev_queue_xmit(skb);
384		dev_put(dev);
385		mutex_unlock(&econet_mutex);
386		return(len);
387
388	out_free:
389		kfree_skb(skb);
390	out_unlock:
391		if (dev)
392			dev_put(dev);
393#else
394		err = -EPROTOTYPE;
395#endif
396		mutex_unlock(&econet_mutex);
397
398		return err;
399	}
400
401#ifdef CONFIG_ECONET_AUNUDP
402	/* AUN virtual Econet. */
403
404	if (udpsock == NULL) {
405		mutex_unlock(&econet_mutex);
406		return -ENETDOWN;		/* No socket - can't send */
407	}
408
409	if (len > 32768) {
410		err = -E2BIG;
411		goto error;
412	}
413
414	/* 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();
428		idev = __in_dev_get_rcu(dev);
429		if (idev) {
430			if (idev->ifa_list)
431				network = ntohl(idev->ifa_list->ifa_address) &
432					0xffffff00;		/* !!! */
433		}
434		rcu_read_unlock();
435		udpdest.sin_addr.s_addr = htonl(network | addr.station);
436	}
437
438	ah.port = port;
439	ah.cb = cb & 0x7f;
440	ah.code = 2;		/* magic */
441	ah.pad = 0;
442
443	/* tack our header on the front of the iovec */
444	size = sizeof(struct aunhdr);
445	iov[0].iov_base = (void *)&ah;
446	iov[0].iov_len = size;
447
448	userbuf = vmalloc(len);
449	if (userbuf == NULL) {
450		err = -ENOMEM;
451		goto error;
452	}
453
454	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
460	/* Get a skbuff (no data, just holds our cb information) */
461	if ((skb = sock_alloc_send_skb(sk, 0,
462				       msg->msg_flags & MSG_DONTWAIT,
463				       &err)) == NULL)
464		goto error_free_buf;
465
466	eb = (struct ec_cb *)&skb->cb;
467
468	eb->cookie = saddr->cookie;
469	eb->timeout = (5*HZ);
470	eb->start = jiffies;
471	ah.handle = aun_seq;
472	eb->seq = (aun_seq++);
473	eb->sec = *saddr;
474
475	skb_queue_tail(&aun_queue, skb);
476
477	udpmsg.msg_name = (void *)&udpdest;
478	udpmsg.msg_namelen = sizeof(udpdest);
479	udpmsg.msg_iov = &iov[0];
480	udpmsg.msg_iovlen = 2;
481	udpmsg.msg_control = NULL;
482	udpmsg.msg_controllen = 0;
483	udpmsg.msg_flags=0;
484
485	oldfs = get_fs(); set_fs(KERNEL_DS);	/* More privs :-) */
486	err = sock_sendmsg(udpsock, &udpmsg, size);
487	set_fs(oldfs);
488
489error_free_buf:
490	vfree(userbuf);
491#else
492	err = -EPROTOTYPE;
493#endif
494	error:
495	mutex_unlock(&econet_mutex);
496
497	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{
507	struct sock *sk;
508	struct econet_sock *eo;
509	struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
510
511	if (peer)
512		return -EOPNOTSUPP;
513
514	memset(sec, 0, sizeof(*sec));
515	mutex_lock(&econet_mutex);
516
517	sk = sock->sk;
518	eo = ec_sk(sk);
519
520	sec->sec_family	  = AF_ECONET;
521	sec->port	  = eo->port;
522	sec->addr.station = eo->station;
523	sec->addr.net	  = eo->net;
524
525	mutex_unlock(&econet_mutex);
526
527	*uaddr_len = sizeof(*sec);
528	return 0;
529}
530
531static void econet_destroy_timer(unsigned long data)
532{
533	struct sock *sk=(struct sock *)data;
534
535	if (!sk_has_allocations(sk)) {
536		sk_free(sk);
537		return;
538	}
539
540	sk->sk_timer.expires = jiffies + 10 * HZ;
541	add_timer(&sk->sk_timer);
542	printk(KERN_DEBUG "econet socket destroy delayed\n");
543}
544
545/*
546 *	Close an econet socket.
547 */
548
549static int econet_release(struct socket *sock)
550{
551	struct sock *sk;
552
553	mutex_lock(&econet_mutex);
554
555	sk = sock->sk;
556	if (!sk)
557		goto out_unlock;
558
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
567	sock_orphan(sk);
568
569	/* Purge queues */
570
571	skb_queue_purge(&sk->sk_receive_queue);
572
573	if (sk_has_allocations(sk)) {
574		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);
578
579		goto out_unlock;
580	}
581
582	sk_free(sk);
583
584out_unlock:
585	mutex_unlock(&econet_mutex);
586	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
599static int econet_create(struct net *net, struct socket *sock, int protocol,
600			 int kern)
601{
602	struct sock *sk;
603	struct econet_sock *eo;
604	int err;
605
606	if (!net_eq(net, &init_net))
607		return -EAFNOSUPPORT;
608
609	/* Econet only provides datagram services. */
610	if (sock->type != SOCK_DGRAM)
611		return -ESOCKTNOSUPPORT;
612
613	sock->state = SS_UNCONNECTED;
614
615	err = -ENOBUFS;
616	sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
617	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);
630	return(0);
631out:
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;
645	int err;
646
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
654	if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
655		return -ENODEV;
656
657	sec = (struct sockaddr_ec *)&ifr.ifr_addr;
658
659	mutex_lock(&econet_mutex);
660
661	err = 0;
662	switch (cmd) {
663	case SIOCSIFADDR:
664		if (!capable(CAP_NET_ADMIN)) {
665			err = -EPERM;
666			break;
667		}
668
669		edev = dev->ec_ptr;
670		if (edev == NULL) {
671			/* Magic up a new one. */
672			edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
673			if (edev == NULL) {
674				err = -ENOMEM;
675				break;
676			}
677			dev->ec_ptr = edev;
678		} else
679			net2dev_map[edev->net] = NULL;
680		edev->station = sec->addr.station;
681		edev->net = sec->addr.net;
682		net2dev_map[sec->addr.net] = dev;
683		if (!net2dev_map[0])
684			net2dev_map[0] = dev;
685		break;
686
687	case SIOCGIFADDR:
688		edev = dev->ec_ptr;
689		if (edev == NULL) {
690			err = -ENODEV;
691			break;
692		}
693		memset(sec, 0, sizeof(struct sockaddr_ec));
694		sec->addr.station = edev->station;
695		sec->addr.net = edev->net;
696		sec->sec_family = AF_ECONET;
697		dev_put(dev);
698		if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
699			err = -EFAULT;
700		break;
701
702	default:
703		err = -EINVAL;
704		break;
705	}
706
707	mutex_unlock(&econet_mutex);
708
709	dev_put(dev);
710
711	return err;
712}
713
714/*
715 *	Handle generic ioctls
716 */
717
718static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
719{
720	struct sock *sk = sock->sk;
721	void __user *argp = (void __user *)arg;
722
723	switch(cmd) {
724		case SIOCGSTAMP:
725			return sock_get_timestamp(sk, argp);
726
727		case SIOCGSTAMPNS:
728			return sock_get_timestampns(sk, argp);
729
730		case SIOCSIFADDR:
731		case SIOCGIFADDR:
732			return ec_dev_ioctl(sock, cmd, argp);
733			break;
734
735		default:
736			return -ENOIOCTLCMD;
737	}
738	/*NOTREACHED*/
739	return 0;
740}
741
742static const struct net_proto_family econet_family_ops = {
743	.family =	PF_ECONET,
744	.create =	econet_create,
745	.owner	=	THIS_MODULE,
746};
747
748static const struct proto_ops econet_ops = {
749	.family =	PF_ECONET,
750	.owner =	THIS_MODULE,
751	.release =	econet_release,
752	.bind =		econet_bind,
753	.connect =	sock_no_connect,
754	.socketpair =	sock_no_socketpair,
755	.accept =	sock_no_accept,
756	.getname =	econet_getname,
757	.poll =		datagram_poll,
758	.ioctl =	econet_ioctl,
759	.listen =	sock_no_listen,
760	.shutdown =	sock_no_shutdown,
761	.setsockopt =	sock_no_setsockopt,
762	.getsockopt =	sock_no_getsockopt,
763	.sendmsg =	econet_sendmsg,
764	.recvmsg =	econet_recvmsg,
765	.mmap =		sock_no_mmap,
766	.sendpage =	sock_no_sendpage,
767};
768
769#if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
770/*
771 *	Find the listening socket, if any, for the given data.
772 */
773
774static struct sock *ec_listening_socket(unsigned char port, unsigned char
775				 station, unsigned char net)
776{
777	struct sock *sk;
778	struct hlist_node *node;
779
780	spin_lock(&econet_lock);
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			sock_hold(sk);
787			goto found;
788		}
789	}
790	sk = NULL;
791found:
792	spin_unlock(&econet_lock);
793	return sk;
794}
795
796/*
797 *	Queue a received packet for a socket.
798 */
799
800static int ec_queue_packet(struct sock *sk, struct sk_buff *skb,
801			   unsigned char stn, unsigned char net,
802			   unsigned char cb, unsigned char port)
803{
804	struct ec_cb *eb = (struct ec_cb *)&skb->cb;
805	struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
806
807	memset(sec, 0, sizeof(struct sockaddr_ec));
808	sec->sec_family = AF_ECONET;
809	sec->type = ECTYPE_PACKET_RECEIVED;
810	sec->port = port;
811	sec->cb = cb;
812	sec->addr.net = net;
813	sec->addr.station = stn;
814
815	return sock_queue_rcv_skb(sk, skb);
816}
817#endif
818
819#ifdef CONFIG_ECONET_AUNUDP
820/*
821 *	Send an AUN protocol response.
822 */
823
824static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
825{
826	struct sockaddr_in sin = {
827		.sin_family = AF_INET,
828		.sin_port = htons(AUN_PORT),
829		.sin_addr = {.s_addr = addr}
830	};
831	struct aunhdr ah = {.code = code, .cb = cb, .handle = seq};
832	struct kvec iov = {.iov_base = (void *)&ah, .iov_len = sizeof(ah)};
833	struct msghdr udpmsg;
834
835	udpmsg.msg_name = (void *)&sin;
836	udpmsg.msg_namelen = sizeof(sin);
837	udpmsg.msg_control = NULL;
838	udpmsg.msg_controllen = 0;
839	udpmsg.msg_flags=0;
840
841	kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
842}
843
844
845/*
846 *	Handle incoming AUN packets.  Work out if anybody wants them,
847 *	and send positive or negative acknowledgements as appropriate.
848 */
849
850static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
851{
852	struct iphdr *ip = ip_hdr(skb);
853	unsigned char stn = ntohl(ip->saddr) & 0xff;
854	struct dst_entry *dst = skb_dst(skb);
855	struct ec_device *edev = NULL;
856	struct sock *sk = NULL;
857	struct sk_buff *newskb;
858
859	if (dst)
860		edev = dst->dev->ec_ptr;
861
862	if (! edev)
863		goto bad;
864
865	if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
866		goto bad;		/* Nobody wants it */
867
868	newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
869			   GFP_ATOMIC);
870	if (newskb == NULL)
871	{
872		printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
873		/* Send nack and hope sender tries again */
874		goto bad;
875	}
876
877	memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
878	       len - sizeof(struct aunhdr));
879
880	if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
881	{
882		/* Socket is bankrupt. */
883		kfree_skb(newskb);
884		goto bad;
885	}
886
887	aun_send_response(ip->saddr, ah->handle, 3, 0);
888	sock_put(sk);
889	return;
890
891bad:
892	aun_send_response(ip->saddr, ah->handle, 4, 0);
893	if (sk)
894		sock_put(sk);
895}
896
897/*
898 *	Handle incoming AUN transmit acknowledgements.  If the sequence
899 *      number matches something in our backlog then kill it and tell
900 *	the user.  If the remote took too long to reply then we may have
901 *	dropped the packet already.
902 */
903
904static void aun_tx_ack(unsigned long seq, int result)
905{
906	struct sk_buff *skb;
907	unsigned long flags;
908	struct ec_cb *eb;
909
910	spin_lock_irqsave(&aun_queue_lock, flags);
911	skb_queue_walk(&aun_queue, skb) {
912		eb = (struct ec_cb *)&skb->cb;
913		if (eb->seq == seq)
914			goto foundit;
915	}
916	spin_unlock_irqrestore(&aun_queue_lock, flags);
917	printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
918	return;
919
920foundit:
921	tx_result(skb->sk, eb->cookie, result);
922	skb_unlink(skb, &aun_queue);
923	spin_unlock_irqrestore(&aun_queue_lock, flags);
924	kfree_skb(skb);
925}
926
927/*
928 *	Deal with received AUN frames - sort out what type of thing it is
929 *	and hand it to the right function.
930 */
931
932static void aun_data_available(struct sock *sk, int slen)
933{
934	int err;
935	struct sk_buff *skb;
936	unsigned char *data;
937	struct aunhdr *ah;
938	struct iphdr *ip;
939	size_t len;
940
941	while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
942		if (err == -EAGAIN) {
943			printk(KERN_ERR "AUN: no data available?!");
944			return;
945		}
946		printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
947	}
948
949	data = skb_transport_header(skb) + sizeof(struct udphdr);
950	ah = (struct aunhdr *)data;
951	len = skb->len - sizeof(struct udphdr);
952	ip = ip_hdr(skb);
953
954	switch (ah->code)
955	{
956	case 2:
957		aun_incoming(skb, ah, len);
958		break;
959	case 3:
960		aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
961		break;
962	case 4:
963		aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
964		break;
965	default:
966		printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
967	}
968
969	skb_free_datagram(sk, skb);
970}
971
972/*
973 *	Called by the timer to manage the AUN transmit queue.  If a packet
974 *	was sent to a dead or nonexistent host then we will never get an
975 *	acknowledgement back.  After a few seconds we need to spot this and
976 *	drop the packet.
977 */
978
979static void ab_cleanup(unsigned long h)
980{
981	struct sk_buff *skb, *n;
982	unsigned long flags;
983
984	spin_lock_irqsave(&aun_queue_lock, flags);
985	skb_queue_walk_safe(&aun_queue, skb, n) {
986		struct ec_cb *eb = (struct ec_cb *)&skb->cb;
987		if ((jiffies - eb->start) > eb->timeout) {
988			tx_result(skb->sk, eb->cookie,
989				  ECTYPE_TRANSMIT_NOT_PRESENT);
990			skb_unlink(skb, &aun_queue);
991			kfree_skb(skb);
992		}
993	}
994	spin_unlock_irqrestore(&aun_queue_lock, flags);
995
996	mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
997}
998
999static int __init aun_udp_initialise(void)
1000{
1001	int error;
1002	struct sockaddr_in sin;
1003
1004	skb_queue_head_init(&aun_queue);
1005	spin_lock_init(&aun_queue_lock);
1006	setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
1007	ab_cleanup_timer.expires = jiffies + (HZ*2);
1008	add_timer(&ab_cleanup_timer);
1009
1010	memset(&sin, 0, sizeof(sin));
1011	sin.sin_port = htons(AUN_PORT);
1012
1013	/* We can count ourselves lucky Acorn machines are too dim to
1014	   speak IPv6. :-) */
1015	if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1016	{
1017		printk("AUN: socket error %d\n", -error);
1018		return error;
1019	}
1020
1021	udpsock->sk->sk_reuse = 1;
1022	udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1023						    from interrupts */
1024
1025	error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1026				sizeof(sin));
1027	if (error < 0)
1028	{
1029		printk("AUN: bind error %d\n", -error);
1030		goto release;
1031	}
1032
1033	udpsock->sk->sk_data_ready = aun_data_available;
1034
1035	return 0;
1036
1037release:
1038	sock_release(udpsock);
1039	udpsock = NULL;
1040	return error;
1041}
1042#endif
1043
1044#ifdef CONFIG_ECONET_NATIVE
1045
1046/*
1047 *	Receive an Econet frame from a device.
1048 */
1049
1050static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1051{
1052	struct ec_framehdr *hdr;
1053	struct sock *sk = NULL;
1054	struct ec_device *edev = dev->ec_ptr;
1055
1056	if (!net_eq(dev_net(dev), &init_net))
1057		goto drop;
1058
1059	if (skb->pkt_type == PACKET_OTHERHOST)
1060		goto drop;
1061
1062	if (!edev)
1063		goto drop;
1064
1065	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1066		return NET_RX_DROP;
1067
1068	if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1069		goto drop;
1070
1071	hdr = (struct ec_framehdr *) skb->data;
1072
1073	/* First check for encapsulated IP */
1074	if (hdr->port == EC_PORT_IP) {
1075		skb->protocol = htons(ETH_P_IP);
1076		skb_pull(skb, sizeof(struct ec_framehdr));
1077		netif_rx(skb);
1078		return NET_RX_SUCCESS;
1079	}
1080
1081	sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1082	if (!sk)
1083		goto drop;
1084
1085	if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1086			    hdr->port))
1087		goto drop;
1088	sock_put(sk);
1089	return NET_RX_SUCCESS;
1090
1091drop:
1092	if (sk)
1093		sock_put(sk);
1094	kfree_skb(skb);
1095	return NET_RX_DROP;
1096}
1097
1098static struct packet_type econet_packet_type __read_mostly = {
1099	.type =		cpu_to_be16(ETH_P_ECONET),
1100	.func =		econet_rcv,
1101};
1102
1103static void econet_hw_initialise(void)
1104{
1105	dev_add_pack(&econet_packet_type);
1106}
1107
1108#endif
1109
1110static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1111{
1112	struct net_device *dev = (struct net_device *)data;
1113	struct ec_device *edev;
1114
1115	if (!net_eq(dev_net(dev), &init_net))
1116		return NOTIFY_DONE;
1117
1118	switch (msg) {
1119	case NETDEV_UNREGISTER:
1120		/* A device has gone down - kill any data we hold for it. */
1121		edev = dev->ec_ptr;
1122		if (edev)
1123		{
1124			if (net2dev_map[0] == dev)
1125				net2dev_map[0] = NULL;
1126			net2dev_map[edev->net] = NULL;
1127			kfree(edev);
1128			dev->ec_ptr = NULL;
1129		}
1130		break;
1131	}
1132
1133	return NOTIFY_DONE;
1134}
1135
1136static struct notifier_block econet_netdev_notifier = {
1137	.notifier_call =econet_notifier,
1138};
1139
1140static void __exit econet_proto_exit(void)
1141{
1142#ifdef CONFIG_ECONET_AUNUDP
1143	del_timer(&ab_cleanup_timer);
1144	if (udpsock)
1145		sock_release(udpsock);
1146#endif
1147	unregister_netdevice_notifier(&econet_netdev_notifier);
1148#ifdef CONFIG_ECONET_NATIVE
1149	dev_remove_pack(&econet_packet_type);
1150#endif
1151	sock_unregister(econet_family_ops.family);
1152	proto_unregister(&econet_proto);
1153}
1154
1155static int __init econet_proto_init(void)
1156{
1157	int err = proto_register(&econet_proto, 0);
1158
1159	if (err != 0)
1160		goto out;
1161	sock_register(&econet_family_ops);
1162#ifdef CONFIG_ECONET_AUNUDP
1163	spin_lock_init(&aun_queue_lock);
1164	aun_udp_initialise();
1165#endif
1166#ifdef CONFIG_ECONET_NATIVE
1167	econet_hw_initialise();
1168#endif
1169	register_netdevice_notifier(&econet_netdev_notifier);
1170out:
1171	return err;
1172}
1173
1174module_init(econet_proto_init);
1175module_exit(econet_proto_exit);
1176
1177MODULE_LICENSE("GPL");
1178MODULE_ALIAS_NETPROTO(PF_ECONET);
1179