FreeCalypso > hg > fc-tourmaline

view src/gpf/tst/drv/socket.c @ 301:4bb5772a05a3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
AT%SPVER: new command for setting custom speech version lists The speech version list in the Bearer Capability IE tells the network which speech codecs are supported by the MS, and in which order of preference. The standard behaviour is to list all codecs that are supported by the hw+fw platform, and the standard preference order is newer over older, FR over HR. But sometimes it is desirable (for network testing) to artificially restrict which codecs the test MS will declare as supported, and/or to list them in some peculiar non-standard order of preference. Add a new private AT command, AT%SPVER, allowing the user to set and clear custom speech version lists for the Bearer Capability IE composer in CC.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 21 May 2023 21:43:10 +0000
parents 4e78acac3d88
children
line wrap: on
line source

/* 
+------------------------------------------------------------------------------
|  File:       socket.c
+------------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG 
|                 All rights reserved. 
| 
|                 This file is confidential and a trade secret of Texas 
|                 Instruments Berlin, AG 
|                 The receipt of or possession of this file does not convey 
|                 any rights to reproduce or disclose its contents or to 
|                 manufacture, use, or sell anything it may describe, in 
|                 whole, or in part, without the specific written consent of 
|                 Texas Instruments Berlin, AG. 
+----------------------------------------------------------------------------- 
|  Purpose :  This Modul contains the socket driver adaptation
+----------------------------------------------------------------------------- 
*/ 

#ifdef _VXWORKS_
#define GNU_COMPILER
#endif

#undef SOCK_TRACE

#undef SOCKET_DEBUG

/*==== INCLUDES =============================================================*/

#if defined _NUCLEUS_ || defined _TOOLS_   /* socket-driver running on windows OS */
/*lint -e717 suppress info do...while(0); */
/*lint -esym(550,rc) suppress info not accessed */
/*lint -e813, suppress Info 813: auto variable has size > 100 -> uncritical in this context */
/*lint -e801, suppress Info 801: Use of goto is deprecated */
  #include <windows.h>
  #include <winsock.h>
  #include <stdio.h>
  #ifdef SOCK_TRACE
    #include <stdio.h>
    #include <fcntl.h>
    #include <io.h>
  #endif  /* SOCK_TRACE */
#endif  /* #ifdef _NUCLEUS_ */

#ifdef _PSOS_                /* socket-driver running on pSOS */
  #define _PNA_30_BACK
  #include <psos.h>
  #include "bsp.h"
  #include <pna.h>
  #include <prepc.h>
  #include <rescfg.h>
#endif /* #ifdef _PSOS_ */

#ifdef _VXWORKS_
  #include "vxWorks.h"
  #include "sockLib.h"
  #include "inetLib.h"
  #include "ioLib.h"
  #include "selectLib.h"
  #include "errnoLib.h"
  #include "logLib.h"
/* undefine the MALLOC and FREE of VxWorks to avoid warnings */
#undef MALLOC
#undef FREE
#endif  /* _VXWORKS_ */

/* More operating systems go here */

#ifdef _LINUX_
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <netinet/tcp.h>
  #include <sys/ioctl.h>
  #include <errno.h>
  #include <netdb.h>
#endif

#ifdef _SOLARIS_
  #include <sys/types.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <netinet/tcp.h>
  #include <sys/ioctl.h>
  #include <errno.h>
  #include <netdb.h>
  #include <sys/filio.h>
#endif

#ifndef OLD_FRAME
  #include "typedefs.h"
  #include "os.h"
#endif

#include "socket.h"
#include "tools.h"
#include "vsi.h"
#include "drvconf.h"
#include "tstheader.h"

/*==== DEFINITIONS ==========================================================*/

#define MAX_PENDING_CONNECTS  5          /* The backlog allowed for listen() */
#define SEND_TIMEOUTUSEC      500        /* minimal timeout value for sending*/
#define INVALID_HANDLE        NULL
#define INVALID_SIGNALTYPE    0
#define NO_FLAGS_SET          0          /* Used with recv()/send()          */
#define MAX_ETH_LEN           (1500-40)  /* Maximum size of a Ethernet packet without IP headers */
#define WRBUF_LEN             2048

#define ALLOWED_SOCKET_SIGNALS   (DRV_SIGTYPE_READ|DRV_SIGTYPE_CONNECT|DRV_SIGTYPE_DISCONNECT)

#if defined _NUCLEUS_ || defined _TOOLS_
    typedef ULONG SIZETYPE;
    #define GETTIME(t)           (t = GetTickCount())
    #define GETREADSIZE(sok,psiz) ioctlsocket(sok, FIONREAD,(ULONG*)psiz)
    #define READ_SOCKET(s,b,l)    recv((s),(b),(int)(l),NO_FLAGS_SET)
    #define WRITE_SOCKET(s,b,l)   send((s),(const char*)(b),(l),NO_FLAGS_SET)
    #define CLOSE_SOCKET(s)       closesocket(s)
#endif /* #ifdef _NUCLEUS_ */

#ifdef _PSOS_
  typedef int SOCKET;
  typedef int SIZETYPE;
  typedef struct hostent HOSTENT;
  #define h_addr  h_addr_list[0]
  typedef HOSTENT *  PHOSTENT;
  #define FAR /**/
  #define SOCKADDR_IN struct sockaddr_in
  #define SOCKET_ERROR   (-1)
  #define INVALID_SOCKET (-1)
  #define GETTIME(t)            os_GetTime (0, &(t))
  #define GETREADSIZE(sok,psiz) ioctl(sok, FIOREAD,(char*)psiz)
  #define READ_SOCKET(s,b,l)    recv((s),(b),(int)(l),NO_FLAGS_SET)
  #define WRITE_SOCKET(s,b,l)   send((s),(char *)(b),(int)(l),NO_FLAGS_SET)
  #define CLOSE_SOCKET(s)       close(s)
#endif /* #ifdef _PSOS_ */

#ifdef _VXWORKS_
  #define SOCKADDR_IN    struct sockaddr_in
  #define FAR /* nil */
  #define SOCKET_ERROR   ERROR
  #define INVALID_SOCKET ERROR
  typedef int SOCKET;
  typedef int SIZETYPE;
  #define GETTIME(t)            os_GetTime (0, &(t))
  #define GETREADSIZE(sok,psiz) ioctl(sok, FIONREAD, (int)psiz)
  #define READ_SOCKET(s,b,l)    recv((s), (b), (int)(l), NO_FLAGS_SET)
  #define WRITE_SOCKET(s,b,l)   send((s), (char *)(b), (int)(l), NO_FLAGS_SET)
  #define CLOSE_SOCKET(s)       close(s)
#endif /* _VXWORKS_ */

#if defined (_LINUX_) || defined (_SOLARIS_)
  #define SOCKADDR_IN    struct sockaddr_in
  #define FAR /* nil */
  #define SOCKET_ERROR   (-1)
  #define INVALID_SOCKET (-1)
  typedef int SIZETYPE;
  #define GETTIME(t)            os_GetTime (0, &(t))
  #define GETREADSIZE(sok,psiz) ioctl(sok, FIONREAD, (int)psiz)
  #define READ_SOCKET(s,b,l)    recv((s), (b), (int)(l), NO_FLAGS_SET)
  #define WRITE_SOCKET(s,b,l)   send((s), (char *)(b), (int)(l), NO_FLAGS_SET)
  #define CLOSE_SOCKET(s)       close(s)
#endif /* _VXWORKS_ */

#define PORT_NO              6392
#define TX_BUFFER_SIZE       8192
#define RX_BUFFER_SIZE       8192
#define TX_TIMEOUT_MSEC     10000
#define RX_TIMEOUT_MSEC     10000

#ifdef _VXWORKS_
#define SOCKET_PRIO    115
#define SOCKET_STACK  8192
#elif defined _PSOS_
#define SOCKET_PRIO    110
#define SOCKET_STACK  1024
#elif defined _TOOLS_
#define SOCKET_PRIO      1
#define SOCKET_STACK  1024
#else
#define SOCKET_PRIO      1
#define SOCKET_STACK  1024
#endif

#define TI_MODE     0x0001

/*==== TYPES ================================================================*/
typedef enum
{
  SST_PL0,     /* 0 bytes of packet length read*/
  SST_PL1,     /* 1 bytes of packet length read*/
  SST_DATA0,   /* 0 bytes of data read*/
  SST_DATAx    /* not all data read */
} T_SOCK_STATE;

typedef struct
{
  USHORT            Connect;
  SOCKET            Listener;
  SOCKET            Socket;
  USHORT            EnabledSignals;
  OS_HANDLE         ThreadID ;
  USHORT            SocketHandle;
  T_DRV_CB_FUNC     Callback;
} Client_Type;

/*==== EXTERNALS ============================================================*/
EXTERN BOOL           socket_flush;

/*==== LOCAL VARS ===========================================================*/

LOCAL socket_DCB_Type L_DCB ;
LOCAL Client_Type     L_ClientData ;
LOCAL BOOL            L_ThreadActive ;
LOCAL T_DRV_SIGNAL    SocketSignal;
LOCAL UBYTE    wrbuf[WRBUF_LEN+2];
LOCAL UBYTE   *wrbuf_pos = wrbuf;
T_SOCK_STATE   sock_state = SST_PL0;

#ifdef SOCK_TRACE
ULONG                 fh_sock = -1;
LOCAL char            stbuf[80];
#endif

LOCAL BOOL     isLittleEndian = TRUE;
int tst_socket; /* for psos */
int tst_socket_initialized; /* flag for pSOS */
int tst_socket_in_TxLen;    /* for pSOS */


/*==== DIAGNOSTICS ==========================================================*/

#ifdef SOCKET_DEBUG
#include <STDIO.H>
static char *logfile = "socket.log";
static char *bufferfullfile = "bufferfull.log";
static char *inprocessfile = "inprogress.log";
static char *noconnectfile1 = "noconnect1.log";
static char *noconnectfile2 = "noconnect2.log";
static char *noconnectfile3 = "noconnect3.log";
static char *readerrorfile = "readerror.log";
static FILE *fp = NULL;
#endif /* SOCKET_DEBUG */

/*==== END DIAGNOSTICS ======================================================*/

extern USHORT ext_data_pool_handle;

GLOBAL ULONG drv_socket_task_stack_size = SOCKET_STACK;
GLOBAL USHORT drv_socket_task_prio = SOCKET_PRIO;

/*==== PRIVATE FUNCTIONS ====================================================*/
/*
+------------------------------------------------------------------------------
|  Function    : L_CreateThread
+------------------------------------------------------------------------------
|  Description : This function creates a thread.
|
|  Parameters  : ThreadFunc        - pointer to the function beeing a thread
|
|  Return      : FALSE             - Thread not created
|                TRUE              - Thread create (Thread ID stored in
|                                    L_ClientData.ThreadID
|
+------------------------------------------------------------------------------
*/
#ifdef OLD_FRAME
BOOL L_CreateThread (USHORT (*ThreadFunc)(USHORT,ULONG))
{
  return (CreateThread ((LPSECURITY_ATTRIBUTES) NULL,
                0,
                (LPTHREAD_START_ROUTINE)ThreadFunc,
                (LPVOID) NULL,
                0,
                &L_ClientData.ThreadID) != NULL);
}
#else
BOOL L_CreateThread (void (*ThreadFunc)(T_HANDLE,ULONG))
{
  if ( os_CreateTask (0, (char*)"SOCKET", ThreadFunc, drv_socket_task_stack_size, drv_socket_task_prio, &L_ClientData.ThreadID, ext_data_pool_handle) < 0L )
    return FALSE;
  if ( os_StartTask (0, L_ClientData.ThreadID, 0) < 0 )
    return FALSE ;

  return TRUE;
}
#endif

/*
+------------------------------------------------------------------------------
|  Function    : L_SetSocketBuffer
+------------------------------------------------------------------------------
|  Description : This function sets the IP read and write buffer
|
|  Parameters  : in_TxLen          - size of transmission buffer
|                in_RxLen          - size of receiver buffer
|
|  Return      : FALSE             - either the read or write buffer could not
|                                    be set.
|                TRUE              - OK
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL L_SetSocketBuffer (USHORT  in_TxLen, USHORT in_RxLen)
{
  int in_TxLen1 = (int) in_TxLen;
  int in_RxLen1 = (int) in_RxLen;
#ifndef _PSOS_
  int nodelay = TRUE;
#if defined (_VXWORKS_) || defined (_LINUX_) || defined (_SOLARIS_)
  struct linger nolinger = {0, 0};
#else
  int linger = TRUE;
#endif
  int rc=0;

  if (in_TxLen > 0)
  {
    if ( (rc=setsockopt(L_ClientData.Socket, SOL_SOCKET, SO_SNDBUF,
                   (char*)&in_TxLen1, sizeof(in_TxLen1))) != 0)
    {
#ifdef _VXWORKS_
      rc = errnoGet ();
#else
  #if defined (_LINUX_) || defined (_SOLARIS_)
      rc = errno;
  #else
      rc = WSAGetLastError();
  #endif
#endif
#if defined _NUCLEUS_ || defined _TOOLS_
      printf("SOCKET: setsockopt() returned error code %d\n", rc); 
#endif
      return FALSE ;
    }
  }
#if defined (_VXWORKS_) || defined (_LINUX_) || defined (_SOLARIS_)
  if (setsockopt(L_ClientData.Socket, SOL_SOCKET, SO_LINGER,
               (char*)&nolinger, sizeof(nolinger)))
#else
  if (setsockopt(L_ClientData.Socket, SOL_SOCKET, (int)SO_DONTLINGER,
               (char*)&linger, sizeof(linger)))
#endif
    return FALSE ;
  if (setsockopt(L_ClientData.Socket, IPPROTO_TCP, TCP_NODELAY,
               (char*)&nodelay, sizeof(nodelay)))
    return FALSE ;

#else /* PSOS */
  tst_socket_in_TxLen = in_TxLen;
#endif /* PSOS */
  if (in_RxLen > 0)
  {
    if (setsockopt(L_ClientData.Socket, SOL_SOCKET, SO_RCVBUF,
                   (char *) &in_RxLen1, sizeof(in_RxLen1)))
      return FALSE ;
  }

  return TRUE ;
}

/*
+------------------------------------------------------------------------------
|  Function    : L_Disconnect
+------------------------------------------------------------------------------
|  Description : This function is called when the connection to the peer entity
|                is lost. If the release signal is set a signal is generated.
|
|  Parameters  :  -
|
|  Return      :  -
|
+------------------------------------------------------------------------------
*/
LOCAL void L_Disconnect (void)
{

  L_ClientData.Connect = FALSE;
  if (L_ClientData.EnabledSignals != INVALID_SIGNALTYPE)
  {
    SocketSignal.SignalType = DRV_SIGTYPE_DISCONNECT;
    SocketSignal.DrvHandle = L_ClientData.SocketHandle;
    (*L_ClientData.Callback)(&SocketSignal) ;
  }
}

/*
+------------------------------------------------------------------------------
|  Function    : L_AsyncSelect
+------------------------------------------------------------------------------
|  Description : This function waits (blocking) for either something to read
|                or an execption on the socket.
|
|  Parameters  : -
|
|  Return      : FALSE             - failure on the socket
|                TRUE              - a read event was signalled
|
+------------------------------------------------------------------------------
*/
LOCAL BOOL L_AsyncSelect (void)
{
  fd_set  fd_r ;
  fd_set  fd_e ;
  int     status, rc;

  /* wait for possibility to read */
  FD_ZERO(&fd_r);
  FD_SET(L_ClientData.Socket, &fd_r);
  FD_ZERO(&fd_e);
  FD_SET(L_ClientData.Socket, &fd_e);

  status = select(FD_SETSIZE, &fd_r, NULL, &fd_e, (struct timeval *) 0);

  if (status > 0)
  {
    if (!FD_ISSET (L_ClientData.Socket, &fd_e))
    {
      if (L_ClientData.Callback != NULL)
      {
        if (FD_ISSET (L_ClientData.Socket, &fd_r))
        {
          SIZETYPE size ;

          if ((rc = GETREADSIZE( L_ClientData.Socket, &size)) != 0 || !size)
          {
#ifdef SOCK_TRACE
            if (fh_sock != -1)
            {
              char sstop[10];
              ULONG stop = GetTickCount();

              sprintf(sstop, "%03d:%03d",  (stop/1000) % 1000, stop % 1000);
              sprintf(stbuf, "reset at %s rc=%d size=%d left %d \n",
                              sstop, rc, size,
                              wrbuf_pos-wrbuf);
              write (fh_sock, stbuf, strlen(stbuf));
/*              close(fh_sock);
              fh_sock = -1; */
            }
#endif
            os_SuspendTask ( 0, 2 );
            CLOSE_SOCKET (L_ClientData.Socket);
            L_ClientData.Socket = INVALID_SOCKET;
            wrbuf_pos = wrbuf;
            sock_state = SST_PL0;
            return FALSE ;
          }

          /* Indicate that it is possible to read something */
          if (L_ClientData.EnabledSignals & DRV_SIGTYPE_READ)
          {
            SocketSignal.SignalType = DRV_SIGTYPE_READ;
            SocketSignal.DrvHandle = L_ClientData.SocketHandle;
            (*L_ClientData.Callback)(&SocketSignal) ;
          }
        }
      }
      return TRUE ;
    }
  }
  return FALSE;
}

/*
+------------------------------------------------------------------------------
|  Function    : L_ClientThread
+------------------------------------------------------------------------------
|  Description : This function is a thread used if the driver is configured to
|                be a client.
|
|  Parameters  : -
|
|  Return      : -
|
+------------------------------------------------------------------------------
*/
void L_ClientThread (T_HANDLE Handle, ULONG Value )
{
  L_ThreadActive = TRUE ;

  L_SetSocketBuffer (L_DCB.tx_buffer_size, L_DCB.rx_buffer_size) ;

  /*-------------------------------------
    Listen what's goning on on the socket
    -------------------------------------*/
  while (L_ThreadActive)
    if (!L_AsyncSelect())
    {
      L_ThreadActive = FALSE ;
      L_Disconnect() ;
    }
}


/*
+------------------------------------------------------------------------------
|  Function    : L_ServerThread
+------------------------------------------------------------------------------
|  Description : This function is a thread used if the driver is configured to
|                be a server. It serves only one client. It cycles between
|                two modes, wait for a client to connect and listening on the
|                connection for any further action.
|                The thread exits when the flag L_ThreadActive is set to false.
|
|  Parameters  : -
|
|  Return      : -
|
+------------------------------------------------------------------------------
*/
void L_ServerThread (T_HANDLE TaskHandle, ULONG Value)
{
  BOOL BufferSizeSet;
  SOCKADDR_IN local_sin;                      /* Local socket - internet style */
#ifdef _VXWORKS_
  SOCKADDR_IN clientAddr;                     /* client */
  int sockAddrSize = sizeof (struct sockaddr_in);

  memset ((char *) &local_sin, 0, sockAddrSize);
  local_sin.sin_len = (u_char) sockAddrSize;
#endif/* _VXWORKS_ */
  L_ClientData.Listener = socket (AF_INET, SOCK_STREAM, 0);
  if (L_ClientData.Listener == INVALID_SOCKET)
    goto error;

  if (L_DCB.port == SOCKET_INVALID_PORT)
    goto error;

  local_sin.sin_addr.s_addr = htonl(INADDR_ANY);
  local_sin.sin_family = AF_INET;
  local_sin.sin_port = htons(L_DCB.port);      /* Convert to network ordering */

  /*-------------------------------------------
    Associate an address with a socket. (bind)
    -------------------------------------------*/
#ifdef _PSOS_
  if (bind (L_ClientData.Listener, (struct sockaddr_in*) &local_sin, sizeof(local_sin)) != 0)
#else
#ifdef _VXWORKS_
  /* Look at the following cast of local_sin.
   * This is from VxWorks Network 5.4 Programmer’s Guide, example 7-1, page 131
   */
  if (bind (L_ClientData.Listener, (struct sockaddr*) &local_sin, sockAddrSize) == ERROR)
#else /* _VXWORKS_ */
  if (bind (L_ClientData.Listener, (const struct sockaddr FAR *) &local_sin, sizeof(local_sin)) != 0)
#endif /* _VXWORKS_ */
#endif
  {
    CLOSE_SOCKET (L_ClientData.Listener);
    goto error;
  }
#ifdef _VXWORKS_
  if (listen (L_ClientData.Listener, MAX_PENDING_CONNECTS) == ERROR)
#else /* _VXWORKS_ */
  if (listen (L_ClientData.Listener, MAX_PENDING_CONNECTS) != 0)
#endif /* _VXWORKS_ */
  {
    CLOSE_SOCKET (L_ClientData.Listener);
    goto error;
  }

  BufferSizeSet = FALSE ;
  L_ThreadActive = TRUE ;

  while (L_ThreadActive)
  {
    /*-------------------------------------
      Wait for somebody to connect
      -------------------------------------*/
    if (L_ClientData.Socket != INVALID_SOCKET)
    {
#ifdef SOCK_TRACE
      if (fh_sock != -1)
      {
        char sstop[10];
        ULONG stop = GetTickCount();

        sprintf(sstop, "%03d:%03d",  (stop/1000) % 1000, stop % 1000);
        sprintf(stbuf, "close at %s socket=%d\n",
                        sstop, L_ClientData.Socket);
        write (fh_sock, stbuf, strlen(stbuf));
/*      close(fh_sock);
        fh_sock = -1;   */
      }
#endif
      CLOSE_SOCKET (L_ClientData.Socket);
      L_ClientData.Socket = INVALID_SOCKET;
      wrbuf_pos = wrbuf;
      sock_state = SST_PL0;
    }
#ifdef _VXWORKS_
    if ((L_ClientData.Socket = accept (L_ClientData.Listener,
                                       (struct sockaddr *) &clientAddr,
                                       &sockAddrSize)) != ERROR)
#else /* _VXWORKS_ */
    L_ClientData.Socket = accept(L_ClientData.Listener, NULL, NULL) ;
    if (L_ClientData.Socket != INVALID_SOCKET)
#endif /* _VXWORKS_ */
    {
#ifdef SOCK_TRACE
      if (fh_sock == -1)
        fh_sock = open("SOCK_S.dbg", O_WRONLY| O_TEXT| O_TRUNC| O_CREAT, 0666);
      if (fh_sock != -1)
      {
        char sstop[10];
        ULONG stop = GetTickCount();

        sprintf(sstop, "%03d:%03d",  (stop/1000) % 1000, stop % 1000);
        sprintf(stbuf, "accept at %s socket=%d listener=%d\n",
                        sstop, L_ClientData.Socket, L_ClientData.Listener);
        write (fh_sock, stbuf, strlen(stbuf));
      }
#endif

#ifdef _PSOS_
      {
        ULONG tid;
        int err;
        /* for pSOS */
        /* wait for TST task */
        while( t_ident( FRM_TST_NAME, 0, &tid ) != 0 )
          tm_wkafter( 10 );

        tst_socket = shr_socket( L_ClientData.Socket, (int)tid );
        if( tst_socket < 0 )
        {
          err = errno;
          goto error;
        }
      }
#endif

      if (!BufferSizeSet)
        L_SetSocketBuffer (L_DCB.tx_buffer_size, L_DCB.rx_buffer_size) ;

      /* Signalisiere Connect */
      L_ClientData.Connect = TRUE;
      if (L_ClientData.EnabledSignals & DRV_SIGTYPE_CONNECT)
      {
        SocketSignal.SignalType = DRV_SIGTYPE_CONNECT;
        SocketSignal.DrvHandle = L_ClientData.SocketHandle;
        (*L_ClientData.Callback)(&SocketSignal) ;
      }

      /*-------------------------------------
        Listen what's goning on on the socket
        -------------------------------------*/
      while (L_ThreadActive)
        if (!L_AsyncSelect())
        {
          L_Disconnect() ;
          break ;
        }
    }
  }

error:
#ifndef OLD_FRAME
  for(;;)
    os_SuspendTask( 0, 1000 );
#endif
}

/*
+------------------------------------------------------------------------------
|  Function    : socket_Create
+------------------------------------------------------------------------------
|  Description : This function is used to set up the driver to act as a
|                server. The function tries to initialize the socket, creates
|                a thread in which it awaits first awaits the establishement
|                of a connection by a client. As soon as a client has
|                connected a signal (SOCKET_CONNECTED) is generated (call
|                socket_SetSignal() to activate a signal). From this time the
|                driver is able to send data (socket_write()) to the client and
|                to read received data (socket_read()). To get notified about
|                the reception of data the apropriate signal has to be set.
|                In the case of a successful completion the driver returns
|                DRV_OK.
|                If the driver is already busy DRV_INPROCESS is returned.
|                If the driver is not configured, the function returns
|                DRV_ NOTCONFIGURED.
|
|  Parameters  : -
|
|  Return      : DRV_OK             - Function successful
|                DRV_INPROCESS      - The driver is currently reading data.
|                                     The data is incomplete.
|                DRV_NOTCONFIGURED  - The driver is not yet configured
|                SOCKET_ERRORUNSPEC - Error occured during initialization
|
+------------------------------------------------------------------------------
*/
LOCAL UBYTE L_CreateServer (void)
{
  if (!L_CreateThread (L_ServerThread))
  {
    CLOSE_SOCKET (L_ClientData.Listener);
    return SOCKET_ERRUNSPEC;
  }
#ifdef _TOOLS_
  printf("SOCKET: now listening on port %i ...\n",L_DCB.port); 
#endif

  return DRV_OK ;
}
/*
+------------------------------------------------------------------------------
| Function    : socket_WriteToOS
+------------------------------------------------------------------------------
| Description : This function is used to write data to the driver of operating
|               system.
|               The parameter thr_BufferSize contains the number of
|               characters to write. In the case of a successful completion,
|               the function returns DRV_OK.
|
| Parameters  : in_BufferPtr          - This parameter points to the buffer
|                                       that is passed to the driver for
|                                       further processing
|               thr_BufferSize        - number of characters to write.
|
| Return      : DRV_OK            - Function successful
|               DRV_INPROCESS     - Driver is busy writing data
|               SOCKET_NOCONNECT  - Connection not available
|
+------------------------------------------------------------------------------
*/
LOCAL UBYTE socket_WriteToOS (void*  in_BufferPtr, USHORT thr_BufferSize)
{
  int             err;
  USHORT          c_written;
#ifndef _PSOS_
  fd_set          fd_w;
  fd_set          fd_e;
  struct timeval  tv;

  if (L_ClientData.Socket == INVALID_SOCKET)
    return SOCKET_NOCONNECT;

  if ( L_ClientData.Connect == FALSE )
    return SOCKET_NOCONNECT ;

  tv.tv_sec = (int)(L_DCB.tx_timeout_msec / 1000) ;
  tv.tv_usec = SEND_TIMEOUTUSEC ;

  FD_ZERO(&fd_w);
  FD_SET(L_ClientData.Socket, &fd_w);
  FD_ZERO(&fd_e);
  FD_SET(L_ClientData.Socket, &fd_e);

  if (select(FD_SETSIZE, NULL, &fd_w, &fd_e, &tv) <= 0)
  {
#ifdef SOCKET_DEBUG
    char buffer[200];
    char *ptr = in_BufferPtr;
    char c = ptr[21];
    fp = fopen(inprocessfile, "at");
    if ( *ptr == 'P' )
      ptr[21] = 0;
    else
      ptr[thr_BufferSize] = 0;
    strcpy (buffer, "errno:" );    
    sprintf (&buffer[6], "%8d", WSAGetLastError() );
    buffer[14] = ' ';
    memcpy (&buffer[15], ptr, (thr_BufferSize)+1);
    fprintf (fp, "%s\n", buffer );
    ptr[21] = c;
    fclose(fp);
#endif  /* SOCKET_DEBUG */
#ifdef _VXWORKS_
    err = errnoGet ();
#else /* _VXWORKS_ */
    err = errno;
    printf("SOCKET: socket write failed with error code: %d\n",err );
#endif /* _VXWORKS_ */

    return DRV_INPROCESS ;
  }

  if (FD_ISSET (L_ClientData.Socket, &fd_e))
  {
#ifdef SOCKET_DEBUG
    char buffer[200];
    char *ptr = in_BufferPtr;
    char c = ptr[21];
    fp = fopen(noconnectfile1, "at");
    if ( *ptr == 'P' )
      ptr[21] = 0;
    else
      ptr[thr_BufferSize] = 0;
    strcpy (buffer, "errno:" );
    sprintf (&buffer[6], "%8d", WSAGetLastError() );
    buffer[14] = ' ';
    memcpy (&buffer[15], ptr, (thr_BufferSize)+1);
    fprintf (fp, "%s\n", buffer );
    ptr[21] = c;
    fclose(fp);
#endif  /* SOCKET_DEBUG */
    return SOCKET_NOCONNECT ;
  }

  /*---------------------------------
    Send the data
    ---------------------------------*/
  c_written = (USHORT) WRITE_SOCKET(L_ClientData.Socket, in_BufferPtr, (USHORT)thr_BufferSize);

  if (c_written == (USHORT)SOCKET_ERROR || c_written != thr_BufferSize)
  {
#ifdef SOCKET_DEBUG
    char buffer[200];
    char *ptr = in_BufferPtr;
    char c = ptr[21];
    fp = fopen(noconnectfile2, "at");
    if ( *ptr == 'P' )
      ptr[21] = 0;
    else
      ptr[thr_BufferSize] = 0;
    strcpy (buffer, "errno:" );
    sprintf (&buffer[6], "%8d", WSAGetLastError() );
    buffer[14] = ' ';
    memcpy (&buffer[15], ptr, (thr_BufferSize)+1);
    fprintf (fp, "%s\n", buffer );
    ptr[21] = c;
    fclose(fp);
#endif  /* SOCKET_DEBUG */
    return SOCKET_NOCONNECT ;
  }

#ifdef SOCK_TRACE
  if (fh_sock != -1)
  {
    char sstop[10];
    ULONG stop = GetTickCount();

    sprintf(sstop, "%03d:%03d",  (stop/1000) % 1000, stop % 1000);
    sprintf(stbuf, "sent %d at %s\n",
                 thr_BufferSize,
                 sstop);
    write (fh_sock, stbuf, strlen(stbuf));
  }
#endif
  return DRV_OK ;

#else

  /* pSOS */

  /*---------------------------------
    Send the data
    ---------------------------------*/
  c_written = (USHORT) WRITE_SOCKET(tst_socket, in_BufferPtr, (USHORT)thr_BufferSize);

  if (c_written == (USHORT)SOCKET_ERROR || c_written != thr_BufferSize)
  {
    err = errno;
    return SOCKET_NOCONNECT ;
  }

  return DRV_OK ;
#endif  /* _PSOS_ */
}

/*==== PUBLIC FUNCTIONS =====================================================*/

/*
+------------------------------------------------------------------------------
|  Function    : socket_Exit
+------------------------------------------------------------------------------
|  Description : The function is called when the driver functionality is no
|                longer required. The function "de-allocates" the resources
|                and releases active connections. The driver terminates
|                regardless of any outstanding data to be sent.
|
|  Parameters  : -
|
|  Return      : -
|
+------------------------------------------------------------------------------
*/
void socket_Exit (void)
{
  os_DestroyTask ( 0, L_ClientData.ThreadID );
  socket_Close() ;
}


/*
+------------------------------------------------------------------------------
|  Function    : socket_Open
+------------------------------------------------------------------------------
|  Description : This function is used to establish a connection to server or
|                activate the driver to act as a server, using the settings of
|                the socket_DCB. A hostname must be specified to open a
|                connection to a server, in this case the driver runs in the
|                client mode. If no hostname is specified the driver will run in
|                server mode. In the server mode it serves a single client. As
|                soon as a client is connected the CONNECT signal is generated.
|                In case of a successful completion the driver is no able to send
|                data (socket_write()) to the peer entity and to read data
|                received from the peer entity (socket_read()). To get notified
|                about the reception of data the appropriate signal has to be set
|                (socket_SetSignal()).
|                In the case of a successful completion the driver returns DRV_OK.
|                If the driver is already busy DRV_INPROCESS is returned.
|                If the driver is not configured, the function returns
|                DRV_NOTCONFIGURED.
|                If an error occurs while establishing the requested mode, the
|                function returns SOCKET_ERRUNSPEC.
|
|  Parameters  : -
|
|  Return      : DRV_OK            - Function successful
|                DRV_INPROCESS     - The driver is currently reading data.
|                                    The data is incomplete.
|                DRV_NOTCONFIGURED - The driver is not yet configured
|                SOCKET_ERRUNSPEC  - Error occured during initialization
|
+------------------------------------------------------------------------------
*/
USHORT socket_Open (void)
{
  SOCKADDR_IN dest_sin;  /* DESTination Socket INternet */
  SOCKET      connectsocket;
#ifdef _VXWORKS_
  int sockAddrSize;
#else /* _VXWORKS_ */
  #if defined (_LINUX_) || defined (_SOLARIS_)
    struct hostent* phe;
  #else
    PHOSTENT    phe;
  #endif
#endif /* _VXWORKS_ */
  if (L_ThreadActive)
  {
    return DRV_INPROCESS ;
  }

  /*---------------------------------
    if no hostname is specified we
    open as a server
    ---------------------------------*/
  if (!*L_DCB.hostname)
  {
    return L_CreateServer() ;
  }

  connectsocket = socket (AF_INET, SOCK_STREAM, 0);
  if (connectsocket == INVALID_SOCKET)
  {
    return SOCKET_ERRUNSPEC;
  }

#ifdef _PSOS_

  if ( !gethostbyname(L_DCB.hostname, phe))
  {
    CLOSE_SOCKET(connectsocket);
    return SOCKET_ERRUNSPEC;
  }

#else /* _PSOS_ */
  #ifdef _VXWORKS_
    sockAddrSize = sizeof (struct sockaddr_in);
    memset((char *) &dest_sin, 0, sockAddrSize);
    dest_sin.sin_len = (u_char) sockAddrSize;
    dest_sin.sin_family = AF_INET;
    dest_sin.sin_port = htons(L_DCB.port);
    if (((dest_sin.sin_addr.s_addr = inet_addr (L_DCB.hostname)) == ERROR) &&
    ((dest_sin.sin_addr.s_addr = hostGetByName (L_DCB.hostname)) == ERROR))
    {
      CLOSE_SOCKET(connectsocket);
      return SOCKET_ERRUNSPEC;
    }
  #else /* _VXWORKS_ */
  phe = gethostbyname(L_DCB.hostname);
  if (!phe)
  {
#ifdef _TOOLS_
    printf("SOCKET: host %s not found ;-(\n",L_DCB.hostname); 
#endif
    CLOSE_SOCKET(connectsocket);
    return SOCKET_ERRUNSPEC;
  }
  #endif /* _VXWORKS_ */
#endif  /* _PSOS_ */

#ifndef _VXWORKS_
  memset(&dest_sin, 0, sizeof(struct sockaddr_in));
  memcpy((char*)&(dest_sin.sin_addr), phe->h_addr, (unsigned int)((int)(phe->h_length)));
  dest_sin.sin_family = AF_INET;
  if ( L_DCB.config & TI_MODE )
    dest_sin.sin_port = L_DCB.port;
  else
    dest_sin.sin_port = htons(L_DCB.port);
#endif /* _VXWORKS_ */

#ifdef _PSOS_
  if (connect (connectsocket, (struct sockaddr_in*) &dest_sin, sizeof(dest_sin)))
#else /* _PSOS_ */
  #ifdef _VXWORKS_
  if (connect (connectsocket, (struct sockaddr*) &dest_sin, sockAddrSize) == ERROR)
  #else /* _VXWORKS_ */
    #if defined (_LINUX_) || defined (_SOLARIS_)
      if (connect (connectsocket, (struct sockaddr*) &dest_sin,
                   sizeof(dest_sin)))
    #else
      if (connect (connectsocket, (const PSOCKADDR) &dest_sin,
                   sizeof(dest_sin)))
    #endif
  #endif /* _VXWORKS_ */
#endif /* defined(_PSOS_) || defined(_VXWORKS_) */
  {
#ifdef _TOOLS_
    printf("SOCKET: connection to %s on port %i failed ;-(\n",L_DCB.hostname,L_DCB.port); 
#endif
    CLOSE_SOCKET(connectsocket);
    return SOCKET_ERRUNSPEC;
  }
#ifdef _TOOLS_
  printf("SOCKET: successfully connected to %s on port %i\n",L_DCB.hostname,L_DCB.port); 
#endif

  if (!L_CreateThread (L_ClientThread))
  {
    CLOSE_SOCKET (L_ClientData.Listener);
    return SOCKET_ERRUNSPEC;
  }

  L_ClientData.Socket = connectsocket ;
  L_ClientData.Connect = TRUE;
  if (L_ClientData.EnabledSignals & DRV_SIGTYPE_CONNECT)
  {
    SocketSignal.SignalType = DRV_SIGTYPE_CONNECT;
    SocketSignal.DrvHandle = L_ClientData.SocketHandle;
    (*L_ClientData.Callback)(&SocketSignal) ;
  }
  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
|  Function    : socket_Close
+------------------------------------------------------------------------------
|  Description : This function is used by a client to close the connection or
|                by server to shut down the server functionality.
|                In case of a successful completion the connection is shutdown
|                and neither socket_Read nor socket_Write will be successful.
|                To get notified about the termination of a connection the
|                appropriate signal has to be set (socket_SetSignal()).
|
|  Parameters  : -
|
|  Return      : -
|
+------------------------------------------------------------------------------
*/
USHORT socket_Close (void)
{
  L_ThreadActive = FALSE ;

#ifdef SOCK_TRACE
  if (fh_sock != -1)
  {
    char sstop[10];
    ULONG stop = GetTickCount();

    sprintf(sstop, "%03d:%03d",  (stop/1000) % 1000, stop % 1000);
    sprintf(stbuf, "socket_Close at %s socket=%d listener=%d\n",
                    sstop, L_ClientData.Socket, L_ClientData.Listener);
    write (fh_sock, stbuf, strlen(stbuf));
  }
#endif
  if (L_ClientData.Socket != INVALID_SOCKET)
  {
    CLOSE_SOCKET (L_ClientData.Socket);
    L_ClientData.Socket = INVALID_SOCKET;
  }

  if (L_ClientData.Listener != INVALID_SOCKET)
    CLOSE_SOCKET (L_ClientData.Listener);

  L_ClientData.ThreadID = 0 ;
  return DRV_OK;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_Read_with_Timeout
+------------------------------------------------------------------------------
| Description : This function is used to read data from the USART driver.
|               For more details see socket_Read()
|
| Return:       >= 0         - Number of bytes read
|               SOCKET_ERROR - error occurred
+------------------------------------------------------------------------------
*/
LOCAL ULONG socket_Read_with_Timeout( void* destBuf, ULONG reqLen )
{
  ULONG timeout,
        totalBytes = 0,
        stop_timeout ;
  int readBytes,
        attempts = 0;

  /* calculate timeout time */
  GETTIME( stop_timeout );
  stop_timeout = stop_timeout + L_DCB.rx_timeout_msec ;

  /* read nonblocking until requested data is read or timeout */
  do
  {
    readBytes = (SHORT)READ_SOCKET( L_ClientData.Socket,
                                    ((char *)destBuf) + totalBytes,
                                    reqLen - totalBytes );

    if( readBytes < 0 || readBytes == SOCKET_ERROR )
    {
#ifdef SOCKET_DEBUG
#ifndef _PSOS_
      fp = fopen(readerrorfile, "at");
      fprintf (fp, "WSAGetLastError returned: %8d", WSAGetLastError() );
      fclose(fp);
#endif
#endif  /* SOCKET_DEBUG */
      return 0;
    }
    else
    {
      totalBytes += (unsigned int)readBytes;

      GETTIME (timeout) ;

      if( totalBytes < reqLen )
      {
        if (attempts++)   /* try to get data by two consecutive accesses
                             then sleep (but this should not be necessary) */
        {
#ifdef OLD_FRAME
          Sleep (1) ;
#else
          os_SuspendTask ( 0, 1 );
#endif
        }
      }
      else
      {
        return totalBytes;
      }
    }
  } while (timeout < stop_timeout);

  return 0;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_Read
+------------------------------------------------------------------------------
| Description : This function is used to read data from the USART driver. The
|               data is copied into the buffer to which out_BufferPtr points.
|               The parameter *thr_BufferSizePtr contains the size of the
|               buffer in characters.
|               In the case of a successful completion, the driver's buffer
|               is cleared. The driver keeps the data available when calling
|               the function drv_Look().
|               If the driver is not configured, the function returns
|               DRV_NOTCONFIGURED.
|
|               NOTE: When calling the function with a buffer size of 0, the
|                     function will return DRV_OK. The size of the buffer
|                     needed to store the available data is stored in the
|                     parameter *thr_BufferSizePtr. In this case, the
|                     out_BufferPtr can be set to NULL.
|
|
| Parameters  : out_BufferPtr         - This parameter points to the buffer
|                                       wherein the data is to be copied
|               thr_BufferSizePtr     - On call: number of characters to
|                                       read. If the function returns DRV_OK,
|                                       it contains the number of characters
|                                       read. If the function returns
|                                       DRV_INPROCESS, it contains 0.
|
| Return      : DRV_OK             - Function successful
|               DRV_INPROCESS      - The driver is currently reading data.
|                                    The data is incomplete.
|               DRV_NOTCONFIGURED  - The driver is not yet configured
|               SOCKET_NOCONNECT   - Connection not available
|
+------------------------------------------------------------------------------
*/
USHORT socket_Read (void* out_BufferPtr, ULONG*  thr_BufferSizePtr)
{
#ifdef _VXWORKS_
  SIZETYPE           pending_data_size = 0;
#else
  ULONG              pending_data_size = 0;
#endif
  ULONG              bytesToRead, bytesReq;
  int                rc;
  static USHORT      packet_size;
  union
  {
    USHORT s;
    UBYTE  b[2];
  } conv;
#ifdef SOCKET_DEBUG
  static ULONG BytesRead = 0;
#endif
#ifdef SOCK_TRACE
  static ULONG start;
  static ULONG lasttime = 0;
#endif

  bytesReq = *thr_BufferSizePtr;
  *thr_BufferSizePtr = 0;      /* no bytes returned yet */
  while ( (rc = (GETREADSIZE( L_ClientData.Socket, &pending_data_size ))) == 0 &&
          pending_data_size > 0 )
  {
    switch (sock_state)
    {
      case SST_PL0:
#ifdef SOCK_TRACE
        GETTIME (start) ;
#endif
        packet_size = 0;
        if (pending_data_size >= 2)
        {
          bytesToRead = 2;
          sock_state = SST_DATA0;
        }
        else
        {
          bytesToRead = 1;
          sock_state = SST_PL1;
        }
        if ( !(L_DCB.config & TI_MODE) )
        {
          if (socket_Read_with_Timeout(&packet_size, bytesToRead) != bytesToRead)
          {
            sock_state = SST_PL0;
            return SOCKET_NOCONNECT;
          }
        }
        break;
      case SST_PL1:
        if (socket_Read_with_Timeout(((char*)&packet_size)+1, 1) != 1)
        {
          sock_state = SST_PL0;
          return SOCKET_NOCONNECT;
        }
        sock_state = SST_DATA0;
        break;
      case SST_DATA0:
        if ( !(L_DCB.config & TI_MODE) && isLittleEndian )
        {
          conv.b[0] = *(((UBYTE*)&packet_size)+1); /* LSB */
          conv.b[1] = *  (UBYTE*)&packet_size;     /* MSB */
          packet_size = conv.s;
        }  
        /*lint -fallthrough*/
      case SST_DATAx:
        /* now read the packet payload or a part of it */
        if ( L_DCB.config & TI_MODE )
        {
          bytesToRead = (pending_data_size < bytesReq) ? pending_data_size : bytesReq;
        }
        else
        {
          bytesToRead = (packet_size < bytesReq) ? packet_size : bytesReq;
          if (pending_data_size < bytesToRead)
            bytesToRead = pending_data_size;
        }
        if( (*thr_BufferSizePtr =
              socket_Read_with_Timeout( ((char *)out_BufferPtr), bytesToRead )) !=
              bytesToRead )
        {
          *thr_BufferSizePtr = 0;
          if ( !(L_DCB.config & TI_MODE) )
            sock_state = SST_PL0;
          return SOCKET_NOCONNECT;
        }
#ifdef SOCK_TRACE
        if (fh_sock != -1 && sock_state == SST_DATA0 && bytesToRead >= 13)
        {
          char split[10+1];
          char sstart[20], sstop[20];
          static ULONG c_received = 0;
          ULONG len = packet_size;
          ULONG stop = GetTickCount();

          if (((char*)out_BufferPtr)[13] == 'T')
          {
            memcpy(split, ((char*)out_BufferPtr)+9, 7);
            split[7] = '\0';
          }
          else
          {
            memcpy(split, ((char*)out_BufferPtr)+9, 4);
            split[4] = '\0';
          }
          if (start != lasttime)
          {
            if (lasttime - start > 11)
              sprintf(sstart, "->%d %03d:%03d\n", c_received, (start/1000) % 1000, start % 1000);
            else
              sprintf(sstart, "%03d:%03d\n", (start/1000) % 1000, start % 1000);
            c_received = 0;
          }
          c_received += packet_size + 2;
          if (start != stop)
          {
            sprintf(sstop, "->%d %03d:%03d\n", c_received, (stop/1000) % 1000, stop % 1000);
            c_received = 0;
          }
          sprintf(stbuf, "%s%d %s\n%s",
                       (start != lasttime) ? sstart : "",
                       packet_size + 2, split,
                       (start != stop) ? sstop : "");
          write (fh_sock, stbuf, strlen(stbuf));
          lasttime = stop;
        }
#endif
        if ( !(L_DCB.config & TI_MODE) )
        {
          if (*thr_BufferSizePtr == packet_size)
            sock_state = SST_PL0;
          else
          {
            packet_size -= (USHORT)*thr_BufferSizePtr;
            sock_state = SST_DATAx;
          }
        }
        return DRV_OK;
    /*lint -e527 suppress Warning -- Unreachable */
        break;
    /*lint +e527 */
    }  /* switch */
  } /* while */
  if (rc)
  {
    sock_state = SST_PL0;
    return SOCKET_NOCONNECT;
  }
#ifdef SOCKET_DEBUG
  {
    static char Buffer[2000];
    memcpy (Buffer+BytesRead,out_BufferPtr,*thr_BufferSizePtr);
    BytesRead += *thr_BufferSizePtr;
    if ( (Buffer[0] == 'P') )
    {
      OS_TIME time;
      char c = Buffer[21];
      fp = fopen(logfile, "at");
      Buffer[21] = 0;
      os_GetTime ( 0, &time );
      fprintf (fp, "P%ld IN:  %s\n", time/10, &Buffer[9] );
      Buffer[21] = c;
      fclose(fp);
    }
  }

#endif
  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_Write
+------------------------------------------------------------------------------
| Description : This function is used to write data to the driver. The
|               parameter *thr_BufferSizePtr contains the number of
|               characters to write. In the case of a successful completion,
|               the function returns DRV_OK.
|               If the data cannot be written because the storage capacity of
|               the driver has been exhausted, the function returns
|               DRV_BUFFER_FULL and the maximum number of characters that can
|               be written in *thr_BufferSizePtr.
|               If the driver is currently busy writing data and therefore
|               cannot accept further data to be written, it returns
|               DRV_INPROCESS and sets the parameter *thr_BufferSizePtr to 0.
|               If the driver is not configured, the function returns
|               DRV_ NOTCONFIGURED.
|
|               NOTE:  When calling the function with a buffer size of 0, the
|                     function will return the number of characters that can be
|                     written in the parameter *thr_BufferSizePtr. In this
|                     case, the in_BufferPtr can be set to NULL.
|
| Parameters  : in_BufferPtr          - This parameter points to the buffer
|                                       that is passed to the driver for
|                                       further processing
|               thr_BufferSizePtr     - On call: number of characters to
|                                       write. If the function returns
|                                       DRV_BUFFER_FULL, it contains the
|                                       maximum number of characters that can
|                                       be written. If the function returns
|                                       DRV_OK, it contains the number of
|                                       characters written. If the function
|                                       returns DRV_INPROCESS, it contains 0.
|
|
| Return      : DRV_OK            - Function successful
|               DRV_BUFFER_FULL   - Not enough space
|               DRV_INPROCESS     - Driver is busy writing data
|               DRV_NOTCONFIGURED - The driver is not yet configured
|               SOCKET_NOCONNECT  - Connection not available
|
+------------------------------------------------------------------------------
*/
/*lint -esym(613,auxb) suppress warning possibly use off NULL pointer auxb */
/*lint -esym(644,auxb) suppress warning possibly not initialized */
/*lint -e668           suppress warning possibly passing NULL pointer to memcpy */
USHORT socket_Write (void*  in_BufferPtr, ULONG*  thr_BufferSizePtr)
{
  UBYTE    rc = DRV_OK;
  int   max_len, rest;
  char *   auxb;
  ULONG buffer_size;
  
  buffer_size = *thr_BufferSizePtr & ~PRIM_FLAG_MASK;

#ifndef _PSOS_
#ifdef SOCKET_DEBUG
  UBYTE Prim = 0;
  {
    char *ptr = in_BufferPtr;
    if ( *ptr == 'P' )
    {
      OS_TIME time;
      char c = ptr[21];
      fp = fopen(logfile, "at");
      ptr[21] = 0;
      os_GetTime ( 0, &time );
      fprintf (fp, "P%ld OUT: %s\n", time/10, &ptr[9] );
      ptr[21] = c;
      fclose(fp);
      Prim = 1;
    }
  }
#endif  /* SOCKET_DEBUG */
#else /* _PSOS */
  if( !tst_socket_initialized )
  {
    if (tst_socket_in_TxLen > 0)
    {
      int nodelay = TRUE;
      if (setsockopt(tst_socket, SOL_SOCKET, SO_SNDBUF,
                     (char*)&tst_socket_in_TxLen, sizeof(tst_socket_in_TxLen)))
        return DRV_INITFAILURE;
      if (setsockopt(tst_socket, IPPROTO_TCP, TCP_NODELAY,
                   (char*)&nodelay, sizeof(nodelay)))
        return DRV_INITFAILURE;
    }
    tst_socket_initialized = 1;
  }
#endif /* _PSOS_ */

  if ( L_DCB.config & TI_MODE )
  {
    /* add TI-MUX header */
    auxb=(char*)malloc(buffer_size+2);
    memcpy((void*)(auxb+2),in_BufferPtr,buffer_size);
    auxb[0]=19; /* assigned to L23 */
    auxb[1]=(char)buffer_size;
    in_BufferPtr=auxb;
    buffer_size+=2;
  }

  max_len = (L_DCB.tx_buffer_size < WRBUF_LEN) ? L_DCB.tx_buffer_size : WRBUF_LEN;
  if (max_len < (int)buffer_size)
  {
#ifndef _PSOS_
#ifdef SOCKET_DEBUG
    char buffer[200];
    char *ptr = in_BufferPtr;
    char c = ptr[21];
    fp = fopen(bufferfullfile, "at");
    if ( *ptr == 'P' )
      ptr[21] = 0;
    else
      ptr[buffer_size] = 0;
    strcpy (buffer, "errno:" );
    sprintf (&buffer[6], "%8d", WSAGetLastError() );
    buffer[14] = ' ';
    memcpy (&buffer[15], ptr, (buffer_size)+1);
    fprintf (fp, "%s\n", buffer );
    ptr[21] = c;
    fclose(fp);
#endif  /* SOCKET_DEBUG */
#endif  /* _PSOS_ */
    if ( L_DCB.config & TI_MODE )
      free(auxb);
    *thr_BufferSizePtr = (unsigned int)max_len |
                                      (*thr_BufferSizePtr & PRIM_FLAG_MASK) ;
    return DRV_BUFFER_FULL ;
  }

  rest = MAX_ETH_LEN - (wrbuf_pos - wrbuf);
  if (buffer_size + 2 >= (unsigned int)rest)    /* more than maximum ethernet packet size needed ?*/
  {
  /*---------------------------------
    send the buffer
    ---------------------------------*/
    rc = socket_WriteToOS(wrbuf, (USHORT)(wrbuf_pos - wrbuf));
    wrbuf_pos = wrbuf;

    if (rc != DRV_OK)
    {
      if ( L_DCB.config & TI_MODE )
        free(auxb);
      *thr_BufferSizePtr = (*thr_BufferSizePtr & PRIM_FLAG_MASK) ;
      return rc;
    }
  }

  if ( !(L_DCB.config & TI_MODE) )
  {
    /*------------------------------------------------
      put the size of the data into buffer (MSB first)
      ------------------------------------------------*/
    if (isLittleEndian)
    {
      *wrbuf_pos     = *(((UBYTE*)&buffer_size)+1); /* MSB */
      *(wrbuf_pos+1) = *  (UBYTE*)&buffer_size;     /* LSB */
    }
    else
      *((USHORT*)wrbuf_pos) = (USHORT)buffer_size;
    wrbuf_pos += 2;
  }
  /*---------------------------------
    put the data itself into buffer
    ---------------------------------*/
  memcpy(wrbuf_pos, in_BufferPtr, (size_t)buffer_size);
  wrbuf_pos += buffer_size;

  if (socket_flush)
  {
    /*---------------------------------
      send the buffer
      ---------------------------------*/
    rc = socket_WriteToOS(wrbuf, (USHORT)(wrbuf_pos - wrbuf));
    wrbuf_pos = wrbuf;
    socket_flush = 0;

    if (rc != DRV_OK)
    {
      *thr_BufferSizePtr = (*thr_BufferSizePtr & PRIM_FLAG_MASK) ;
    }
  }

  if ( L_DCB.config & TI_MODE )
  {
    free(auxb);
  }
  return rc ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_Flush
+------------------------------------------------------------------------------
| Description : This function flushes the socket write buffer where data
|               is stored until a complete packet can be sent or the
|               transmission is forced by an external setting of the
|               socket_flush flag. 
|
| Parameters  : ---
|
| Return      : DRV_OK                  - Function completed successfully
|
+------------------------------------------------------------------------------
*/
USHORT socket_Flush ( void )
{
ULONG len = 0;

  socket_flush = 1;
  return ( socket_Write(NULL, &len) );
}

/*
+------------------------------------------------------------------------------
| Function    : socket_SetSignal
+------------------------------------------------------------------------------
| Description : This function is used to define a single or multiple signals
|               that is/are indicated to the process when the event identified
|               in the signal information data type as SignalType occurs. The
|               USART uses only the standard signals defined in [C_8415.0026].
|               To remove a signal, call the function socket_ResetSignal().
|               If one of the parameters of the signal information data is
|               invalid, the function returns DRV_INVALID_PARAMS.
|               If no signal call-back function has been defined at the time
|               of initialization, the driver returns DRV_SIGFCT_NOTAVAILABLE.
|
| Parameters  : in_SignalIDPtr        - Pointer to the signal information
|                                       data
|
| Return      : DRV_OK                  - Function completed successfully
|               DRV_INVALID_PARAMS      - One or more parameters are out of
|                                         range or invalid
|               DRV_SIGFCT_NOTAVAILABLE - Event signaling functionality is
|                                         not available
|
+------------------------------------------------------------------------------
*/
USHORT socket_SetSignal (USHORT SignalType)
{
  if (L_ClientData.Callback == NULL)
    return DRV_SIGFCT_NOTAVAILABLE ;

  if (SignalType & ALLOWED_SOCKET_SIGNALS)
    L_ClientData.EnabledSignals |= SignalType;
  else
    return DRV_INVALID_PARAMS ;
  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_ResetSignal
+------------------------------------------------------------------------------
| Description : This function is used to remove previously set single or
|               multiple signals. The signals that are removed are identified
|               by the Signal Information Data element called SignalType. All
|               other elements of the Signal Information Data must be
|               identical to the signal(s) that are to be removed (process
|               handle and signal value). If the SignalID provided cannot be
|               located, the function returns DRV_INVALID_PARAMS.
|               If no signal call-back function has been defined at the time
|               of initialization, the driver returns DRV_SIGFCT_NOTAVAILABLE.
|
| Parameters  : in_SignalIDPtr        - Pointer to the signal information
|                                       data
|
| Return      : DRV_OK                    - Function completed successfully
|               DRV_INVALID_PARAMS        - One or more parameters are out of
|                                           range or invalid
|               DRV_SIGFCT_NOTAVAILABLE   - Event signaling functionality is
|                                           not available
|
+------------------------------------------------------------------------------
*/
USHORT socket_ResetSignal (USHORT SignalType)
{
  if (L_ClientData.Callback == NULL)
    return DRV_SIGFCT_NOTAVAILABLE ;

  if (SignalType & ALLOWED_SOCKET_SIGNALS)
    L_ClientData.EnabledSignals &= ~SignalType;
  else
    return DRV_INVALID_PARAMS ;

  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_SetConfig
+------------------------------------------------------------------------------
| Description : This function is used to configure the driver (port,
|               transmission rate, flow control, etc). The driver can be
|               configured at any one time before a connection is opened. The
|               parameters that can be configured are included in the USART's
|               device control block socket_DCB_Type. For detailed information
|               about the contents of the device control block, refer to
|               Chapter 2.1.1. If any value of the configuration is out of
|               range or invalid in combination with any other value of the
|               configuration, the function returns DRV_INVALID_PARAMS.
|               Call the socket_GetConfig() function to retrieve the driver's
|               configuration.
|               The driver needs to be configured after initialization. Only
|               the following functions can be called while the driver is not
|               configured: socket_Clear, socket_SetSignal and socket_GetSignal.
|               All other functions return DRV_NOTCONFIGURED.
|
| Parameters  : in_DCBPtr             - Pointer to the driver control block
|
| Return      : DRV_OK                    - Function completed successfully
|               DRV_INVALID_PARAMS        - One or more parameters are out of
|                                           range or invalid
|
+------------------------------------------------------------------------------
*/
USHORT socket_SetConfig (char* in_DCBPtr)
{
char token [SOCKET_MAX_LEN_HOSTNAME+1];
USHORT port;
unsigned int len;

  if ( (len = GetNextToken (in_DCBPtr, token, " #")) == 0)
  {
    return DRV_INVALID_PARAMS;
  }
  else
  {
    in_DCBPtr += (len+1);
  }

  port = (USHORT)atoi(token);

  if ( (len = GetNextToken (in_DCBPtr, token, " #")) == 0) 
  {
    return DRV_INVALID_PARAMS;
  }
  else
  {
    in_DCBPtr += (len+1);
  }

  if ( !strcmp ( DRV_TI_MODE, token ) )
  {
    L_DCB.config = TI_MODE;
    sock_state = SST_DATAx;
  }
  else if ( !strcmp ( DRV_DEFAULT, token ) )
  {
    L_DCB.config = 0;
    sock_state = SST_PL0;
  }
  else
    return DRV_INVALID_PARAMS;

  if ( (len = GetNextToken (in_DCBPtr, token, " #")) == 0 ) 
  {
#ifdef _TOOLS_
    gethostname (token,SOCKET_MAX_LEN_HOSTNAME);
#endif /* _TOOLS_ */
  }

  if (L_ThreadActive)
  {
    /* check if host is already used */
    if (strcmp(L_DCB.hostname, token)==0 && L_DCB.port==port) 
    {
#ifdef _TOOLS_
      printf("SOCKET: keeping connection to host %s on port %u\n",L_DCB.hostname,L_DCB.port); 
#endif
      return DRV_OK;
    }

    socket_Close();
  }
  
  L_DCB.port=port;
  strcpy ( L_DCB.hostname, token);
  
  if (socket_Open () != DRV_OK)
  {
    return DRV_INVALID_PARAMS ;
  }

  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_GetConfig
+------------------------------------------------------------------------------
| Description : This function is used to retrieve the configuration of the
|               driver. The configuration is returned in the driver control
|               block to which the pointer provided out_DCBPtr points. For
|               detailed information about the contents of the device control
|               block, refer to Chapter 2.1.1. The configuration can be
|               requested at any one time.
|               If the driver is not configured, the function returns
|               DRV_ NOTCONFIGURED.
|
| Parameters  : out_DCBPtr                - Pointer to the driver control block
|
| Return      : DRV_OK                    - Function completed successfully
|               DRV_INVALID_PARAMS        - One or more parameters are out of
|                                           range or invalid
|
+------------------------------------------------------------------------------
*/
USHORT socket_GetConfig (socket_DCB_Type*  out_DCBPtr)
{
  if (out_DCBPtr == NULL)
    return DRV_INVALID_PARAMS ;

  memcpy (out_DCBPtr, &L_DCB, sizeof (L_DCB)) ;
  return DRV_OK ;
}

/*
+------------------------------------------------------------------------------
| Function    : socket_Init
+------------------------------------------------------------------------------
| Description : The function initializes the internal data of the driver.
|               The function returns DRV_INITIALIZED if the driver has
|               already been initialized and is ready to be used or is
|               already in use. In the case of an initialization failure,
|               i.e. the driver cannot be used, the function returns
|               DRV_INITFAILURE.
|
| Parameters  : in_SignalCBPtr    - This parameter points to the function that
|                                   is called at the time an event that is to
|                                   be signaled occurs. This value can be set
|                                   to NULL if event signaling should not be
|                                   possible.
|
| Return      : DRV_OK            - Initialization successful
|               DRV_INITIALIZED   - Driver already initialized
|               DRV_INITFAILURE   - Initialization failed
|
+------------------------------------------------------------------------------
*/
GLOBAL USHORT socket_Init ( USHORT DrvHandle, T_DRV_CB_FUNC CallbackFunc, T_DRV_EXPORT const **DrvInfo )
{
static const T_DRV_EXPORT Socket_Info =
{
  "SOCKET",
  0,
  {
#ifdef _TOOLS_
    socket_Init,
#endif
    socket_Exit,
    socket_Read,
    socket_Write,
    NULL,
    NULL,
    socket_Flush,
    socket_SetSignal,
    socket_ResetSignal,
    socket_SetConfig,
    NULL,
    NULL,
  }
};
union
{
  USHORT s;
  UBYTE b[2];
} test;

#ifndef _PSOS_
#if defined (_VXWORKS_) || defined (_LINUX_) || defined (_SOLARIS_)
/* ToDo: vxWorks-libs initiieren
  sockLib
  inetLib
*/
#else /* _VXWORKS_ */
  WSADATA WSAData;
  if (WSAStartup(MAKEWORD(1,1), &WSAData))
    return DRV_INITFAILURE;
#endif /* _VXWORKS_ */
#endif

  test.s = 1;
  isLittleEndian = (test.b[0] == 1);

  L_ThreadActive = FALSE ;
  L_DCB.config = 0;
  L_DCB.port = 6392;
  L_DCB.tx_buffer_size = TX_BUFFER_SIZE;
  L_DCB.rx_buffer_size = RX_BUFFER_SIZE ;
  L_DCB.tx_timeout_msec = TX_TIMEOUT_MSEC;
  L_DCB.rx_timeout_msec = RX_TIMEOUT_MSEC;
  *L_DCB.hostname = 0 ;
  L_ClientData.Connect = FALSE;
  L_ClientData.SocketHandle = DrvHandle;
  L_ClientData.Socket = INVALID_SOCKET ;
  L_ClientData.Listener = INVALID_SOCKET ;
#ifdef _PSOS_
  tst_socket = INVALID_SOCKET ;
  tst_socket_initialized = 0;
  tst_socket_in_TxLen = 0;
#endif

  L_ClientData.Callback   = CallbackFunc ;
  L_ClientData.EnabledSignals = ALLOWED_SOCKET_SIGNALS ;
  *DrvInfo = &Socket_Info;
#ifdef SOCKET_DEBUG
  fp = fopen(logfile,"wt");
  fclose(fp);
  fp = fopen(inprocessfile,"wt");
  fclose(fp);
  fp = fopen(bufferfullfile,"wt");
  fclose(fp);
  fp = fopen(noconnectfile1,"wt");
  fclose(fp);
  fp = fopen(noconnectfile2,"wt");
  fclose(fp);
  fp = fopen(noconnectfile3,"wt");
  fclose(fp);
  fp = fopen(readerrorfile,"wt");
  fclose(fp);
#endif /* SOCKET_DEBUG */
  return DRV_OK ;
}

/*==== END OF FILE ==========================================================*/