netbuf.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

		}

	}

	return nTop;

}





/*

 * nPullup - Rearange an nBuf chain so that len bytes are contiguous and in

 * the data area of the buffer thereby allowing direct access to a structure

 * of size len. 

 * Return the resulting nBuf chain on success.  On failure, the original

 * nBuf is freed and NULL is returned.

 */

NBuf *nPullup(NBuf *nIn, u_int len)

{

	char *s, *d;

	u_int i;

	NBuf *nTmp, *nPrev, *nNext;

	

	if (!nIn)

		;

	/* If the required data is already in the first buffer, we're done! */

	else if (nIn->len >= len)

		;

	/* If the required data won't fit in the first buffer, fail! */

	else if (len > NBUFSZ) {

		(void)nFreeChain(nIn);

		nIn = NULL;

	} else {

		/* If there's not enough space at the end, shift the data to the beginning. */

		if (nTRAILINGSPACE(nIn) < len) {

			s = nBUFTOPTR(nIn, char *);

			d = nIn->data = &nIn->body[0];

			for (i = nIn->len; i > 0; i--)

				*d++ = *s++;

		}

		/* Move the data in from successive buffers. */

		nPrev = nIn;

		nNext = nIn->nextBuf;

		while (len && nNext) {

			i = min(len, nNext->len);

			memcpy(&nIn->data[nIn->len], nNext->data, i);

			nIn->len += i;

			/* If this emptied the buffer, free it. */

			if ((nNext->len -= i) == 0) {

				nTmp = nNext;

				nFREE(nTmp, nNext);

				nPrev->nextBuf = nNext;

			} else {

				nNext->data += i;

			}

			len -= i;

			nPrev = nNext;

			nNext = nNext->nextBuf;

		}

	}

	return nIn;

}





/*

 * nCopyOut - Copy len bytes from an nBuf chain starting from an offset in

 * that chain.

 * Return the number of bytes copied.

 */

u_int nCopyOut(

	char *d, 					/* Destination string. */

	NBuf *n0, 					/* Source nBuf chain. */

	u_int off0, 				/* Offset into the nBuf chain's data. */

	u_int len					/* Max bytes to copy. */

)

{

	u_int copied = 0, i;

	NBuf *nNext;

	

	/* Find the starting position in the original chain. */

	for (nNext = n0; nNext && off0 > nNext->len; nNext = nNext->nextBuf)

		off0 -= nNext->len;

	

	while (len && nNext) {

		i = min(len, nNext->len - off0);

		memcpy(&d[copied], &nNext->data[off0], i);

		off0 = 0;

		copied += i;

		len -= i;

		nNext = nNext->nextBuf;

	}

	

	return copied;

}



/*

 * nSplit - Partition an nBuf chain in two pieces leaving len bytes in the

 * original chain.  A len of zero leaves an empty nBuf for n0.  A len longer

 * than the amount of data in the chain returns NULL.

 * Return the new chain produced by the tail on success.  Otherwise, return

 * NULL and attempt to restore the chain to its original state.

 */

NBuf *nSplit(

	NBuf *n0, 					/* The chain to be split. */

	u_int len					/* The bytes to leave in the original chain. */

)

{

	NBuf *n1 = NULL, *nNext;

	u_int off0 = len;

	

	/* Find the starting position in the original chain. */

	for (nNext = n0; nNext && len > nNext->len; nNext = nNext->nextBuf)

		len -= nNext->len;

	

	/* If the chain is too short, return nothing. */

	if (!nNext)

		;

	/* If the chain breaks on the desired boundary, trivial case. */

	else if (len == nNext->len) {

		n1 = nNext->nextBuf;

		nNext->nextBuf = NULL;

		n1->chainLen = n0->chainLen - off0;

		n0->chainLen = off0;

	}

	/* Otherwise we need to split this next buffer. */

	else {

		nGET(n1);

		if (n1) {

			n1->len = nNext->len - len;

			n1->nextBuf = nNext->nextBuf;

			nNext->nextBuf = NULL;

			/* Move the data to the end of the new buffer to leave space for

			 * new headers. */

			n1->data = &n1->body[NBUFSZ - n1->len];



			memcpy(n1->data, &nNext->data[len], n1->len);

			nNext->len -= n1->len;



			n1->chainLen = n0->chainLen - off0;

			n0->chainLen = off0;

		}

		/* If !n1, we return NULL. */

	}

	

	return n1;

}





/* 

 * nTrim - Trim up to len bytes from the chain, copying the data into

 * dst if dst is not NULL.  len > 0 trims off the front,

 * len < 0 trims off the end.  *nb is set to the new chain, NULL if

 * |len| >= the amount of data in the chain.

 * Note that this depends on the chain length field being accurate.

 * Return the actual number of bytes trimmed (always positive).

 */

int nTrim(char *dst, NBuf **nb, int len)

{

	int st = 0;

	NBuf* n0;

	NBuf* n1;

	u_int cLen;				/* Total chain length. */

	

	if (!len || !nb || !(*nb))

		;

	else if (len > 0) {

		n0 = *nb;

		cLen = n0->chainLen;

		

		/* Trim whole leading buffers. */

		while (n0 && len >= (int)(n0->len)) {

			st += n0->len;

			len -= n0->len;

			cLen -= n0->len;

			if (dst) {

				memcpy(dst, n0->data, n0->len);

				dst += n0->len;

			}

			nFREE(n0, n1);

			n0 = n1;

		}

		/* Trim partial buffers. */

		if (n0) {

			if (len) {

				st += len;

				cLen -= len;

				if (dst) {

					memcpy(dst, n0->data, len);

				}

				n0->data += len;

				n0->len -= len;

			}

			n0->chainLen = cLen;

		}

		*nb = n0;

	} else {

		len = -len;

		n0 = *nb;

		cLen = n0->chainLen;

		if (cLen > (unsigned int)len) {

			n1 = nSplit(n0, cLen - len);

		} else {

			n1 = n0;

			n0 = NULL;

		}

		st = nTrim(dst, &n1, len);

		*nb = n0;

	}

	

	return st;

}



/*

 * nTrimQ - Trim bytes from the front of a buffer queue.

 * Note: The queue needs to be protected from collisions for the duration

 * of this call.

 * Return the number of bytes trimmed.

 */

int nTrimQ(char *dst, NBufQHdr *qh, u_int len)

{

	int st = 0;

	

	if (qh && qh->qHead && len) {

		NBuf *n0;

		int trimmed;

		

		/* Trim entire chains. */

#ifdef XXX

		OS_ENTER_CRITICAL();

#endif

		while (qh->qHead && len >= qh->qHead->chainLen) {

			if ((qh->qHead = (n0 = qh->qHead)->nextChain) == NULL)

				qh->qTail = NULL;

			qh->qLen--;

#ifdef XXX

			OS_EXIT_CRITICAL();

#endif

			

			n0->nextChain = NULL;

			trimmed = nTrim(dst, &n0, len);

			if (dst)

				dst += trimmed;

			len -= trimmed;

			st += trimmed;

#ifdef XXX

			OS_ENTER_CRITICAL();

#endif

		}

		

		/* If more to go, trim from next chain. */

		if (len && qh->qHead) {

			/* 

			 * XXX LONG CRITICAL SECTION!!!  Could we pop this off the queue,

			 * trim it, and then replace the remainder?  Do we need a semaphore? 

			 */

			trimmed = nTrim(dst, &qh->qHead, len);

			st += trimmed;

		}

#ifdef XXX

		OS_EXIT_CRITICAL();

#endif

	}

	

	return st;

}





/*

 * nCat - Concatenate nBuf chain n2 to n1.  The chain length of n2 is added

 * to n1.

 * Return the new chain.

 */

NBuf *nCat(NBuf *n1, NBuf *n2)

{

	NBuf *nNext;

	

	if (!n1 || !n2)

		;

	else {

		for (nNext = n1; nNext->nextBuf; nNext = nNext->nextBuf)

			;

		nNext->nextBuf = n2;

#if STATS_SUPPORT > 0

		if ((n1->chainLen += n2->chainLen) > nBufStats.maxChainLen.val)

			nBufStats.maxChainLen.val = n1->chainLen;

#else

		n1->chainLen += n2->chainLen;

#endif

	}

	

	return n1;

}





/*

 * nChainLen - Determine the chain length of the mBuf chain and update the

 * chain length field of the top buffer.

 * Return the chain length.

 */

u_int nChainLen(NBuf *n)

{

	u_int chainLen = 0;

	NBuf *nNext;

	

	for (nNext = n; nNext; nNext = nNext->nextBuf)

		chainLen += nNext->len;

	n->chainLen = chainLen;

#if STATS_SUPPORT > 0

	if (chainLen > nBufStats.maxChainLen.val)

		nBufStats.maxChainLen.val = chainLen;

#endif



	return chainLen;

}





/*

 * nEnqSort - Insert a new chain into the queue in sorted order.

 * The sort function is designed to handle wrapping 32 bit values.

 * Return the number of chains in the queue on success, an error code

 * on error.

 */

int nEnqSort(NBufQHdr *qh, NBuf *nb, u_int32 sort) 

{

	int st;

	

	OS_ENTER_CRITICAL();

	if (!qh || !nb)

		st = -1;

	else if (!qh->qHead) {

		qh->qHead = qh->qTail = nb;

		nb->nextChain = NULL;

		st = qh->qLen = 1;

	} else {

		NBuf *n0;

		/*** NOTE: Potentially long critical section. ***/

		for(n0 = qh->qHead; 

			n0->nextChain && (long)(sort - nb->sortOrder) >= 0;

			n0 = n0->nextChain)

			;

		nb->nextChain = n0->nextChain;

		n0->nextChain = nb;

		st = ++qh->qLen;

	}

	OS_EXIT_CRITICAL();

	

	return st;

}

		

#if DEBUG_SUPPORT > 0

/*

 * nDumpChain - Dump the details of the given buffer chain to the trace log.

 */

void nDumpChain(NBuf *n)

{

	int bufNum, len, dLen;

	u_char *dPtr;

	

	trace(LOG_INFO, "Buffer chain len=%u", n->chainLen);

	for (bufNum = 0; n; bufNum++) {

		dPtr = nBUFTOPTR(n, u_char *);

		for (len = n->len; len > 0;) {

			dLen = MIN(len, 32);

			trace(LOG_INFO, "Buf %d[%d]:%.*H", bufNum, dLen, dLen * 2, dPtr);

			len -= dLen;

			dPtr += dLen;

		}

		n = n->nextBuf;

	}

}

#endif



/*

 * inChkSum - Compute the internet ones complement 16 bit checksum for a given

 * length of a network buffer chain starting at offset off0.

 * Return the checksum in network byte order.

 */

#define ADDCARRY(x)  (x > 65535 ? x -= 65535 : x)

#define REDUCE {l_util.l = sum; sum = (u_long)l_util.s[0] + (u_long)l_util.s[1]; ADDCARRY(sum);}



u_short _inChkSum(NBuf *nb, u_short len, u_short off0, u_short start_sum)

{

	register u_short *w;

	register long sum = start_sum;

	register int bufLen = 0;

	register NBuf *n0 = nb;

	int byte_swapped = 0;



	union {

		char	c[2];

		u_short	s;

	} s_util;

	union {

		u_short s[2];

		long	l;

	} l_util;



	/* Ensure that there is enough data for the offset. */

	if (nb->len <= off0)

		return -1;

	

	/*

	 * Adjust buffer start for the offset.

	 */

	nb->len -= off0;

	nb->data += off0;

	for (;n0 && len; n0 = n0->nextBuf) {

		if (n0->len <= 0)

			continue;

		w = nBUFTOPTR(n0, u_short *);

		if (bufLen == -1) {

			/*

			 * The first byte of this nBuf is the continuation

			 * of a word spanning between this nBuf and the

			 * last nBuf.

			 *

			 * s_util.c[0] is already saved when scanning previous 

			 * nBuf.

			 */

			s_util.c[1] = *(char *)w;

			sum += s_util.s;

			w = (u_short *)((char *)w + 1);

			bufLen = n0->len - 1;

			len--;

		} else

			bufLen = n0->len;

		if (len < bufLen)

			bufLen = len;

		len -= bufLen;

		/*

		 * Force to even boundary.

		 */

		if ((1 & (int) w) && (bufLen > 0)) {

			REDUCE;

			sum <<= 8;

			s_util.c[0] = *(u_char *)w;

			w = (u_short *)((char *)w + 1);

			bufLen--;

			byte_swapped = 1;

		}

		/*

		 * Unroll the loop to make overhead from

		 * branches &c small.

		 */

		while ((bufLen -= 32) >= 0) {

			sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];

			sum += w[4]; sum += w[5]; sum += w[6]; sum += w[7];

			sum += w[8]; sum += w[9]; sum += w[10]; sum += w[11];

			sum += w[12]; sum += w[13]; sum += w[14]; sum += w[15];

			w += 16;

		}

		bufLen += 32;

		while ((bufLen -= 8) >= 0) {

			sum += w[0]; sum += w[1]; sum += w[2]; sum += w[3];

			w += 4;

		}

		bufLen += 8;

		if (bufLen == 0 && byte_swapped == 0)

			continue;

		REDUCE;

		while ((bufLen -= 2) >= 0) {

			sum += *w++;

		}

		if (byte_swapped) {

			REDUCE;

			sum <<= 8;

			byte_swapped = 0;

			if (bufLen == -1) {

				s_util.c[1] = *(char *)w;

				sum += s_util.s;

				bufLen = 0;

			} else

				bufLen = -1;

		} else if (bufLen == -1)

			s_util.c[0] = *(char *)w;

	}

	/*

	 * Reset buffer start for the offset.

	 */

	nb->len += off0;

	nb->data -= off0;

	

    if (len) {

		IPDEBUG((LOG_ERR, TL_IP, "inChkSum: out of data"));

    }

	if (bufLen == -1) {

		/* The last nBuf has odd # of bytes. Follow the

		   standard (the odd byte may be shifted left by 8 bits

		   or not as determined by endian-ness of the machine) */

		s_util.c[1] = 0;

		sum += s_util.s;

	}

	REDUCE;

	return ((u_short)(~sum) & 0xffff);

}



u_short inChkSum(NBuf *nb, u_short len, u_short off0)

{

    return _inChkSum(nb, len, off0, 0);

}





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

/*** LOCAL FUNCTION DEFINITIONS ***/

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



//#pragma warning (pop)