diff --git a/sys/netatalk/at_extern.h b/sys/netatalk/at_extern.h
index bed1022c4a1d..7e9478f13af8 100644
--- a/sys/netatalk/at_extern.h
+++ b/sys/netatalk/at_extern.h
@@ -1,41 +1,43 @@
 
 #ifdef _NETINET_IF_ETHER_H_
 extern void	aarpprobe	__P((struct arpcom *));
 extern int	aarpresolve	__P((struct arpcom *,
 					struct mbuf *,
 					struct sockaddr_at *,
 					u_char *));
 extern void	aarpinput	__P(( struct arpcom *, struct mbuf *));
 extern int	at_broadcast	__P((struct sockaddr_at  *));
 #endif
 
 #ifdef _NETATALK_AARP_H_
 extern void	aarptfree	__P((struct aarptab *));
 #endif
 
 extern void	aarp_clean	__P((void));
 extern int	at_control	__P(( int cmd,
 					caddr_t data,
 					struct ifnet *ifp,
 					struct proc *p ));
 extern u_short	at_cksum	__P(( struct mbuf *m, int skip));
 extern int	ddp_usrreq	__P(( struct socket *so, int req,
 					struct mbuf *m,
 					struct mbuf  *addr,
 					struct mbuf *rights));
 extern void	ddp_init	__P((void ));
 extern struct ifaddr *at_ifawithnet	__P((struct sockaddr_at *,
 						struct ifaddrhead *));
 #ifdef	_NETATALK_DDP_VAR_H_
-extern int	ddp_output	__P(( struct ddpcb *ddp, struct mbuf *m));
+extern int     ddp_output    __P((struct mbuf *m, struct socket *so)); 
+
+/*extern int	ddp_output	__P(( struct ddpcb *ddp, struct mbuf *m));*/
 #endif
 #if	defined (_NETATALK_DDP_VAR_H_) && defined(_NETATALK_AT_VAR_H_)
 extern struct ddpcb  *ddp_search __P((struct sockaddr_at *,
                                 		struct sockaddr_at *,
 						struct at_ifaddr *));
 #endif
 #ifdef _NET_ROUTE_H_
 int     ddp_route( struct mbuf *m, struct route *ro);
 #endif
 
 
diff --git a/sys/netatalk/ddp_output.c b/sys/netatalk/ddp_output.c
index c5df8457086e..34f010b8720d 100644
--- a/sys/netatalk/ddp_output.c
+++ b/sys/netatalk/ddp_output.c
@@ -1,178 +1,181 @@
 /*
  * Copyright (c) 1990,1991 Regents of The University of Michigan.
  * All Rights Reserved.
  *
  * Permission to use, copy, modify, and distribute this software and
  * its documentation for any purpose and without fee is hereby granted,
  * provided that the above copyright notice appears in all copies and
  * that both that copyright notice and this permission notice appear
  * in supporting documentation, and that the name of The University
  * of Michigan not be used in advertising or publicity pertaining to
  * distribution of the software without specific, written prior
  * permission. This software is supplied as is without expressed or
  * implied warranties of any kind.
  *
  *	Research Systems Unix Group
  *	The University of Michigan
  *	c/o Mike Clark
  *	535 W. William Street
  *	Ann Arbor, Michigan
  *	+1-313-763-0525
  *	netatalk@itd.umich.edu
  */
 
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mbuf.h>
 #include <sys/socket.h>
+#include <sys/socketvar.h>
 #include <sys/errno.h>
 #include <sys/syslog.h>
 
 #include <net/if.h>
 #include <net/route.h>
 
 #include <netinet/in.h>
 #undef s_net
 #include <netinet/if_ether.h>
 
 #include <netatalk/at.h>
 #include <netatalk/at_var.h>
 #include <netatalk/endian.h>
 #include <netatalk/ddp.h>
 #include <netatalk/ddp_var.h>
 #include <netatalk/at_extern.h>
 
 int	ddp_cksum = 1;
 
 int
-ddp_output( struct ddpcb *ddp, struct mbuf *m)
+/*ddp_output( struct ddpcb *ddp, struct mbuf *m)*/
+ddp_output( struct mbuf *m, struct socket *so)
 {
     struct ddpehdr	*deh;
+    struct ddpcb *ddp = sotoddpcb( so );
 
     M_PREPEND( m, sizeof( struct ddpehdr ), M_WAIT );
 
     deh = mtod( m, struct ddpehdr *);
     deh->deh_pad = 0;
     deh->deh_hops = 0;
 
     deh->deh_len = m->m_pkthdr.len;
 
     deh->deh_dnet = ddp->ddp_fsat.sat_addr.s_net;
     deh->deh_dnode = ddp->ddp_fsat.sat_addr.s_node;
     deh->deh_dport = ddp->ddp_fsat.sat_port;
     deh->deh_snet = ddp->ddp_lsat.sat_addr.s_net;
     deh->deh_snode = ddp->ddp_lsat.sat_addr.s_node;
     deh->deh_sport = ddp->ddp_lsat.sat_port;
 
     /*
      * The checksum calculation is done after all of the other bytes have
      * been filled in.
      */
     if ( ddp_cksum ) {
 	deh->deh_sum = at_cksum( m, sizeof( int ));
     } else {
 	deh->deh_sum = 0;
     }
     deh->deh_bytes = htonl( deh->deh_bytes );
 
     return( ddp_route( m, &ddp->ddp_route ));
 }
 
 u_short
 at_cksum( struct mbuf *m, int skip)
 {
     u_char	*data, *end;
     u_long	cksum = 0;
 
     for (; m; m = m->m_next ) {
 	for ( data = mtod( m, u_char * ), end = data + m->m_len; data < end;
 		data++ ) {
 	    if ( skip ) {
 		skip--;
 		continue;
 	    }
 	    cksum = ( cksum + *data ) << 1;
 	    if ( cksum & 0x00010000 ) {
 		cksum++;
 	    }
 	    cksum &= 0x0000ffff;
 	}
     }
 
     if ( cksum == 0 ) {
 	cksum = 0x0000ffff;
     }
     return( (u_short)cksum );
 }
 
 int
 ddp_route( struct mbuf *m, struct route *ro)
 {
     struct sockaddr_at	gate;
     struct elaphdr	*elh;
     struct mbuf		*m0;
     struct at_ifaddr	*aa = NULL;
     struct ifnet	*ifp = NULL;
     u_short		net;
 
     if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
 	net = satosat( ro->ro_rt->rt_gateway )->sat_addr.s_net;
 	for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 	    if ( aa->aa_ifp == ifp &&
 		    ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
 		    ntohs( net ) <= ntohs( aa->aa_lastnet )) {
 		break;
 	    }
 	}
     }
     if ( aa == NULL ) {
 printf( "ddp_route: oops\n" );
 	m_freem( m );
 	return( EINVAL );
     }
 
     /*
      * There are several places in the kernel where data is added to
      * an mbuf without ensuring that the mbuf pointer is aligned.
      * This is bad for transition routing, since phase 1 and phase 2
      * packets end up poorly aligned due to the three byte elap header.
      */
     if ( !(aa->aa_flags & AFA_PHASE2) ) {
 	MGET( m0, M_WAIT, MT_HEADER );
 	if ( m0 == 0 ) {
 	    m_freem( m );
 	    printf("ddp_route: no buffers\n");
 	    return( ENOBUFS );
 	}
 	m0->m_next = m;
 	/* XXX perhaps we ought to align the header? */
 	m0->m_len = SZ_ELAPHDR;
 	m = m0;
 
 	elh = mtod( m, struct elaphdr *);
 	elh->el_snode = satosat( &aa->aa_addr )->sat_addr.s_node;
 	elh->el_type = ELAP_DDPEXTEND;
 	if ( ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) >=
 		ntohs( aa->aa_firstnet ) &&
 		ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) <=
 		ntohs( aa->aa_lastnet )) {
 	    elh->el_dnode = satosat( &ro->ro_dst )->sat_addr.s_node;
 	} else {
 	    elh->el_dnode = satosat( ro->ro_rt->rt_gateway )->sat_addr.s_node;
 	}
     }
 
     if ( ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) >=
 	    ntohs( aa->aa_firstnet ) &&
 	    ntohs( satosat( &ro->ro_dst )->sat_addr.s_net ) <=
 	    ntohs( aa->aa_lastnet )) {
 	gate = *satosat( &ro->ro_dst );
     } else {
 	gate = *satosat( ro->ro_rt->rt_gateway );
     }
     ro->ro_rt->rt_use++;
 
     return((*ifp->if_output)( ifp,
 	m, (struct sockaddr *)&gate, NULL)); /* XXX */
 }
diff --git a/sys/netatalk/ddp_pcb.c b/sys/netatalk/ddp_pcb.c
index 7a89a9481e57..3f03a306343c 100644
--- a/sys/netatalk/ddp_pcb.c
+++ b/sys/netatalk/ddp_pcb.c
@@ -1,527 +1,527 @@
 /*
  * Copyright (c) 1990,1994 Regents of The University of Michigan.
  * All Rights Reserved.  See COPYRIGHT.
  */
 
 #include <sys/errno.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/protosw.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 
 #include <netatalk/at.h>
 #include <netatalk/at_var.h>
 #include <netatalk/ddp_var.h>
 #include <netatalk/aarp.h>
 #include <netatalk/endian.h>
 #include <netatalk/at_extern.h>
 
 static void at_pcbdisconnect( struct ddpcb *ddp );
 static void at_sockaddr( struct ddpcb *ddp, struct mbuf *addr );
 static int at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
 static int at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
 static void at_pcbdetach( struct socket *so, struct ddpcb *ddp);
 static int at_pcballoc( struct socket *so );
 
 struct ddpcb	*ddp_ports[ ATPORT_LAST ];
 struct ddpcb	*ddpcb = NULL;
 u_long		ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
 u_long		ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
 
 /*ARGSUSED*/
 int
 ddp_usrreq( struct socket *so, int req, struct mbuf *m,
 		struct mbuf  *addr, struct mbuf *rights)
 {
     struct proc *p = curproc;           /* XXX */
     struct ddpcb	*ddp;
     int			error = 0;
 
     ddp = sotoddpcb( so );
 
     if ( req == PRU_CONTROL ) {
 	return( at_control( (int) m, (caddr_t) addr,
 		(struct ifnet *) rights, (struct proc *)p ));
     }
 
     if ( rights && rights->m_len ) {
 	error = EINVAL;
 	goto release;
     }
 
     if ( ddp == NULL && req != PRU_ATTACH ) {
 	error = EINVAL;
 	goto release;
     }
 
     switch ( req ) {
     case PRU_ATTACH :
 	if ( ddp != NULL ) {
 	    error = EINVAL;
 	    break;
 	}
 	if (( error = at_pcballoc( so )) != 0 ) {
 	    break;
 	}
 	error = soreserve( so, ddp_sendspace, ddp_recvspace );
 	break;
 
     case PRU_DETACH :
 	at_pcbdetach( so, ddp );
 	break;
 
     case PRU_BIND :
 	error = at_pcbsetaddr( ddp, addr, p );
 	break;
     
     case PRU_SOCKADDR :
 	at_sockaddr( ddp, addr );
 	break;
 
     case PRU_CONNECT:
 	if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 	    error = EISCONN;
 	    break;
 	}
 
 	error = at_pcbconnect( ddp, addr, p );
 	if ( error == 0 )
 	    soisconnected( so );
 	break;
 
     case PRU_DISCONNECT:
 	if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
 	    error = ENOTCONN;
 	    break;
 	}
 	at_pcbdisconnect( ddp );
 	soisdisconnected( so );
 	break;
 
     case PRU_SHUTDOWN:
 	socantsendmore( so );
 	break;
 
     case PRU_SEND: {
 	int	s = 0;
 
 	if ( addr ) {
 	    if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 		error = EISCONN;
 		break;
 	    }
 
 	    s = splnet();
 	    error = at_pcbconnect( ddp, addr, p );
 	    if ( error ) {
 		splx( s );
 		break;
 	    }
 	} else {
 	    if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
 		error = ENOTCONN;
 		break;
 	    }
 	}
 
-	error = ddp_output( ddp, m );
+	error = ddp_output( m, so );
 	m = NULL;
 	if ( addr ) {
 	    at_pcbdisconnect( ddp );
 	    splx( s );
 	}
 	}
 	break;
 
     case PRU_ABORT:
 	soisdisconnected( so );
 	at_pcbdetach( so, ddp );
 	break;
 
     case PRU_LISTEN:
     case PRU_CONNECT2:
     case PRU_ACCEPT:
     case PRU_SENDOOB:
     case PRU_FASTTIMO:
     case PRU_SLOWTIMO:
     case PRU_PROTORCV:
     case PRU_PROTOSEND:
 	error = EOPNOTSUPP;
 	break;
 
     case PRU_RCVD:
     case PRU_RCVOOB:
 	/*
 	 * Don't mfree. Good architecture...
 	 */
 	return( EOPNOTSUPP );
 
     case PRU_SENSE:
 	/*
 	 * 1. Don't return block size.
 	 * 2. Don't mfree.
 	 */
 	return( 0 );
 
     default:
 	error = EOPNOTSUPP;
     }
 
 release:
     if ( m != NULL ) {
 	m_freem( m );
     }
     return( error );
 }
 
 static void
 at_sockaddr( struct ddpcb *ddp, struct mbuf *addr)
 {
     struct sockaddr_at	*sat;
 
     addr->m_len = sizeof( struct sockaddr_at );
     sat = mtod( addr, struct sockaddr_at *);
     *sat = ddp->ddp_lsat;
 }
 
 static int 
 at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p )
 {
     struct sockaddr_at	lsat, *sat;
     struct at_ifaddr	*aa;
     struct ddpcb	*ddpp;
 
     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
 	return( EINVAL );
     }
 
     if ( addr != 0 ) {			/* validate passed address */
 	sat = mtod( addr, struct sockaddr_at *);
 	if ( addr->m_len != sizeof( *sat )) {
 	    return( EINVAL );
 	}
 	if ( sat->sat_family != AF_APPLETALK ) {
 	    return( EAFNOSUPPORT );
 	}
 
 	if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
 		sat->sat_addr.s_net != ATADDR_ANYNET ) {
 	    for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 		if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
 		 ( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
 		    break;
 		}
 	    }
 	    if ( !aa ) {
 		return( EADDRNOTAVAIL );
 	    }
 	}
 
 	if ( sat->sat_port != ATADDR_ANYPORT ) {
 	    if ( sat->sat_port < ATPORT_FIRST ||
 		    sat->sat_port >= ATPORT_LAST ) {
 		return( EINVAL );
 	    }
 	    if ( sat->sat_port < ATPORT_RESERVED &&
 		 suser( p->p_ucred, &p->p_acflag ) ) {
 		return( EACCES );
 	    }
 	}
     } else {
 	bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
 	lsat.sat_len = sizeof(struct sockaddr_at);
 	lsat.sat_addr.s_node = ATADDR_ANYNODE;
 	lsat.sat_addr.s_net = ATADDR_ANYNET;
 	lsat.sat_family = AF_APPLETALK;
 	sat = &lsat;
     }
 
     if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
 	    sat->sat_addr.s_net == ATADDR_ANYNET ) {
 	if ( at_ifaddr == NULL ) {
 	    return( EADDRNOTAVAIL );
 	}
 	sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
     }
     ddp->ddp_lsat = *sat;
 
     /*
      * Choose port.
      */
     if ( sat->sat_port == ATADDR_ANYPORT ) {
 	for ( sat->sat_port = ATPORT_RESERVED;
 		sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
 	    if ( ddp_ports[ sat->sat_port - 1 ] == 0 ) {
 		break;
 	    }
 	}
 	if ( sat->sat_port == ATPORT_LAST ) {
 	    return( EADDRNOTAVAIL );
 	}
 	ddp->ddp_lsat.sat_port = sat->sat_port;
 	ddp_ports[ sat->sat_port - 1 ] = ddp;
     } else {
 	for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
 		ddpp = ddpp->ddp_pnext ) {
 	    if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
 		    ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
 		break;
 	    }
 	}
 	if ( ddpp != NULL ) {
 	    return( EADDRINUSE );
 	}
 	ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
 	ddp_ports[ sat->sat_port - 1 ] = ddp;
 	if ( ddp->ddp_pnext ) {
 	    ddp->ddp_pnext->ddp_pprev = ddp;
 	}
     }
 
     return( 0 );
 }
 
 static int
 at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p)
 {
     struct sockaddr_at	*sat = mtod( addr, struct sockaddr_at *);
     struct route	*ro;
     struct at_ifaddr	*aa = 0;
     struct ifnet	*ifp;
     u_short		hintnet = 0, net;
 
     if ( addr->m_len != sizeof( *sat ))
 	return( EINVAL );
     if ( sat->sat_family != AF_APPLETALK ) {
 	return( EAFNOSUPPORT );
     }
 
     /*
      * Under phase 2, network 0 means "the network".  We take "the
      * network" to mean the network the control block is bound to.
      * If the control block is not bound, there is an error.
      */
     if ( sat->sat_addr.s_net == ATADDR_ANYNET
 		&& sat->sat_addr.s_node != ATADDR_ANYNODE ) {
 	if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 	    return( EADDRNOTAVAIL );
 	}
 	hintnet = ddp->ddp_lsat.sat_addr.s_net;
     }
 
     ro = &ddp->ddp_route;
     /*
      * If we've got an old route for this pcb, check that it is valid.
      * If we've changed our address, we may have an old "good looking"
      * route here.  Attempt to detect it.
      */
     if ( ro->ro_rt ) {
 	if ( hintnet ) {
 	    net = hintnet;
 	} else {
 	    net = sat->sat_addr.s_net;
 	}
 	aa = 0;
 	if ( ifp = ro->ro_rt->rt_ifp ) {
 	    for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 		if ( aa->aa_ifp == ifp &&
 			ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
 			ntohs( net ) <= ntohs( aa->aa_lastnet )) {
 		    break;
 		}
 	    }
 	}
 	if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
 		( hintnet ? hintnet : sat->sat_addr.s_net ) ||
 		satosat( &ro->ro_dst )->sat_addr.s_node !=
 		sat->sat_addr.s_node )) {
 	    RTFREE( ro->ro_rt );
 	    ro->ro_rt = (struct rtentry *)0;
 	}
     }
 
     /*
      * If we've got no route for this interface, try to find one.
      */
     if ( ro->ro_rt == (struct rtentry *)0 ||
 	 ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
 	ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
 	ro->ro_dst.sa_family = AF_APPLETALK;
 	if ( hintnet ) {
 	    satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
 	} else {
 	    satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
 	}
 	satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
 	rtalloc( ro );
     }
 
     /*
      * Make sure any route that we have has a valid interface.
      */
     aa = 0;
     if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
 	for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 	    if ( aa->aa_ifp == ifp ) {
 		break;
 	    }
 	}
     }
     if ( aa == 0 ) {
 	return( ENETUNREACH );
     }
 
     ddp->ddp_fsat = *sat;
     if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 	return( at_pcbsetaddr( ddp, (struct mbuf *)0, p ));
     }
     return( 0 );
 }
 
 static void 
 at_pcbdisconnect( struct ddpcb	*ddp )
 {
     ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
     ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
     ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
 }
 
 static int
 at_pcballoc( struct socket *so )
 {
     struct ddpcb	*ddp;
     struct mbuf		*m;
 
     m = m_getclr( M_WAIT, MT_PCB );
     ddp = mtod( m, struct ddpcb * );
     ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
 
     ddp->ddp_next = ddpcb;
     ddp->ddp_prev = NULL;
     ddp->ddp_pprev = NULL;
     ddp->ddp_pnext = NULL;
     if ( ddpcb ) {
 	ddpcb->ddp_prev = ddp;
     }
     ddpcb = ddp;
 
     ddp->ddp_socket = so;
     so->so_pcb = (caddr_t)ddp;
     return( 0 );
 }
 
 static void
 at_pcbdetach( struct socket *so, struct ddpcb *ddp)
 {
     soisdisconnected( so );
     so->so_pcb = 0;
     sofree( so );
 
     /* remove ddp from ddp_ports list */
     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
 	    ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
 	if ( ddp->ddp_pprev != NULL ) {
 	    ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
 	} else {
 	    ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
 	}
 	if ( ddp->ddp_pnext != NULL ) {
 	    ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
 	}
     }
 
     if ( ddp->ddp_route.ro_rt ) {
 	rtfree( ddp->ddp_route.ro_rt );
     }
 
     if ( ddp->ddp_prev ) {
 	ddp->ddp_prev->ddp_next = ddp->ddp_next;
     } else {
 	ddpcb = ddp->ddp_next;
     }
     if ( ddp->ddp_next ) {
 	ddp->ddp_next->ddp_prev = ddp->ddp_prev;
     }
 
     (void) m_free( dtom( ddp ));
 }
 
 /*
  * For the moment, this just find the pcb with the correct local address.
  * In the future, this will actually do some real searching, so we can use
  * the sender's address to do de-multiplexing on a single port to many
  * sockets (pcbs).
  */
 struct ddpcb *
 ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
 			struct at_ifaddr *aa)
 {
     struct ddpcb	*ddp;
 
     /*
      * Check for bad ports.
      */
     if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
 	return( NULL );
     }
 
     /*
      * Make sure the local address matches the sent address.  What about
      * the interface?
      */
     for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
 	/* XXX should we handle 0.YY? */
 
 	/* XXXX.YY to socket on destination interface */
 	if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
 		to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
 	    break;
 	}
 
 	/* 0.255 to socket on receiving interface */
 	if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
 		to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
 		ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
 	    break;
 	}
 
 	/* XXXX.0 to socket on destination interface */
 	if ( to->sat_addr.s_net == aa->aa_firstnet &&
 		to->sat_addr.s_node == 0 &&
 		ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
 		ntohs( aa->aa_firstnet ) &&
 		ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
 		ntohs( aa->aa_lastnet )) {
 	    break;
 	}
     }
     return( ddp );
 }
 
 void 
 ddp_init(void )
 {
     atintrq1.ifq_maxlen = IFQ_MAXLEN;
     atintrq2.ifq_maxlen = IFQ_MAXLEN;
 }
 
 #if 0
 static void 
 ddp_clean(void )
 {
     struct ddpcb	*ddp;
 
     for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
 	at_pcbdetach( ddp->ddp_socket, ddp );
     }
 }
 #endif
diff --git a/sys/netatalk/ddp_usrreq.c b/sys/netatalk/ddp_usrreq.c
index 7a89a9481e57..3f03a306343c 100644
--- a/sys/netatalk/ddp_usrreq.c
+++ b/sys/netatalk/ddp_usrreq.c
@@ -1,527 +1,527 @@
 /*
  * Copyright (c) 1990,1994 Regents of The University of Michigan.
  * All Rights Reserved.  See COPYRIGHT.
  */
 
 #include <sys/errno.h>
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mbuf.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/protosw.h>
 #include <net/if.h>
 #include <net/route.h>
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 
 #include <netatalk/at.h>
 #include <netatalk/at_var.h>
 #include <netatalk/ddp_var.h>
 #include <netatalk/aarp.h>
 #include <netatalk/endian.h>
 #include <netatalk/at_extern.h>
 
 static void at_pcbdisconnect( struct ddpcb *ddp );
 static void at_sockaddr( struct ddpcb *ddp, struct mbuf *addr );
 static int at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
 static int at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p);
 static void at_pcbdetach( struct socket *so, struct ddpcb *ddp);
 static int at_pcballoc( struct socket *so );
 
 struct ddpcb	*ddp_ports[ ATPORT_LAST ];
 struct ddpcb	*ddpcb = NULL;
 u_long		ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
 u_long		ddp_recvspace = 10 * ( 587 + sizeof( struct sockaddr_at ));
 
 /*ARGSUSED*/
 int
 ddp_usrreq( struct socket *so, int req, struct mbuf *m,
 		struct mbuf  *addr, struct mbuf *rights)
 {
     struct proc *p = curproc;           /* XXX */
     struct ddpcb	*ddp;
     int			error = 0;
 
     ddp = sotoddpcb( so );
 
     if ( req == PRU_CONTROL ) {
 	return( at_control( (int) m, (caddr_t) addr,
 		(struct ifnet *) rights, (struct proc *)p ));
     }
 
     if ( rights && rights->m_len ) {
 	error = EINVAL;
 	goto release;
     }
 
     if ( ddp == NULL && req != PRU_ATTACH ) {
 	error = EINVAL;
 	goto release;
     }
 
     switch ( req ) {
     case PRU_ATTACH :
 	if ( ddp != NULL ) {
 	    error = EINVAL;
 	    break;
 	}
 	if (( error = at_pcballoc( so )) != 0 ) {
 	    break;
 	}
 	error = soreserve( so, ddp_sendspace, ddp_recvspace );
 	break;
 
     case PRU_DETACH :
 	at_pcbdetach( so, ddp );
 	break;
 
     case PRU_BIND :
 	error = at_pcbsetaddr( ddp, addr, p );
 	break;
     
     case PRU_SOCKADDR :
 	at_sockaddr( ddp, addr );
 	break;
 
     case PRU_CONNECT:
 	if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 	    error = EISCONN;
 	    break;
 	}
 
 	error = at_pcbconnect( ddp, addr, p );
 	if ( error == 0 )
 	    soisconnected( so );
 	break;
 
     case PRU_DISCONNECT:
 	if ( ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE ) {
 	    error = ENOTCONN;
 	    break;
 	}
 	at_pcbdisconnect( ddp );
 	soisdisconnected( so );
 	break;
 
     case PRU_SHUTDOWN:
 	socantsendmore( so );
 	break;
 
     case PRU_SEND: {
 	int	s = 0;
 
 	if ( addr ) {
 	    if ( ddp->ddp_fsat.sat_port != ATADDR_ANYPORT ) {
 		error = EISCONN;
 		break;
 	    }
 
 	    s = splnet();
 	    error = at_pcbconnect( ddp, addr, p );
 	    if ( error ) {
 		splx( s );
 		break;
 	    }
 	} else {
 	    if ( ddp->ddp_fsat.sat_port == ATADDR_ANYPORT ) {
 		error = ENOTCONN;
 		break;
 	    }
 	}
 
-	error = ddp_output( ddp, m );
+	error = ddp_output( m, so );
 	m = NULL;
 	if ( addr ) {
 	    at_pcbdisconnect( ddp );
 	    splx( s );
 	}
 	}
 	break;
 
     case PRU_ABORT:
 	soisdisconnected( so );
 	at_pcbdetach( so, ddp );
 	break;
 
     case PRU_LISTEN:
     case PRU_CONNECT2:
     case PRU_ACCEPT:
     case PRU_SENDOOB:
     case PRU_FASTTIMO:
     case PRU_SLOWTIMO:
     case PRU_PROTORCV:
     case PRU_PROTOSEND:
 	error = EOPNOTSUPP;
 	break;
 
     case PRU_RCVD:
     case PRU_RCVOOB:
 	/*
 	 * Don't mfree. Good architecture...
 	 */
 	return( EOPNOTSUPP );
 
     case PRU_SENSE:
 	/*
 	 * 1. Don't return block size.
 	 * 2. Don't mfree.
 	 */
 	return( 0 );
 
     default:
 	error = EOPNOTSUPP;
     }
 
 release:
     if ( m != NULL ) {
 	m_freem( m );
     }
     return( error );
 }
 
 static void
 at_sockaddr( struct ddpcb *ddp, struct mbuf *addr)
 {
     struct sockaddr_at	*sat;
 
     addr->m_len = sizeof( struct sockaddr_at );
     sat = mtod( addr, struct sockaddr_at *);
     *sat = ddp->ddp_lsat;
 }
 
 static int 
 at_pcbsetaddr( struct ddpcb *ddp, struct mbuf *addr, struct proc *p )
 {
     struct sockaddr_at	lsat, *sat;
     struct at_ifaddr	*aa;
     struct ddpcb	*ddpp;
 
     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT ) { /* shouldn't be bound */
 	return( EINVAL );
     }
 
     if ( addr != 0 ) {			/* validate passed address */
 	sat = mtod( addr, struct sockaddr_at *);
 	if ( addr->m_len != sizeof( *sat )) {
 	    return( EINVAL );
 	}
 	if ( sat->sat_family != AF_APPLETALK ) {
 	    return( EAFNOSUPPORT );
 	}
 
 	if ( sat->sat_addr.s_node != ATADDR_ANYNODE ||
 		sat->sat_addr.s_net != ATADDR_ANYNET ) {
 	    for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 		if (( sat->sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) &&
 		 ( sat->sat_addr.s_node == AA_SAT( aa )->sat_addr.s_node )) {
 		    break;
 		}
 	    }
 	    if ( !aa ) {
 		return( EADDRNOTAVAIL );
 	    }
 	}
 
 	if ( sat->sat_port != ATADDR_ANYPORT ) {
 	    if ( sat->sat_port < ATPORT_FIRST ||
 		    sat->sat_port >= ATPORT_LAST ) {
 		return( EINVAL );
 	    }
 	    if ( sat->sat_port < ATPORT_RESERVED &&
 		 suser( p->p_ucred, &p->p_acflag ) ) {
 		return( EACCES );
 	    }
 	}
     } else {
 	bzero( (caddr_t)&lsat, sizeof( struct sockaddr_at ));
 	lsat.sat_len = sizeof(struct sockaddr_at);
 	lsat.sat_addr.s_node = ATADDR_ANYNODE;
 	lsat.sat_addr.s_net = ATADDR_ANYNET;
 	lsat.sat_family = AF_APPLETALK;
 	sat = &lsat;
     }
 
     if ( sat->sat_addr.s_node == ATADDR_ANYNODE &&
 	    sat->sat_addr.s_net == ATADDR_ANYNET ) {
 	if ( at_ifaddr == NULL ) {
 	    return( EADDRNOTAVAIL );
 	}
 	sat->sat_addr = AA_SAT( at_ifaddr )->sat_addr;
     }
     ddp->ddp_lsat = *sat;
 
     /*
      * Choose port.
      */
     if ( sat->sat_port == ATADDR_ANYPORT ) {
 	for ( sat->sat_port = ATPORT_RESERVED;
 		sat->sat_port < ATPORT_LAST; sat->sat_port++ ) {
 	    if ( ddp_ports[ sat->sat_port - 1 ] == 0 ) {
 		break;
 	    }
 	}
 	if ( sat->sat_port == ATPORT_LAST ) {
 	    return( EADDRNOTAVAIL );
 	}
 	ddp->ddp_lsat.sat_port = sat->sat_port;
 	ddp_ports[ sat->sat_port - 1 ] = ddp;
     } else {
 	for ( ddpp = ddp_ports[ sat->sat_port - 1 ]; ddpp;
 		ddpp = ddpp->ddp_pnext ) {
 	    if ( ddpp->ddp_lsat.sat_addr.s_net == sat->sat_addr.s_net &&
 		    ddpp->ddp_lsat.sat_addr.s_node == sat->sat_addr.s_node ) {
 		break;
 	    }
 	}
 	if ( ddpp != NULL ) {
 	    return( EADDRINUSE );
 	}
 	ddp->ddp_pnext = ddp_ports[ sat->sat_port - 1 ];
 	ddp_ports[ sat->sat_port - 1 ] = ddp;
 	if ( ddp->ddp_pnext ) {
 	    ddp->ddp_pnext->ddp_pprev = ddp;
 	}
     }
 
     return( 0 );
 }
 
 static int
 at_pcbconnect( struct ddpcb *ddp, struct mbuf *addr, struct proc *p)
 {
     struct sockaddr_at	*sat = mtod( addr, struct sockaddr_at *);
     struct route	*ro;
     struct at_ifaddr	*aa = 0;
     struct ifnet	*ifp;
     u_short		hintnet = 0, net;
 
     if ( addr->m_len != sizeof( *sat ))
 	return( EINVAL );
     if ( sat->sat_family != AF_APPLETALK ) {
 	return( EAFNOSUPPORT );
     }
 
     /*
      * Under phase 2, network 0 means "the network".  We take "the
      * network" to mean the network the control block is bound to.
      * If the control block is not bound, there is an error.
      */
     if ( sat->sat_addr.s_net == ATADDR_ANYNET
 		&& sat->sat_addr.s_node != ATADDR_ANYNODE ) {
 	if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 	    return( EADDRNOTAVAIL );
 	}
 	hintnet = ddp->ddp_lsat.sat_addr.s_net;
     }
 
     ro = &ddp->ddp_route;
     /*
      * If we've got an old route for this pcb, check that it is valid.
      * If we've changed our address, we may have an old "good looking"
      * route here.  Attempt to detect it.
      */
     if ( ro->ro_rt ) {
 	if ( hintnet ) {
 	    net = hintnet;
 	} else {
 	    net = sat->sat_addr.s_net;
 	}
 	aa = 0;
 	if ( ifp = ro->ro_rt->rt_ifp ) {
 	    for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 		if ( aa->aa_ifp == ifp &&
 			ntohs( net ) >= ntohs( aa->aa_firstnet ) &&
 			ntohs( net ) <= ntohs( aa->aa_lastnet )) {
 		    break;
 		}
 	    }
 	}
 	if ( aa == NULL || ( satosat( &ro->ro_dst )->sat_addr.s_net !=
 		( hintnet ? hintnet : sat->sat_addr.s_net ) ||
 		satosat( &ro->ro_dst )->sat_addr.s_node !=
 		sat->sat_addr.s_node )) {
 	    RTFREE( ro->ro_rt );
 	    ro->ro_rt = (struct rtentry *)0;
 	}
     }
 
     /*
      * If we've got no route for this interface, try to find one.
      */
     if ( ro->ro_rt == (struct rtentry *)0 ||
 	 ro->ro_rt->rt_ifp == (struct ifnet *)0 ) {
 	ro->ro_dst.sa_len = sizeof( struct sockaddr_at );
 	ro->ro_dst.sa_family = AF_APPLETALK;
 	if ( hintnet ) {
 	    satosat( &ro->ro_dst )->sat_addr.s_net = hintnet;
 	} else {
 	    satosat( &ro->ro_dst )->sat_addr.s_net = sat->sat_addr.s_net;
 	}
 	satosat( &ro->ro_dst )->sat_addr.s_node = sat->sat_addr.s_node;
 	rtalloc( ro );
     }
 
     /*
      * Make sure any route that we have has a valid interface.
      */
     aa = 0;
     if ( ro->ro_rt && ( ifp = ro->ro_rt->rt_ifp )) {
 	for ( aa = at_ifaddr; aa; aa = aa->aa_next ) {
 	    if ( aa->aa_ifp == ifp ) {
 		break;
 	    }
 	}
     }
     if ( aa == 0 ) {
 	return( ENETUNREACH );
     }
 
     ddp->ddp_fsat = *sat;
     if ( ddp->ddp_lsat.sat_port == ATADDR_ANYPORT ) {
 	return( at_pcbsetaddr( ddp, (struct mbuf *)0, p ));
     }
     return( 0 );
 }
 
 static void 
 at_pcbdisconnect( struct ddpcb	*ddp )
 {
     ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
     ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
     ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
 }
 
 static int
 at_pcballoc( struct socket *so )
 {
     struct ddpcb	*ddp;
     struct mbuf		*m;
 
     m = m_getclr( M_WAIT, MT_PCB );
     ddp = mtod( m, struct ddpcb * );
     ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
 
     ddp->ddp_next = ddpcb;
     ddp->ddp_prev = NULL;
     ddp->ddp_pprev = NULL;
     ddp->ddp_pnext = NULL;
     if ( ddpcb ) {
 	ddpcb->ddp_prev = ddp;
     }
     ddpcb = ddp;
 
     ddp->ddp_socket = so;
     so->so_pcb = (caddr_t)ddp;
     return( 0 );
 }
 
 static void
 at_pcbdetach( struct socket *so, struct ddpcb *ddp)
 {
     soisdisconnected( so );
     so->so_pcb = 0;
     sofree( so );
 
     /* remove ddp from ddp_ports list */
     if ( ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
 	    ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] != NULL ) {
 	if ( ddp->ddp_pprev != NULL ) {
 	    ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
 	} else {
 	    ddp_ports[ ddp->ddp_lsat.sat_port - 1 ] = ddp->ddp_pnext;
 	}
 	if ( ddp->ddp_pnext != NULL ) {
 	    ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
 	}
     }
 
     if ( ddp->ddp_route.ro_rt ) {
 	rtfree( ddp->ddp_route.ro_rt );
     }
 
     if ( ddp->ddp_prev ) {
 	ddp->ddp_prev->ddp_next = ddp->ddp_next;
     } else {
 	ddpcb = ddp->ddp_next;
     }
     if ( ddp->ddp_next ) {
 	ddp->ddp_next->ddp_prev = ddp->ddp_prev;
     }
 
     (void) m_free( dtom( ddp ));
 }
 
 /*
  * For the moment, this just find the pcb with the correct local address.
  * In the future, this will actually do some real searching, so we can use
  * the sender's address to do de-multiplexing on a single port to many
  * sockets (pcbs).
  */
 struct ddpcb *
 ddp_search( struct sockaddr_at *from, struct sockaddr_at *to,
 			struct at_ifaddr *aa)
 {
     struct ddpcb	*ddp;
 
     /*
      * Check for bad ports.
      */
     if ( to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST ) {
 	return( NULL );
     }
 
     /*
      * Make sure the local address matches the sent address.  What about
      * the interface?
      */
     for ( ddp = ddp_ports[ to->sat_port - 1 ]; ddp; ddp = ddp->ddp_pnext ) {
 	/* XXX should we handle 0.YY? */
 
 	/* XXXX.YY to socket on destination interface */
 	if ( to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
 		to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node ) {
 	    break;
 	}
 
 	/* 0.255 to socket on receiving interface */
 	if ( to->sat_addr.s_node == ATADDR_BCAST && ( to->sat_addr.s_net == 0 ||
 		to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net ) &&
 		ddp->ddp_lsat.sat_addr.s_net == AA_SAT( aa )->sat_addr.s_net ) {
 	    break;
 	}
 
 	/* XXXX.0 to socket on destination interface */
 	if ( to->sat_addr.s_net == aa->aa_firstnet &&
 		to->sat_addr.s_node == 0 &&
 		ntohs( ddp->ddp_lsat.sat_addr.s_net ) >=
 		ntohs( aa->aa_firstnet ) &&
 		ntohs( ddp->ddp_lsat.sat_addr.s_net ) <=
 		ntohs( aa->aa_lastnet )) {
 	    break;
 	}
     }
     return( ddp );
 }
 
 void 
 ddp_init(void )
 {
     atintrq1.ifq_maxlen = IFQ_MAXLEN;
     atintrq2.ifq_maxlen = IFQ_MAXLEN;
 }
 
 #if 0
 static void 
 ddp_clean(void )
 {
     struct ddpcb	*ddp;
 
     for ( ddp = ddpcb; ddp; ddp = ddp->ddp_next ) {
 	at_pcbdetach( ddp->ddp_socket, ddp );
     }
 }
 #endif