Subversion Repositories or1k_old

/*
 *	Implements an IPX socket layer (badly - but I'm working on it).
 *
 *	This code is derived from work by
 *		Ross Biro	: 	Writing the original IP stack
 *		Fred Van Kempen :	Tidying up the TCP/IP
 *
 *	Many thanks go to Keith Baker, Institute For Industrial Information
 *	Technology Ltd, Swansea University for allowing me to work on this
 *	in my own time even though it was in some ways related to commercial
 *	work I am currently employed to do there.
 *
 *	All the material in this file is subject to the Gnu license version 2.
 *	Neither Alan Cox nor the Swansea University Computer Society admit liability
 *	nor provide warranty for any of this software. This material is provided 
 *	as is and at no charge.		
 *
 *	Revision 0.21:	Uses the new generic socket option code.
 *	Revision 0.22:	Gcc clean ups and drop out device registration. Use the
 *			new multi-protocol edition of hard_header 
 *	Revision 0.23:  IPX /proc by Mark Evans.
 *     			Adding a route will overwrite any existing route to the same
 *			network.
 *	Revision 0.24:	Supports new /proc with no 4K limit
 *	Revision 0.25:	Add ephemeral sockets, passive local network 
 *			identification, support for local net 0 and
 *			multiple datalinks <Greg Page>
 *	Revision 0.26:  Device drop kills IPX routes via it. (needed for modules)
 *	Revision 0.27:  Autobind <Mark Evans>
 *	Revision 0.28:  Small fix for multiple local networks <Thomas Winder>
 *	Revision 0.29:  Assorted major errors removed <Mark Evans>
 *			Small correction to promisc mode error fix <Alan Cox>
 *			Asynchronous I/O support.
 *			Changed to use notifiers and the newer packet_type stuff.
 *			Assorted major fixes <Alejandro Liu>
 *	Revision 0.30:	Moved to net/ipx/...	<Alan Cox>
 *			Don't set address length on recvfrom that errors.
 *			Incorrect verify_area.
 *	Revision 0.31:	New sk_buffs. This still needs a lot of testing. <Alan Cox>
 *	Revision 0.32:  Using sock_alloc_send_skb, firewall hooks. <Alan Cox>
 *			Supports sendmsg/recvmsg
 *	Revision 0.33:	Internal network support, routing changes, uses a
 *			protocol private area for ipx data.
 *	Revision 0.34:	Module support. <Jim Freeman>
 *	Revision 0.35:  Checksum support. <Neil Turton>, hooked in by <Alan Cox>
 *			Handles WIN95 discovery packets <Volker Lendecke>
 *
 *	Protect the module by a MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT
 *	pair. Also, now usage count is managed this way
 *	-Count one if the auto_interface mode is on
 *      -Count one per configured interface
 *
 *	Jacques Gelinas (jacques@solucorp.qc.ca)
 *
 *
 * 	Portions Copyright (c) 1995 Caldera, Inc. <greg@caldera.com>
 *	Neither Greg Page nor Caldera, Inc. admit liability nor provide 
 *	warranty for any of this software. This material is provided 
 *	"AS-IS" and at no charge.		
 */
 
#include <linux/module.h>
 
#include <linux/config.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/in.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/netdevice.h>
#include <net/ipx.h>
#include <linux/inet.h>
#include <linux/route.h>
#include <net/sock.h>
#include <asm/segment.h>
#include <asm/system.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/termios.h>	/* For TIOCOUTQ/INQ */
#include <linux/interrupt.h>
#include <net/p8022.h>
#include <net/p8022tr.h>
#include <net/psnap.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/firewall.h>
 
#ifdef MODULE
static void ipx_proto_finito(void);
#endif /* def MODULE */
 
/* Configuration Variables */
static unsigned char	ipxcfg_max_hops = 16;
static char		ipxcfg_auto_select_primary = 0;
static char		ipxcfg_auto_create_interfaces = 0;
 
/* Global Variables */
static struct datalink_proto	*p8022_datalink = NULL;
static struct datalink_proto	*p8022tr_datalink = NULL;
static struct datalink_proto	*pEII_datalink = NULL;
static struct datalink_proto	*p8023_datalink = NULL;
static struct datalink_proto	*pSNAP_datalink = NULL;
 
static ipx_route 	*ipx_routes = NULL;
static ipx_interface	*ipx_interfaces = NULL;
static ipx_interface	*ipx_primary_net = NULL;
static ipx_interface	*ipx_internal_net = NULL;
 
static int
ipxcfg_set_auto_create(char val)
{
	if (ipxcfg_auto_create_interfaces != val){
		if (val){
			MOD_INC_USE_COUNT;
		}else{
			MOD_DEC_USE_COUNT;
		}
		ipxcfg_auto_create_interfaces = val;
	}
	return 0;
}
 
static int
ipxcfg_set_auto_select(char val)
{
	ipxcfg_auto_select_primary = val;
	if (val && (ipx_primary_net == NULL))
		ipx_primary_net = ipx_interfaces;
	return 0;
}
 
static int
ipxcfg_get_config_data(ipx_config_data *arg)
{
	ipx_config_data	vals;
 
	vals.ipxcfg_auto_create_interfaces = ipxcfg_auto_create_interfaces;
	vals.ipxcfg_auto_select_primary = ipxcfg_auto_select_primary;
	memcpy_tofs(arg, &vals, sizeof(vals));
	return 0;
}
 
 
/***********************************************************************************************************************\
*															*
*						Handlers for the socket list.						*
*															*
\***********************************************************************************************************************/
 
/*
 *	Note: Sockets may not be removed _during_ an interrupt or inet_bh
 *	handler using this technique. They can be added although we do not
 *	use this facility.
 */
 
static void 
ipx_remove_socket(ipx_socket *sk)
{
	ipx_socket	*s;
	ipx_interface	*intrfc;
	unsigned long	flags;
 
	save_flags(flags);
	cli();
 
	/* Determine interface with which socket is associated */
	intrfc = sk->protinfo.af_ipx.intrfc;
	if (intrfc == NULL) {
		restore_flags(flags);
		return;
	}
 
	s=intrfc->if_sklist;
	if(s==sk) {
		intrfc->if_sklist=s->next;
		restore_flags(flags);
		return;
	} 
 
	while(s && s->next) {
		if(s->next==sk) {
			s->next=sk->next;
			restore_flags(flags);
			return;
		}
		s=s->next;
	}
	restore_flags(flags);
}
 
/*
 *	This is only called from user mode. Thus it protects itself against
 *	interrupt users but doesn't worry about being called during work.
 *	Once it is removed from the queue no interrupt or bottom half will
 *	touch it and we are (fairly 8-) ) safe.
 */
 
static void 
ipx_destroy_socket(ipx_socket *sk)
{
	struct sk_buff	*skb;
 
	ipx_remove_socket(sk);
	while((skb=skb_dequeue(&sk->receive_queue))!=NULL) {
		kfree_skb(skb,FREE_READ);
	}
 
	sk_free(sk);
	MOD_DEC_USE_COUNT;
}
 
/* The following code is used to support IPX Interfaces (IPXITF).  An
 * IPX interface is defined by a physical device and a frame type.
 */
 
static ipx_route * ipxrtr_lookup(unsigned long);
 
static void
ipxitf_clear_primary_net(void)
{
	if (ipxcfg_auto_select_primary && (ipx_interfaces != NULL))
		ipx_primary_net = ipx_interfaces;
	else
		ipx_primary_net = NULL;
}
 
static ipx_interface *
ipxitf_find_using_phys(struct device *dev, unsigned short datalink)
{
	ipx_interface	*i;
 
	for (i=ipx_interfaces; 
		i && ((i->if_dev!=dev) || (i->if_dlink_type!=datalink)); 
		i=i->if_next)
		;
	return i;
}
 
static ipx_interface *
ipxitf_find_using_net(unsigned long net)
{
	ipx_interface	*i;
 
	if (net == 0L)
		return ipx_primary_net;
 
	for (i=ipx_interfaces; i && (i->if_netnum!=net); i=i->if_next)
		;
 
	return i;
}
 
/* Sockets are bound to a particular IPX interface. */
static void
ipxitf_insert_socket(ipx_interface *intrfc, ipx_socket *sk)
{
	ipx_socket	*s;
 
	sk->protinfo.af_ipx.intrfc = intrfc;
	sk->next = NULL;
	if (intrfc->if_sklist == NULL) {
		intrfc->if_sklist = sk;
	} else {
		for (s = intrfc->if_sklist; s->next != NULL; s = s->next)
			;
		s->next = sk;
	}
}
 
static ipx_socket *
ipxitf_find_socket(ipx_interface *intrfc, unsigned short port)
{
	ipx_socket	*s;
 
	for (s=intrfc->if_sklist; 
		(s != NULL) && (s->protinfo.af_ipx.port != port); 
		s=s->next)
		;
 
	return s;
}
 
#ifdef CONFIG_IPX_INTERN
 
static ipx_socket *
ipxitf_find_internal_socket(ipx_interface *intrfc,
			    unsigned char *node, unsigned short port)
{
	ipx_socket *s = intrfc->if_sklist;
 
	while (s != NULL)
	{
		if (   (s->protinfo.af_ipx.port == port)
		    && (memcmp(node, s->protinfo.af_ipx.node, IPX_NODE_LEN) == 0))
		{
			break;
		}
		s = s->next;
	}
	return s;
}	
#endif
 
static void ipxrtr_del_routes(ipx_interface *);
 
static void
ipxitf_down(ipx_interface *intrfc)
{
	ipx_interface	*i;
	ipx_socket	*s, *t;
 
	/* Delete all routes associated with this interface */
	ipxrtr_del_routes(intrfc);
 
	/* error sockets */
	for (s = intrfc->if_sklist; s != NULL; ) {
		s->err = ENOLINK;
		s->error_report(s);
		s->protinfo.af_ipx.intrfc = NULL;
		s->protinfo.af_ipx.port = 0;
		s->zapped=1;	/* Indicates it is no longer bound */
		t = s;
		s = s->next;
		t->next = NULL;
	}
	intrfc->if_sklist = NULL;
 
	/* remove this interface from list */
	if (intrfc == ipx_interfaces) {
		ipx_interfaces = intrfc->if_next;
	} else {
		for (i = ipx_interfaces; 
			(i != NULL) && (i->if_next != intrfc);
			i = i->if_next)
			;
		if ((i != NULL) && (i->if_next == intrfc)) 
			i->if_next = intrfc->if_next;
	}
 
	/* remove this interface from *special* networks */
	if (intrfc == ipx_primary_net)
		ipxitf_clear_primary_net();
	if (intrfc == ipx_internal_net)
		ipx_internal_net = NULL;
 
	kfree_s(intrfc, sizeof(*intrfc));
	/* sockets still dangling
	 * - must be closed from user space
	 */
	MOD_DEC_USE_COUNT;
	return;
}
 
static int 
ipxitf_device_event(struct notifier_block *notifier, unsigned long event, void *ptr)
{
	struct device *dev = ptr;
	ipx_interface *i, *tmp;
 
	if(event!=NETDEV_DOWN)
		return NOTIFY_DONE;
 
	for (i = ipx_interfaces; i != NULL; ) {
 
		tmp = i->if_next;
		if (i->if_dev == dev) 
			ipxitf_down(i);
		i = tmp;
 
	}
 
	return NOTIFY_DONE;
}
 
static int ipxitf_def_skb_handler(struct sock *sock, struct sk_buff *skb)
{
	int	retval;
 
	if((retval = sock_queue_rcv_skb(sock, skb))<0) 
	{
		/*
		 * skb->sk is NULL here, so FREE_WRITE does not hurt
		 * the sending socket.
	 	 */
		kfree_skb(skb,FREE_WRITE);
	}
	return retval;
}
 
/*
 * On input skb->sk is NULL. Nobody is charged for the memory.
 */
 
#ifdef CONFIG_IPX_INTERN
static int
ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
{
	ipx_packet	*ipx = (ipx_packet *)(skb->h.raw);
	ipx_socket	*s;
 
	int is_broadcast = (memcmp(ipx->ipx_dest.node, ipx_broadcast_node,
				   IPX_NODE_LEN) == 0);
 
	s = intrfc->if_sklist;
 
	while (s != NULL)
	{
		if (   (s->protinfo.af_ipx.port == ipx->ipx_dest.sock)
		    && (   is_broadcast
			|| (memcmp(ipx->ipx_dest.node, s->protinfo.af_ipx.node,
				   IPX_NODE_LEN) == 0)))
		{
			/* We found a socket to which to send */
			struct sk_buff *skb1;
 
			if (copy != 0)
			{
				skb1 = skb_clone(skb, GFP_ATOMIC);
				if (skb1 != NULL)
				{
					skb1->arp = skb1->free = 1;
				}
				else
				{
					return -ENOMEM;
				}
			}
			else
			{
				skb1 = skb;
				copy = 1; /* skb may only be used once */
			}
			ipxitf_def_skb_handler(s, skb1);
 
			if (intrfc != ipx_internal_net)
			{
				/* on an external interface, at most
                                 * one socket can listen.
				 */
				break;
			}
		}
		s = s->next;
	}
 
	if (copy == 0)
	{
		/* skb was solely for us, and we did not make a copy,
		 * so free it. FREE_WRITE does not hurt, because
		 * skb->sk is NULL here.
		 */
		kfree_skb(skb, FREE_WRITE);
	}
	return 0;
}
 
#else
 
static int
ipxitf_demux_socket(ipx_interface *intrfc, struct sk_buff *skb, int copy) 
{
	ipx_packet	*ipx = (ipx_packet *)(skb->h.raw);
	ipx_socket	*sock1 = NULL, *sock2 = NULL;
	struct sk_buff	*skb1 = NULL, *skb2 = NULL;
 
	if (intrfc == ipx_primary_net
	  && ntohs(ipx->ipx_dest.sock) == 0x451) 
	{
	  /* 
	   * The packet's target is a NCP connection handler. We want to
	   * hand it to the correct socket directly within the kernel,
	   * so that the mars_nwe packet distribution process
	   * does not have to do it. Here we only care about NCP and
	   * BURST packets.
	   * You might call this a hack, but believe me, you do not
	   * want a complete NCP layer in the kernel, and this is
	   * VERY fast as well.
	   */
	  int connection = 0;
 
	  if (    *((char*)(ipx+1))   == 0x22
	      &&  *((char*)(ipx+1)+1) == 0x22) 
	  {
	  	/*
		 * The packet is a NCP request
		 */
		 connection = ( ((int) *((char*)(ipx+1)+5)) << 8 )
		 	       | (int) *((char*)(ipx+1)+3);
	  } 
	  else if (    *((char*)(ipx+1))   == 0x77
		   &&  *((char*)(ipx+1)+1) == 0x77) 
	  {
		/*
		 * The packet is a BURST packet
		 */
		 connection = ( ((int) *((char*)(ipx+1)+9)) << 8 )
		 	       | (int) *((char*)(ipx+1)+8);
	  }
 
          if (connection) 
	  {
	    /*
	     * Now we have to look for a special NCP connection handling
	     * socket. Only these sockets have ipx_ncp_conn != 0, set
	     * by SIOCIPXNCPCONN.
	     */
            for (sock1=intrfc->if_sklist;
		(sock1 != NULL) &&
		(sock1->protinfo.af_ipx.ipx_ncp_conn != connection);
		sock1=sock1->next);;
          }
        }
        if (sock1 == NULL) 
	{
		/* No special socket found, forward the packet the
		 * normal way.
		 */
		sock1 = ipxitf_find_socket(intrfc, ipx->ipx_dest.sock);
	}
 
	/*
	 *	We need to check if there is a primary net and if
	 *	this is addressed to one of the *SPECIAL* sockets because
	 *	these need to be propagated to the primary net.
	 *	The *SPECIAL* socket list contains: 0x452(SAP), 0x453(RIP) and
	 *	0x456(Diagnostic).
	 */
 
	if (ipx_primary_net && (intrfc != ipx_primary_net)) 
	{
		switch (ntohs(ipx->ipx_dest.sock)) 
		{
			case 0x452:
			case 0x453:
			case 0x456:
				/*
				 *	The appropriate thing to do here is to
				 * 	dup the packet and route to the primary net
				 *	interface via ipxitf_send; however, we'll cheat
				 *	and just demux it here.
				 */
				sock2 = ipxitf_find_socket(ipx_primary_net, 
					ipx->ipx_dest.sock);
				break;
			default:
				break;
		}
	}
 
	/* 
	 *	if there is nothing to do, return. The kfree will
	 *	cancel any charging.
	 */
 
	if (sock1 == NULL && sock2 == NULL) 
	{
		if (!copy) 
			kfree_skb(skb,FREE_WRITE);
		return 0;
	}
 
	/*
	 * This next segment of code is a little awkward, but it sets it up
	 * so that the appropriate number of copies of the SKB are made and 
	 * that skb1 and skb2 point to it (them) so that it (they) can be 
	 * demuxed to sock1 and/or sock2.  If we are unable to make enough
	 * copies, we do as much as is possible.
	 */
 
	if (copy) 
	{
		skb1 = skb_clone(skb, GFP_ATOMIC);
		if (skb1 != NULL) 
			skb1->arp = skb1->free = 1;
	} 
	else 
	{
		skb1 = skb;
	}
 
	if (skb1 == NULL) 
		return -ENOMEM; 
 
	/*
	 *	Do we need 2 SKBs? 
	 */
 
	if (sock1 && sock2) 
	{
		skb2 = skb_clone(skb1, GFP_ATOMIC);
		if (skb2 != NULL) 
			skb2->arp = skb2->free = 1;
	}
	else 
		skb2 = skb1;
 
	if (sock1)
		(void) ipxitf_def_skb_handler(sock1, skb1);
 
	if (skb2 == NULL) 
		return -ENOMEM;
 
	if (sock2)
		(void) ipxitf_def_skb_handler(sock2, skb2);
 
	return 0;
}
#endif
 
static struct sk_buff *
ipxitf_adjust_skbuff(ipx_interface *intrfc, struct sk_buff *skb)
{
	struct sk_buff	*skb2;
	int	in_offset = skb->h.raw - skb->head;
	int	out_offset = intrfc->if_ipx_offset;
	int	len;
 
	/* Hopefully, most cases */
	if (in_offset >= out_offset) {
		skb->arp = skb->free = 1;
		return skb;
	}
 
	/* Need new SKB */
	len = skb->len + out_offset;
	skb2 = alloc_skb(len, GFP_ATOMIC);
	if (skb2 != NULL) {
		skb_reserve(skb2,out_offset);
		skb2->h.raw=skb_put(skb2,skb->len);
		skb2->free=1;
		skb2->arp=1;
		memcpy(skb2->h.raw, skb->h.raw, skb->len);
	}
	kfree_skb(skb, FREE_WRITE);
	return skb2;
}
 
static int ipxitf_send(ipx_interface *intrfc, struct sk_buff *skb, char *node)
{
	ipx_packet	*ipx = (ipx_packet *)(skb->h.raw);
	struct device	*dev = intrfc->if_dev;
	struct datalink_proto	*dl = intrfc->if_dlink;
	char		dest_node[IPX_NODE_LEN];
	int		send_to_wire = 1;
	int		addr_len;
 
	/* 
	 *	We need to know how many skbuffs it will take to send out this
	 *	packet to avoid unnecessary copies.
	 */
 
	if ((dl == NULL) || (dev == NULL) || (dev->flags & IFF_LOOPBACK)) 
		send_to_wire = 0;	/* No non looped */
 
	/*
	 *	See if this should be demuxed to sockets on this interface 
	 *
	 *	We want to ensure the original was eaten or that we only use
	 *	up clones.
	 */
 
	if (ipx->ipx_dest.net == intrfc->if_netnum) 
	{
		/*
		 *	To our own node, loop and free the original.
		 */
		if (memcmp(intrfc->if_node, node, IPX_NODE_LEN) == 0) 
		{
			/*
			 *	Don't charge sender
			 */
			if(skb->sk)
			{
				atomic_sub(skb->truesize, &skb->sk->wmem_alloc);
				skb->sk=NULL;
			}
			/*
			 *	Will charge receiver
			 */
			return ipxitf_demux_socket(intrfc, skb, 0);
		}
		/*
		 *	Broadcast, loop and possibly keep to send on.
		 */
		if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0) 
		{
			if (!send_to_wire && skb->sk)
			{
				atomic_sub(skb->truesize, &skb->sk->wmem_alloc);
				skb->sk=NULL;
			}
			ipxitf_demux_socket(intrfc, skb, send_to_wire);
			if (!send_to_wire) 
				return 0;
		}
	}
 
	/*
	 *	If the originating net is not equal to our net; this is routed 
	 *	We are still charging the sender. Which is right - the driver
	 *	free will handle this fairly.
	 */
 
	if (ipx->ipx_source.net != intrfc->if_netnum) 
	{
		if (++(ipx->ipx_tctrl) > ipxcfg_max_hops) 
			send_to_wire = 0;
	}
 
	if (!send_to_wire) 
	{
		/*
		 *	We do a FREE_WRITE here because this indicates how
		 *	to treat the socket with which the packet is 
	 	 *	associated.  If this packet is associated with a
		 *	socket at all, it must be the originator of the 
		 *	packet.   Routed packets will have no socket associated
		 *	with them.
		 */
		kfree_skb(skb,FREE_WRITE);
		return 0;
	}
 
	/*
	 *	Determine the appropriate hardware address 
	 */
 
	addr_len = dev->addr_len;
	if (memcmp(ipx_broadcast_node, node, IPX_NODE_LEN) == 0) 
		memcpy(dest_node, dev->broadcast, addr_len);
	else
		memcpy(dest_node, &(node[IPX_NODE_LEN-addr_len]), addr_len);
 
	/*
	 *	Make any compensation for differing physical/data link size 
	 */
 
	skb = ipxitf_adjust_skbuff(intrfc, skb);
	if (skb == NULL) 
		return 0;
 
	/* set up data link and physical headers */
	skb->dev = dev;
	skb->protocol = htons(ETH_P_IPX);
	dl->datalink_header(dl, skb, dest_node);
#if 0
	/* 
	 *	Now log the packet just before transmission 
	 */
 
	dump_pkt("IPX snd:", (ipx_packet *)skb->h.raw);
	dump_data("ETH hdr:", skb->data, skb->h.raw - skb->data);
#endif
 
	/*
	 *	Send it out 
	 */
 
	dev_queue_xmit(skb, dev, SOPRI_NORMAL);
	return 0;
}
 
static int ipxrtr_add_route(unsigned long, ipx_interface *, unsigned char *);
 
static int ipxitf_add_local_route(ipx_interface *intrfc)
{
	return ipxrtr_add_route(intrfc->if_netnum, intrfc, NULL);
}
 
static const char * ipx_frame_name(unsigned short);
static const char * ipx_device_name(ipx_interface *);
static int ipxrtr_route_skb(struct sk_buff *);
 
static int ipxitf_rcv(ipx_interface *intrfc, struct sk_buff *skb)
{
	ipx_packet	*ipx = (ipx_packet *) (skb->h.raw);
	ipx_interface	*i;
 
#ifdef CONFIG_FIREWALL	
	/*
	 *	We firewall first, ask questions later.
	 */
 
	if (call_in_firewall(PF_IPX, skb->dev, ipx, NULL)!=FW_ACCEPT)
	{
		kfree_skb(skb, FREE_READ);
		return 0;
	}
 
#endif	
 
	/* See if we should update our network number */
	if ((intrfc->if_netnum == 0L) && 
		(ipx->ipx_source.net == ipx->ipx_dest.net) &&
		(ipx->ipx_source.net != 0L)) 
	{
		/* NB: NetWare servers lie about their hop count so we
		 * dropped the test based on it.  This is the best way
		 * to determine this is a 0 hop count packet.
		 */
		if ((i=ipxitf_find_using_net(ipx->ipx_source.net))==NULL) 
		{
			intrfc->if_netnum = ipx->ipx_source.net;
			(void) ipxitf_add_local_route(intrfc);
		} 
		else 
		{
			printk(KERN_WARNING "IPX: Network number collision %lx\n        %s %s and %s %s\n",
				htonl(ipx->ipx_source.net), 
				ipx_device_name(i),
				ipx_frame_name(i->if_dlink_type),
				ipx_device_name(intrfc),
				ipx_frame_name(intrfc->if_dlink_type));
		}
	}
 
	if (ipx->ipx_dest.net == 0L)
		ipx->ipx_dest.net = intrfc->if_netnum;
	if (ipx->ipx_source.net == 0L)
		ipx->ipx_source.net = intrfc->if_netnum;
 
	if (intrfc->if_netnum != ipx->ipx_dest.net) 
	{
#ifdef CONFIG_FIREWALL	
		/*
		 *	See if we are allowed to firewall forward
		 */
		if (call_fw_firewall(PF_IPX, skb->dev, ipx, NULL)!=FW_ACCEPT)
		{
			kfree_skb(skb, FREE_READ);
			return 0;
		}
#endif		
		/* We only route point-to-point packets. */
		if (skb->pkt_type == PACKET_HOST)
			return ipxrtr_route_skb(skb);
 
		kfree_skb(skb,FREE_READ);
		return 0;
	}
 
	/* see if we should keep it */
	if ((memcmp(ipx_broadcast_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0) 
		|| (memcmp(intrfc->if_node, ipx->ipx_dest.node, IPX_NODE_LEN) == 0)) 
	{
		return ipxitf_demux_socket(intrfc, skb, 0);
	}
 
	/* we couldn't pawn it off so unload it */
	kfree_skb(skb,FREE_READ);
	return 0;
}
 
static void
ipxitf_insert(ipx_interface *intrfc)
{
	ipx_interface	*i;
 
	intrfc->if_next = NULL;
	if (ipx_interfaces == NULL) {
		ipx_interfaces = intrfc;
	} else {
		for (i = ipx_interfaces; i->if_next != NULL; i = i->if_next)
			;
		i->if_next = intrfc;
	}
 
	if (ipxcfg_auto_select_primary && (ipx_primary_net == NULL))
		ipx_primary_net = intrfc;
	MOD_INC_USE_COUNT;
	return;
}
 
static int 
ipxitf_create_internal(ipx_interface_definition *idef)
{
	ipx_interface	*intrfc;
 
	/* Only one primary network allowed */
	if (ipx_primary_net != NULL) return -EEXIST;
 
	/* Must have a valid network number */
	if (idef->ipx_network == 0L) return -EADDRNOTAVAIL;
	if (ipxitf_find_using_net(idef->ipx_network) != NULL)
		return -EADDRINUSE;
 
	intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
	if (intrfc==NULL)
		return -EAGAIN;
	intrfc->if_dev=NULL;
	intrfc->if_netnum=idef->ipx_network;
	intrfc->if_dlink_type = 0;
	intrfc->if_dlink = NULL;
	intrfc->if_sklist = NULL;
	intrfc->if_internal = 1;
	intrfc->if_ipx_offset = 0;
	intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
	memcpy((char *)&(intrfc->if_node), idef->ipx_node, IPX_NODE_LEN);
	ipx_internal_net = intrfc;
	ipx_primary_net = intrfc;
	ipxitf_insert(intrfc);
	return ipxitf_add_local_route(intrfc);
}
 
static int
ipx_map_frame_type(unsigned char type)
{
	switch (type) {
	case IPX_FRAME_ETHERII: return htons(ETH_P_IPX);
	case IPX_FRAME_8022: return htons(ETH_P_802_2);
	case IPX_FRAME_TR_8022: return htons(ETH_P_TR_802_2);
	case IPX_FRAME_SNAP: return htons(ETH_P_SNAP);
	case IPX_FRAME_8023: return htons(ETH_P_802_3);
	}
	return 0;
}
 
static int 
ipxitf_create(ipx_interface_definition *idef)
{
	struct device	*dev;
	unsigned short	dlink_type = 0;
	struct datalink_proto	*datalink = NULL;
	ipx_interface	*intrfc;
 
	if (idef->ipx_special == IPX_INTERNAL) 
		return ipxitf_create_internal(idef);
 
	if ((idef->ipx_special == IPX_PRIMARY) && (ipx_primary_net != NULL))
		return -EEXIST;
 
	if ((idef->ipx_network != 0L) &&
		(ipxitf_find_using_net(idef->ipx_network) != NULL))
		return -EADDRINUSE;
 
	switch (idef->ipx_dlink_type) {
	case IPX_FRAME_ETHERII: 
		dlink_type = htons(ETH_P_IPX);
		datalink = pEII_datalink;
		break;
	case IPX_FRAME_TR_8022:
		dlink_type = htons(ETH_P_TR_802_2);
		datalink = p8022tr_datalink;
		break;
	case IPX_FRAME_8022:
		dlink_type = htons(ETH_P_802_2);
		datalink = p8022_datalink;
		break;
	case IPX_FRAME_SNAP:
		dlink_type = htons(ETH_P_SNAP);
		datalink = pSNAP_datalink;
		break;
	case IPX_FRAME_8023:
		dlink_type = htons(ETH_P_802_3);
		datalink = p8023_datalink;
		break;
	case IPX_FRAME_NONE:
	default:
		break;
	}
 
	if (datalink == NULL) 
		return -EPROTONOSUPPORT;
 
	dev=dev_get(idef->ipx_device);
	if (dev==NULL) 
		return -ENODEV;
 
	if (!(dev->flags & IFF_UP))
		return -ENETDOWN;
 
	/* Check addresses are suitable */
	if(dev->addr_len>IPX_NODE_LEN)
		return -EINVAL;
 
	if ((intrfc = ipxitf_find_using_phys(dev, dlink_type)) == NULL) 
	{
		/* Ok now create */
		intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
		if (intrfc==NULL)
			return -EAGAIN;
		intrfc->if_dev=dev;
		intrfc->if_netnum=idef->ipx_network;
		intrfc->if_dlink_type = dlink_type;
		intrfc->if_dlink = datalink;
		intrfc->if_sklist = NULL;
		intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
		/* Setup primary if necessary */
		if ((idef->ipx_special == IPX_PRIMARY)) 
			ipx_primary_net = intrfc;
		intrfc->if_internal = 0;
		intrfc->if_ipx_offset = dev->hard_header_len + datalink->header_length;
		if(memcmp(idef->ipx_node, "\000\000\000\000\000\000", IPX_NODE_LEN)==0)
		{
			memset(intrfc->if_node, 0, IPX_NODE_LEN);
			memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
				dev->dev_addr, dev->addr_len);
		}
		else
			memcpy(intrfc->if_node, idef->ipx_node, IPX_NODE_LEN);
		ipxitf_insert(intrfc);
	}
 
	/* If the network number is known, add a route */
	if (intrfc->if_netnum == 0L) 
		return 0;
 
	return ipxitf_add_local_route(intrfc);
}
 
static int 
ipxitf_delete(ipx_interface_definition *idef)
{
	struct device	*dev = NULL;
	unsigned short	dlink_type = 0;
	ipx_interface	*intrfc;
 
	if (idef->ipx_special == IPX_INTERNAL) {
		if (ipx_internal_net != NULL) {
			ipxitf_down(ipx_internal_net);
			return 0;
		}
		return -ENOENT;
	}
 
	dlink_type = ipx_map_frame_type(idef->ipx_dlink_type);
	if (dlink_type == 0)
		return -EPROTONOSUPPORT;
 
	dev=dev_get(idef->ipx_device);
	if(dev==NULL) return -ENODEV;
 
	intrfc = ipxitf_find_using_phys(dev, dlink_type);
	if (intrfc != NULL) {
		ipxitf_down(intrfc);
		return 0;
	}
	return -EINVAL;
}
 
static ipx_interface *
ipxitf_auto_create(struct device *dev, unsigned short dlink_type)
{
	struct datalink_proto *datalink = NULL;
	ipx_interface	*intrfc;
 
	switch (htons(dlink_type)) {
	case ETH_P_IPX: datalink = pEII_datalink; break;
	case ETH_P_802_2: datalink = p8022_datalink; break;
	case ETH_P_TR_802_2: datalink = p8022tr_datalink; break;
	case ETH_P_SNAP: datalink = pSNAP_datalink; break;
	case ETH_P_802_3: datalink = p8023_datalink; break;
	default: return NULL;
	}
 
	if (dev == NULL)
		return NULL;
 
	/* Check addresses are suitable */
	if(dev->addr_len>IPX_NODE_LEN) return NULL;
 
	intrfc=(ipx_interface *)kmalloc(sizeof(ipx_interface),GFP_ATOMIC);
	if (intrfc!=NULL) {
		intrfc->if_dev=dev;
		intrfc->if_netnum=0L;
		intrfc->if_dlink_type = dlink_type;
		intrfc->if_dlink = datalink;
		intrfc->if_sklist = NULL;
		intrfc->if_internal = 0;
		intrfc->if_sknum = IPX_MIN_EPHEMERAL_SOCKET;
		intrfc->if_ipx_offset = dev->hard_header_len + 
			datalink->header_length;
		memset(intrfc->if_node, 0, IPX_NODE_LEN);
		memcpy((char *)&(intrfc->if_node[IPX_NODE_LEN-dev->addr_len]), 
			dev->dev_addr, dev->addr_len);
		ipxitf_insert(intrfc);
	}
 
	return intrfc;
}
 
static int 
ipxitf_ioctl_real(unsigned int cmd, void *arg)
{
	int err;
	switch(cmd)
	{
		case SIOCSIFADDR:
		{
			struct ifreq ifr;
			struct sockaddr_ipx *sipx;
			ipx_interface_definition f;
			err=verify_area(VERIFY_READ,arg,sizeof(ifr));
			if(err)
				return err;
			memcpy_fromfs(&ifr,arg,sizeof(ifr));
			sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
			if(sipx->sipx_family!=AF_IPX)
				return -EINVAL;
			f.ipx_network=sipx->sipx_network;
			memcpy(f.ipx_device, ifr.ifr_name, sizeof(f.ipx_device));
			memcpy(f.ipx_node, sipx->sipx_node, IPX_NODE_LEN);
			f.ipx_dlink_type=sipx->sipx_type;
			f.ipx_special=sipx->sipx_special;
			if(sipx->sipx_action==IPX_DLTITF)
				return ipxitf_delete(&f);
			else
				return ipxitf_create(&f);
		}
		case SIOCGIFADDR:
		{
			struct ifreq ifr;
			struct sockaddr_ipx *sipx;
			ipx_interface *ipxif;
			struct device *dev;
			err=verify_area(VERIFY_WRITE,arg,sizeof(ifr));
			if(err)
				return err;
			memcpy_fromfs(&ifr,arg,sizeof(ifr));
			sipx=(struct sockaddr_ipx *)&ifr.ifr_addr;
			dev=dev_get(ifr.ifr_name);
			if(!dev)
				return -ENODEV;
			ipxif=ipxitf_find_using_phys(dev, ipx_map_frame_type(sipx->sipx_type));
			if(ipxif==NULL)
				return -EADDRNOTAVAIL;
			sipx->sipx_family=AF_IPX;
			sipx->sipx_network=ipxif->if_netnum;
			memcpy(sipx->sipx_node, ipxif->if_node, sizeof(sipx->sipx_node));
			memcpy_tofs(arg,&ifr,sizeof(ifr));
			return 0;
		}
		case SIOCAIPXITFCRT:
			err=verify_area(VERIFY_READ,arg,sizeof(char));
			if(err)
				return err;
			return ipxcfg_set_auto_create(get_fs_byte(arg));
		case SIOCAIPXPRISLT:
			err=verify_area(VERIFY_READ,arg,sizeof(char));
			if(err)
				return err;
			return ipxcfg_set_auto_select(get_fs_byte(arg));
		default:
			return -EINVAL;
	}
}
 
static int 
ipxitf_ioctl(unsigned int cmd, void *arg)
{
	int ret;
	MOD_INC_USE_COUNT;
	ret = ipxitf_ioctl_real (cmd,arg);
	MOD_DEC_USE_COUNT;
	return ret;
}
/*******************************************************************************************************************\
*													            *
*	            			Routing tables for the IPX socket layer				            *
*														    *
\*******************************************************************************************************************/
 
static ipx_route *
ipxrtr_lookup(unsigned long net)
{
	ipx_route *r;
 
	for (r=ipx_routes; (r!=NULL) && (r->ir_net!=net); r=r->ir_next)
		;
 
	return r;
}
 
static int
ipxrtr_add_route(unsigned long network, ipx_interface *intrfc, unsigned char *node)
{
	ipx_route	*rt;
 
	/* Get a route structure; either existing or create */
	rt = ipxrtr_lookup(network);
	if (rt==NULL) {
		rt=(ipx_route *)kmalloc(sizeof(ipx_route),GFP_ATOMIC);
		if(rt==NULL)
			return -EAGAIN;
		rt->ir_next=ipx_routes;
		ipx_routes=rt;
	}
	else if (intrfc == ipx_internal_net)
		return(-EEXIST);
 
	rt->ir_net = network;
	rt->ir_intrfc = intrfc;
	if (node == NULL) {
		memset(rt->ir_router_node, '\0', IPX_NODE_LEN);
		rt->ir_routed = 0;
	} else {
		memcpy(rt->ir_router_node, node, IPX_NODE_LEN);
		rt->ir_routed=1;
	}
	return 0;
}
 
static void
ipxrtr_del_routes(ipx_interface *intrfc)
{
	ipx_route	**r, *tmp;
 
	for (r = &ipx_routes; (tmp = *r) != NULL; ) {
		if (tmp->ir_intrfc == intrfc) {
			*r = tmp->ir_next;
			kfree_s(tmp, sizeof(ipx_route));
		} else {
			r = &(tmp->ir_next);
		}
	}
}
 
static int 
ipxrtr_create(ipx_route_definition *rd)
{
	ipx_interface *intrfc;
 
	/* Find the appropriate interface */
	intrfc = ipxitf_find_using_net(rd->ipx_router_network);
	if (intrfc == NULL)
		return -ENETUNREACH;
 
	return ipxrtr_add_route(rd->ipx_network, intrfc, rd->ipx_router_node);
}
 
 
static int 
ipxrtr_delete(long net)
{
	ipx_route	**r;
	ipx_route	*tmp;
 
	for (r = &ipx_routes; (tmp = *r) != NULL; ) {
		if (tmp->ir_net == net) {
			if (!(tmp->ir_routed)) {
				/* Directly connected; can't lose route */
				return -EPERM;
			}
			*r = tmp->ir_next;
			kfree_s(tmp, sizeof(ipx_route));
			return 0;
		} 
		r = &(tmp->ir_next);
	}
 
	return -ENOENT;
}
 
/*
 *	Checksum routine for IPX
 */
 
/* Note: We assume ipx_tctrl==0 and htons(length)==ipx_pktsize */
 
static __u16 ipx_set_checksum(ipx_packet *packet,int length) 
{
	/* 
	 *	NOTE: sum is a net byte order quantity, which optimizes the 
	 *	loop. This only works on big and little endian machines. (I
	 *	don't know of a machine that isn't.)
	 */
 
	__u32 sum=0;
 
	/*
	 *	Pointer to second word - We skip the checksum field
	 */
 
	__u16 *p=(__u16 *)&packet->ipx_pktsize;
 
	/*
	 *	Number of complete words 
	 */
 
	__u32 i=length>>1;
	char    hops = packet->ipx_tctrl;
 
	packet->ipx_tctrl = 0;     /* hop count excluded from checksum calc */
 
	/*
	 *	Loop through all complete words except the checksum field 
	 */
 
	while(--i)
		sum+=*p++;
 
	/*
	 *	Add on the last part word if it exists 
	 */
 
	if(packet->ipx_pktsize&htons(1))
		sum+=ntohs(0xff00)&*p;
 
	packet->ipx_tctrl = hops;
	/*
	 *	Do final fixup 
	 */
 
	sum=(sum&0xffff)+(sum>>16);
 
	/*
	 *	It's a pity there's no concept of carry in C 
	 */
 
	if(sum>=0x10000)
		sum++;
 
	return ~sum;
};
 
 
/*
 *	Route an outgoing frame from a socket.
 */
 
static int ipxrtr_route_packet(ipx_socket *sk, struct sockaddr_ipx *usipx, struct iovec *iov, int len, int noblock)
{
	struct sk_buff *skb;
	ipx_interface *intrfc;
	ipx_packet *ipx;
	int size;
	int ipx_offset;
	ipx_route *rt = NULL;
	int err;
 
	/* Find the appropriate interface on which to send packet */
	if ((usipx->sipx_network == 0L) && (ipx_primary_net != NULL)) 
	{
		usipx->sipx_network = ipx_primary_net->if_netnum;
		intrfc = ipx_primary_net;
	} 
	else 
	{
		rt = ipxrtr_lookup(usipx->sipx_network);
		if (rt==NULL) {
			return -ENETUNREACH;
		}
		intrfc = rt->ir_intrfc;
	}
 
	ipx_offset = intrfc->if_ipx_offset;
	size=sizeof(ipx_packet)+len;
	size += ipx_offset;
 
	skb=sock_alloc_send_skb(sk, size, 0, noblock, &err);
	if(skb==NULL)
		return err;
 
	skb_reserve(skb,ipx_offset);
	skb->free=1;
	skb->arp=1;
	skb->sk=sk;
 
	/* Fill in IPX header */
	ipx=(ipx_packet *)skb_put(skb,sizeof(ipx_packet));
	ipx->ipx_pktsize=htons(len+sizeof(ipx_packet));
	ipx->ipx_tctrl=0;
	ipx->ipx_type=usipx->sipx_type;
	skb->h.raw = (unsigned char *)ipx;
 
	ipx->ipx_source.net = sk->protinfo.af_ipx.intrfc->if_netnum;
#ifdef CONFIG_IPX_INTERN
	memcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
#else
	if ((err = ntohs(sk->protinfo.af_ipx.port)) == 0x453 || err == 0x452)  
	{
		/* RIP/SAP special handling for mars_nwe */
		ipx->ipx_source.net = intrfc->if_netnum;
		memcpy(ipx->ipx_source.node, intrfc->if_node, IPX_NODE_LEN);
	}
	else
	{
		ipx->ipx_source.net = sk->protinfo.af_ipx.intrfc->if_netnum;
		memcpy(ipx->ipx_source.node, sk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
	}
#endif
	ipx->ipx_source.sock = sk->protinfo.af_ipx.port;
	ipx->ipx_dest.net=usipx->sipx_network;
	memcpy(ipx->ipx_dest.node,usipx->sipx_node,IPX_NODE_LEN);
	ipx->ipx_dest.sock=usipx->sipx_port;
 
	memcpy_fromiovec(skb_put(skb,len),iov,len);
 
	/*
	 *	Apply checksum. Not allowed on 802.3 links.
	 */
 
	if(sk->no_check || intrfc->if_dlink_type==IPX_FRAME_8023)
		ipx->ipx_checksum=0xFFFF;
	else
		ipx->ipx_checksum=ipx_set_checksum(ipx, len+sizeof(ipx_packet));
 
#ifdef CONFIG_FIREWALL	
	if(call_out_firewall(PF_IPX, skb->dev, ipx, NULL)!=FW_ACCEPT)
	{
		kfree_skb(skb, FREE_WRITE);
		return -EPERM;
	}
#endif
 
	return ipxitf_send(intrfc, skb, (rt && rt->ir_routed) ? 
				rt->ir_router_node : ipx->ipx_dest.node);
}
 
static int
ipxrtr_route_skb(struct sk_buff *skb)
{
	ipx_packet	*ipx = (ipx_packet *) (skb->h.raw);
	ipx_route	*r;
	ipx_interface	*i;
 
	r = ipxrtr_lookup(ipx->ipx_dest.net);
	if (r == NULL) {
		/* no known route */
		kfree_skb(skb,FREE_READ);
		return 0;
	}
	i = r->ir_intrfc;
	(void)ipxitf_send(i, skb, (r->ir_routed) ? 
			r->ir_router_node : ipx->ipx_dest.node);
	return 0;
}
 
/*
 *	We use a normal struct rtentry for route handling
 */
 
static int ipxrtr_ioctl(unsigned int cmd, void *arg)
{
	int err;
	struct rtentry rt;	/* Use these to behave like 'other' stacks */
	struct sockaddr_ipx *sg,*st;
 
	err=verify_area(VERIFY_READ,arg,sizeof(rt));
	if(err)
		return err;
 
	memcpy_fromfs(&rt,arg,sizeof(rt));
 
	sg=(struct sockaddr_ipx *)&rt.rt_gateway;
	st=(struct sockaddr_ipx *)&rt.rt_dst;
 
	if(!(rt.rt_flags&RTF_GATEWAY))
		return -EINVAL;		/* Direct routes are fixed */
	if(sg->sipx_family!=AF_IPX)
		return -EINVAL;
	if(st->sipx_family!=AF_IPX)
		return -EINVAL;
 
	switch(cmd)
	{
		case SIOCDELRT:
			return ipxrtr_delete(st->sipx_network);
		case SIOCADDRT:
		{
			struct ipx_route_definition f;
			f.ipx_network=st->sipx_network;
			f.ipx_router_network=sg->sipx_network;
			memcpy(f.ipx_router_node, sg->sipx_node, IPX_NODE_LEN);
			return ipxrtr_create(&f);
		}
		default:
			return -EINVAL;
	}
}
 
static const char *
ipx_frame_name(unsigned short frame)
{
	switch (ntohs(frame)) {
	case ETH_P_IPX: return "EtherII";
	case ETH_P_802_2: return "802.2";
	case ETH_P_SNAP: return "SNAP";
	case ETH_P_802_3: return "802.3";
	case ETH_P_TR_802_2: return "802.2TR";
	default: return "None";
	}
}
 
static const char *
ipx_device_name(ipx_interface *intrfc)
{
	return (intrfc->if_internal ? "Internal" :
		(intrfc->if_dev ? intrfc->if_dev->name : "Unknown"));
}
 
/* Called from proc fs */
static int ipx_interface_get_info(char *buffer, char **start, off_t offset,
				  int length, int dummy)
{
	ipx_interface *i;
	int len=0;
	off_t pos=0;
	off_t begin=0;
 
	/* Theory.. Keep printing in the same place until we pass offset */
 
	len += sprintf (buffer,"%-11s%-15s%-9s%-11s%s\n", "Network", 
		"Node_Address", "Primary", "Device", "Frame_Type");
	for (i = ipx_interfaces; i != NULL; i = i->if_next) {
		len += sprintf(buffer+len, "%08lX   ", ntohl(i->if_netnum));
		len += sprintf (buffer+len,"%02X%02X%02X%02X%02X%02X   ", 
				i->if_node[0], i->if_node[1], i->if_node[2],
				i->if_node[3], i->if_node[4], i->if_node[5]);
		len += sprintf(buffer+len, "%-9s", (i == ipx_primary_net) ?
			"Yes" : "No");
		len += sprintf (buffer+len, "%-11s", ipx_device_name(i));
		len += sprintf (buffer+len, "%s\n", 
			ipx_frame_name(i->if_dlink_type));
 
		/* Are we still dumping unwanted data then discard the record */
		pos=begin+len;
 
		if(pos<offset) {
			len=0;			/* Keep dumping into the buffer start */
			begin=pos;
		}
		if(pos>offset+length)		/* We have dumped enough */
			break;
	}
 
	/* The data in question runs from begin to begin+len */
	*start=buffer+(offset-begin);	/* Start of wanted data */
	len-=(offset-begin);		/* Remove unwanted header data from length */
	if(len>length)
		len=length;		/* Remove unwanted tail data from length */
 
	return len;
}
 
static int ipx_get_info(char *buffer, char **start, off_t offset,
			int length, int dummy)
{
	ipx_socket *s;
	ipx_interface *i;
	int len=0;
	off_t pos=0;
	off_t begin=0;
 
	/* Theory.. Keep printing in the same place until we pass offset */
 
#ifdef CONFIG_IPX_INTERN	
	len += sprintf (buffer,"%-28s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
#else
	len += sprintf (buffer,"%-15s%-28s%-10s%-10s%-7s%s\n", "Local_Address", 
#endif
			"Remote_Address", "Tx_Queue", "Rx_Queue", 
			"State", "Uid");
	for (i = ipx_interfaces; i != NULL; i = i->if_next) {
		for (s = i->if_sklist; s != NULL; s = s->next) {
#ifdef CONFIG_IPX_INTERN
			len += sprintf(buffer+len,
				       "%08lX:%02X%02X%02X%02X%02X%02X:%04X  ", 
				 htonl(s->protinfo.af_ipx.intrfc->if_netnum),
				       s->protinfo.af_ipx.node[0],
				       s->protinfo.af_ipx.node[1], 
				       s->protinfo.af_ipx.node[2], 
				       s->protinfo.af_ipx.node[3], 
				       s->protinfo.af_ipx.node[4], 
				       s->protinfo.af_ipx.node[5],
				       htons(s->protinfo.af_ipx.port));
#else
			len += sprintf(buffer+len,"%08lX:%04X  ", 
				       htonl(i->if_netnum),
				       htons(s->protinfo.af_ipx.port));
#endif
			if (s->state!=TCP_ESTABLISHED) {
				len += sprintf(buffer+len, "%-28s", "Not_Connected");
			} else {
				len += sprintf (buffer+len,
					"%08lX:%02X%02X%02X%02X%02X%02X:%04X  ", 
					htonl(s->protinfo.af_ipx.dest_addr.net),
					s->protinfo.af_ipx.dest_addr.node[0],
					s->protinfo.af_ipx.dest_addr.node[1], 
					s->protinfo.af_ipx.dest_addr.node[2],
					s->protinfo.af_ipx.dest_addr.node[3], 
					s->protinfo.af_ipx.dest_addr.node[4],
					s->protinfo.af_ipx.dest_addr.node[5],
					htons(s->protinfo.af_ipx.dest_addr.sock));
			}
			len += sprintf (buffer+len,"%08X  %08X  ", 
				s->wmem_alloc, s->rmem_alloc);
			len += sprintf (buffer+len,"%02X     %03d\n", 
				s->state, SOCK_INODE(s->socket)->i_uid);
 
			/* Are we still dumping unwanted data then discard the record */
			pos=begin+len;
 
			if(pos<offset)
			{
				len=0;			/* Keep dumping into the buffer start */
				begin=pos;
			}
			if(pos>offset+length)		/* We have dumped enough */
				break;
		}
	}
 
	/* The data in question runs from begin to begin+len */
	*start=buffer+(offset-begin);	/* Start of wanted data */
	len-=(offset-begin);		/* Remove unwanted header data from length */
	if(len>length)
		len=length;		/* Remove unwanted tail data from length */
 
	return len;
}
 
static int ipx_rt_get_info(char *buffer, char **start, off_t offset,
			   int length, int dummy)
{
	ipx_route *rt;
	int len=0;
	off_t pos=0;
	off_t begin=0;
 
	len += sprintf (buffer,"%-11s%-13s%s\n", 
			"Network", "Router_Net", "Router_Node");
	for (rt = ipx_routes; rt != NULL; rt = rt->ir_next)
	{
		len += sprintf (buffer+len,"%08lX   ", ntohl(rt->ir_net));
		if (rt->ir_routed) {
			len += sprintf (buffer+len,"%08lX     %02X%02X%02X%02X%02X%02X\n", 
				ntohl(rt->ir_intrfc->if_netnum), 
				rt->ir_router_node[0], rt->ir_router_node[1], 
				rt->ir_router_node[2], rt->ir_router_node[3], 
				rt->ir_router_node[4], rt->ir_router_node[5]);
		} else {
			len += sprintf (buffer+len, "%-13s%s\n",
					"Directly", "Connected");
		}
		pos=begin+len;
		if(pos<offset)
		{
			len=0;
			begin=pos;
		}
		if(pos>offset+length)
			break;
	}
	*start=buffer+(offset-begin);
	len-=(offset-begin);
	if(len>length)
		len=length;
	return len;
}
 
/*******************************************************************************************************************\
*													            *
*	      Handling for system calls applied via the various interfaces to an IPX socket object		    *
*														    *
\*******************************************************************************************************************/
 
static int ipx_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	switch(cmd)
	{
		default:
			return(-EINVAL);
	}
}
 
static int ipx_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
{
	ipx_socket *sk;
	int err,opt;
 
	sk=(ipx_socket *)sock->data;
 
	if(optval==NULL)
		return(-EINVAL);
 
	err=verify_area(VERIFY_READ,optval,sizeof(int));
	if(err)
		return err;
	opt=get_fs_long((unsigned long *)optval);
 
	switch(level)
	{
		case SOL_IPX:
			switch(optname)
			{
				case IPX_TYPE:
					sk->protinfo.af_ipx.type=opt;
					return 0;
				default:
					return -EOPNOTSUPP;
			}
			break;
 
		case SOL_SOCKET:
			return sock_setsockopt(sk,level,optname,optval,optlen);
 
		default:
			return -EOPNOTSUPP;
	}
}
 
static int ipx_getsockopt(struct socket *sock, int level, int optname,
	char *optval, int *optlen)
{
	ipx_socket *sk;
	int val=0;
	int err;
 
	sk=(ipx_socket *)sock->data;
 
	switch(level)
	{
 
		case SOL_IPX:
			switch(optname)
			{
				case IPX_TYPE:
					val=sk->protinfo.af_ipx.type;
					break;
				default:
					return -ENOPROTOOPT;
			}
			break;
 
		case SOL_SOCKET:
			return sock_getsockopt(sk,level,optname,optval,optlen);
 
		default:
			return -EOPNOTSUPP;
	}
	err=verify_area(VERIFY_WRITE,optlen,sizeof(int));
	if(err)
		return err;
	put_fs_long(sizeof(int),(unsigned long *)optlen);
	err=verify_area(VERIFY_WRITE,optval,sizeof(int));
	if (err) return err;
	put_fs_long(val,(unsigned long *)optval);
	return(0);
}
 
static int ipx_listen(struct socket *sock, int backlog)
{
	return -EOPNOTSUPP;
}
 
static void def_callback1(struct sock *sk)
{
	if(!sk->dead)
		wake_up_interruptible(sk->sleep);
}
 
static void def_callback2(struct sock *sk, int len)
{
	if(!sk->dead)
	{
		wake_up_interruptible(sk->sleep);
		sock_wake_async(sk->socket, 1);
	}
}
 
static int ipx_create(struct socket *sock, int protocol)
{
	ipx_socket *sk;
	sk=(ipx_socket *)sk_alloc(GFP_KERNEL);
	if(sk==NULL)
		return(-ENOMEM);
	switch(sock->type)
	{
		case SOCK_DGRAM:
			break;
		default:
			kfree_s((void *)sk,sizeof(*sk));
			return(-ESOCKTNOSUPPORT);
	}
	sk->rcvbuf=SK_RMEM_MAX;
	sk->sndbuf=SK_WMEM_MAX;
	sk->allocation=GFP_KERNEL;
	sk->prot=NULL;	/* So we use default free mechanisms */
	skb_queue_head_init(&sk->receive_queue);
	skb_queue_head_init(&sk->write_queue);
	sk->send_head=NULL;
	skb_queue_head_init(&sk->back_log);
	sk->state=TCP_CLOSE;
	sk->socket=sock;
	sk->type=sock->type;
	sk->mtu=IPX_MTU;
	sk->no_check = 1;		/* Checksum off by default */	
	if(sock!=NULL)
	{
		sock->data=(void *)sk;
		sk->sleep=sock->wait;
	}
 
	sk->state_change=def_callback1;
	sk->data_ready=def_callback2;
	sk->write_space=def_callback1;
	sk->error_report=def_callback1;
 
	sk->zapped=1;
	MOD_INC_USE_COUNT;
	return 0;
}
 
static int ipx_release(struct socket *sock, struct socket *peer)
{
	ipx_socket *sk=(ipx_socket *)sock->data;
	if(sk==NULL)
		return(0);
	if(!sk->dead)
		sk->state_change(sk);
	sk->dead=1;
	sock->data=NULL;
	ipx_destroy_socket(sk);
	return(0);
}
 
static int ipx_dup(struct socket *newsock,struct socket *oldsock)
{
	return(ipx_create(newsock,SOCK_DGRAM));
}
 
static unsigned short 
ipx_first_free_socketnum(ipx_interface *intrfc)
{
	unsigned short	socketNum = intrfc->if_sknum;
 
	if (socketNum < IPX_MIN_EPHEMERAL_SOCKET)
		socketNum = IPX_MIN_EPHEMERAL_SOCKET;
 
	while (ipxitf_find_socket(intrfc, ntohs(socketNum)) != NULL)
		if (socketNum > IPX_MAX_EPHEMERAL_SOCKET)
			socketNum = IPX_MIN_EPHEMERAL_SOCKET;
		else
			socketNum++;
 
	intrfc->if_sknum = socketNum;
	return	ntohs(socketNum);
}
 
static int ipx_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
{
	ipx_socket *sk;
	ipx_interface *intrfc;
	struct sockaddr_ipx *addr=(struct sockaddr_ipx *)uaddr;
 
	sk=(ipx_socket *)sock->data;
 
	if(sk->zapped==0)
		return -EIO;
 
	if(addr_len!=sizeof(struct sockaddr_ipx))
		return -EINVAL;
 
	intrfc = ipxitf_find_using_net(addr->sipx_network);
	if (intrfc == NULL)
		return -EADDRNOTAVAIL;
 
	if (addr->sipx_port == 0) {
		addr->sipx_port = ipx_first_free_socketnum(intrfc);
		if (addr->sipx_port == 0)
			return -EINVAL;
	}
 
	if(ntohs(addr->sipx_port)<IPX_MIN_EPHEMERAL_SOCKET && !suser())
		return -EPERM;	/* protect IPX system stuff like routing/sap */
 
	sk->protinfo.af_ipx.port=addr->sipx_port;
 
#ifdef CONFIG_IPX_INTERN
	if (intrfc == ipx_internal_net)
	{
		/* The source address is to be set explicitly if the
		 * socket is to be bound on the internal network. If a
		 * node number 0 was specified, the default is used.
		 */
 
		if (memcmp(addr->sipx_node, ipx_broadcast_node,
			   IPX_NODE_LEN) == 0)
		{
			return -EINVAL;
		}
		if (memcmp(addr->sipx_node, ipx_this_node, IPX_NODE_LEN) == 0)
		{
			memcpy(sk->protinfo.af_ipx.node, intrfc->if_node,
			       IPX_NODE_LEN);
		}
		else
		{
			memcpy(sk->protinfo.af_ipx.node, addr->sipx_node, IPX_NODE_LEN);
		}
		if (ipxitf_find_internal_socket(intrfc, 
			sk->protinfo.af_ipx.node, 
			sk->protinfo.af_ipx.port) != NULL)
		{
			if(sk->debug)
				printk("IPX: bind failed because port %X in"
				       " use.\n", (int)addr->sipx_port);
			return -EADDRINUSE;
		}
	}
	else
	{
		/* Source addresses are easy. It must be our
		 * network:node pair for an interface routed to IPX
		 * with the ipx routing ioctl()
		 */
 
		memcpy(sk->protinfo.af_ipx.node, intrfc->if_node, 
			IPX_NODE_LEN);
 
		if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
			if(sk->debug)
				printk("IPX: bind failed because port %X in"
				       " use.\n", (int)addr->sipx_port);
			return -EADDRINUSE;	   
		}
	}
 
#else
 
	/* Source addresses are easy. It must be our network:node pair for
	   an interface routed to IPX with the ipx routing ioctl() */
 
	if(ipxitf_find_socket(intrfc, addr->sipx_port)!=NULL) {
		if(sk->debug)
			printk("IPX: bind failed because port %X in use.\n",
				(int)addr->sipx_port);
		return -EADDRINUSE;	   
	}
 
#endif
 
	ipxitf_insert_socket(intrfc, sk);
	sk->zapped=0;
	if(sk->debug)
		printk("IPX: socket is bound.\n");
	return 0;
}
 
static int ipx_connect(struct socket *sock, struct sockaddr *uaddr,
	int addr_len, int flags)
{
	ipx_socket *sk=(ipx_socket *)sock->data;
	struct sockaddr_ipx *addr;
 
	sk->state = TCP_CLOSE;	
	sock->state = SS_UNCONNECTED;
 
	if(addr_len!=sizeof(*addr))
		return(-EINVAL);
	addr=(struct sockaddr_ipx *)uaddr;
 
	if(sk->protinfo.af_ipx.port==0)
	/* put the autobinding in */
	{
		struct sockaddr_ipx uaddr;
		int ret;
 
		uaddr.sipx_port = 0;
		uaddr.sipx_network = 0L;
#ifdef CONFIG_IPX_INTERN
		memcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc->if_node,
		       IPX_NODE_LEN);
#endif
		ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
				sizeof(struct sockaddr_ipx));
		if (ret != 0) return (ret);
	}
 
	if(ipxrtr_lookup(addr->sipx_network)==NULL)
		return -ENETUNREACH;
	sk->protinfo.af_ipx.dest_addr.net=addr->sipx_network;
	sk->protinfo.af_ipx.dest_addr.sock=addr->sipx_port;
	memcpy(sk->protinfo.af_ipx.dest_addr.node,
		addr->sipx_node,IPX_NODE_LEN);
	sk->protinfo.af_ipx.type=addr->sipx_type;
	sock->state = SS_CONNECTED;
	sk->state=TCP_ESTABLISHED;
	return 0;
}
 
static int ipx_socketpair(struct socket *sock1, struct socket *sock2)
{
	return(-EOPNOTSUPP);
}
 
static int ipx_accept(struct socket *sock, struct socket *newsock, int flags)
{
	if(newsock->data) {
		kfree_s(newsock->data,sizeof(ipx_socket));
		MOD_DEC_USE_COUNT;
	}
	return -EOPNOTSUPP;
}
 
static int ipx_getname(struct socket *sock, struct sockaddr *uaddr,
	int *uaddr_len, int peer)
{
	ipx_address *addr;
	struct sockaddr_ipx sipx;
	ipx_socket *sk;
 
	sk=(ipx_socket *)sock->data;
 
	*uaddr_len = sizeof(struct sockaddr_ipx);
 
	if(peer) {
		if(sk->state!=TCP_ESTABLISHED)
			return -ENOTCONN;
		addr=&sk->protinfo.af_ipx.dest_addr;
		sipx.sipx_network = addr->net;
		memcpy(sipx.sipx_node,addr->node,IPX_NODE_LEN);
		sipx.sipx_port = addr->sock;
	} else {
		if (sk->protinfo.af_ipx.intrfc != NULL) {
			sipx.sipx_network = sk->protinfo.af_ipx.intrfc->if_netnum;
#ifdef CONFIG_IPX_INTERN
			memcpy(sipx.sipx_node, sk->protinfo.af_ipx.node, IPX_NODE_LEN);
#else
			memcpy(sipx.sipx_node, 
				sk->protinfo.af_ipx.intrfc->if_node, IPX_NODE_LEN);
#endif
 
		} else {
			sipx.sipx_network = 0L;
			memset(sipx.sipx_node, '\0', IPX_NODE_LEN);
		}
		sipx.sipx_port = sk->protinfo.af_ipx.port;
	}
 
	sipx.sipx_family = AF_IPX;
	sipx.sipx_type = sk->protinfo.af_ipx.type;
	memcpy(uaddr,&sipx,sizeof(sipx));
	return 0;
}
 
#if 0
/*
 * User to dump IPX packets (debugging)
 */
void dump_data(char *str,unsigned char *d, int len) {
  static char h2c[] = "0123456789ABCDEF";
  int l,i;
  char *p, b[64];
  for (l=0;len > 0 && l<16;l++) {
    p = b;
    for (i=0; i < 8 ; i++, --len) {
	  if (len > 0) {
	      *(p++) = h2c[(d[i] >> 4) & 0x0f];
	      *(p++) = h2c[d[i] & 0x0f];
	  }
	  else {
	      *(p++) = ' ';
	      *(p++) = ' ';
	  }
      *(p++) = ' ';
    }
    *(p++) = '-';
    *(p++) = ' ';
	len += 8;
    for (i=0; i < 8 ; i++, --len)
		if (len > 0)
			*(p++) = ' '<= d[i] && d[i]<'\177' ? d[i] : '.';
		else
			*(p++) = ' ';
    *p = '\000';
    d += i;
    printk("%s-%04X: %s\n",str,l*8,b);
  }
}
 
void dump_addr(char *str,ipx_address *p) {
  printk("%s: %08X:%02X%02X%02X%02X%02X%02X:%04X\n",
   str,ntohl(p->net),p->node[0],p->node[1],p->node[2],
   p->node[3],p->node[4],p->node[5],ntohs(p->sock));
}
 
void dump_hdr(char *str,ipx_packet *p) {
  printk("%s: CHKSUM=%04X SIZE=%d (%04X) HOPS=%d (%02X) TYPE=%02X\n",
   str,p->ipx_checksum,ntohs(p->ipx_pktsize),ntohs(p->ipx_pktsize),
   p->ipx_tctrl,p->ipx_tctrl,p->ipx_type);
  dump_addr("  IPX-DST",&p->ipx_dest);
  dump_addr("  IPX-SRC",&p->ipx_source);
}
 
void dump_pkt(char *str,ipx_packet *p) {
  int len = ntohs(p->ipx_pktsize);
  dump_hdr(str,p);
  if (len > 30)
	  dump_data(str,(unsigned char *)p + 30, len - 30);
}
#endif
 
int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
{
	/* NULL here for pt means the packet was looped back */
	ipx_interface	*intrfc;
	ipx_packet *ipx;
 
 
	ipx=(ipx_packet *)skb->h.raw;
 
	/* Too small */
 
	if(ntohs(ipx->ipx_pktsize)<sizeof(ipx_packet)) {
		kfree_skb(skb,FREE_READ);
		return 0;
	}
 
	if(ipx->ipx_checksum!=IPX_NO_CHECKSUM) 
	{
		if(ipx_set_checksum(ipx, ntohs(ipx->ipx_pktsize))!=ipx->ipx_checksum)
		{
			kfree_skb(skb,FREE_READ);
			return 0;
		}
	}
 
	/* Determine what local ipx endpoint this is */
	intrfc = ipxitf_find_using_phys(dev, pt->type);
	if (intrfc == NULL) 
	{
		if (ipxcfg_auto_create_interfaces &&
		    ntohl(ipx->ipx_dest.net)!=0L) 
		{
			intrfc = ipxitf_auto_create(dev, pt->type);
		}
 
		if (intrfc == NULL) {
			/* Not one of ours */
			kfree_skb(skb,FREE_READ);
			return 0;
		}
	}
 
	return ipxitf_rcv(intrfc, skb);
}
 
static int ipx_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock,
	int flags)
{
	ipx_socket *sk=(ipx_socket *)sock->data;
	struct sockaddr_ipx *usipx=(struct sockaddr_ipx *)msg->msg_name;
	struct sockaddr_ipx local_sipx;
	int retval;
 
	if (sk->zapped) 
		return -EIO; /* Socket not bound */
	if(flags) 
		return -EINVAL;
 
	if(usipx) 
	{
		if(sk->protinfo.af_ipx.port == 0) 
		{
			struct sockaddr_ipx uaddr;
			int ret;
 
			uaddr.sipx_port = 0;
			uaddr.sipx_network = 0L; 
#ifdef CONFIG_IPX_INTERN
			memcpy(uaddr.sipx_node, sk->protinfo.af_ipx.intrfc
				->if_node, IPX_NODE_LEN);
#endif
			ret = ipx_bind (sock, (struct sockaddr *)&uaddr,
					sizeof(struct sockaddr_ipx));
			if (ret != 0) return ret;
		}
 
		if(msg->msg_namelen <sizeof(*usipx))
			return -EINVAL;
		if(usipx->sipx_family != AF_IPX)
			return -EINVAL;
	}
	else 
	{
		if(sk->state!=TCP_ESTABLISHED)
			return -ENOTCONN;
		usipx=&local_sipx;
		usipx->sipx_family=AF_IPX;
		usipx->sipx_type=sk->protinfo.af_ipx.type;
		usipx->sipx_port=sk->protinfo.af_ipx.dest_addr.sock;
		usipx->sipx_network=sk->protinfo.af_ipx.dest_addr.net;
		memcpy(usipx->sipx_node,sk->protinfo.af_ipx.dest_addr.node,IPX_NODE_LEN);
	}
 
	retval = ipxrtr_route_packet(sk, usipx, msg->msg_iov, len, noblock);
	if (retval < 0) 
		return retval;
 
	return len;
}
 
 
static int ipx_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock,
		 int flags, int *addr_len)
{
	ipx_socket *sk=(ipx_socket *)sock->data;
	struct sockaddr_ipx *sipx=(struct sockaddr_ipx *)msg->msg_name;
	struct ipx_packet *ipx = NULL;
	int copied = 0;
	int truesize;
	struct sk_buff *skb;
	int er;
 
	if(sk->err)
		return sock_error(sk);
 
	if (sk->zapped)
		return -EIO;
 
 
	skb=skb_recv_datagram(sk,flags,noblock,&er);
	if(skb==NULL)
		return er;
 
	if(addr_len)
		*addr_len=sizeof(*sipx);
 
	ipx = (ipx_packet *)(skb->h.raw);
	truesize=ntohs(ipx->ipx_pktsize) - sizeof(ipx_packet);
	copied = (truesize > size) ? size : truesize;
	skb_copy_datagram_iovec(skb,sizeof(struct ipx_packet),msg->msg_iov,copied);
 
	if(sipx)
	{
		sipx->sipx_family=AF_IPX;
		sipx->sipx_port=ipx->ipx_source.sock;
		memcpy(sipx->sipx_node,ipx->ipx_source.node,IPX_NODE_LEN);
		sipx->sipx_network=ipx->ipx_source.net;
		sipx->sipx_type = ipx->ipx_type;
	}
	skb_free_datagram(sk, skb);
	return(truesize);
}		
 
static int ipx_shutdown(struct socket *sk,int how)
{
	return -EOPNOTSUPP;
}
 
static int ipx_select(struct socket *sock , int sel_type, select_table *wait)
{
	ipx_socket *sk=(ipx_socket *)sock->data;
 
	return datagram_select(sk,sel_type,wait);
}
 
static int ipx_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
{
	int err;
	long amount=0;
	ipx_socket *sk=(ipx_socket *)sock->data;
 
	switch(cmd)
	{
		case TIOCOUTQ:
			err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
			if(err)
				return err;
			amount=sk->sndbuf-sk->wmem_alloc;
			if(amount<0)
				amount=0;
			put_fs_long(amount,(unsigned long *)arg);
			return 0;
		case TIOCINQ:
		{
			struct sk_buff *skb;
			/* These two are safe on a single CPU system as only user tasks fiddle here */
			if((skb=skb_peek(&sk->receive_queue))!=NULL)
				amount=skb->len-sizeof(struct ipx_packet);
			err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(unsigned long));
			if(err)
				return err;
			put_fs_long(amount,(unsigned long *)arg);
			return 0;
		}
		case SIOCADDRT:
		case SIOCDELRT:
			if(!suser())
				return -EPERM;
			return(ipxrtr_ioctl(cmd,(void *)arg));
		case SIOCSIFADDR:
		case SIOCAIPXITFCRT:
		case SIOCAIPXPRISLT:
			if(!suser())
				return -EPERM;
		case SIOCGIFADDR:
			return(ipxitf_ioctl(cmd,(void *)arg));
		case SIOCIPXCFGDATA: 
		{
			err=verify_area(VERIFY_WRITE,(void *)arg,
				sizeof(ipx_config_data));
			if(err) return err;
			return(ipxcfg_get_config_data((void *)arg));
		}
 
		case SIOCIPXNCPCONN:
                {
		  /*
		   * This socket wants to take care of the NCP connection
		   * handed to us in arg.
		   */
                  if (!suser()) return(-EPERM);
                  err = verify_area(VERIFY_READ, (void *)arg,
                                sizeof(unsigned short));
                  if (err) return err;
                  sk->protinfo.af_ipx.ipx_ncp_conn = get_fs_word(arg);
                  return 0;
                }
 
		case SIOCGSTAMP:
			if (sk)
			{
				if(sk->stamp.tv_sec==0)
					return -ENOENT;
				err=verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval));
				if(err)
					return err;
				memcpy_tofs((void *)arg,&sk->stamp,sizeof(struct timeval));
				return 0;
			}
			return -EINVAL;
		case SIOCGIFDSTADDR:
		case SIOCSIFDSTADDR:
		case SIOCGIFBRDADDR:
		case SIOCSIFBRDADDR:
		case SIOCGIFNETMASK:
		case SIOCSIFNETMASK:
			return -EINVAL;
		default:
			return(dev_ioctl(cmd,(void *) arg));
	}
	/*NOTREACHED*/
	return(0);
}
 
static struct proto_ops ipx_proto_ops = {
	AF_IPX,
 
	ipx_create,
	ipx_dup,
	ipx_release,
	ipx_bind,
	ipx_connect,
	ipx_socketpair,
	ipx_accept,
	ipx_getname,
	ipx_select,
	ipx_ioctl,
	ipx_listen,
	ipx_shutdown,
	ipx_setsockopt,
	ipx_getsockopt,
	ipx_fcntl,
	ipx_sendmsg,
	ipx_recvmsg
};
 
/* Called by protocol.c on kernel start up */
 
static struct packet_type ipx_8023_packet_type = 
 
{
	0,	/* MUTTER ntohs(ETH_P_8023),*/
	NULL,		/* All devices */
	ipx_rcv,
	NULL,
	NULL,
};
 
static struct packet_type ipx_dix_packet_type = 
{
	0,	/* MUTTER ntohs(ETH_P_IPX),*/
	NULL,		/* All devices */
	ipx_rcv,
	NULL,
	NULL,
};
 
static struct notifier_block ipx_dev_notifier={
	ipxitf_device_event,
	NULL,
	0
};
 
 
extern struct datalink_proto	*make_EII_client(void);
extern struct datalink_proto	*make_8023_client(void);
extern void	destroy_EII_client(struct datalink_proto *);
extern void	destroy_8023_client(struct datalink_proto *);
 
#ifdef CONFIG_PROC_FS
struct proc_dir_entry ipx_procinfo = {
	PROC_NET_IPX, 3, "ipx", S_IFREG | S_IRUGO,
	1, 0, 0, 0, &proc_net_inode_operations, ipx_get_info
};
 
struct proc_dir_entry ipx_if_procinfo = {
	PROC_NET_IPX_INTERFACE, 13, "ipx_interface", S_IFREG | S_IRUGO,
	1, 0, 0, 0, &proc_net_inode_operations, ipx_interface_get_info
};
 
struct proc_dir_entry ipx_rt_procinfo = {
	PROC_NET_IPX_ROUTE, 9, "ipx_route", S_IFREG | S_IRUGO,
	1, 0, 0, 0, &proc_net_inode_operations, ipx_rt_get_info
};
#endif
 
static unsigned char	ipx_8022_type = 0xE0;
static unsigned char	ipx_snap_id[5] =  { 0x0, 0x0, 0x0, 0x81, 0x37 };
 
void
ipx_proto_init(struct net_proto *pro)
{
	(void) sock_register(ipx_proto_ops.family, &ipx_proto_ops);
 
	pEII_datalink = make_EII_client();
	ipx_dix_packet_type.type=htons(ETH_P_IPX);
	dev_add_pack(&ipx_dix_packet_type);
 
	p8023_datalink = make_8023_client();
	ipx_8023_packet_type.type=htons(ETH_P_802_3);
	dev_add_pack(&ipx_8023_packet_type);
 
	if ((p8022_datalink = register_8022_client(ipx_8022_type, ipx_rcv)) == NULL)
		printk(KERN_CRIT "IPX: Unable to register with 802.2\n");
 
	if ((p8022tr_datalink = register_8022tr_client(ipx_8022_type, ipx_rcv)) == NULL)
		printk(KERN_CRIT "IPX: Unable to register with 802.2TR\n");
 
	if ((pSNAP_datalink = register_snap_client(ipx_snap_id, ipx_rcv)) == NULL)
		printk(KERN_CRIT "IPX: Unable to register with SNAP\n");
 
	register_netdevice_notifier(&ipx_dev_notifier);
#ifdef CONFIG_PROC_FS
	proc_net_register(&ipx_procinfo);
	proc_net_register(&ipx_if_procinfo);
	proc_net_register(&ipx_rt_procinfo);
#endif	
 
	printk(KERN_INFO "Swansea University Computer Society IPX 0.34 for NET3.035\n");
	printk(KERN_INFO "IPX Portions Copyright (c) 1995 Caldera, Inc.\n");
}
 
#ifdef MODULE
/* Note on MOD_{INC,DEC}_USE_COUNT:
 *
 * Use counts are incremented/decremented when
 * sockets are created/deleted.
 * 
 * Routes are always associated with an interface, and
 * allocs/frees will remain properly accounted for by
 * their associated interfaces.
 * 
 * Ergo, before the ipx module can be removed, all IPX
 * sockets be closed from user space. 
 */
 
static void
ipx_proto_finito(void)
{	ipx_interface	*ifc;
 
	while (ipx_interfaces) {
		ifc = ipx_interfaces;
		ipx_interfaces = ifc->if_next;
		ifc->if_next = NULL;
		ipxitf_down(ifc);
	}
 
#ifdef CONFIG_PROC_FS
	proc_net_unregister(PROC_NET_IPX_ROUTE);
	proc_net_unregister(PROC_NET_IPX_INTERFACE);
	proc_net_unregister(PROC_NET_IPX);
#endif	
 
	unregister_netdevice_notifier(&ipx_dev_notifier);
 
	unregister_snap_client(ipx_snap_id);
	pSNAP_datalink = NULL;
 
	unregister_8022tr_client(ipx_8022_type);
	p8022tr_datalink = NULL;
 
	unregister_8022_client(ipx_8022_type);
	p8022_datalink = NULL;
 
	dev_remove_pack(&ipx_8023_packet_type);
	destroy_8023_client(p8023_datalink);
	p8023_datalink = NULL;
 
	dev_remove_pack(&ipx_dix_packet_type);
	destroy_EII_client(pEII_datalink);
	pEII_datalink = NULL;
 
	(void) sock_unregister(ipx_proto_ops.family);
 
	return;
}
 
int init_module(void)
{
	ipx_proto_init(NULL);
	register_symtab(0);
	return 0;
}
 
void cleanup_module(void)
{
	ipx_proto_finito();
	return;
}
#endif /* def MODULE */