Concurrent Server Example. 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 <Libs/Netlib/pserver.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>

Data Structures
struct	echoserv_type

Macros
#define	_ECHO_RECEIVE_BUFFER 1460L

#define	_ECHO_LISTENING 0

#define	_ECHO_ESTABLISHED 1

Functions
int32_t	tcp_echo (SOCKET so, void data, uint32_t len, uint32_t ec)

int	close_parallel_echo_server (SOCKET *so)

int	init_parallel_echo_server (SOCKET *so)

int	main (void)

Variables
char *	program_name = "pserver"

_PARALLEL_SERVER *	_ECHO_SERVER_HEAD = NULL

_PARALLEL_SERVER *	echo_pserver = NULL

unsigned int	echo_socket_counter = 0

Detailed Description

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

Author: D.SignT GmbH & Co. KG, Claus Hermbusche

Date: 2019-06-03

This program installs a concurrent TCP echo server on port 5031.

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_DATA = 1024).

Using parallel servers:

The user defined function 'init_parallel_echo_server()' must be called once to have at least one listening socket. After connecting this socket, the callback function tcp_echo() is called from TCP stack with error code SO_CONNECTION_ESTABLISHED. The next 'init_parallel_echo_server()' function call increases the server list. The new opened server socket is auto- matically in listening state and can be connected from the next client. After disconnecting one client, the TCP stack calls the user callback function again. This time with error code SO_CONNECTION_CLOSED (or SO_CONNECTION_RESET ). Call 'close_parallel_echo_server()' to decrease the server list and free all associated memory.

Macro Definition Documentation

#define _ECHO_RECEIVE_BUFFER 1460L

Examples:: PServer.c.

#define _ECHO_LISTENING 0

Examples:: PServer.c.

#define _ECHO_ESTABLISHED 1

Examples:: PServer.c.

Function Documentation

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

 {
     /***************************************************************************
      it's safe to use ec unmasked, because the event flag (MSB) is reset before
      this callback function is called
     ***************************************************************************/
     switch (ec)
     {
         case SO_NO_ERROR:
             /*******************************************************************
              send echo
             *******************************************************************/
             net_send (so, data, (uint16_t)len);
             break;
 
         case SO_CONNECTION_ESTABLISHED:
             /*******************************************************************
              get a new listening server
             *******************************************************************/
             if (init_parallel_echo_server (so))
             {
                 /***************************************************************
                  print error code
                 ***************************************************************/
                 CPuts ("\r ");
                 net_print_error (ec, CPrintf);
                 CPrintf (" %d concurrent sockets\r\n", echo_socket_counter);
             }
             else
             {
                 /***************************************************************
                  print error code
                 ***************************************************************/
                 CPuts ("\r Out of memory\r\n");
                 shutdown (so, 100L);
             }
             break;
 
         case SO_CONNECTION_CLOSED:
         case SO_CONNECTION_RESET   :
             /*******************************************************************
              close the server
             *******************************************************************/
             close_parallel_echo_server (so);
 
             /*******************************************************************
              print error code
             *******************************************************************/
             CPuts ("\r ");
             net_print_error (ec, CPrintf);
             CPrintf (" %d concurrent sockets\r\n", echo_socket_counter);
 
             /*******************************************************************
              return -1 signals socket is invalid
             *******************************************************************/
             return (SOCKET_CB_CLOSED);
 
         default:
             /*******************************************************************
              else print error code
             *******************************************************************/
             CPuts ("\r ");
             net_print_error (ec, CPrintf);
             break;
     }
 
     /***************************************************************************
      return true, if message processed
     ***************************************************************************/
     return (SOCKET_CB_OK);
 }

int close_parallel_echo_server ( SOCKET * so )

Examples:: PServer.c.

 {
     /***************************************************************************
      Locals
     ***************************************************************************/
     _PARALLEL_SERVER *echo_pserver = NULL;
     echoserv_type    *echo_info;        // used for protocol information for
                                         // each connection
 
     /***************************************************************************
      get control information for current server
     ***************************************************************************/
     echo_pserver = get_current_pserver (so, &_ECHO_SERVER_HEAD);
     echo_info = (echoserv_type *)(echo_pserver-> info);
 
     echo_pserver-> close = TRUE;
 
     if ( echo_pserver-> state > _ECHO_LISTENING )
     {
         /***********************************************************************
           connection closed or terminated:
           free all protocol specific buffers
         ***********************************************************************/
         if ( echo_info-> control_buffer != NULL )
         {
             free (echo_info-> control_buffer);
             echo_info-> control_buffer = NULL;
 
             free (echo_info);
             echo_pserver-> info = NULL;
         }
 
         /***********************************************************************
           use close() method to delete the terminated or closed server
         ***********************************************************************/
         echo_pserver = close_pserver (echo_pserver, &_ECHO_SERVER_HEAD);
 
         /***********************************************************************
           correct current connection counter
         ***********************************************************************/
         echo_socket_counter--;
     }
 
     /***************************************************************************
      return true, if message processed
     ***************************************************************************/
     return (1);
 }

int init_parallel_echo_server ( SOCKET * so )

Examples:: PServer.c.

 {
     /***************************************************************************
      Locals
     ***************************************************************************/
     _PARALLEL_SERVER *pserver = NULL;
     echoserv_type    *echo_info;        // used for protocol information for
                                         // each connection
 
     /***************************************************************************
      add a new pserver to server list
      first parameter:  Port to listen on
      second parameter: user defined head of server list
     ***************************************************************************/
     pserver = add_pserver (5031, &_ECHO_SERVER_HEAD);
 
     if ( pserver == NULL )
     {
         /***********************************************************************
          out of memory
         ***********************************************************************/
         return (FALSE);
     }
 
     /***************************************************************************
      create a protocol info and link it to the parallel server
      echoserv_type is a user defined structure type containing all
      information needed for protocol handling
     ***************************************************************************/
     pserver-> info = (echoserv_type *) malloc ( sizeof( echoserv_type));
 
     if ( pserver-> info == NULL )
     {
         /***********************************************************************
          out of memory, use close() method to delete the listening server
         ***********************************************************************/
         close_pserver (pserver, &_ECHO_SERVER_HEAD);
 
         return (FALSE);
     }
 
     /***************************************************************************
      initialize protocol specific information
     ***************************************************************************/
     echo_info = (echoserv_type *)(pserver-> info);
     echo_info-> control        = INVALID_SOCKET;
 
     /***************************************************************************
      get buffer space for control data
     ***************************************************************************/
     echo_info-> control_buffer = (char *) malloc (_ECHO_RECEIVE_BUFFER * sizeof (char));
 
     if ( echo_info-> control_buffer == NULL )
     {
         /***********************************************************************
          out of memory, use close() method to delete the listening server
         ***********************************************************************/
         free (echo_info);
 
         pserver = close_pserver (pserver, &_ECHO_SERVER_HEAD);
 
         return (FALSE);     // out of memory
     } // if
 
     /***************************************************************************
       define callback function for received TCP packets
     ***************************************************************************/
     socket_define_callback (pserver-> server,           /* socket             */
                             tcp_echo,                   /* call back function */
                             echo_info-> control_buffer, /* data buffer        */
                             _ECHO_RECEIVE_BUFFER);      /* data buffer size   */
 
     /***************************************************************************
      count the current sockets
     ***************************************************************************/
     echo_socket_counter++;
 
     if (so != INVALID_SOCKET)
     {
         pserver = get_current_pserver (so, &_ECHO_SERVER_HEAD);
 
         /***********************************************************************
          switch to established state
         ***********************************************************************/
         pserver-> state = _ECHO_ESTABLISHED;
         pserver-> close = FALSE;
     }
 
     return (TRUE);
 }

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          */
 
     /***************************************************************************
       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
 
     /***************************************************************************
      the first call to init_parallel_echo_server() creates a listening socket
     ***************************************************************************/
     init_parallel_echo_server (NULL);
     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);
 
 
     /***************************************************************************
      loop forever
     ***************************************************************************/
     CPrintf (" %s running on address %s\r\n", program_name, eth.ip);
     CPuts ("\r\n Entering main loop ...\r\n");
 
     /***************************************************************************
       main program loop: set main_loop to 0 to exit loop
     ***************************************************************************/
     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
         ***********************************************************************/
         monitor_ip_address (CPrintf);
 
         /***********************************************************************
          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 = "pserver"

_PARALLEL_SERVER* _ECHO_SERVER_HEAD = NULL

Examples:: PServer.c.

_PARALLEL_SERVER* echo_pserver = NULL

Examples:: PServer.c.

unsigned int echo_socket_counter = 0

Examples:: PServer.c.

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

Function Documentation

Variable Documentation