[unix-history] / sys / netiso / clnp_options.c

/*-
 * Copyright (c) 1991 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *	from: @(#)clnp_options.c	7.8 (Berkeley) 5/6/91
 *	$Id$
 */

/***********************************************************
		Copyright IBM Corporation 1987

                      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 appear in all copies and that
both that copyright notice and this permission notice appear in 
supporting documentation, and that the name of IBM not be
used in advertising or publicity pertaining to distribution of the
software without specific, written prior permission.  

IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

******************************************************************/

/*
 * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
 */

#ifdef ISO

#include "types.h"
#include "param.h"
#include "mbuf.h"
#include "domain.h"
#include "protosw.h"
#include "socket.h"
#include "socketvar.h"
#include "errno.h"

#include "../net/if.h"
#include "../net/route.h"

#include "iso.h"
#include "clnp.h"
#include "clnp_stat.h"
#include "argo_debug.h"

/*
 * FUNCTION:		clnp_update_srcrt
 *
 * PURPOSE:			Process src rt option accompanying a clnp datagram.
 *						- bump src route ptr if src routing and
 *							we appear current in src route list.
 *
 * RETURNS:			none
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			If source routing has been terminated, do nothing.
 */
clnp_update_srcrt(options, oidx)
struct mbuf			*options;	/* ptr to options mbuf */
struct clnp_optidx	*oidx;		/* ptr to option index */
{
	u_char			len;	/* length of current address */
	struct iso_addr	isoa;	/* copy current address into here */

	if (CLNPSRCRT_TERM(oidx, options)) {
		IFDEBUG(D_OPTIONS)
			printf("clnp_update_srcrt: src rt terminated\n");
		ENDDEBUG
		return;
	}

	len = CLNPSRCRT_CLEN(oidx, options);
	bcopy(CLNPSRCRT_CADDR(oidx, options), (caddr_t)&isoa, len);
	isoa.isoa_len = len;
		
	IFDEBUG(D_OPTIONS)
		printf("clnp_update_srcrt: current src rt: %s\n", 
			clnp_iso_addrp(&isoa));
	ENDDEBUG

	if (clnp_ours(&isoa)) {
		IFDEBUG(D_OPTIONS)
			printf("clnp_update_srcrt: updating src rt\n");
		ENDDEBUG

		/* update pointer to next src route */
		len++;	/* count length byte too! */
		CLNPSRCRT_OFF(oidx, options) += len;
	}
}

/*
 * FUNCTION:		clnp_dooptions
 *
 * PURPOSE:			Process options accompanying a clnp datagram.
 *					Processing includes
 *						- log our address if recording route
 *
 * RETURNS:			none
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			
 */
clnp_dooptions(options, oidx, ifp, isoa)
struct mbuf			*options;	/* ptr to options mbuf */
struct clnp_optidx	*oidx;		/* ptr to option index */
struct ifnet		*ifp;		/* ptr to interface pkt is leaving on */
struct iso_addr		*isoa;		/* ptr to our address for this ifp */
{
	/*
	 *	If record route is specified, move all
	 *	existing records over, and insert the address of
	 *	interface passed
	 */
	if (oidx->cni_recrtp) {
		char 	*opt;			/* ptr to beginning of recrt option */
		u_char	off;			/* offset from opt of first free byte */
		char	*rec_start;		/* beginning of new rt recorded */

		opt = CLNP_OFFTOOPT(options, oidx->cni_recrtp);
		off = *(opt + 1);
		rec_start = opt + off - 1;

		IFDEBUG(D_OPTIONS)
			printf("clnp_dooptions: record route: option x%x for %d bytes\n",
				opt, oidx->cni_recrt_len);
			printf("\tfree slot offset x%x\n", off);
			printf("clnp_dooptions: recording %s\n", clnp_iso_addrp(isoa));
			printf("clnp_dooptions: option dump:\n");
			dump_buf(opt, oidx->cni_recrt_len);
		ENDDEBUG

		/* proceed only if recording has not been terminated */
		if (off != 0xff) {
			int new_addrlen = isoa->isoa_len + 1;
			/* 
			 *	if there is insufficient room to store the next address,
			 *	then terminate recording. Plus 1 on isoa_len is for the
			 *	length byte itself
			 */
			if (oidx->cni_recrt_len - (off - 1) < new_addrlen) {
				*(opt + 1) = 0xff;	/* terminate recording */
			} else {
				IFDEBUG(D_OPTIONS)
					printf("clnp_dooptions: new addr at x%x for %d\n",
						rec_start, new_addrlen);
				ENDDEBUG

				bcopy((caddr_t)isoa, rec_start, new_addrlen);

				/* update offset field */
				*(opt + 1) += new_addrlen;

				IFDEBUG(D_OPTIONS)
					printf("clnp_dooptions: new option dump:\n");
					dump_buf(opt, oidx->cni_recrt_len);
				ENDDEBUG
			}
		}
	}
}

/*
 * FUNCTION:		clnp_set_opts
 *
 * PURPOSE:			Check the data mbuf passed for option sanity. If it is
 *					ok, then set the options ptr to address the data mbuf.
 *					If an options mbuf exists, free it. This implies that
 *					any old options will be lost. If data is NULL, simply
 *					free any old options.
 *
 * RETURNS:			unix error code
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			
 */
clnp_set_opts(options, data)
struct mbuf	**options;	/* target for option information */
struct mbuf	**data;		/* source of option information */
{
	int					error = 0;	/* error return value */
	struct clnp_optidx	dummy;		/* dummy index - not used */

	/*
	 *	remove any existing options
	 */
	if (*options != NULL) {
		m_freem(*options);
		*options = NULL;
	}

	if (*data != NULL) {
		/*
		 *	Insure that the options are reasonable.
		 *
		 *	Also, we do not support security, priority,
		 *	nor do we allow one to send an ER option
		 *
		 *	The QOS parameter is checked for the DECBIT.
		 */
		if ((clnp_opt_sanity(*data, mtod(*data, caddr_t), (*data)->m_len, 
			&dummy) != 0) ||
				(dummy.cni_securep) ||
				(dummy.cni_priorp) ||
				(dummy.cni_er_reason != ER_INVALREAS)) {
			error = EINVAL;
		} else {
			*options = *data;
			*data = NULL;	/* so caller won't free mbuf @ *data */
		}
	}
	return error;
}

/*
 * FUNCTION:		clnp_opt_sanity
 *
 * PURPOSE:			Check the options (beginning at opts for len bytes) for
 *					sanity. In addition, fill in the option index structure 
 *					in with information about each option discovered.
 *
 * RETURNS:			success (options check out) - 0
 *					failure - an ER pdu error code describing failure
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			Each pointer field of the option index is filled in with
 *					the offset from the beginning of the mbuf data, not the
 *					actual address.
 */
clnp_opt_sanity(m, opts, len, oidx)
struct mbuf 		*m;		/* mbuf options reside in */
caddr_t				opts;	/* ptr to buffer containing options */
int					len;	/* length of buffer */
struct clnp_optidx	*oidx;	/* RETURN: filled in with option idx info */
{
	u_char	opcode;			/* code of particular option */
	u_char	oplen;			/* length of a particular option */
	caddr_t	opts_end;		/* ptr to end of options */
	u_char	pad = 0, secure = 0, srcrt = 0, recrt = 0, qos = 0, prior = 0;
							/* flags for catching duplicate options */
	
	IFDEBUG(D_OPTIONS)
		printf("clnp_opt_sanity: checking %d bytes of data:\n", len);
		dump_buf(opts, len);
	ENDDEBUG

	/* clear option index field if passed */
	bzero((caddr_t)oidx, sizeof(struct clnp_optidx));

	/*
	 *	We need to indicate whether the ER option is present. This is done
	 *	by overloading the er_reason field to also indicate presense of
	 *	the option along with the option value. I would like ER_INVALREAS
	 *	to have value 0, but alas, 0 is a valid er reason...
	 */
	oidx->cni_er_reason = ER_INVALREAS;

	opts_end = opts + len;
	while (opts < opts_end) {
		/* must have at least 2 bytes per option (opcode and len) */
		if (opts + 2 > opts_end)
			return(GEN_INCOMPLETE);
		
		opcode = *opts++;
		oplen = *opts++;
		IFDEBUG(D_OPTIONS)
			printf("clnp_opt_sanity: opcode is %x and oplen %d\n",
				opcode, oplen);
			printf("clnp_opt_sanity: clnpoval_SRCRT is %x\n", CLNPOVAL_SRCRT);

				switch (opcode) {
					case CLNPOVAL_PAD: {
						printf("CLNPOVAL_PAD\n");
					} break;
					case CLNPOVAL_SECURE: {
						printf("CLNPOVAL_SECURE\n");
					} break;
					case CLNPOVAL_SRCRT: {
							printf("CLNPOVAL_SRCRT\n");
					} break;
					case CLNPOVAL_RECRT: {
						printf("CLNPOVAL_RECRT\n");
					} break;
					case CLNPOVAL_QOS: {
						printf("CLNPOVAL_QOS\n");
					} break;
					case CLNPOVAL_PRIOR: {
						printf("CLNPOVAL_PRIOR\n");
					} break;
					case CLNPOVAL_ERREAS: {
						printf("CLNPOVAL_ERREAS\n");
					} break;
					default:
						printf("UKNOWN option %x\n", opcode);
				}
		ENDDEBUG

		/* don't allow crazy length values */
		if (opts + oplen > opts_end)
			return(GEN_INCOMPLETE);

		switch (opcode) {
			case CLNPOVAL_PAD:
				/*
				 *	Padding: increment pointer by length of padding
				 */
				if (pad++)						/* duplicate ? */
					return(GEN_DUPOPT);
				opts += oplen;
				break;

			case CLNPOVAL_SECURE: {
				u_char	format = *opts;

				if (secure++)					/* duplicate ? */
					return(GEN_DUPOPT);
				/*
				 *	Security: high 2 bits of first octet indicate format
				 *	(00 in high bits is reserved).
				 *	Remaining bits must be 0. Remaining octets indicate
				 *	actual security
				 */
				if (((format & 0x3f) > 0) ||	/* low 6 bits set ? */
					((format & 0xc0) == 0))		/* high 2 bits zero ? */
					return(GEN_HDRSYNTAX);

				oidx->cni_securep = CLNP_OPTTOOFF(m, opts);
				oidx->cni_secure_len = oplen;
				opts += oplen;
			} break;

			case CLNPOVAL_SRCRT: {
				u_char	type, offset;	/* type of rt, offset of start */
				caddr_t	route_end;		/* address of end of route option */

				IFDEBUG(D_OPTIONS)
					printf("clnp_opt_sanity: SRC RT\n");
				ENDDEBUG

				if (srcrt++)					/* duplicate ? */
					return(GEN_DUPOPT);
				/* 
				 *	source route: There must be 2 bytes following the length
				 *	field: type and offset. The type must be either
				 *	partial route or complete route. The offset field must
				 *	be within the option. A single exception is made, however.
				 *	The offset may be 1 greater than the length. This case 
				 *	occurs when the last source route record is consumed. 
				 *	In this case, we ignore the source route option.
				 *	RAH? You should be able to set offset to 'ff' like in record
				 *	route!
				 *	Following this is a series of address fields. 
				 *	Each address field is composed of a (length, address) pair.
				 *	Insure that the offset and each address length is reasonable
				 */
				route_end = opts + oplen;

				if (opts + 2 > route_end)
					return(SRCRT_SYNTAX);

				type = *opts;
				offset = *(opts+1);


				/* type must be partial or complete */
				if (!((type == CLNPOVAL_PARTRT) || (type == CLNPOVAL_COMPRT)))
					return(SRCRT_SYNTAX);
				
				oidx->cni_srcrt_s = CLNP_OPTTOOFF(m, opts);
				oidx->cni_srcrt_len = oplen;

				opts += offset-1;	/*set opts to first addr in rt */

				/* 
				 *	Offset must be reasonable:
				 *	less than end of options, or equal to end of options
				 */
				if (opts >= route_end) {
					if (opts == route_end) {
						IFDEBUG(D_OPTIONS)
							printf("clnp_opt_sanity: end of src route info\n");
						ENDDEBUG
						break;
					} else 
						return(SRCRT_SYNTAX);
				}

				while (opts < route_end) {
					u_char	addrlen = *opts++;
					if (opts + addrlen > route_end)
						return(SRCRT_SYNTAX);
					opts += addrlen;
				}
			} break;
			case CLNPOVAL_RECRT: {
				u_char	type, offset;	/* type of rt, offset of start */
				caddr_t	record_end;		/* address of end of record option */

				if (recrt++)					/* duplicate ? */
					return(GEN_DUPOPT);
				/*
				 *	record route: after the length field, expect a
				 *	type and offset. Type must be partial or complete.
				 *	Offset indicates where to start recording. Insure it
				 *	is within the option. All ones for offset means
				 *	recording is terminated.
				 */
				record_end = opts + oplen;

				oidx->cni_recrtp = CLNP_OPTTOOFF(m, opts);
				oidx->cni_recrt_len = oplen;

				if (opts + 2 > record_end)
					return(GEN_INCOMPLETE);

				type = *opts;
				offset = *(opts+1);

				/* type must be partial or complete */
				if (!((type == CLNPOVAL_PARTRT) || (type == CLNPOVAL_COMPRT)))
					return(GEN_HDRSYNTAX);
				
				/* offset must be reasonable */
				if ((offset < 0xff) && (opts + offset > record_end))
					return(GEN_HDRSYNTAX);
				opts += oplen;
			} break;
			case CLNPOVAL_QOS: {
				u_char	format = *opts;

				if (qos++)					/* duplicate ? */
					return(GEN_DUPOPT);
				/*
				 *	qos: high 2 bits of first octet indicate format
				 *	(00 in high bits is reserved).
				 *	Remaining bits must be 0 (unless format indicates
				 *	globally unique qos, in which case remaining bits indicate
				 *	qos (except bit 6 which is reserved)).  Otherwise,
				 *	remaining octets indicate actual qos.
				 */
				if (((format & 0xc0) == 0) ||	/* high 2 bits zero ? */
					(((format & 0xc0) != CLNPOVAL_GLOBAL) && 
						((format & 0x3f) > 0))) /* not global,low bits used ? */
					return(GEN_HDRSYNTAX);
				
				oidx->cni_qos_formatp = CLNP_OPTTOOFF(m, opts);
				oidx->cni_qos_len = oplen;

				opts += oplen;
			} break;

			case CLNPOVAL_PRIOR: {
				if (prior++)				/* duplicate ? */
					return(GEN_DUPOPT);
				/*
				 *	priority: value must be one byte long
				 */
				if (oplen != 1)
					return(GEN_HDRSYNTAX);
				
				oidx->cni_priorp = CLNP_OPTTOOFF(m, opts);

				opts += oplen;
			} break;

			case CLNPOVAL_ERREAS: {
				/*
				 *	er reason: value must be two bytes long
				 */
				if (oplen != 2)
					return(GEN_HDRSYNTAX);

				oidx->cni_er_reason = *opts;

				opts += oplen;
			} break;

			default: {
				IFDEBUG(D_OPTIONS)
					printf("clnp_opt_sanity: UNKNOWN OPTION 0x%x\n", opcode);
				ENDDEBUG
				return(DISC_UNSUPPOPT);
			}
		}
	}
		IFDEBUG(D_OPTIONS)
			printf("clnp_opt_sanity: return(0)\n", opcode);
		ENDDEBUG
	return(0);
}
#endif	ISO
Commit	Line	Data
15637ed4 RG	1	/*-
	2	* Copyright (c) 1991 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*
78ed81a3	33	* from: @(#)clnp_options.c 7.8 (Berkeley) 5/6/91
78ed81a3	34	* $Id$
15637ed4 RG	35	*/
	36
	37	/***********************************************************
	38	Copyright IBM Corporation 1987
	39
	40	All Rights Reserved
	41
	42	Permission to use, copy, modify, and distribute this software and its
	43	documentation for any purpose and without fee is hereby granted,
	44	provided that the above copyright notice appear in all copies and that
	45	both that copyright notice and this permission notice appear in
	46	supporting documentation, and that the name of IBM not be
	47	used in advertising or publicity pertaining to distribution of the
	48	software without specific, written prior permission.
	49
	50	IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
	51	ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
	52	IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
	53	ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	54	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
	55	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
	56	SOFTWARE.
	57
	58	******************************************************************/
	59
	60	/*
	61	* ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
	62	*/
15637ed4 RG	63
	64	#ifdef ISO
	65
	66	#include "types.h"
	67	#include "param.h"
	68	#include "mbuf.h"
	69	#include "domain.h"
	70	#include "protosw.h"
	71	#include "socket.h"
	72	#include "socketvar.h"
	73	#include "errno.h"
	74
	75	#include "../net/if.h"
	76	#include "../net/route.h"
	77
	78	#include "iso.h"
	79	#include "clnp.h"
	80	#include "clnp_stat.h"
	81	#include "argo_debug.h"
	82
	83	/*
	84	* FUNCTION: clnp_update_srcrt
	85	*
	86	* PURPOSE: Process src rt option accompanying a clnp datagram.
	87	* - bump src route ptr if src routing and
	88	* we appear current in src route list.
	89	*
	90	* RETURNS: none
	91	*
	92	* SIDE EFFECTS:
	93	*
	94	* NOTES: If source routing has been terminated, do nothing.
	95	*/
	96	clnp_update_srcrt(options, oidx)
	97	struct mbuf options; / ptr to options mbuf */
	98	struct clnp_optidx oidx; / ptr to option index */
	99	{
	100	u_char len; /* length of current address */
	101	struct iso_addr isoa; /* copy current address into here */
	102
	103	if (CLNPSRCRT_TERM(oidx, options)) {
	104	IFDEBUG(D_OPTIONS)
	105	printf("clnp_update_srcrt: src rt terminated\n");
	106	ENDDEBUG
	107	return;
	108	}
	109
	110	len = CLNPSRCRT_CLEN(oidx, options);
	111	bcopy(CLNPSRCRT_CADDR(oidx, options), (caddr_t)&isoa, len);
	112	isoa.isoa_len = len;
	113
	114	IFDEBUG(D_OPTIONS)
	115	printf("clnp_update_srcrt: current src rt: %s\n",
	116	clnp_iso_addrp(&isoa));
	117	ENDDEBUG
	118
	119	if (clnp_ours(&isoa)) {
	120	IFDEBUG(D_OPTIONS)
	121	printf("clnp_update_srcrt: updating src rt\n");
	122	ENDDEBUG
	123
	124	/* update pointer to next src route */
	125	len++; /* count length byte too! */
	126	CLNPSRCRT_OFF(oidx, options) += len;
127	}
128	}
129
130	/*
131	* FUNCTION: clnp_dooptions
132	*
133	* PURPOSE: Process options accompanying a clnp datagram.
134	* Processing includes
135	* - log our address if recording route
136	*
137	* RETURNS: none
138	*
139	* SIDE EFFECTS:
140	*
141	* NOTES:
142	*/
143	clnp_dooptions(options, oidx, ifp, isoa)
144	struct mbuf options; / ptr to options mbuf */
145	struct clnp_optidx oidx; / ptr to option index */
146	struct ifnet ifp; / ptr to interface pkt is leaving on */
147	struct iso_addr isoa; / ptr to our address for this ifp */
148	{
149	/*
150	* If record route is specified, move all
151	* existing records over, and insert the address of
152	* interface passed
153	*/
154	if (oidx->cni_recrtp) {
155	char opt; / ptr to beginning of recrt option */
156	u_char off; /* offset from opt of first free byte */
157	char rec_start; / beginning of new rt recorded */
158
159	opt = CLNP_OFFTOOPT(options, oidx->cni_recrtp);
160	off = *(opt + 1);
161	rec_start = opt + off - 1;
162
163	IFDEBUG(D_OPTIONS)
164	printf("clnp_dooptions: record route: option x%x for %d bytes\n",
165	opt, oidx->cni_recrt_len);
166	printf("\tfree slot offset x%x\n", off);
167	printf("clnp_dooptions: recording %s\n", clnp_iso_addrp(isoa));
168	printf("clnp_dooptions: option dump:\n");
169	dump_buf(opt, oidx->cni_recrt_len);
170	ENDDEBUG
171
172	/* proceed only if recording has not been terminated */
173	if (off != 0xff) {
174	int new_addrlen = isoa->isoa_len + 1;
175	/*
176	* if there is insufficient room to store the next address,
177	* then terminate recording. Plus 1 on isoa_len is for the
178	* length byte itself
179	*/
180	if (oidx->cni_recrt_len - (off - 1) < new_addrlen) {
181	(opt + 1) = 0xff; / terminate recording */
182	} else {
183	IFDEBUG(D_OPTIONS)
184	printf("clnp_dooptions: new addr at x%x for %d\n",
185	rec_start, new_addrlen);
186	ENDDEBUG
187
188	bcopy((caddr_t)isoa, rec_start, new_addrlen);
189
190	/* update offset field */
191	*(opt + 1) += new_addrlen;
192
193	IFDEBUG(D_OPTIONS)
194	printf("clnp_dooptions: new option dump:\n");
195	dump_buf(opt, oidx->cni_recrt_len);
196	ENDDEBUG
197	}
198	}
199	}
200	}
201
202	/*
203	* FUNCTION: clnp_set_opts
204	*
205	* PURPOSE: Check the data mbuf passed for option sanity. If it is
206	* ok, then set the options ptr to address the data mbuf.
207	* If an options mbuf exists, free it. This implies that
208	* any old options will be lost. If data is NULL, simply
209	* free any old options.
210	*
211	* RETURNS: unix error code
212	*
213	* SIDE EFFECTS:
214	*
215	* NOTES:
216	*/
217	clnp_set_opts(options, data)
218	struct mbuf *options; / target for option information */
219	struct mbuf *data; / source of option information */
220	{
221	int error = 0; /* error return value */
222	struct clnp_optidx dummy; /* dummy index - not used */
223
224	/*
225	* remove any existing options
226	*/
227	if (*options != NULL) {
228	m_freem(*options);
229	*options = NULL;
230	}
231
232	if (*data != NULL) {
233	/*
234	* Insure that the options are reasonable.
235	*
236	* Also, we do not support security, priority,
237	* nor do we allow one to send an ER option
238	*
239	* The QOS parameter is checked for the DECBIT.
240	*/
241	if ((clnp_opt_sanity(data, mtod(data, caddr_t), (*data)->m_len,
242	&dummy) != 0) \|\|
243	(dummy.cni_securep) \|\|
244	(dummy.cni_priorp) \|\|
245	(dummy.cni_er_reason != ER_INVALREAS)) {
246	error = EINVAL;
247	} else {
248	options = data;
249	data = NULL; / so caller won't free mbuf @ data /
250	}
251	}
252	return error;
253	}
254
255	/*
256	* FUNCTION: clnp_opt_sanity
257	*
258	* PURPOSE: Check the options (beginning at opts for len bytes) for
259	* sanity. In addition, fill in the option index structure
260	* in with information about each option discovered.
261	*
262	* RETURNS: success (options check out) - 0
263	* failure - an ER pdu error code describing failure
264	*
265	* SIDE EFFECTS:
266	*
267	* NOTES: Each pointer field of the option index is filled in with
268	* the offset from the beginning of the mbuf data, not the
269	* actual address.
270	*/
271	clnp_opt_sanity(m, opts, len, oidx)
272	struct mbuf m; / mbuf options reside in */
273	caddr_t opts; /* ptr to buffer containing options */
274	int len; /* length of buffer */
275	struct clnp_optidx oidx; / RETURN: filled in with option idx info */
276	{
277	u_char opcode; /* code of particular option */
278	u_char oplen; /* length of a particular option */
279	caddr_t opts_end; /* ptr to end of options */
280	u_char pad = 0, secure = 0, srcrt = 0, recrt = 0, qos = 0, prior = 0;
281	/* flags for catching duplicate options */
282
283	IFDEBUG(D_OPTIONS)
284	printf("clnp_opt_sanity: checking %d bytes of data:\n", len);
285	dump_buf(opts, len);
286	ENDDEBUG
287
288	/* clear option index field if passed */
289	bzero((caddr_t)oidx, sizeof(struct clnp_optidx));
290
291	/*
292	* We need to indicate whether the ER option is present. This is done
293	* by overloading the er_reason field to also indicate presense of
294	* the option along with the option value. I would like ER_INVALREAS
295	* to have value 0, but alas, 0 is a valid er reason...
296	*/
297	oidx->cni_er_reason = ER_INVALREAS;
298
299	opts_end = opts + len;
300	while (opts < opts_end) {
301	/* must have at least 2 bytes per option (opcode and len) */
302	if (opts + 2 > opts_end)
303	return(GEN_INCOMPLETE);
304
305	opcode = *opts++;
306	oplen = *opts++;
307	IFDEBUG(D_OPTIONS)
308	printf("clnp_opt_sanity: opcode is %x and oplen %d\n",
309	opcode, oplen);
310	printf("clnp_opt_sanity: clnpoval_SRCRT is %x\n", CLNPOVAL_SRCRT);
311
312	switch (opcode) {
313	case CLNPOVAL_PAD: {
314	printf("CLNPOVAL_PAD\n");
315	} break;
316	case CLNPOVAL_SECURE: {
317	printf("CLNPOVAL_SECURE\n");
318	} break;
319	case CLNPOVAL_SRCRT: {
320	printf("CLNPOVAL_SRCRT\n");
321	} break;
322	case CLNPOVAL_RECRT: {
323	printf("CLNPOVAL_RECRT\n");
324	} break;
325	case CLNPOVAL_QOS: {
326	printf("CLNPOVAL_QOS\n");
327	} break;
328	case CLNPOVAL_PRIOR: {
329	printf("CLNPOVAL_PRIOR\n");
330	} break;
331	case CLNPOVAL_ERREAS: {
332	printf("CLNPOVAL_ERREAS\n");
333	} break;
334	default:
335	printf("UKNOWN option %x\n", opcode);
336	}
337	ENDDEBUG
338
339	/* don't allow crazy length values */
340	if (opts + oplen > opts_end)
341	return(GEN_INCOMPLETE);
342
343	switch (opcode) {
344	case CLNPOVAL_PAD:
345	/*
346	* Padding: increment pointer by length of padding
347	*/
348	if (pad++) /* duplicate ? */
349	return(GEN_DUPOPT);
350	opts += oplen;
351	break;
352
353	case CLNPOVAL_SECURE: {
354	u_char format = *opts;
355
356	if (secure++) /* duplicate ? */
357	return(GEN_DUPOPT);
358	/*
359	* Security: high 2 bits of first octet indicate format
360	* (00 in high bits is reserved).
361	* Remaining bits must be 0. Remaining octets indicate
362	* actual security
363	*/
364	if (((format & 0x3f) > 0) \|\| /* low 6 bits set ? */
365	((format & 0xc0) == 0)) /* high 2 bits zero ? */
366	return(GEN_HDRSYNTAX);
367
368	oidx->cni_securep = CLNP_OPTTOOFF(m, opts);
369	oidx->cni_secure_len = oplen;
370	opts += oplen;
371	} break;
372
373	case CLNPOVAL_SRCRT: {
374	u_char type, offset; /* type of rt, offset of start */
375	caddr_t route_end; /* address of end of route option */
376
377	IFDEBUG(D_OPTIONS)
378	printf("clnp_opt_sanity: SRC RT\n");
379	ENDDEBUG
380
381	if (srcrt++) /* duplicate ? */
382	return(GEN_DUPOPT);
383	/*
384	* source route: There must be 2 bytes following the length
385	* field: type and offset. The type must be either
386	* partial route or complete route. The offset field must
387	* be within the option. A single exception is made, however.
388	* The offset may be 1 greater than the length. This case
389	* occurs when the last source route record is consumed.
390	* In this case, we ignore the source route option.
391	* RAH? You should be able to set offset to 'ff' like in record
392	* route!
393	* Following this is a series of address fields.
394	* Each address field is composed of a (length, address) pair.
395	* Insure that the offset and each address length is reasonable
396	*/
397	route_end = opts + oplen;
398
399	if (opts + 2 > route_end)
400	return(SRCRT_SYNTAX);
401
402	type = *opts;
403	offset = *(opts+1);
404
405
406	/* type must be partial or complete */
407	if (!((type == CLNPOVAL_PARTRT) \|\| (type == CLNPOVAL_COMPRT)))
408	return(SRCRT_SYNTAX);
409
410	oidx->cni_srcrt_s = CLNP_OPTTOOFF(m, opts);
411	oidx->cni_srcrt_len = oplen;
412
413	opts += offset-1; /set opts to first addr in rt /
414
415	/*
416	* Offset must be reasonable:
417	* less than end of options, or equal to end of options
418	*/
419	if (opts >= route_end) {
420	if (opts == route_end) {
421	IFDEBUG(D_OPTIONS)
422	printf("clnp_opt_sanity: end of src route info\n");
423	ENDDEBUG
424	break;
425	} else
426	return(SRCRT_SYNTAX);
427	}
428
429	while (opts < route_end) {
430	u_char addrlen = *opts++;
431	if (opts + addrlen > route_end)
432	return(SRCRT_SYNTAX);
433	opts += addrlen;
434	}
435	} break;
436	case CLNPOVAL_RECRT: {
437	u_char type, offset; /* type of rt, offset of start */
438	caddr_t record_end; /* address of end of record option */
439
440	if (recrt++) /* duplicate ? */
441	return(GEN_DUPOPT);
442	/*
443	* record route: after the length field, expect a
444	* type and offset. Type must be partial or complete.
445	* Offset indicates where to start recording. Insure it
446	* is within the option. All ones for offset means
447	* recording is terminated.
448	*/
449	record_end = opts + oplen;
450
451	oidx->cni_recrtp = CLNP_OPTTOOFF(m, opts);
452	oidx->cni_recrt_len = oplen;
453
454	if (opts + 2 > record_end)
455	return(GEN_INCOMPLETE);
456
457	type = *opts;
458	offset = *(opts+1);
459
460	/* type must be partial or complete */
461	if (!((type == CLNPOVAL_PARTRT) \|\| (type == CLNPOVAL_COMPRT)))
462	return(GEN_HDRSYNTAX);
463
464	/* offset must be reasonable */
465	if ((offset < 0xff) && (opts + offset > record_end))
466	return(GEN_HDRSYNTAX);
467	opts += oplen;
468	} break;
469	case CLNPOVAL_QOS: {
470	u_char format = *opts;
471
472	if (qos++) /* duplicate ? */
473	return(GEN_DUPOPT);
474	/*
475	* qos: high 2 bits of first octet indicate format
476	* (00 in high bits is reserved).
477	* Remaining bits must be 0 (unless format indicates
478	* globally unique qos, in which case remaining bits indicate
479	* qos (except bit 6 which is reserved)). Otherwise,
480	* remaining octets indicate actual qos.
481	*/
482	if (((format & 0xc0) == 0) \|\| /* high 2 bits zero ? */
483	(((format & 0xc0) != CLNPOVAL_GLOBAL) &&
484	((format & 0x3f) > 0))) /* not global,low bits used ? */
485	return(GEN_HDRSYNTAX);
486
487	oidx->cni_qos_formatp = CLNP_OPTTOOFF(m, opts);
488	oidx->cni_qos_len = oplen;
489
490	opts += oplen;
491	} break;
492
493	case CLNPOVAL_PRIOR: {
494	if (prior++) /* duplicate ? */
495	return(GEN_DUPOPT);
496	/*
497	* priority: value must be one byte long
498	*/
499	if (oplen != 1)
500	return(GEN_HDRSYNTAX);
501
502	oidx->cni_priorp = CLNP_OPTTOOFF(m, opts);
503
504	opts += oplen;
505	} break;
506
507	case CLNPOVAL_ERREAS: {
508	/*
509	* er reason: value must be two bytes long
510	*/
511	if (oplen != 2)
512	return(GEN_HDRSYNTAX);
513
514	oidx->cni_er_reason = *opts;
515
516	opts += oplen;
517	} break;
518
519	default: {
520	IFDEBUG(D_OPTIONS)
521	printf("clnp_opt_sanity: UNKNOWN OPTION 0x%x\n", opcode);
522	ENDDEBUG
523	return(DISC_UNSUPPOPT);
524	}
525	}
526	}
527	IFDEBUG(D_OPTIONS)
528	printf("clnp_opt_sanity: return(0)\n", opcode);
529	ENDDEBUG
530	return(0);
531	}
532	#endif ISO