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 #define pr_fmt(fmt) fmt
14 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
18 #include <linux/string.h>
20 #include <linux/socket.h>
21 #include <linux/sockios.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>
34 #include <linux/udp.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
38 #include <net/inet_common.h>
39 #include <linux/stat.h>
40 #include <linux/init.h>
41 #include <linux/if_ec.h>
44 #include <linux/spinlock.h>
45 #include <linux/rcupdate.h>
46 #include <linux/bitops.h>
47 #include <linux/mutex.h>
49 #include <linux/uaccess.h>
51 static const struct proto_ops econet_ops
;
52 static struct hlist_head econet_sklist
;
53 static DEFINE_SPINLOCK(econet_lock
);
54 static DEFINE_MUTEX(econet_mutex
);
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. */
58 static struct net_device
*net2dev_map
[256];
60 #define EC_PORT_IP 0xd2
62 #ifdef CONFIG_ECONET_AUNUDP
63 static DEFINE_SPINLOCK(aun_queue_lock
);
64 static struct socket
*udpsock
;
65 #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 */
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 spin_lock_bh(&econet_lock
);
101 sk_del_node_init(sk
);
102 spin_unlock_bh(&econet_lock
);
105 static void econet_insert_socket(struct hlist_head
*list
, struct sock
*sk
)
107 spin_lock_bh(&econet_lock
);
108 sk_add_node(sk
, list
);
109 spin_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.
157 msg
->msg_flags
|= MSG_TRUNC
;
160 /* We can't use skb_copy_datagram here */
161 err
= memcpy_toiovec(msg
->msg_iov
, skb
->data
, copied
);
164 sk
->sk_stamp
= skb
->tstamp
;
167 memcpy(msg
->msg_name
, skb
->cb
, msg
->msg_namelen
);
170 * Free or return the buffer as appropriate. Again this
171 * hides all the races and re-entrancy issues from us.
176 skb_free_datagram(sk
, skb
);
178 mutex_unlock(&econet_mutex
);
183 * Bind an Econet socket.
186 static int econet_bind(struct socket
*sock
, struct sockaddr
*uaddr
,
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
;
228 pr_debug("econet: memory squeeze, transmit result dropped\n");
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
;
239 if (sock_queue_rcv_skb(sk
, skb
) < 0)
244 #ifdef CONFIG_ECONET_NATIVE
246 * Called by the Econet hardware driver when a packet transmit
247 * has completed. Tell the user.
250 static void ec_tx_done(struct sk_buff
*skb
, int result
)
252 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
253 tx_result(skb
->sk
, eb
->cookie
, result
);
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.
262 static int econet_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
263 struct msghdr
*msg
, size_t len
)
265 struct sockaddr_ec
*saddr
= (struct sockaddr_ec
*)msg
->msg_name
;
266 struct net_device
*dev
;
269 unsigned char port
, cb
;
270 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
271 struct sock
*sk
= sock
->sk
;
275 #ifdef CONFIG_ECONET_AUNUDP
276 struct msghdr udpmsg
;
279 struct sockaddr_in udpdest
;
280 __kernel_size_t size
;
289 if (msg
->msg_flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
293 * Get and verify the address.
296 mutex_lock(&econet_mutex
);
298 if (saddr
== NULL
|| msg
->msg_namelen
< sizeof(struct sockaddr_ec
)) {
299 mutex_unlock(&econet_mutex
);
302 addr
.station
= saddr
->addr
.station
;
303 addr
.net
= saddr
->addr
.net
;
307 /* Look for a device with the right network number. */
308 dev
= net2dev_map
[addr
.net
];
310 /* If not directly reachable, use some default */
312 dev
= net2dev_map
[0];
313 /* No interfaces at all? */
315 mutex_unlock(&econet_mutex
);
320 if (dev
->type
== ARPHRD_ECONET
) {
321 /* Real hardware Econet. We're not worthy etc. */
322 #ifdef CONFIG_ECONET_NATIVE
323 unsigned short proto
= 0;
327 if (len
+ 15 > dev
->mtu
) {
328 mutex_unlock(&econet_mutex
);
334 hlen
= LL_RESERVED_SPACE(dev
);
335 tlen
= dev
->needed_tailroom
;
336 skb
= sock_alloc_send_skb(sk
, len
+ hlen
+ tlen
,
337 msg
->msg_flags
& MSG_DONTWAIT
, &err
);
341 skb_reserve(skb
, hlen
);
342 skb_reset_network_header(skb
);
344 eb
= (struct ec_cb
*)&skb
->cb
;
346 eb
->cookie
= saddr
->cookie
;
348 eb
->sent
= ec_tx_done
;
351 res
= dev_hard_header(skb
, dev
, ntohs(proto
), &addr
, NULL
, len
);
355 struct ec_framehdr
*fh
;
356 /* Poke in our control byte and
357 port number. Hack, hack. */
358 fh
= (struct ec_framehdr
*)skb
->data
;
361 if (sock
->type
!= SOCK_DGRAM
) {
362 skb_reset_tail_pointer(skb
);
367 /* Copy the data. Returns -EFAULT on error */
368 err
= memcpy_fromiovec(skb_put(skb
, len
), msg
->msg_iov
, len
);
369 skb
->protocol
= proto
;
371 skb
->priority
= sk
->sk_priority
;
376 if (!(dev
->flags
& IFF_UP
))
385 mutex_unlock(&econet_mutex
);
396 mutex_unlock(&econet_mutex
);
401 #ifdef CONFIG_ECONET_AUNUDP
402 /* AUN virtual Econet. */
404 if (udpsock
== NULL
) {
405 mutex_unlock(&econet_mutex
);
406 return -ENETDOWN
; /* No socket - can't send */
414 /* Make up a UDP datagram and hand it off to some higher intellect. */
416 memset(&udpdest
, 0, sizeof(udpdest
));
417 udpdest
.sin_family
= AF_INET
;
418 udpdest
.sin_port
= htons(AUN_PORT
);
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. */
424 struct in_device
*idev
;
425 unsigned long network
= 0;
428 idev
= __in_dev_get_rcu(dev
);
431 network
= ntohl(idev
->ifa_list
->ifa_address
) &
432 0xffffff00; /* !!! */
435 udpdest
.sin_addr
.s_addr
= htonl(network
| addr
.station
);
438 memset(&ah
, 0, sizeof(ah
));
441 ah
.code
= 2; /* magic */
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
;
448 userbuf
= vmalloc(len
);
449 if (userbuf
== NULL
) {
454 iov
[1].iov_base
= userbuf
;
455 iov
[1].iov_len
= len
;
456 err
= memcpy_fromiovec(userbuf
, msg
->msg_iov
, len
);
460 /* Get a skbuff (no data, just holds our cb information) */
461 skb
= sock_alloc_send_skb(sk
, 0, msg
->msg_flags
& MSG_DONTWAIT
, &err
);
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;
482 udpmsg
.msg_flags
= 0;
485 set_fs(KERNEL_DS
); /* More privs :-) */
486 err
= sock_sendmsg(udpsock
, &udpmsg
, size
);
495 mutex_unlock(&econet_mutex
);
501 * Look up the address of a socket.
504 static int econet_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
505 int *uaddr_len
, int peer
)
508 struct econet_sock
*eo
;
509 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)uaddr
;
514 memset(sec
, 0, sizeof(*sec
));
515 mutex_lock(&econet_mutex
);
520 sec
->sec_family
= AF_ECONET
;
521 sec
->port
= eo
->port
;
522 sec
->addr
.station
= eo
->station
;
523 sec
->addr
.net
= eo
->net
;
525 mutex_unlock(&econet_mutex
);
527 *uaddr_len
= sizeof(*sec
);
531 static void econet_destroy_timer(unsigned long data
)
533 struct sock
*sk
= (struct sock
*)data
;
535 if (!sk_has_allocations(sk
)) {
540 sk
->sk_timer
.expires
= jiffies
+ 10 * HZ
;
541 add_timer(&sk
->sk_timer
);
542 pr_debug("econet: socket destroy delayed\n");
546 * Close an econet socket.
549 static int econet_release(struct socket
*sock
)
553 mutex_lock(&econet_mutex
);
559 econet_remove_socket(&econet_sklist
, sk
);
562 * Now the socket is dead. No more input will appear.
565 sk
->sk_state_change(sk
); /* It is useless. Just for sanity. */
571 skb_queue_purge(&sk
->sk_receive_queue
);
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
);
585 mutex_unlock(&econet_mutex
);
589 static struct proto econet_proto
= {
591 .owner
= THIS_MODULE
,
592 .obj_size
= sizeof(struct econet_sock
),
596 * Create an Econet socket
599 static int econet_create(struct net
*net
, struct socket
*sock
, int protocol
,
603 struct econet_sock
*eo
;
606 if (!net_eq(net
, &init_net
))
607 return -EAFNOSUPPORT
;
609 /* Econet only provides datagram services. */
610 if (sock
->type
!= SOCK_DGRAM
)
611 return -ESOCKTNOSUPPORT
;
613 sock
->state
= SS_UNCONNECTED
;
616 sk
= sk_alloc(net
, PF_ECONET
, GFP_KERNEL
, &econet_proto
);
621 sock
->ops
= &econet_ops
;
622 sock_init_data(sock
, sk
);
625 sock_reset_flag(sk
, SOCK_ZAPPED
);
626 sk
->sk_family
= PF_ECONET
;
629 econet_insert_socket(&econet_sklist
, sk
);
636 * Handle Econet specific ioctls
639 static int ec_dev_ioctl(struct socket
*sock
, unsigned int cmd
, void __user
*arg
)
642 struct ec_device
*edev
;
643 struct net_device
*dev
;
644 struct sockaddr_ec
*sec
;
648 * Fetch the caller's info block into kernel space
651 if (copy_from_user(&ifr
, arg
, sizeof(struct ifreq
)))
654 dev
= dev_get_by_name(&init_net
, ifr
.ifr_name
);
658 sec
= (struct sockaddr_ec
*)&ifr
.ifr_addr
;
660 mutex_lock(&econet_mutex
);
665 if (!capable(CAP_NET_ADMIN
)) {
672 /* Magic up a new one. */
673 edev
= kzalloc(sizeof(struct ec_device
), GFP_KERNEL
);
680 net2dev_map
[edev
->net
] = NULL
;
681 edev
->station
= sec
->addr
.station
;
682 edev
->net
= sec
->addr
.net
;
683 net2dev_map
[sec
->addr
.net
] = dev
;
685 net2dev_map
[0] = dev
;
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
;
699 if (copy_to_user(arg
, &ifr
, sizeof(struct ifreq
)))
708 mutex_unlock(&econet_mutex
);
716 * Handle generic ioctls
719 static int econet_ioctl(struct socket
*sock
, unsigned int cmd
,
722 struct sock
*sk
= sock
->sk
;
723 void __user
*argp
= (void __user
*)arg
;
727 return sock_get_timestamp(sk
, argp
);
730 return sock_get_timestampns(sk
, argp
);
734 return ec_dev_ioctl(sock
, cmd
, argp
);
741 static const struct net_proto_family econet_family_ops
= {
743 .create
= econet_create
,
744 .owner
= THIS_MODULE
,
747 static const struct proto_ops econet_ops
= {
749 .owner
= THIS_MODULE
,
750 .release
= econet_release
,
752 .connect
= sock_no_connect
,
753 .socketpair
= sock_no_socketpair
,
754 .accept
= sock_no_accept
,
755 .getname
= econet_getname
,
756 .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
,
768 #if defined(CONFIG_ECONET_AUNUDP) || defined(CONFIG_ECONET_NATIVE)
770 * Find the listening socket, if any, for the given data.
773 static struct sock
*ec_listening_socket(unsigned char port
, unsigned char
774 station
, unsigned char net
)
777 struct hlist_node
*node
;
779 spin_lock(&econet_lock
);
780 sk_for_each(sk
, node
, &econet_sklist
) {
781 struct econet_sock
*opt
= ec_sk(sk
);
782 if ((opt
->port
== port
|| opt
->port
== 0) &&
783 (opt
->station
== station
|| opt
->station
== 0) &&
784 (opt
->net
== net
|| opt
->net
== 0)) {
791 spin_unlock(&econet_lock
);
796 * Queue a received packet for a socket.
799 static 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
)
803 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
804 struct sockaddr_ec
*sec
= (struct sockaddr_ec
*)&eb
->sec
;
806 memset(sec
, 0, sizeof(struct sockaddr_ec
));
807 sec
->sec_family
= AF_ECONET
;
808 sec
->type
= ECTYPE_PACKET_RECEIVED
;
812 sec
->addr
.station
= stn
;
814 return sock_queue_rcv_skb(sk
, skb
);
818 #ifdef CONFIG_ECONET_AUNUDP
820 * Send an AUN protocol response.
823 static void aun_send_response(__u32 addr
, unsigned long seq
, int code
, int cb
)
825 struct sockaddr_in sin
= {
826 .sin_family
= AF_INET
,
827 .sin_port
= htons(AUN_PORT
),
828 .sin_addr
= {.s_addr
= addr
}
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
;
834 udpmsg
.msg_name
= (void *)&sin
;
835 udpmsg
.msg_namelen
= sizeof(sin
);
836 udpmsg
.msg_control
= NULL
;
837 udpmsg
.msg_controllen
= 0;
838 udpmsg
.msg_flags
= 0;
840 kernel_sendmsg(udpsock
, &udpmsg
, &iov
, 1, sizeof(ah
));
845 * Handle incoming AUN packets. Work out if anybody wants them,
846 * and send positive or negative acknowledgements as appropriate.
849 static void aun_incoming(struct sk_buff
*skb
, struct aunhdr
*ah
, size_t len
)
851 struct iphdr
*ip
= ip_hdr(skb
);
852 unsigned char stn
= ntohl(ip
->saddr
) & 0xff;
853 struct dst_entry
*dst
= skb_dst(skb
);
854 struct ec_device
*edev
= NULL
;
855 struct sock
*sk
= NULL
;
856 struct sk_buff
*newskb
;
859 edev
= dst
->dev
->ec_ptr
;
864 sk
= ec_listening_socket(ah
->port
, stn
, edev
->net
);
866 goto bad
; /* Nobody wants it */
868 newskb
= alloc_skb((len
- sizeof(struct aunhdr
) + 15) & ~15,
870 if (newskb
== NULL
) {
871 pr_debug("AUN: memory squeeze, dropping packet\n");
872 /* Send nack and hope sender tries again */
876 memcpy(skb_put(newskb
, len
- sizeof(struct aunhdr
)), (void *)(ah
+ 1),
877 len
- sizeof(struct aunhdr
));
879 if (ec_queue_packet(sk
, newskb
, stn
, edev
->net
, ah
->cb
, ah
->port
)) {
880 /* Socket is bankrupt. */
885 aun_send_response(ip
->saddr
, ah
->handle
, 3, 0);
890 aun_send_response(ip
->saddr
, ah
->handle
, 4, 0);
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.
902 static void aun_tx_ack(unsigned long seq
, int result
)
908 spin_lock_irqsave(&aun_queue_lock
, flags
);
909 skb_queue_walk(&aun_queue
, skb
) {
910 eb
= (struct ec_cb
*)&skb
->cb
;
914 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
915 pr_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
)
938 while ((skb
= skb_recv_datagram(sk
, 0, 1, &err
)) == NULL
) {
939 if (err
== -EAGAIN
) {
940 pr_err("AUN: no data available?!\n");
943 pr_debug("AUN: recvfrom() error %d\n", -err
);
946 data
= skb_transport_header(skb
) + sizeof(struct udphdr
);
947 ah
= (struct aunhdr
*)data
;
948 len
= skb
->len
- sizeof(struct udphdr
);
952 aun_incoming(skb
, ah
, len
);
955 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_OK
);
958 aun_tx_ack(ah
->handle
, ECTYPE_TRANSMIT_NOT_LISTENING
);
961 pr_debug("AUN: unknown packet type: %d\n", data
[0]);
964 skb_free_datagram(sk
, skb
);
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
974 static void ab_cleanup(unsigned long h
)
976 struct sk_buff
*skb
, *n
;
979 spin_lock_irqsave(&aun_queue_lock
, flags
);
980 skb_queue_walk_safe(&aun_queue
, skb
, n
) {
981 struct ec_cb
*eb
= (struct ec_cb
*)&skb
->cb
;
982 if ((jiffies
- eb
->start
) > eb
->timeout
) {
983 tx_result(skb
->sk
, eb
->cookie
,
984 ECTYPE_TRANSMIT_NOT_PRESENT
);
985 skb_unlink(skb
, &aun_queue
);
989 spin_unlock_irqrestore(&aun_queue_lock
, flags
);
991 mod_timer(&ab_cleanup_timer
, jiffies
+ (HZ
* 2));
994 static int __init
aun_udp_initialise(void)
997 struct sockaddr_in sin
;
999 skb_queue_head_init(&aun_queue
);
1000 setup_timer(&ab_cleanup_timer
, ab_cleanup
, 0);
1001 ab_cleanup_timer
.expires
= jiffies
+ (HZ
* 2);
1002 add_timer(&ab_cleanup_timer
);
1004 memset(&sin
, 0, sizeof(sin
));
1005 sin
.sin_port
= htons(AUN_PORT
);
1007 /* We can count ourselves lucky Acorn machines are too dim to
1009 error
= sock_create_kern(PF_INET
, SOCK_DGRAM
, 0, &udpsock
);
1011 pr_err("AUN: socket error %d\n", -error
);
1015 udpsock
->sk
->sk_reuse
= 1;
1016 udpsock
->sk
->sk_allocation
= GFP_ATOMIC
; /* we're going to call it
1019 error
= udpsock
->ops
->bind(udpsock
, (struct sockaddr
*)&sin
,
1022 pr_err("AUN: bind error %d\n", -error
);
1026 udpsock
->sk
->sk_data_ready
= aun_data_available
;
1031 sock_release(udpsock
);
1037 #ifdef CONFIG_ECONET_NATIVE
1040 * Receive an Econet frame from a device.
1043 static int econet_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
1044 struct packet_type
*pt
, struct net_device
*orig_dev
)
1046 struct ec_framehdr
*hdr
;
1047 struct sock
*sk
= NULL
;
1048 struct ec_device
*edev
= dev
->ec_ptr
;
1050 if (!net_eq(dev_net(dev
), &init_net
))
1053 if (skb
->pkt_type
== PACKET_OTHERHOST
)
1059 skb
= skb_share_check(skb
, GFP_ATOMIC
);
1063 if (!pskb_may_pull(skb
, sizeof(struct ec_framehdr
)))
1066 hdr
= (struct ec_framehdr
*)skb
->data
;
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
));
1073 return NET_RX_SUCCESS
;
1076 sk
= ec_listening_socket(hdr
->port
, hdr
->src_stn
, hdr
->src_net
);
1080 if (ec_queue_packet(sk
, skb
, edev
->net
, hdr
->src_stn
, hdr
->cb
,
1084 return NET_RX_SUCCESS
;
1093 static struct packet_type econet_packet_type __read_mostly
= {
1094 .type
= cpu_to_be16(ETH_P_ECONET
),
1098 static void econet_hw_initialise(void)
1100 dev_add_pack(&econet_packet_type
);
1105 static int econet_notifier(struct notifier_block
*this, unsigned long msg
,
1108 struct net_device
*dev
= data
;
1109 struct ec_device
*edev
;
1111 if (!net_eq(dev_net(dev
), &init_net
))
1115 case NETDEV_UNREGISTER
:
1116 /* A device has gone down - kill any data we hold for it. */
1119 if (net2dev_map
[0] == dev
)
1120 net2dev_map
[0] = NULL
;
1121 net2dev_map
[edev
->net
] = NULL
;
1131 static struct notifier_block econet_netdev_notifier
= {
1132 .notifier_call
= econet_notifier
,
1135 static void __exit
econet_proto_exit(void)
1137 #ifdef CONFIG_ECONET_AUNUDP
1138 del_timer(&ab_cleanup_timer
);
1140 sock_release(udpsock
);
1142 unregister_netdevice_notifier(&econet_netdev_notifier
);
1143 #ifdef CONFIG_ECONET_NATIVE
1144 dev_remove_pack(&econet_packet_type
);
1146 sock_unregister(econet_family_ops
.family
);
1147 proto_unregister(&econet_proto
);
1150 static int __init
econet_proto_init(void)
1152 int err
= proto_register(&econet_proto
, 0);
1156 sock_register(&econet_family_ops
);
1157 #ifdef CONFIG_ECONET_AUNUDP
1158 aun_udp_initialise();
1160 #ifdef CONFIG_ECONET_NATIVE
1161 econet_hw_initialise();
1163 register_netdevice_notifier(&econet_netdev_notifier
);
1168 module_init(econet_proto_init
);
1169 module_exit(econet_proto_exit
);
1171 MODULE_LICENSE("GPL");
1172 MODULE_ALIAS_NETPROTO(PF_ECONET
);