nbuffer.h File Reference

Network buffer management: Definitions and Prototypes More...

Data Structures
struct	NBuffer_t
	Network Buffer. More...
struct	NBCtl_t
	Network Buffer Control Structure. More...

Macros
#define	BUFFER_EMPTY   (-1)

Functions
char *	NBufferAcquireBuffer (SOCKET *so)
	acquire new buffer More...
int	NBufferFreeBuffer (SOCKET *so)
	free packet buffer More...

Detailed Description

                          _         _             _
                       __| |    ___(_) ____ _ __ | |_
                      / _` |   / __| |/ _` | '_ \| __|
                     | (_| | _ \__ \ | (_| | | | | |_
                      \__,_|(_) ___/_|\__, |_| |_|\__|
                     Signalprocessing |___/ Technology

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Version

2.91

Date

2019-04-17

Macro Definition Documentation

#define BUFFER_EMPTY   (-1)

Examples:

Echo.c, and NetTest.c.

Function Documentation

char* NBufferAcquireBuffer

(

SOCKET *

so

)

[Network Buffer Control Structure]

Parameters

so	- socket to acquire new buffer for

Returns

buffer if successful, NULL if no buffer available

Note

Precondition is a valid user_pointer to a buffer control structure

Examples:

Echo.c, and NetTest.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    NBCtl_t *bctl = (NBCtl_t *)so-> user_pointer;       /* get buffer control */
    size_t psize;
    char *pbuffer;

    if ( bctl == NULL )
    {
        /***********************************************************************
         no control structure available
        ***********************************************************************/
        return (NULL);
    } // if

    /***************************************************************************
     check used buffers
    ***************************************************************************/
    if ( bctl-> BuffersInUse >= bctl-> MaxBuffers )
    {
        /***********************************************************************
         all buffers in use
        ***********************************************************************/
        return (NULL);
    } // if

    /***************************************************************************
     check receive index range
    ***************************************************************************/
    if ( ++bctl-> ri >= bctl-> MaxBuffers )
    {
        /***********************************************************************
         wrap around ring buffer
        ***********************************************************************/
        bctl-> ri = 0;
    } // if

    /***************************************************************************
     depending on protocol allocate max packet size
    ***************************************************************************/
    psize = (so-> proto == IPT_TCP)? TCP_MAX_PACKET_SIZE* sizeof(char)
                                   : UDP_MAX_PACKET_SIZE* sizeof(char);

    /***************************************************************************
     limit to buffer size
    ***************************************************************************/
    if ( psize > bctl-> NBuffer_SizeLimit )
    {
        psize = bctl-> NBuffer_SizeLimit;
    } // if


    /***************************************************************************
     use dynamic memory?
    ***************************************************************************/
    if ( bctl-> UseDynMem )
    {
        /***********************************************************************
         allocate a new buffer
        ***********************************************************************/
        pbuffer = bctl-> Buf[bctl-> ri].Data = (char *) malloc (psize*2);
        if ( pbuffer == NULL )
        {
            prg_exit(NBUFFER_OUT_OF_MEMORY_ERROR);
        }
    }
    else
    {
        /***********************************************************************
         for static buffers determine next buffer offset
         from nubffer.c view NBuffer_t member Data is a simple char * not an
         array of char, because define USE_STATIC_MEMORY is undefined (defined
         in user application). Thus we cannot use bctl-> buf[bctl-> ri].Data
         here and have to calculate the new buffer offset manually
        ***********************************************************************/
        pbuffer = (char *)((uint32_t)(bctl-> Buf) + (bctl-> ri * bctl-> NBuffer_tsize));
    }

    /***************************************************************************
     assign new buffer to socket
      for TCP this buffer size (psize in this case) is offered to peer as
      TCP Window Size
    ***************************************************************************/
    set_recv_buffer (so, pbuffer, (uint16_t)psize );

    //~ CPrintf ("allocate: %08lx\r\n", buffer);

    /***************************************************************************
     maintain buffer counter
    ***************************************************************************/
    bctl-> BuffersInUse++;

    return (pbuffer);
}

int NBufferFreeBuffer

(

SOCKET *

so

)

Parameters

so	- socket to release old buffer

Returns

• 0 - success
• -1 - error

Note

Precondition is a valid user_pointer to a buffer control structure

Examples:

Echo.c, and NetTest.c.

{
    /***************************************************************************
     locals
    ***************************************************************************/
    NBCtl_t *bctl = (NBCtl_t *)so-> user_pointer;       /* get buffer control */
    char *pbuffer;

    if ( bctl == NULL )
    {
        /***********************************************************************
         no control structure available
        ***********************************************************************/
        return (-1);
    } // if

    /***************************************************************************
     range check
    ***************************************************************************/
    if (( bctl-> pi != BUFFER_EMPTY ) && ( bctl-> pi < bctl-> MaxBuffers ) )
    {
        /***********************************************************************
         use dynamic memory?
        ***********************************************************************/
        if ( bctl-> UseDynMem )
        {
             pbuffer = bctl-> Buf[bctl-> pi].Data;
             //~ CPrintf ("free: %08lx\r\n", buffer);

            /*******************************************************************
             free memory
            *******************************************************************/
            free ((void *)pbuffer );
        }
        else
        {
            /*******************************************************************
             for static buffers determine next buffer offset
             from nubffer.c view NBuffer_t member Data is a simple char * not an
             array of char, because define USE_STATIC_MEMORY is undefined (defined
             in user application). Thus we cannot use bctl-> Buf[bctl-> ri].Data
             here.
            *******************************************************************/
            pbuffer = (char *)((uint32_t)(bctl-> Buf) + (bctl-> pi * bctl-> NBuffer_tsize));
        }

        //~ CPrintf ("free: %08lx\r\n", buffer);

        /***********************************************************************
          maintain buffer counter
        ***********************************************************************/
        bctl-> BuffersInUse--;
    } // if

    /***************************************************************************
     maintain process index
    ***************************************************************************/
    if ( ++bctl-> pi >= bctl-> MaxBuffers )
    {
        /***********************************************************************
         wrap around ring buffer
        ***********************************************************************/
        bctl-> pi = 0;
    } // if

    /***************************************************************************
     was it the last buffer (process index points to receive index)?
    ***************************************************************************/
    if ( bctl-> pi == bctl-> ri )
    {
        /***********************************************************************
         yes, set buffer empty flag
        ***********************************************************************/
        bctl-> pi = BUFFER_EMPTY;
    } // if

    return (0);
}