2 * An implementation of the Acorn Econet and AUN protocols.
3 * Philip Blundell <philb@gnu.org>
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.
12 #include <linux/module.h>
14 #include <linux/types.h>
15 #include <linux/kernel.h>
16 #include <linux/string.h>
18 #include <linux/socket.h>
19 #include <linux/sockios.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>
34 #include <net/inet_common.h>
35 #include <linux/stat.h>
36 #include <linux/init.h>
37 #include <linux/if_ec.h>
40 #include <linux/spinlock.h>
41 #include <linux/rcupdate.h>
42 #include <linux/bitops.h>
43 #include <linux/mutex.h>
45 #include <asm/uaccess.h>
46 #include <asm/system.h>
48 static const struct proto_ops econet_ops;
49 static struct hlist_head econet_sklist;
50 static DEFINE_RWLOCK(econet_lock);
51 static DEFINE_MUTEX(econet_mutex);
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. */
55 static struct net_device *net2dev_map[256];
57 #define EC_PORT_IP 0xd2
59 #ifdef CONFIG_ECONET_AUNUDP
60 static DEFINE_SPINLOCK(aun_queue_lock);
61 static struct socket *udpsock;
62 #define AUN_PORT 0x8000
67 unsigned char code; /* AUN magic protocol byte */
74 static unsigned long aun_seq;
76 /* Queue of packets waiting to be transmitted. */
77 static struct sk_buff_head aun_queue;
78 static struct timer_list ab_cleanup_timer;
80 #endif /* CONFIG_ECONET_AUNUDP */
82 /* Per-packet information */
85 struct sockaddr_ec sec;
86 unsigned long cookie; /* Supplied by user. */
87 #ifdef CONFIG_ECONET_AUNUDP
89 unsigned long seq; /* Sequencing */
90 unsigned long timeout; /* Timeout */
91 unsigned long start; /* jiffies */
93 #ifdef CONFIG_ECONET_NATIVE
94 void (*sent)(struct sk_buff *, int result);
98 static void econet_remove_socket(struct hlist_head *list, struct sock *sk)
100 write_lock_bh(&econet_lock);
101 sk_del_node_init(sk);
102 write_unlock_bh(&econet_lock);
105 static void econet_insert_socket(struct hlist_head *list, struct sock *sk)
107 write_lock_bh(&econet_lock);
108 sk_add_node(sk, list);
109 write_unlock_bh(&econet_lock);
113 * Pull a packet from our receive queue and hand it to the user.
114 * If necessary we block.
117 static int econet_recvmsg(struct kiocb *iocb, struct socket *sock,
118 struct msghdr *msg, size_t len, int flags)
120 struct sock *sk = sock->sk;
125 msg->msg_namelen = sizeof(struct sockaddr_ec);
127 mutex_lock(&econet_mutex);
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.
134 * Now it will return ENETDOWN, if device have just gone down,
135 * but then it will block.
138 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
141 * An error occurred so return it. Because skb_recv_datagram()
142 * handles the blocking we don't see and worry about blocking
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.
158 msg->msg_flags|=MSG_TRUNC;
161 /* We can't use skb_copy_datagram here */
162 err = memcpy_toiovec(msg->msg_iov, skb->data, copied);
165 sk->sk_stamp = skb->tstamp;
168 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
171 * Free or return the buffer as appropriate. Again this
172 * hides all the races and re-entrancy issues from us.
177 skb_free_datagram(sk, skb);
179 mutex_unlock(&econet_mutex);
184 * Bind an Econet socket.
187 static int econet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
189 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
191 struct econet_sock *eo;
197 if (addr_len < sizeof(struct sockaddr_ec) ||
198 sec->sec_family != AF_ECONET)
201 mutex_lock(&econet_mutex);
207 eo->port = sec->port;
208 eo->station = sec->addr.station;
209 eo->net = sec->addr.net;
211 mutex_unlock(&econet_mutex);
216 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
218 * Queue a transmit result for the user to be told about.
221 static void tx_result(struct sock *sk, unsigned long cookie, int result)
223 struct sk_buff *skb = alloc_skb(0, GFP_ATOMIC);
225 struct sockaddr_ec *sec;
229 printk(KERN_DEBUG "ec: memory squeeze, transmit result dropped.\n");
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;
240 if (sock_queue_rcv_skb(sk, skb) < 0)
245 #ifdef CONFIG_ECONET_NATIVE
247 * Called by the Econet hardware driver when a packet transmit
248 * has completed. Tell the user.
251 static void ec_tx_done(struct sk_buff *skb, int result)
253 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
254 tx_result(skb->sk, eb->cookie, result);
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.
263 static int econet_sendmsg(struct kiocb *iocb, struct socket *sock,
264 struct msghdr *msg, size_t len)
266 struct sock *sk = sock->sk;
267 struct sockaddr_ec *saddr=(struct sockaddr_ec *)msg->msg_name;
268 struct net_device *dev;
271 unsigned char port, cb;
272 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
276 #ifdef CONFIG_ECONET_AUNUDP
277 struct msghdr udpmsg;
278 struct iovec iov[msg->msg_iovlen+1];
280 struct sockaddr_in udpdest;
281 __kernel_size_t size;
290 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
294 * Get and verify the address.
297 mutex_lock(&econet_mutex);
300 struct econet_sock *eo = ec_sk(sk);
302 addr.station = eo->station;
307 if (msg->msg_namelen < sizeof(struct sockaddr_ec)) {
308 mutex_unlock(&econet_mutex);
311 addr.station = saddr->addr.station;
312 addr.net = saddr->addr.net;
317 /* Look for a device with the right network number. */
318 dev = net2dev_map[addr.net];
320 /* If not directly reachable, use some default */
322 dev = net2dev_map[0];
323 /* No interfaces at all? */
325 mutex_unlock(&econet_mutex);
330 if (len + 15 > dev->mtu) {
331 mutex_unlock(&econet_mutex);
335 if (dev->type == ARPHRD_ECONET) {
336 /* Real hardware Econet. We're not worthy etc. */
337 #ifdef CONFIG_ECONET_NATIVE
338 unsigned short proto = 0;
343 skb = sock_alloc_send_skb(sk, len+LL_ALLOCATED_SPACE(dev),
344 msg->msg_flags & MSG_DONTWAIT, &err);
348 skb_reserve(skb, LL_RESERVED_SPACE(dev));
349 skb_reset_network_header(skb);
351 eb = (struct ec_cb *)&skb->cb;
353 /* BUG: saddr may be NULL */
354 eb->cookie = saddr->cookie;
356 eb->sent = ec_tx_done;
359 res = dev_hard_header(skb, dev, ntohs(proto), &addr, NULL, len);
363 struct ec_framehdr *fh;
364 /* Poke in our control byte and
365 port number. Hack, hack. */
366 fh = (struct ec_framehdr *)(skb->data);
369 if (sock->type != SOCK_DGRAM) {
370 skb_reset_tail_pointer(skb);
375 /* Copy the data. Returns -EFAULT on error */
376 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
377 skb->protocol = proto;
379 skb->priority = sk->sk_priority;
384 if (!(dev->flags & IFF_UP))
393 mutex_unlock(&econet_mutex);
404 mutex_unlock(&econet_mutex);
409 #ifdef CONFIG_ECONET_AUNUDP
410 /* AUN virtual Econet. */
412 if (udpsock == NULL) {
413 mutex_unlock(&econet_mutex);
414 return -ENETDOWN; /* No socket - can't send */
417 /* Make up a UDP datagram and hand it off to some higher intellect. */
419 memset(&udpdest, 0, sizeof(udpdest));
420 udpdest.sin_family = AF_INET;
421 udpdest.sin_port = htons(AUN_PORT);
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. */
427 struct in_device *idev;
428 unsigned long network = 0;
431 idev = __in_dev_get_rcu(dev);
434 network = ntohl(idev->ifa_list->ifa_address) &
435 0xffffff00; /* !!! */
438 udpdest.sin_addr.s_addr = htonl(network | addr.station);
443 ah.code = 2; /* magic */
446 /* tack our header on the front of the iovec */
447 size = sizeof(struct aunhdr);
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
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. */
462 if (!access_ok(VERIFY_READ, base, len)) {
463 mutex_unlock(&econet_mutex);
466 iov[i+1].iov_base = base;
467 iov[i+1].iov_len = len;
471 /* Get a skbuff (no data, just holds our cb information) */
472 if ((skb = sock_alloc_send_skb(sk, 0,
473 msg->msg_flags & MSG_DONTWAIT,
475 mutex_unlock(&econet_mutex);
479 eb = (struct ec_cb *)&skb->cb;
481 eb->cookie = saddr->cookie;
482 eb->timeout = (5*HZ);
485 eb->seq = (aun_seq++);
488 skb_queue_tail(&aun_queue, skb);
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;
498 oldfs = get_fs(); set_fs(KERNEL_DS); /* More privs :-) */
499 err = sock_sendmsg(udpsock, &udpmsg, size);
504 mutex_unlock(&econet_mutex);
510 * Look up the address of a socket.
513 static int econet_getname(struct socket *sock, struct sockaddr *uaddr,
514 int *uaddr_len, int peer)
517 struct econet_sock *eo;
518 struct sockaddr_ec *sec = (struct sockaddr_ec *)uaddr;
523 mutex_lock(&econet_mutex);
528 sec->sec_family = AF_ECONET;
529 sec->port = eo->port;
530 sec->addr.station = eo->station;
531 sec->addr.net = eo->net;
533 mutex_unlock(&econet_mutex);
535 *uaddr_len = sizeof(*sec);
539 static void econet_destroy_timer(unsigned long data)
541 struct sock *sk=(struct sock *)data;
543 if (!atomic_read(&sk->sk_wmem_alloc) &&
544 !atomic_read(&sk->sk_rmem_alloc)) {
549 sk->sk_timer.expires = jiffies + 10 * HZ;
550 add_timer(&sk->sk_timer);
551 printk(KERN_DEBUG "econet socket destroy delayed\n");
555 * Close an econet socket.
558 static int econet_release(struct socket *sock)
562 mutex_lock(&econet_mutex);
568 econet_remove_socket(&econet_sklist, sk);
571 * Now the socket is dead. No more input will appear.
574 sk->sk_state_change(sk); /* It is useless. Just for sanity. */
580 skb_queue_purge(&sk->sk_receive_queue);
582 if (atomic_read(&sk->sk_rmem_alloc) ||
583 atomic_read(&sk->sk_wmem_alloc)) {
584 sk->sk_timer.data = (unsigned long)sk;
585 sk->sk_timer.expires = jiffies + HZ;
586 sk->sk_timer.function = econet_destroy_timer;
587 add_timer(&sk->sk_timer);
595 mutex_unlock(&econet_mutex);
599 static struct proto econet_proto = {
601 .owner = THIS_MODULE,
602 .obj_size = sizeof(struct econet_sock),
606 * Create an Econet socket
609 static int econet_create(struct net *net, struct socket *sock, int protocol)
612 struct econet_sock *eo;
615 if (net != &init_net)
616 return -EAFNOSUPPORT;
618 /* Econet only provides datagram services. */
619 if (sock->type != SOCK_DGRAM)
620 return -ESOCKTNOSUPPORT;
622 sock->state = SS_UNCONNECTED;
625 sk = sk_alloc(net, PF_ECONET, GFP_KERNEL, &econet_proto);
630 sock->ops = &econet_ops;
631 sock_init_data(sock, sk);
634 sock_reset_flag(sk, SOCK_ZAPPED);
635 sk->sk_family = PF_ECONET;
638 econet_insert_socket(&econet_sklist, sk);
645 * Handle Econet specific ioctls
648 static int ec_dev_ioctl(struct socket *sock, unsigned int cmd, void __user *arg)
651 struct ec_device *edev;
652 struct net_device *dev;
653 struct sockaddr_ec *sec;
657 * Fetch the caller's info block into kernel space
660 if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
663 if ((dev = dev_get_by_name(&init_net, ifr.ifr_name)) == NULL)
666 sec = (struct sockaddr_ec *)&ifr.ifr_addr;
668 mutex_lock(&econet_mutex);
675 /* Magic up a new one. */
676 edev = kzalloc(sizeof(struct ec_device), GFP_KERNEL);
683 net2dev_map[edev->net] = NULL;
684 edev->station = sec->addr.station;
685 edev->net = sec->addr.net;
686 net2dev_map[sec->addr.net] = dev;
688 net2dev_map[0] = dev;
697 memset(sec, 0, sizeof(struct sockaddr_ec));
698 sec->addr.station = edev->station;
699 sec->addr.net = edev->net;
700 sec->sec_family = AF_ECONET;
702 if (copy_to_user(arg, &ifr, sizeof(struct ifreq)))
711 mutex_unlock(&econet_mutex);
719 * Handle generic ioctls
722 static int econet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
724 struct sock *sk = sock->sk;
725 void __user *argp = (void __user *)arg;
729 return sock_get_timestamp(sk, argp);
732 return sock_get_timestampns(sk, argp);
736 return ec_dev_ioctl(sock, cmd, argp);
746 static struct net_proto_family econet_family_ops = {
748 .create = econet_create,
749 .owner = THIS_MODULE,
752 static const struct proto_ops econet_ops = {
754 .owner = THIS_MODULE,
755 .release = econet_release,
757 .connect = sock_no_connect,
758 .socketpair = sock_no_socketpair,
759 .accept = sock_no_accept,
760 .getname = econet_getname,
761 .poll = datagram_poll,
762 .ioctl = econet_ioctl,
763 .listen = sock_no_listen,
764 .shutdown = sock_no_shutdown,
765 .setsockopt = sock_no_setsockopt,
766 .getsockopt = sock_no_getsockopt,
767 .sendmsg = econet_sendmsg,
768 .recvmsg = econet_recvmsg,
769 .mmap = sock_no_mmap,
770 .sendpage = sock_no_sendpage,
773 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
775 * Find the listening socket, if any, for the given data.
778 static struct sock *ec_listening_socket(unsigned char port, unsigned char
779 station, unsigned char net)
782 struct hlist_node *node;
784 sk_for_each(sk, node, &econet_sklist) {
785 struct econet_sock *opt = ec_sk(sk);
786 if ((opt->port == port || opt->port == 0) &&
787 (opt->station == station || opt->station == 0) &&
788 (opt->net == net || opt->net == 0))
797 * Queue a received packet for a socket.
800 static 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)
804 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
805 struct sockaddr_ec *sec = (struct sockaddr_ec *)&eb->sec;
807 memset(sec, 0, sizeof(struct sockaddr_ec));
808 sec->sec_family = AF_ECONET;
809 sec->type = ECTYPE_PACKET_RECEIVED;
813 sec->addr.station = stn;
815 return sock_queue_rcv_skb(sk, skb);
819 #ifdef CONFIG_ECONET_AUNUDP
821 * Send an AUN protocol response.
824 static void aun_send_response(__u32 addr, unsigned long seq, int code, int cb)
826 struct sockaddr_in sin = {
827 .sin_family = AF_INET,
828 .sin_port = htons(AUN_PORT),
829 .sin_addr = {.s_addr = addr}
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;
835 udpmsg.msg_name = (void *)&sin;
836 udpmsg.msg_namelen = sizeof(sin);
837 udpmsg.msg_control = NULL;
838 udpmsg.msg_controllen = 0;
841 kernel_sendmsg(udpsock, &udpmsg, &iov, 1, sizeof(ah));
846 * Handle incoming AUN packets. Work out if anybody wants them,
847 * and send positive or negative acknowledgements as appropriate.
850 static void aun_incoming(struct sk_buff *skb, struct aunhdr *ah, size_t len)
852 struct iphdr *ip = ip_hdr(skb);
853 unsigned char stn = ntohl(ip->saddr) & 0xff;
855 struct sk_buff *newskb;
856 struct ec_device *edev = skb->dev->ec_ptr;
861 if ((sk = ec_listening_socket(ah->port, stn, edev->net)) == NULL)
862 goto bad; /* Nobody wants it */
864 newskb = alloc_skb((len - sizeof(struct aunhdr) + 15) & ~15,
868 printk(KERN_DEBUG "AUN: memory squeeze, dropping packet.\n");
869 /* Send nack and hope sender tries again */
873 memcpy(skb_put(newskb, len - sizeof(struct aunhdr)), (void *)(ah+1),
874 len - sizeof(struct aunhdr));
876 if (ec_queue_packet(sk, newskb, stn, edev->net, ah->cb, ah->port))
878 /* Socket is bankrupt. */
883 aun_send_response(ip->saddr, ah->handle, 3, 0);
887 aun_send_response(ip->saddr, ah->handle, 4, 0);
891 * Handle incoming AUN transmit acknowledgements. If the sequence
892 * number matches something in our backlog then kill it and tell
893 * the user. If the remote took too long to reply then we may have
894 * dropped the packet already.
897 static void aun_tx_ack(unsigned long seq, int result)
903 spin_lock_irqsave(&aun_queue_lock, flags);
904 skb = skb_peek(&aun_queue);
905 while (skb && skb != (struct sk_buff *)&aun_queue)
907 struct sk_buff *newskb = skb->next;
908 eb = (struct ec_cb *)&skb->cb;
914 spin_unlock_irqrestore(&aun_queue_lock, flags);
915 printk(KERN_DEBUG "AUN: unknown sequence %ld\n", seq);
919 tx_result(skb->sk, eb->cookie, result);
920 skb_unlink(skb, &aun_queue);
921 spin_unlock_irqrestore(&aun_queue_lock, flags);
926 * Deal with received AUN frames - sort out what type of thing it is
927 * and hand it to the right function.
930 static void aun_data_available(struct sock *sk, int slen)
939 while ((skb = skb_recv_datagram(sk, 0, 1, &err)) == NULL) {
940 if (err == -EAGAIN) {
941 printk(KERN_ERR "AUN: no data available?!");
944 printk(KERN_DEBUG "AUN: recvfrom() error %d\n", -err);
947 data = skb_transport_header(skb) + sizeof(struct udphdr);
948 ah = (struct aunhdr *)data;
949 len = skb->len - sizeof(struct udphdr);
955 aun_incoming(skb, ah, len);
958 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_OK);
961 aun_tx_ack(ah->handle, ECTYPE_TRANSMIT_NOT_LISTENING);
964 /* This isn't quite right yet. */
966 aun_send_response(ip->saddr, ah->handle, 6, ah->cb);
970 printk(KERN_DEBUG "unknown AUN packet (type %d)\n", data[0]);
973 skb_free_datagram(sk, skb);
977 * Called by the timer to manage the AUN transmit queue. If a packet
978 * was sent to a dead or nonexistent host then we will never get an
979 * acknowledgement back. After a few seconds we need to spot this and
983 static void ab_cleanup(unsigned long h)
988 spin_lock_irqsave(&aun_queue_lock, flags);
989 skb = skb_peek(&aun_queue);
990 while (skb && skb != (struct sk_buff *)&aun_queue)
992 struct sk_buff *newskb = skb->next;
993 struct ec_cb *eb = (struct ec_cb *)&skb->cb;
994 if ((jiffies - eb->start) > eb->timeout)
996 tx_result(skb->sk, eb->cookie,
997 ECTYPE_TRANSMIT_NOT_PRESENT);
998 skb_unlink(skb, &aun_queue);
1003 spin_unlock_irqrestore(&aun_queue_lock, flags);
1005 mod_timer(&ab_cleanup_timer, jiffies + (HZ*2));
1008 static int __init aun_udp_initialise(void)
1011 struct sockaddr_in sin;
1013 skb_queue_head_init(&aun_queue);
1014 spin_lock_init(&aun_queue_lock);
1015 setup_timer(&ab_cleanup_timer, ab_cleanup, 0);
1016 ab_cleanup_timer.expires = jiffies + (HZ*2);
1017 add_timer(&ab_cleanup_timer);
1019 memset(&sin, 0, sizeof(sin));
1020 sin.sin_port = htons(AUN_PORT);
1022 /* We can count ourselves lucky Acorn machines are too dim to
1024 if ((error = sock_create_kern(PF_INET, SOCK_DGRAM, 0, &udpsock)) < 0)
1026 printk("AUN: socket error %d\n", -error);
1030 udpsock->sk->sk_reuse = 1;
1031 udpsock->sk->sk_allocation = GFP_ATOMIC; /* we're going to call it
1034 error = udpsock->ops->bind(udpsock, (struct sockaddr *)&sin,
1038 printk("AUN: bind error %d\n", -error);
1042 udpsock->sk->sk_data_ready = aun_data_available;
1047 sock_release(udpsock);
1053 #ifdef CONFIG_ECONET_NATIVE
1056 * Receive an Econet frame from a device.
1059 static int econet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1061 struct ec_framehdr *hdr;
1063 struct ec_device *edev = dev->ec_ptr;
1065 if (!net_eq(dev_net(dev), &init_net))
1068 if (skb->pkt_type == PACKET_OTHERHOST)
1074 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
1077 if (!pskb_may_pull(skb, sizeof(struct ec_framehdr)))
1080 hdr = (struct ec_framehdr *) skb->data;
1082 /* First check for encapsulated IP */
1083 if (hdr->port == EC_PORT_IP) {
1084 skb->protocol = htons(ETH_P_IP);
1085 skb_pull(skb, sizeof(struct ec_framehdr));
1090 sk = ec_listening_socket(hdr->port, hdr->src_stn, hdr->src_net);
1094 if (ec_queue_packet(sk, skb, edev->net, hdr->src_stn, hdr->cb,
1105 static struct packet_type econet_packet_type = {
1106 .type = cpu_to_be16(ETH_P_ECONET),
1110 static void econet_hw_initialise(void)
1112 dev_add_pack(&econet_packet_type);
1117 static int econet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1119 struct net_device *dev = (struct net_device *)data;
1120 struct ec_device *edev;
1122 if (!net_eq(dev_net(dev), &init_net))
1126 case NETDEV_UNREGISTER:
1127 /* A device has gone down - kill any data we hold for it. */
1131 if (net2dev_map[0] == dev)
1132 net2dev_map[0] = NULL;
1133 net2dev_map[edev->net] = NULL;
1143 static struct notifier_block econet_netdev_notifier = {
1144 .notifier_call =econet_notifier,
1147 static void __exit econet_proto_exit(void)
1149 #ifdef CONFIG_ECONET_AUNUDP
1150 del_timer(&ab_cleanup_timer);
1152 sock_release(udpsock);
1154 unregister_netdevice_notifier(&econet_netdev_notifier);
1155 #ifdef CONFIG_ECONET_NATIVE
1156 dev_remove_pack(&econet_packet_type);
1158 sock_unregister(econet_family_ops.family);
1159 proto_unregister(&econet_proto);
1162 static int __init econet_proto_init(void)
1164 int err = proto_register(&econet_proto, 0);
1168 sock_register(&econet_family_ops);
1169 #ifdef CONFIG_ECONET_AUNUDP
1170 spin_lock_init(&aun_queue_lock);
1171 aun_udp_initialise();
1173 #ifdef CONFIG_ECONET_NATIVE
1174 econet_hw_initialise();
1176 register_netdevice_notifier(&econet_netdev_notifier);
1181 module_init(econet_proto_init);
1182 module_exit(econet_proto_exit);
1184 MODULE_LICENSE("GPL");
1185 MODULE_ALIAS_NETPROTO(PF_ECONET);