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>
33 #include <linux/vmalloc.h>
35 #include <net/inet_common.h>
36 #include <linux/stat.h>
37 #include <linux/init.h>
38 #include <linux/if_ec.h>
41 #include <linux/spinlock.h>
42 #include <linux/rcupdate.h>
43 #include <linux/bitops.h>
44 #include <linux/mutex.h>
46 #include <asm/uaccess.h>
47 #include <asm/system.h>
49 static const struct proto_ops econet_ops
;
50 static struct hlist_head econet_sklist
;
51 static DEFINE_RWLOCK(econet_lock
);
52 static DEFINE_MUTEX(econet_mutex
);
54 /* Since there are only 256 possible network numbers (or fewer, depends
55 how you count) it makes sense to use a simple lookup table. */
56 static struct net_device
*net2dev_map
[256];
58 #define EC_PORT_IP 0xd2
60 #ifdef CONFIG_ECONET_AUNUDP
61 static DEFINE_SPINLOCK(aun_queue_lock
);
62 static struct socket
*udpsock
;
63 #define AUN_PORT 0x8000
68 unsigned char code
; /* AUN magic protocol byte */
75 static unsigned long aun_seq
;
77 /* Queue of packets waiting to be transmitted. */
78 static struct sk_buff_head aun_queue
;
79 static struct timer_list ab_cleanup_timer
;
81 #endif /* CONFIG_ECONET_AUNUDP */
83 /* Per-packet information */
86 struct sockaddr_ec sec
;
87 unsigned long cookie
; /* Supplied by user. */
88 #ifdef CONFIG_ECONET_AUNUDP
90 unsigned long seq
; /* Sequencing */
91 unsigned long timeout
; /* Timeout */
92 unsigned long start
; /* jiffies */
94 #ifdef CONFIG_ECONET_NATIVE
95 void (*sent
)(struct sk_buff
*, int result
);
99 static void econet_remove_socket(struct hlist_head
*list
, struct sock
*sk
)
101 write_lock_bh(&econet_lock
);
102 sk_del_node_init(sk
);
103 write_unlock_bh(&econet_lock
);
106 static void econet_insert_socket(struct hlist_head
*list
, struct sock
*sk
)
108 write_lock_bh(&econet_lock
);
109 sk_add_node(sk
, list
);
110 write_unlock_bh(&econet_lock
);
114 * Pull a packet from our receive queue and hand it to the user.
115 * If necessary we block.
118 static int econet_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
119 struct msghdr
*msg
, size_t len
, int flags
)
121 struct sock
*sk
= sock
->sk
;
126 msg
->msg_namelen
= sizeof(struct sockaddr_ec
);
128 mutex_lock(&econet_mutex
);
131 * Call the generic datagram receiver. This handles all sorts
132 * of horrible races and re-entrancy so we can forget about it
133 * in the protocol layers.
135 * Now it will return ENETDOWN, if device have just gone down,
136 * but then it will block.
139 skb
=skb_recv_datagram(sk
,flags
,flags
&MSG_DONTWAIT
,&err
);
142 * An error occurred so return it. Because skb_recv_datagram()
143 * handles the blocking we don't see and worry about blocking
151 * You lose any data beyond the buffer you gave. If it worries a
152 * user program they can ask the device for its MTU anyway.
159 msg
->msg_flags
|=MSG_TRUNC
;
162 /* We can't use skb_copy_datagram here */
163 err
= memcpy_toiovec(msg
->msg_iov
, skb
->data
, copied
);
166 sk
->sk_stamp
= skb
->tstamp
;
169 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
172 * Free or return the buffer as appropriate. Again this
173 * hides all the races and re-entrancy issues from us.
178 skb_free_datagram(sk
, skb
);
180 mutex_unlock(&econet_mutex
);
185 * Bind an Econet socket.
188 static int econet_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
190 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)uaddr
;
192 struct econet_sock
*eo
;
198 if (addr_len
< sizeof(struct sockaddr_ec
) ||
199 sec
->sec_family
!= AF_ECONET
)
202 mutex_lock(&econet_mutex
);
208 eo
->port
= sec
->port
;
209 eo
->station
= sec
->addr
.station
;
210 eo
->net
= sec
->addr
.net
;
212 mutex_unlock(&econet_mutex
);
217 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
219 * Queue a transmit result for the user to be told about.
222 static void tx_result(struct sock
*sk
, unsigned long cookie
, int result
)
224 struct sk_buff
*skb
= alloc_skb(0, GFP_ATOMIC
);
226 struct sockaddr_ec
*sec
;
230 printk(KERN_DEBUG
"ec: memory squeeze, transmit result dropped.\n");
234 eb
= (struct ec_cb
*)&skb
->cb
;
235 sec
= (struct sockaddr_ec
*)&eb
->sec
;
236 memset(sec
, 0, sizeof(struct sockaddr_ec
));
237 sec
->cookie
= cookie
;
238 sec
->type
= ECTYPE_TRANSMIT_STATUS
| result
;
239 sec
->sec_family
= AF_ECONET
;
241 if (sock_queue_rcv_skb(sk
, skb
) < 0)
246 #ifdef CONFIG_ECONET_NATIVE
248 * Called by the Econet hardware driver when a packet transmit
249 * has completed. Tell the user.
252 static void ec_tx_done(struct sk_buff
*skb
, int result
)
254 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
255 tx_result(skb
->sk
, eb
->cookie
, result
);
260 * Send a packet. We have to work out which device it's going out on
261 * and hence whether to use real Econet or the UDP emulation.
264 static int econet_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
265 struct msghdr
*msg
, size_t len
)
267 struct sock
*sk
= sock
->sk
;
268 struct sockaddr_ec
*saddr
=(struct sockaddr_ec
*)msg
->msg_name
;
269 struct net_device
*dev
;
272 unsigned char port
, cb
;
273 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
277 #ifdef CONFIG_ECONET_AUNUDP
278 struct msghdr udpmsg
;
281 struct sockaddr_in udpdest
;
282 __kernel_size_t size
;
291 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
295 * Get and verify the address.
298 mutex_lock(&econet_mutex
);
300 if (saddr
== NULL
|| msg
->msg_namelen
< sizeof(struct sockaddr_ec
)) {
301 mutex_unlock(&econet_mutex
);
304 addr
.station
= saddr
->addr
.station
;
305 addr
.net
= saddr
->addr
.net
;
309 /* Look for a device with the right network number. */
310 dev
= net2dev_map
[addr
.net
];
312 /* If not directly reachable, use some default */
314 dev
= net2dev_map
[0];
315 /* No interfaces at all? */
317 mutex_unlock(&econet_mutex
);
322 if (dev
->type
== ARPHRD_ECONET
) {
323 /* Real hardware Econet. We're not worthy etc. */
324 #ifdef CONFIG_ECONET_NATIVE
325 unsigned short proto
= 0;
328 if (len
+ 15 > dev
->mtu
) {
329 mutex_unlock(&econet_mutex
);
335 skb
= sock_alloc_send_skb(sk
, len
+LL_ALLOCATED_SPACE(dev
),
336 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
340 skb_reserve(skb
, LL_RESERVED_SPACE(dev
));
341 skb_reset_network_header(skb
);
343 eb
= (struct ec_cb
*)&skb
->cb
;
345 eb
->cookie
= saddr
->cookie
;
347 eb
->sent
= ec_tx_done
;
350 res
= dev_hard_header(skb
, dev
, ntohs(proto
), &addr
, NULL
, len
);
354 struct ec_framehdr
*fh
;
355 /* Poke in our control byte and
356 port number. Hack, hack. */
357 fh
= (struct ec_framehdr
*)(skb
->data
);
360 if (sock
->type
!= SOCK_DGRAM
) {
361 skb_reset_tail_pointer(skb
);
366 /* Copy the data. Returns -EFAULT on error */
367 err
= memcpy_fromiovec(skb_put(skb
,len
), msg
->msg_iov
, len
);
368 skb
->protocol
= proto
;
370 skb
->priority
= sk
->sk_priority
;
375 if (!(dev
->flags
& IFF_UP
))
384 mutex_unlock(&econet_mutex
);
395 mutex_unlock(&econet_mutex
);
400 #ifdef CONFIG_ECONET_AUNUDP
401 /* AUN virtual Econet. */
403 if (udpsock
== NULL
) {
404 mutex_unlock(&econet_mutex
);
405 return -ENETDOWN
; /* No socket - can't send */
413 /* Make up a UDP datagram and hand it off to some higher intellect. */
415 memset(&udpdest
, 0, sizeof(udpdest
));
416 udpdest
.sin_family
= AF_INET
;
417 udpdest
.sin_port
= htons(AUN_PORT
);
419 /* At the moment we use the stupid Acorn scheme of Econet address
420 y.x maps to IP a.b.c.x. This should be replaced with something
421 more flexible and more aware of subnet masks. */
423 struct in_device
*idev
;
424 unsigned long network
= 0;
427 idev
= __in_dev_get_rcu(dev
);
430 network
= ntohl(idev
->ifa_list
->ifa_address
) &
431 0xffffff00; /* !!! */
434 udpdest
.sin_addr
.s_addr
= htonl(network
| addr
.station
);
439 ah
.code
= 2; /* magic */
442 /* tack our header on the front of the iovec */
443 size
= sizeof(struct aunhdr
);
444 iov
[0].iov_base
= (void *)&ah
;
445 iov
[0].iov_len
= size
;
447 userbuf
= vmalloc(len
);
448 if (userbuf
== NULL
) {
453 iov
[1].iov_base
= userbuf
;
454 iov
[1].iov_len
= len
;
455 err
= memcpy_fromiovec(userbuf
, msg
->msg_iov
, len
);
459 /* Get a skbuff (no data, just holds our cb information) */
460 if ((skb
= sock_alloc_send_skb(sk
, 0,
461 msg
->msg_flags
& MSG_DONTWAIT
,
465 eb
= (struct ec_cb
*)&skb
->cb
;
467 eb
->cookie
= saddr
->cookie
;
468 eb
->timeout
= (5*HZ
);
471 eb
->seq
= (aun_seq
++);
474 skb_queue_tail(&aun_queue
, skb
);
476 udpmsg
.msg_name
= (void *)&udpdest
;
477 udpmsg
.msg_namelen
= sizeof(udpdest
);
478 udpmsg
.msg_iov
= &iov
[0];
479 udpmsg
.msg_iovlen
= 2;
480 udpmsg
.msg_control
= NULL
;
481 udpmsg
.msg_controllen
= 0;
484 oldfs
= get_fs(); set_fs(KERNEL_DS
); /* More privs :-) */
485 err
= sock_sendmsg(udpsock
, &udpmsg
, size
);
494 mutex_unlock(&econet_mutex
);
500 * Look up the address of a socket.
503 static int econet_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
504 int *uaddr_len
, int peer
)
507 struct econet_sock
*eo
;
508 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)uaddr
;
513 memset(sec
, 0, sizeof(*sec
));
514 mutex_lock(&econet_mutex
);
519 sec
->sec_family
= AF_ECONET
;
520 sec
->port
= eo
->port
;
521 sec
->addr
.station
= eo
->station
;
522 sec
->addr
.net
= eo
->net
;
524 mutex_unlock(&econet_mutex
);
526 *uaddr_len
= sizeof(*sec
);
530 static void econet_destroy_timer(unsigned long data
)
532 struct sock
*sk
=(struct sock
*)data
;
534 if (!sk_has_allocations(sk
)) {
539 sk
->sk_timer
.expires
= jiffies
+ 10 * HZ
;
540 add_timer(&sk
->sk_timer
);
541 printk(KERN_DEBUG
"econet socket destroy delayed\n");
545 * Close an econet socket.
548 static int econet_release(struct socket
*sock
)
552 mutex_lock(&econet_mutex
);
558 econet_remove_socket(&econet_sklist
, sk
);
561 * Now the socket is dead. No more input will appear.
564 sk
->sk_state_change(sk
); /* It is useless. Just for sanity. */
570 skb_queue_purge(&sk
->sk_receive_queue
);
572 if (sk_has_allocations(sk
)) {
573 sk
->sk_timer
.data
= (unsigned long)sk
;
574 sk
->sk_timer
.expires
= jiffies
+ HZ
;
575 sk
->sk_timer
.function
= econet_destroy_timer
;
576 add_timer(&sk
->sk_timer
);
584 mutex_unlock(&econet_mutex
);
588 static struct proto econet_proto
= {
590 .owner
= THIS_MODULE
,
591 .obj_size
= sizeof(struct econet_sock
),
595 * Create an Econet socket
598 static int econet_create(struct net
*net
, struct socket
*sock
, int protocol
,
602 struct econet_sock
*eo
;
605 if (!net_eq(net
, &init_net
))
606 return -EAFNOSUPPORT
;
608 /* Econet only provides datagram services. */
609 if (sock
->type
!= SOCK_DGRAM
)
610 return -ESOCKTNOSUPPORT
;
612 sock
->state
= SS_UNCONNECTED
;
615 sk
= sk_alloc(net
, PF_ECONET
, GFP_KERNEL
, &econet_proto
);
620 sock
->ops
= &econet_ops
;
621 sock_init_data(sock
, sk
);
624 sock_reset_flag(sk
, SOCK_ZAPPED
);
625 sk
->sk_family
= PF_ECONET
;
628 econet_insert_socket(&econet_sklist
, sk
);
635 * Handle Econet specific ioctls
638 static int ec_dev_ioctl(struct socket
*sock
, unsigned int cmd
, void __user
*arg
)
641 struct ec_device
*edev
;
642 struct net_device
*dev
;
643 struct sockaddr_ec
*sec
;
647 * Fetch the caller's info block into kernel space
650 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
653 if ((dev
= dev_get_by_name(&init_net
, ifr
.ifr_name
)) == NULL
)
656 sec
= (struct sockaddr_ec
*)&ifr
.ifr_addr
;
658 mutex_lock(&econet_mutex
);
663 if (!capable(CAP_NET_ADMIN
))
668 /* Magic up a new one. */
669 edev
= kzalloc(sizeof(struct ec_device
), GFP_KERNEL
);
676 net2dev_map
[edev
->net
] = NULL
;
677 edev
->station
= sec
->addr
.station
;
678 edev
->net
= sec
->addr
.net
;
679 net2dev_map
[sec
->addr
.net
] = dev
;
681 net2dev_map
[0] = dev
;
690 memset(sec
, 0, sizeof(struct sockaddr_ec
));
691 sec
->addr
.station
= edev
->station
;
692 sec
->addr
.net
= edev
->net
;
693 sec
->sec_family
= AF_ECONET
;
695 if (copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)))
704 mutex_unlock(&econet_mutex
);
712 * Handle generic ioctls
715 static int econet_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
717 struct sock
*sk
= sock
->sk
;
718 void __user
*argp
= (void __user
*)arg
;
722 return sock_get_timestamp(sk
, argp
);
725 return sock_get_timestampns(sk
, argp
);
729 return ec_dev_ioctl(sock
, cmd
, argp
);
739 static const struct net_proto_family econet_family_ops
= {
741 .create
= econet_create
,
742 .owner
= THIS_MODULE
,
745 static const struct proto_ops econet_ops
= {
747 .owner
= THIS_MODULE
,
748 .release
= econet_release
,
750 .connect
= sock_no_connect
,
751 .socketpair
= sock_no_socketpair
,
752 .accept
= sock_no_accept
,
753 .getname
= econet_getname
,
754 .poll
= datagram_poll
,
755 .ioctl
= econet_ioctl
,
756 .listen
= sock_no_listen
,
757 .shutdown
= sock_no_shutdown
,
758 .setsockopt
= sock_no_setsockopt
,
759 .getsockopt
= sock_no_getsockopt
,
760 .sendmsg
= econet_sendmsg
,
761 .recvmsg
= econet_recvmsg
,
762 .mmap
= sock_no_mmap
,
763 .sendpage
= sock_no_sendpage
,
766 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
768 * Find the listening socket, if any, for the given data.
771 static struct sock
*ec_listening_socket(unsigned char port
, unsigned char
772 station
, unsigned char net
)
775 struct hlist_node
*node
;
777 sk_for_each(sk
, node
, &econet_sklist
) {
778 struct econet_sock
*opt
= ec_sk(sk
);
779 if ((opt
->port
== port
|| opt
->port
== 0) &&
780 (opt
->station
== station
|| opt
->station
== 0) &&
781 (opt
->net
== net
|| opt
->net
== 0))
790 * Queue a received packet for a socket.
793 static int ec_queue_packet(struct sock
*sk
, struct sk_buff
*skb
,
794 unsigned char stn
, unsigned char net
,
795 unsigned char cb
, unsigned char port
)
797 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
798 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)&eb
->sec
;
800 memset(sec
, 0, sizeof(struct sockaddr_ec
));
801 sec
->sec_family
= AF_ECONET
;
802 sec
->type
= ECTYPE_PACKET_RECEIVED
;
806 sec
->addr
.station
= stn
;
808 return sock_queue_rcv_skb(sk
, skb
);
812 #ifdef CONFIG_ECONET_AUNUDP
814 * Send an AUN protocol response.
817 static void aun_send_response(__u32 addr
, unsigned long seq
, int code
, int cb
)
819 struct sockaddr_in sin
= {
820 .sin_family
= AF_INET
,
821 .sin_port
= htons(AUN_PORT
),
822 .sin_addr
= {.s_addr
= addr
}
824 struct aunhdr ah
= {.code
= code
, .cb
= cb
, .handle
= seq
};
825 struct kvec iov
= {.iov_base
= (void *)&ah
, .iov_len
= sizeof(ah
)};
826 struct msghdr udpmsg
;
828 udpmsg
.msg_name
= (void *)&sin
;
829 udpmsg
.msg_namelen
= sizeof(sin
);
830 udpmsg
.msg_control
= NULL
;
831 udpmsg
.msg_controllen
= 0;
834 kernel_sendmsg(udpsock
, &udpmsg
, &iov
, 1, sizeof(ah
));
839 * Handle incoming AUN packets. Work out if anybody wants them,
840 * and send positive or negative acknowledgements as appropriate.
843 static void aun_incoming(struct sk_buff
*skb
, struct aunhdr
*ah
, size_t len
)
845 struct iphdr
*ip
= ip_hdr(skb
);
846 unsigned char stn
= ntohl(ip
->saddr
) & 0xff;
848 struct sk_buff
*newskb
;
849 struct ec_device
*edev
= skb
->dev
->ec_ptr
;
854 if ((sk
= ec_listening_socket(ah
->port
, stn
, edev
->net
)) == NULL
)
855 goto bad
; /* Nobody wants it */
857 newskb
= alloc_skb((len
- sizeof(struct aunhdr
) + 15) & ~15,
861 printk(KERN_DEBUG
"AUN: memory squeeze, dropping packet.\n");
862 /* Send nack and hope sender tries again */
866 memcpy(skb_put(newskb
, len
- sizeof(struct aunhdr
)), (void *)(ah
+1),
867 len
- sizeof(struct aunhdr
));
869 if (ec_queue_packet(sk
, newskb
, stn
, edev
->net
, ah
->cb
, ah
->port
))
871 /* Socket is bankrupt. */
876 aun_send_response(ip
->saddr
, ah
->handle
, 3, 0);
880 aun_send_response(ip
->saddr
, ah
->handle
, 4, 0);
884 * Handle incoming AUN transmit acknowledgements. If the sequence
885 * number matches something in our backlog then kill it and tell
886 * the user. If the remote took too long to reply then we may have
887 * dropped the packet already.
890 static void aun_tx_ack(unsigned long seq
, int result
)
896 spin_lock_irqsave(&aun_queue_lock
, flags
);
897 skb_queue_walk(&aun_queue
, skb
) {
898 eb
= (struct ec_cb
*)&skb
->cb
;
902 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
903 printk(KERN_DEBUG
"AUN: unknown sequence %ld\n", seq
);
907 tx_result(skb
->sk
, eb
->cookie
, result
);
908 skb_unlink(skb
, &aun_queue
);
909 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
914 * Deal with received AUN frames - sort out what type of thing it is
915 * and hand it to the right function.
918 static void aun_data_available(struct sock
*sk
, int slen
)
927 while ((skb
= skb_recv_datagram(sk
, 0, 1, &err
)) == NULL
) {
928 if (err
== -EAGAIN
) {
929 printk(KERN_ERR
"AUN: no data available?!");
932 printk(KERN_DEBUG
"AUN: recvfrom() error %d\n", -err
);
935 data
= skb_transport_header(skb
) + sizeof(struct udphdr
);
936 ah
= (struct aunhdr
*)data
;
937 len
= skb
->len
- sizeof(struct udphdr
);
943 aun_incoming(skb
, ah
, len
);
946 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_OK
);
949 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_NOT_LISTENING
);
952 /* This isn't quite right yet. */
954 aun_send_response(ip
->saddr
, ah
->handle
, 6, ah
->cb
);
958 printk(KERN_DEBUG
"unknown AUN packet (type %d)\n", data
[0]);
961 skb_free_datagram(sk
, skb
);
965 * Called by the timer to manage the AUN transmit queue. If a packet
966 * was sent to a dead or nonexistent host then we will never get an
967 * acknowledgement back. After a few seconds we need to spot this and
971 static void ab_cleanup(unsigned long h
)
973 struct sk_buff
*skb
, *n
;
976 spin_lock_irqsave(&aun_queue_lock
, flags
);
977 skb_queue_walk_safe(&aun_queue
, skb
, n
) {
978 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
979 if ((jiffies
- eb
->start
) > eb
->timeout
) {
980 tx_result(skb
->sk
, eb
->cookie
,
981 ECTYPE_TRANSMIT_NOT_PRESENT
);
982 skb_unlink(skb
, &aun_queue
);
986 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
988 mod_timer(&ab_cleanup_timer
, jiffies
+ (HZ
*2));
991 static int __init
aun_udp_initialise(void)
994 struct sockaddr_in sin
;
996 skb_queue_head_init(&aun_queue
);
997 spin_lock_init(&aun_queue_lock
);
998 setup_timer(&ab_cleanup_timer
, ab_cleanup
, 0);
999 ab_cleanup_timer
.expires
= jiffies
+ (HZ
*2);
1000 add_timer(&ab_cleanup_timer
);
1002 memset(&sin
, 0, sizeof(sin
));
1003 sin
.sin_port
= htons(AUN_PORT
);
1005 /* We can count ourselves lucky Acorn machines are too dim to
1007 if ((error
= sock_create_kern(PF_INET
, SOCK_DGRAM
, 0, &udpsock
)) < 0)
1009 printk("AUN: socket error %d\n", -error
);
1013 udpsock
->sk
->sk_reuse
= 1;
1014 udpsock
->sk
->sk_allocation
= GFP_ATOMIC
; /* we're going to call it
1017 error
= udpsock
->ops
->bind(udpsock
, (struct sockaddr
*)&sin
,
1021 printk("AUN: bind error %d\n", -error
);
1025 udpsock
->sk
->sk_data_ready
= aun_data_available
;
1030 sock_release(udpsock
);
1036 #ifdef CONFIG_ECONET_NATIVE
1039 * Receive an Econet frame from a device.
1042 static int econet_rcv(struct sk_buff
*skb
, struct net_device
*dev
, struct packet_type
*pt
, struct net_device
*orig_dev
)
1044 struct ec_framehdr
*hdr
;
1046 struct ec_device
*edev
= dev
->ec_ptr
;
1048 if (!net_eq(dev_net(dev
), &init_net
))
1051 if (skb
->pkt_type
== PACKET_OTHERHOST
)
1057 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
1060 if (!pskb_may_pull(skb
, sizeof(struct ec_framehdr
)))
1063 hdr
= (struct ec_framehdr
*) skb
->data
;
1065 /* First check for encapsulated IP */
1066 if (hdr
->port
== EC_PORT_IP
) {
1067 skb
->protocol
= htons(ETH_P_IP
);
1068 skb_pull(skb
, sizeof(struct ec_framehdr
));
1070 return NET_RX_SUCCESS
;
1073 sk
= ec_listening_socket(hdr
->port
, hdr
->src_stn
, hdr
->src_net
);
1077 if (ec_queue_packet(sk
, skb
, edev
->net
, hdr
->src_stn
, hdr
->cb
,
1081 return NET_RX_SUCCESS
;
1088 static struct packet_type econet_packet_type __read_mostly
= {
1089 .type
= cpu_to_be16(ETH_P_ECONET
),
1093 static void econet_hw_initialise(void)
1095 dev_add_pack(&econet_packet_type
);
1100 static int econet_notifier(struct notifier_block
*this, unsigned long msg
, void *data
)
1102 struct net_device
*dev
= (struct net_device
*)data
;
1103 struct ec_device
*edev
;
1105 if (!net_eq(dev_net(dev
), &init_net
))
1109 case NETDEV_UNREGISTER
:
1110 /* A device has gone down - kill any data we hold for it. */
1114 if (net2dev_map
[0] == dev
)
1115 net2dev_map
[0] = NULL
;
1116 net2dev_map
[edev
->net
] = NULL
;
1126 static struct notifier_block econet_netdev_notifier
= {
1127 .notifier_call
=econet_notifier
,
1130 static void __exit
econet_proto_exit(void)
1132 #ifdef CONFIG_ECONET_AUNUDP
1133 del_timer(&ab_cleanup_timer
);
1135 sock_release(udpsock
);
1137 unregister_netdevice_notifier(&econet_netdev_notifier
);
1138 #ifdef CONFIG_ECONET_NATIVE
1139 dev_remove_pack(&econet_packet_type
);
1141 sock_unregister(econet_family_ops
.family
);
1142 proto_unregister(&econet_proto
);
1145 static int __init
econet_proto_init(void)
1147 int err
= proto_register(&econet_proto
, 0);
1151 sock_register(&econet_family_ops
);
1152 #ifdef CONFIG_ECONET_AUNUDP
1153 spin_lock_init(&aun_queue_lock
);
1154 aun_udp_initialise();
1156 #ifdef CONFIG_ECONET_NATIVE
1157 econet_hw_initialise();
1159 register_netdevice_notifier(&econet_netdev_notifier
);
1164 module_init(econet_proto_init
);
1165 module_exit(econet_proto_exit
);
1167 MODULE_LICENSE("GPL");
1168 MODULE_ALIAS_NETPROTO(PF_ECONET
);