echo.c File Reference

TCP echo server on port 5031. More...

#include <BoardSupport/inc/stdtypes.h>
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <inttypes.h>
#include <time.h>
#include <string.h>
#include <Libs/NETlib/net.h>
#include <BoardSupport/inc/BoardSpecific.h>
#include <Common/Common.h>
#include <Common/uartio.h>
#include <Common/timer.h>
#include <Common/CPrintf.h>
#include <BoardSupport/config/netconfig.c>
#include <Common/nbuffer.h>

Macros
#define	USE_STATIC_MEMORY   TRUE
#define	MAX_NBUFFER_SIZE   (1500)
#define	MAX_TCP_BUFFERS   4

Functions
int32_t	tcp_echo_cb (SOCKET *so, void *data, uint32_t len, uint32_t ec)
void	process_data (SOCKET *so)
int	main (void)

Variables
char *	program_name = "Echo"
far char *	domain_name
NBuffer_t	tcp_buffer [MAX_TCP_BUFFERS]
SOCKET *	tcp_echo_so = INVALID_SOCKET
NBCtl_t	bcontrol

Detailed Description

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

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Date

2019-06-03

This program works as a TCP echo server with quad buffering (default). A define MAX_TCP_BUFFERS controls the number of buffers. Uncomment define USE_STATIC_MEMORY to use static instead of dynamic memory for buffering. To achieve a better TCP performance, MAX_TCP_BUFFER_SIZE can be increased by multiple of TCP_MAX_PACKET_SIZE. Also linking the tcp_buffer to internal memory (if available) may increase the performance significantly.

To verify this program, first 'ping' the DSP:

>ping 192.168.168.200

or

>ping mydemo

If the settings and network connections are correct, the pings will be replied.

The TCP Echo server will re-send (echo) anything it receives. To verify this, start NetCat (nc) with the following command

>nc 192.168.168.200 5031
           |         |
           |         +-- port 5031 = User Echo Port
           +------------ the DSP's IP address

or

>nc mydemo 5031
      |     |
      |     +------ port 5031 = User Echo Port
      +------------ the DSP hostname

Any characters you type in the console window will be returned. NetCat doesn't send the characters immediately, it will send the entire string following a terminating CR. Please note that the maximum length of the character string is limited by the size of the buffer used for TCP echo (MAX_TCP_BUFFER_SIZE).

Macro Definition Documentation

#define USE_STATIC_MEMORY   TRUE

Examples:

Echo.c, and NetTest.c.

#define MAX_NBUFFER_SIZE   (1500)

#define MAX_TCP_BUFFERS   4

Examples:

Echo.c.

Function Documentation

int32_t tcp_echo_cb	(	SOCKET *	so,
		void *	data,
		uint32_t	len,
		uint32_t	ec
	)

{
    /***************************************************************************
     locals
    ***************************************************************************/
    NBCtl_t *bctl = (NBCtl_t *)so-> user_pointer;       /* get buffer control */
    int32_t data_length;      // net_recv_event_handler() return parameter

    /***************************************************************************
     suppress unused parameter warning
    ***************************************************************************/
    UNREFERENCED_PARAMETER(data); // replaced by bctl-> Buf[].Data
    UNREFERENCED_PARAMETER(ec);   // handled in net_recv_event_handler()
    UNREFERENCED_PARAMETER(len);  // len is ignored, data_len is used instead


    /***************************************************************************
     Check events
     If NULL is passed as pLog parameter, no message is printed to output.
     Use net_recv_event_handler() to determine the data length waiting in the
     receive buffer
    ***************************************************************************/
    data_length = net_recv_event_handler (so, CPrintf); /* with messages      */
 // data_length = net_recv_event_handler (so, NULL);    /* without messages   */

    /***************************************************************************
     net_recv_event_handler() returns the amount of data waiting in the buffer
    ***************************************************************************/
    if (data_length)
    {
        // CPrintf ("received %"PRId32" bytes\r\n", data_length);

        if ( bctl == NULL )
        {
            /*******************************************************************
             no control structure available, buffer processing not possible
            *******************************************************************/
            return (SOCKET_CB_OK);
        } // if

        /***********************************************************************
         new data is available in buffer that has been previously assigned by
         socket_define_callback() or set_recv_buffer() function.
         The receive index bctl-> ri should always point to the active buffer
         and is maintained in NBufferAcquireBuffer()
        ***********************************************************************/
        /***********************************************************************
         save packet size, useful for later processing
        ***********************************************************************/
        bctl-> Buf[bctl-> ri].Size = data_length;

        /***********************************************************************
         set process index to this buffer, if not already set.
         this starts the processing task in main.
         if bctl-> pi is not BUFFER_EMPTY, processing is already in progress
        ***********************************************************************/
        if ( bctl-> pi == BUFFER_EMPTY )
        {
            bctl-> pi = bctl-> ri;
        } // if
        /***********************************************************************
         malloc space for new data
        ***********************************************************************/
        if ( NBufferAcquireBuffer (so) == NULL)
        {
            /*******************************************************************
             allocation failed due to all buffers in use.
             this may happen when the receive task works faster than the signal
             processing task. Send a zero window packet to the remote side to
             stop the TCP and set OutOfBuffer flag to handle this condition
             later
            *******************************************************************/
            bctl-> OutOfBuffer = TRUE;
            tcp_send_zero_window ( so );
        } // if
    }

    /***************************************************************************
     Return true, if socket was not closed before
    ***************************************************************************/
    return (SOCKET_CB_OK);
}

void process_data

(

SOCKET *

so

)

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

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

    /***************************************************************************
     if allocation failed due to all buffers in use, OutOfBuffer flag was
     set in tcp_echo_cb(). try to allocate new buffer and send window update on
     success
    ***************************************************************************/
    if ( bctl-> OutOfBuffer )
    {
        if ( NBufferAcquireBuffer (so) != NULL )
        {
            /*******************************************************************
             allocation successful,
             reset OutOfBuffer flag,
             send window update to start the TCP
            *******************************************************************/
            bctl-> OutOfBuffer = FALSE;
            tcp_send_window_update ( so );
        } // if
    } // if

    /***************************************************************************
     check received TCP messages
     process index bctl-> pi is set by the first received packet in tcp_echo_cb()
     and signals data waiting for processing
    ***************************************************************************/
    if ( bctl-> pi != BUFFER_EMPTY )
    {
        /***********************************************************************
         process buffer if necessary
         the next data is bctl-> Buf[bctl-> pi].Data
        ***********************************************************************/
        buffer = (char*)bctl-> Buf[bctl-> pi].Data;
        size = (uint32_t)bctl-> Buf[bctl-> pi].Size;

        /***********************************************************************
         send data back (TCP echo), wait for completion
        ***********************************************************************/
        net_send_safe (so, buffer , size, TCP_WAIT);

        /***********************************************************************
         since wait flag was set in net_send_safe() call before, it's safe
         to free this buffer here
        ***********************************************************************/
        if ( NBufferFreeBuffer (so) )
        {
            /*******************************************************************
             error occurred, no buffer control structure available
             assign buffer control structure to socket-> user_pointer
             during initialization
            *******************************************************************/
            prg_exit ("out of memory error");
        } // if
    }
}

int main

(

void

)

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int main_loop      = 1;           /* main loop switch, set to 0 to exit   */
    timeval stamp1, stamp2, delta;    /* used to determine startup time       */
    char conversion_buffer[16];

    /***************************************************************************
      initialize application (e.g. timer clocks, PLL settings, EMIF etc.)
       (ref. \Common\Common.c)
    ***************************************************************************/
    AppInit (GET_CLOCK);

    /***************************************************************************
      select output device for CPrintf  (ref. \Common\cprintf.c)
      possible settings:
        CPRINTF_UART_OUTPUT                       -> output to UART
        CPRINTF_CCS_OUTPUT                        -> output to CCS
        CPRINTF_UART_OUTPUT | CPRINTF_CCS_OUTPUT  -> output to UART and CCS
    ***************************************************************************/
    CPrintf_select_output (CPRINTF_DEFAULT_OUTPUT);  /* default outputs       */

    /***************************************************************************
     print a start up message
    ***************************************************************************/
    START_UP_MESSAGE (BLANK_REV NETLIB_REV);

    /**************************************************************************/
    // CPrintfProgress (" Heap check ");
    // at least 0x2000 bytes required for this app
    /**************************************************************************/
    ASSERT_HEAP (initial_heap_size, 0x2000);
    // CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Setup system time ");
     // 1 milli seconds resolution
    /**************************************************************************/
    SetupSystemTime ( SYSTEM_TIMER_INT, SYSTEM_TIMER, RES_MSECONDS);
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d mapped to CPU int %d ***\r\n",
             SystemTimerDev, SYSTEM_TIMER_INT);

    /**************************************************************************/
     CPrintfProgress (" Enable interrupts ");
    /**************************************************************************/
    BoardEnableInterrupts();
    CPrintfProgressSuccess();

    /**************************************************************************/
     CPrintfProgress (" Start system timer ");
    /**************************************************************************/
    StartSystemTimer ();
    CPrintfProgressSuccess();
    CPrintf ("   *** timer %d running at %"PRId32" Hz ***\r\n", SystemTimerDev, RES_SECONDS/GetSystemTimerRes());

    /***************************************************************************
      measure network initialization time
    ***************************************************************************/
    stamp1 = GetTimeStamp();

    /**************************************************************************/
     CPrintfProgress (" Initialize network ");
    /**************************************************************************/
    InitializeNetwork ( 64); // 64 bytes for ping

    /**************************************************************************
     open sockets
    **************************************************************************/
    tcp_echo_so = socket_open (ANY_ADDRESS,
                               ANY_PORT,
                               5031,
                               DATATYPE_CHAR,
                               TCP_INIT_FUNC);
    if ( tcp_echo_so == INVALID_SOCKET )
    {
        prg_exit ("socket_open() error");      /* possibly insufficient heap */
    } // if

    /***************************************************************************
     attach buffer control structure to socket
      (required for NBufferAcquireBuffer() later)
    ***************************************************************************/
    tcp_echo_so-> user_pointer = (void *)&bcontrol;

    /***************************************************************************
     initially malloc space for data
     NBufferAcquireBuffer() allocates new buffer space and modifies the
     bcontrol structure data buffer pointer and receive index
    ***************************************************************************/
    if ( NBufferAcquireBuffer (tcp_echo_so) == NULL )
    {
        prg_exit ("out of memory error");
    } // if

    /***************************************************************************
     install callback function
     NBufferAcquireBuffer() has modified receive index ri to point to the next
     buffer
    ***************************************************************************/
    socket_define_callback (tcp_echo_so, tcp_echo_cb, bcontrol.Buf[bcontrol.ri].Data , MAX_NBUFFER_SIZE);

    /***************************************************************************
     set keep alive time 10 seconds (three unanswered packets within 10 seconds)
    ***************************************************************************/
    tcp_set_keep_alive_time (tcp_echo_so, KA_TIMEOUT(10));

    CPrintfProgressSuccess();

    stamp2 = GetTimeStamp();

    tv_interval (&delta, &stamp1, &stamp2);
    CPuts (" network startup time [sec]: ");
    CPrintf (VT100_RED
             "%"PRId32".%03"PRId32"\r\n"
             VT100_DEFAULT,
              delta.tv_sec,
              delta.tv_usec/1000);

    /***************************************************************************
      main program loop: set main_loop to 0 to exit loop
    ***************************************************************************/
    CPuts ("\r\n Entering main loop ...\r\n");
    while ( main_loop )
    {
        /***********************************************************************
         process net_isq()
        ***********************************************************************/
        net_isq ();  // process ISQ

        /***********************************************************************
         monitor link status
        ***********************************************************************/
        monitor_link_status (CPrintf);

        /***********************************************************************
         try to detect IP assignment
          if DHCP is used, the assigned IP address may change
        ***********************************************************************/
        if (monitor_ip_address (CPrintf))
        {
            /*******************************************************************
             print what to do next
            *******************************************************************/
            CPrintf (" Establish a TCP connection on port %d:\r\n", tcp_echo_so-> src_port);

            if (domain_name)  CPrintf (">nc %s.%s %d\r\n or\r\n",
                                       eth.ip,
                                       domain_name,
                                       tcp_echo_so-> src_port);
            CPrintf (">nc %s %d\r\n",
                     inet_ntoa(get_ip_address(0), conversion_buffer),
                     tcp_echo_so-> src_port);

            CPuts (" Any characters you type into the nc console will be echoed back\r\n when you press enter until the connection is closed.\r\n");
        }

        /***********************************************************************
         process data
        ***********************************************************************/
        process_data (tcp_echo_so);

        /***********************************************************************
         show that the program is running, perform symbol animation
        ***********************************************************************/
        CPrintAnimatedSymbol ( sym_animate, 200000, ANIMATE_SYMBOLS_COUNT);
    }

    /***************************************************************************
      exit program, shut down peripherals
    ***************************************************************************/
    return (0);
}

Variable Documentation

char* program_name = "Echo"

far char* domain_name

NBuffer_t tcp_buffer[MAX_TCP_BUFFERS]

Examples:

Echo.c.

SOCKET* tcp_echo_so = INVALID_SOCKET

Examples:

Echo.c.

NBCtl_t bcontrol

Initial value:

=
{
    tcp_buffer,                                 
    sizeof(NBuffer_t),                          
    0,                                          
    0,                                          
    BUFFER_EMPTY,                               
    BUFFER_EMPTY,                               
    MAX_TCP_BUFFERS,                            

    0,                                          



    MAX_NBUFFER_SIZE                            
}