Merge with 2.1.56 as first part of merging back my code.

21 files changed, 955 insertions, 1009 deletions

diff --git a/net/Config.in b/net/Config.in
index d9ec19354..f5a06935a 100644
--- a/net/Config.in
+++ b/net/Config.in
@@ -31,9 +31,6 @@ if [ "$CONFIG_IPX" != "n" ]; then
   fi
 fi
 tristate 'Appletalk DDP' CONFIG_ATALK
-if [ "$CONFIG_ATALK" != "n" ]; then
-  bool 'IP-over-DDP support (EXPERIMENTAL)' CONFIG_IPDDP
-fi
 tristate 'Amateur Radio AX.25 Level 2' CONFIG_AX25
 if [ "$CONFIG_AX25" != "n" ]; then
   bool 'AX.25 DAMA Slave support' CONFIG_AX25_DAMA_SLAVE
@@ -53,6 +50,6 @@ if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
 #  if [ "$CONFIG_LLC" = "y" ]; then
 #   bool 'Netbeui (EXPERIMENTAL)' CONFIG_NETBEUI
 #  fi
-  bool 'WAN router' CONFIG_WAN_ROUTER
+  tristate 'WAN router' CONFIG_WAN_ROUTER
 fi
 endmenu
diff --git a/net/appletalk/Makefile b/net/appletalk/Makefile
index 19379a44a..4adbc858c 100644
--- a/net/appletalk/Makefile
+++ b/net/appletalk/Makefile
@@ -1,5 +1,5 @@
 #
-# Makefile for the Linux TCP/IP (INET) layer.
+# Makefile for the Linux AppleTalk layer.
 #
 # Note! Dependencies are done automagically by 'make dep', which also
 # removes any old dependencies. DON'T put your own dependencies here
@@ -8,9 +8,11 @@
 # Note 2! The CFLAGS definition is now in the main makefile...
 
 O_TARGET := appletalk.o
-O_OBJS	 := aarp.o ddp.o
+O_OBJS	 := aarp.o
 M_OBJS   := $(O_TARGET)
 
+OX_OBJS  += ddp.o
+
 ifeq ($(CONFIG_SYSCTL),y)
 O_OBJS += sysctl_net_atalk.o
 endif
diff --git a/net/appletalk/aarp.c b/net/appletalk/aarp.c
index f8a510e62..2cb6f3888 100644
--- a/net/appletalk/aarp.c
+++ b/net/appletalk/aarp.c
@@ -22,7 +22,9 @@
  *	References:
  *		Inside Appletalk (2nd Ed).
  */
- 
+
+#include <linux/config.h>
+#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE) 
 #include <asm/uaccess.h>
 #include <asm/system.h>
 #include <asm/bitops.h>
@@ -89,7 +91,6 @@ static struct timer_list aarp_timer;
 /*
  *	Delete an aarp queue
  */
-
 static void aarp_expire(struct aarp_entry *a)
 {
 	struct sk_buff *skb;
@@ -403,10 +404,9 @@ static struct aarp_entry *aarp_alloc(void)
 }
 
 /*
- *	Find an entry. We might return an expired but not yet purged entry. We
- *	don't care as it will do no harm.
+ * Find an entry. We might return an expired but not yet purged entry. We
+ * don't care as it will do no harm.
  */
- 
 static struct aarp_entry *aarp_find_entry(struct aarp_entry *list, struct device *dev, struct at_addr *sat)
 {
 	unsigned long flags;
@@ -426,7 +426,6 @@ static struct aarp_entry *aarp_find_entry(struct aarp_entry *list, struct device
 /*
  *	Send a DDP frame
  */
- 
 int aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr)
 {
 	static char ddp_eth_multicast[ETH_ALEN]={ 0x09, 0x00, 0x07, 0xFF, 0xFF, 0xFF };
@@ -620,7 +619,6 @@ int aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, vo
  *	An entry in the aarp unresolved queue has become resolved. Send
  *	all the frames queued under it.
  */
- 
 static void aarp_resolved(struct aarp_entry **list, struct aarp_entry *a, int hash)
 {
 	struct sk_buff *skb;
@@ -662,7 +660,6 @@ static void aarp_resolved(struct aarp_entry **list, struct aarp_entry *a, int ha
  *	This is called by the SNAP driver whenever we see an AARP SNAP
  *	frame. We currently only support ethernet.
  */
- 
 static int aarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
 {
 	struct elapaarp *ea=(struct elapaarp *)skb->h.raw;
@@ -833,39 +830,32 @@ __initfunc(void aarp_proto_init(void))
 
 #ifdef MODULE
 
-/* Free all the entries in an aarp list. Caller should turn off interrupts. */
-static void free_entry_list(struct aarp_entry *list)
+/*
+ * Remove the AARP entries associated with a device.
+ * Called from cleanup_module() in ddp.c.
+ */
+void aarp_device_down(struct device *dev)
 {
-	struct aarp_entry *tmp;
+	int ct = 0;
 
-	while (list != NULL)
+	for(ct = 0; ct < AARP_HASH_SIZE; ct++)
 	{
-		tmp = list->next;
-		aarp_expire(list);
-		list = tmp;
+		aarp_expire_device(&resolved[ct], dev);
+		aarp_expire_device(&unresolved[ct], dev);
 	}
+
+	return;
 }
 
-/* General module cleanup. Called from cleanup_module() in ddp.c. */
+/*
+ * General module cleanup. Called from cleanup_module() in ddp.c.
+ */
 void aarp_cleanup_module(void)
 {
-	unsigned long flags;
-	int i;
-
-	save_flags(flags);
-	cli();
-
 	del_timer(&aarp_timer);
 	unregister_netdevice_notifier(&aarp_notifier);
 	unregister_snap_client(aarp_snap_id);
-
-	for (i = 0; i < AARP_HASH_SIZE; i++)
-	{
-		free_entry_list(resolved[i]);
-		free_entry_list(unresolved[i]);
-	}
-
-	restore_flags(flags);
 }
 
 #endif  /* MODULE */
+#endif  /* CONFIG_ATALK || CONFIG_ATALK_MODULE */
diff --git a/net/appletalk/ddp.c b/net/appletalk/ddp.c
index dc659d18f..5f070e903 100644
--- a/net/appletalk/ddp.c
+++ b/net/appletalk/ddp.c
@@ -25,6 +25,10 @@
  *		Alan Cox		:	Posix bits
  *		Alan Cox/Mike Freeman	:	Possible fix to NBP problems
  *		Bradford Johnson	:	IP-over-DDP (experimental)
+ *		Jay Schulist		:	Moved IP-over-DDP to its own
+ *						driver file. (ipddp.c & ipddp.h)
+ *		Jay Schulist		:	Made work as module with 
+ *						Appletalk drivers, cleaned it.
  *
  *		This program is free software; you can redistribute it and/or
  *		modify it under the terms of the GNU General Public License
@@ -34,6 +38,7 @@
  */
 
 #include <linux/config.h>
+#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE)
 #include <linux/module.h>
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -72,35 +77,34 @@
 
 #undef APPLETALK_DEBUG
 
-
 #ifdef APPLETALK_DEBUG
 #define DPRINT(x)		print(x)
 #else
 #define DPRINT(x)
-#endif
+#endif /* APPLETALK_DEBUG */
 
 #ifdef CONFIG_SYSCTL
 extern inline void atalk_register_sysctl(void);
 extern inline void atalk_unregister_sysctl(void);
-#endif
+#endif /* CONFIG_SYSCTL */
 
 struct datalink_proto *ddp_dl, *aarp_dl;
 static struct proto_ops atalk_dgram_ops;
 
 #define min(a,b)	(((a)<(b))?(a):(b))
 
-/***********************************************************************************************************************\
-*															*
-*						Handlers for the socket list.						*
-*															*
-\***********************************************************************************************************************/
+/**************************************************************************\
+*                                                                          *
+* Handlers for the socket list.                                            *
+*                                                                          *
+\**************************************************************************/
 
-static struct sock *atalk_socket_list=NULL;
+static struct sock *atalk_socket_list = NULL;
 
 /*
- *	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.
+ * 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.
  */
 
 extern inline void atalk_remove_socket(struct sock *sk)
@@ -117,70 +121,73 @@ static struct sock *atalk_search_socket(struct sockaddr_at *to, struct atalk_ifa
 {
 	struct sock *s;
 
-	for( s = atalk_socket_list; s != NULL; s = s->next )
+	for(s = atalk_socket_list; s != NULL; s = s->next)
 	{
-		if ( to->sat_port != s->protinfo.af_at.src_port )
+		if(to->sat_port != s->protinfo.af_at.src_port)
 		{
 			continue;
 	   	}
 
-	    	if ( to->sat_addr.s_net == 0 &&
-		    to->sat_addr.s_node == ATADDR_BCAST &&
-		    s->protinfo.af_at.src_net == atif->address.s_net )
+	    	if(to->sat_addr.s_net == 0
+			&& to->sat_addr.s_node == ATADDR_BCAST
+			&& s->protinfo.af_at.src_net == atif->address.s_net)
 		{
 			break;
 	    	}
 
-	    	if ( to->sat_addr.s_net == s->protinfo.af_at.src_net &&
-		    (to->sat_addr.s_node == s->protinfo.af_at.src_node
-		     ||to->sat_addr.s_node == ATADDR_BCAST
-			||to->sat_addr.s_node == ATADDR_ANYNODE ))
+	    	if(to->sat_addr.s_net == s->protinfo.af_at.src_net
+			&& (to->sat_addr.s_node == s->protinfo.af_at.src_node
+		     	|| to->sat_addr.s_node == ATADDR_BCAST
+			|| to->sat_addr.s_node == ATADDR_ANYNODE))
 		{
 			break;
 	   	}
 
 	    	/* XXXX.0 */
 	}
-	return( s );
+
+	return (s);
 }
 
 /*
- *	Find a socket in the list.
+ * Find a socket in the list.
  */
-
 static struct sock *atalk_find_socket(struct sockaddr_at *sat)
 {
 	struct sock *s;
 
-	for ( s = atalk_socket_list; s != NULL; s = s->next )
+	for(s = atalk_socket_list; s != NULL; s = s->next)
 	{
-		if ( s->protinfo.af_at.src_net != sat->sat_addr.s_net )
+		if(s->protinfo.af_at.src_net != sat->sat_addr.s_net)
 		{
 			continue;
 		}
-		if ( s->protinfo.af_at.src_node != sat->sat_addr.s_node )
+
+		if(s->protinfo.af_at.src_node != sat->sat_addr.s_node)
 		{
 			continue;
 		}
-		if ( s->protinfo.af_at.src_port != sat->sat_port )
+
+		if(s->protinfo.af_at.src_port != sat->sat_port)
 		{
 			continue;
 		}
+
 		break;
 	}
-	return( s );
+
+	return (s);
 }
 
 extern inline void atalk_destroy_socket(struct sock *sk)
 {
-	sklist_destroy_socket(&atalk_socket_list,sk);
+	sklist_destroy_socket(&atalk_socket_list, sk);
 	MOD_DEC_USE_COUNT;
 }
 
 /*
- *	Called from proc fs
+ * Called from proc fs
  */
-
 int atalk_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
 {
 	struct sock *s;
@@ -189,76 +196,74 @@ int atalk_get_info(char *buffer, char **start, off_t offset, int length, int dum
 	off_t begin=0;
 
 	/*
-	 *	Output the appletalk data for the /proc virtual fs.
+	 * Output the appletalk data for the /proc virtual fs.
 	 */
 
-	len += sprintf (buffer,"Type local_addr  remote_addr tx_queue rx_queue st uid\n");
-	for (s = atalk_socket_list; s != NULL; s = s->next)
+	len += sprintf(buffer,"Type local_addr  remote_addr tx_queue rx_queue st uid\n");
+	for(s = atalk_socket_list; s != NULL; s = s->next)
 	{
-		len += sprintf (buffer+len,"%02X   ", s->type);
-		len += sprintf (buffer+len,"%04X:%02X:%02X  ",
+		len += sprintf(buffer+len,"%02X   ", s->type);
+		len += sprintf(buffer+len,"%04X:%02X:%02X  ",
 			ntohs(s->protinfo.af_at.src_net),
 			s->protinfo.af_at.src_node,
 			s->protinfo.af_at.src_port);
-		len += sprintf (buffer+len,"%04X:%02X:%02X  ",
+		len += sprintf(buffer+len,"%04X:%02X:%02X  ",
 			ntohs(s->protinfo.af_at.dest_net),
 			s->protinfo.af_at.dest_node,
 			s->protinfo.af_at.dest_port);
-		len += sprintf (buffer+len,"%08X:%08X ",
-				atomic_read(&s->wmem_alloc),
-				atomic_read(&s->rmem_alloc));
-		len += sprintf (buffer+len,"%02X %d\n", s->state, SOCK_INODE(s->socket)->i_uid);
+		len += sprintf(buffer+len,"%08X:%08X ",
+			atomic_read(&s->wmem_alloc),
+			atomic_read(&s->rmem_alloc));
+		len += sprintf(buffer+len,"%02X %d\n", s->state, 
+			SOCK_INODE(s->socket)->i_uid);
 
 		/* Are we still dumping unwanted data then discard the record */
-		pos=begin+len;
+		pos = begin + len;
 
-		if(pos<offset)
+		if(pos < offset)
 		{
-			len=0;			/* Keep dumping into the buffer start */
-			begin=pos;
+			len = 0;	/* Keep dumping into the buffer start */
+			begin = pos;
 		}
-		if(pos>offset+length)		/* We have dumped enough */
+		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 */
+	*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;
+	return (len);
 }
 
-/*******************************************************************************************************************\
-*													            *
-*	            			Routing tables for the Appletalk socket layer			       	    *
-*														    *
-\*******************************************************************************************************************/
-
+/**************************************************************************\
+*                                                                          *
+* Routing tables for the Appletalk socket layer.                           *
+*                                                                          *
+\**************************************************************************/
 
-static struct atalk_route *atalk_router_list=NULL;
-static struct atalk_route atrtr_default;		/* For probing devices or in a routerless network */
-static struct atalk_iface *atalk_iface_list=NULL;
+static struct atalk_route *atalk_router_list = NULL;
+static struct atalk_iface *atalk_iface_list  = NULL;
+static struct atalk_route atrtr_default; /* For probing devices or in a routerless network */
 
 /*
- *	Appletalk interface control
+ * Appletalk interface control
  */
 
 /*
- *	Drop a device. Doesn't drop any of its routes - that is the
- *	the callers problem. Called when we down the interface or
- *	delete the address.
+ * Drop a device. Doesn't drop any of its routes - that is the the callers
+ * problem. Called when we down the interface or delete the address.
  */
-
 static void atif_drop_device(struct device *dev)
 {
 	struct atalk_iface **iface = &atalk_iface_list;
 	struct atalk_iface *tmp;
 
-	while ((tmp = *iface) != NULL)
+	while((tmp = *iface) != NULL)
 	{
-		if (tmp->dev == dev)
+		if(tmp->dev == dev)
 		{
 			*iface = tmp->next;
 			kfree_s(tmp, sizeof(struct atalk_iface));
@@ -267,15 +272,19 @@ static void atif_drop_device(struct device *dev)
 		else
 			iface = &tmp->next;
 	}
+
+	MOD_DEC_USE_COUNT;
 }
 
 static struct atalk_iface *atif_add_device(struct device *dev, struct at_addr *sa)
 {
-	struct atalk_iface *iface=(struct atalk_iface *)
-					kmalloc(sizeof(*iface), GFP_KERNEL);
+	struct atalk_iface *iface = (struct atalk_iface *)
+		kmalloc(sizeof(*iface), GFP_KERNEL);
 	unsigned long flags;
+
 	if(iface==NULL)
-		return NULL;
+		return (NULL);
+
 	iface->dev=dev;
 	dev->atalk_ptr=iface;
 	iface->address= *sa;
@@ -285,13 +294,15 @@ static struct atalk_iface *atif_add_device(struct device *dev, struct at_addr *s
 	iface->next=atalk_iface_list;
 	atalk_iface_list=iface;
 	restore_flags(flags);
-	return iface;
+
+	MOD_INC_USE_COUNT;
+
+	return (iface);
 }
 
 /*
- *	Perform phase 2 AARP probing on our tentative address.
+ * Perform phase 2 AARP probing on our tentative address.
  */
-
 static int atif_probe_device(struct atalk_iface *atif)
 {
 	int ct;
@@ -310,19 +321,20 @@ static int atif_probe_device(struct atalk_iface *atif)
  *	addresses. This needs tidying up when someone does localtalk
  *	drivers
  */
+
 	if((atif->dev->type == ARPHRD_LOCALTLK || atif->dev->type == ARPHRD_PPP)
 		&& atif->dev->do_ioctl)
 	{
 		/* fake up the request and pass it down */
 		sa = (struct sockaddr_at*)&atreq.ifr_addr;
 		sa->sat_addr.s_node = probe_node;
-        	sa->sat_addr.s_net = probe_net;
-		if (!(err=atif->dev->do_ioctl(atif->dev,&atreq,SIOCSIFADDR)))
+        	sa->sat_addr.s_net  = probe_net;
+		if(!(err=atif->dev->do_ioctl(atif->dev,&atreq,SIOCSIFADDR)))
 		{
 			(void)atif->dev->do_ioctl(atif->dev,&atreq,SIOCGIFADDR);
 			atif->address.s_net=htons(sa->sat_addr.s_net);
 			atif->address.s_node=sa->sat_addr.s_node;
-			return 0;
+			return (0);
 		}
 		/*
 		 *	If it didn't like our faked request then fail:
@@ -330,190 +342,197 @@ static int atif_probe_device(struct atalk_iface *atif)
 		 *	through. That needs us to fix all the devices up
 		 *	properly. We can then also dump the localtalk test.
 		 */
-		return err;
+		return (err);
 	}
 	/*
-	 *	Offset the network we start probing with.
+	 * Offset the network we start probing with.
 	 */
 
-	if(probe_net==ATADDR_ANYNET)
+	if(probe_net == ATADDR_ANYNET)
 	{
 		if(!netrange)
-			probe_net=ntohs(atif->nets.nr_firstnet);
+			probe_net = ntohs(atif->nets.nr_firstnet);
 		else
-			probe_net=ntohs(atif->nets.nr_firstnet) + (jiffies%netrange);
+			probe_net = ntohs(atif->nets.nr_firstnet) + (jiffies%netrange);
 	}
 
 	if(probe_node == ATADDR_ANYNODE)
 		probe_node = jiffies&0xFF;
 
-
 	/*
-	 *	Scan the networks.
+	 * Scan the networks.
 	 */
 
-	for(netct=0;netct<=netrange;netct++)
+	for(netct = 0; netct <= netrange; netct++)
 	{
 		/*
-		 *	Sweep the available nodes from a given start.
+		 * Sweep the available nodes from a given start.
 		 */
 
-		atif->address.s_net=htons(probe_net);
-		for(nodect=0;nodect<256;nodect++)
+		atif->address.s_net = htons(probe_net);
+		for(nodect = 0; nodect < 256; nodect++)
 		{
-			atif->address.s_node=((nodect+probe_node)&0xFF);
-			if(atif->address.s_node>0&&atif->address.s_node<254)
+			atif->address.s_node = ((nodect+probe_node) & 0xFF);
+			if(atif->address.s_node > 0 && atif->address.s_node<254)
 			{
 				/*
-				 *	Probe a proposed address.
+				 * Probe a proposed address.
 				 */
-				for(ct=0;ct<AARP_RETRANSMIT_LIMIT;ct++)
+				for(ct = 0; ct < AARP_RETRANSMIT_LIMIT; ct++)
 				{
 					aarp_send_probe(atif->dev, &atif->address);
 					/*
-					 *	Defer 1/10th
+					 * Defer 1/10th
 					 */
 					current->timeout = jiffies + (HZ/10);
 					current->state = TASK_INTERRUPTIBLE;
 					schedule();
-					if(atif->status&ATIF_PROBE_FAIL)
+					if(atif->status & ATIF_PROBE_FAIL)
 						break;
 				}
-				if(!(atif->status&ATIF_PROBE_FAIL))
-					return 0;
+				if(!(atif->status & ATIF_PROBE_FAIL))
+					return (0);
 			}
-			atif->status&=~ATIF_PROBE_FAIL;
+			atif->status &= ~ATIF_PROBE_FAIL;
 		}
 		probe_net++;
-		if(probe_net>ntohs(atif->nets.nr_lastnet))
-			probe_net=ntohs(atif->nets.nr_firstnet);
+		if(probe_net > ntohs(atif->nets.nr_lastnet))
+			probe_net = ntohs(atif->nets.nr_firstnet);
 	}
-	return -EADDRINUSE;	/* Network is full... */
+
+	return (-EADDRINUSE);	/* Network is full... */
 }
 
 struct at_addr *atalk_find_dev_addr(struct device *dev)
 {
 	struct atalk_iface *iface=dev->atalk_ptr;
+
 	if(iface)
-		return &iface->address;
-	return NULL;
+		return (&iface->address);
+
+	return (NULL);
 }
 
 static struct at_addr *atalk_find_primary(void)
 {
 	struct atalk_iface *iface;
-	struct atalk_iface *fiface;
+	struct atalk_iface *fiface = NULL;
+
 	/*
-	 *	Return a point-to-point interface only if
-	 *	there is no non-ptp interface available.
+	 * Return a point-to-point interface only if
+	 * there is no non-ptp interface available.
 	 */
-	fiface=NULL;
-	for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
+	for(iface=atalk_iface_list; iface != NULL; iface=iface->next)
 	{
-		if(!fiface && !(iface->dev->flags&IFF_LOOPBACK))
+		if(!fiface && !(iface->dev->flags & IFF_LOOPBACK))
 			fiface=iface;
-		if(!(iface->dev->flags&(IFF_LOOPBACK|IFF_POINTOPOINT)))
-			return &iface->address;
+		if(!(iface->dev->flags & (IFF_LOOPBACK | IFF_POINTOPOINT)))
+			return (&iface->address);
 	}
-	if (fiface)
-		return &fiface->address;
-	if ( atalk_iface_list != NULL )
-		return &atalk_iface_list->address;
+
+	if(fiface)
+		return (&fiface->address);
+	if(atalk_iface_list != NULL)
+		return (&atalk_iface_list->address);
 	else
-		return NULL;
+		return (NULL);
 }
 
 /*
- *	Find a match for 'any network' - ie any of our interfaces with that
- *	node number will do just nicely.
+ * Find a match for 'any network' - ie any of our interfaces with that
+ * node number will do just nicely.
  */
-
 static struct atalk_iface *atalk_find_anynet(int node, struct device *dev)
 {
 	struct atalk_iface *iface=dev->atalk_ptr;
-	if (iface==NULL || ( iface->status & ATIF_PROBE ))
-		return NULL;
-	if ( node == ATADDR_BCAST || iface->address.s_node == node || node == ATADDR_ANYNODE)
-		return iface;
-	return NULL;
+
+	if(iface==NULL || (iface->status & ATIF_PROBE))
+		return (NULL);
+	if(node == ATADDR_BCAST || iface->address.s_node == node
+		|| node == ATADDR_ANYNODE)
+		return (iface);
+
+	return (NULL);
 }
 
 /*
- *	Find a match for a specific network:node pair
+ * Find a match for a specific network:node pair
  */
-
 static struct atalk_iface *atalk_find_interface(int net, int node)
 {
 	struct atalk_iface *iface;
-	for(iface=atalk_iface_list;iface!=NULL;iface=iface->next)
+
+	for(iface=atalk_iface_list; iface != NULL; iface=iface->next)
 	{
 		if((node==ATADDR_BCAST || node==ATADDR_ANYNODE 
 			|| iface->address.s_node==node)
 			&& iface->address.s_net==net 
-			&& !(iface->status&ATIF_PROBE))
-			return iface;
+			&& !(iface->status & ATIF_PROBE))
+			return (iface);
 	}
-	return NULL;
+
+	return (NULL);
 }
 
 
 /*
- *	Find a route for an appletalk packet. This ought to get cached in
- *	the socket (later on...). We know about host routes and the fact
- *	that a route must be direct to broadcast.
+ * Find a route for an appletalk packet. This ought to get cached in
+ * the socket (later on...). We know about host routes and the fact
+ * that a route must be direct to broadcast.
  */
-
 static struct atalk_route *atrtr_find(struct at_addr *target)
 {
 	struct atalk_route *r;
-	for(r=atalk_router_list;r!=NULL;r=r->next)
+
+	for(r=atalk_router_list; r != NULL; r=r->next)
 	{
-		if(!(r->flags&RTF_UP))
+		if(!(r->flags & RTF_UP))
 			continue;
-		if(r->target.s_net==target->s_net)
+		if(r->target.s_net == target->s_net)
 		{
-			if(!(r->flags&RTF_HOST) || r->target.s_node==target->s_node)
-				return r;
+			if(!(r->flags&RTF_HOST) 
+				|| r->target.s_node == target->s_node)
+				return (r);
 		}
 	}
+
 	if(atrtr_default.dev)
-		return &atrtr_default;
-	return NULL;
+		return (&atrtr_default);
+
+	return (NULL);
 }
 
 
 /*
- *	Given an appletalk network find the device to use. This can be
- *	a simple lookup.
+ * Given an appletalk network find the device to use. This can be
+ * a simple lookup.
  */
-
-static struct device *atrtr_get_dev(struct at_addr *sa)
+struct device *atrtr_get_dev(struct at_addr *sa)
 {
 	struct atalk_route *atr=atrtr_find(sa);
-	if(atr==NULL)
-		return NULL;
+
+	if(atr == NULL)
+		return (NULL);
 	else
-		return atr->dev;
+		return (atr->dev);
 }
 
 /*
- *	Set up a default router.
+ * Set up a default router.
  */
-
 static void atrtr_set_default(struct device *dev)
 {
-	atrtr_default.dev=dev;
-	atrtr_default.flags= RTF_UP;
-	atrtr_default.gateway.s_net=htons(0);
-	atrtr_default.gateway.s_node=0;
+	atrtr_default.dev = dev;
+	atrtr_default.flags = RTF_UP;
+	atrtr_default.gateway.s_net = htons(0);
+	atrtr_default.gateway.s_node = 0;
 }
 
 /*
- *	Add a router. Basically make sure it looks valid and stuff the
- *	entry in the list. While it uses netranges we always set them to one
- *	entry to work like netatalk.
+ * Add a router. Basically make sure it looks valid and stuff the
+ * entry in the list. While it uses netranges we always set them to one
+ * entry to work like netatalk.
  */
-
 static int atrtr_create(struct rtentry *r, struct device *devhint)
 {
 	struct sockaddr_at *ta=(struct sockaddr_at *)&r->rt_dst;
@@ -525,113 +544,113 @@ static int atrtr_create(struct rtentry *r, struct device *devhint)
 	save_flags(flags);
 
 	/*
-	 *	Fixme: Raise/Lower a routing change semaphore for these
-	 *	operations.
+	 * Fixme: Raise/Lower a routing change semaphore for these
+	 * operations.
 	 */
 
 	/*
-	 *	Validate the request
+	 * Validate the request
 	 */
-	if(ta->sat_family!=AF_APPLETALK)
-		return -EINVAL;
+	if(ta->sat_family != AF_APPLETALK)
+		return (-EINVAL);
 	if(devhint == NULL && ga->sat_family != AF_APPLETALK)
-		return -EINVAL;
+		return (-EINVAL);
 
 	/*
-	 *	Now walk the routing table and make our decisions
+	 * Now walk the routing table and make our decisions.
 	 */
-
-	for(rt=atalk_router_list;rt!=NULL;rt=rt->next)
+	for(rt=atalk_router_list; rt!=NULL; rt=rt->next)
 	{
 		if(r->rt_flags != rt->flags)
 			continue;
 
 		if(ta->sat_addr.s_net == rt->target.s_net)
 		{
-			if(!(rt->flags&RTF_HOST))
+			if(!(rt->flags & RTF_HOST))
 				break;
 			if(ta->sat_addr.s_node == rt->target.s_node)
 				break;
 		}
 	}
 
-	if ( devhint == NULL )
+	if(devhint == NULL)
 	{
-		for ( riface = NULL, iface = atalk_iface_list; iface; iface = iface->next )
+		for(riface = NULL, iface = atalk_iface_list; iface; iface = iface->next)
 		{
-			if ( riface == NULL && ntohs( ga->sat_addr.s_net ) >= ntohs( iface->nets.nr_firstnet ) &&
-				ntohs( ga->sat_addr.s_net ) <=	ntohs( iface->nets.nr_lastnet ))
+			if(riface == NULL && ntohs(ga->sat_addr.s_net) >= ntohs(iface->nets.nr_firstnet) &&
+				ntohs(ga->sat_addr.s_net) <= ntohs(iface->nets.nr_lastnet))
 			{
 				riface = iface;
 			}
-			if ( ga->sat_addr.s_net == iface->address.s_net && ga->sat_addr.s_node == iface->address.s_node )
+			if(ga->sat_addr.s_net == iface->address.s_net 
+				&& ga->sat_addr.s_node == iface->address.s_node)
 				riface = iface;
 		}
-		if ( riface == NULL )
-			return -ENETUNREACH;
+
+		if(riface == NULL)
+			return (-ENETUNREACH);
 		devhint = riface->dev;
 	}
 
-	if(rt==NULL)
+	if(rt == NULL)
 	{
-		rt=(struct atalk_route *)kmalloc(sizeof(struct atalk_route), GFP_KERNEL);
-		if(rt==NULL)
-			return -ENOBUFS;
+		rt = (struct atalk_route *)kmalloc(sizeof(struct atalk_route), GFP_KERNEL);
+		if(rt == NULL)
+			return (-ENOBUFS);
 		cli();
-		rt->next=atalk_router_list;
-		atalk_router_list=rt;
+		rt->next = atalk_router_list;
+		atalk_router_list = rt;
 	}
 
 	/*
-	 *	Fill in the entry.
+	 * Fill in the routing entry.
 	 */
-	rt->target=ta->sat_addr;
-	rt->dev=devhint;
-	rt->flags=r->rt_flags;
-	rt->gateway=ga->sat_addr;
+	rt->target  = ta->sat_addr;
+	rt->dev     = devhint;
+	rt->flags   = r->rt_flags;
+	rt->gateway = ga->sat_addr;
 
 	restore_flags(flags);
-	return 0;
-}
 
+	return (0);
+}
 
 /*
- *	Delete a route. Find it and discard it.
+ * Delete a route. Find it and discard it.
  */
-
 static int atrtr_delete( struct at_addr *addr )
 {
 	struct atalk_route **r = &atalk_router_list;
 	struct atalk_route *tmp;
 
-	while ((tmp = *r) != NULL)
+	while((tmp = *r) != NULL)
 	{
-		if (tmp->target.s_net == addr->s_net &&
-			    (!(tmp->flags&RTF_GATEWAY) ||
-			    tmp->target.s_node == addr->s_node ))
+		if(tmp->target.s_net == addr->s_net
+			&& (!(tmp->flags&RTF_GATEWAY)
+			|| tmp->target.s_node == addr->s_node))
 		{
 			*r = tmp->next;
 			kfree_s(tmp, sizeof(struct atalk_route));
-			return 0;
+			return (0);
 		}
 		r = &tmp->next;
 	}
-	return -ENOENT;
+
+	return (-ENOENT);
 }
 
 /*
- *	Called when a device is downed. Just throw away any routes
- *	via it.
+ * Called when a device is downed. Just throw away any routes
+ * via it.
  */
-
 void atrtr_device_down(struct device *dev)
 {
 	struct atalk_route **r = &atalk_router_list;
 	struct atalk_route *tmp;
 
-	while ((tmp = *r) != NULL)
+	while((tmp = *r) != NULL)
 	{
-		if (tmp->dev == dev)
+		if(tmp->dev == dev)
 		{
 			*r = tmp->next;
 			kfree_s(tmp, sizeof(struct atalk_route));
@@ -639,53 +658,51 @@ void atrtr_device_down(struct device *dev)
 		else
 			r = &tmp->next;
 	}
-	if(atrtr_default.dev==dev)
+
+	if(atrtr_default.dev == dev)
 		atrtr_set_default(NULL);
 }
 
 /*
- *	A device event has occurred. Watch for devices going down and
- *	delete our use of them (iface and route).
+ * A device event has occurred. Watch for devices going down and
+ * delete our use of them (iface and route).
  */
-
 static int ddp_device_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
-	if(event==NETDEV_DOWN)
+	if(event == NETDEV_DOWN)
 	{
 		/* Discard any use of this */
 		atrtr_device_down((struct device *)ptr);
 		atif_drop_device((struct device *)ptr);
 	}
-	return NOTIFY_DONE;
+
+	return (NOTIFY_DONE);
 }
 
 /*
- *	ioctl calls. Shouldn't even need touching.
+ * ioctl calls. Shouldn't even need touching.
  */
 
 /*
- *	Device configuration ioctl calls.
+ * Device configuration ioctl calls.
  */
-
 int atif_ioctl(int cmd, void *arg)
 {
 	struct ifreq atreq;
-	static char aarp_mcast[6]={0x09,0x00,0x00,0xFF,0xFF,0xFF};
+	static char aarp_mcast[6] = {0x09, 0x00, 0x00, 0xFF, 0xFF, 0xFF};
 	struct netrange *nr;
 	struct sockaddr_at *sa;
 	struct device *dev;
 	struct atalk_iface *atif;
-	int err;
 	int ct;
 	int limit;
 	struct rtentry rtdef;
 
-	err = copy_from_user(&atreq,arg,sizeof(atreq));
-	if (err)
-		return -EFAULT;
+	if(copy_from_user(&atreq,arg,sizeof(atreq)))
+		return (-EFAULT);
 
-	if((dev=dev_get(atreq.ifr_name))==NULL)
-		return -ENODEV;
+	if((dev = dev_get(atreq.ifr_name)) == NULL)
+		return (-ENODEV);
 
 	sa=(struct sockaddr_at*)&atreq.ifr_addr;
 	atif=atalk_find_dev(dev);
@@ -694,149 +711,154 @@ int atif_ioctl(int cmd, void *arg)
 	{
 		case SIOCSIFADDR:
 			if(!suser())
-				return -EPERM;
-			if(sa->sat_family!=AF_APPLETALK)
-				return -EINVAL;
-			if(dev->type!=ARPHRD_ETHER&&dev->type!=ARPHRD_LOOPBACK
-				&&dev->type!=ARPHRD_LOCALTLK && dev->type!=ARPHRD_PPP)
-				return -EPROTONOSUPPORT;
+				return (-EPERM);
+			if(sa->sat_family != AF_APPLETALK)
+				return (-EINVAL);
+			if(dev->type != ARPHRD_ETHER
+				&& dev->type != ARPHRD_LOOPBACK
+				&& dev->type != ARPHRD_LOCALTLK
+				&& dev->type != ARPHRD_PPP)
+				return (-EPROTONOSUPPORT);
+
 			nr=(struct netrange *)&sa->sat_zero[0];
+
 			/*
-			 *	Phase 1 is fine on localtalk but we don't
-			 *	do Ethertalk phase 1. Anyone wanting to add
-			 *	it go ahead.
+			 * Phase 1 is fine on Localtalk but we don't do
+			 * Ethertalk phase 1. Anyone wanting to add it go ahead.
 			 */
-			if(dev->type==ARPHRD_ETHER && nr->nr_phase!=2)
-				return -EPROTONOSUPPORT;
-			if(sa->sat_addr.s_node==ATADDR_BCAST || sa->sat_addr.s_node == 254)
-				return -EINVAL;
+			if(dev->type == ARPHRD_ETHER && nr->nr_phase != 2)
+				return (-EPROTONOSUPPORT);
+			if(sa->sat_addr.s_node == ATADDR_BCAST 
+				|| sa->sat_addr.s_node == 254)
+				return (-EINVAL);
 			if(atif)
 			{
 				/*
-				 *	Already setting address.
+				 * Already setting address.
 				 */
 				if(atif->status&ATIF_PROBE)
-					return -EBUSY;
+					return (-EBUSY);
 
-				atif->address.s_net=sa->sat_addr.s_net;
-				atif->address.s_node=sa->sat_addr.s_node;
+				atif->address.s_net  = sa->sat_addr.s_net;
+				atif->address.s_node = sa->sat_addr.s_node;
 				atrtr_device_down(dev);	/* Flush old routes */
 			}
 			else
 			{
 				atif=atif_add_device(dev, &sa->sat_addr);
 				if (atif == NULL)
-					return -ENOMEM;
+					return (-ENOMEM);
 			}
 			atif->nets= *nr;
 
 			/*
-			 *	Check if the chosen address is used. If so we
-			 *	error and atalkd will try another.
+			 * Check if the chosen address is used. If so we
+			 * error and atalkd will try another.
 			 */
 
-			if(!(dev->flags&IFF_LOOPBACK) && atif_probe_device(atif)<0)
+			if(!(dev->flags & IFF_LOOPBACK) && atif_probe_device(atif) < 0)
 			{
 				atif_drop_device(dev);
-				return -EADDRINUSE;
+				return (-EADDRINUSE);
 			}
 
 			/*
-			 *	Hey it worked - add the direct
-			 *	routes.
+			 * Hey it worked - add the direct routes.
 			 */
 
-			sa=(struct sockaddr_at *)&rtdef.rt_gateway;
-			sa->sat_family=AF_APPLETALK;
-			sa->sat_addr.s_net=atif->address.s_net;
-			sa->sat_addr.s_node=atif->address.s_node;
-			sa=(struct sockaddr_at *)&rtdef.rt_dst;
-			rtdef.rt_flags=RTF_UP;
-			sa->sat_family=AF_APPLETALK;
-			sa->sat_addr.s_node=ATADDR_ANYNODE;
-			if(dev->flags&IFF_LOOPBACK)
-				rtdef.rt_flags|=RTF_HOST;
+			sa = (struct sockaddr_at *)&rtdef.rt_gateway;
+			sa->sat_family = AF_APPLETALK;
+			sa->sat_addr.s_net  = atif->address.s_net;
+			sa->sat_addr.s_node = atif->address.s_node;
+			sa = (struct sockaddr_at *)&rtdef.rt_dst;
+			rtdef.rt_flags = RTF_UP;
+			sa->sat_family = AF_APPLETALK;
+			sa->sat_addr.s_node = ATADDR_ANYNODE;
+			if(dev->flags & IFF_LOOPBACK)
+				rtdef.rt_flags |= RTF_HOST;
+
 			/*
-			 *	Routerless initial state.
+			 * Routerless initial state.
 			 */
-			if(nr->nr_firstnet==htons(0) && nr->nr_lastnet==htons(0xFFFE))
+			if(nr->nr_firstnet == htons(0)
+				&& nr->nr_lastnet == htons(0xFFFE))
 			{
-				sa->sat_addr.s_net=atif->address.s_net;
+				sa->sat_addr.s_net = atif->address.s_net;
 				atrtr_create(&rtdef, dev);
 				atrtr_set_default(dev);
 			}
 			else
 			{
-				limit=ntohs(nr->nr_lastnet);
-				if(limit-ntohs(nr->nr_firstnet) > 256)
+				limit = ntohs(nr->nr_lastnet);
+				if(limit - ntohs(nr->nr_firstnet) > 256)
 				{
 					printk(KERN_WARNING "Too many routes/iface.\n");
-					return -EINVAL;
+					return (-EINVAL);
 				}
 				for(ct=ntohs(nr->nr_firstnet);ct<=limit;ct++)
 				{
-					sa->sat_addr.s_net=htons(ct);
+					sa->sat_addr.s_net = htons(ct);
 					atrtr_create(&rtdef, dev);
 				}
 			}
 			dev_mc_add(dev, aarp_mcast, 6, 1);
-			return 0;
+			return (0);
+
 		case SIOCGIFADDR:
-			if(atif==NULL)
-				return -EADDRNOTAVAIL;
+			if(atif == NULL)
+				return (-EADDRNOTAVAIL);
 			((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
 			((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr=atif->address;
 			break;
+
 		case SIOCGIFBRDADDR:
-			if(atif==NULL)
-				return -EADDRNOTAVAIL;
+			if(atif == NULL)
+				return (-EADDRNOTAVAIL);
 			((struct sockaddr_at *)(&atreq.ifr_addr))->sat_family=AF_APPLETALK;
 			((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_net=atif->address.s_net;
 			((struct sockaddr_at *)(&atreq.ifr_addr))->sat_addr.s_node=ATADDR_BCAST;
 			break;
+
 	        case SIOCATALKDIFADDR:
 			if(!suser())
-				return -EPERM;
-			if(sa->sat_family!=AF_APPLETALK)
-				return -EINVAL;
-			if(atif==NULL)
-				return -EADDRNOTAVAIL;
+				return (-EPERM);
+			if(sa->sat_family != AF_APPLETALK)
+				return (-EINVAL);
+			if(atif == NULL)
+				return (-EADDRNOTAVAIL);
 			atrtr_device_down(atif->dev);
 			atif_drop_device(atif->dev);
 			break;			
 	}
-	err = copy_to_user(arg,&atreq,sizeof(atreq));
 
-	if (err)
-	{
-		err = -EFAULT;
-	}
-	return err;
+	if(copy_to_user(arg, &atreq, sizeof(atreq)))
+		return (-EFAULT);
+
+	return (0);
 }
 
 /*
- *	Routing ioctl() calls
+ * Routing ioctl() calls
  */
-
 static int atrtr_ioctl(unsigned int cmd, void *arg)
 {
-	int err;
 	struct rtentry rt;
 
-	err = copy_from_user(&rt,arg,sizeof(rt));
-	if (err)
-		return -EFAULT;
+	if(copy_from_user(&rt, arg, sizeof(rt)))
+		return (-EFAULT);
 
 	switch(cmd)
 	{
 		case SIOCDELRT:
-			if(rt.rt_dst.sa_family!=AF_APPLETALK)
-				return -EINVAL;
-			return atrtr_delete(&((struct sockaddr_at *)&rt.rt_dst)->sat_addr);
+			if(rt.rt_dst.sa_family != AF_APPLETALK)
+				return (-EINVAL);
+			return (atrtr_delete(&((struct sockaddr_at *)&rt.rt_dst)->sat_addr));
+
 		case SIOCADDRT:
-			return atrtr_create(&rt, NULL);
+			return (atrtr_create(&rt, NULL));
+
 		default:
-			return -EINVAL;
+			return (-EINVAL);
 	}
 }
 
@@ -849,28 +871,28 @@ int atalk_if_get_info(char *buffer, char **start, off_t offset, int length, int
 	off_t pos=0;
 	off_t begin=0;
 
-	len += sprintf (buffer,"Interface	  Address   Networks   Status\n");
-	for (iface = atalk_iface_list; iface != NULL; iface = iface->next)
+	len += sprintf(buffer,"Interface	  Address   Networks   Status\n");
+	for(iface = atalk_iface_list; iface != NULL; iface = iface->next)
 	{
-		len += sprintf (buffer+len,"%-16s %04X:%02X  %04X-%04X  %d\n",
-			iface->dev->name,
-			ntohs(iface->address.s_net),iface->address.s_node,
-			ntohs(iface->nets.nr_firstnet),ntohs(iface->nets.nr_lastnet),
-			iface->status);
-		pos=begin+len;
-		if(pos<offset)
+		len += sprintf(buffer+len,"%-16s %04X:%02X  %04X-%04X  %d\n",
+			iface->dev->name, ntohs(iface->address.s_net),
+			iface->address.s_node, ntohs(iface->nets.nr_firstnet),
+			ntohs(iface->nets.nr_lastnet), iface->status);
+		pos = begin + len;
+		if(pos < offset)
 		{
-			len=0;
-			begin=pos;
+			len   = 0;
+			begin = pos;
 		}
-		if(pos>offset+length)
+		if(pos > offset + length)
 			break;
 	}
-	*start=buffer+(offset-begin);
-	len-=(offset-begin);
-	if(len>length)
-		len=length;
-	return len;
+	*start = buffer + (offset - begin);
+	len -= (offset - begin);
+	if(len > length)
+		len = length;
+
+	return (len);
 }
 
 /* Called from proc fs - just make it print the routes neatly */
@@ -882,138 +904,151 @@ int atalk_rt_get_info(char *buffer, char **start, off_t offset, int length, int
 	off_t pos=0;
 	off_t begin=0;
 
-	len += sprintf (buffer,"Target        Router  Flags Dev\n");
+	len += sprintf(buffer,"Target        Router  Flags Dev\n");
 	if(atrtr_default.dev)
 	{
-		rt=&atrtr_default;
-		len += sprintf (buffer+len,"Default     %04X:%02X  %-4d  %s\n",
+		rt = &atrtr_default;
+		len += sprintf(buffer+len,"Default     %04X:%02X  %-4d  %s\n",
 			ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
 			rt->dev->name);
 	}
-	for (rt = atalk_router_list; rt != NULL; rt = rt->next)
+
+	for(rt = atalk_router_list; rt != NULL; rt = rt->next)
 	{
-		len += sprintf (buffer+len,"%04X:%02X     %04X:%02X  %-4d  %s\n",
+		len += sprintf(buffer+len,"%04X:%02X     %04X:%02X  %-4d  %s\n",
 			ntohs(rt->target.s_net),rt->target.s_node,
 			ntohs(rt->gateway.s_net), rt->gateway.s_node, rt->flags,
 			rt->dev->name);
-		pos=begin+len;
-		if(pos<offset)
+		pos = begin + len;
+		if(pos < offset)
 		{
-			len=0;
-			begin=pos;
+			len = 0;
+			begin = pos;
 		}
-		if(pos>offset+length)
+		if(pos > offset + length)
 			break;
 	}
-	*start=buffer+(offset-begin);
-	len-=(offset-begin);
-	if(len>length)
-		len=length;
-	return len;
+
+	*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 Appletalk socket object	    *
-*														    *
-\*******************************************************************************************************************/
+/**************************************************************************\
+*                                                                          *
+* Handling for system calls applied via the various interfaces to an       *
+* Appletalk socket object.                                                 *
+*                                                                          *
+\**************************************************************************/
 
 /*
- *	Checksum: This is 'optional'. It's quite likely also a good
- *	candidate for assembler hackery 8)
+ * Checksum: This is 'optional'. It's quite likely also a good
+ * candidate for assembler hackery 8)
  */
-
 unsigned short atalk_checksum(struct ddpehdr *ddp, int len)
 {
 	unsigned long sum=0;	/* Assume unsigned long is >16 bits */
 	unsigned char *data=(unsigned char *)ddp;
 
-	len-=4;		/* skip header 4 bytes */
-	data+=4;
+	len  -= 4;		/* skip header 4 bytes */
+	data += 4;
 
 	/* This ought to be unwrapped neatly. I'll trust gcc for now */
 	while(len--)
 	{
-		sum+=*data;
-		sum<<=1;
-		if(sum&0x10000)
+		sum += *data;
+		sum <<= 1;
+		if(sum & 0x10000)
 		{
 			sum++;
-			sum&=0xFFFF;
+			sum &= 0xFFFF;
 		}
 		data++;
 	}
+
 	if(sum)
 		return htons((unsigned short)sum);
+
 	return 0xFFFF;		/* Use 0xFFFF for 0. 0 itself means none */
 }
 
 /*
- *	Create a socket. Initialise the socket, blank the addresses
- *	set the state.
+ * Create a socket. Initialise the socket, blank the addresses
+ * set the state.
  */
-
 static int atalk_create(struct socket *sock, int protocol)
 {
 	struct sock *sk;
-	sk=sk_alloc(AF_APPLETALK, GFP_KERNEL);
-	if(sk==NULL)
-		return(-ENOMEM);
+
+	sk = sk_alloc(AF_APPLETALK, GFP_KERNEL);
+	if(sk == NULL)
+		return (-ENOMEM);
+
 	switch(sock->type)
 	{
-		/* This RAW is an extension. It is trivial to do and gives you
-		   the full ELAP frame. Should be handy for CAP 8) */
+		/*
+		 * We permit SOCK_DGRAM and RAW is an extension. It is
+		 * trivial to do and gives you the full ELAP frame.
+		 * Should be handy for CAP 8) 
+		 */
 		case SOCK_RAW:
-		/* We permit DDP datagram sockets */
 		case SOCK_DGRAM:
 			sock->ops = &atalk_dgram_ops;
 			break;
+
 		default:
 			sk_free((void *)sk);
-			return(-ESOCKTNOSUPPORT);
+			return (-ESOCKTNOSUPPORT);
 	}
 
 	MOD_INC_USE_COUNT;
 
 	sock_init_data(sock,sk);
 
-	sk->destruct=NULL;
+	sk->destruct = NULL;
 	/* Checksums on by default */
-	sk->mtu=DDP_MAXSZ;
-	sk->zapped=1;
-	return(0);
+	sk->mtu = DDP_MAXSZ;
+	sk->zapped = 1;
+
+	return (0);
 }
 
 /*
- *	Free a socket. No work needed
+ * Free a socket. No work needed
  */
-
 static int atalk_release(struct socket *sock, struct socket *peer)
 {
 	struct sock *sk=sock->sk;
-	if(sk==NULL)
-		return(0);
+
+	if(sk == NULL)
+		return (0);
+
 	if(!sk->dead)
 		sk->state_change(sk);
-	sk->dead=1;
-	sock->sk=NULL;
+
+	sk->dead = 1;
+	sock->sk = NULL;
 	atalk_destroy_socket(sk);
-	return(0);
+
+	return (0);
 }
 
 /*
- *	Pick a source address if one is not given. Just return
- *	an error if not supportable.
+ * Pick a source address if one is not given. Just return
+ * an error if not supportable.
  */
-
 static int atalk_pick_port(struct sockaddr_at *sat)
 {
-	for ( sat->sat_port = ATPORT_RESERVED; sat->sat_port < ATPORT_LAST; sat->sat_port++ )
+	for(sat->sat_port = ATPORT_RESERVED; sat->sat_port < ATPORT_LAST; sat->sat_port++)
 	{
-		if ( atalk_find_socket( sat ) == NULL )
+		if(atalk_find_socket(sat) == NULL)
 			return sat->sat_port;
 	}
-	return -EBUSY;
+
+	return (-EBUSY);
 }
 
 static int atalk_autobind(struct sock *sk)
@@ -1022,381 +1057,189 @@ static int atalk_autobind(struct sock *sk)
 	struct sockaddr_at sat;
 	int n;
 
-	if ( ap == NULL || ap->s_net == htons( ATADDR_ANYNET ))
-		return -EADDRNOTAVAIL;
-	sk->protinfo.af_at.src_net = sat.sat_addr.s_net = ap->s_net;
+	if(ap == NULL || ap->s_net == htons(ATADDR_ANYNET))
+		return (-EADDRNOTAVAIL);
+
+	sk->protinfo.af_at.src_net  = sat.sat_addr.s_net  = ap->s_net;
 	sk->protinfo.af_at.src_node = sat.sat_addr.s_node = ap->s_node;
 
-	if (( n = atalk_pick_port( &sat )) < 0 )
-		return( n );
-	sk->protinfo.af_at.src_port=n;
+	if((n = atalk_pick_port(&sat)) < 0)
+		return (n);
+
+	sk->protinfo.af_at.src_port = n;
 	atalk_insert_socket(sk);
-	sk->zapped=0;
-	return 0;
+	sk->zapped = 0;
+
+	return (0);
 }
 
 /*
- *	Set the address 'our end' of the connection.
+ * Set the address 'our end' of the connection.
  */
-
 static int atalk_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 {
 	struct sock *sk;
 	struct sockaddr_at *addr=(struct sockaddr_at *)uaddr;
 
-	sk=sock->sk;
+	sk = sock->sk;
 
-	if(sk->zapped==0)
-		return(-EINVAL);
+	if(sk->zapped == 0)
+		return (-EINVAL);
 
-	if(addr_len!=sizeof(struct sockaddr_at))
-		return -EINVAL;
+	if(addr_len != sizeof(struct sockaddr_at))
+		return (-EINVAL);
 
-	if(addr->sat_family!=AF_APPLETALK)
-		return -EAFNOSUPPORT;
+	if(addr->sat_family != AF_APPLETALK)
+		return (-EAFNOSUPPORT);
 
-	if(addr->sat_addr.s_net==htons(ATADDR_ANYNET))
+	if(addr->sat_addr.s_net == htons(ATADDR_ANYNET))
 	{
 		struct at_addr *ap=atalk_find_primary();
-		if(ap==NULL)
-			return -EADDRNOTAVAIL;
-		sk->protinfo.af_at.src_net=addr->sat_addr.s_net=ap->s_net;
-		sk->protinfo.af_at.src_node=addr->sat_addr.s_node=ap->s_node;
+
+		if(ap == NULL)
+			return (-EADDRNOTAVAIL);
+
+		sk->protinfo.af_at.src_net  = addr->sat_addr.s_net = ap->s_net;
+		sk->protinfo.af_at.src_node = addr->sat_addr.s_node= ap->s_node;
 	}
 	else
 	{
-		if ( atalk_find_interface( addr->sat_addr.s_net, addr->sat_addr.s_node ) == NULL )
-			return -EADDRNOTAVAIL;
-		sk->protinfo.af_at.src_net=addr->sat_addr.s_net;
-		sk->protinfo.af_at.src_node=addr->sat_addr.s_node;
+		if(atalk_find_interface(addr->sat_addr.s_net, addr->sat_addr.s_node) == NULL)
+			return (-EADDRNOTAVAIL);
+
+		sk->protinfo.af_at.src_net  = addr->sat_addr.s_net;
+		sk->protinfo.af_at.src_node = addr->sat_addr.s_node;
 	}
 
 	if(addr->sat_port == ATADDR_ANYPORT)
 	{
 		int n = atalk_pick_port(addr);
 		if(n < 0)
-			return n;
-		sk->protinfo.af_at.src_port=addr->sat_port=n;
+			return (n);
+
+		sk->protinfo.af_at.src_port = addr->sat_port = n;
 	}
 	else
-		sk->protinfo.af_at.src_port=addr->sat_port;
+		sk->protinfo.af_at.src_port = addr->sat_port;
 
-	if(atalk_find_socket(addr)!=NULL)
-		return -EADDRINUSE;
+	if(atalk_find_socket(addr) != NULL)
+		return (-EADDRINUSE);
 
 	atalk_insert_socket(sk);
-	sk->zapped=0;
-	return(0);
+	sk->zapped = 0;
+
+	return (0);
 }
 
 /*
- *	Set the address we talk to.
+ * Set the address we talk to.
  */
-
 static int atalk_connect(struct socket *sock, struct sockaddr *uaddr,
 	int addr_len, int flags)
 {
 	struct sock *sk=sock->sk;
 	struct sockaddr_at *addr;
 
-	sk->state = TCP_CLOSE;
+	sk->state   = TCP_CLOSE;
 	sock->state = SS_UNCONNECTED;
 
-	if(addr_len!=sizeof(*addr))
-		return(-EINVAL);
-	addr=(struct sockaddr_at *)uaddr;
+	if(addr_len != sizeof(*addr))
+		return (-EINVAL);
+	addr = (struct sockaddr_at *)uaddr;
 
-	if(addr->sat_family!=AF_APPLETALK)
-		return -EAFNOSUPPORT;
-	if(addr->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
+	if(addr->sat_family != AF_APPLETALK)
+		return (-EAFNOSUPPORT);
+
+	if(addr->sat_addr.s_node == ATADDR_BCAST && !sk->broadcast)
 	{
 #if 1	
 		printk(KERN_WARNING "%s is broken and did not set SO_BROADCAST. It will break when 2.2 is released.\n",
 			current->comm);
 #else
-		return -EACCES;
+		return (-EACCES);
 #endif			
 	}
+
 	if(sk->zapped)
 	{
-		if(atalk_autobind(sk)<0)
-			return -EBUSY;
+		if(atalk_autobind(sk) < 0)
+			return (-EBUSY);
 	}
 
-	if(atrtr_get_dev(&addr->sat_addr)==NULL)
-		return -ENETUNREACH;
+	if(atrtr_get_dev(&addr->sat_addr) == NULL)
+		return (-ENETUNREACH);
+
+	sk->protinfo.af_at.dest_port = addr->sat_port;
+	sk->protinfo.af_at.dest_net  = addr->sat_addr.s_net;
+	sk->protinfo.af_at.dest_node = addr->sat_addr.s_node;
 
-	sk->protinfo.af_at.dest_port=addr->sat_port;
-	sk->protinfo.af_at.dest_net=addr->sat_addr.s_net;
-	sk->protinfo.af_at.dest_node=addr->sat_addr.s_node;
 	sock->state = SS_CONNECTED;
-	sk->state=TCP_ESTABLISHED;
-	return(0);
+	sk->state   = TCP_ESTABLISHED;
+
+	return (0);
 }
 
 /*
- *	Not relevant
+ * Not relevant
  */
-
 static int atalk_accept(struct socket *sock, struct socket *newsock, int flags)
 {
-	if(newsock->sk) {
+	if(newsock->sk)
+	{
 		sk_free(newsock->sk);
 		MOD_DEC_USE_COUNT;
 	}
-	return -EOPNOTSUPP;
+
+	return (-EOPNOTSUPP);
 }
 
 /*
- *	Find the name of an appletalk socket. Just copy the right
- *	fields into the sockaddr.
+ * Find the name of an appletalk socket. Just copy the right
+ * fields into the sockaddr.
  */
-
 static int atalk_getname(struct socket *sock, struct sockaddr *uaddr,
 	int *uaddr_len, int peer)
 {
 	struct sockaddr_at sat;
 	struct sock *sk;
 
-	sk=sock->sk;
+	sk = sock->sk;
 	if(sk->zapped)
 	{
-		if(atalk_autobind(sk)<0)
-			return -ENOBUFS;
+		if(atalk_autobind(sk) < 0)
+			return (-ENOBUFS);
 	}
 
 	*uaddr_len = sizeof(struct sockaddr_at);
 
 	if(peer)
 	{
-		if(sk->state!=TCP_ESTABLISHED)
-			return -ENOTCONN;
-		sat.sat_addr.s_net=sk->protinfo.af_at.dest_net;
-		sat.sat_addr.s_node=sk->protinfo.af_at.dest_node;
-		sat.sat_port=sk->protinfo.af_at.dest_port;
+		if(sk->state != TCP_ESTABLISHED)
+			return (-ENOTCONN);
+		sat.sat_addr.s_net  = sk->protinfo.af_at.dest_net;
+		sat.sat_addr.s_node = sk->protinfo.af_at.dest_node;
+		sat.sat_port = sk->protinfo.af_at.dest_port;
 	}
 	else
 	{
-		sat.sat_addr.s_net=sk->protinfo.af_at.src_net;
-		sat.sat_addr.s_node=sk->protinfo.af_at.src_node;
-		sat.sat_port=sk->protinfo.af_at.src_port;
+		sat.sat_addr.s_net  = sk->protinfo.af_at.src_net;
+		sat.sat_addr.s_node = sk->protinfo.af_at.src_node;
+		sat.sat_port = sk->protinfo.af_at.src_port;
 	}
-	sat.sat_family = AF_APPLETALK;
-	memcpy(uaddr,&sat,sizeof(sat));
-	return(0);
-}
-
-/*	
- *	IP-over-DDP support.  Under construction.
- */
-
-#ifdef CONFIG_IPDDP
-
-#define SIOCADDIPDDPRT SIOCDEVPRIVATE
-#define SIOCDELIPDDPRT SIOCDEVPRIVATE+1
-#define SIOCFINDIPDDPRT SIOCDEVPRIVATE+2
-
-struct ipddp_route 
-{
-	struct device *dev;		/* Carrier device */
-	__u32 ip;			/* IP address */
-	struct at_addr at;		/* Gateway appletalk address */
-	int flags;
-	struct ipddp_route *next;
-};
-
-static struct ipddp_route *ipddp_route_head;
-
-static struct ipddp_route ipddp_route_test;
-
-int ipddp_open(struct device *dev)
-{
-	MOD_INC_USE_COUNT;
-	return 0;
-}
 
-int ipddp_close(struct device *dev)
-{
-	MOD_DEC_USE_COUNT;
-	return 0;
-}
-
-int ipddp_xmit(struct sk_buff *skb, struct device *dev)
-{
-	/* Retrieve the saved address hint */
-	struct at_addr *a=(struct at_addr *)skb->data;
-	skb_pull(skb,4);
-	
-	((struct net_device_stats *) dev->priv)->tx_packets++;
-	((struct net_device_stats *) dev->priv)->tx_bytes+=skb->len;
-
-	/* printk("ipddp_xmit called with headroom %d\n",skb_headroom(skb)); */
-
-	if( aarp_send_ddp(skb->dev,skb,a,NULL) < 0 )
-		dev_kfree_skb(skb,FREE_WRITE);
-
-	return 0;
-}
-
-struct net_device_stats *ipddp_get_stats(struct device *dev)
-{
-	return (struct net_device_stats *) dev->priv;
-}
-
-int ipddp_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
-{
-	struct ipddp_route *urt = (struct ipddp_route *)ifr->ifr_data;
-
-	if(!suser())
-		return -EPERM;
-	
-	/* for now we only have one route at a time */
-
-	switch(cmd) 
-	{
-		case SIOCADDIPDDPRT:
-			if(copy_from_user(&ipddp_route_test,urt,sizeof(struct ipddp_route)))
-				return -EFAULT;
-			ipddp_route_test.dev = atrtr_get_dev(&ipddp_route_test.at);
-			if (dev==NULL)
-				return -ENETUNREACH;
-			ipddp_route_test.next = NULL;
-			printk("added ipddp route through %s\n",ipddp_route_test.dev->name);
-			ipddp_route_head = &ipddp_route_test;
-			return 0;
-		case SIOCFINDIPDDPRT:
-			if(copy_to_user(urt,&ipddp_route_test,sizeof(struct ipddp_route)))
-				return -EFAULT;
-			return 0;
-		case SIOCDELIPDDPRT:
-			ipddp_route_test.dev = NULL;
-			ipddp_route_head = NULL;
-			return 0;
-		default: 
-			return -EINVAL;
-	}
-}
-
-int ipddp_header (struct sk_buff *skb, struct device *dev, unsigned short type,
-		void *daddr, void *saddr, unsigned len)
-{
-	/* printk("ipddp_header\n"); */
-	/* Push down the header space and the type byte */
-	skb_push(skb, sizeof(struct ddpehdr)+1+4);
-	return 0;
-}
-
-/*
- *	Now the packet really wants to go out. 
- */
- 
-int ipddp_rebuild_header (struct sk_buff *skb)
-{
-	struct ddpehdr *ddp;
-	struct at_addr at;
-	struct ipddp_route *rt;
-	struct at_addr *our_addr;
-	u32 paddr = ((struct rtable *)skb->dst)->rt_gateway;
-
-	/*
-	 *	On entry skb->data points to the ddpehdr we reserved earlier.
-	 *	skb->h.raw will be the higher level header.
-	 */
-
-	/*
-	 *	We created this earlier
-	 */
-
-	ddp = (struct ddpehdr *) (skb->data+4);
-	
-	/* find appropriate route */
-
-	for(rt=ipddp_route_head;rt;rt=rt->next) 
-	{
-		if(rt->ip == paddr) 
-			break;
-	}
-
-	if(!rt) {
-		printk("ipddp unreachable dst %08lx\n",ntohl(paddr));
-		return -ENETUNREACH;
-	}
-
-	our_addr = atalk_find_dev_addr(rt->dev);
- 	
-	/* fill in ddpehdr */
-	ddp->deh_len = skb->len;
-	ddp->deh_hops = 1;
-	ddp->deh_pad = 0;
-	ddp->deh_sum = 0;
-	ddp->deh_dnet = rt->at.s_net;	/* FIXME more hops?? */ 
-	ddp->deh_snet = our_addr->s_net;
-	ddp->deh_dnode = rt->at.s_node;
-	ddp->deh_snode = our_addr->s_node;
-	ddp->deh_dport = 72;
-	ddp->deh_sport = 72;
-	
-	*((__u8 *)(ddp+1)) = 22;	/* ddp type = IP */
-
-	/* fix up length field */
-	*((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
-
-	/* set skb->dev to appropriate device */
-	skb->dev = rt->dev;
-
-	/* skb->raddr = (unsigned long) at */ 
-	at = rt->at;
-	/* Hide it at the start of the buffer */
-	memcpy(skb->data,(void *)&at,sizeof(at));
-	skb->arp = 1;	/* so the actual device doesn't try to arp it... */
-	skb->protocol = htons(ETH_P_ATALK);	/* Protocol has changed */
-	
-	return 0;
-}
-
-int ipddp_init (struct device *dev)
-{
-	ether_setup(dev);
-	dev->hard_start_xmit = ipddp_xmit;
-	dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
-	if(!dev->priv) 
-		return -ENOMEM;
-	memset(dev->priv,0,sizeof(struct enet_statistics));
-	dev->get_stats = ipddp_get_stats;
-	dev->do_ioctl = ipddp_ioctl;
-	dev->type = ARPHRD_IPDDP;	/* IP over DDP tunnel */
-	dev->family = AF_INET;
-	dev->mtu = 585;
-	dev->flags |= IFF_NOARP;
-	dev->hard_header = ipddp_header; /* see ip_output.c */
-	dev->rebuild_header = ipddp_rebuild_header;
-	/*
-	 *	The worst case header we will need is currently a
-	 *	ethernet header (14 bytes) and a ddp header (sizeof ddpehdr+1)
-	 *	We send over SNAP so that takes another 8 bytes.
-	 */
-	dev->hard_header_len = 14+8+sizeof(struct ddpehdr)+1;
-	dev->open = ipddp_open;
-	dev->stop = ipddp_close;
+	sat.sat_family = AF_APPLETALK;
+	memcpy(uaddr, &sat, sizeof(sat));
 
-	return 0;
+	return (0);
 }
 
-static struct device dev_ipddp = {
-	"ipddp0\0   ",
-		0, 0, 0, 0,
-		0x0, 0,
-		0, 0, 0, NULL, ipddp_init };
-
-#endif /* CONFIG_IPDDP */
-
 /*
- *	Receive a packet (in skb) from device dev. This has come from the SNAP decoder, and on entry
- *	skb->h.raw is the DDP header, skb->len is the DDP length. The physical headers have been
- *	extracted. PPP should probably pass frames marked as for this layer
- *	[ie ARPHRD_ETHERTALK]
+ * Receive a packet (in skb) from device dev. This has come from the SNAP
+ * decoder, and on entry skb->h.raw is the DDP header, skb->len is the DDP
+ * header, skb->len is the DDP length. The physical headers have been
+ * extracted. PPP should probably pass frames marked as for this layer.
+ * [ie ARPHRD_ETHERTALK]
  */
-
 static int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
 {
 	struct sock *sock;
@@ -1406,13 +1249,12 @@ static int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type
         int origlen;
 
 	/* Size check */
-	if(skb->len<sizeof(*ddp))
+	if(skb->len < sizeof(*ddp))
 	{
 		kfree_skb(skb,FREE_READ);
-		return(0);
+		return (0);
 	}
 
-
 	/*
 	 *	Fix up the length field	[Ok this is horrible but otherwise
 	 *	I end up with unions of bit fields and messy bit field order
@@ -1423,254 +1265,264 @@ static int atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type
 	 *	run until we put it back)
 	 */
 
-	*((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
+	*((__u16 *)ddp) = ntohs(*((__u16 *)ddp));
 
 	/*
-	 *	Trim buffer in case of stray trailing data
+	 * Trim buffer in case of stray trailing data
 	 */
 
 	origlen = skb->len;
 
-	skb_trim(skb,min(skb->len,ddp->deh_len));
+	skb_trim(skb, min(skb->len, ddp->deh_len));
 
 	/*
-	 *	Size check to see if ddp->deh_len was crap
-	 *	(Otherwise we'll detonate most spectacularly
-	 *	 in the middle of recvmsg()).
+	 * Size check to see if ddp->deh_len was crap
+	 * (Otherwise we'll detonate most spectacularly
+	 * in the middle of recvmsg()).
 	 */
-
-	if(skb->len<sizeof(*ddp))
+	if(skb->len < sizeof(*ddp))
 	{
 		kfree_skb(skb,FREE_READ);
-		return(0);
+		return (0);
 	}
 
 	/*
-	 *	Any checksums. Note we don't do htons() on this == is assumed to be
-	 *	valid for net byte orders all over the networking code...
+	 * Any checksums. Note we don't do htons() on this == is assumed to be
+	 * valid for net byte orders all over the networking code...
 	 */
-
-	if(ddp->deh_sum && atalk_checksum(ddp, ddp->deh_len)!= ddp->deh_sum)
+	if(ddp->deh_sum && atalk_checksum(ddp, ddp->deh_len) != ddp->deh_sum)
 	{
 		/* Not a valid appletalk frame - dustbin time */
-		kfree_skb(skb,FREE_READ);
-		return(0);
+		kfree_skb(skb, FREE_READ);
+		return (0);
 	}
 
 	if(call_in_firewall(AF_APPLETALK, skb->dev, ddp, NULL,&skb)!=FW_ACCEPT)
 	{
 		kfree_skb(skb, FREE_READ);
-		return 0;
+		return (0);
 	}
 
 	/* Check the packet is aimed at us */
 
 	if(ddp->deh_dnet == 0)	/* Net 0 is 'this network' */
-		atif=atalk_find_anynet(ddp->deh_dnode, dev);
+		atif = atalk_find_anynet(ddp->deh_dnode, dev);
 	else
-		atif=atalk_find_interface(ddp->deh_dnet,ddp->deh_dnode);
+		atif = atalk_find_interface(ddp->deh_dnet, ddp->deh_dnode);
 
-	/* Not ours */
-	if(atif==NULL)
+	/* 
+	 * Not ours, so we route the packet via the correct Appletalk interface.
+	 */
+	if(atif == NULL)
 	{
 		struct atalk_route *rt;
 		struct at_addr ta;
 
-		/* Don't route multicast, etc., packets, or packets
-		   sent to "this network" */
+		/*
+		 * Don't route multicast, etc., packets, or packets
+		 * sent to "this network" 
+		 */
 		if (skb->pkt_type != PACKET_HOST || ddp->deh_dnet == 0)
 		{
 			kfree_skb(skb, FREE_READ);
-			return(0);
+			return (0);
 		}
 
 		/*
-		 *	Check firewall allows this routing
+		 * Check firewall allows this routing
 		 */
-
-		if(call_fw_firewall(AF_APPLETALK, skb->dev, ddp, NULL, &skb)!=FW_ACCEPT)
+		if(call_fw_firewall(AF_APPLETALK, skb->dev, ddp, NULL, &skb) != FW_ACCEPT)
 		{
 			kfree_skb(skb, FREE_READ);
-			return(0);
+			return (0);
 		}
 
-		ta.s_net=ddp->deh_dnet;
-		ta.s_node=ddp->deh_dnode;
+		ta.s_net  = ddp->deh_dnet;
+		ta.s_node = ddp->deh_dnode;
 
 		/* Route the packet */
-		rt=atrtr_find(&ta);
-		if(rt==NULL || ddp->deh_hops==15)
+		rt = atrtr_find(&ta);
+		if(rt == NULL || ddp->deh_hops == DDP_MAXHOPS)
 		{
 			kfree_skb(skb, FREE_READ);
-			return(0);
+			return (0);
 		}
 		ddp->deh_hops++;
 
 		/*
-		 *      Route goes through another gateway, so
-		 *      set the target to the gateway instead.
+		 * Route goes through another gateway, so
+		 * set the target to the gateway instead.
 		 */
-
-		if(rt->flags&RTF_GATEWAY)
+		if(rt->flags & RTF_GATEWAY)
 		{
-			ta.s_net = rt->gateway.s_net;
+			ta.s_net  = rt->gateway.s_net;
 			ta.s_node = rt->gateway.s_node;
 		}
 
                 /* Fix up skb->len field */
-                skb_trim(skb,min(origlen, rt->dev->hard_header_len +
+                skb_trim(skb, min(origlen, rt->dev->hard_header_len +
 			ddp_dl->header_length + ddp->deh_len));
 
-		*((__u16 *)ddp)=ntohs(*((__u16 *)ddp));		/* Mend the byte order */
+		/* Mend the byte order */
+		*((__u16 *)ddp) = ntohs(*((__u16 *)ddp));
 
 		/*
-		 *	Send the buffer onwards
-		 */
-
-		/*
-		 *	Now we must always be careful. If it's come from 
-		 *	localtalk to ethertalk it might not fit
+		 * Send the buffer onwards
+		 *
+		 * Now we must always be careful. If it's come from 
+		 * localtalk to ethertalk it might not fit
 		 *
-		 *	Order matters here: If a packet has to be copied
-		 *	to make a new headroom (rare hopefully) then it
-		 *	won't need unsharing.
+		 * Order matters here: If a packet has to be copied
+		 * to make a new headroom (rare hopefully) then it
+		 * won't need unsharing.
 		 *
-		 *	Note. ddp-> becomes invalid at the realloc.
+		 * Note. ddp-> becomes invalid at the realloc.
 		 */
-		
-		if(skb_headroom(skb)<22)
+		if(skb_headroom(skb) < 22)
 			/* 22 bytes - 12 ether, 2 len, 3 802.2 5 snap */
-			skb=skb_realloc_headroom(skb, 32);
+			skb = skb_realloc_headroom(skb, 32);
 		else
-			skb=skb_unshare(skb, GFP_ATOMIC, FREE_READ);
+			skb = skb_unshare(skb, GFP_ATOMIC, FREE_READ);
 		
 		/*
-		 *	If the buffer didnt vanish into the lack of
-		 *	space bitbucket we can send it.
+		 * If the buffer didn't vanish into the lack of
+		 * space bitbucket we can send it.
 		 */
-		 
 		if(skb)
 		{
 			skb->arp = 1;	/* Resolved */
-			if(aarp_send_ddp(rt->dev, skb, &ta, NULL)==-1)
+			if(aarp_send_ddp(rt->dev, skb, &ta, NULL) == -1)
 				kfree_skb(skb, FREE_READ);
 		}
-		return 0;
+
+		return (0);
 	}
 
-	/* Which socket - atalk_search_socket() looks for a *full match*
-	   of the <net,node,port> tuple */
-	tosat.sat_addr.s_net = ddp->deh_dnet;
+	/*
+	 * Which socket - atalk_search_socket() looks for a *full match*
+	 * of the <net,node,port> tuple.
+	 */
+	tosat.sat_addr.s_net  = ddp->deh_dnet;
 	tosat.sat_addr.s_node = ddp->deh_dnode;
 	tosat.sat_port = ddp->deh_dport;
 
-	sock=atalk_search_socket( &tosat, atif );
+	sock = atalk_search_socket(&tosat, atif);
 	
-	if(sock==NULL)	/* But not one of our sockets */
+	if(sock == NULL)	/* But not one of our sockets */
 	{
-		kfree_skb(skb,FREE_READ);
-		return(0);
+		kfree_skb(skb, FREE_READ);
+		return (0);
 	}
 
 #ifdef CONFIG_IPDDP
 	/*
 	 *	Check if IP-over-DDP
 	 */
-
-	if(skb->data[12]==22) 
+	if(skb->data[12] == 22) 
 	{
-		struct net_device_stats *estats = 
-			(struct net_device_stats *) dev_ipddp.priv;
-		skb->protocol=htons(ETH_P_IP);
-		skb_pull(skb,13);
-		skb->dev=&dev_ipddp;
+		struct device *dev;
+                struct net_device_stats *estats;
+
+		if((dev = dev_get("ipddp0")) == NULL)
+                	return (-ENODEV);
+
+		estats = (struct net_device_stats *) dev->priv;
+		skb->protocol = htons(ETH_P_IP);
+		skb_pull(skb, 13);
+		skb->dev = dev;
 		skb->h.raw = skb->data;
+
 	/*	printk("passing up ipddp, 0x%02x better be 45\n",skb->data[0]);
 	 *	printk("tot_len %d, skb->len %d\n",
 	 *		ntohs(skb->h.iph->tot_len),skb->len);
 	 */
+
 		estats->rx_packets++;
-		estats->rx_bytes+=skb->len+13;
-		netif_rx(skb);
-		return 0;
+		estats->rx_bytes += skb->len + 13;
+		netif_rx(skb);	/* Send the SKB up to a higher place. */
+
+		return (0);
 	}
-#endif /* CONFIG_IPDDP */	
+#endif /* CONFIG_IPDDP */
+	
 	/*
 	 *	Queue packet (standard)
 	 */
 	 
 	skb->sk = sock;
 
-	if(sock_queue_rcv_skb(sock,skb)<0)
+	if(sock_queue_rcv_skb(sock, skb) < 0)
 	{
-		skb->sk=NULL;
+		skb->sk = NULL;
 		kfree_skb(skb, FREE_WRITE);
 	}
-	return(0);
+
+	return (0);
 }
 
 /*
- *	Receive a localtalk frame. We make some demands on the caller here.
- *	Caller must provide enough headroom on the packet to pull the short
- *	header and append a long one.
+ * Receive a localtalk frame. We make some demands on the caller here.
+ * Caller must provide enough headroom on the packet to pull the short
+ * header and append a long one.
  */
-
-
 static int ltalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
 {
 	struct ddpehdr *ddp;
 	struct at_addr *ap;
+
 	/*
-	 *	Expand any short form frames.
+	 * Expand any short form frames.
 	 */
-
-	if(skb->mac.raw[2]==1)
+	if(skb->mac.raw[2] == 1)
 	{
 		/*
-		 *	Find our address.
+		 * Find our address.
 		 */
 
-		ap=atalk_find_dev_addr(dev);
-		if(ap==NULL || skb->len<sizeof(struct ddpshdr))
+		ap = atalk_find_dev_addr(dev);
+		if(ap == NULL || skb->len < sizeof(struct ddpshdr))
 		{
 			kfree_skb(skb, FREE_READ);
-			return 0;
+			return (0);
 		}
 
 		/*
-		 *	The push leaves us with a ddephdr not an shdr, and
-		 *	handily the port bytes in the right place preset.
+		 * The push leaves us with a ddephdr not an shdr, and
+		 * handily the port bytes in the right place preset.
 		 */
 
-		skb_push(skb, sizeof(*ddp)-4);
-		ddp=(struct ddpehdr *)skb->data;
+		skb_push(skb, sizeof(*ddp) - 4);
+		ddp = (struct ddpehdr *)skb->data;
 
 		/*
-		 *	Now fill in the long header.
+		 * Now fill in the long header.
 		 */
 
 	 	/*
-	 	 *	These two first. The mac overlays the new source/dest
-	 	 *	network information so we MUST copy these before
-	 	 *	we write the network numbers !
+	 	 * These two first. The mac overlays the new source/dest
+	 	 * network information so we MUST copy these before
+	 	 * we write the network numbers !
 	 	 */
 
-		ddp->deh_dnode=skb->mac.raw[0];	/* From physical header */
-		ddp->deh_snode=skb->mac.raw[1];	/* From physical header */
+		ddp->deh_dnode = skb->mac.raw[0];     /* From physical header */
+		ddp->deh_snode = skb->mac.raw[1];     /* From physical header */
 
-		ddp->deh_dnet=ap->s_net;	/* Network number */
-		ddp->deh_snet=ap->s_net;
-		ddp->deh_sum=0;			/* No checksum */
+		ddp->deh_dnet  = ap->s_net;	/* Network number */
+		ddp->deh_snet  = ap->s_net;
+		ddp->deh_sum   = 0;		/* No checksum */
 		/*
-		 *	Not sure about this bit...
+		 * Not sure about this bit...
 		 */
-		ddp->deh_len=skb->len;
-		ddp->deh_hops=15;		/* Non routable, so force a drop
+		ddp->deh_len   = skb->len;
+		ddp->deh_hops  = DDP_MAXHOPS;	/* Non routable, so force a drop
 						   if we slip up later */
-		*((__u16 *)ddp)=htons(*((__u16 *)ddp));		/* Mend the byte order */
+
+		/* Mend the byte order */
+		*((__u16 *)ddp) = htons(*((__u16 *)ddp));
 	}
 	skb->h.raw = skb->data;
-	return atalk_rcv(skb,dev,pt);
+
+	return (atalk_rcv(skb, dev, pt));
 }
 
 static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len,
@@ -1688,66 +1540,68 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len,
 	int err;
 	int flags = msg->msg_flags;
 
-	if(flags&~MSG_DONTWAIT)
-		return -EINVAL;
+	if(flags & ~MSG_DONTWAIT)
+		return (-EINVAL);
 
-	if(len>587)
-		return -EMSGSIZE;
+	if(len > DDP_MAXSZ)
+		return (-EMSGSIZE);
 
 	if(usat)
 	{
 		if(sk->zapped)
 		{
-			if(atalk_autobind(sk)<0)
-				return -EBUSY;
+			if(atalk_autobind(sk) < 0)
+				return (-EBUSY);
 		}
 
-		if(msg->msg_namelen <sizeof(*usat))
-			return(-EINVAL);
+		if(msg->msg_namelen < sizeof(*usat))
+			return (-EINVAL);
 		if(usat->sat_family != AF_APPLETALK)
-			return -EINVAL;
+			return (-EINVAL);
+
 		/* netatalk doesn't implement this check */
-		if(usat->sat_addr.s_node==ATADDR_BCAST && !sk->broadcast)
+		if(usat->sat_addr.s_node == ATADDR_BCAST && !sk->broadcast)
 		{
 			printk(KERN_INFO "SO_BROADCAST: Fix your netatalk as it will break before 2.2\n");
 #if 0
-			return -EPERM;
+			return (-EPERM);
 #endif
 		}
 	}
 	else
 	{
-		if(sk->state!=TCP_ESTABLISHED)
-			return -ENOTCONN;
-		usat=&local_satalk;
-		usat->sat_family=AF_APPLETALK;
-		usat->sat_port=sk->protinfo.af_at.dest_port;
-		usat->sat_addr.s_node=sk->protinfo.af_at.dest_node;
-		usat->sat_addr.s_net=sk->protinfo.af_at.dest_net;
+		if(sk->state != TCP_ESTABLISHED)
+			return (-ENOTCONN);
+		usat =& local_satalk;
+		usat->sat_family = AF_APPLETALK;
+		usat->sat_port   = sk->protinfo.af_at.dest_port;
+		usat->sat_addr.s_node = sk->protinfo.af_at.dest_node;
+		usat->sat_addr.s_net  = sk->protinfo.af_at.dest_net;
 	}
 
 	/* Build a packet */
 
 	SOCK_DEBUG(sk, "SK %p: Got address.\n",sk);
 
-	size=sizeof(struct ddpehdr)+len+ddp_dl->header_length;	/* For headers */
+	/* For headers */
+	size = sizeof(struct ddpehdr) + len + ddp_dl->header_length;
 
-	if(usat->sat_addr.s_net!=0 || usat->sat_addr.s_node == ATADDR_ANYNODE)
+	if(usat->sat_addr.s_net != 0 || usat->sat_addr.s_node == ATADDR_ANYNODE)
 	{
-		rt=atrtr_find(&usat->sat_addr);
-		if(rt==NULL)
-			return -ENETUNREACH;
-		dev=rt->dev;
+		rt = atrtr_find(&usat->sat_addr);
+		if(rt == NULL)
+			return (-ENETUNREACH);
+		dev = rt->dev;
 	}
 	else
 	{
 		struct at_addr at_hint;
-		at_hint.s_node=0;
-		at_hint.s_net=sk->protinfo.af_at.src_net;
-		rt=atrtr_find(&at_hint);
-		if(rt==NULL)
-			return -ENETUNREACH;
-		dev=rt->dev;
+		at_hint.s_node = 0;
+		at_hint.s_net  = sk->protinfo.af_at.src_net;
+		rt = atrtr_find(&at_hint);
+		if(rt == NULL)
+			return (-ENETUNREACH);
+		dev = rt->dev;
 	}
 
 	SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n", sk, size, dev->name);
@@ -1755,105 +1609,105 @@ static int atalk_sendmsg(struct socket *sock, struct msghdr *msg, int len,
 	size += dev->hard_header_len;
 
 	skb = sock_alloc_send_skb(sk, size, 0, flags&MSG_DONTWAIT, &err);
-	if(skb==NULL)
-		return err;
+	if(skb == NULL)
+		return (err);
 
-	skb->sk=sk;
-	skb->arp=1;
-	skb_reserve(skb,ddp_dl->header_length);
-	skb_reserve(skb,dev->hard_header_len);
+	skb->sk  = sk;
+	skb->arp = 1;
+	skb_reserve(skb, ddp_dl->header_length);
+	skb_reserve(skb, dev->hard_header_len);
 
-	skb->dev=dev;
+	skb->dev = dev;
 
 	SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk);
 
-	ddp=(struct ddpehdr *)skb_put(skb,sizeof(struct ddpehdr));
-	ddp->deh_pad=0;
-	ddp->deh_hops=0;
-	ddp->deh_len=len+sizeof(*ddp);
+	ddp = (struct ddpehdr *)skb_put(skb,sizeof(struct ddpehdr));
+	ddp->deh_pad  = 0;
+	ddp->deh_hops = 0;
+	ddp->deh_len  = len + sizeof(*ddp);
 	/*
-	 *	Fix up the length field	[Ok this is horrible but otherwise
-	 *	I end up with unions of bit fields and messy bit field order
-	 *	compiler/endian dependencies..
+	 * Fix up the length field [Ok this is horrible but otherwise
+	 * I end up with unions of bit fields and messy bit field order
+	 * compiler/endian dependencies..
 	 */
-	*((__u16 *)ddp)=ntohs(*((__u16 *)ddp));
+	*((__u16 *)ddp) = ntohs(*((__u16 *)ddp));
 
-	ddp->deh_dnet=usat->sat_addr.s_net;
-	ddp->deh_snet=sk->protinfo.af_at.src_net;
-	ddp->deh_dnode=usat->sat_addr.s_node;
-	ddp->deh_snode=sk->protinfo.af_at.src_node;
-	ddp->deh_dport=usat->sat_port;
-	ddp->deh_sport=sk->protinfo.af_at.src_port;
+	ddp->deh_dnet  = usat->sat_addr.s_net;
+	ddp->deh_snet  = sk->protinfo.af_at.src_net;
+	ddp->deh_dnode = usat->sat_addr.s_node;
+	ddp->deh_snode = sk->protinfo.af_at.src_node;
+	ddp->deh_dport = usat->sat_port;
+	ddp->deh_sport = sk->protinfo.af_at.src_port;
 
 	SOCK_DEBUG(sk, "SK %p: Copy user data (%d bytes).\n", sk, len);
 
-	err = memcpy_fromiovec(skb_put(skb,len),msg->msg_iov,len);
-	if (err)
+	err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
+	if(err)
 	{
 		kfree_skb(skb, FREE_WRITE);
-		return -EFAULT;
+		return (-EFAULT);
 	}
 
-	if(sk->no_check==1)
-		ddp->deh_sum=0;
+	if(sk->no_check == 1)
+		ddp->deh_sum = 0;
 	else
-		ddp->deh_sum=atalk_checksum(ddp, len+sizeof(*ddp));
+		ddp->deh_sum = atalk_checksum(ddp, len + sizeof(*ddp));
 
-	if(call_out_firewall(AF_APPLETALK, skb->dev, ddp, NULL, &skb)!=FW_ACCEPT)
+	if(call_out_firewall(AF_APPLETALK, skb->dev, ddp, NULL, &skb) != FW_ACCEPT)
 	{
 		kfree_skb(skb, FREE_WRITE);
-		return -EPERM;
+		return (-EPERM);
 	}
 
 	/*
-	 *	Loopback broadcast packets to non gateway targets (ie routes
-	 *	to group we are in)
+	 * Loopback broadcast packets to non gateway targets (ie routes
+	 * to group we are in)
 	 */
-
-	if(ddp->deh_dnode==ATADDR_BCAST)
+	if(ddp->deh_dnode == ATADDR_BCAST)
 	{
-		if((!(rt->flags&RTF_GATEWAY))&&(!(dev->flags&IFF_LOOPBACK)))
+		if((!(rt->flags&RTF_GATEWAY)) && (!(dev->flags&IFF_LOOPBACK)))
 		{
-			struct sk_buff *skb2=skb_copy(skb, GFP_KERNEL);
+			struct sk_buff *skb2 = skb_copy(skb, GFP_KERNEL);
 			if(skb2)
 			{
-				loopback=1;
+				loopback = 1;
 				SOCK_DEBUG(sk, "SK %p: send out(copy).\n", sk);
-				if(aarp_send_ddp(dev,skb2,&usat->sat_addr, NULL)==-1)
+				if(aarp_send_ddp(dev, skb2, &usat->sat_addr, NULL) == -1)
 					kfree_skb(skb2, FREE_WRITE);
 				/* else queued/sent above in the aarp queue */
 			}
 		}
 	}
 
-	if((dev->flags&IFF_LOOPBACK) || loopback)
+	if((dev->flags & IFF_LOOPBACK) || loopback)
 	{
 		SOCK_DEBUG(sk, "SK %p: Loop back.\n", sk);
 		/* loop back */
 		skb_orphan(skb);
 		ddp_dl->datalink_header(ddp_dl, skb, dev->dev_addr);
-		skb->mac.raw=skb->data;
-		skb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
+		skb->mac.raw = skb->data;
+		skb->h.raw   = skb->data + ddp_dl->header_length + dev->hard_header_len;
 		skb_pull(skb,dev->hard_header_len);
 		skb_pull(skb,ddp_dl->header_length);
-		atalk_rcv(skb,dev,NULL);
+		atalk_rcv(skb, dev, NULL);
 	}
 	else
 	{
 		SOCK_DEBUG(sk, "SK %p: send out.\n", sk);
-		if ( rt->flags & RTF_GATEWAY ) {
+		if (rt->flags & RTF_GATEWAY)
+		{
 		    gsat.sat_addr = rt->gateway;
 		    usat = &gsat;
 		}
 
-		if(aarp_send_ddp(dev,skb,&usat->sat_addr, NULL)==-1)
+		if(aarp_send_ddp(dev, skb, &usat->sat_addr, NULL) == -1)
 			kfree_skb(skb, FREE_WRITE);
 		/* else queued/sent above in the aarp queue */
 	}
 	SOCK_DEBUG(sk, "SK %p: Done write (%d).\n", sk, len);
-	return len;
-}
 
+	return (len);
+}
 
 static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size,
 		int flags, struct scm_cookie *scm)
@@ -1863,60 +1717,60 @@ static int atalk_recvmsg(struct socket *sock, struct msghdr *msg, int size,
 	struct ddpehdr	*ddp = NULL;
 	int copied = 0;
 	struct sk_buff *skb;
-	int er = 0;
+	int err = 0;
 
-	skb=skb_recv_datagram(sk,flags&~MSG_DONTWAIT,flags&MSG_DONTWAIT,&er);
-	if(skb==NULL)
-		return er;
+	skb = skb_recv_datagram(sk,flags&~MSG_DONTWAIT,flags&MSG_DONTWAIT,&err);
+	if(skb == NULL)
+		return (err);
 
 	ddp = (struct ddpehdr *)(skb->h.raw);
-	if(sk->type==SOCK_RAW)
+	if(sk->type == SOCK_RAW)
 	{
-		copied=ddp->deh_len;
+		copied = ddp->deh_len;
 		if(copied > size)
 		{
-			copied=size;
-			msg->msg_flags|=MSG_TRUNC;
+			copied = size;
+			msg->msg_flags |= MSG_TRUNC;
 		}
-		er = skb_copy_datagram_iovec(skb,0,msg->msg_iov,copied);
-		if (er)
-			goto out;
+
+		err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 	}
 	else
 	{
-		copied=ddp->deh_len - sizeof(*ddp);
-		if (copied > size)
+		copied = ddp->deh_len - sizeof(*ddp);
+		if(copied > size)
 		{
 			copied = size;
-			msg->msg_flags|=MSG_TRUNC;
+			msg->msg_flags |= MSG_TRUNC;
 		}
-		er = skb_copy_datagram_iovec(skb,sizeof(*ddp),msg->msg_iov,copied);
-		if (er)
-			goto out;
+		err = skb_copy_datagram_iovec(skb,sizeof(*ddp),msg->msg_iov,copied);
 	}
-	if(sat)
+
+	if(!err)
 	{
-		sat->sat_family=AF_APPLETALK;
-		sat->sat_port=ddp->deh_sport;
-		sat->sat_addr.s_node=ddp->deh_snode;
-		sat->sat_addr.s_net=ddp->deh_snet;
+		if(sat)
+		{
+			sat->sat_family      = AF_APPLETALK;
+			sat->sat_port        = ddp->deh_sport;
+			sat->sat_addr.s_node = ddp->deh_snode;
+			sat->sat_addr.s_net  = ddp->deh_snet;
+		}
+		msg->msg_namelen = sizeof(*sat);
 	}
-	msg->msg_namelen=sizeof(*sat);
-out:
-	skb_free_datagram(sk, skb);
-	return er ? er : (copied);
-}
 
+	skb_free_datagram(sk, skb);	/* Free the datagram. */
+
+	return (err ? err : (copied));
+}
 
 static int atalk_shutdown(struct socket *sk,int how)
 {
-	return -EOPNOTSUPP;
+	return (-EOPNOTSUPP);
 }
 
 /*
- *	Appletalk ioctl calls.
+ * Appletalk ioctl calls.
  */
-
 static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
 {
 	long amount=0;
@@ -1929,43 +1783,48 @@ static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
 		 */
 		case TIOCOUTQ:
 			amount = sk->sndbuf - atomic_read(&sk->wmem_alloc);
-			if(amount<0)
-				amount=0;
+			if(amount < 0)
+				amount = 0;
 			break;
+
 		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 ddpehdr);
+			if((skb = skb_peek(&sk->receive_queue)) != NULL)
+				amount = skb->len-sizeof(struct ddpehdr);
 			break;
 		}
+
 		case SIOCGSTAMP:
-			if (sk)
+			if(sk)
 			{
-				if(sk->stamp.tv_sec==0)
+				if(sk->stamp.tv_sec == 0)
 					return -ENOENT;
-				return copy_to_user((void *)arg,&sk->stamp,sizeof(struct timeval)) ? -EFAULT : 0;
+				return (copy_to_user((void *)arg,&sk->stamp,sizeof(struct timeval)) ? -EFAULT : 0);
 			}
-			return -EINVAL;
+			return (-EINVAL);
+
 		/*
-		 *	Routing
+		 * Routing
 		 */
 		case SIOCADDRT:
 		case SIOCDELRT:
 			if(!suser())
 				return -EPERM;
-			return(atrtr_ioctl(cmd,(void *)arg));
+			return (atrtr_ioctl(cmd,(void *)arg));
+
 		/*
-		 *	Interface
+		 * Interface
 		 */
 		case SIOCGIFADDR:
 		case SIOCSIFADDR:
 		case SIOCGIFBRDADDR:
 		case SIOCATALKDIFADDR:
-			return atif_ioctl(cmd,(void *)arg);
+			return (atif_ioctl(cmd,(void *)arg));
+
 		/*
-		 *	Physical layer ioctl calls
+		 * Physical layer ioctl calls
 		 */
 		case SIOCSIFLINK:
 		case SIOCGIFHWADDR:
@@ -1979,7 +1838,7 @@ static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
 		case SIOCGIFCOUNT:
 		case SIOGIFINDEX:
 		case SIOGIFNAME:
-			return(dev_ioctl(cmd,(void *) arg));
+			return ((dev_ioctl(cmd,(void *) arg)));
 
 		case SIOCSIFMETRIC:
 		case SIOCSIFBRDADDR:
@@ -1989,20 +1848,23 @@ static int atalk_ioctl(struct socket *sock,unsigned int cmd, unsigned long arg)
 		case SIOCSIFMEM:
 		case SIOCGIFDSTADDR:
 		case SIOCSIFDSTADDR:
-			return -EINVAL;
+			return (-EINVAL);
 
 		default:
-			return -EINVAL;
+			return (-EINVAL);
 	}
-	return put_user(amount, (int *)arg);
+
+	return (put_user(amount, (int *)arg));
 }
 
-static struct net_proto_family atalk_family_ops = {
+static struct net_proto_family atalk_family_ops=
+{
 	AF_APPLETALK,
 	atalk_create
 };
 
-static struct proto_ops atalk_dgram_ops = {
+static struct proto_ops atalk_dgram_ops=
+{
 	AF_APPLETALK,
 
 	sock_no_dup,
@@ -2023,7 +1885,8 @@ static struct proto_ops atalk_dgram_ops = {
 	atalk_recvmsg
 };
 
-static struct notifier_block ddp_notifier={
+static struct notifier_block ddp_notifier=
+{
 	ddp_device_event,
 	NULL,
 	0
@@ -2047,41 +1910,53 @@ struct packet_type ppptalk_packet_type=
 	NULL
 };
 
-static char ddp_snap_id[]={0x08,0x00,0x07,0x80,0x9B};
+static char ddp_snap_id[] = {0x08, 0x00, 0x07, 0x80, 0x9B};
+
+/*
+ * Export symbols for use by drivers when Appletalk is a module.
+ */
+EXPORT_SYMBOL(aarp_send_ddp);
+EXPORT_SYMBOL(atrtr_get_dev);
+EXPORT_SYMBOL(atalk_find_dev_addr);
 
 #ifdef CONFIG_PROC_FS
-static struct proc_dir_entry proc_appletalk = {
+static struct proc_dir_entry proc_appletalk=
+{
 	PROC_NET_ATALK, 9, "appletalk",
 	S_IFREG | S_IRUGO, 1, 0, 0,
 	0, &proc_net_inode_operations,
 	atalk_get_info
 };
-static struct proc_dir_entry proc_atalk_route = {
+
+static struct proc_dir_entry proc_atalk_route=
+{
 	PROC_NET_AT_ROUTE, 11,"atalk_route",
 	S_IFREG | S_IRUGO, 1, 0, 0,
 	0, &proc_net_inode_operations,
 	atalk_rt_get_info
 };
-static struct proc_dir_entry proc_atalk_iface = {
+
+static struct proc_dir_entry proc_atalk_iface=
+{
 	PROC_NET_ATIF, 11,"atalk_iface",
 	S_IFREG | S_IRUGO, 1, 0, 0,
 	0, &proc_net_inode_operations,
 	atalk_if_get_info
 };
-#endif
+#endif /* CONFIG_PROC_FS */
 
 /* Called by proto.c on kernel start up */
 
 __initfunc(void atalk_proto_init(struct net_proto *pro))
 {
 	(void) sock_register(&atalk_family_ops);
-	if ((ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv)) == NULL)
+	if((ddp_dl = register_snap_client(ddp_snap_id, atalk_rcv)) == NULL)
 		printk(KERN_CRIT "Unable to register DDP with SNAP.\n");
 
-	ltalk_packet_type.type=htons(ETH_P_LOCALTALK);
+	ltalk_packet_type.type = htons(ETH_P_LOCALTALK);
 	dev_add_pack(&ltalk_packet_type);
 
-	ppptalk_packet_type.type=htons(ETH_P_PPPTALK);
+	ppptalk_packet_type.type = htons(ETH_P_PPPTALK);
 	dev_add_pack(&ppptalk_packet_type);
 
 	register_netdevice_notifier(&ddp_notifier);
@@ -2091,88 +1966,80 @@ __initfunc(void atalk_proto_init(struct net_proto *pro))
 	proc_net_register(&proc_appletalk);
 	proc_net_register(&proc_atalk_route);
 	proc_net_register(&proc_atalk_iface);
-#endif	
+#endif /* CONFIG_PROC_FS */
 
 #ifdef CONFIG_SYSCTL
 	atalk_register_sysctl();
-#endif
-
-#ifdef CONFIG_IPDDP
-	register_netdev(&dev_ipddp);
-#endif /* CONFIG_IPDDP */
+#endif /* CONFIG_SYSCTL */
 
 	printk(KERN_INFO "Appletalk 0.18 for Linux NET3.037\n");
 }
 
 #ifdef MODULE
-EXPORT_NO_SYMBOLS;
 
 int init_module(void)
 {
 	atalk_proto_init(NULL);
-	return 0;
+	return (0);
 }
 
 /*
- *	FIX THIS: If there are any routes/devices configured
- *	for appletalk we must not be unloaded.
+ * Actually down the interface.
  */
-
-/* Remove all route entries. Interrupts must be off. */
-extern inline void free_route_list(void)
+static void atalk_iface_down(struct atalk_iface *iface)
 {
-	struct atalk_route *list = atalk_router_list, *tmp;
+	atrtr_device_down(iface->dev);	/* Remove all routes for the device */
+	aarp_device_down(iface->dev);	/* Remove AARP entries for the device */
+	atif_drop_device(iface->dev);	/* Remove the device */
 
-	while (list != NULL)
-	{
-		tmp = list->next;
-		kfree_s(list, sizeof(struct atalk_route));
-		list = tmp;
-	}
+	return;
 }
 
-/* Remove all interface entries. Interrupts must be off. */
-extern inline void free_interface_list(void)
-{
-	struct atalk_iface *list = atalk_iface_list, *tmp;
-
-	while (list != NULL)
-	{
-		tmp = list->next;
-		list->dev->atalk_ptr = NULL;
-		kfree_s(list, sizeof(struct atalk_iface));
-		list = tmp;
-	}
-}
+/*
+ * Note on MOD_{INC,DEC}_USE_COUNT:
+ *
+ * Use counts are incremented/decremented when
+ * sockets are created/deleted.
+ *
+ * Appletalk interfaces are not incremented untill atalkd is run
+ * and are only decremented when they are downed.
+ *
+ * Ergo, before the appletalk module can be removed, all Appletalk
+ * sockets be closed from user space.
+ */
 
 void cleanup_module(void)
 {
-	unsigned long flags;
+	struct atalk_iface *ifaces = atalk_iface_list, *tmp;
 
-	save_flags(flags);
-	cli();
-
-	aarp_cleanup_module();
+        while(ifaces != NULL)
+        {
+                tmp = ifaces->next;
+                ifaces->dev->atalk_ptr = NULL;
+                atalk_iface_down(ifaces);
+                ifaces = tmp;
+        }
 
 #ifdef CONFIG_SYSCTL
 	atalk_unregister_sysctl();
-#endif
+#endif /* CONFIG_SYSCTL */
 
 #ifdef CONFIG_PROC_FS
 	proc_net_unregister(PROC_NET_ATALK);
 	proc_net_unregister(PROC_NET_AT_ROUTE);
 	proc_net_unregister(PROC_NET_ATIF);
-#endif
+#endif /* CONFIG_PROC_FS */
+
+	aarp_cleanup_module();	/* General aarp clean-up. */
+
 	unregister_netdevice_notifier(&ddp_notifier);
 	dev_remove_pack(&ltalk_packet_type);
 	dev_remove_pack(&ppptalk_packet_type);
 	unregister_snap_client(ddp_snap_id);
 	sock_unregister(atalk_family_ops.family);
 
-	free_route_list();
-	free_interface_list();
-
-	restore_flags(flags);
+	return;
 }
 
 #endif  /* MODULE */
+#endif  /* CONFIG_ATALK || CONFIG_ATALK_MODULE */
diff --git a/net/appletalk/sysctl_net_atalk.c b/net/appletalk/sysctl_net_atalk.c
index c2c1a8c64..776902889 100644
--- a/net/appletalk/sysctl_net_atalk.c
+++ b/net/appletalk/sysctl_net_atalk.c
@@ -59,9 +59,3 @@ void atalk_unregister_sysctl(void)
 {
 }
 #endif
-
-
-
-
-
-
diff --git a/net/core/dev.c b/net/core/dev.c
index c2b29617a..5970c5bab 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -1006,7 +1006,7 @@ static int dev_ifname(struct ifreq *arg)
 
 	strcpy(ifr.ifr_name, dev->name);
 
-	err = copy_to_user(&ifr, arg, sizeof(struct ifreq));
+	err = copy_to_user(arg, &ifr, sizeof(struct ifreq));
 	return (err)?-EFAULT:0;
 }
 
diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index ebf2c6c6b..472f64811 100644
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -797,10 +797,11 @@ static struct arp_table * arp_alloc(int how)
 
 	entry = (struct arp_table *)neigh_alloc(sizeof(struct arp_table),
 						&arp_neigh_ops);
-	atomic_set(&entry->u.neigh.refcnt, 1);
 
 	if (entry != NULL)
 	{
+		atomic_set(&entry->u.neigh.refcnt, 1);
+
 		if (how)
 			atomic_inc(&arp_size);
 
@@ -1265,7 +1266,7 @@ void arp_send(int type, int ptype, u32 dest_ip,
 	arp = (struct arphdr *) skb_put(skb,sizeof(struct arphdr) + 2*(dev->addr_len+4));
 	skb->arp = 1;
 	skb->dev = dev;
-	skb->protocol = htons (ETH_P_IP);
+	skb->protocol = htons (ETH_P_ARP);
 
 	/*
 	 *	Fill the device header for the ARP frame
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index ddb398938..74dbd2266 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -5,7 +5,7 @@
  *
  *		Implementation of the Transmission Control Protocol(TCP).
  *
- * Version:	$Id: tcp_output.c,v 1.1.1.1 1997/06/01 03:16:26 ralf Exp $
+ * Version:	$Id: tcp_output.c,v 1.2 1997/09/12 01:34:42 ralf Exp $
  *
  * Authors:	Ross Biro, <bir7@leland.Stanford.Edu>
  *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
@@ -605,11 +605,14 @@ static int tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *skb)
 	memcpy(skb_put(skb, size2), ((char *) th2) + (th2->doff << 2), size2);
 	
 	/* Update sizes on original skb, both TCP and IP. */
-	skb->end_seq += size2;
+	skb->end_seq += buff->end_seq - buff->seq;
 	if (th2->urg) {
 		th1->urg = 1;
 		th1->urg_ptr = th2->urg_ptr + size1;
 	}
+	if (th2->fin) {
+		th1->fin = 1;
+	}
 
 	/* ... and off you go. */
 	kfree_skb(buff, FREE_WRITE);
diff --git a/net/ipv6/icmp.c b/net/ipv6/icmp.c
index a5a884646..57b528c0d 100644
--- a/net/ipv6/icmp.c
+++ b/net/ipv6/icmp.c
@@ -5,7 +5,7 @@
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>
  *
- *	$Id: icmp.c,v 1.1.1.1 1997/06/01 03:16:27 ralf Exp $
+ *	$Id: icmp.c,v 1.2 1997/07/20 15:01:57 ralf Exp $
  *
  *	Based on net/ipv4/icmp.c
  *
@@ -92,7 +92,6 @@ struct icmpv6_msg {
 
 /*
  *	getfrag callback
- *	not static because it's needed in ndisc.c
  */
 
 static int icmpv6_getfrag(const void *data, struct in6_addr *saddr, 
@@ -131,11 +130,12 @@ static int icmpv6_getfrag(const void *data, struct in6_addr *saddr,
 }
 
 /*
- *	an inline helper for the "simple" if statement bellow
+ *	an inline helper for the "simple" if statement below
  *	checks if parameter problem report is caused by an
  *	unrecognized IPv6 option that has the Option Type 
  *	highest-order two bits set to 10
  */
+
 static __inline__ int opt_unrec(struct sk_buff *skb, __u32 offset)
 {
 	char *buff = skb->nh.raw;
diff --git a/net/ipv6/ip6_fib.c b/net/ipv6/ip6_fib.c
index 25b34465c..a54582816 100644
--- a/net/ipv6/ip6_fib.c
+++ b/net/ipv6/ip6_fib.c
@@ -5,7 +5,7 @@
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>	
  *
- *	$Id: ip6_fib.c,v 1.7 1997/04/12 04:32:46 davem Exp $
+ *	$Id: ip6_fib.c,v 1.1.1.1 1997/06/01 03:16:27 ralf Exp $
  *
  *	This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
@@ -235,7 +235,15 @@ static struct fib6_node * fib6_add_1(struct fib6_node *root, void *addr,
 
 		key = (struct rt6key *)((u8 *)fn->leaf + offset);
 
+		/*
+		 *	Prefix match
+		 */
 		if (addr_match(&key->addr, addr, fn->fn_bit)) {
+		
+			/*
+			 *	Exact match ?
+			 */
+			 
 			if (plen == fn->fn_bit) {
 				/* clean up an intermediate node */
 				if ((fn->fn_flags & RTN_RTINFO) == 0) {
@@ -248,6 +256,10 @@ static struct fib6_node * fib6_add_1(struct fib6_node *root, void *addr,
 				return fn;
 			}
 
+			/*
+			 *	We have more bits to go
+			 */
+			 
 			if (plen > fn->fn_bit) {
 				/* Walk down on tree. */
 				fn->fn_sernum = sernum;
@@ -255,6 +267,11 @@ static struct fib6_node * fib6_add_1(struct fib6_node *root, void *addr,
 				pn = fn;
 				fn = dir ? fn->right: fn->left;
 
+				/*
+				 *	Round we go. Note if fn has become
+				 *	NULL then dir is set and fn is handled
+				 *	top of loop.
+				 */
 				continue;
 			}
 		}
@@ -611,7 +628,8 @@ static struct rt6_info * fib6_find_prefix(struct fib6_node *fn)
 }
 
 /*
- *	called to trim the tree of intermediate nodes when possible
+ *	Called to trim the tree of intermediate nodes when possible. "fn"
+ *	is the node we want to try and remove.
  */
 
 static void fib6_del_2(struct fib6_node *fn)
@@ -621,6 +639,10 @@ static void fib6_del_2(struct fib6_node *fn)
 	fn->fn_flags &= ~RTN_RTINFO;
 	rt6_stats.fib_route_nodes--;
 
+	/*
+	 *	Can't delete a root node
+	 */
+	 
 	if (fn->fn_flags & RTN_TL_ROOT)
 		return;
 
@@ -630,43 +652,89 @@ static void fib6_del_2(struct fib6_node *fn)
 
 		child = NULL;
 
+		/*
+		 *	We have a child to left
+		 */
+		 
 		if (fn->left) {
 			children++;
 			child = fn->left;
 		}
 
+		/*
+		 *	To right
+		 */
+		 
 		if (fn->right) {
 			children++;
 			child = fn->right;
 		}
 
+		/*
+		 *	We can't tidy a case of two children.
+		 */
+		 
 		if (children > 1 || (fn->fn_flags & RTN_RTINFO))
 			break;
 
+		/*
+		 *	The node we plan to tidy has an stree. Talk about
+		 *	making life hard.
+		 */
+		 
 		if (fn->subtree)
 			goto stree_node;
 
+		/*
+		 *	Up we go
+		 */
+		 
 		pn = fn->parent;
 
+		/*
+		 *	Not a ROOT - we can tidy
+		 */
+		 
 		if ((fn->fn_flags & RTN_ROOT) == 0) {
+			/*
+			 *	Make our child our parents child
+			 */
 			if (pn->left == fn)
 				pn->left = child;
 			else
 				pn->right = child;
 
+			/*
+			 *	Reparent the child
+			 */
 			if (child)
 				child->parent = pn;
 
+			/*
+			 *	Discard leaf entries
+			 */
 			if (fn->leaf)
 				rt6_release(fn->leaf);
 		} else {
 			if (children)
 				break;
+			/*
+			 *	No children so no subtree
+			 */
 
 			pn->subtree = NULL;
 		}
 
+		/*
+		 *	We are discarding 
+		 */
 		node_free(fn);
+		
+		/*
+		 *	Our merge of entries might propogate further
+		 *	up the tree, so move up a level and retry.
+		 */
+		 
 		fn = pn;
 
 	} while (!(fn->fn_flags & RTN_TL_ROOT));
@@ -685,18 +753,29 @@ stree_node:
 	fn->leaf = rt;
 }
 
+/*
+ *	Remove our entry in the tree. This throws away the route entry
+ *	from the list of entries attached to this fib node. It doesn't
+ *	expunge from the tree.
+ */
+
 static struct fib6_node * fib6_del_1(struct rt6_info *rt)
 {
 	struct fib6_node *fn;
 	
 	fn = rt->rt6i_node;
 
+	/* We need a fib node! */
 	if (fn) {
 		struct rt6_info **back;
 		struct rt6_info *lf;
 
 		back = &fn->leaf;
 		
+		/*
+		 *	Walk the leaf entries looking for ourself
+		 */
+		 
 		for(lf = fn->leaf; lf; lf=lf->u.next) {
 			if (rt == lf) {
 				/*
diff --git a/net/ipv6/ip6_input.c b/net/ipv6/ip6_input.c
index cf107efcd..ad33e86a2 100644
--- a/net/ipv6/ip6_input.c
+++ b/net/ipv6/ip6_input.c
@@ -6,7 +6,7 @@
  *	Pedro Roque		<roque@di.fc.ul.pt>
  *	Ian P. Morris		<I.P.Morris@soton.ac.uk>
  *
- *	$Id: ip6_input.c,v 1.6 1997/05/11 16:06:52 davem Exp $
+ *	$Id: ip6_input.c,v 1.1.1.1 1997/06/01 03:16:27 ralf Exp $
  *
  *	Based in linux/net/ipv4/ip_input.c
  *
@@ -374,6 +374,9 @@ int ip6_mc_input(struct sk_buff *skb)
 	if (ipv6_chk_mcast_addr(skb->dev, &hdr->daddr))
 		deliver = 1;
 
+	/*
+	 *	IPv6 multicast router mode isnt currently supported.
+	 */
 #if 0
 	if (ipv6_config.multicast_route) {
 		int addr_type;
diff --git a/net/ipv6/ip6_output.c b/net/ipv6/ip6_output.c
index 6c14747eb..cafa5eafb 100644
--- a/net/ipv6/ip6_output.c
+++ b/net/ipv6/ip6_output.c
@@ -5,7 +5,7 @@
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>	
  *
- *	$Id: ip6_output.c,v 1.3 1997/03/18 18:24:37 davem Exp $
+ *	$Id: ip6_output.c,v 1.1.1.1 1997/06/01 03:16:27 ralf Exp $
  *
  *	Based on linux/net/ipv4/ip_output.c
  *
@@ -47,7 +47,9 @@ static void ipv6_build_mac_hdr(struct sk_buff *skb, struct dst_entry *dst,
 	
 	if (dev->hard_header) {
 		int mac;
-		
+
+		/* Maybe when Alexey has done his new magic I'll hack this
+		   it seems to be worth 1-2% on IPv4 */
 #if 0
 		if (dst->hh)
 			hh_copy_header(dst->hh, skb);
@@ -143,7 +145,7 @@ int ip6_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl,
 
 /*
  *	To avoid extra problems ND packets are send through this
- *	routine. It's code duplication but i really want to avoid
+ *	routine. It's code duplication but I really want to avoid
  *	extra checks since ipv6_build_header is used by TCP (which
  *	is for us performace critical)
  */
diff --git a/net/ipv6/route.c b/net/ipv6/route.c
index 1b4235dbd..612534930 100644
--- a/net/ipv6/route.c
+++ b/net/ipv6/route.c
@@ -5,7 +5,7 @@
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>	
  *
- *	$Id: route.c,v 1.1.1.1 1997/06/01 03:16:27 ralf Exp $
+ *	$Id: route.c,v 1.2 1997/08/06 19:16:57 miguel Exp $
  *
  *	This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
@@ -733,6 +733,25 @@ int ip6_del_rt(struct rt6_info *rt)
 
 int ip6_route_del(struct in6_rtmsg *rtmsg)
 {
+	struct rt6_info *rt;
+	struct device *dev=NULL;
+
+	/*
+	 *	Find device
+	 */
+	if(rtmsg->rtmsg_ifindex)
+		dev=dev_get_by_index(rtmsg->rtmsg_ifindex);
+	/*
+	 *	Find route
+	 */
+	rt=rt6_lookup(&rtmsg->rtmsg_dst, &rtmsg->rtmsg_src, dev, rtmsg->rtmsg_flags);
+	
+	/*
+	 *	Blow it away
+	 */
+	if(rt)
+		ip6_del_rt(rt);
+
 	return 0;
 }
 
diff --git a/net/netlink.c b/net/netlink.c
index f33c04040..9bf31a126 100644
--- a/net/netlink.c
+++ b/net/netlink.c
@@ -126,8 +126,7 @@ static long netlink_read(struct inode * inode, struct file * file, char * buf,
 	return err ? -EFAULT : count;
 }
 
-static loff_t netlink_lseek(struct inode * inode, struct file * file,
-			    loff_t offset, int origin)
+static long long netlink_lseek(struct file * file, long long offset, int origin)
 {
 	return -ESPIPE;
 }
diff --git a/net/socket.c b/net/socket.c
index ce8bb95c5..3405677cd 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -96,8 +96,7 @@
 #include <net/scm.h>
 
 
-static long long sock_lseek(struct inode *inode, struct file *file,
-			    long long offset, int whence);
+static long long sock_lseek(struct file *file, long long offset, int whence);
 static long sock_read(struct inode *inode, struct file *file,
 		      char *buf, unsigned long size);
 static long sock_write(struct inode *inode, struct file *file,
@@ -107,7 +106,7 @@ static int sock_close(struct inode *inode, struct file *file);
 static unsigned int sock_poll(struct file *file, poll_table *wait);
 static int sock_ioctl(struct inode *inode, struct file *file,
 		      unsigned int cmd, unsigned long arg);
-static int sock_fasync(struct inode *inode, struct file *filp, int on);
+static int sock_fasync(struct file *filp, int on);
 
 
 /*
@@ -353,8 +352,7 @@ int sock_recvmsg(struct socket *sock, struct msghdr *msg, int size, int flags)
  *	Sockets are not seekable.
  */
 
-static long long sock_lseek(struct inode *inode, struct file *file,
-			    long long offset, int whence)
+static long long sock_lseek(struct file *file,long long offset, int whence)
 {
 	return -ESPIPE;
 }
@@ -482,7 +480,7 @@ int sock_close(struct inode *inode, struct file *filp)
 		printk(KERN_DEBUG "sock_close: NULL inode\n");
 		return 0;
 	}
-	sock_fasync(inode, filp, 0);
+	sock_fasync(filp, 0);
 	sock_release(socki_lookup(inode));
 	return 0;
 }
@@ -491,7 +489,7 @@ int sock_close(struct inode *inode, struct file *filp)
  *	Update the socket async list
  */
  
-static int sock_fasync(struct inode *inode, struct file *filp, int on)
+static int sock_fasync(struct file *filp, int on)
 {
 	struct fasync_struct *fa, *fna=NULL, **prev;
 	struct socket *sock;
@@ -504,7 +502,7 @@ static int sock_fasync(struct inode *inode, struct file *filp, int on)
 			return -ENOMEM;
 	}
 
-	sock = socki_lookup(inode);
+	sock = socki_lookup(filp->f_dentry->d_inode);
 	
 	prev=&(sock->fasync_list);
 	
diff --git a/net/sunrpc/clnt.c b/net/sunrpc/clnt.c
index bcdb13610..971163963 100644
--- a/net/sunrpc/clnt.c
+++ b/net/sunrpc/clnt.c
@@ -352,7 +352,7 @@ call_allocate(struct rpc_task *task)
 	if ((task->tk_buffer = rpc_malloc(task, bufsiz)) != NULL)
 		return;
 
-	if (!signalled()) {
+	if (1 || !signalled()) {
 		xprt_release(task);
 		task->tk_action = call_reserve;
 		rpc_delay(task, HZ);
diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index 960093cad..fb02640f9 100644
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -390,7 +390,7 @@ __rpc_execute(struct rpc_task *task)
 			dprintk("RPC: %4d sync task going to sleep\n",
 							task->tk_pid);
 			current->timeout = 0;
-			interruptible_sleep_on(&task->tk_wait);
+			sleep_on(&task->tk_wait);
 
 			/* When the task received a signal, remove from
 			 * any queues etc, and make runnable again. */
@@ -408,7 +408,7 @@ __rpc_execute(struct rpc_task *task)
 		 * clean up after sleeping on some queue, we don't
 		 * break the loop here, but go around once more.
 		 */
-		if (!RPC_IS_ASYNC(task) && signalled()) {
+		if (0 && !RPC_IS_ASYNC(task) && signalled()) {
 			dprintk("RPC: %4d got signal (map %08lx)\n",
 				task->tk_pid,
 				current->signal & ~current->blocked);
diff --git a/net/sunrpc/sunrpc_syms.c b/net/sunrpc/sunrpc_syms.c
index 3e1d57873..b5495df93 100644
--- a/net/sunrpc/sunrpc_syms.c
+++ b/net/sunrpc/sunrpc_syms.c
@@ -74,7 +74,9 @@ EXPORT_SYMBOL(svc_wake_up);
 /* RPC statistics */
 #ifdef CONFIG_PROC_FS
 EXPORT_SYMBOL(rpc_proc_register);
+EXPORT_SYMBOL(rpc_register_sysctl);
 EXPORT_SYMBOL(rpc_proc_unregister);
+EXPORT_SYMBOL(rpc_proc_init);
 EXPORT_SYMBOL(rpc_proc_read);
 EXPORT_SYMBOL(svc_proc_register);
 EXPORT_SYMBOL(svc_proc_unregister);
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 62d2d7b40..87a5ed82e 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -750,7 +750,7 @@ again:
 		rqstp->rq_wait = NULL;
 		svc_serv_enqueue(serv, rqstp);
 
-		current->state = TASK_INTERRUPTIBLE;
+		current->state = TASK_UNINTERRUPTIBLE;
 		add_wait_queue(&rqstp->rq_wait, &wait);
 		enable_bh(NET_BH);
 		schedule();
diff --git a/net/sunrpc/xprt.c b/net/sunrpc/xprt.c
index dc4fd0515..0372500ee 100644
--- a/net/sunrpc/xprt.c
+++ b/net/sunrpc/xprt.c
@@ -1073,6 +1073,7 @@ xprt_release(struct rpc_task *task)
 
 	if (!(req = task->tk_rqstp))
 		return;
+	task->tk_rqstp = NULL;
 	memset(req, 0, sizeof(*req));	/* mark unused */
 
 	dprintk("RPC: %4d release request %p\n", task->tk_pid, req);
diff --git a/net/unix/garbage.c b/net/unix/garbage.c
index 02fafc7f6..d68f018fd 100644
--- a/net/unix/garbage.c
+++ b/net/unix/garbage.c
@@ -35,31 +35,20 @@
  */
  
 #include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/signal.h>
 #include <linux/sched.h>
-#include <linux/errno.h>
 #include <linux/string.h>
-#include <linux/stat.h>
 #include <linux/socket.h>
 #include <linux/un.h>
-#include <linux/fcntl.h>
-#include <linux/termios.h>
-#include <linux/socket.h>
-#include <linux/sockios.h>
 #include <linux/net.h>
-#include <linux/in.h>
 #include <linux/fs.h>
 #include <linux/malloc.h>
-#include <linux/vmalloc.h>
-
-#include <asm/uaccess.h>
 #include <linux/skbuff.h>
 #include <linux/netdevice.h>
 #include <net/sock.h>
 #include <net/tcp.h>
 #include <net/af_unix.h>
 #include <linux/proc_fs.h>
+#include <linux/vmalloc.h>
 #include <net/scm.h>
 
 /* Internal data structures and random procedures: */