packetbuf.c

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

/* packetBuf.c - WindNet IPsec and IKE resizeable packet routines */

/* 
 * Copyright (c) 2000-2005 Wind River Systems, Inc. 
 * 
 * The right to copy, distribute, modify or otherwise make use 
 * of this software may be licensed only pursuant to the terms 
 * of an applicable Wind River license agreement. 
 */

/*
modification history
--------------------
13feb06,rma  Performance optimazations
14nov05,rlm  Creation (adapted from RWOS packet routines)
*/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <vxWorks.h>
#include <taskLib.h>
#include <assert.h>

#include "packetBuf.h"
#include "../common/wrSecMem.h"

#if STACK_NAME == STACK_NAME_V4_V6 && defined (INET6)
#define IPSEC_PACKETBUF_RESERVED_HEADER_SIZE  100
#else
#define IPSEC_PACKETBUF_RESERVED_HEADER_SIZE  80
#endif /* STACK_NAME == STACK_NAME_V4_V6 && defined (INET6) */
#define IPSEC_PACKETBUF_RESERVED_TRAILER_SIZE (36+44)  /* 44 additional bytes for SHA2-512 -rlm */
#define IPSEC_PACKETBUF_RESERVED_SIZE \
    (IPSEC_PACKETBUF_RESERVED_HEADER_SIZE + \
     IPSEC_PACKETBUF_RESERVED_TRAILER_SIZE)
#define IPSEC_PACKETBUF_MINIMUM_DATA_SIZE   1500


/* Private functions */


LOCAL BOOL packetBufFree
    (
    PACKETBUF * pPacketBuf
    );

LOCAL BOOL packetMBufInit
    (
    PACKETBUF   * pMBufPacket,
    struct mbuf * pMBuf
    );

/************************************************************************/
PACKETBUF *packetBufCreate
    (
    UINT bufSize,
    UINT reservedHdrSize
    )
    {
    PACKETBUF* pPacketBuf;

    if (reservedHdrSize >= bufSize)
        {
        return NULL;
        }

    pPacketBuf = (PACKETBUF *)wrSecCalloc(1,sizeof(PACKETBUF));
    if (pPacketBuf == NULL)return NULL;


    pPacketBuf->pBuffer = (unsigned char *)wrSecCalloc(1,bufSize);
    if (pPacketBuf->pBuffer == NULL)
        {
        packetBufFree(pPacketBuf);
        return NULL;
        }

    #if defined(IPSEC_PACKETBUF_DEBUG)
    printf("packetBufCreate(): created buffer 0x%08x\n", pPacketBuf->pBuffer);
    #endif /* IPSEC_PACKETBUF_DEBUG */

    pPacketBuf->bufSize = bufSize;
    pPacketBuf->reservedHdrSize = reservedHdrSize;
    pPacketBuf->dataLength = 0;
    pPacketBuf->isFromMBuf = FALSE;
    pPacketBuf->pMBuf = NULL;

    return pPacketBuf;
    } /* end packetBufCreate() */


/*************************************************************************/
LOCAL BOOL packetBufFree
    (
    PACKETBUF * pPacketBuf
    )
    {

    #if defined(IPSEC_PACKETBUF_DEBUG)
    printf("packetBufFree()\n");
    #endif

    if( pPacketBuf == NULL )
        {
        #if defined(IPSEC_PACKETBUF_DEBUG)
        printf("packetBufFree(): ERROR - NULL packetBuf pointer passed.\n");
        #endif
        return FALSE;
        }

    if( (pPacketBuf->pBuffer != NULL) && (pPacketBuf->isFromMBuf == FALSE) )
        {
        #if defined(IPSEC_PACKETBUF_DEBUG)
        printf("packetBufFree(): freeing buffer 0x%08x\n", pPacketBuf->pBuffer);
        #endif
        wrSecFree(pPacketBuf->pBuffer);
        pPacketBuf->pBuffer = NULL;
        }

    #if defined(IPSEC_PACKETBUF_DEBUG)
    printf("packetBufFree(): freeing packetBuf 0x%08x\n", pPacketBuf);
    #endif
    wrSecFree(pPacketBuf);
    return TRUE;
    }

/************************************************************************/
PACKETBUF * packetBufClone
    (
    PACKETBUF * pOrigPacketBuf
    )
    {
    PACKETBUF * pNewPacketBuf = NULL;

    if( pOrigPacketBuf == NULL )
        {
        return NULL;
        }

    if( (pNewPacketBuf = packetBufCreate( pOrigPacketBuf->bufSize, pOrigPacketBuf->reservedHdrSize )) == NULL )
        {
        printf("packetBufClone(): FATAL ERROR - out of memory.\n");
        taskSuspend(0);
        }
    pNewPacketBuf->dataLength = pOrigPacketBuf->dataLength;
    /* NOTE that field ->isFromMBuf is always FALSE -- this is a copy of the original
       packetBuf, whether or not is was originally derived from an mbuf */
    memcpy( pNewPacketBuf->pBuffer, pOrigPacketBuf->pBuffer, pOrigPacketBuf->bufSize);

    return pNewPacketBuf;
    } /* end packetBufClone() */

/************************************************************************/
unsigned char * packetBufWritableHeaderGet
    (
    PACKETBUF * pPacketBuf,
    UINT        requestedSize
    )
    {

    if( pPacketBuf == NULL )
        {
        return NULL;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return NULL;
        }

    if( requestedSize > pPacketBuf->reservedHdrSize )
        {
        /* log message: requested header size larger than can be allocated */
        return NULL;
        }

    return (pPacketBuf->pBuffer + (pPacketBuf->reservedHdrSize - requestedSize));
    } /* end packetBufWritableHeaderGet() */

/************************************************************************/
unsigned char * packetBufWritableTrailerGet
    (
    PACKETBUF * pPacketBuf,
    UINT        requestedSize
    )
    {
    UINT reservedTrailerSize;

    if( pPacketBuf == NULL )
        {
        return NULL;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return NULL;
        }

    reservedTrailerSize = pPacketBuf->bufSize - (pPacketBuf->reservedHdrSize + pPacketBuf->dataLength);

    if( requestedSize > reservedTrailerSize)
        {
        return NULL;
        }

    return (pPacketBuf->pBuffer + pPacketBuf->reservedHdrSize + pPacketBuf->dataLength);
    } /* end packetBufWritableTrailerGet() */

/************************************************************************/
BOOL packetBufExtendFront
    (
    PACKETBUF * pPacketBuf,
    UINT        amount
    )
    {

    if( pPacketBuf == NULL )
        {
        return FALSE;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return FALSE;
        }

    if( amount > pPacketBuf->reservedHdrSize )
        {
        return FALSE;
        }

    pPacketBuf->dataLength += amount;
    pPacketBuf->reservedHdrSize -= amount;

    return TRUE;
    } /* end packetBufExtendFront() */

/************************************************************************/
BOOL packetBufReduceFront
    (
    PACKETBUF * pPacketBuf,
    UINT        amount
    )
    {

    if( pPacketBuf == NULL )
        {
        return FALSE;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return FALSE;
        }

    if( amount > pPacketBuf->dataLength )
        {
        return FALSE;
        }

    pPacketBuf->dataLength -= amount;
    pPacketBuf->reservedHdrSize += amount;

    return TRUE;
    } /* end packetBufReduceFront() */

/************************************************************************/
BOOL packetBufExtendBack
    (
    PACKETBUF * pPacketBuf,
    UINT        amount
    )
    {

    if( pPacketBuf == NULL )
        {
        return FALSE;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return FALSE;
        }

    if( pPacketBuf->reservedHdrSize + pPacketBuf->dataLength + amount > pPacketBuf->bufSize )
        {
        return FALSE;
        }

    pPacketBuf->dataLength += amount;

    return TRUE;
    } /* end packetBufExtendBack() */

/************************************************************************/
BOOL packetBufReduceBack
    (
    PACKETBUF * pPacketBuf,
    UINT        amount
    )
    {

    if( pPacketBuf == NULL )
        {
        return FALSE;
        }

    if( pPacketBuf->pBuffer == NULL )
        {
        return FALSE;
        }

    if( amount > pPacketBuf->dataLength )
        {
        return FALSE;
        }

    pPacketBuf->dataLength -= amount;

    return TRUE;
    } /* end packetBufReduceBack() */

/************************************************************************/
unsigned char * packetBufDataGet