[apple/xnu.git] / bsd / netat / aurp_aurpd.c

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 *	Copyright (c) 1996 Apple Computer, Inc. 
 *
 *		Created April 25, 1996, by Justin C. Walker
 *   Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
 *
 *	File: aurpd.c
 */

/*
 * Kernel process to implement the AURP daemon:
 *  manage tunnels to remote AURP servers across IP networks
 */

#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <machine/spl.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/kauth.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/protosw.h>
#include <sys/malloc.h>
#include <sys/proc.h>
#include <sys/uio_internal.h>
#include <kern/locks.h>
#include <netinet/in.h>
#include <net/if.h>

#include <netat/sysglue.h>
#include <netat/appletalk.h>
#include <netat/at_var.h>
#include <netat/routing_tables.h>
#include <netat/at_pcb.h>
#include <netat/aurp.h>
#include <netat/debug.h>

#define M_RCVBUF (64 * 1024)
#define M_SNDBUF (64 * 1024)

extern lck_mtx_t * atalk_mutex;

static int ip_to_atalk(struct sockaddr_in *fp, register gbuf_t *p_mbuf);
static int aurp_bindrp(struct socket *so);

struct aurp_global_t aurp_global;

/*
 * Initialize the aurp pipe -
 * -Create, initialize, and start the aurpd kernel process; we need
 *  a process to permit queueing between the socket and the stream,
 *  which is necessary for orderly access to the socket structure.
 * -The user process (aurpd) is there to 'build' the AURP
 *  stream, act as a 'logging agent' (:-}), and hold open the stream
 *  during its use.
 * -Data and AURP packets from the DDP stream will be fed into the
 *  UDP tunnel (AURPsend())
 * -Data and AURP packets from the UDP tunnel will be fed into the
 *  DDP stream (ip_to_atalk(), via the kernel process).
 */
int
aurpd_start()
{
	register int error;
	register struct socket *so;
	struct mbuf *m;
	int maxbuf;
	struct sockopt sopt;

	if (suser(kauth_cred_get(), 0) != 0 )
		return(EPERM);

	/*
	 * Set up state prior to starting kernel process so we can back out
	 *  (error return) if something goes wrong.
	 */
	bzero((char *)&aurp_global.tunnel, sizeof(aurp_global.tunnel));
	/*lock_alloc(&aurp_global.glock, LOCK_ALLOC_PIN, AURP_EVNT_LOCK, -1);*/
	ATLOCKINIT(aurp_global.glock);
	ATEVENTINIT(aurp_global.event_anchor);

	/* open udp socket */
	if (aurp_global.udp_port == 0)
		aurp_global.udp_port = AURP_SOCKNUM;
	error = socreate(AF_INET, &aurp_global.tunnel, SOCK_DGRAM,
			 IPPROTO_UDP);
	if (error)
	{	dPrintf(D_M_AURP, D_L_FATAL, ("AURP: Can't get socket (%d)\n",
			error));
		return(error);
	}

	so = aurp_global.tunnel;

	if ((error = aurp_bindrp(so)) != 0)
	{	dPrintf(D_M_AURP, D_L_FATAL,
			("AURP: Can't bind to port %d (error %d)\n",
			aurp_global.udp_port, error));
		soclose(so);
		return(error);
	}

	sblock(&so->so_rcv, M_WAIT);
	sblock(&so->so_snd, M_WAIT);

	/*
	 * Set socket Receive buffer size
	 */
	m = m_get(M_WAIT, MT_SOOPTS);
	if (m == NULL) {
		error = ENOBUFS;
		goto out;
	} else {
		maxbuf = M_RCVBUF;
		sopt.sopt_val     = CAST_USER_ADDR_T(&maxbuf);
		sopt.sopt_valsize = sizeof(maxbuf);
		sopt.sopt_level   = SOL_SOCKET;
		sopt.sopt_name    = SO_RCVBUF;
		sopt.sopt_dir     = SOPT_SET;
		sopt.sopt_p		  = NULL;
		if ((error = sosetopt(so, &sopt)) != 0)
			goto out;
	}

	/*
	 * Set socket Send buffer size
	 */
	m = m_get(M_WAIT, MT_SOOPTS);
	if (m == NULL) {
		error = ENOBUFS;
		goto out;
	} else {

		maxbuf = M_SNDBUF;
		sopt.sopt_val     = CAST_USER_ADDR_T(&maxbuf);
		sopt.sopt_valsize = sizeof(maxbuf);
		sopt.sopt_level   = SOL_SOCKET;
		sopt.sopt_name    = SO_SNDBUF;
		sopt.sopt_dir     = SOPT_SET;
		sopt.sopt_p		  = NULL;
		if ((error = sosetopt(so, &sopt)) != 0)
			goto out;
	}

	so->so_upcall = aurp_wakeup;
	so->so_upcallarg = (caddr_t)AE_UDPIP; /* Yuck */
	so->so_state |= SS_NBIO;
	so->so_rcv.sb_flags |=(SB_SEL|SB_NOINTR);
	so->so_snd.sb_flags |=(SB_SEL|SB_NOINTR);

out:
	sbunlock(&so->so_snd, 0);
	sbunlock(&so->so_rcv, 0);

	return(error);
}

int
AURPgetmsg(err)
	int *err;
{	register struct socket *so;
	register int events;

	so = aurp_global.tunnel;
	*err = 0;

	for (;;)
	{	gbuf_t *from, *p_mbuf;
		int flags = MSG_DONTWAIT;
		uio_t auio;
		char uio_buf[ UIO_SIZEOF(0) ];

		/*
		 * Wait for a package to arrive.  This will be from the
		 * IP side - sowakeup() calls aurp_wakeup()
		 *	     when a packet arrives
		 */

		ATDISABLE(s, aurp_global.glock);
		events = aurp_global.event;
		if (((*err == 0) || (*err == EWOULDBLOCK)) && events == 0)
		  {
			lck_mtx_assert(atalk_mutex, LCK_MTX_ASSERT_OWNED);
		    *err = msleep(&aurp_global.event_anchor, atalk_mutex, PSOCK | PCATCH, "AURPgetmsg", 0);
		    events = aurp_global.event;
		    aurp_global.event = 0;
		  }	
		ATENABLE(s, aurp_global.glock);	 

		/*
		 * Shut down if we have the AE_SHUTDOWN event or if we got
		 * a system error other than EWOULDBLOCK, such as EINTR.
		 */
		if (((*err != EWOULDBLOCK) && (*err != 0)) || events & AE_SHUTDOWN)
		  {	
		    dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
			("AURPgetmsg: AE_SHUTDOWN detected--starting shutdown sequence\n"));
		    aurp_global.shutdown = 1;
		    while (aurp_global.running)
			;
		    /*lock_free(&aurp_global.glock);*/
		    aurp_global.tunnel = 0;
		    aurp_global.event = 0;
		    aurp_global.shutdown = 0;
		    soclose(so);
		    if (*err == 0)
		    *err = ESHUTDOWN;
		    dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
			("AURPgetmsg: shutdown completed\n"));
		    return -1;
		  }


		/*
		 * Set up the nominal uio structure -
		 *  give it no iov's, point off to non-existant user space,
		 *  but make sure the 'resid' count means somehting.
		 */
		auio = uio_createwithbuffer(0, 0, UIO_SYSSPACE, UIO_READ, 
								  &uio_buf[0], sizeof(uio_buf));

		/* Keep up an even flow... */
		for (;;)
		{
/*
 * This should be large enough to encompass a full DDP packet plus
 *  domain header.
 */
#define A_LARGE_SIZE 700

			flags = MSG_DONTWAIT;
			uio_setresid(auio, A_LARGE_SIZE);
			*err = soreceive(so, (struct sockaddr **)&from, auio, &p_mbuf, 0, &flags);
			dPrintf(D_M_AURP, D_L_VERBOSE,
				("AURPgetmsg: soreceive returned %d, aurp_global.event==0x%x\n", *err, events));
			/* soreceive() sets *mp to zero! at start */
			if (p_mbuf)
			        ip_to_atalk((struct sockaddr_in *)from, p_mbuf);
			if (*err || (p_mbuf == NULL)) {
				/*
				 * An error occurred in soreceive(),
				 * so clear the data input event flag
				 * and break out of this inner loop.
				 *
				 * XXX Note that clearing AE_UDPIP here could
				 * cause us to lose an AE_UDPIP event that
				 * was posted in aurp_global.event between
				 * the soreceive() above and the code here.
				 * The protocol should recover from this
				 * lost event, though, since the next
				 * request (a tickle, for example) from
				 * the other end of the tunnel will cause
				 * another AE_UDPIP event to be posted,
				 * which will wake us from the sleep at
				 * the top of the outer loop.
				 */
				ATDISABLE(s, aurp_global.glock);
				aurp_global.event &= ~AE_UDPIP;
				ATENABLE(s, aurp_global.glock);
				dPrintf(D_M_AURP, D_L_WARNING, ("AURPgetmsg: spurious soreceive, err==%d, p_mbuf==0x%x\n", *err, (unsigned int) p_mbuf));
			  break;
		}
	}
	}
	return -1;
}

/*
 * Wakeup the sleeping giant - we've put a message on his queue(s).
 * The arg indicates what queue has been updated.
 *
 * This conforms to the so_upcall function pointer member of struct sockbuf.
 */
void aurp_wakeup(__unused struct socket *so, register caddr_t p, __unused int state)
{
	register int bit;

	bit = (int) p;
	ATDISABLE(s, aurp_global.glock);
	aurp_global.event |= bit;
	ATENABLE(s, aurp_global.glock);

	dPrintf(D_M_AURP, D_L_STATE_CHG,
		("aurp_wakeup: bit 0x%x, aurp_global.event now 0x%x\n",
		bit, aurp_global.event));

	wakeup(&aurp_global.event_anchor);
}

/*
 * Try to bind to the specified reserved port.
 * Sort of like sobind(), but no suser() check.
 */
static int
aurp_bindrp(struct socket *so)
{
	struct sockaddr_in sin;
	struct proc *p = current_proc();
	int error;


	bzero(&sin, sizeof(sin));
	sin.sin_family      = AF_INET;
	sin.sin_addr.s_addr = htons(aurp_global.src_addr);
	sin.sin_port        = htons(aurp_global.udp_port);
	sin.sin_len         = sizeof(struct sockaddr_in);

	sblock(&so->so_rcv, M_WAIT);
	sblock(&so->so_snd, M_WAIT);
	so->so_state |= SS_PRIV;
	error = (*so->so_proto->pr_usrreqs->pru_bind)(so, (struct sockaddr *) &sin, p);
	sbunlock(&so->so_snd, 0);
	sbunlock(&so->so_rcv, 0);

	return (error);
}

/*
 * receive from UDP
 * fp is the 'source address' mbuf; p_mbuf is the data mbuf.
 * Use the source address to find the 'node number' (index of the address),
 *  and pass that to the next stage.
 */
int ip_to_atalk(register struct sockaddr_in *rem_addr, register gbuf_t *p_mbuf)
{	
	register aurp_domain_t *domain;
	unsigned char node;


	/* determine the node where the packet came from */
	for (node=1; node <= dst_addr_cnt; node++) {
		if (aurp_global.dst_addr[node] == *(long *)&rem_addr->sin_addr)
			break;
	}
	if (node > dst_addr_cnt) {
		dPrintf(D_M_AURP, D_L_WARNING,
			("AURPrecv: invalid node, %d.%lx\n",
			rem_addr->sin_port,
			rem_addr->sin_addr.s_addr));
		
		gbuf_freem(p_mbuf);
		FREE(rem_addr, M_SONAME);
		return -1;
	}

	/* validate the domain */
	domain = (aurp_domain_t *)gbuf_rptr(p_mbuf);
	if ( (domain->dst_length != IP_LENGTH) ||
	    (domain->dst_authority != IP_AUTHORITY) ||
	    (domain->version != AUD_Version) ||
	    ((domain->type != AUD_Atalk) && (domain->type != AUD_AURP)) ) {
		dPrintf(D_M_AURP, D_L_WARNING,
			("AURPrecv: invalid domain, %d.%lx\n",
			rem_addr->sin_port,
			rem_addr->sin_addr.s_addr));
		
		gbuf_freem(p_mbuf);
		FREE(rem_addr, M_SONAME);
		return -1;
	}

	/* Remove domain header */
	p_mbuf->m_pkthdr.len -= IP_DOMAINSIZE;
	gbuf_rinc(p_mbuf,IP_DOMAINSIZE);
	gbuf_set_type(p_mbuf, MSG_DATA);

	/* forward the packet to the local AppleTalk stack */

	at_insert(p_mbuf, domain->type, node);
	FREE(rem_addr, M_SONAME);
	return 0;
}

/*
 * send to UDP
 * The real work has been done already.	 Here, we just cobble together
 *  a sockaddr for the destination and call sosend().
 */
void
atalk_to_ip(register gbuf_t *m)
{	register aurp_domain_t *domain;
	int error;
	int flags = MSG_DONTWAIT;
	struct sockaddr_in rem_addr;

	m->m_type = MT_HEADER;
	m->m_pkthdr.len = gbuf_msgsize(m);
	m->m_pkthdr.rcvif = 0;

	bzero((char *) &rem_addr, sizeof(rem_addr));
	rem_addr.sin_family = PF_INET;
	rem_addr.sin_port = aurp_global.udp_port;
	rem_addr.sin_len  = sizeof (struct sockaddr_in);
	domain = (aurp_domain_t *)gbuf_rptr(m);
	*(long *) &rem_addr.sin_addr = domain->dst_address;

	ATDISABLE(s, aurp_global.glock);
	aurp_global.running++;
	ATENABLE(s, aurp_global.glock);
	if (aurp_global.shutdown) {
		gbuf_freem(m);
			ATDISABLE(s, aurp_global.glock);
		aurp_global.running--;
		ATENABLE(s, aurp_global.glock);
		dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
			("atalk_to_ip: detected aurp_global.shutdown state\n"));
		return;
	}
	dPrintf(D_M_AURP, D_L_VERBOSE, ("atalk_to_ip: calling sosend\n"));
	error = sosend(aurp_global.tunnel, (struct sockaddr *) &rem_addr, NULL, m, NULL, flags);
	if (error)
	{	/*log error*/
	  dPrintf(D_M_AURP, D_L_ERROR, ("AURP: sosend error (%d)\n",
		  error));
	}

	ATDISABLE(s, aurp_global.glock);
	aurp_global.running--;
	ATENABLE(s, aurp_global.glock);
	return;
}
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* Copyright (c) 1996 Apple Computer, Inc.
	30	*
	31	* Created April 25, 1996, by Justin C. Walker
	32	* Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
	33	*
	34	* File: aurpd.c
	35	*/
	36
	37	/*
	38	* Kernel process to implement the AURP daemon:
	39	* manage tunnels to remote AURP servers across IP networks
	40	*/
	41
	42	#include <sys/errno.h>
	43	#include <sys/types.h>
	44	#include <sys/param.h>
	45	#include <machine/spl.h>
	46	#include <sys/systm.h>
	47	#include <sys/kernel.h>
	48	#include <sys/proc.h>
91447636	49	#include <sys/kauth.h>
1c79356b A	50	#include <sys/filedesc.h>
	51	#include <sys/fcntl.h>
	52	#include <sys/mbuf.h>
	53	#include <sys/socket.h>
	54	#include <sys/socketvar.h>
	55	#include <sys/protosw.h>
	56	#include <sys/malloc.h>
	57	#include <sys/proc.h>
91447636 A	58	#include <sys/uio_internal.h>
91447636 A	59	#include <kern/locks.h>
1c79356b A	60	#include <netinet/in.h>
	61	#include <net/if.h>
	62
	63	#include <netat/sysglue.h>
	64	#include <netat/appletalk.h>
	65	#include <netat/at_var.h>
	66	#include <netat/routing_tables.h>
	67	#include <netat/at_pcb.h>
	68	#include <netat/aurp.h>
	69	#include <netat/debug.h>
	70
	71	#define M_RCVBUF (64 * 1024)
	72	#define M_SNDBUF (64 * 1024)
	73
91447636 A	74	extern lck_mtx_t * atalk_mutex;
91447636 A	75
1c79356b A	76	static int ip_to_atalk(struct sockaddr_in fp, register gbuf_t p_mbuf);
	77	static int aurp_bindrp(struct socket *so);
	78
	79	struct aurp_global_t aurp_global;
	80
	81	/*
	82	* Initialize the aurp pipe -
	83	* -Create, initialize, and start the aurpd kernel process; we need
	84	* a process to permit queueing between the socket and the stream,
	85	* which is necessary for orderly access to the socket structure.
	86	* -The user process (aurpd) is there to 'build' the AURP
	87	* stream, act as a 'logging agent' (:-}), and hold open the stream
	88	* during its use.
	89	* -Data and AURP packets from the DDP stream will be fed into the
	90	* UDP tunnel (AURPsend())
	91	* -Data and AURP packets from the UDP tunnel will be fed into the
	92	* DDP stream (ip_to_atalk(), via the kernel process).
	93	*/
	94	int
	95	aurpd_start()
	96	{
	97	register int error;
	98	register struct socket *so;
	99	struct mbuf *m;
	100	int maxbuf;
	101	struct sockopt sopt;
	102
91447636	103	if (suser(kauth_cred_get(), 0) != 0 )
1c79356b A	104	return(EPERM);
	105
	106	/*
	107	* Set up state prior to starting kernel process so we can back out
	108	* (error return) if something goes wrong.
	109	*/
	110	bzero((char *)&aurp_global.tunnel, sizeof(aurp_global.tunnel));
	111	/lock_alloc(&aurp_global.glock, LOCK_ALLOC_PIN, AURP_EVNT_LOCK, -1);/
21362eb3	112	ATLOCKINIT(aurp_global.glock);
1c79356b A	113	ATEVENTINIT(aurp_global.event_anchor);
	114
	115	/* open udp socket */
	116	if (aurp_global.udp_port == 0)
	117	aurp_global.udp_port = AURP_SOCKNUM;
	118	error = socreate(AF_INET, &aurp_global.tunnel, SOCK_DGRAM,
	119	IPPROTO_UDP);
	120	if (error)
	121	{ dPrintf(D_M_AURP, D_L_FATAL, ("AURP: Can't get socket (%d)\n",
	122	error));
	123	return(error);
	124	}
	125
	126	so = aurp_global.tunnel;
	127
	128	if ((error = aurp_bindrp(so)) != 0)
	129	{ dPrintf(D_M_AURP, D_L_FATAL,
	130	("AURP: Can't bind to port %d (error %d)\n",
	131	aurp_global.udp_port, error));
	132	soclose(so);
	133	return(error);
	134	}
	135
	136	sblock(&so->so_rcv, M_WAIT);
	137	sblock(&so->so_snd, M_WAIT);
	138
	139	/*
	140	* Set socket Receive buffer size
	141	*/
	142	m = m_get(M_WAIT, MT_SOOPTS);
	143	if (m == NULL) {
	144	error = ENOBUFS;
	145	goto out;
	146	} else {
	147	maxbuf = M_RCVBUF;
91447636	148	sopt.sopt_val = CAST_USER_ADDR_T(&maxbuf);
1c79356b A	149	sopt.sopt_valsize = sizeof(maxbuf);
	150	sopt.sopt_level = SOL_SOCKET;
	151	sopt.sopt_name = SO_RCVBUF;
	152	sopt.sopt_dir = SOPT_SET;
0b4e3aa0	153	sopt.sopt_p = NULL;
1c79356b A	154	if ((error = sosetopt(so, &sopt)) != 0)
	155	goto out;
	156	}
	157
	158	/*
	159	* Set socket Send buffer size
	160	*/
	161	m = m_get(M_WAIT, MT_SOOPTS);
	162	if (m == NULL) {
	163	error = ENOBUFS;
	164	goto out;
	165	} else {
	166
	167	maxbuf = M_SNDBUF;
91447636	168	sopt.sopt_val = CAST_USER_ADDR_T(&maxbuf);
1c79356b A	169	sopt.sopt_valsize = sizeof(maxbuf);
	170	sopt.sopt_level = SOL_SOCKET;
	171	sopt.sopt_name = SO_SNDBUF;
	172	sopt.sopt_dir = SOPT_SET;
0b4e3aa0	173	sopt.sopt_p = NULL;
1c79356b A	174	if ((error = sosetopt(so, &sopt)) != 0)
	175	goto out;
	176	}
	177
	178	so->so_upcall = aurp_wakeup;
	179	so->so_upcallarg = (caddr_t)AE_UDPIP; /* Yuck */
	180	so->so_state \|= SS_NBIO;
0b4e3aa0 A	181	so->so_rcv.sb_flags \|=(SB_SEL\|SB_NOINTR);
0b4e3aa0 A	182	so->so_snd.sb_flags \|=(SB_SEL\|SB_NOINTR);
1c79356b A	183
1c79356b A	184	out:
91447636 A	185	sbunlock(&so->so_snd, 0);
91447636 A	186	sbunlock(&so->so_rcv, 0);
1c79356b A	187
	188	return(error);
	189	}
	190
	191	int
	192	AURPgetmsg(err)
	193	int *err;
	194	{ register struct socket *so;
91447636	195	register int events;
1c79356b A	196
	197	so = aurp_global.tunnel;
	198	*err = 0;
	199
	200	for (;;)
	201	{ gbuf_t from, p_mbuf;
	202	int flags = MSG_DONTWAIT;
91447636 A	203	uio_t auio;
91447636 A	204	char uio_buf[ UIO_SIZEOF(0) ];
1c79356b A	205
	206	/*
	207	* Wait for a package to arrive. This will be from the
	208	* IP side - sowakeup() calls aurp_wakeup()
	209	* when a packet arrives
	210	*/
	211
21362eb3	212	ATDISABLE(s, aurp_global.glock);
1c79356b A	213	events = aurp_global.event;
	214	if (((err == 0) \|\| (err == EWOULDBLOCK)) && events == 0)
	215	{
91447636 A	216	lck_mtx_assert(atalk_mutex, LCK_MTX_ASSERT_OWNED);
91447636 A	217	*err = msleep(&aurp_global.event_anchor, atalk_mutex, PSOCK \| PCATCH, "AURPgetmsg", 0);
1c79356b A	218	events = aurp_global.event;
	219	aurp_global.event = 0;
	220	}
21362eb3	221	ATENABLE(s, aurp_global.glock);
1c79356b A	222
	223	/*
	224	* Shut down if we have the AE_SHUTDOWN event or if we got
	225	* a system error other than EWOULDBLOCK, such as EINTR.
	226	*/
	227	if (((err != EWOULDBLOCK) && (err != 0)) \|\| events & AE_SHUTDOWN)
	228	{
	229	dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
	230	("AURPgetmsg: AE_SHUTDOWN detected--starting shutdown sequence\n"));
	231	aurp_global.shutdown = 1;
	232	while (aurp_global.running)
	233	;
	234	/lock_free(&aurp_global.glock);/
	235	aurp_global.tunnel = 0;
	236	aurp_global.event = 0;
	237	aurp_global.shutdown = 0;
	238	soclose(so);
	239	if (*err == 0)
	240	*err = ESHUTDOWN;
	241	dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
	242	("AURPgetmsg: shutdown completed\n"));
	243	return -1;
	244	}
	245
	246
	247
	248	/*
	249	* Set up the nominal uio structure -
	250	* give it no iov's, point off to non-existant user space,
	251	* but make sure the 'resid' count means somehting.
	252	*/
91447636 A	253	auio = uio_createwithbuffer(0, 0, UIO_SYSSPACE, UIO_READ,
91447636 A	254	&uio_buf[0], sizeof(uio_buf));
1c79356b A	255
	256	/* Keep up an even flow... */
	257	for (;;)
	258	{
	259	/*
	260	* This should be large enough to encompass a full DDP packet plus
	261	* domain header.
	262	*/
	263	#define A_LARGE_SIZE 700
	264
	265	flags = MSG_DONTWAIT;
91447636 A	266	uio_setresid(auio, A_LARGE_SIZE);
91447636 A	267	err = soreceive(so, (struct sockaddr *)&from, auio, &p_mbuf, 0, &flags);
1c79356b A	268	dPrintf(D_M_AURP, D_L_VERBOSE,
	269	("AURPgetmsg: soreceive returned %d, aurp_global.event==0x%x\n", *err, events));
	270	/* soreceive() sets mp to zero! at start /
	271	if (p_mbuf)
55e303ae	272	ip_to_atalk((struct sockaddr_in *)from, p_mbuf);
1c79356b A	273	if (*err \|\| (p_mbuf == NULL)) {
	274	/*
	275	* An error occurred in soreceive(),
	276	* so clear the data input event flag
	277	* and break out of this inner loop.
	278	*
	279	* XXX Note that clearing AE_UDPIP here could
	280	* cause us to lose an AE_UDPIP event that
	281	* was posted in aurp_global.event between
	282	* the soreceive() above and the code here.
	283	* The protocol should recover from this
	284	* lost event, though, since the next
	285	* request (a tickle, for example) from
	286	* the other end of the tunnel will cause
	287	* another AE_UDPIP event to be posted,
	288	* which will wake us from the sleep at
	289	* the top of the outer loop.
	290	*/
21362eb3	291	ATDISABLE(s, aurp_global.glock);
1c79356b	292	aurp_global.event &= ~AE_UDPIP;
21362eb3	293	ATENABLE(s, aurp_global.glock);
1c79356b A	294	dPrintf(D_M_AURP, D_L_WARNING, ("AURPgetmsg: spurious soreceive, err==%d, p_mbuf==0x%x\n", *err, (unsigned int) p_mbuf));
	295	break;
	296	}
	297	}
	298	}
	299	return -1;
	300	}
	301
	302	/*
	303	* Wakeup the sleeping giant - we've put a message on his queue(s).
	304	* The arg indicates what queue has been updated.
	305	*
	306	* This conforms to the so_upcall function pointer member of struct sockbuf.
	307	*/
91447636	308	void aurp_wakeup(__unused struct socket *so, register caddr_t p, __unused int state)
1c79356b	309	{
1c79356b A	310	register int bit;
	311
	312	bit = (int) p;
21362eb3	313	ATDISABLE(s, aurp_global.glock);
1c79356b	314	aurp_global.event \|= bit;
21362eb3	315	ATENABLE(s, aurp_global.glock);
1c79356b A	316
	317	dPrintf(D_M_AURP, D_L_STATE_CHG,
	318	("aurp_wakeup: bit 0x%x, aurp_global.event now 0x%x\n",
	319	bit, aurp_global.event));
	320
9bccf70c	321	wakeup(&aurp_global.event_anchor);
1c79356b A	322	}
	323
	324	/*
	325	* Try to bind to the specified reserved port.
	326	* Sort of like sobind(), but no suser() check.
	327	*/
	328	static int
	329	aurp_bindrp(struct socket *so)
	330	{
	331	struct sockaddr_in sin;
	332	struct proc *p = current_proc();
1c79356b A	333	int error;
	334
	335
	336	bzero(&sin, sizeof(sin));
	337	sin.sin_family = AF_INET;
	338	sin.sin_addr.s_addr = htons(aurp_global.src_addr);
	339	sin.sin_port = htons(aurp_global.udp_port);
	340	sin.sin_len = sizeof(struct sockaddr_in);
	341
	342	sblock(&so->so_rcv, M_WAIT);
	343	sblock(&so->so_snd, M_WAIT);
	344	so->so_state \|= SS_PRIV;
	345	error = (so->so_proto->pr_usrreqs->pru_bind)(so, (struct sockaddr ) &sin, p);
91447636 A	346	sbunlock(&so->so_snd, 0);
91447636 A	347	sbunlock(&so->so_rcv, 0);
1c79356b A	348
	349	return (error);
	350	}
	351
	352	/*
	353	* receive from UDP
	354	* fp is the 'source address' mbuf; p_mbuf is the data mbuf.
	355	* Use the source address to find the 'node number' (index of the address),
	356	* and pass that to the next stage.
	357	*/
	358	int ip_to_atalk(register struct sockaddr_in rem_addr, register gbuf_t p_mbuf)
	359	{
	360	register aurp_domain_t *domain;
	361	unsigned char node;
	362
	363
	364	/* determine the node where the packet came from */
	365	for (node=1; node <= dst_addr_cnt; node++) {
	366	if (aurp_global.dst_addr[node] == (long )&rem_addr->sin_addr)
	367	break;
	368	}
	369	if (node > dst_addr_cnt) {
	370	dPrintf(D_M_AURP, D_L_WARNING,
	371	("AURPrecv: invalid node, %d.%lx\n",
	372	rem_addr->sin_port,
	373	rem_addr->sin_addr.s_addr));
	374
	375	gbuf_freem(p_mbuf);
	376	FREE(rem_addr, M_SONAME);
	377	return -1;
	378	}
	379
	380	/* validate the domain */
	381	domain = (aurp_domain_t *)gbuf_rptr(p_mbuf);
	382	if ( (domain->dst_length != IP_LENGTH) \|\|
	383	(domain->dst_authority != IP_AUTHORITY) \|\|
	384	(domain->version != AUD_Version) \|\|
	385	((domain->type != AUD_Atalk) && (domain->type != AUD_AURP)) ) {
	386	dPrintf(D_M_AURP, D_L_WARNING,
	387	("AURPrecv: invalid domain, %d.%lx\n",
	388	rem_addr->sin_port,
	389	rem_addr->sin_addr.s_addr));
	390
	391	gbuf_freem(p_mbuf);
	392	FREE(rem_addr, M_SONAME);
	393	return -1;
	394	}
	395
	396	/* Remove domain header */
	397	p_mbuf->m_pkthdr.len -= IP_DOMAINSIZE;
	398	gbuf_rinc(p_mbuf,IP_DOMAINSIZE);
	399	gbuf_set_type(p_mbuf, MSG_DATA);
	400
	401	/* forward the packet to the local AppleTalk stack */
	402
	403	at_insert(p_mbuf, domain->type, node);
	404	FREE(rem_addr, M_SONAME);
	405	return 0;
	406	}
	407
	408	/*
	409	* send to UDP
	410	* The real work has been done already. Here, we just cobble together
	411	* a sockaddr for the destination and call sosend().
412	*/
413	void
414	atalk_to_ip(register gbuf_t *m)
415	{ register aurp_domain_t *domain;
416	int error;
417	int flags = MSG_DONTWAIT;
418	struct sockaddr_in rem_addr;
1c79356b A	419
	420	m->m_type = MT_HEADER;
	421	m->m_pkthdr.len = gbuf_msgsize(m);
	422	m->m_pkthdr.rcvif = 0;
	423
	424	bzero((char *) &rem_addr, sizeof(rem_addr));
	425	rem_addr.sin_family = PF_INET;
	426	rem_addr.sin_port = aurp_global.udp_port;
	427	rem_addr.sin_len = sizeof (struct sockaddr_in);
	428	domain = (aurp_domain_t *)gbuf_rptr(m);
	429	(long ) &rem_addr.sin_addr = domain->dst_address;
	430
21362eb3	431	ATDISABLE(s, aurp_global.glock);
1c79356b	432	aurp_global.running++;
21362eb3	433	ATENABLE(s, aurp_global.glock);
1c79356b A	434	if (aurp_global.shutdown) {
1c79356b A	435	gbuf_freem(m);
21362eb3	436	ATDISABLE(s, aurp_global.glock);
1c79356b	437	aurp_global.running--;
21362eb3	438	ATENABLE(s, aurp_global.glock);
1c79356b A	439	dPrintf(D_M_AURP, D_L_SHUTDN_INFO,
	440	("atalk_to_ip: detected aurp_global.shutdown state\n"));
	441	return;
	442	}
	443	dPrintf(D_M_AURP, D_L_VERBOSE, ("atalk_to_ip: calling sosend\n"));
	444	error = sosend(aurp_global.tunnel, (struct sockaddr *) &rem_addr, NULL, m, NULL, flags);
	445	if (error)
	446	{ /log error/
	447	dPrintf(D_M_AURP, D_L_ERROR, ("AURP: sosend error (%d)\n",
	448	error));
	449	}
	450
21362eb3	451	ATDISABLE(s, aurp_global.glock);
1c79356b	452	aurp_global.running--;
21362eb3	453	ATENABLE(s, aurp_global.glock);
1c79356b A	454	return;
	455	}
	456