packetbuf.c

ipsec PNE 3.3 source code, running at more than vxworks6.x version.

    (
    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() */