netbuf.c

UCOS-ii对于网络的支持代码

			
	}
	
	return st;
}


/*
 * nBufCopy - Return a new nBuf chain containing a copy of up to len bytes of
 * an nBuf chain starting "off0" bytes from the beginning.
 * Return the new chain on success, otherwise NULL. 
 */
NBuf *nBufCopy(
	NBuf *nSrc,					/* Top of nBuf chain to be copied. */
	u_int off0, 				/* Offset into the nBuf chain's data. */
	u_int len					/* Maximum bytes to copy. */
)
{
	u_int i;
	NBuf *nTop = NULL, *nDst, *nTmp;
	
	/* Find the starting position in the source chain. */
	for (; nSrc && off0 > nSrc->len; nSrc = nSrc->nextBuf)
		off0 -= nSrc->len;
	
	if (nSrc) {
		nGET(nDst);
		nTop = nDst;
		
		while (nDst && len) {
			/* Compute how much to copy from the current source buffer. */
			i = nSrc->len - off0;
			if (i > len)
				i = len;
			
			/* Copy it and advance to the next buffer if needed. */
			memcpy(nDst->data, &nSrc->data[off0], i);
#if STATS_SUPPORT > 0
			if ((nTop->chainLen += i) > nBufStats.maxChainLen.val)
				nBufStats.maxChainLen.val = nTop->chainLen;
#else
			nTop->chainLen += i;
#endif
			nDst->len = i;
			len -= i;
			off0 = 0;
			nSrc = nSrc->nextBuf;
			if (len && nSrc) {
				nGET(nTmp);
				if (nTmp) {
					nDst->nextBuf = nTmp;
					nDst = nTmp;
				} else {
					NBUFDEBUG((LOG_ERR, "nBufCopy: No free buffers"));
					(void)nFreeChain(nTop);
					nTop = NULL;
				}
			} else {
				/*** Let's just break out...
				nDst = NULL;
				***/
				break;
			}
		}
	}
	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, &n0->data[len], n1->len);
			n0->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, *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


/**********************************/
/*** LOCAL FUNCTION DEFINITIONS ***/
/**********************************/