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

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_OSREFERENCE_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_LICENSE_OSREFERENCE_HEADER_END@
 */
/*
 *	Copyright (c) 1996 Apple Computer, Inc. 
 *
 *		Created April 8, 1996 by Tuyen Nguyen
 *   Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
 *
 *	File: tx.c
 */
 
#ifdef AURP_SUPPORT

#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/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/socketvar.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>

/*
 * Any AURP protocol or appletalk data (ddp) packets flowing through
 *  are inserted into the kernel aurpd process's (atalk) input queue.
 * Assume here that we deal with single packets, i.e., someone earlier
 *  in the food chain has broken up packet chains.
 */
void AURPsend(mdata, type, node)
	gbuf_t *mdata;
	int type, node;
{
	struct aurp_domain *domain;
	gbuf_t *m;
	int msize = AT_WR_OFFSET+32+IP_DOMAINSIZE;

	/* Add the domain header */
	if ((m = gbuf_alloc(msize, PRI_MED)) == 0) {
		gbuf_freem(mdata);
		dPrintf(D_M_AURP, D_L_WARNING, ("AURPsend: gbuf_alloc failed\n"));
		return;
	}
	gbuf_wset(m,msize);
	gbuf_rinc(m,AT_WR_OFFSET+32);
	gbuf_cont(m) = mdata;
	domain = (struct aurp_domain *)gbuf_rptr(m);
	domain->dst_length = IP_LENGTH;
	domain->dst_authority = IP_AUTHORITY;
	domain->dst_distinguisher = IP_DISTINGUISHER;
	domain->src_length = IP_LENGTH;
	domain->src_authority = IP_AUTHORITY;
	domain->src_distinguisher = IP_DISTINGUISHER;
	domain->src_address = aurp_global.src_addr;
	domain->version = AUD_Version;
	domain->reserved = 0;
	domain->type = type;
	domain->dst_address = aurp_global.dst_addr[node];
	atalk_to_ip(m);
}

/*
 * Called from within ddp (via ddp_AURPsendx) to handle data (DDP) packets
 *  sent from the AppleTalk stack, routing updates, and routing info
 *  initialization.
 */
void AURPcmdx(code, mdata, param)
	int code;
	gbuf_t *mdata;
	int param;
{
	unsigned char node;
	gbuf_t *mdata_next;

	if (mdata == 0)
		return;
	if (aurp_gref == 0) {
		if (code != AURPCODE_DEBUGINFO)
			AURPfreemsg(mdata);
		return;
	}

	switch (code) {
	case AURPCODE_DATAPKT: /* data packet */
		node = (unsigned char)param;
		if (gbuf_next(mdata)) {
			mdata_next = gbuf_next(mdata);
			gbuf_next(mdata) = 0;
			AURPsend(mdata, AUD_Atalk, node);
			do {
				mdata = mdata_next;
				mdata_next = gbuf_next(mdata);
				gbuf_next(mdata) = 0;
				/* Indicate non-AURP packet, node id of peer */
				AURPsend(mdata, AUD_Atalk, node);
			} while (mdata_next);
		} else
			AURPsend(mdata, AUD_Atalk, node);
		break;

	case AURPCODE_RTUPDATE:
		AURPrtupdate((RT_entry *)mdata, param);
		break;

	case AURPCODE_DEBUGINFO: /* debug info */
		dbgBits = *(dbgBits_t *)mdata;
		net_port = param;
		break;

	default:
		dPrintf(D_M_AURP, D_L_ERROR, ("AURPcmdx: bad code, %d\n", code));
	}
}

#endif  /* AURP_SUPPORT */
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
8ad349bb	4	* @APPLE_LICENSE_OSREFERENCE_HEADER_START@
1c79356b	5	*
8ad349bb 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
	10	* License may not be used to create, or enable the creation or
	11	* redistribution of, unlawful or unlicensed copies of an Apple operating
	12	* system, or to circumvent, violate, or enable the circumvention or
	13	* violation of, any terms of an Apple operating system software license
	14	* agreement.
	15	*
	16	* Please obtain a copy of the License at
	17	* http://www.opensource.apple.com/apsl/ and read it before using this
	18	* file.
	19	*
	20	* The Original Code and all software distributed under the License are
	21	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	22	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	23	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	24	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	25	* Please see the License for the specific language governing rights and
	26	* limitations under the License.
	27	*
	28	* @APPLE_LICENSE_OSREFERENCE_HEADER_END@
1c79356b A	29	*/
	30	/*
	31	* Copyright (c) 1996 Apple Computer, Inc.
	32	*
	33	* Created April 8, 1996 by Tuyen Nguyen
	34	* Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
	35	*
	36	* File: tx.c
	37	*/
5d5c5d0d A	38
	39	#ifdef AURP_SUPPORT
	40
1c79356b A	41	#include <sys/errno.h>
	42	#include <sys/types.h>
	43	#include <sys/param.h>
	44	#include <machine/spl.h>
	45	#include <sys/systm.h>
	46	#include <sys/kernel.h>
	47	#include <sys/proc.h>
	48	#include <sys/filedesc.h>
	49	#include <sys/fcntl.h>
	50	#include <sys/mbuf.h>
	51	#include <sys/socket.h>
	52	#include <sys/socketvar.h>
	53	#include <net/if.h>
	54
	55	#include <netat/sysglue.h>
	56	#include <netat/appletalk.h>
	57	#include <netat/at_var.h>
	58	#include <netat/routing_tables.h>
	59	#include <netat/at_pcb.h>
	60	#include <netat/aurp.h>
	61	#include <netat/debug.h>
	62
	63	/*
	64	* Any AURP protocol or appletalk data (ddp) packets flowing through
	65	* are inserted into the kernel aurpd process's (atalk) input queue.
	66	* Assume here that we deal with single packets, i.e., someone earlier
	67	* in the food chain has broken up packet chains.
	68	*/
	69	void AURPsend(mdata, type, node)
	70	gbuf_t *mdata;
	71	int type, node;
	72	{
	73	struct aurp_domain *domain;
	74	gbuf_t *m;
	75	int msize = AT_WR_OFFSET+32+IP_DOMAINSIZE;
	76
	77	/* Add the domain header */
	78	if ((m = gbuf_alloc(msize, PRI_MED)) == 0) {
	79	gbuf_freem(mdata);
	80	dPrintf(D_M_AURP, D_L_WARNING, ("AURPsend: gbuf_alloc failed\n"));
	81	return;
	82	}
	83	gbuf_wset(m,msize);
	84	gbuf_rinc(m,AT_WR_OFFSET+32);
	85	gbuf_cont(m) = mdata;
	86	domain = (struct aurp_domain *)gbuf_rptr(m);
	87	domain->dst_length = IP_LENGTH;
	88	domain->dst_authority = IP_AUTHORITY;
	89	domain->dst_distinguisher = IP_DISTINGUISHER;
	90	domain->src_length = IP_LENGTH;
	91	domain->src_authority = IP_AUTHORITY;
	92	domain->src_distinguisher = IP_DISTINGUISHER;
	93	domain->src_address = aurp_global.src_addr;
	94	domain->version = AUD_Version;
	95	domain->reserved = 0;
	96	domain->type = type;
	97	domain->dst_address = aurp_global.dst_addr[node];
	98	atalk_to_ip(m);
	99	}
	100
	101	/*
	102	* Called from within ddp (via ddp_AURPsendx) to handle data (DDP) packets
	103	* sent from the AppleTalk stack, routing updates, and routing info
	104	* initialization.
105	*/
106	void AURPcmdx(code, mdata, param)
107	int code;
108	gbuf_t *mdata;
109	int param;
110	{
111	unsigned char node;
112	gbuf_t *mdata_next;
113
114	if (mdata == 0)
115	return;
116	if (aurp_gref == 0) {
117	if (code != AURPCODE_DEBUGINFO)
118	AURPfreemsg(mdata);
119	return;
120	}
121
122	switch (code) {
123	case AURPCODE_DATAPKT: /* data packet */
124	node = (unsigned char)param;
125	if (gbuf_next(mdata)) {
126	mdata_next = gbuf_next(mdata);
127	gbuf_next(mdata) = 0;
128	AURPsend(mdata, AUD_Atalk, node);
129	do {
130	mdata = mdata_next;
131	mdata_next = gbuf_next(mdata);
132	gbuf_next(mdata) = 0;
133	/* Indicate non-AURP packet, node id of peer */
134	AURPsend(mdata, AUD_Atalk, node);
135	} while (mdata_next);
136	} else
137	AURPsend(mdata, AUD_Atalk, node);
138	break;
139
140	case AURPCODE_RTUPDATE:
141	AURPrtupdate((RT_entry *)mdata, param);
142	break;
143
144	case AURPCODE_DEBUGINFO: /* debug info */
145	dbgBits = (dbgBits_t )mdata;
146	net_port = param;
147	break;
148
149	default:
150	dPrintf(D_M_AURP, D_L_ERROR, ("AURPcmdx: bad code, %d\n", code));
151	}
152	}
5d5c5d0d A	153
5d5c5d0d A	154	#endif /* AURP_SUPPORT */