(    PACKETBUF * pPacketBuf    )    {    if( pPacketBuf == NULL )        {        return NULL;        }    if( pPacketBuf->pBuffer == NULL )        {        return NULL;        }    return (pPacketBuf->pBuffer + pPacketBuf->reservedHdrSize);    } /* end packetBufDataGet() *//************************************************************************/UINT packetBufDataSizeGet    (    PACKETBUF * pPacketBuf    )    {    if( pPacketBuf == NULL )        {        return 0;        }    if( pPacketBuf->pBuffer == NULL )        {        return 0;        }    return pPacketBuf->dataLength;    } /* packetBufDataSizeGet() *//************************************************************************/UINT packetBufBufferSizeGet    (    PACKETBUF * pPacketBuf    )    {    if( pPacketBuf == NULL )        {        return 0;        }    if( pPacketBuf->pBuffer == NULL )        {        return 0;        }    return pPacketBuf->bufSize;    } /* end packetBufBufferSizeGet() *//************************************************************************/UINT packetBufMaxWritableHeaderSizeGet    (    PACKETBUF * pPacketBuf    )    {    if( pPacketBuf == NULL )        {        return 0;        }    if( pPacketBuf->pBuffer == NULL )        {        return 0;        }    return pPacketBuf->reservedHdrSize;    } /* end packetBufMaxWritableHeaderSizeGet() *//************************************************************************/BOOL packetBufIsBuiltFromMBuf    (    PACKETBUF * pPacketBuf    )    {     if( pPacketBuf == NULL )        {        return FALSE;        }    return pPacketBuf->isFromMBuf;    } /* end packetBufIsBuiltFromMBuf() *//******************************************************************/void packetMBufDestruct    (    PACKETBUF ** ppMBufPacket    )    {    if (*ppMBufPacket != NULL)        {        packetBufFree( *ppMBufPacket );        *ppMBufPacket = NULL;        }    return;    } /* end packetMBufDestruct() *//*****************************************************************************/PACKETBUF * packetBufCreateFromMBuf    (    struct mbuf * pMBuf    )    {    PACKETBUF *pPacketBuf = NULL;    if( pMBuf == NULL )        {        return NULL;        }    /* In the case of a packetBuf created to wrap an mbuf, the fields     * ->pBuffer and ->bufSize fields must be determined from the mbuf     * itself, so packetBufCreate() isn't called here. */    pPacketBuf = (PACKETBUF *)wrSecCalloc(1,sizeof(PACKETBUF) );    if( pPacketBuf == NULL ) return NULL;    if( packetMBufInit( pPacketBuf, pMBuf ) == FALSE )        {        wrSecFree(pPacketBuf);        return NULL;        }    return pPacketBuf;    } /* end packetBufCreateFromMBuf() *//*****************************************************************************/struct mbuf * packetMBufExtract    (    PACKETBUF * pMBufPacket    )    {    struct mbuf * pMBuf = NULL;    if( pMBufPacket == NULL )        {        return NULL;        }    pMBuf = pMBufPacket->pMBuf;    pMBuf->mBlkHdr.mData  = (char *)packetBufDataGet((PACKETBUF *)pMBufPacket);    pMBuf->mBlkHdr.mLen = packetBufDataSizeGet((PACKETBUF *)pMBufPacket);    pMBuf->mBlkPktHdr.len = pMBuf->mBlkHdr.mLen;    packetMBufDestruct (&pMBufPacket);    return pMBuf;    } /* end packetMBufExtract() *//*******************************************************************************/struct mbuf* packetMBufCreate    (    struct mbuf *pSourcePacket    )    {    UINT            total_length;    UINT            total_pktHdr_length;    UINT            mblk_clk_size;    UINT            reservedHdrSize;    struct mbuf   * pPacket;    struct mbuf   * pNextMBuf;    unsigned char * pPayload;    char          * pSourceBuffer;    pPacket = NULL;    pPayload = NULL;    pNextMBuf = NULL;    total_length = 0;    total_pktHdr_length = 0;    mblk_clk_size = 0;    pSourceBuffer = NULL;    if (pSourcePacket->mBlkPktHdr.len > 65408 )        {        printf( "packetMBufCreate(): FATAL ERROR - Received mBlk data size too big ( >65408 ).\n" );        return NULL;        }    reservedHdrSize = IPSEC_PACKETBUF_RESERVED_SIZE;#if STACK_NAME == STACK_NAME_V4_V6    mblk_clk_size = pSourcePacket->mBlkPktHdr.len + reservedHdrSize;    MGET1(pPacket, mblk_clk_size, M_WAIT, pSourcePacket->m_type);    if (pPacket != NULL)        {        bzero(mtod(pPacket, caddr_t), pPacket->m_extSize);        /* copy the reserved field , Needed to determine fragmentation needed.*/        pPacket->mBlkHdr.reserved = pSourcePacket->mBlkHdr.reserved;        }#else /*  STACK_NAME == STACK_NAME_V4_V6_ */    mblk_clk_size = pSourcePacket->mBlkPktHdr.len + reservedHdrSize;    pPacket = m_getclr (M_WAIT, pSourcePacket->m_type, mblk_clk_size, TRUE);#endif /* STACK_NAME == STACK_NAME_V4_V6 */    if (pPacket == NULL)        {        printf(" packetMBufCreate(): Warning!  Failed to get new mBlk of size = %d, check memory pool.\n", mblk_clk_size );        return (NULL);        }    /*header */    pPacket->mBlkHdr.mType = pSourcePacket->mBlkHdr.mType;    pPacket->mBlkHdr.mFlags = pSourcePacket->mBlkHdr.mFlags;    /* pkthdr */    pPacket->mBlkPktHdr.rcvif = pSourcePacket->mBlkPktHdr.rcvif;    pPayload = (unsigned char *)mtod (pPacket, char *);    pPayload = (unsigned char *)((ULONG)pPayload + IPSEC_PACKETBUF_RESERVED_HEADER_SIZE);    /*copy data segments */    pNextMBuf = pSourcePacket;    while (pNextMBuf != NULL)        {        pSourceBuffer = (char *)mtod (pNextMBuf, char *);        bcopy ((const char*)pSourceBuffer, (char *)pPayload,  pNextMBuf->m_len);        total_length += pNextMBuf->m_len;        if (total_length >= mblk_clk_size - reservedHdrSize)            {            break;            }        total_pktHdr_length += pNextMBuf->mBlkPktHdr.len;        pPayload = (unsigned char *)((ULONG)pPayload + pNextMBuf->m_len);        pNextMBuf = pNextMBuf->m_next;        }    pPacket->m_len = total_length;    pPacket->mBlkPktHdr.len = total_length;    return pPacket;    } /* end packetMBufCreate() *//*****************************************************************************/LOCAL BOOL packetMBufInit    (    PACKETBUF   * pMBufPacket,    struct mbuf * pMBuf    )    {    UINT buffer_size;    register struct mbuf* pNewMBuf;    buffer_size = 0;    pNewMBuf = NULL;    if( pMBufPacket == NULL )        {        return FALSE;        }    if( (pMBuf->m_flags & M_EXT) == 0 )        {        printf( "packetMBufInit(): WARNING! Received mBlk is not using memory cluster.\n" );#if defined (IPSEC_PACKETBUF_DEBUG)        assert (0); /*mBlk is not using cluster*/#else        return FALSE;#endif /* IPSEC_PACKETBUF_DEBUG */        }    if( (pMBuf->m_flags == 0) && (pMBuf->m_data == NULL) )        {        printf( "packetMBufInit(): WARNING! Empty mBlk received from IP Stack.\n" );#if defined (IPSEC_PACKETBUF_DEBUG)        assert (0); /*empty or new buffer */#else        return FALSE;#endif /* IPSEC_PACKETBUF_DEBUG */        }    buffer_size = pMBuf->pClBlk->clSize;    pNewMBuf = packetMBufCreate(pMBuf);    if( pNewMBuf == NULL )        {        return FALSE;        }    #if defined(IPSEC_PACKETBUF_DEBUG)    printf( "packetMBufInit(): freeing mbuf at 0x%08x\n", pMBuf );    #endif    m_freem( pMBuf );    pMBufPacket->pBuffer = (unsigned char *)mtod(pNewMBuf, char*);    pMBufPacket->dataLength = pNewMBuf->mBlkPktHdr.len;    pMBufPacket->reservedHdrSize = IPSEC_PACKETBUF_RESERVED_HEADER_SIZE;#if STACK_NAME == STACK_NAME_V4_V6    pMBufPacket->bufSize = pNewMBuf->m_extSize;#else    pMBufPacket->bufSize = pNewMBuf->pClBlk->clSize;#endif /*  STACK_NAME == STACK_NAME_V4_V6 */    pMBufPacket->isFromMBuf = TRUE;    pNewMBuf->m_next = NULL;    pMBufPacket->pMBuf = pNewMBuf;    return TRUE;    } /* end packetMBufInit() *//******************************************************************************/UINT packetBufReservedHeaderSizeGet(void)    {    return IPSEC_PACKETBUF_RESERVED_HEADER_SIZE;    } /* end packetBufReservedHeaderSizeGet() */