[apple/xnu.git] / bsd / netiso / clnp_er.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This 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 OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*-
 * Copyright (c) 1991, 1993
 *	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.
 *
 *	@(#)clnp_er.c	8.1 (Berkeley) 6/10/93
 */

/***********************************************************
		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
 */

#include <sys/param.h>
#include <sys/mbuf.h>
#include <sys/domain.h>
#include <sys/protosw.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/errno.h>

#include <net/if.h>
#include <net/route.h>

#include <netiso/iso.h>
#include <netiso/iso_var.h>
#include <netiso/iso_pcb.h>
#define CLNP_ER_CODES
#include <netiso/clnp.h>
#include <netiso/clnp_stat.h>
#include <netiso/argo_debug.h>

static struct clnp_fixed er_template = {
	ISO8473_CLNP,	/* network identifier */
	0,				/* length */
	ISO8473_V1,		/* version */
	CLNP_TTL,		/* ttl */
	CLNP_ER,		/* type */
	0,				/* segment length */
	0				/* checksum */
};

/*
 * FUNCTION:		clnp_er_input
 *
 * PURPOSE:			Process an ER pdu.
 *
 * RETURNS:			
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			
 */
clnp_er_input(m, src, reason)
struct mbuf		*m;		/* ptr to packet itself */
struct iso_addr	*src;	/* ptr to src of er */
u_char			reason;	/* reason code of er */
{
	int	cmd = -1;
	extern u_char clnp_protox[];

	IFDEBUG(D_CTLINPUT)
		printf("clnp_er_input: m x%x, src %s, reason x%x\n", m, 
			clnp_iso_addrp(src), reason);
	ENDDEBUG

	INCSTAT(cns_er_inhist[clnp_er_index(reason)]);
	switch (reason) {
		case GEN_NOREAS:
		case GEN_PROTOERR:
			break;
		case GEN_BADCSUM:		
			cmd = PRC_PARAMPROB;
			break;
		case GEN_CONGEST:		
			cmd = PRC_QUENCH;
			break;
		case GEN_HDRSYNTAX:		
			cmd = PRC_PARAMPROB;
			break;
		case GEN_SEGNEEDED:		
			cmd = PRC_MSGSIZE; 
			break;
		case GEN_INCOMPLETE:	
			cmd = PRC_PARAMPROB; 		
			break;
		case GEN_DUPOPT:		
			cmd = PRC_PARAMPROB;		
			break;
		case ADDR_DESTUNREACH:	
			cmd = PRC_UNREACH_HOST; 	
			break;
		case ADDR_DESTUNKNOWN:	
			cmd = PRC_UNREACH_PROTOCOL; 
			break;
		case SRCRT_UNSPECERR:
		case SRCRT_SYNTAX:
		case SRCRT_UNKNOWNADDR:
		case SRCRT_BADPATH:
			cmd = PRC_UNREACH_SRCFAIL;
			break;
		case TTL_EXPTRANSIT:	
			cmd = PRC_TIMXCEED_INTRANS;	
			break;
		case TTL_EXPREASS:		
			cmd = PRC_TIMXCEED_REASS;	
			break;
		case DISC_UNSUPPOPT:
		case DISC_UNSUPPVERS:
		case DISC_UNSUPPSECURE:
		case DISC_UNSUPPSRCRT:
		case DISC_UNSUPPRECRT:
			cmd = PRC_PARAMPROB; 
			break;
		case REASS_INTERFERE:	
			cmd = PRC_TIMXCEED_REASS;
			break;
	}

	/*
	 *	tpclnp_ctlinput1 is called directly so that we don't
	 *	have to build an iso_sockaddr out of src.
	 */
	if (cmd >= 0)
		tpclnp_ctlinput1(cmd, src);

	m_freem(m);
}

/*
 * FUNCTION:		clnp_discard
 *
 * PURPOSE:			Discard a clnp datagram
 *
 * RETURNS:			nothing
 *
 * SIDE EFFECTS:	Will emit an ER pdu if possible
 *
 * NOTES:			This code assumes that we have previously tried to pull
 *					up the header of the datagram into one mbuf.
 */
clnp_discard(m, reason)
struct mbuf	*m;		/* header of packet to discard */
char					reason;	/* reason for discard */
{
	IFDEBUG(D_DISCARD)
		printf("clnp_discard: m x%x, reason x%x\n", m, reason);
	ENDDEBUG

	if (m != NULL) {
		if (m->m_len >= sizeof(struct clnp_fixed)) {
			register struct clnp_fixed *clnp = mtod(m, struct clnp_fixed *);

			if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
				(clnp->cnf_type & CNF_ERR_OK)) {
					clnp_emit_er(m, reason);
					return;
			}
		}
		m_freem(m);
	}
}

/*
 * FUNCTION:		clnp_emit_er
 *
 * PURPOSE:			Send an ER pdu.
 *					The src of the of the ER pdu is the host that is sending
 *					the ER (ie. us), *not* the original destination of the
 *					packet.
 *
 * RETURNS:			nothing
 *
 * SIDE EFFECTS:	
 *
 * NOTES:			Takes responsibility for freeing mbuf passed
 *					This function may be called with a packet that
 *					was created by us; in this case, do not send
 *					an ER.
 */
clnp_emit_er(m, reason)
struct mbuf	*m;		/* header of packet to discard */
char					reason;	/* reason for discard */
{
	register struct clnp_fixed	*clnp = mtod(m, struct clnp_fixed *);
	register struct clnp_fixed	*er;
	struct route_iso			route;
	struct ifnet				*ifp;
	struct sockaddr				*first_hop;
	struct iso_addr				src, dst, *our_addr;
	caddr_t						hoff, hend;
	int							total_len;		/* total len of dg */
	struct mbuf 				*m0;			/* contains er pdu hdr */
	struct iso_ifaddr			*ia = 0;

	IFDEBUG(D_DISCARD)
		printf("clnp_emit_er: m x%x, hdr len %d\n", m, clnp->cnf_hdr_len);
	ENDDEBUG

	bzero((caddr_t)&route, sizeof(route));

	/*
	 *	If header length is incorrect, or entire header is not contained
	 *	in this mbuf, we punt
	 */
	if ((clnp->cnf_hdr_len < CLNP_HDR_MIN) ||
		(clnp->cnf_hdr_len > CLNP_HDR_MAX) ||
		(clnp->cnf_hdr_len > m->m_len))
		goto bad;
	
	/* extract src, dest address */
	hend = (caddr_t)clnp + clnp->cnf_hdr_len;
	hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
	CLNP_EXTRACT_ADDR(dst, hoff, hend);
	if (hoff == (caddr_t)0) {
		goto bad;
	}
	CLNP_EXTRACT_ADDR(src, hoff, hend);
	if (hoff == (caddr_t)0) {
		goto bad;
	}
	
	/*
	 *	Do not send ER if we generated the packet.
	 */
	if (clnp_ours(&src))
		goto bad;

	/* 
	 *	Trim mbuf to hold only the header.
	 *	This mbuf will be the 'data' of the er pdu
	 */
	if (m->m_next != NULL) {
		m_freem(m->m_next);
		m->m_next = NULL;
	}

	if (m->m_len > clnp->cnf_hdr_len)
		m_adj(m, (int)-(m->m_len - (int)clnp->cnf_hdr_len));

	/* route er pdu: note we send pkt to src of original packet  */
	if (clnp_route(&src, &route, /* flags */0, &first_hop, &ia) != 0)
		goto bad;

	/* compute our address based upon firsthop/ifp */
	if (ia)
			our_addr = &ia->ia_addr.siso_addr;
	else
			goto bad;
	ifp = ia->ia_ifp;

	IFDEBUG(D_DISCARD)
		printf("clnp_emit_er: to %s", clnp_iso_addrp(&src));
		printf(" from %s\n", clnp_iso_addrp(our_addr));
	ENDDEBUG

	IFDEBUG(D_DISCARD)
		printf("clnp_emit_er: packet routed to %s\n", 
			clnp_iso_addrp(&((struct sockaddr_iso *)first_hop)->siso_addr));
	ENDDEBUG

	/* allocate mbuf for er pdu header: punt on no space */
	MGET(m0, M_DONTWAIT, MT_HEADER);
	if (m0 == 0)
		goto bad;
	
	m0->m_next = m;
	er = mtod(m0, struct clnp_fixed *);
	*er = er_template;

	/* setup src/dst on er pdu */
	/* NOTE REVERSAL OF SRC/DST */
	hoff = (caddr_t)er + sizeof(struct clnp_fixed);
	CLNP_INSERT_ADDR(hoff, src);
	CLNP_INSERT_ADDR(hoff, *our_addr);

	/*
	 *	TODO: if complete src rt was specified, then reverse path, and
	 *	copy into er as option.
	 */

	/* add er option */
	*hoff++ = CLNPOVAL_ERREAS;	/* code */
	*hoff++ = 2;				/* length */
	*hoff++ = reason;			/* discard reason */
	*hoff++ = 0;				/* error localization = not specified */

	/* set length */
	er->cnf_hdr_len = m0->m_len = (u_char)(hoff - (caddr_t)er);
	total_len = m0->m_len + m->m_len;
	HTOC(er->cnf_seglen_msb, er->cnf_seglen_lsb, total_len);

	/* compute checksum (on header only) */
	iso_gen_csum(m0, CLNP_CKSUM_OFF, (int)er->cnf_hdr_len);

	/* trim packet if too large for interface */
	if (total_len > ifp->if_mtu)
		m_adj(m0, -(total_len - ifp->if_mtu));
	
	/* send packet */
	INCSTAT(cns_er_outhist[clnp_er_index(reason)]);
	(void) (*ifp->if_output)(ifp, m0, first_hop, route.ro_rt);
	goto done;

bad:
	m_freem(m);

done:
	/* free route if it is a temp */
	if (route.ro_rt != NULL)
		RTFREE(route.ro_rt);
}

clnp_er_index(p)
u_char p;
{
	register u_char *cp = clnp_er_codes + CLNP_ERRORS;
	while (cp > clnp_er_codes) {
		cp--;
		if (*cp == p)
			return (cp - clnp_er_codes);
	}
	return (CLNP_ERRORS + 1);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*-
	23	* Copyright (c) 1991, 1993
	24	* The Regents of the University of California. All rights reserved.
	25	*
	26	* Redistribution and use in source and binary forms, with or without
	27	* modification, are permitted provided that the following conditions
	28	* are met:
	29	* 1. Redistributions of source code must retain the above copyright
	30	* notice, this list of conditions and the following disclaimer.
	31	* 2. Redistributions in binary form must reproduce the above copyright
	32	* notice, this list of conditions and the following disclaimer in the
	33	* documentation and/or other materials provided with the distribution.
	34	* 3. All advertising materials mentioning features or use of this software
	35	* must display the following acknowledgement:
	36	* This product includes software developed by the University of
	37	* California, Berkeley and its contributors.
	38	* 4. Neither the name of the University nor the names of its contributors
	39	* may be used to endorse or promote products derived from this software
	40	* without specific prior written permission.
	41	*
	42	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	43	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	44	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	45	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	46	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	47	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	48	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	49	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	50	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	51	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	52	* SUCH DAMAGE.
	53	*
	54	* @(#)clnp_er.c 8.1 (Berkeley) 6/10/93
	55	*/
	56
	57	/***********************************************************
	58	Copyright IBM Corporation 1987
	59
	60	All Rights Reserved
	61
	62	Permission to use, copy, modify, and distribute this software and its
	63	documentation for any purpose and without fee is hereby granted,
	64	provided that the above copyright notice appear in all copies and that
65	both that copyright notice and this permission notice appear in
66	supporting documentation, and that the name of IBM not be
67	used in advertising or publicity pertaining to distribution of the
68	software without specific, written prior permission.
69
70	IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
71	ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
72	IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
73	ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
74	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
75	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
76	SOFTWARE.
77
78	******************************************************************/
79
80	/*
81	* ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
82	*/
83
84	#include <sys/param.h>
85	#include <sys/mbuf.h>
86	#include <sys/domain.h>
87	#include <sys/protosw.h>
88	#include <sys/socket.h>
89	#include <sys/socketvar.h>
90	#include <sys/errno.h>
91
92	#include <net/if.h>
93	#include <net/route.h>
94
95	#include <netiso/iso.h>
96	#include <netiso/iso_var.h>
97	#include <netiso/iso_pcb.h>
98	#define CLNP_ER_CODES
99	#include <netiso/clnp.h>
100	#include <netiso/clnp_stat.h>
101	#include <netiso/argo_debug.h>
102
103	static struct clnp_fixed er_template = {
104	ISO8473_CLNP, /* network identifier */
105	0, /* length */
106	ISO8473_V1, /* version */
107	CLNP_TTL, /* ttl */
108	CLNP_ER, /* type */
109	0, /* segment length */
110	0 /* checksum */
111	};
112
113	/*
114	* FUNCTION: clnp_er_input
115	*
116	* PURPOSE: Process an ER pdu.
117	*
118	* RETURNS:
119	*
120	* SIDE EFFECTS:
121	*
122	* NOTES:
123	*/
124	clnp_er_input(m, src, reason)
125	struct mbuf m; / ptr to packet itself */
126	struct iso_addr src; / ptr to src of er */
127	u_char reason; /* reason code of er */
128	{
129	int cmd = -1;
130	extern u_char clnp_protox[];
131
132	IFDEBUG(D_CTLINPUT)
133	printf("clnp_er_input: m x%x, src %s, reason x%x\n", m,
134	clnp_iso_addrp(src), reason);
135	ENDDEBUG
136
137	INCSTAT(cns_er_inhist[clnp_er_index(reason)]);
138	switch (reason) {
139	case GEN_NOREAS:
140	case GEN_PROTOERR:
141	break;
142	case GEN_BADCSUM:
143	cmd = PRC_PARAMPROB;
144	break;
145	case GEN_CONGEST:
146	cmd = PRC_QUENCH;
147	break;
148	case GEN_HDRSYNTAX:
149	cmd = PRC_PARAMPROB;
150	break;
151	case GEN_SEGNEEDED:
152	cmd = PRC_MSGSIZE;
153	break;
154	case GEN_INCOMPLETE:
155	cmd = PRC_PARAMPROB;
156	break;
157	case GEN_DUPOPT:
158	cmd = PRC_PARAMPROB;
159	break;
160	case ADDR_DESTUNREACH:
161	cmd = PRC_UNREACH_HOST;
162	break;
163	case ADDR_DESTUNKNOWN:
164	cmd = PRC_UNREACH_PROTOCOL;
165	break;
166	case SRCRT_UNSPECERR:
167	case SRCRT_SYNTAX:
168	case SRCRT_UNKNOWNADDR:
169	case SRCRT_BADPATH:
170	cmd = PRC_UNREACH_SRCFAIL;
171	break;
172	case TTL_EXPTRANSIT:
173	cmd = PRC_TIMXCEED_INTRANS;
174	break;
175	case TTL_EXPREASS:
176	cmd = PRC_TIMXCEED_REASS;
177	break;
178	case DISC_UNSUPPOPT:
179	case DISC_UNSUPPVERS:
180	case DISC_UNSUPPSECURE:
181	case DISC_UNSUPPSRCRT:
182	case DISC_UNSUPPRECRT:
183	cmd = PRC_PARAMPROB;
184	break;
185	case REASS_INTERFERE:
186	cmd = PRC_TIMXCEED_REASS;
187	break;
188	}
189
190	/*
191	* tpclnp_ctlinput1 is called directly so that we don't
192	* have to build an iso_sockaddr out of src.
193	*/
194	if (cmd >= 0)
195	tpclnp_ctlinput1(cmd, src);
196
197	m_freem(m);
198	}
199
200	/*
201	* FUNCTION: clnp_discard
202	*
203	* PURPOSE: Discard a clnp datagram
204	*
205	* RETURNS: nothing
206	*
207	* SIDE EFFECTS: Will emit an ER pdu if possible
208	*
209	* NOTES: This code assumes that we have previously tried to pull
210	* up the header of the datagram into one mbuf.
211	*/
212	clnp_discard(m, reason)
213	struct mbuf m; / header of packet to discard */
214	char reason; /* reason for discard */
215	{
216	IFDEBUG(D_DISCARD)
217	printf("clnp_discard: m x%x, reason x%x\n", m, reason);
218	ENDDEBUG
219
220	if (m != NULL) {
221	if (m->m_len >= sizeof(struct clnp_fixed)) {
222	register struct clnp_fixed clnp = mtod(m, struct clnp_fixed );
223
224	if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
225	(clnp->cnf_type & CNF_ERR_OK)) {
226	clnp_emit_er(m, reason);
227	return;
228	}
229	}
230	m_freem(m);
231	}
232	}
233
234	/*
235	* FUNCTION: clnp_emit_er
236	*
237	* PURPOSE: Send an ER pdu.
238	* The src of the of the ER pdu is the host that is sending
239	* the ER (ie. us), not the original destination of the
240	* packet.
241	*
242	* RETURNS: nothing
243	*
244	* SIDE EFFECTS:
245	*
246	* NOTES: Takes responsibility for freeing mbuf passed
247	* This function may be called with a packet that
248	* was created by us; in this case, do not send
249	* an ER.
250	*/
251	clnp_emit_er(m, reason)
252	struct mbuf m; / header of packet to discard */
253	char reason; /* reason for discard */
254	{
255	register struct clnp_fixed clnp = mtod(m, struct clnp_fixed );
256	register struct clnp_fixed *er;
257	struct route_iso route;
258	struct ifnet *ifp;
259	struct sockaddr *first_hop;
260	struct iso_addr src, dst, *our_addr;
261	caddr_t hoff, hend;
262	int total_len; /* total len of dg */
263	struct mbuf m0; / contains er pdu hdr */
264	struct iso_ifaddr *ia = 0;
265
266	IFDEBUG(D_DISCARD)
267	printf("clnp_emit_er: m x%x, hdr len %d\n", m, clnp->cnf_hdr_len);
268	ENDDEBUG
269
270	bzero((caddr_t)&route, sizeof(route));
271
272	/*
273	* If header length is incorrect, or entire header is not contained
274	* in this mbuf, we punt
275	*/
276	if ((clnp->cnf_hdr_len < CLNP_HDR_MIN) \|\|
277	(clnp->cnf_hdr_len > CLNP_HDR_MAX) \|\|
278	(clnp->cnf_hdr_len > m->m_len))
279	goto bad;
280
281	/* extract src, dest address */
282	hend = (caddr_t)clnp + clnp->cnf_hdr_len;
283	hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
284	CLNP_EXTRACT_ADDR(dst, hoff, hend);
285	if (hoff == (caddr_t)0) {
286	goto bad;
287	}
288	CLNP_EXTRACT_ADDR(src, hoff, hend);
289	if (hoff == (caddr_t)0) {
290	goto bad;
291	}
292
293	/*
294	* Do not send ER if we generated the packet.
295	*/
296	if (clnp_ours(&src))
297	goto bad;
298
299	/*
300	* Trim mbuf to hold only the header.
301	* This mbuf will be the 'data' of the er pdu
302	*/
303	if (m->m_next != NULL) {
304	m_freem(m->m_next);
305	m->m_next = NULL;
306	}
307
308	if (m->m_len > clnp->cnf_hdr_len)
309	m_adj(m, (int)-(m->m_len - (int)clnp->cnf_hdr_len));
310
311	/* route er pdu: note we send pkt to src of original packet */
312	if (clnp_route(&src, &route, /* flags */0, &first_hop, &ia) != 0)
313	goto bad;
314
315	/* compute our address based upon firsthop/ifp */
316	if (ia)
317	our_addr = &ia->ia_addr.siso_addr;
318	else
319	goto bad;
320	ifp = ia->ia_ifp;
321
322	IFDEBUG(D_DISCARD)
323	printf("clnp_emit_er: to %s", clnp_iso_addrp(&src));
324	printf(" from %s\n", clnp_iso_addrp(our_addr));
325	ENDDEBUG
326
327	IFDEBUG(D_DISCARD)
328	printf("clnp_emit_er: packet routed to %s\n",
329	clnp_iso_addrp(&((struct sockaddr_iso *)first_hop)->siso_addr));
330	ENDDEBUG
331
332	/* allocate mbuf for er pdu header: punt on no space */
333	MGET(m0, M_DONTWAIT, MT_HEADER);
334	if (m0 == 0)
335	goto bad;
336
337	m0->m_next = m;
338	er = mtod(m0, struct clnp_fixed *);
339	*er = er_template;
340
341	/* setup src/dst on er pdu */
342	/* NOTE REVERSAL OF SRC/DST */
343	hoff = (caddr_t)er + sizeof(struct clnp_fixed);
344	CLNP_INSERT_ADDR(hoff, src);
345	CLNP_INSERT_ADDR(hoff, *our_addr);
346
347	/*
348	* TODO: if complete src rt was specified, then reverse path, and
349	* copy into er as option.
350	*/
351
352	/* add er option */
353	hoff++ = CLNPOVAL_ERREAS; / code */
354	hoff++ = 2; / length */
355	hoff++ = reason; / discard reason */
356	hoff++ = 0; / error localization = not specified */
357
358	/* set length */
359	er->cnf_hdr_len = m0->m_len = (u_char)(hoff - (caddr_t)er);
360	total_len = m0->m_len + m->m_len;
361	HTOC(er->cnf_seglen_msb, er->cnf_seglen_lsb, total_len);
362
363	/* compute checksum (on header only) */
364	iso_gen_csum(m0, CLNP_CKSUM_OFF, (int)er->cnf_hdr_len);
365
366	/* trim packet if too large for interface */
367	if (total_len > ifp->if_mtu)
368	m_adj(m0, -(total_len - ifp->if_mtu));
369
370	/* send packet */
371	INCSTAT(cns_er_outhist[clnp_er_index(reason)]);
372	(void) (*ifp->if_output)(ifp, m0, first_hop, route.ro_rt);
373	goto done;
374
375	bad:
376	m_freem(m);
377
378	done:
379	/* free route if it is a temp */
380	if (route.ro_rt != NULL)
381	RTFREE(route.ro_rt);
382	}
383
384	clnp_er_index(p)
385	u_char p;
386	{
387	register u_char *cp = clnp_er_codes + CLNP_ERRORS;
388	while (cp > clnp_er_codes) {
389	cp--;
390	if (*cp == p)
391	return (cp - clnp_er_codes);
392	}
393	return (CLNP_ERRORS + 1);
394	}