[unix-history] / usr / src / sys / netiso / iso_chksum.c

/***********************************************************
		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
 */
/* 
 * $Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $
 * $Source: /usr/argo/sys/netiso/RCS/iso_chksum.c,v $
 *	@(#)iso_chksum.c	7.3 (Berkeley) %G% *
 *
 * ISO CHECKSUM
 *
 * The checksum generation and check routines are here.
 * The checksum is 2 bytes such that the sum of all the bytes b(i) == 0
 * and the sum of i * b(i) == 0.
 * The whole thing is complicated by the fact that the data are in mbuf
 * chains.
 * Furthermore, there is the possibility of wraparound in the running
 * sums after adding up 4102 octets.  In order to avoid doing a mod
 * operation after EACH add, we have restricted this implementation to 
 * negotiating a maximum of 4096-octets per TPDU (for the transport layer).
 * The routine iso_check_csum doesn't need to know where the checksum
 * octets are.
 * The routine iso_gen_csum takes a pointer to an mbuf chain (logically
 * a chunk of data), an offset into the chunk at which the 2 octets are to
 * be stuffed, and the length of the chunk.  The 2 octets have to be
 * logically adjacent, but may be physically located in separate mbufs.
 */

#ifdef ISO
#ifndef lint
static char *rcsid = "$Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $";
#endif

#include "argo_debug.h"
#include "param.h"
#include "mbuf.h"
#endif ISO

#ifndef MNULL
#define MNULL (struct mbuf *)0
#endif MNULL

/*
 * FUNCTION:	iso_check_csum
 *
 * PURPOSE:		To check the checksum of the packet in the mbuf chain (m).
 * 				The total length of the packet is (len).
 * 				Called from tp_input() and clnp_intr()
 *
 * RETURNS:		 TRUE (something non-zero) if there is a checksum error,
 * 			 	 FALSE if there was NO checksum error.
 *
 * SIDE EFFECTS:  none
 *
 * NOTES:		 It might be possible to gain something by optimizing
 *               this routine (unrolling loops, etc). But it is such
 *				 a horrible thing to fiddle with anyway, it probably
 *				 isn't worth it.
 */
int 
iso_check_csum(m, len)
	struct mbuf *m;
	int len;
{
	register u_char *p = mtod(m, u_char *);
	register u_long c0=0, c1=0;
	register int i=0;
	int cum = 0; /* cumulative length */
	int l;

	l = len;
	len = MIN(m->m_len, len);
	i = 0;

	IFDEBUG(D_CHKSUM)
		printf("iso_check_csum: m x%x, l x%x, m->m_len x%x\n", m, l, m->m_len);
	ENDDEBUG

	while( i<l ) {
		cum += len;
		while (i<cum) {
			c0 = c0 + *(p++);
			c1 += c0;
			i++;
		}
		if(i < l) {
			m = m->m_next;
			IFDEBUG(D_CHKSUM)
				printf("iso_check_csum: new mbuf\n");
				if(l-i < m->m_len)
					printf(
					"bad mbuf chain in check csum l 0x%x i 0x%x m_data 0x%x",
						l,i,m->m_data);
			ENDDEBUG
			ASSERT( m != MNULL);
			len = MIN( m->m_len, l-i);
			p = mtod(m, u_char *);
		}
	}
	if ( ((int)c0 % 255) || ((int)c1 % 255) ) {
		IFDEBUG(D_CHKSUM)
			printf("BAD iso_check_csum l 0x%x cum 0x%x len 0x%x, i 0x%x", 
				l, cum, len, i);
		ENDDEBUG
		return ((int)c0 % 255)<<8 | ((int)c1 % 255);
	}
	return 0;
}

/*
 * FUNCTION:	iso_gen_csum
 *
 * PURPOSE:		To generate the checksum of the packet in the mbuf chain (m).
 * 				The first of the 2 (logically) adjacent checksum bytes 
 *				(x and y) go at offset (n).
 * 				(n) is an offset relative to the beginning of the data, 
 *				not the beginning of the mbuf.
 * 				(l) is the length of the total mbuf chain's data.
 * 				Called from tp_emit(), tp_error_emit()
 *				clnp_emit_er(), clnp_forward(), clnp_output().
 *
 * RETURNS:		Rien
 *
 * SIDE EFFECTS: Puts the 2 checksum bytes into the packet.
 *
 * NOTES:		Ditto the note for iso_check_csum().
 */

void
iso_gen_csum(m,n,l)
	struct mbuf *m;
	int n; /* offset of 2 checksum bytes */
	int l;
{
	register u_char *p = mtod(m, u_char *);
	register int c0=0, c1=0;
	register int i=0;
	int loc = n++, len=0; /* n is position, loc is offset */
	u_char *xloc;
	u_char *yloc;
	int cum=0;	/* cum == cumulative length */

	IFDEBUG(D_CHKSUM)
		printf("enter gen csum m 0x%x n 0x%x l 0x%x\n",m, n-1 ,l );
	ENDDEBUG

	while(i < l) {
		len = MIN(m->m_len, CLBYTES);
		/* RAH: don't cksum more than l bytes */
		len = MIN(len, l);

		cum +=len;
		p = mtod(m, u_char *);

		if(loc>=0) {
			if (loc < len) {
				xloc = loc + mtod(m, u_char *);
				IFDEBUG(D_CHKSUM)
					printf("1: zeroing xloc 0x%x loc 0x%x\n",xloc, loc );
				ENDDEBUG
				*xloc = (u_char)0;
				if (loc+1 < len) {
					/* both xloc and yloc are in same mbuf */
					yloc = 1  + xloc;
					IFDEBUG(D_CHKSUM)
						printf("2: zeroing yloc 0x%x loc 0x%x\n",yloc, loc );
					ENDDEBUG
					*yloc = (u_char)0;
				} else {
					/* crosses boundary of mbufs */
					yloc = mtod(m->m_next, u_char *);
					IFDEBUG(D_CHKSUM)
						printf("3: zeroing yloc 0x%x \n",yloc );
					ENDDEBUG
					*yloc = (u_char)0;
				}
			}
			loc -= len;
		}

		while(i < cum) {
			c0 = (c0 + *p);
			c1 += c0 ;
			i++; 
			p++;
		}
		m = m->m_next;
	}
	IFDEBUG(D_CHKSUM)
		printf("gen csum final xloc 0x%x yloc 0x%x\n",xloc, yloc );
	ENDDEBUG

	c1 = (((c0 * (l-n))-c1)%255) ;
	*xloc = (u_char) ((c1 < 0)? c1+255 : c1);

	c1 = (-(int)(c1+c0))%255;
	*yloc = (u_char) (c1 < 0? c1 + 255 : c1);

	IFDEBUG(D_CHKSUM)
		printf("gen csum end \n");
	ENDDEBUG
}

struct mbuf  *
m_append(head, m)
	struct mbuf *head, *m;
{
	register struct mbuf *n;

	if (m == 0)
		return head;
	if (head == 0)
		return m;
	n = head;
	while (n->m_next)
		n = n->m_next;
	n->m_next = m;
	return head;
}
/*
 * FUNCTION:	m_datalen
 *
 * PURPOSE:		returns length of the mbuf chain.
 * 				used all over the iso code.
 *
 * RETURNS:		integer
 *
 * SIDE EFFECTS: none
 *
 * NOTES:		
 */

int
m_datalen (morig)
	struct mbuf *morig;
{ 	
	int	s = splimp();
	register struct mbuf *n=morig;
	register int datalen = 0;

	if( morig == (struct mbuf *)0)
		return 0;
	for(;;) {
		datalen += n->m_len;
		if (n->m_next == (struct mbuf *)0 ) {
			break;
		}
		n = n->m_next;
	}
	splx(s);
	return datalen;
}

int
m_compress(in, out)
	register struct mbuf *in, **out;
{
	register 	int datalen = 0;
	int	s = splimp();

	if( in->m_next == MNULL ) {
		*out = in;
		IFDEBUG(D_REQUEST)
			printf("m_compress returning 0x%x: A\n", in->m_len);
		ENDDEBUG
		splx(s);
		return in->m_len;
	}
	MGET((*out), M_DONTWAIT, MT_DATA);
	if((*out) == MNULL) {
		*out = in;
		IFDEBUG(D_REQUEST)
			printf("m_compress returning -1: B\n");
		ENDDEBUG
		splx(s);
		return -1; 
	}
	(*out)->m_len = 0;
	(*out)->m_act = MNULL;

	while (in) {
		IFDEBUG(D_REQUEST)
			printf("m_compress in 0x%x *out 0x%x\n", in, *out);
			printf("m_compress in: len 0x%x, off 0x%x\n", in->m_len, in->m_data);
			printf("m_compress *out: len 0x%x, off 0x%x\n", (*out)->m_len, 
				(*out)->m_data);
		ENDDEBUG
		if (in->m_flags & M_EXT) {
			ASSERT(in->m_len == 0);
		}
		if ( in->m_len == 0) {
			in = in->m_next;
			continue;
		}
		if (((*out)->m_flags & M_EXT) == 0) {
			int len;

			len = M_TRAILINGSPACE(*out);
			len = MIN(len, in->m_len);
			datalen += len;

			IFDEBUG(D_REQUEST)
				printf("m_compress copying len %d\n", len);
			ENDDEBUG
			bcopy(mtod(in, caddr_t), mtod((*out), caddr_t) + (*out)->m_len,
						(unsigned)len);

			(*out)->m_len += len;
			in->m_len -= len;
			continue;
		} else {
			/* (*out) is full */
			if(( (*out)->m_next = m_get(M_DONTWAIT, MT_DATA) ) == MNULL) {
				m_freem(*out);
				*out = in;
				IFDEBUG(D_REQUEST)
					printf("m_compress returning -1: B\n");
				ENDDEBUG
				splx(s);
				return -1;
			}
			(*out)->m_len = 0;
			(*out)->m_act = MNULL;
			*out = (*out)->m_next;
		}
	}
	m_freem(in);
	IFDEBUG(D_REQUEST)
		printf("m_compress returning 0x%x: A\n", datalen);
	ENDDEBUG
	splx(s);
	return datalen;
}
Commit	Line	Data
ee8eb34a KS	1	/***********************************************************
	2	Copyright IBM Corporation 1987
	3
	4	All Rights Reserved
	5
	6	Permission to use, copy, modify, and distribute this software and its
	7	documentation for any purpose and without fee is hereby granted,
	8	provided that the above copyright notice appear in all copies and that
	9	both that copyright notice and this permission notice appear in
	10	supporting documentation, and that the name of IBM not be
	11	used in advertising or publicity pertaining to distribution of the
	12	software without specific, written prior permission.
	13
	14	IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
	15	ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
	16	IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
	17	ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	18	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
	19	ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
	20	SOFTWARE.
	21
	22	******************************************************************/
	23
	24	/*
	25	* ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
	26	*/
	27	/*
	28	* $Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $
	29	* $Source: /usr/argo/sys/netiso/RCS/iso_chksum.c,v $
44f52ea5	30	* @(#)iso_chksum.c 7.3 (Berkeley) %G% *
ee8eb34a KS	31	*
	32	* ISO CHECKSUM
	33	*
	34	* The checksum generation and check routines are here.
	35	* The checksum is 2 bytes such that the sum of all the bytes b(i) == 0
	36	* and the sum of i * b(i) == 0.
	37	* The whole thing is complicated by the fact that the data are in mbuf
	38	* chains.
	39	* Furthermore, there is the possibility of wraparound in the running
	40	* sums after adding up 4102 octets. In order to avoid doing a mod
	41	* operation after EACH add, we have restricted this implementation to
	42	* negotiating a maximum of 4096-octets per TPDU (for the transport layer).
	43	* The routine iso_check_csum doesn't need to know where the checksum
	44	* octets are.
	45	* The routine iso_gen_csum takes a pointer to an mbuf chain (logically
	46	* a chunk of data), an offset into the chunk at which the 2 octets are to
	47	* be stuffed, and the length of the chunk. The 2 octets have to be
	48	* logically adjacent, but may be physically located in separate mbufs.
	49	*/
	50
a50e2bc0	51	#ifdef ISO
ee8eb34a KS	52	#ifndef lint
	53	static char *rcsid = "$Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $";
	54	#endif
	55
a50e2bc0 KS	56	#include "argo_debug.h"
	57	#include "param.h"
	58	#include "mbuf.h"
	59	#endif ISO
ee8eb34a KS	60
	61	#ifndef MNULL
	62	#define MNULL (struct mbuf *)0
	63	#endif MNULL
	64
	65	/*
	66	* FUNCTION: iso_check_csum
	67	*
	68	* PURPOSE: To check the checksum of the packet in the mbuf chain (m).
	69	* The total length of the packet is (len).
	70	* Called from tp_input() and clnp_intr()
	71	*
	72	* RETURNS: TRUE (something non-zero) if there is a checksum error,
	73	* FALSE if there was NO checksum error.
	74	*
	75	* SIDE EFFECTS: none
	76	*
	77	* NOTES: It might be possible to gain something by optimizing
	78	* this routine (unrolling loops, etc). But it is such
	79	* a horrible thing to fiddle with anyway, it probably
	80	* isn't worth it.
	81	*/
	82	int
	83	iso_check_csum(m, len)
	84	struct mbuf *m;
	85	int len;
	86	{
	87	register u_char p = mtod(m, u_char );
	88	register u_long c0=0, c1=0;
	89	register int i=0;
	90	int cum = 0; /* cumulative length */
	91	int l;
	92
	93	l = len;
	94	len = MIN(m->m_len, len);
	95	i = 0;
	96
	97	IFDEBUG(D_CHKSUM)
	98	printf("iso_check_csum: m x%x, l x%x, m->m_len x%x\n", m, l, m->m_len);
	99	ENDDEBUG
	100
	101	while( i<l ) {
	102	cum += len;
	103	while (i<cum) {
	104	c0 = c0 + *(p++);
	105	c1 += c0;
	106	i++;
	107	}
	108	if(i < l) {
	109	m = m->m_next;
	110	IFDEBUG(D_CHKSUM)
	111	printf("iso_check_csum: new mbuf\n");
	112	if(l-i < m->m_len)
	113	printf(
a50e2bc0 KS	114	"bad mbuf chain in check csum l 0x%x i 0x%x m_data 0x%x",
a50e2bc0 KS	115	l,i,m->m_data);
ee8eb34a KS	116	ENDDEBUG
	117	ASSERT( m != MNULL);
	118	len = MIN( m->m_len, l-i);
	119	p = mtod(m, u_char *);
	120	}
	121	}
	122	if ( ((int)c0 % 255) \|\| ((int)c1 % 255) ) {
	123	IFDEBUG(D_CHKSUM)
	124	printf("BAD iso_check_csum l 0x%x cum 0x%x len 0x%x, i 0x%x",
	125	l, cum, len, i);
	126	ENDDEBUG
	127	return ((int)c0 % 255)<<8 \| ((int)c1 % 255);
	128	}
	129	return 0;
	130	}
	131
	132	/*
	133	* FUNCTION: iso_gen_csum
	134	*
	135	* PURPOSE: To generate the checksum of the packet in the mbuf chain (m).
	136	* The first of the 2 (logically) adjacent checksum bytes
	137	* (x and y) go at offset (n).
	138	* (n) is an offset relative to the beginning of the data,
	139	* not the beginning of the mbuf.
	140	* (l) is the length of the total mbuf chain's data.
	141	* Called from tp_emit(), tp_error_emit()
	142	* clnp_emit_er(), clnp_forward(), clnp_output().
	143	*
	144	* RETURNS: Rien
	145	*
	146	* SIDE EFFECTS: Puts the 2 checksum bytes into the packet.
	147	*
	148	* NOTES: Ditto the note for iso_check_csum().
	149	*/
	150
	151	void
	152	iso_gen_csum(m,n,l)
	153	struct mbuf *m;
	154	int n; /* offset of 2 checksum bytes */
	155	int l;
	156	{
ee8eb34a	157	register u_char p = mtod(m, u_char );
ee8eb34a KS	158	register int c0=0, c1=0;
	159	register int i=0;
	160	int loc = n++, len=0; /* n is position, loc is offset */
	161	u_char *xloc;
	162	u_char *yloc;
	163	int cum=0; /* cum == cumulative length */
	164
	165	IFDEBUG(D_CHKSUM)
	166	printf("enter gen csum m 0x%x n 0x%x l 0x%x\n",m, n-1 ,l );
	167	ENDDEBUG
	168
	169	while(i < l) {
	170	len = MIN(m->m_len, CLBYTES);
	171	/* RAH: don't cksum more than l bytes */
	172	len = MIN(len, l);
	173
	174	cum +=len;
	175	p = mtod(m, u_char *);
	176
	177	if(loc>=0) {
	178	if (loc < len) {
a50e2bc0	179	xloc = loc + mtod(m, u_char *);
ee8eb34a KS	180	IFDEBUG(D_CHKSUM)
	181	printf("1: zeroing xloc 0x%x loc 0x%x\n",xloc, loc );
	182	ENDDEBUG
	183	*xloc = (u_char)0;
	184	if (loc+1 < len) {
	185	/* both xloc and yloc are in same mbuf */
a50e2bc0	186	yloc = 1 + xloc;
ee8eb34a KS	187	IFDEBUG(D_CHKSUM)
	188	printf("2: zeroing yloc 0x%x loc 0x%x\n",yloc, loc );
	189	ENDDEBUG
	190	*yloc = (u_char)0;
	191	} else {
	192	/* crosses boundary of mbufs */
a50e2bc0	193	yloc = mtod(m->m_next, u_char *);
ee8eb34a KS	194	IFDEBUG(D_CHKSUM)
	195	printf("3: zeroing yloc 0x%x \n",yloc );
	196	ENDDEBUG
	197	*yloc = (u_char)0;
	198	}
	199	}
	200	loc -= len;
	201	}
	202
	203	while(i < cum) {
	204	c0 = (c0 + *p);
	205	c1 += c0 ;
	206	i++;
	207	p++;
	208	}
	209	m = m->m_next;
	210	}
	211	IFDEBUG(D_CHKSUM)
	212	printf("gen csum final xloc 0x%x yloc 0x%x\n",xloc, yloc );
	213	ENDDEBUG
	214
	215	c1 = (((c0 * (l-n))-c1)%255) ;
	216	*xloc = (u_char) ((c1 < 0)? c1+255 : c1);
	217
	218	c1 = (-(int)(c1+c0))%255;
	219	*yloc = (u_char) (c1 < 0? c1 + 255 : c1);
	220
	221	IFDEBUG(D_CHKSUM)
	222	printf("gen csum end \n");
	223	ENDDEBUG
	224	}
	225
	226	struct mbuf *
	227	m_append(head, m)
	228	struct mbuf head, m;
	229	{
	230	register struct mbuf *n;
	231
	232	if (m == 0)
	233	return head;
	234	if (head == 0)
	235	return m;
	236	n = head;
	237	while (n->m_next)
	238	n = n->m_next;
	239	n->m_next = m;
	240	return head;
	241	}
	242	/*
	243	* FUNCTION: m_datalen
	244	*
	245	* PURPOSE: returns length of the mbuf chain.
	246	* used all over the iso code.
	247	*
	248	* RETURNS: integer
	249	*
	250	* SIDE EFFECTS: none
	251	*
	252	* NOTES:
	253	*/
	254
	255	int
	256	m_datalen (morig)
	257	struct mbuf *morig;
258	{
259	int s = splimp();
260	register struct mbuf *n=morig;
261	register int datalen = 0;
262
263	if( morig == (struct mbuf *)0)
264	return 0;
265	for(;;) {
266	datalen += n->m_len;
267	if (n->m_next == (struct mbuf *)0 ) {
268	break;
269	}
270	n = n->m_next;
271	}
272	splx(s);
273	return datalen;
274	}
275
276	int
277	m_compress(in, out)
278	register struct mbuf in, *out;
279	{
280	register int datalen = 0;
281	int s = splimp();
282
283	if( in->m_next == MNULL ) {
284	*out = in;
285	IFDEBUG(D_REQUEST)
286	printf("m_compress returning 0x%x: A\n", in->m_len);
287	ENDDEBUG
288	splx(s);
289	return in->m_len;
290	}
291	MGET((*out), M_DONTWAIT, MT_DATA);
292	if((*out) == MNULL) {
293	*out = in;
294	IFDEBUG(D_REQUEST)
295	printf("m_compress returning -1: B\n");
296	ENDDEBUG
297	splx(s);
298	return -1;
299	}
300	(*out)->m_len = 0;
301	(*out)->m_act = MNULL;
302
303	while (in) {
304	IFDEBUG(D_REQUEST)
305	printf("m_compress in 0x%x out 0x%x\n", in, out);
a50e2bc0	306	printf("m_compress in: len 0x%x, off 0x%x\n", in->m_len, in->m_data);
ee8eb34a	307	printf("m_compress out: len 0x%x, off 0x%x\n", (out)->m_len,
a50e2bc0	308	(*out)->m_data);
ee8eb34a	309	ENDDEBUG
a50e2bc0	310	if (in->m_flags & M_EXT) {
ee8eb34a KS	311	ASSERT(in->m_len == 0);
	312	}
	313	if ( in->m_len == 0) {
	314	in = in->m_next;
	315	continue;
	316	}
a50e2bc0	317	if (((*out)->m_flags & M_EXT) == 0) {
ee8eb34a KS	318	int len;
ee8eb34a KS	319
a50e2bc0	320	len = M_TRAILINGSPACE(*out);
ee8eb34a KS	321	len = MIN(len, in->m_len);
	322	datalen += len;
	323
	324	IFDEBUG(D_REQUEST)
	325	printf("m_compress copying len %d\n", len);
	326	ENDDEBUG
a50e2bc0 KS	327	bcopy(mtod(in, caddr_t), mtod((out), caddr_t) + (out)->m_len,
a50e2bc0 KS	328	(unsigned)len);
ee8eb34a KS	329
	330	(*out)->m_len += len;
	331	in->m_len -= len;
	332	continue;
	333	} else {
	334	/* (out) is full /
	335	if(( (*out)->m_next = m_get(M_DONTWAIT, MT_DATA) ) == MNULL) {
	336	m_freem(*out);
	337	*out = in;
	338	IFDEBUG(D_REQUEST)
	339	printf("m_compress returning -1: B\n");
	340	ENDDEBUG
	341	splx(s);
	342	return -1;
	343	}
	344	(*out)->m_len = 0;
	345	(*out)->m_act = MNULL;
	346	out = (out)->m_next;
	347	}
	348	}
	349	m_freem(in);
	350	IFDEBUG(D_REQUEST)
	351	printf("m_compress returning 0x%x: A\n", datalen);
	352	ENDDEBUG
	353	splx(s);
	354	return datalen;
	355	}