}
                nDst->nextBuf = nTmp;
                nDst = nTmp;
            }
                
            /* Copy it and advance to the next source buffer if needed. */
            memcpy(&nDst->data[nDst->len], &nSrc->data[off0], copySz);
#if STATS_SUPPORT > 0
            if ((nTop->chainLen += copySz) > nBufStats.maxChainLen.val)
                nBufStats.maxChainLen.val = nTop->chainLen;
#else
            nTop->chainLen += copySz;
#endif
            nDst->len += copySz;
            st += copySz;
            len -= copySz;
            off0 = 0;
            nSrc = nSrc->nextBuf;
        }
    }
    
    return st;
}


/*
 * nAppendFromQ - Append data from a source queue starting from the offset
 * onto the end of the destination chain.
 * Return the number of characters appended.
 */
u_int nAppendFromQ(
    NBuf *nDst,                 /* The destination chain. */
    NBufQHdr *nSrcQ,            /* The source queue. */
    u_int off0,                 /* The starting offset into the source. */
    u_int len                   /* The maximum bytes to copy. */
)
{
    u_int st = 0, copySz;
    NBuf *nDstTop, *nSrc, *nSrcTop, *nTmp;
    
    /* Validate parameters. */
    if (!nDst || !nSrcQ)
        return 0;
    
    /* Find the end of the destination chain. */
    nDstTop = nDst;
    while (nDst->nextBuf)
        nDst = nDst->nextBuf;
        
    /* Find the starting chain in the source queue. */
    for (nSrc = nSrcQ->qHead; nSrc && off0 >= nSrc->chainLen; nSrc = nSrc->nextChain) {
        off0 -= nSrc->chainLen;
    }
    nSrcTop = nSrc;
    
    /* Find the starting position in the source chain. */
    for (; nSrc && off0 >= nSrc->len; nSrc = nSrc->nextBuf) {
        off0 -= nSrc->len;
    }

    while (nSrc && nDst && len) {
        /* 
         * Compute how much to copy from the current source buffer. 
         * Note that since we copy from a single source buffer at a
         * time, we don't have to check that the copy size fits in
         * a single buffer.
         */
        copySz = min(len, nSrc->len - off0);

        /* Append another destination buffer if needed. */
        /* 
         * Note that we don't attempt to fill small spaces at the
         * end of the current destination buffer since on average,
         * we don't expect that it would reduce the number of
         * buffers used and it would complicate and slow the 
         * operation.
         */
        if (nTRAILINGSPACE(nDst) < copySz) {
            nGET(nTmp);
            if (!nTmp) {
                NBUFDEBUG((LOG_ERR, "nAppendFromQ: No free buffers"));
                nDst = NULL;
                break;
            }
            nDst->nextBuf = nTmp;
            nDst = nTmp;
        }
            
        /* Copy it and advance to the next source buffer if needed. */
        memcpy(&nDst->data[nDst->len], &nSrc->data[off0], copySz);
#if STATS_SUPPORT > 0
        if ((nDstTop->chainLen += copySz) > nBufStats.maxChainLen.val)
            nBufStats.maxChainLen.val = nDstTop->chainLen;
#else
        nDstTop->chainLen += copySz;
#endif
        nDst->len += copySz;
        st += copySz;
        len -= copySz;
        off0 = 0;
        if ((nSrc = nSrc->nextBuf) == NULL)
            nSrc = nSrcTop = nSrcTop->nextChain;
            
    }
    
    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, &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;
        }