* within the specified memory pool <pNetPool>. ** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** RETURNS* This routine returns a character pointer to a cluster buffer or NULL* if none was available.**/char * netClusterGet    (    NET_POOL_ID		pNetPool,	/* pointer to the net pool */    CL_POOL_ID 		pClPool 	/* ptr to the cluster pool */    )    {    if (pNetPool == NULL || pNetPool->pFuncTbl == NULL ||        pNetPool->pFuncTbl->pClGetRtn == NULL)        return (NULL);    return ((*pNetPool->pFuncTbl->pClGetRtn) (pNetPool, pClPool));    }/********************************************************************************* netMblkClGet - get a `clBlk'-cluster and join it to the specified `mBlk'** This routine gets a `clBlk'-cluster pair from the specified memory pool* and joins it to the specified `mBlk' structure.  The `mBlk'-`clBlk'-cluster* triplet it produces is the basic structure for handling data at all layers* of the network stack.** .IP <pNetPool> 9* Expects a pointer to the memory pool from which you want to get a * free `clBlk'-cluster pair.* .IP <pMbkl>* Expects a pointer to the `mBlk' structure (previously allocated) to which * you want to join the retrieved `clBlk'-cluster pair.  * .IP <bufSize>* Expects the size, in bytes, of the cluster in the `clBlk'-cluster pair.  * .IP <canWait>* Expects either M_WAIT or M_DONTWAIT.  If either item is not immediately* available, the M_WAIT value allows this routine to repeat the allocation* attempt after performing garbage collection. It omits those steps when the* M_DONTWAIT value is used.* .IP <bestFit>* Expects either TRUE or FALSE.  If <bestFit> is TRUE and a cluster of the * exact size is unavailable, this routine gets a larger cluster (if* available).  If <bestFit> is FALSE and an exact size cluster is unavailable, * this routine gets either a smaller or a larger cluster (depending * on what is available).  Otherwise, it returns immediately with an ERROR value.* For memory pools containing only one cluster size, <bestFit> should always* be set to FALSE.** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * This restriction does not apply under non-AE versions of VxWorks.  ** .SH "RETURNS"* OK or ERROR.** ERRNO:*  S_netBufLib_CLSIZE_INVALID*/STATUS netMblkClGet    (    NET_POOL_ID		pNetPool,	/* pointer to the net pool */    M_BLK_ID	 	pMblk, 		/* mBlk to embed the cluster in */    int			bufSize,	/* size of the buffer to get */    int			canWait,	/* wait or dontwait */    BOOL		bestFit		/* TRUE/FALSE */    )    {    if (pNetPool == NULL || pNetPool->pFuncTbl == NULL ||        pNetPool->pFuncTbl->pMblkClGetRtn == NULL)        return (ERROR);    return ((*pNetPool->pFuncTbl->pMblkClGetRtn) (pNetPool, pMblk, bufSize,                                                  canWait, bestFit));    }/********************************************************************************* netTupleGet - get an `mBlk'-`clBlk'-cluster** This routine gets an `mBlk'-`clBlk'-cluster triplet from the specified* memory pool.  The resulting structure is the basic method for accessing* data at all layers of the network stack.** .IP <pNetPool> 9* Expects a pointer to the memory pool with which you want to build a* `mBlk'-`clBlk'-cluster triplet.* .IP <bufSize>* Expects the size, in bytes, of the cluster in the `clBlk'-cluster* pair.* .IP <canWait>* Expects either M_WAIT or M_DONTWAIT.  If any item in the triplet is not* immediately available, the M_WAIT value allows this routine to repeat the* allocation attempt after performing garbage collection. The M_DONTWAIT value* prevents those extra steps.* .IP <type>* Expects the type of data, for example MT_DATA, MT_HEADER. The various* values for this type are defined in netBufLib.h.* .IP <bestFit>* Expects either TRUE or FALSE.  If <bestFit> is TRUE and a cluster of the * exact size is unavailable, this routine gets a larger cluster (if* available).  If <bestFit> is FALSE and an exact size cluster is unavailable, * this routine gets either a smaller or a larger cluster (depending * on what is available).  Otherwise, it returns immediately with an ERROR value.* For memory pools containing only one cluster size, <bestFit> should always* be set to FALSE.** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** RETURNS* M_BLK_ID or NULL.** ERRNO:*  S_netBufLib_MBLK_INVALID*  S_netBufLib_CLSIZE_INVALID*  S_netBufLib_NETPOOL_INVALID*/M_BLK_ID netTupleGet    (    NET_POOL_ID		pNetPool,	/* pointer to the net pool */    int			bufSize,	/* size of the buffer to get */    int			canWait,	/* wait or dontwait */    UCHAR		type,		/* type of data */    BOOL		bestFit		/* TRUE/FALSE */    )    {    M_BLK_ID		pMblk = NULL; 		/* pointer to mBlk */    if (pNetPool != NULL && pNetPool->pFuncTbl != NULL)        {        pMblk = mBlkGet (pNetPool, canWait, type); 	/* get an mBlk */        /* allocate a cluster and point the mBlk to it */        if (pMblk && (mClGet (pNetPool, pMblk, bufSize, canWait, bestFit)                      != OK))            {            netMblkFree (pNetPool, pMblk);             pMblk = NULL;             }        }    else        errno = S_netBufLib_NETPOOL_INVALID;     return (pMblk);     }/********************************************************************************* netClBlkJoin - join a cluster to a `clBlk' structure ** This routine joins the previously reserved cluster specified by <pClBuf> * to the previously reserved `clBlk' structure specified by <pClBlk>. * The <size> parameter passes in the size of the cluster referenced * in <pClBuf>.  The arguments <pFreeRtn>, <arg1>, <arg2>, <arg3> set the  * values of the 'pCLFreeRtn', 'clFreeArg1', 'clFreeArg2', and 'clFreeArg1', * members of the specified `clBlk' structure.** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** RETURNS: CL_BLK_ID or NULL.*/CL_BLK_ID netClBlkJoin    (    CL_BLK_ID		pClBlk,		/* pointer to a cluster Blk */    char *		pClBuf,		/* pointer to a cluster buffer */    int			size,		/* size of the cluster buffer */    FUNCPTR		pFreeRtn,	/* pointer to the free routine */    int			arg1,		/* argument 1 of the free routine */    int			arg2,		/* argument 2 of the free routine */    int			arg3		/* argument 3 of the free routine */    )    {    if (pClBlk == NULL || pClBuf == NULL)        return (NULL);    pClBlk->clNode.pClBuf 	= pClBuf;    pClBlk->clSize 		= size;    pClBlk->pClFreeRtn 		= pFreeRtn;    pClBlk->clFreeArg1 		= arg1;    pClBlk->clFreeArg2 		= arg2;    pClBlk->clFreeArg3 		= arg3;    pClBlk->clRefCnt		= 1;    return (pClBlk);    }/********************************************************************************* netMblkClJoin - join an `mBlk' to a `clBlk'-cluster construct** This routine joins the previously reserved `mBlk' referenced in <pMblk> to* the `clBlk'-cluster construct referenced in <pClBlk>. * Internally, this routine sets the M_EXT flag in 'mBlk.mBlkHdr.mFlags'.  It * also and sets the 'mBlk.mBlkHdr.mData' to point to the start of the data * in the cluster.** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** .SH "RETURNS"* M_BLK_ID or NULL. **/M_BLK_ID netMblkClJoin    (    M_BLK_ID 		pMblk,		/* pointer to an mBlk */    CL_BLK_ID		pClBlk		/* pointer to a cluster Blk */    )    {    if (pMblk == NULL || pClBlk == NULL)        return (NULL);    pMblk->mBlkHdr.mData 	= pClBlk->clNode.pClBuf;    pMblk->mBlkHdr.mFlags 	|= M_EXT;    pMblk->pClBlk		= pClBlk;    return (pMblk);    }/********************************************************************************* netClPoolIdGet - return a CL_POOL_ID for a specified buffer size * This routine returns a CL_POOL_ID for a cluster pool containing clusters * that match the specified <bufSize>.  If bestFit is TRUE, this routine returns * a CL_POOL_ID for a pool that contains clusters greater than or equal * to <bufSize>.  If <bestFit> is FALSE, this routine returns a CL_POOL_ID for a * cluster from whatever cluster pool is available.  If the memory pool * specified by <pNetPool> contains only one cluster pool, <bestFit> should * always be FALSE.** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** RETURNS: CL_POOL_ID or NULL.*/CL_POOL_ID netClPoolIdGet    (    NET_POOL_ID		pNetPool,	/* pointer to the net pool */    int 		bufSize,	/* size of the buffer */    BOOL		bestFit		/* TRUE/FALSE */    )    {    if (pNetPool == NULL || pNetPool->pFuncTbl == NULL ||        pNetPool->pFuncTbl->pClPoolIdGetRtn == NULL)        return (NULL);    return ((*pNetPool->pFuncTbl->pClPoolIdGetRtn) (pNetPool, bufSize,                                                    bestFit));    }/********************************************************************************* netMblkToBufCopy - copy data from an `mBlk' to a buffer** This routine copies data from the `mBlk' chain referenced in <pMblk> to * the buffer referenced in <pBuf>.  It is assumed that <pBuf> points to * enough memory to contain all the data in the entire `mBlk' chain.* The argument <pCopyRtn> expects either a NULL or a function pointer to a * copy routine.  The arguments passed to the copy routine are source * pointer, destination pointer and the length of data to copy.  If <pCopyRtn> * is NULL, netMblkToBufCopy() uses a default routine to extract the data from * the chain.* * .SH "RETURNS"* The length of data copied or zero.*/int netMblkToBufCopy    (    M_BLK_ID 		pMblk,		/* pointer to an mBlk */    char *		pBuf,		/* pointer to the buffer to copy */    FUNCPTR		pCopyRtn	/* function pointer for copy routine */    )    {    char *		pChar;    if (pCopyRtn == NULL)        pCopyRtn = (FUNCPTR) bcopy;	/* default copy routine */    pChar = pBuf;    while (pMblk != NULL)        {        (*pCopyRtn) ((char *)pMblk->mBlkHdr.mData, pBuf, pMblk->mBlkHdr.mLen);        pBuf 	+= pMblk->mBlkHdr.mLen;        pMblk 	= pMblk->mBlkHdr.mNext;        }    return ((int) pBuf - (int) pChar);		/* return length copied */    }/********************************************************************************* netMblkDup - duplicate an `mBlk'** This routine copies the references from a source `mBlk' in * an `mBlk'-`clBlk'-cluster construct to a stand-alone `mBlk'.* This lets the two `mBlk' structures share the same `clBlk'-cluster* construct.  This routine also increments the reference count in the * shared `clBlk'.  The <pSrcMblk> expects a pointer to the source `mBlk'.  * The <pDescMblk> parameter expects a pointer to the destination `mBlk'. ** VXWORKS AE PROTECTION DOMAINS* Under VxWorks AE, you can call this function from within the kernel * protection domain only.  In addition, all arguments to this function can  * reference only that data which is valid in the kernel protection domain. * Likewise, the returned ID is valid in the kernel protection domain only.* This restriction does not apply under non-AE versions of VxWorks.  ** .SH "RETURNS"* A pointer to the destination `mBlk' or NULL if the source `mBlk' * referenced in <pSrcMblk> is not part of a * valid `mBlk'-`clBlk'-cluster construct.**/M_BLK_ID netMblkDup    (    M_BLK_ID	pSrcMblk,		/* pointer to source mBlk */    M_BLK_ID	pDestMblk		/* pointer to the destination mBlk */    )    {    int		level;			/* level of interrupt */    if (pSrcMblk == NULL || pDestMblk == NULL)        return (NULL);    if (M_HASCL (pSrcMblk))		/* only if associated with a cluster */        {        if (pSrcMblk->mBlkHdr.mFlags & M_PKTHDR)            pDestMblk->mBlkPktHdr = pSrcMblk->mBlkPktHdr;        pDestMblk->mBlkHdr.mData 	= pSrcMblk->mBlkHdr.mData;        pDestMblk->mBlkHdr.mLen 	= pSrcMblk->mBlkHdr.mLen;        pDestMblk->mBlkHdr.mType 	= pSrcMblk->mBlkHdr.mType;        pDestMblk->mBlkHdr.mFlags 	= pSrcMblk->mBlkHdr.mFlags;        pDestMblk->pClBlk 		= pSrcMblk->pClBlk;        level = intLock ();        ++(pDestMblk->pClBlk->clRefCnt);	/* increment the ref count */        intUnlock (level);        }    else        pDestMblk = NULL;    return (pDestMblk);    }/********************************************************************************* netMblkChainDup - duplicate an `mBlk' chain** This routine makes a copy of an `mBlk' chain starting at <offset> bytes from* the beginning of the chain and continuing for <len> bytes.  If <len> * is M_COPYALL, then this routine will copy the entire `mBlk' chain from * the <offset>.* * This routine copies the references from a source <pMblk> chain to* a newly allocated `mBlk' chain. * This lets the two `mBlk' chains share the same `clBlk'-cluster* constructs.  This routine also increments the reference count in the * shared `clBlk'.  The <pMblk> expects a pointer to the source `mBlk'* chain.  * The <pNetPool> parameter expects a pointer to the netPool from which* the new `mBlk' chain is allocated.** The <canWait> parameter determines the behavior if any required 'mBlk'* is not immediately available. A valu