mbuflib.c

VXWORKS源代码

    if (mbufSeg == NULL)			/* use head if mbuf NULL */
	mbufSeg = mbufId->mbufHead;

    while ((mbufNext = mbufSeg->m_next) != NULL)	/* join */
	{
        if (!(M_HASCL(mbufSeg)) || !(M_HASCL(mbufNext)))
	    break;				/* must be clusters */

	if ((mtod (mbufSeg, int) + mbufSeg->m_len) != (mtod (mbufNext, int)))
	    break;				/* data must be adjacent */

        /* check that mbuf params are the exact same */

        if ((mbufSeg->m_type		!= mbufNext->m_type) ||
           (mbufSeg->m_flags		!= mbufNext->m_flags) ||
           (mbufSeg->m_extBuf		!= mbufNext->m_extBuf) ||
           (mbufSeg->m_extRefCnt	!= mbufNext->m_extRefCnt) ||
           (mbufSeg->m_extFreeRtn	!= mbufNext->m_extFreeRtn) ||
           (mbufSeg->m_extArg1		!= mbufNext->m_extArg1) ||
           (mbufSeg->m_extArg2		!= mbufNext->m_extArg2) ||
           (mbufSeg->m_extArg3		!= mbufNext->m_extArg3) ||
           (mbufSeg->m_extSize		!= mbufNext->m_extSize))
	    break;

        mbufSeg->m_len += mbufNext->m_len;	/* join */
        mbufSeg->m_next = m_free (mbufNext);	/* bump */
        status = OK;
	}

    return (status);
    }
#endif	/* FALSE */

/*******************************************************************************
*
* _mbufSegFindPrev - find the mbuf prev to a specified byte location
*
* This routine finds the mbuf in <mbufId> that is previous to the byte
* location specified by <mbufSeg> and <pOffset>.  Once found, a pointer
* to the m_next pointer of that mbuf is returned by this routine,
* and the offset to the specified location is returned in <pOffset>. 
*
* This routine is similar to _mbufSegFind(), except that a pointer to the
* previous mbuf's m_next is returned by this routine, instead of the mbuf
* itself.  Additionally, the end boundary case differs.  This routine will
* return a valid pointer and offset when the specified byte is the byte just
* past the end of the chain.  Return values for this "imaginary" byte
* will also be returned when an offset of MBUF_END is passed in.
*
* RETURNS:
* A pointer to the m_next pointer of the mbuf previous to the mbuf associated
* with the mbuf containing the specified byte, or NULL if the operation failed.
*
* NOMANUAL
*/

LOCAL MBUF_SEG * _mbufSegFindPrev
    (
    MBUF_ID		mbufId,		/* mbuf	ID to examine */
    MBUF_SEG		mbufSeg,	/* mbuf base for <pOffset> */
    int * 		pOffset		/* relative byte offset */
    )
    {
    MBUF_SEG *		pMbufPrev;		/* prev ptr for return */
    MBUF_SEG		mbuf;			/* mbuf in chain */
    int			offset;			/* offset in bytes */
    int 		length;			/* length counter */

    if (mbufId == NULL
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (NULL);
	}

    pMbufPrev = &mbufId->mbufHead;		/* init prev ptr to head */

    if ((mbuf = mbufId->mbufHead) == NULL)	/* is this chain empty ? */
	{
	if ((mbufSeg == NULL) && (*pOffset == 0))/* empty mbuf ID ? */
	    return (pMbufPrev);			/* OK, if explicit */
        else					/* else error condition */
	    {
	    errno = S_mbufLib_ID_EMPTY;
	    return (NULL);
	    }
	}

    if ((offset = *pOffset) == MBUF_BEGIN)	/* shortcut to head of chain */
	{
	*pOffset = 0;
	return (pMbufPrev);
	}
    else if (offset == MBUF_END)		/* shortcut to end of chain */
	{
        if (mbufSeg != NULL)
	    mbuf = mbufSeg;			/* set base as <mbufSeg> */

        for (; mbuf->m_next != NULL; mbuf = mbuf->m_next)
	    ;					/* find last mbuf in chain */

        *pOffset = 0;				/* imaginary byte past mbuf */
        return (&mbuf->m_next);
	}
    else if (offset < 0)			/* counting backwards ? */
	{
        if ((mbufSeg == NULL) || (mbufSeg == mbufId->mbufHead))
	    {
	    errno = S_mbufLib_OFFSET_INVALID;
	    return (NULL);			/* offset before head */
	    }

        for (length = 0; (mbuf->m_next != NULL) && (mbuf->m_next != mbufSeg);
	    mbuf = mbuf->m_next)
	    {
	    length += mbuf->m_len;		/* find length up to base */
	    pMbufPrev = &mbuf->m_next;
	    }

        if (mbuf->m_next == NULL)
	    {
	    errno = S_mbufLib_SEGMENT_NOT_FOUND;
	    return (NULL);			/* couldn't find base mbufSeg */
	    }

        if (-(offset) < mbuf->m_len)		/* within one mbuf */
	    {
	    *pOffset += mbuf->m_len;
	    return (pMbufPrev);
	    }

	if ((offset += length + mbuf->m_len) < 0)/* adjust to positive */
	    {
	    errno = S_mbufLib_OFFSET_INVALID;
	    return (NULL);
	    }

        mbuf = mbufId->mbufHead;
        pMbufPrev = &mbufId->mbufHead;		/* init prev ptr to head */
	}
    else if ((mbufSeg != NULL) && (mbufSeg != mbuf))/* new base, init head */
        {
	if (offset < mbufSeg->m_len)		/* dest within this base ? */
	    {
	    if ((mbuf = _mbufSegPrev (mbufId, mbufSeg)) != NULL)
	        return (&mbuf->m_next);		/* located previous mbuf */
            else
	        return (NULL);
	    }

	mbuf = mbufSeg;				/* set base as <mbufSeg> */
	}

    for (; (mbuf != NULL) && (offset >= mbuf->m_len); mbuf = mbuf->m_next)
	{
        offset -= mbuf->m_len;			/* find right mbuf in chain */
	pMbufPrev = &mbuf->m_next;
	}
 
    if ((mbuf == NULL) && (offset != 0))
	{
	errno = S_mbufLib_OFFSET_INVALID;
	return (NULL);				/* too large offset */
	}

    *pOffset = offset;				/* return new offset */
    return (pMbufPrev);				/* return found mbuf */
    }

/*******************************************************************************
*
* _mbufSegFind - find the mbuf containing a specified byte location
*
* This routine finds the mbuf in <mbufId> that contains the byte location
* specified by <mbufSeg> and <pOffset>.  Once found, the mbuf is returned
* by this routine, and the offset to the specified location is returned
* in <pOffset>. 
*
* <mbufSeg> determines the base from which <pOffset> is counted.
* If <mbufSeg> is NULL, then <pOffset> starts from the beginning of <mbufId>.
* If <mbufSeg> is not NULL, then <pOffset> starts relative to that
* mbuf.  Byte locations after <mbufSeg> would be specified with a
* positive offset, whereas locations previous to <mbufSeg> would be
* accessed with a negative offset.
*
* <pOffset> is a pointer to a byte offset into the mbuf chain, with offset 0
* being the first byte of data in the mbuf.  The offset does not reset
* for each mbuf in the chain when counting through <mbufId>.  For example,
* if offset 100 is the last byte in a particular mbuf, offset 101 will be
* the first byte in the next mbuf.  Also, the offset may be a negative value.
* An offset of -1 locates the last byte in the previous mbuf.  If offset -55
* is the first byte in a mbuf, an offset -56 would be the last byte in the
* preceding mbuf.
*
* The last byte in the mbuf chain may be specified by passing in an offset of
* MBUF_END, which would cause this routine to return the last mbuf
* in the chain, and return an offset to the last byte in that mbuf.
* Likewise, an offset of MBUF_BEGIN may be passed in to specify the
* first byte in the chain, causing the routine to return the first mbuf
* in the chain, and return an offset of 0.
*
* If the <mbufSeg>, <pOffset> pair specify a byte location past the end
* of the chain, or before the first byte in the chain, NULL is returned by
* this routine.
*
* RETURNS:
* An mbuf pointer associated with the mbuf containing the specified byte,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufSegFind
    (
    MBUF_ID		mbufId,		/* mbuf	ID to examine */
    MBUF_SEG		mbufSeg,	/* mbuf base for <pOffset> */
    int * 		pOffset		/* relative byte offset */
    )
    {
    MBUF_SEG		mbuf;			/* mbuf in chain */
    int			offset;			/* offset in bytes */
    int 		length;			/* length counter */

    if (mbufId == NULL
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (NULL);
	}

    if ((mbuf = mbufId->mbufHead) == NULL)	/* is this chain empty ? */
	{
	errno = S_mbufLib_ID_EMPTY;
	return (NULL);
	}

    if ((offset = *pOffset) == MBUF_BEGIN)	/* shortcut to head of chain */
	{
	*pOffset = 0;
	return (mbuf);
	}
    else if (offset == MBUF_END)		/* shortcut to end of chain */
	{
        if (mbufSeg != NULL)
	    mbuf = mbufSeg;			/* set base as <mbufSeg> */

        for (; mbuf->m_next != NULL; mbuf = mbuf->m_next)
	    ;					/* find last mbuf in chain */

        *pOffset = mbuf->m_len - 1;		/* stuff new offset */
        return (mbuf);
	}
    else if (offset < 0)			/* counting backwards ? */
	{
        if ((mbufSeg == NULL) || (mbufSeg == mbufId->mbufHead))
	    {
	    errno = S_mbufLib_OFFSET_INVALID;
	    return (NULL);			/* offset before head */
	    }

        for (length = 0; (mbuf->m_next != NULL) && (mbuf->m_next != mbufSeg);
	    mbuf = mbuf->m_next)
	    length += mbuf->m_len;		/* find length up to base */

        if (mbuf->m_next == NULL)
	    {
	    errno = S_mbufLib_SEGMENT_NOT_FOUND;
	    return (NULL);			/* couldn't find base mbufSeg */
	    }

        if (-(offset) < mbuf->m_len)		/* within one mbuf */
	    {
	    *pOffset += mbuf->m_len;
	    return (mbuf);
	    }

	if ((offset += length + mbuf->m_len) < 0)/* adjust to positive */
	    {
	    errno = S_mbufLib_OFFSET_INVALID;
	    return (NULL);
	    }

        mbuf = mbufId->mbufHead;
	}
    else if (mbufSeg != NULL)
	mbuf = mbufSeg;				/* set base as <mbufSeg> */

    for (; (mbuf != NULL) && (offset >= mbuf->m_len); mbuf = mbuf->m_next)
        offset -= mbuf->m_len;			/* find right mbuf in chain */
 
    if (mbuf == NULL)
        errno = S_mbufLib_OFFSET_INVALID;
    else
        *pOffset = offset;			/* return new offset */

    return (mbuf);				/* return found mbuf */
    }

/*******************************************************************************
*
* _mbufSegNext - get the next mbuf in an mbuf chain
*
* This routine finds the mbuf in <mbufId> that is just after the
* mbuf <mbufSeg>.  If <mbufSeg> is NULL, the mbuf after the first
* mbuf in <mbufId> is returned.	 If <mbufSeg> is the last mbuf in
* <mbufId>, NULL is returned
*
* RETURNS:
* An mbuf pointer associated with the mbuf after <mbufSeg>, 
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufSegNext
    (
    MBUF_ID		mbufId,		/* mbuf ID to examine */
    MBUF_SEG		mbufSeg		/* mbuf to get next mbuf */
    )
    {
    if (mbufId == NULL
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (NULL);
	}

    if (mbufId->mbufHead == NULL)		/* is this chain empty ? */
	{
	errno = S_mbufLib_ID_EMPTY;
	return (NULL);
	}

    /* get mbuf after <mbufSeg> (or start of chain if <mbufSeg> is NULL) */

    if (mbufSeg == NULL)
        return (mbufId->mbufHead->m_next);
    else
        return (mbufSeg->m_next);
    }

/*******************************************************************************
*
* _mbufSegPrev - get the previous mbuf in an mbuf chain
*
* This routine finds the mbuf in <mbufId> that is just previous
* to the mbuf <mbufSeg>.  If <mbufSeg> is NULL, or is the first
* mbuf in <mbufId>, NULL will be returned.
*
* RETURNS:
* An mbuf pointer associated with the mbuf previous to <mbufSeg>,
* or NULL if the operation failed.
*
* NOMANUAL
*/

MBUF_SEG _mbufSegPrev
    (
    MBUF_ID		mbufId,		/* mbuf ID to examine */
    MBUF_SEG		mbufSeg		/* mbuf to get previous mbuf */
    )
    {
    MBUF_SEG		mbuf = mbufId->mbufHead;/* mbuf in chain */

    if (mbufId == NULL ||
	mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (NULL);
	}

    if ((mbufSeg == NULL) || (mbufSeg == mbuf))
	return (NULL);				/* no previous to first mbuf */

    /*
     * Find <mbufSeg> and return a pointer to the previous mbuf.
     * Note: OK if <mbufSeg> is not found... the return will be NULL anyway.
     */

    for (; (mbuf != NULL) && (mbuf->m_next != mbufSeg); mbuf = mbuf->m_next)
	;

    if (mbuf == NULL)				/* could not find mbufSeg */
	errno = S_mbufLib_SEGMENT_NOT_FOUND;

    return (mbuf);
    }

/*******************************************************************************
*
* _mbufSegData - determine the location of data in an mbuf
*
* This routine returns the location of the first byte of data in the mbuf
* <mbufSeg>.  If <mbufSeg> is NULL, the location of data in the first mbuf
* in <mbufId> is returned.
*
* RETURNS:
* A pointer to the first byte of data in the specified mbuf,
* or NULL if the mbuf chain is empty.
*
* NOMANUAL
*/

caddr_t _mbufSegData
    (
    MBUF_ID		mbufId,		/* mbuf ID to examine  */
    MBUF_SEG		mbufSeg		/* mbuf to get pointer to data */
    )
    {
    if (mbufId == NULL 
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (NULL);
	}

    if (mbufId->mbufHead == NULL)		/* is this chain empty ? */
	{
	errno = S_mbufLib_ID_EMPTY;
	return (NULL);
	}

    /* get data location <mbufSeg> (or start of chain if <mbufSeg> is NULL) */

    if (mbufSeg == NULL)
        return (mtod (mbufId->mbufHead, caddr_t));
    else
        return (mtod (mbufSeg, caddr_t));
    }

/*******************************************************************************
*
* _mbufSegLength - determine the length of an mbuf
*
* This routine returns the number of bytes in the mbuf <mbufSeg>.   
* If <mbufSeg> is NULL, the length of the first mbuf in <mbufId> is
* returned. 
*
* RETURNS:
* The number of bytes in the specified mbuf, or ERROR if incorrect parameters.
*
* NOMANUAL
*/

int _mbufSegLength
    (
    MBUF_ID		mbufId,		/* mbuf ID to examine  */
    MBUF_SEG		mbufSeg		/* mbuf to determine length of */
    )
    {
    if (mbufId == NULL 
	|| mbufId->type != MBUF_VALID)		/* invalid ID ? */
	{
	errno = S_mbufLib_ID_INVALID;
	return (ERROR);
	}

    if (mbufId->mbufHead == NULL)		/* is this chain empty ? */
	{
	if (mbufSeg == NULL)			/* empty mbuf chain */
	    return (0);

	errno = S_mbufLib_SEGMENT_NOT_FOUND;
	return (ERROR);
        }

    /* get length of <mbufSeg> (or start of chain if <mbufSeg> is NULL) */

    if (mbufSeg == NULL)
	return (mbufId->mbufHead->m_len);
    else
        return (mbufSeg->m_len);
    }