netbuf.c

uC/IP Release Notes These release notes for uC/IP are divided into the following sections

		}
	}
	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 >= 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 > 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)