2 * Implements an IPX socket layer.
4 * This code is derived from work by
5 * Ross Biro : Writing the original IP stack
6 * Fred Van Kempen : Tidying up the TCP/IP
8 * Many thanks go to Keith Baker, Institute For Industrial Information
9 * Technology Ltd, Swansea University for allowing me to work on this
10 * in my own time even though it was in some ways related to commercial
11 * work I am currently employed to do there.
13 * All the material in this file is subject to the Gnu license version 2.
14 * Neither Alan Cox nor the Swansea University Computer Society admit
15 * liability nor provide warranty for any of this software. This material
16 * is provided as is and at no charge.
18 * Portions Copyright (c) 2000-2003 Conectiva, Inc. <acme@conectiva.com.br>
19 * Neither Arnaldo Carvalho de Melo nor Conectiva, Inc. admit liability nor
20 * provide warranty for any of this software. This material is provided
21 * "AS-IS" and at no charge.
23 * Portions Copyright (c) 1995 Caldera, Inc. <greg@caldera.com>
24 * Neither Greg Page nor Caldera, Inc. admit liability nor provide
25 * warranty for any of this software. This material is provided
26 * "AS-IS" and at no charge.
28 * See net/ipx/ChangeLog.
31 #include <linux/capability.h>
32 #include <linux/errno.h>
33 #include <linux/if_arp.h>
34 #include <linux/if_ether.h>
35 #include <linux/init.h>
36 #include <linux/ipx.h>
37 #include <linux/kernel.h>
38 #include <linux/list.h>
39 #include <linux/module.h>
40 #include <linux/net.h>
41 #include <linux/netdevice.h>
42 #include <linux/uio.h>
43 #include <linux/skbuff.h>
44 #include <linux/socket.h>
45 #include <linux/sockios.h>
46 #include <linux/string.h>
47 #include <linux/types.h>
48 #include <linux/termios.h>
51 #include <net/p8022.h>
52 #include <net/psnap.h>
54 #include <net/tcp_states.h>
56 #include <asm/uaccess.h>
59 extern void ipx_register_sysctl(void);
60 extern void ipx_unregister_sysctl(void);
62 #define ipx_register_sysctl()
63 #define ipx_unregister_sysctl()
66 /* Configuration Variables */
67 static unsigned char ipxcfg_max_hops
= 16;
68 static char ipxcfg_auto_select_primary
;
69 static char ipxcfg_auto_create_interfaces
;
70 int sysctl_ipx_pprop_broadcasting
= 1;
72 /* Global Variables */
73 static struct datalink_proto
*p8022_datalink
;
74 static struct datalink_proto
*pEII_datalink
;
75 static struct datalink_proto
*p8023_datalink
;
76 static struct datalink_proto
*pSNAP_datalink
;
78 static const struct proto_ops ipx_dgram_ops
;
80 LIST_HEAD(ipx_interfaces
);
81 DEFINE_SPINLOCK(ipx_interfaces_lock
);
83 struct ipx_interface
*ipx_primary_net
;
84 struct ipx_interface
*ipx_internal_net
;
86 extern int ipxrtr_add_route(__be32 network
, struct ipx_interface
*intrfc
,
88 extern void ipxrtr_del_routes(struct ipx_interface
*intrfc
);
89 extern int ipxrtr_route_packet(struct sock
*sk
, struct sockaddr_ipx
*usipx
,
90 struct iovec
*iov
, int len
, int noblock
);
91 extern int ipxrtr_route_skb(struct sk_buff
*skb
);
92 extern struct ipx_route
*ipxrtr_lookup(__be32 net
);
93 extern int ipxrtr_ioctl(unsigned int cmd
, void __user
*arg
);
95 #undef IPX_REFCNT_DEBUG
96 #ifdef IPX_REFCNT_DEBUG
100 struct ipx_interface
*ipx_interfaces_head(void)
102 struct ipx_interface
*rc
= NULL
;
104 if (!list_empty(&ipx_interfaces
))
105 rc
= list_entry(ipx_interfaces
.next
,
106 struct ipx_interface
, node
);
110 static void ipxcfg_set_auto_select(char val
)
112 ipxcfg_auto_select_primary
= val
;
113 if (val
&& !ipx_primary_net
)
114 ipx_primary_net
= ipx_interfaces_head();
117 static int ipxcfg_get_config_data(struct ipx_config_data __user
*arg
)
119 struct ipx_config_data vals
;
121 vals
.ipxcfg_auto_create_interfaces
= ipxcfg_auto_create_interfaces
;
122 vals
.ipxcfg_auto_select_primary
= ipxcfg_auto_select_primary
;
124 return copy_to_user(arg
, &vals
, sizeof(vals
)) ? -EFAULT
: 0;
128 * Note: Sockets may not be removed _during_ an interrupt or inet_bh
129 * handler using this technique. They can be added although we do not
133 static void ipx_remove_socket(struct sock
*sk
)
135 /* Determine interface with which socket is associated */
136 struct ipx_interface
*intrfc
= ipx_sk(sk
)->intrfc
;
142 spin_lock_bh(&intrfc
->if_sklist_lock
);
143 sk_del_node_init(sk
);
144 spin_unlock_bh(&intrfc
->if_sklist_lock
);
150 static void ipx_destroy_socket(struct sock
*sk
)
152 ipx_remove_socket(sk
);
153 skb_queue_purge(&sk
->sk_receive_queue
);
154 #ifdef IPX_REFCNT_DEBUG
155 atomic_dec(&ipx_sock_nr
);
156 printk(KERN_DEBUG
"IPX socket %p released, %d are still alive\n", sk
,
157 atomic_read(&ipx_sock_nr
));
158 if (atomic_read(&sk
->sk_refcnt
) != 1)
159 printk(KERN_DEBUG
"Destruction sock ipx %p delayed, cnt=%d\n",
160 sk
, atomic_read(&sk
->sk_refcnt
));
166 * The following code is used to support IPX Interfaces (IPXITF). An
167 * IPX interface is defined by a physical device and a frame type.
170 /* ipxitf_clear_primary_net has to be called with ipx_interfaces_lock held */
172 static void ipxitf_clear_primary_net(void)
174 ipx_primary_net
= NULL
;
175 if (ipxcfg_auto_select_primary
)
176 ipx_primary_net
= ipx_interfaces_head();
179 static struct ipx_interface
*__ipxitf_find_using_phys(struct net_device
*dev
,
182 struct ipx_interface
*i
;
184 list_for_each_entry(i
, &ipx_interfaces
, node
)
185 if (i
->if_dev
== dev
&& i
->if_dlink_type
== datalink
)
192 static struct ipx_interface
*ipxitf_find_using_phys(struct net_device
*dev
,
195 struct ipx_interface
*i
;
197 spin_lock_bh(&ipx_interfaces_lock
);
198 i
= __ipxitf_find_using_phys(dev
, datalink
);
201 spin_unlock_bh(&ipx_interfaces_lock
);
205 struct ipx_interface
*ipxitf_find_using_net(__be32 net
)
207 struct ipx_interface
*i
;
209 spin_lock_bh(&ipx_interfaces_lock
);
211 list_for_each_entry(i
, &ipx_interfaces
, node
)
212 if (i
->if_netnum
== net
)
223 spin_unlock_bh(&ipx_interfaces_lock
);
227 /* Sockets are bound to a particular IPX interface. */
228 static void ipxitf_insert_socket(struct ipx_interface
*intrfc
, struct sock
*sk
)
231 spin_lock_bh(&intrfc
->if_sklist_lock
);
232 ipx_sk(sk
)->intrfc
= intrfc
;
233 sk_add_node(sk
, &intrfc
->if_sklist
);
234 spin_unlock_bh(&intrfc
->if_sklist_lock
);
238 /* caller must hold intrfc->if_sklist_lock */
239 static struct sock
*__ipxitf_find_socket(struct ipx_interface
*intrfc
,
243 struct hlist_node
*node
;
245 sk_for_each(s
, node
, &intrfc
->if_sklist
)
246 if (ipx_sk(s
)->port
== port
)
253 /* caller must hold a reference to intrfc */
254 static struct sock
*ipxitf_find_socket(struct ipx_interface
*intrfc
,
259 spin_lock_bh(&intrfc
->if_sklist_lock
);
260 s
= __ipxitf_find_socket(intrfc
, port
);
263 spin_unlock_bh(&intrfc
->if_sklist_lock
);
268 #ifdef CONFIG_IPX_INTERN
269 static struct sock
*ipxitf_find_internal_socket(struct ipx_interface
*intrfc
,
270 unsigned char *ipx_node
,
274 struct hlist_node
*node
;
277 spin_lock_bh(&intrfc
->if_sklist_lock
);
279 sk_for_each(s
, node
, &intrfc
->if_sklist
) {
280 struct ipx_sock
*ipxs
= ipx_sk(s
);
282 if (ipxs
->port
== port
&&
283 !memcmp(ipx_node
, ipxs
->node
, IPX_NODE_LEN
))
288 spin_unlock_bh(&intrfc
->if_sklist_lock
);
294 static void __ipxitf_down(struct ipx_interface
*intrfc
)
297 struct hlist_node
*node
, *t
;
299 /* Delete all routes associated with this interface */
300 ipxrtr_del_routes(intrfc
);
302 spin_lock_bh(&intrfc
->if_sklist_lock
);
304 sk_for_each_safe(s
, node
, t
, &intrfc
->if_sklist
) {
305 struct ipx_sock
*ipxs
= ipx_sk(s
);
308 s
->sk_error_report(s
);
311 sock_set_flag(s
, SOCK_ZAPPED
); /* Indicates it is no longer bound */
314 INIT_HLIST_HEAD(&intrfc
->if_sklist
);
315 spin_unlock_bh(&intrfc
->if_sklist_lock
);
317 /* remove this interface from list */
318 list_del(&intrfc
->node
);
320 /* remove this interface from *special* networks */
321 if (intrfc
== ipx_primary_net
)
322 ipxitf_clear_primary_net();
323 if (intrfc
== ipx_internal_net
)
324 ipx_internal_net
= NULL
;
327 dev_put(intrfc
->if_dev
);
331 void ipxitf_down(struct ipx_interface
*intrfc
)
333 spin_lock_bh(&ipx_interfaces_lock
);
334 __ipxitf_down(intrfc
);
335 spin_unlock_bh(&ipx_interfaces_lock
);
338 static __inline__
void __ipxitf_put(struct ipx_interface
*intrfc
)
340 if (atomic_dec_and_test(&intrfc
->refcnt
))
341 __ipxitf_down(intrfc
);
344 static int ipxitf_device_event(struct notifier_block
*notifier
,
345 unsigned long event
, void *ptr
)
347 struct net_device
*dev
= ptr
;
348 struct ipx_interface
*i
, *tmp
;
350 if (event
!= NETDEV_DOWN
&& event
!= NETDEV_UP
)
353 spin_lock_bh(&ipx_interfaces_lock
);
354 list_for_each_entry_safe(i
, tmp
, &ipx_interfaces
, node
)
355 if (i
->if_dev
== dev
) {
356 if (event
== NETDEV_UP
)
361 spin_unlock_bh(&ipx_interfaces_lock
);
367 static __exit
void ipxitf_cleanup(void)
369 struct ipx_interface
*i
, *tmp
;
371 spin_lock_bh(&ipx_interfaces_lock
);
372 list_for_each_entry_safe(i
, tmp
, &ipx_interfaces
, node
)
374 spin_unlock_bh(&ipx_interfaces_lock
);
377 static void ipxitf_def_skb_handler(struct sock
*sock
, struct sk_buff
*skb
)
379 if (sock_queue_rcv_skb(sock
, skb
) < 0)
384 * On input skb->sk is NULL. Nobody is charged for the memory.
387 /* caller must hold a reference to intrfc */
389 #ifdef CONFIG_IPX_INTERN
390 static int ipxitf_demux_socket(struct ipx_interface
*intrfc
,
391 struct sk_buff
*skb
, int copy
)
393 struct ipxhdr
*ipx
= ipx_hdr(skb
);
394 int is_broadcast
= !memcmp(ipx
->ipx_dest
.node
, ipx_broadcast_node
,
397 struct hlist_node
*node
;
400 spin_lock_bh(&intrfc
->if_sklist_lock
);
402 sk_for_each(s
, node
, &intrfc
->if_sklist
) {
403 struct ipx_sock
*ipxs
= ipx_sk(s
);
405 if (ipxs
->port
== ipx
->ipx_dest
.sock
&&
406 (is_broadcast
|| !memcmp(ipx
->ipx_dest
.node
,
407 ipxs
->node
, IPX_NODE_LEN
))) {
408 /* We found a socket to which to send */
409 struct sk_buff
*skb1
;
412 skb1
= skb_clone(skb
, GFP_ATOMIC
);
418 copy
= 1; /* skb may only be used once */
420 ipxitf_def_skb_handler(s
, skb1
);
422 /* On an external interface, one socket can listen */
423 if (intrfc
!= ipx_internal_net
)
428 /* skb was solely for us, and we did not make a copy, so free it. */
434 spin_unlock_bh(&intrfc
->if_sklist_lock
);
438 static struct sock
*ncp_connection_hack(struct ipx_interface
*intrfc
,
441 /* The packet's target is a NCP connection handler. We want to hand it
442 * to the correct socket directly within the kernel, so that the
443 * mars_nwe packet distribution process does not have to do it. Here we
444 * only care about NCP and BURST packets.
446 * You might call this a hack, but believe me, you do not want a
447 * complete NCP layer in the kernel, and this is VERY fast as well. */
448 struct sock
*sk
= NULL
;
450 u8
*ncphdr
= (u8
*)(ipx
+ 1);
452 if (*ncphdr
== 0x22 && *(ncphdr
+ 1) == 0x22) /* NCP request */
453 connection
= (((int) *(ncphdr
+ 5)) << 8) | (int) *(ncphdr
+ 3);
454 else if (*ncphdr
== 0x77 && *(ncphdr
+ 1) == 0x77) /* BURST packet */
455 connection
= (((int) *(ncphdr
+ 9)) << 8) | (int) *(ncphdr
+ 8);
458 struct hlist_node
*node
;
459 /* Now we have to look for a special NCP connection handling
460 * socket. Only these sockets have ipx_ncp_conn != 0, set by
462 spin_lock_bh(&intrfc
->if_sklist_lock
);
463 sk_for_each(sk
, node
, &intrfc
->if_sklist
)
464 if (ipx_sk(sk
)->ipx_ncp_conn
== connection
) {
470 spin_unlock_bh(&intrfc
->if_sklist_lock
);
475 static int ipxitf_demux_socket(struct ipx_interface
*intrfc
,
476 struct sk_buff
*skb
, int copy
)
478 struct ipxhdr
*ipx
= ipx_hdr(skb
);
479 struct sock
*sock1
= NULL
, *sock2
= NULL
;
480 struct sk_buff
*skb1
= NULL
, *skb2
= NULL
;
483 if (intrfc
== ipx_primary_net
&& ntohs(ipx
->ipx_dest
.sock
) == 0x451)
484 sock1
= ncp_connection_hack(intrfc
, ipx
);
486 /* No special socket found, forward the packet the normal way */
487 sock1
= ipxitf_find_socket(intrfc
, ipx
->ipx_dest
.sock
);
490 * We need to check if there is a primary net and if
491 * this is addressed to one of the *SPECIAL* sockets because
492 * these need to be propagated to the primary net.
493 * The *SPECIAL* socket list contains: 0x452(SAP), 0x453(RIP) and
497 if (ipx_primary_net
&& intrfc
!= ipx_primary_net
) {
498 const int dsock
= ntohs(ipx
->ipx_dest
.sock
);
500 if (dsock
== 0x452 || dsock
== 0x453 || dsock
== 0x456)
501 /* The appropriate thing to do here is to dup the
502 * packet and route to the primary net interface via
503 * ipxitf_send; however, we'll cheat and just demux it
505 sock2
= ipxitf_find_socket(ipx_primary_net
,
510 * If there is nothing to do return. The kfree will cancel any charging.
513 if (!sock1
&& !sock2
) {
520 * This next segment of code is a little awkward, but it sets it up
521 * so that the appropriate number of copies of the SKB are made and
522 * that skb1 and skb2 point to it (them) so that it (they) can be
523 * demuxed to sock1 and/or sock2. If we are unable to make enough
524 * copies, we do as much as is possible.
528 skb1
= skb_clone(skb
, GFP_ATOMIC
);
536 /* Do we need 2 SKBs? */
538 skb2
= skb_clone(skb1
, GFP_ATOMIC
);
543 ipxitf_def_skb_handler(sock1
, skb1
);
549 ipxitf_def_skb_handler(sock2
, skb2
);
560 #endif /* CONFIG_IPX_INTERN */
562 static struct sk_buff
*ipxitf_adjust_skbuff(struct ipx_interface
*intrfc
,
565 struct sk_buff
*skb2
;
566 int in_offset
= (unsigned char *)ipx_hdr(skb
) - skb
->head
;
567 int out_offset
= intrfc
->if_ipx_offset
;
570 /* Hopefully, most cases */
571 if (in_offset
>= out_offset
)
575 len
= skb
->len
+ out_offset
;
576 skb2
= alloc_skb(len
, GFP_ATOMIC
);
578 skb_reserve(skb2
, out_offset
);
579 skb_reset_network_header(skb2
);
580 skb_reset_transport_header(skb2
);
581 skb_put(skb2
, skb
->len
);
582 memcpy(ipx_hdr(skb2
), ipx_hdr(skb
), skb
->len
);
583 memcpy(skb2
->cb
, skb
->cb
, sizeof(skb
->cb
));
589 /* caller must hold a reference to intrfc and the skb has to be unshared */
590 int ipxitf_send(struct ipx_interface
*intrfc
, struct sk_buff
*skb
, char *node
)
592 struct ipxhdr
*ipx
= ipx_hdr(skb
);
593 struct net_device
*dev
= intrfc
->if_dev
;
594 struct datalink_proto
*dl
= intrfc
->if_dlink
;
595 char dest_node
[IPX_NODE_LEN
];
596 int send_to_wire
= 1;
599 ipx
->ipx_tctrl
= IPX_SKB_CB(skb
)->ipx_tctrl
;
600 ipx
->ipx_dest
.net
= IPX_SKB_CB(skb
)->ipx_dest_net
;
601 ipx
->ipx_source
.net
= IPX_SKB_CB(skb
)->ipx_source_net
;
603 /* see if we need to include the netnum in the route list */
604 if (IPX_SKB_CB(skb
)->last_hop
.index
>= 0) {
605 __be32
*last_hop
= (__be32
*)(((u8
*) skb
->data
) +
606 sizeof(struct ipxhdr
) +
607 IPX_SKB_CB(skb
)->last_hop
.index
*
609 *last_hop
= IPX_SKB_CB(skb
)->last_hop
.netnum
;
610 IPX_SKB_CB(skb
)->last_hop
.index
= -1;
614 * We need to know how many skbuffs it will take to send out this
615 * packet to avoid unnecessary copies.
618 if (!dl
|| !dev
|| dev
->flags
& IFF_LOOPBACK
)
619 send_to_wire
= 0; /* No non looped */
622 * See if this should be demuxed to sockets on this interface
624 * We want to ensure the original was eaten or that we only use
628 if (ipx
->ipx_dest
.net
== intrfc
->if_netnum
) {
630 * To our own node, loop and free the original.
631 * The internal net will receive on all node address.
633 if (intrfc
== ipx_internal_net
||
634 !memcmp(intrfc
->if_node
, node
, IPX_NODE_LEN
)) {
635 /* Don't charge sender */
638 /* Will charge receiver */
639 return ipxitf_demux_socket(intrfc
, skb
, 0);
642 /* Broadcast, loop and possibly keep to send on. */
643 if (!memcmp(ipx_broadcast_node
, node
, IPX_NODE_LEN
)) {
646 ipxitf_demux_socket(intrfc
, skb
, send_to_wire
);
653 * If the originating net is not equal to our net; this is routed
654 * We are still charging the sender. Which is right - the driver
655 * free will handle this fairly.
657 if (ipx
->ipx_source
.net
!= intrfc
->if_netnum
) {
659 * Unshare the buffer before modifying the count in
660 * case it's a flood or tcpdump
662 skb
= skb_unshare(skb
, GFP_ATOMIC
);
665 if (++ipx
->ipx_tctrl
> ipxcfg_max_hops
)
674 /* Determine the appropriate hardware address */
675 addr_len
= dev
->addr_len
;
676 if (!memcmp(ipx_broadcast_node
, node
, IPX_NODE_LEN
))
677 memcpy(dest_node
, dev
->broadcast
, addr_len
);
679 memcpy(dest_node
, &(node
[IPX_NODE_LEN
-addr_len
]), addr_len
);
681 /* Make any compensation for differing physical/data link size */
682 skb
= ipxitf_adjust_skbuff(intrfc
, skb
);
686 /* set up data link and physical headers */
688 skb
->protocol
= htons(ETH_P_IPX
);
691 dl
->request(dl
, skb
, dest_node
);
696 static int ipxitf_add_local_route(struct ipx_interface
*intrfc
)
698 return ipxrtr_add_route(intrfc
->if_netnum
, intrfc
, NULL
);
701 static void ipxitf_discover_netnum(struct ipx_interface
*intrfc
,
702 struct sk_buff
*skb
);
703 static int ipxitf_pprop(struct ipx_interface
*intrfc
, struct sk_buff
*skb
);
705 static int ipxitf_rcv(struct ipx_interface
*intrfc
, struct sk_buff
*skb
)
707 struct ipxhdr
*ipx
= ipx_hdr(skb
);
712 /* See if we should update our network number */
713 if (!intrfc
->if_netnum
) /* net number of intrfc not known yet */
714 ipxitf_discover_netnum(intrfc
, skb
);
716 IPX_SKB_CB(skb
)->last_hop
.index
= -1;
717 if (ipx
->ipx_type
== IPX_TYPE_PPROP
) {
718 rc
= ipxitf_pprop(intrfc
, skb
);
723 /* local processing follows */
724 if (!IPX_SKB_CB(skb
)->ipx_dest_net
)
725 IPX_SKB_CB(skb
)->ipx_dest_net
= intrfc
->if_netnum
;
726 if (!IPX_SKB_CB(skb
)->ipx_source_net
)
727 IPX_SKB_CB(skb
)->ipx_source_net
= intrfc
->if_netnum
;
729 /* it doesn't make sense to route a pprop packet, there's no meaning
730 * in the ipx_dest_net for such packets */
731 if (ipx
->ipx_type
!= IPX_TYPE_PPROP
&&
732 intrfc
->if_netnum
!= IPX_SKB_CB(skb
)->ipx_dest_net
) {
733 /* We only route point-to-point packets. */
734 if (skb
->pkt_type
== PACKET_HOST
) {
735 skb
= skb_unshare(skb
, GFP_ATOMIC
);
737 rc
= ipxrtr_route_skb(skb
);
744 /* see if we should keep it */
745 if (!memcmp(ipx_broadcast_node
, ipx
->ipx_dest
.node
, IPX_NODE_LEN
) ||
746 !memcmp(intrfc
->if_node
, ipx
->ipx_dest
.node
, IPX_NODE_LEN
)) {
747 rc
= ipxitf_demux_socket(intrfc
, skb
, 0);
751 /* we couldn't pawn it off so unload it */
759 static void ipxitf_discover_netnum(struct ipx_interface
*intrfc
,
762 const struct ipx_cb
*cb
= IPX_SKB_CB(skb
);
764 /* see if this is an intra packet: source_net == dest_net */
765 if (cb
->ipx_source_net
== cb
->ipx_dest_net
&& cb
->ipx_source_net
) {
766 struct ipx_interface
*i
=
767 ipxitf_find_using_net(cb
->ipx_source_net
);
768 /* NB: NetWare servers lie about their hop count so we
769 * dropped the test based on it. This is the best way
770 * to determine this is a 0 hop count packet. */
772 intrfc
->if_netnum
= cb
->ipx_source_net
;
773 ipxitf_add_local_route(intrfc
);
775 printk(KERN_WARNING
"IPX: Network number collision "
776 "%lx\n %s %s and %s %s\n",
777 (unsigned long) ntohl(cb
->ipx_source_net
),
779 ipx_frame_name(i
->if_dlink_type
),
780 ipx_device_name(intrfc
),
781 ipx_frame_name(intrfc
->if_dlink_type
));
788 * ipxitf_pprop - Process packet propagation IPX packet type 0x14, used for
790 * @intrfc: IPX interface receiving this packet
791 * @skb: Received packet
793 * Checks if packet is valid: if its more than %IPX_MAX_PPROP_HOPS hops or if it
794 * is smaller than a IPX header + the room for %IPX_MAX_PPROP_HOPS hops we drop
795 * it, not even processing it locally, if it has exact %IPX_MAX_PPROP_HOPS we
796 * don't broadcast it, but process it locally. See chapter 5 of Novell's "IPX
797 * RIP and SAP Router Specification", Part Number 107-000029-001.
799 * If it is valid, check if we have pprop broadcasting enabled by the user,
800 * if not, just return zero for local processing.
802 * If it is enabled check the packet and don't broadcast it if we have already
805 * Broadcast: send it to the interfaces that aren't on the packet visited nets
806 * array, just after the IPX header.
808 * Returns -EINVAL for invalid packets, so that the calling function drops
809 * the packet without local processing. 0 if packet is to be locally processed.
811 static int ipxitf_pprop(struct ipx_interface
*intrfc
, struct sk_buff
*skb
)
813 struct ipxhdr
*ipx
= ipx_hdr(skb
);
815 struct ipx_interface
*ifcs
;
819 /* Illegal packet - too many hops or too short */
820 /* We decide to throw it away: no broadcasting, no local processing.
821 * NetBIOS unaware implementations route them as normal packets -
822 * tctrl <= 15, any data payload... */
823 if (IPX_SKB_CB(skb
)->ipx_tctrl
> IPX_MAX_PPROP_HOPS
||
824 ntohs(ipx
->ipx_pktsize
) < sizeof(struct ipxhdr
) +
825 IPX_MAX_PPROP_HOPS
* sizeof(u32
))
827 /* are we broadcasting this damn thing? */
829 if (!sysctl_ipx_pprop_broadcasting
)
831 /* We do broadcast packet on the IPX_MAX_PPROP_HOPS hop, but we
832 * process it locally. All previous hops broadcasted it, and process it
834 if (IPX_SKB_CB(skb
)->ipx_tctrl
== IPX_MAX_PPROP_HOPS
)
837 c
= ((u8
*) ipx
) + sizeof(struct ipxhdr
);
840 /* Don't broadcast packet if already seen this net */
841 for (i
= 0; i
< IPX_SKB_CB(skb
)->ipx_tctrl
; i
++)
842 if (*l
++ == intrfc
->if_netnum
)
845 /* < IPX_MAX_PPROP_HOPS hops && input interface not in list. Save the
846 * position where we will insert recvd netnum into list, later on,
848 IPX_SKB_CB(skb
)->last_hop
.index
= i
;
849 IPX_SKB_CB(skb
)->last_hop
.netnum
= intrfc
->if_netnum
;
850 /* xmit on all other interfaces... */
851 spin_lock_bh(&ipx_interfaces_lock
);
852 list_for_each_entry(ifcs
, &ipx_interfaces
, node
) {
853 /* Except unconfigured interfaces */
854 if (!ifcs
->if_netnum
)
857 /* That aren't in the list */
861 /* don't consider the last entry in the packet list,
862 * it is our netnum, and it is not there yet */
863 for (i
= 0; i
< IPX_SKB_CB(skb
)->ipx_tctrl
; i
++)
864 if (ifcs
->if_netnum
== *l
++)
866 if (i
== IPX_SKB_CB(skb
)->ipx_tctrl
) {
867 struct sk_buff
*s
= skb_copy(skb
, GFP_ATOMIC
);
870 IPX_SKB_CB(s
)->ipx_dest_net
= ifcs
->if_netnum
;
875 spin_unlock_bh(&ipx_interfaces_lock
);
880 static void ipxitf_insert(struct ipx_interface
*intrfc
)
882 spin_lock_bh(&ipx_interfaces_lock
);
883 list_add_tail(&intrfc
->node
, &ipx_interfaces
);
884 spin_unlock_bh(&ipx_interfaces_lock
);
886 if (ipxcfg_auto_select_primary
&& !ipx_primary_net
)
887 ipx_primary_net
= intrfc
;
890 static struct ipx_interface
*ipxitf_alloc(struct net_device
*dev
, __be32 netnum
,
892 struct datalink_proto
*dlink
,
893 unsigned char internal
,
896 struct ipx_interface
*intrfc
= kmalloc(sizeof(*intrfc
), GFP_ATOMIC
);
899 intrfc
->if_dev
= dev
;
900 intrfc
->if_netnum
= netnum
;
901 intrfc
->if_dlink_type
= dlink_type
;
902 intrfc
->if_dlink
= dlink
;
903 intrfc
->if_internal
= internal
;
904 intrfc
->if_ipx_offset
= ipx_offset
;
905 intrfc
->if_sknum
= IPX_MIN_EPHEMERAL_SOCKET
;
906 INIT_HLIST_HEAD(&intrfc
->if_sklist
);
907 atomic_set(&intrfc
->refcnt
, 1);
908 spin_lock_init(&intrfc
->if_sklist_lock
);
914 static int ipxitf_create_internal(struct ipx_interface_definition
*idef
)
916 struct ipx_interface
*intrfc
;
919 /* Only one primary network allowed */
923 /* Must have a valid network number */
925 if (!idef
->ipx_network
)
927 intrfc
= ipxitf_find_using_net(idef
->ipx_network
);
933 intrfc
= ipxitf_alloc(NULL
, idef
->ipx_network
, 0, NULL
, 1, 0);
937 memcpy((char *)&(intrfc
->if_node
), idef
->ipx_node
, IPX_NODE_LEN
);
938 ipx_internal_net
= ipx_primary_net
= intrfc
;
940 ipxitf_insert(intrfc
);
942 rc
= ipxitf_add_local_route(intrfc
);
948 static __be16
ipx_map_frame_type(unsigned char type
)
953 case IPX_FRAME_ETHERII
: rc
= htons(ETH_P_IPX
); break;
954 case IPX_FRAME_8022
: rc
= htons(ETH_P_802_2
); break;
955 case IPX_FRAME_SNAP
: rc
= htons(ETH_P_SNAP
); break;
956 case IPX_FRAME_8023
: rc
= htons(ETH_P_802_3
); break;
962 static int ipxitf_create(struct ipx_interface_definition
*idef
)
964 struct net_device
*dev
;
965 __be16 dlink_type
= 0;
966 struct datalink_proto
*datalink
= NULL
;
967 struct ipx_interface
*intrfc
;
970 if (idef
->ipx_special
== IPX_INTERNAL
) {
971 rc
= ipxitf_create_internal(idef
);
976 if (idef
->ipx_special
== IPX_PRIMARY
&& ipx_primary_net
)
979 intrfc
= ipxitf_find_using_net(idef
->ipx_network
);
981 if (idef
->ipx_network
&& intrfc
) {
989 dev
= dev_get_by_name(idef
->ipx_device
);
994 switch (idef
->ipx_dlink_type
) {
995 case IPX_FRAME_TR_8022
:
996 printk(KERN_WARNING
"IPX frame type 802.2TR is "
997 "obsolete Use 802.2 instead.\n");
1000 dlink_type
= htons(ETH_P_802_2
);
1001 datalink
= p8022_datalink
;
1003 case IPX_FRAME_ETHERII
:
1004 if (dev
->type
!= ARPHRD_IEEE802
) {
1005 dlink_type
= htons(ETH_P_IPX
);
1006 datalink
= pEII_datalink
;
1009 printk(KERN_WARNING
"IPX frame type EtherII over "
1010 "token-ring is obsolete. Use SNAP "
1013 case IPX_FRAME_SNAP
:
1014 dlink_type
= htons(ETH_P_SNAP
);
1015 datalink
= pSNAP_datalink
;
1017 case IPX_FRAME_8023
:
1018 dlink_type
= htons(ETH_P_802_3
);
1019 datalink
= p8023_datalink
;
1021 case IPX_FRAME_NONE
:
1023 rc
= -EPROTONOSUPPORT
;
1028 if (!(dev
->flags
& IFF_UP
))
1031 /* Check addresses are suitable */
1033 if (dev
->addr_len
> IPX_NODE_LEN
)
1036 intrfc
= ipxitf_find_using_phys(dev
, dlink_type
);
1039 intrfc
= ipxitf_alloc(dev
, idef
->ipx_network
, dlink_type
,
1040 datalink
, 0, dev
->hard_header_len
+
1041 datalink
->header_length
);
1045 /* Setup primary if necessary */
1046 if (idef
->ipx_special
== IPX_PRIMARY
)
1047 ipx_primary_net
= intrfc
;
1048 if (!memcmp(idef
->ipx_node
, "\000\000\000\000\000\000",
1050 memset(intrfc
->if_node
, 0, IPX_NODE_LEN
);
1051 memcpy(intrfc
->if_node
+ IPX_NODE_LEN
- dev
->addr_len
,
1052 dev
->dev_addr
, dev
->addr_len
);
1054 memcpy(intrfc
->if_node
, idef
->ipx_node
, IPX_NODE_LEN
);
1055 ipxitf_hold(intrfc
);
1056 ipxitf_insert(intrfc
);
1060 /* If the network number is known, add a route */
1062 if (!intrfc
->if_netnum
)
1065 rc
= ipxitf_add_local_route(intrfc
);
1075 static int ipxitf_delete(struct ipx_interface_definition
*idef
)
1077 struct net_device
*dev
= NULL
;
1078 __be16 dlink_type
= 0;
1079 struct ipx_interface
*intrfc
;
1082 spin_lock_bh(&ipx_interfaces_lock
);
1083 if (idef
->ipx_special
== IPX_INTERNAL
) {
1084 if (ipx_internal_net
) {
1085 __ipxitf_put(ipx_internal_net
);
1092 dlink_type
= ipx_map_frame_type(idef
->ipx_dlink_type
);
1093 rc
= -EPROTONOSUPPORT
;
1097 dev
= __dev_get_by_name(idef
->ipx_device
);
1102 intrfc
= __ipxitf_find_using_phys(dev
, dlink_type
);
1106 __ipxitf_put(intrfc
);
1110 spin_unlock_bh(&ipx_interfaces_lock
);
1114 static struct ipx_interface
*ipxitf_auto_create(struct net_device
*dev
,
1117 struct ipx_interface
*intrfc
= NULL
;
1118 struct datalink_proto
*datalink
;
1123 /* Check addresses are suitable */
1124 if (dev
->addr_len
> IPX_NODE_LEN
)
1127 switch (ntohs(dlink_type
)) {
1128 case ETH_P_IPX
: datalink
= pEII_datalink
; break;
1129 case ETH_P_802_2
: datalink
= p8022_datalink
; break;
1130 case ETH_P_SNAP
: datalink
= pSNAP_datalink
; break;
1131 case ETH_P_802_3
: datalink
= p8023_datalink
; break;
1135 intrfc
= ipxitf_alloc(dev
, 0, dlink_type
, datalink
, 0,
1136 dev
->hard_header_len
+ datalink
->header_length
);
1139 memset(intrfc
->if_node
, 0, IPX_NODE_LEN
);
1140 memcpy((char *)&(intrfc
->if_node
[IPX_NODE_LEN
-dev
->addr_len
]),
1141 dev
->dev_addr
, dev
->addr_len
);
1142 spin_lock_init(&intrfc
->if_sklist_lock
);
1143 atomic_set(&intrfc
->refcnt
, 1);
1144 ipxitf_insert(intrfc
);
1152 static int ipxitf_ioctl(unsigned int cmd
, void __user
*arg
)
1160 struct sockaddr_ipx
*sipx
;
1161 struct ipx_interface_definition f
;
1164 if (copy_from_user(&ifr
, arg
, sizeof(ifr
)))
1166 sipx
= (struct sockaddr_ipx
*)&ifr
.ifr_addr
;
1168 if (sipx
->sipx_family
!= AF_IPX
)
1170 f
.ipx_network
= sipx
->sipx_network
;
1171 memcpy(f
.ipx_device
, ifr
.ifr_name
,
1172 sizeof(f
.ipx_device
));
1173 memcpy(f
.ipx_node
, sipx
->sipx_node
, IPX_NODE_LEN
);
1174 f
.ipx_dlink_type
= sipx
->sipx_type
;
1175 f
.ipx_special
= sipx
->sipx_special
;
1177 if (sipx
->sipx_action
== IPX_DLTITF
)
1178 rc
= ipxitf_delete(&f
);
1180 rc
= ipxitf_create(&f
);
1184 struct sockaddr_ipx
*sipx
;
1185 struct ipx_interface
*ipxif
;
1186 struct net_device
*dev
;
1189 if (copy_from_user(&ifr
, arg
, sizeof(ifr
)))
1191 sipx
= (struct sockaddr_ipx
*)&ifr
.ifr_addr
;
1192 dev
= __dev_get_by_name(ifr
.ifr_name
);
1196 ipxif
= ipxitf_find_using_phys(dev
,
1197 ipx_map_frame_type(sipx
->sipx_type
));
1198 rc
= -EADDRNOTAVAIL
;
1202 sipx
->sipx_family
= AF_IPX
;
1203 sipx
->sipx_network
= ipxif
->if_netnum
;
1204 memcpy(sipx
->sipx_node
, ipxif
->if_node
,
1205 sizeof(sipx
->sipx_node
));
1207 if (copy_to_user(arg
, &ifr
, sizeof(ifr
)))
1213 case SIOCAIPXITFCRT
:
1215 if (get_user(val
, (unsigned char __user
*) arg
))
1218 ipxcfg_auto_create_interfaces
= val
;
1220 case SIOCAIPXPRISLT
:
1222 if (get_user(val
, (unsigned char __user
*) arg
))
1225 ipxcfg_set_auto_select(val
);
1233 * Checksum routine for IPX
1236 /* Note: We assume ipx_tctrl==0 and htons(length)==ipx_pktsize */
1237 /* This functions should *not* mess with packet contents */
1239 __be16
ipx_cksum(struct ipxhdr
*packet
, int length
)
1242 * NOTE: sum is a net byte order quantity, which optimizes the
1243 * loop. This only works on big and little endian machines. (I
1244 * don't know of a machine that isn't.)
1246 /* handle the first 3 words separately; checksum should be skipped
1247 * and ipx_tctrl masked out */
1248 __u16
*p
= (__u16
*)packet
;
1249 __u32 sum
= p
[1] + (p
[2] & (__force u16
)htons(0x00ff));
1250 __u32 i
= (length
>> 1) - 3; /* Number of remaining complete words */
1252 /* Loop through them */
1257 /* Add on the last part word if it exists */
1258 if (packet
->ipx_pktsize
& htons(1))
1259 sum
+= (__force u16
)htons(0xff00) & *p
;
1261 /* Do final fixup */
1262 sum
= (sum
& 0xffff) + (sum
>> 16);
1264 /* It's a pity there's no concept of carry in C */
1269 * Leave 0 alone; we don't want 0xffff here. Note that we can't get
1270 * here with 0x10000, so this check is the same as ((__u16)sum)
1275 return (__force __be16
)sum
;
1278 const char *ipx_frame_name(__be16 frame
)
1282 switch (ntohs(frame
)) {
1283 case ETH_P_IPX
: rc
= "EtherII"; break;
1284 case ETH_P_802_2
: rc
= "802.2"; break;
1285 case ETH_P_SNAP
: rc
= "SNAP"; break;
1286 case ETH_P_802_3
: rc
= "802.3"; break;
1287 case ETH_P_TR_802_2
: rc
= "802.2TR"; break;
1293 const char *ipx_device_name(struct ipx_interface
*intrfc
)
1295 return intrfc
->if_internal
? "Internal" :
1296 intrfc
->if_dev
? intrfc
->if_dev
->name
: "Unknown";
1299 /* Handling for system calls applied via the various interfaces to an IPX
1302 static int ipx_setsockopt(struct socket
*sock
, int level
, int optname
,
1303 char __user
*optval
, int optlen
)
1305 struct sock
*sk
= sock
->sk
;
1309 if (optlen
!= sizeof(int))
1313 if (get_user(opt
, (unsigned int __user
*)optval
))
1317 if (!(level
== SOL_IPX
&& optname
== IPX_TYPE
))
1320 ipx_sk(sk
)->type
= opt
;
1326 static int ipx_getsockopt(struct socket
*sock
, int level
, int optname
,
1327 char __user
*optval
, int __user
*optlen
)
1329 struct sock
*sk
= sock
->sk
;
1332 int rc
= -ENOPROTOOPT
;
1334 if (!(level
== SOL_IPX
&& optname
== IPX_TYPE
))
1337 val
= ipx_sk(sk
)->type
;
1340 if (get_user(len
, optlen
))
1343 len
= min_t(unsigned int, len
, sizeof(int));
1349 if (put_user(len
, optlen
) || copy_to_user(optval
, &val
, len
))
1357 static struct proto ipx_proto
= {
1359 .owner
= THIS_MODULE
,
1360 .obj_size
= sizeof(struct ipx_sock
),
1363 static int ipx_create(struct socket
*sock
, int protocol
)
1365 int rc
= -ESOCKTNOSUPPORT
;
1369 * SPX support is not anymore in the kernel sources. If you want to
1370 * ressurrect it, completing it and making it understand shared skbs,
1371 * be fully multithreaded, etc, grab the sources in an early 2.5 kernel
1374 if (sock
->type
!= SOCK_DGRAM
)
1378 sk
= sk_alloc(PF_IPX
, GFP_KERNEL
, &ipx_proto
, 1);
1381 #ifdef IPX_REFCNT_DEBUG
1382 atomic_inc(&ipx_sock_nr
);
1383 printk(KERN_DEBUG
"IPX socket %p created, now we have %d alive\n", sk
,
1384 atomic_read(&ipx_sock_nr
));
1386 sock_init_data(sock
, sk
);
1387 sk
->sk_no_check
= 1; /* Checksum off by default */
1388 sock
->ops
= &ipx_dgram_ops
;
1394 static int ipx_release(struct socket
*sock
)
1396 struct sock
*sk
= sock
->sk
;
1401 if (!sock_flag(sk
, SOCK_DEAD
))
1402 sk
->sk_state_change(sk
);
1404 sock_set_flag(sk
, SOCK_DEAD
);
1406 ipx_destroy_socket(sk
);
1411 /* caller must hold a reference to intrfc */
1413 static __be16
ipx_first_free_socketnum(struct ipx_interface
*intrfc
)
1415 unsigned short socketNum
= intrfc
->if_sknum
;
1417 spin_lock_bh(&intrfc
->if_sklist_lock
);
1419 if (socketNum
< IPX_MIN_EPHEMERAL_SOCKET
)
1420 socketNum
= IPX_MIN_EPHEMERAL_SOCKET
;
1422 while (__ipxitf_find_socket(intrfc
, htons(socketNum
)))
1423 if (socketNum
> IPX_MAX_EPHEMERAL_SOCKET
)
1424 socketNum
= IPX_MIN_EPHEMERAL_SOCKET
;
1428 spin_unlock_bh(&intrfc
->if_sklist_lock
);
1429 intrfc
->if_sknum
= socketNum
;
1431 return htons(socketNum
);
1434 static int ipx_bind(struct socket
*sock
, struct sockaddr
*uaddr
, int addr_len
)
1436 struct sock
*sk
= sock
->sk
;
1437 struct ipx_sock
*ipxs
= ipx_sk(sk
);
1438 struct ipx_interface
*intrfc
;
1439 struct sockaddr_ipx
*addr
= (struct sockaddr_ipx
*)uaddr
;
1442 if (!sock_flag(sk
, SOCK_ZAPPED
) || addr_len
!= sizeof(struct sockaddr_ipx
))
1445 intrfc
= ipxitf_find_using_net(addr
->sipx_network
);
1446 rc
= -EADDRNOTAVAIL
;
1450 if (!addr
->sipx_port
) {
1451 addr
->sipx_port
= ipx_first_free_socketnum(intrfc
);
1453 if (!addr
->sipx_port
)
1457 /* protect IPX system stuff like routing/sap */
1459 if (ntohs(addr
->sipx_port
) < IPX_MIN_EPHEMERAL_SOCKET
&&
1460 !capable(CAP_NET_ADMIN
))
1463 ipxs
->port
= addr
->sipx_port
;
1465 #ifdef CONFIG_IPX_INTERN
1466 if (intrfc
== ipx_internal_net
) {
1467 /* The source address is to be set explicitly if the
1468 * socket is to be bound on the internal network. If a
1469 * node number 0 was specified, the default is used.
1473 if (!memcmp(addr
->sipx_node
, ipx_broadcast_node
, IPX_NODE_LEN
))
1475 if (!memcmp(addr
->sipx_node
, ipx_this_node
, IPX_NODE_LEN
))
1476 memcpy(ipxs
->node
, intrfc
->if_node
, IPX_NODE_LEN
);
1478 memcpy(ipxs
->node
, addr
->sipx_node
, IPX_NODE_LEN
);
1481 if (ipxitf_find_internal_socket(intrfc
, ipxs
->node
,
1484 "IPX: bind failed because port %X in use.\n",
1485 ntohs(addr
->sipx_port
));
1489 /* Source addresses are easy. It must be our
1490 * network:node pair for an interface routed to IPX
1491 * with the ipx routing ioctl()
1494 memcpy(ipxs
->node
, intrfc
->if_node
, IPX_NODE_LEN
);
1497 if (ipxitf_find_socket(intrfc
, addr
->sipx_port
)) {
1499 "IPX: bind failed because port %X in use.\n",
1500 ntohs(addr
->sipx_port
));
1505 #else /* !def CONFIG_IPX_INTERN */
1507 /* Source addresses are easy. It must be our network:node pair for
1508 an interface routed to IPX with the ipx routing ioctl() */
1511 if (ipxitf_find_socket(intrfc
, addr
->sipx_port
)) {
1512 SOCK_DEBUG(sk
, "IPX: bind failed because port %X in use.\n",
1513 ntohs((int)addr
->sipx_port
));
1517 #endif /* CONFIG_IPX_INTERN */
1519 ipxitf_insert_socket(intrfc
, sk
);
1520 sock_reset_flag(sk
, SOCK_ZAPPED
);
1529 static int ipx_connect(struct socket
*sock
, struct sockaddr
*uaddr
,
1530 int addr_len
, int flags
)
1532 struct sock
*sk
= sock
->sk
;
1533 struct ipx_sock
*ipxs
= ipx_sk(sk
);
1534 struct sockaddr_ipx
*addr
;
1536 struct ipx_route
*rt
;
1538 sk
->sk_state
= TCP_CLOSE
;
1539 sock
->state
= SS_UNCONNECTED
;
1541 if (addr_len
!= sizeof(*addr
))
1543 addr
= (struct sockaddr_ipx
*)uaddr
;
1545 /* put the autobinding in */
1547 struct sockaddr_ipx uaddr
;
1549 uaddr
.sipx_port
= 0;
1550 uaddr
.sipx_network
= 0;
1552 #ifdef CONFIG_IPX_INTERN
1555 goto out
; /* Someone zonked the iface */
1556 memcpy(uaddr
.sipx_node
, ipxs
->intrfc
->if_node
,
1558 #endif /* CONFIG_IPX_INTERN */
1560 rc
= ipx_bind(sock
, (struct sockaddr
*)&uaddr
,
1561 sizeof(struct sockaddr_ipx
));
1566 /* We can either connect to primary network or somewhere
1567 * we can route to */
1568 rt
= ipxrtr_lookup(addr
->sipx_network
);
1570 if (!rt
&& !(!addr
->sipx_network
&& ipx_primary_net
))
1573 ipxs
->dest_addr
.net
= addr
->sipx_network
;
1574 ipxs
->dest_addr
.sock
= addr
->sipx_port
;
1575 memcpy(ipxs
->dest_addr
.node
, addr
->sipx_node
, IPX_NODE_LEN
);
1576 ipxs
->type
= addr
->sipx_type
;
1578 if (sock
->type
== SOCK_DGRAM
) {
1579 sock
->state
= SS_CONNECTED
;
1580 sk
->sk_state
= TCP_ESTABLISHED
;
1591 static int ipx_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
1592 int *uaddr_len
, int peer
)
1594 struct ipx_address
*addr
;
1595 struct sockaddr_ipx sipx
;
1596 struct sock
*sk
= sock
->sk
;
1597 struct ipx_sock
*ipxs
= ipx_sk(sk
);
1600 *uaddr_len
= sizeof(struct sockaddr_ipx
);
1604 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1607 addr
= &ipxs
->dest_addr
;
1608 sipx
.sipx_network
= addr
->net
;
1609 sipx
.sipx_port
= addr
->sock
;
1610 memcpy(sipx
.sipx_node
, addr
->node
, IPX_NODE_LEN
);
1613 sipx
.sipx_network
= ipxs
->intrfc
->if_netnum
;
1614 #ifdef CONFIG_IPX_INTERN
1615 memcpy(sipx
.sipx_node
, ipxs
->node
, IPX_NODE_LEN
);
1617 memcpy(sipx
.sipx_node
, ipxs
->intrfc
->if_node
,
1619 #endif /* CONFIG_IPX_INTERN */
1622 sipx
.sipx_network
= 0;
1623 memset(sipx
.sipx_node
, '\0', IPX_NODE_LEN
);
1626 sipx
.sipx_port
= ipxs
->port
;
1629 sipx
.sipx_family
= AF_IPX
;
1630 sipx
.sipx_type
= ipxs
->type
;
1632 memcpy(uaddr
, &sipx
, sizeof(sipx
));
1639 static int ipx_rcv(struct sk_buff
*skb
, struct net_device
*dev
, struct packet_type
*pt
, struct net_device
*orig_dev
)
1641 /* NULL here for pt means the packet was looped back */
1642 struct ipx_interface
*intrfc
;
1648 if (skb
->pkt_type
== PACKET_OTHERHOST
)
1651 if ((skb
= skb_share_check(skb
, GFP_ATOMIC
)) == NULL
)
1654 if (!pskb_may_pull(skb
, sizeof(struct ipxhdr
)))
1657 ipx_pktsize
= ntohs(ipx_hdr(skb
)->ipx_pktsize
);
1659 /* Too small or invalid header? */
1660 if (ipx_pktsize
< sizeof(struct ipxhdr
) ||
1661 !pskb_may_pull(skb
, ipx_pktsize
))
1665 if (ipx
->ipx_checksum
!= IPX_NO_CHECKSUM
&&
1666 ipx
->ipx_checksum
!= ipx_cksum(ipx
, ipx_pktsize
))
1669 IPX_SKB_CB(skb
)->ipx_tctrl
= ipx
->ipx_tctrl
;
1670 IPX_SKB_CB(skb
)->ipx_dest_net
= ipx
->ipx_dest
.net
;
1671 IPX_SKB_CB(skb
)->ipx_source_net
= ipx
->ipx_source
.net
;
1673 /* Determine what local ipx endpoint this is */
1674 intrfc
= ipxitf_find_using_phys(dev
, pt
->type
);
1676 if (ipxcfg_auto_create_interfaces
&&
1677 IPX_SKB_CB(skb
)->ipx_dest_net
) {
1678 intrfc
= ipxitf_auto_create(dev
, pt
->type
);
1680 ipxitf_hold(intrfc
);
1683 if (!intrfc
) /* Not one of ours */
1684 /* or invalid packet for auto creation */
1688 rc
= ipxitf_rcv(intrfc
, skb
);
1697 static int ipx_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
1698 struct msghdr
*msg
, size_t len
)
1700 struct sock
*sk
= sock
->sk
;
1701 struct ipx_sock
*ipxs
= ipx_sk(sk
);
1702 struct sockaddr_ipx
*usipx
= (struct sockaddr_ipx
*)msg
->msg_name
;
1703 struct sockaddr_ipx local_sipx
;
1705 int flags
= msg
->msg_flags
;
1707 /* Socket gets bound below anyway */
1708 /* if (sk->sk_zapped)
1709 return -EIO; */ /* Socket not bound */
1710 if (flags
& ~(MSG_DONTWAIT
|MSG_CMSG_COMPAT
))
1713 /* Max possible packet size limited by 16 bit pktsize in header */
1714 if (len
>= 65535 - sizeof(struct ipxhdr
))
1719 struct sockaddr_ipx uaddr
;
1721 uaddr
.sipx_port
= 0;
1722 uaddr
.sipx_network
= 0;
1723 #ifdef CONFIG_IPX_INTERN
1726 goto out
; /* Someone zonked the iface */
1727 memcpy(uaddr
.sipx_node
, ipxs
->intrfc
->if_node
,
1730 rc
= ipx_bind(sock
, (struct sockaddr
*)&uaddr
,
1731 sizeof(struct sockaddr_ipx
));
1737 if (msg
->msg_namelen
< sizeof(*usipx
) ||
1738 usipx
->sipx_family
!= AF_IPX
)
1742 if (sk
->sk_state
!= TCP_ESTABLISHED
)
1745 usipx
= &local_sipx
;
1746 usipx
->sipx_family
= AF_IPX
;
1747 usipx
->sipx_type
= ipxs
->type
;
1748 usipx
->sipx_port
= ipxs
->dest_addr
.sock
;
1749 usipx
->sipx_network
= ipxs
->dest_addr
.net
;
1750 memcpy(usipx
->sipx_node
, ipxs
->dest_addr
.node
, IPX_NODE_LEN
);
1753 rc
= ipxrtr_route_packet(sk
, usipx
, msg
->msg_iov
, len
,
1754 flags
& MSG_DONTWAIT
);
1762 static int ipx_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
1763 struct msghdr
*msg
, size_t size
, int flags
)
1765 struct sock
*sk
= sock
->sk
;
1766 struct ipx_sock
*ipxs
= ipx_sk(sk
);
1767 struct sockaddr_ipx
*sipx
= (struct sockaddr_ipx
*)msg
->msg_name
;
1768 struct ipxhdr
*ipx
= NULL
;
1769 struct sk_buff
*skb
;
1772 /* put the autobinding in */
1774 struct sockaddr_ipx uaddr
;
1776 uaddr
.sipx_port
= 0;
1777 uaddr
.sipx_network
= 0;
1779 #ifdef CONFIG_IPX_INTERN
1782 goto out
; /* Someone zonked the iface */
1783 memcpy(uaddr
.sipx_node
, ipxs
->intrfc
->if_node
, IPX_NODE_LEN
);
1784 #endif /* CONFIG_IPX_INTERN */
1786 rc
= ipx_bind(sock
, (struct sockaddr
*)&uaddr
,
1787 sizeof(struct sockaddr_ipx
));
1793 if (sock_flag(sk
, SOCK_ZAPPED
))
1796 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
1797 flags
& MSG_DONTWAIT
, &rc
);
1802 copied
= ntohs(ipx
->ipx_pktsize
) - sizeof(struct ipxhdr
);
1803 if (copied
> size
) {
1805 msg
->msg_flags
|= MSG_TRUNC
;
1808 rc
= skb_copy_datagram_iovec(skb
, sizeof(struct ipxhdr
), msg
->msg_iov
,
1812 if (skb
->tstamp
.tv64
)
1813 sk
->sk_stamp
= skb
->tstamp
;
1815 msg
->msg_namelen
= sizeof(*sipx
);
1818 sipx
->sipx_family
= AF_IPX
;
1819 sipx
->sipx_port
= ipx
->ipx_source
.sock
;
1820 memcpy(sipx
->sipx_node
, ipx
->ipx_source
.node
, IPX_NODE_LEN
);
1821 sipx
->sipx_network
= IPX_SKB_CB(skb
)->ipx_source_net
;
1822 sipx
->sipx_type
= ipx
->ipx_type
;
1823 sipx
->sipx_zero
= 0;
1828 skb_free_datagram(sk
, skb
);
1834 static int ipx_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1838 struct sock
*sk
= sock
->sk
;
1839 void __user
*argp
= (void __user
*)arg
;
1843 amount
= sk
->sk_sndbuf
- atomic_read(&sk
->sk_wmem_alloc
);
1846 rc
= put_user(amount
, (int __user
*)argp
);
1849 struct sk_buff
*skb
= skb_peek(&sk
->sk_receive_queue
);
1850 /* These two are safe on a single CPU system as only
1851 * user tasks fiddle here */
1853 amount
= skb
->len
- sizeof(struct ipxhdr
);
1854 rc
= put_user(amount
, (int __user
*)argp
);
1860 if (capable(CAP_NET_ADMIN
))
1861 rc
= ipxrtr_ioctl(cmd
, argp
);
1864 case SIOCAIPXITFCRT
:
1865 case SIOCAIPXPRISLT
:
1867 if (!capable(CAP_NET_ADMIN
))
1870 rc
= ipxitf_ioctl(cmd
, argp
);
1872 case SIOCIPXCFGDATA
:
1873 rc
= ipxcfg_get_config_data(argp
);
1875 case SIOCIPXNCPCONN
:
1877 * This socket wants to take care of the NCP connection
1878 * handed to us in arg.
1881 if (!capable(CAP_NET_ADMIN
))
1883 rc
= get_user(ipx_sk(sk
)->ipx_ncp_conn
,
1884 (const unsigned short __user
*)argp
);
1889 rc
= sock_get_timestamp(sk
, argp
);
1891 case SIOCGIFDSTADDR
:
1892 case SIOCSIFDSTADDR
:
1893 case SIOCGIFBRDADDR
:
1894 case SIOCSIFBRDADDR
:
1895 case SIOCGIFNETMASK
:
1896 case SIOCSIFNETMASK
:
1908 #ifdef CONFIG_COMPAT
1909 static int ipx_compat_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
1912 * These 4 commands use same structure on 32bit and 64bit. Rest of IPX
1913 * commands is handled by generic ioctl code. As these commands are
1914 * SIOCPROTOPRIVATE..SIOCPROTOPRIVATE+3, they cannot be handled by generic
1918 case SIOCAIPXITFCRT
:
1919 case SIOCAIPXPRISLT
:
1920 case SIOCIPXCFGDATA
:
1921 case SIOCIPXNCPCONN
:
1922 return ipx_ioctl(sock
, cmd
, arg
);
1924 return -ENOIOCTLCMD
;
1931 * Socket family declarations
1934 static struct net_proto_family ipx_family_ops
= {
1936 .create
= ipx_create
,
1937 .owner
= THIS_MODULE
,
1940 static const struct proto_ops
SOCKOPS_WRAPPED(ipx_dgram_ops
) = {
1942 .owner
= THIS_MODULE
,
1943 .release
= ipx_release
,
1945 .connect
= ipx_connect
,
1946 .socketpair
= sock_no_socketpair
,
1947 .accept
= sock_no_accept
,
1948 .getname
= ipx_getname
,
1949 .poll
= datagram_poll
,
1951 #ifdef CONFIG_COMPAT
1952 .compat_ioctl
= ipx_compat_ioctl
,
1954 .listen
= sock_no_listen
,
1955 .shutdown
= sock_no_shutdown
, /* FIXME: support shutdown */
1956 .setsockopt
= ipx_setsockopt
,
1957 .getsockopt
= ipx_getsockopt
,
1958 .sendmsg
= ipx_sendmsg
,
1959 .recvmsg
= ipx_recvmsg
,
1960 .mmap
= sock_no_mmap
,
1961 .sendpage
= sock_no_sendpage
,
1964 #include <linux/smp_lock.h>
1965 SOCKOPS_WRAP(ipx_dgram
, PF_IPX
);
1967 static struct packet_type ipx_8023_packet_type
= {
1968 .type
= __constant_htons(ETH_P_802_3
),
1972 static struct packet_type ipx_dix_packet_type
= {
1973 .type
= __constant_htons(ETH_P_IPX
),
1977 static struct notifier_block ipx_dev_notifier
= {
1978 .notifier_call
= ipxitf_device_event
,
1981 extern struct datalink_proto
*make_EII_client(void);
1982 extern void destroy_EII_client(struct datalink_proto
*);
1984 static unsigned char ipx_8022_type
= 0xE0;
1985 static unsigned char ipx_snap_id
[5] = { 0x0, 0x0, 0x0, 0x81, 0x37 };
1986 static char ipx_EII_err_msg
[] __initdata
=
1987 KERN_CRIT
"IPX: Unable to register with Ethernet II\n";
1988 static char ipx_8023_err_msg
[] __initdata
=
1989 KERN_CRIT
"IPX: Unable to register with 802.3\n";
1990 static char ipx_llc_err_msg
[] __initdata
=
1991 KERN_CRIT
"IPX: Unable to register with 802.2\n";
1992 static char ipx_snap_err_msg
[] __initdata
=
1993 KERN_CRIT
"IPX: Unable to register with SNAP\n";
1995 static int __init
ipx_init(void)
1997 int rc
= proto_register(&ipx_proto
, 1);
2002 sock_register(&ipx_family_ops
);
2004 pEII_datalink
= make_EII_client();
2006 dev_add_pack(&ipx_dix_packet_type
);
2008 printk(ipx_EII_err_msg
);
2010 p8023_datalink
= make_8023_client();
2012 dev_add_pack(&ipx_8023_packet_type
);
2014 printk(ipx_8023_err_msg
);
2016 p8022_datalink
= register_8022_client(ipx_8022_type
, ipx_rcv
);
2017 if (!p8022_datalink
)
2018 printk(ipx_llc_err_msg
);
2020 pSNAP_datalink
= register_snap_client(ipx_snap_id
, ipx_rcv
);
2021 if (!pSNAP_datalink
)
2022 printk(ipx_snap_err_msg
);
2024 register_netdevice_notifier(&ipx_dev_notifier
);
2025 ipx_register_sysctl();
2031 static void __exit
ipx_proto_finito(void)
2034 ipx_unregister_sysctl();
2036 unregister_netdevice_notifier(&ipx_dev_notifier
);
2040 if (pSNAP_datalink
) {
2041 unregister_snap_client(pSNAP_datalink
);
2042 pSNAP_datalink
= NULL
;
2045 if (p8022_datalink
) {
2046 unregister_8022_client(p8022_datalink
);
2047 p8022_datalink
= NULL
;
2050 dev_remove_pack(&ipx_8023_packet_type
);
2051 if (p8023_datalink
) {
2052 destroy_8023_client(p8023_datalink
);
2053 p8023_datalink
= NULL
;
2056 dev_remove_pack(&ipx_dix_packet_type
);
2057 if (pEII_datalink
) {
2058 destroy_EII_client(pEII_datalink
);
2059 pEII_datalink
= NULL
;
2062 proto_unregister(&ipx_proto
);
2063 sock_unregister(ipx_family_ops
.family
);
2066 module_init(ipx_init
);
2067 module_exit(ipx_proto_finito
);
2068 MODULE_LICENSE("GPL");
2069 MODULE_ALIAS_NETPROTO(PF_IPX
);