---

sokintrf.c

Go to the documentation of this file.

#include "rcs_defs.hh"          /* _WINDOWS, EXTERN_C_STD_HEADERS */
#include "sokintrf.h"           /* Forward Fuction Prototypes */
#include "rcs_prnt.hh"          /* rcs_print_error() */

#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif

#ifndef MAKEWORD
#define MAKEWORD(a,b) \
        ((unsigned short) (((unsigned char) (a)) | ((unsigned short) ((unsigned char) (b)) << 8)))
#endif

  int WSA_count = 0;

#if defined(_WINDOWS) && !defined(gnuwin32)
#define USE_WINSOCK
#endif

#ifdef _WINDOWS
#ifdef gnuwin32
#define WSADESCRIPTION_LEN      256
#define WSASYS_STATUS_LEN       128

#ifndef WSADATA_DEFINED
#define WSADATA_DEFINED
  typedef struct WSAData
  {
    short wVersion;
    short wHighVersion;
    char szDescription[WSADESCRIPTION_LEN + 1];
    char szSystemStatus[WSASYS_STATUS_LEN + 1];
    unsigned short iMaxSockets;
    unsigned short iMaxUdpDg;
    char RCS_FAR *lpVendorInfo;
  }
  WSADATA;
#endif
#endif

  typedef WSADATA RCS_FAR *LPWSADATA;
  typedef int (RCS_PASCAL RCS_FAR * PTR_TO_WSASTARTUP) (short, LPWSADATA);
  extern PTR_TO_WSASTARTUP ptr_to_wsastartup;
  typedef int (RCS_PASCAL RCS_FAR * PTR_TO_WSACLEANUP) (void);
  extern PTR_TO_WSACLEANUP ptr_to_wsacleanup;


  PTR_TO_WSASTARTUP ptr_to_wsastartup = NULL;
  PTR_TO_WSACLEANUP ptr_to_wsacleanup = NULL;
  PTR_TO_WSAGETLASTERROR ptr_to_wsagetlasterror = NULL;
  void RCS_FAR *socket_library_instance = (void RCS_FAR *) NULL;

#else                           /* _WINDOWS */




#ifdef MSDOS
#include <tklib.h>
#include <sys\tk_types.h>
#include <sys\nfs_time.h>
#include <sys\socket.h>
#include <io.h>
#include <netinet\in.h>
#include <in_addr.h>
#include <netdb.h>
#else
#include <unistd.h>             /* close() */
#include <sys/types.h>          /* u_long, u_short */
#include <sys/socket.h>         /* send(), recv(), */
  /* socket(), accept(), bind(), listen() */
#include <netinet/in.h>         /* htonl(), htons(), ntohs(), ntohl() */
#if !defined(VXWORKS)
#include <arpa/inet.h>          /* inet_ntoa(), inet_addr() */
#include <netdb.h>              /* gethostbyname() */
#else
  unsigned long inet_addr (char *);
  char *inet_ntoa (struct in_addr);
#include <sockLib.h>            /* accept(), socket(), bind(), ... */
#include <ioLib.h>              /* ioctl() */
#include <selectLib.h>          /* select() */
#include <inetLib.h>            /* inet_makeaddr */
#endif

#endif

#ifdef CenterLine
  int ioctl (int, int, caddr_t);
#endif
#endif


#ifdef EXTERN_C_STD_HEADERS
}                               // extern "C"
#endif


enum SOCKET_AVAILABILITY
{
  SOCKET_AVAIL_NOT_CHECKED,
  SOCKETS_AVAILABLE,
  SOCKETS_NOT_AVAILABLE
};
enum SOCKET_AVAILABILITY socket_availability = SOCKET_AVAIL_NOT_CHECKED;



/* Declare Pointers to all the Socket Functions */
#if defined(USE_DYNAMICALLY_LOADED_POINTERS)


typedef int (RCS_PASCAL RCS_FAR * PTR_TO_SEND) (SOCKET, char RCS_FAR *, int,
                                                int);
extern PTR_TO_SEND ptr_to_send;
#ifdef MSDOS
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_SELECT) (int, void *, void *, void *,
                                                  struct timeval *);
#else
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_SELECT) (int, fd_set *, fd_set *,
                                                  fd_set *, struct timeval *);
#endif
extern PTR_TO_SELECT ptr_to_select;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_RECV) (SOCKET, char RCS_FAR *, int,
                                                int);
extern PTR_TO_RECV ptr_to_recv;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_RECVFROM) (SOCKET, char RCS_FAR *,
                                                    int, int,
                                                    struct sockaddr *, int *);
extern PTR_TO_RECVFROM ptr_to_recvfrom;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_SENDTO) (SOCKET, char RCS_FAR *, int,
                                                  int, struct sockaddr *,
                                                  int);
extern PTR_TO_SENDTO ptr_to_sendto;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_SETSOCKOPT) (SOCKET s, int level,
                                                      int optname,
                                                      const char RCS_FAR *
                                                      optval, int optlen);
extern PTR_TO_SETSOCKOPT ptr_to_setsockopt;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_IOCTLSOCKET) (SOCKET s,
                                                       long cmd,
                                                       unsigned long RCS_FAR *
                                                       argp);
extern PTR_TO_IOCTLSOCKET ptr_to_ioctlsocket;
typedef unsigned short (RCS_PASCAL RCS_FAR *
                        PTR_TO_NTOHS) (unsigned short netshort);
extern PTR_TO_NTOHS ptr_to_ntohs;
typedef unsigned long (RCS_PASCAL RCS_FAR *
                       PTR_TO_NTOHL) (unsigned long netlong);
extern PTR_TO_NTOHL ptr_to_ntohl;
typedef unsigned short (RCS_PASCAL RCS_FAR *
                        PTR_TO_HTONS) (unsigned short hostshort);
extern PTR_TO_HTONS ptr_to_htons;
typedef unsigned long (RCS_PASCAL RCS_FAR *
                       PTR_TO_HTONL) (unsigned long hostlong);
extern PTR_TO_HTONL ptr_to_htonl;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_LISTEN) (SOCKET, int);
extern PTR_TO_LISTEN ptr_to_listen;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_CONNECT) (SOCKET,
                                                   struct sockaddr RCS_FAR *,
                                                   int);
extern PTR_TO_CONNECT ptr_to_connect;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_CLOSESOCKET) (SOCKET);
extern PTR_TO_CLOSESOCKET ptr_to_closesocket;
typedef SOCKET (RCS_PASCAL RCS_FAR * PTR_TO_SOCKET) (int, int, int);
extern PTR_TO_SOCKET ptr_to_socket;
typedef unsigned long (RCS_PASCAL RCS_FAR *
                       PTR_TO_INET_ADDR) (char RCS_FAR *);
extern PTR_TO_INET_ADDR ptr_to_inet_addr;
typedef char RCS_FAR *(RCS_PASCAL RCS_FAR *
                       PTR_TO_INET_NTOA) (struct in_addr);
extern PTR_TO_INET_NTOA ptr_to_inet_ntoa;
extern PTR_TO_ACCEPT ptr_to_accept;
typedef int (RCS_PASCAL RCS_FAR * PTR_TO_BIND) (SOCKET,
                                                struct sockaddr RCS_FAR *,
                                                int);
extern PTR_TO_BIND ptr_to_bind;
typedef struct hostent *(RCS_FAR * PTR_TO_GETHOSTBYNAME) (char RCS_FAR *);
extern PTR_TO_GETHOSTBYNAME ptr_to_get_hostbyname;
#ifdef _WINDOWS
typedef int (RCS_FAR * PTR_TO_WSAISFDSET) (SOCKET, fd_set RCS_FAR *);
extern PTR_TO_WSAISFDSET ptr_to_wsaisfdset;
#endif

PTR_TO_SOCKET ptr_to_socket = NULL;
PTR_TO_CLOSESOCKET ptr_to_closesocket = NULL;
PTR_TO_ACCEPT ptr_to_accept = NULL;
PTR_TO_BIND ptr_to_bind = NULL;
PTR_TO_CONNECT ptr_to_connect = NULL;
PTR_TO_LISTEN ptr_to_listen = NULL;
PTR_TO_SELECT ptr_to_select = NULL;
PTR_TO_SEND ptr_to_send = NULL;
PTR_TO_SENDTO ptr_to_sendto = NULL;
PTR_TO_RECV ptr_to_recv = NULL;
PTR_TO_RECVFROM ptr_to_recvfrom = NULL;
PTR_TO_INET_ADDR ptr_to_inet_addr = NULL;
PTR_TO_INET_NTOA ptr_to_inet_ntoa = NULL;
PTR_TO_HTONL ptr_to_htonl = NULL;
PTR_TO_HTONS ptr_to_htons = NULL;
PTR_TO_NTOHL ptr_to_ntohl = NULL;
PTR_TO_NTOHS ptr_to_ntohs = NULL;
PTR_TO_SETSOCKOPT ptr_to_setsockopt = NULL;
PTR_TO_IOCTLSOCKET ptr_to_ioctlsocket = NULL;
PTR_TO_GETHOSTBYNAME ptr_to_gethostbyname = NULL;

PTR_TO_WSAISFDSET ptr_to_wsaisfdset = NULL;

static FARPROC GetProc (char RCS_FAR * proc_name);

FARPROC
GetProc (char RCS_FAR * proc_name)
{
  FARPROC retval = NULL;
  static char buffer[128];
  char *ptr;
  if (socket_library_instance == NULL)
    {
      return NULL;
    }
  retval = GetProcAddress (socket_library_instance, proc_name);
  if (retval != NULL)
    {
      return retval;
    }
  strcpy (buffer, proc_name);
  ptr = buffer;
  while (*ptr)
    {
      *ptr = (char) toupper (*ptr);
    }
  retval = GetProcAddress (socket_library_instance, proc_name);
  if (retval != NULL)
    {
      return retval;
    }
  ptr = buffer;
  while (*ptr)
    {
      *ptr = (char) tolower (*ptr);
    }
  retval = GetProcAddress (socket_library_instance, buffer);
  if (retval != NULL)
    {
      return retval;

    }
  return NULL;
}

#endif /* USE_DYNAMICALLY_LOADED_POINTERS */

int RCS_EXPORT
load_socket_interface ()
{
#if !defined(_WINDOWS)
  socket_availability = SOCKETS_AVAILABLE;
  return 0;
#else
  short winsock_version;
  int wsa_startup_retval;
  WSADATA startup_data;

  if (SOCKETS_NOT_AVAILABLE == socket_availability)
    {
      return -1;
    }
  if (SOCKETS_AVAILABLE == socket_availability)
    {
      return 0;
    }
  socket_availability = SOCKETS_NOT_AVAILABLE;

#if defined(USE_DYNAMICALLY_LOADED_POINTERS)
#if defined(WIN32)
  socket_library_instance = LoadLibrary ("wsock32.dll");
  if (socket_library_instance == NULL)
    {
      rcs_print_error ("Error on LoadLibrary(" "wsock32.dll" ")\n");
      return -1;
    }
#else
  socket_library_instance = (void RCS_FAR *) LoadLibrary ("winsock.dll");
  if (((int) socket_library_instance) < HINSTANCE_ERROR)
    {
      rcs_print_error ("Error %d from LoadLibrary(" "winsock.dll" ")\n",
                       socket_library_instance);
      return -1;
    }
#endif
  ptr_to_wsastartup = (PTR_TO_WSASTARTUP) GetProc ("WSAStartup");
  if (NULL == ptr_to_wsastartup)
    {
      rcs_print_error ("Cannot find WSAStartup function.\n");
      return -1;
    }
  ptr_to_wsacleanup = (PTR_TO_WSACLEANUP) GetProc ("WSACleanup");
  if (NULL == ptr_to_wsacleanup)
    {
      rcs_print_error ("Cannot find WSACleanup function.\n");
      return -1;
    }
  ptr_to_wsagetlasterror = (PTR_TO_WSAGETLASTERROR)
    GetProc ("WSAGetLastError");
  if (NULL == ptr_to_wsagetlasterror)
    {
      rcs_print_error ("Cannot find WSAGetLastError function.\n");
      return -1;
    }
  ptr_to_wsaisfdset = (PTR_TO_WSAISFDSET) GetProc ("__WSAFDIsSet");
  if (NULL == ptr_to_wsaisfdset)
    {
      rcs_print_error ("Cannot find WSAGetLastError function.\n");
      return -1;
    }
  ptr_to_socket = (PTR_TO_SOCKET) GetProc ("socket");
  if (NULL == ptr_to_socket)
    {
      rcs_print_error ("Cannot find socket function.\n");
      return -1;
    }
  ptr_to_closesocket = (PTR_TO_CLOSESOCKET) GetProc ("closesocket");
  if (NULL == ptr_to_closesocket)
    {
      rcs_print_error ("Cannot find closesocket function.\n");
      return -1;
    }
  ptr_to_bind = (PTR_TO_BIND) GetProc ("bind");
  if (NULL == ptr_to_bind)
    {
      rcs_print_error ("Cannot find bind function.\n");
      return -1;
    }
  ptr_to_connect = (PTR_TO_CONNECT) GetProc ("connect");
  if (NULL == ptr_to_connect)
    {
      rcs_print_error ("Cannot find connect function.\n");
      return -1;
    }
  ptr_to_accept = (PTR_TO_ACCEPT) GetProc ("accept");
  if (NULL == ptr_to_accept)
    {
      rcs_print_error ("Cannot find accept function.\n");
      return -1;
    }
  ptr_to_listen = (PTR_TO_LISTEN) GetProc ("listen");
  if (NULL == ptr_to_listen)
    {
      rcs_print_error ("Cannot find listen function.\n");
      return -1;
    }
  ptr_to_select = (PTR_TO_SELECT) GetProc ("select");
  if (NULL == ptr_to_select)
    {
      rcs_print_error ("Cannot find select function.\n");
      return -1;
    }
  ptr_to_send = (PTR_TO_SEND) GetProc ("send");
  if (NULL == ptr_to_send)
    {
      rcs_print_error ("Cannot find send function.\n");
      return -1;
    }
  ptr_to_recv = (PTR_TO_RECV) GetProc ("recv");
  if (NULL == ptr_to_recv)
    {
      rcs_print_error ("Cannot find recv function.\n");
      return -1;
    }
  ptr_to_sendto = (PTR_TO_SENDTO) GetProc ("sendto");
  if (NULL == ptr_to_sendto)
    {
      rcs_print_error ("Cannot find sendto function.\n");
      return -1;
    }
  ptr_to_recvfrom = (PTR_TO_RECVFROM) GetProc ("recvfrom");
  if (NULL == ptr_to_recvfrom)
    {
      rcs_print_error ("Cannot find recvfrom function.\n");
      return -1;
    }
  ptr_to_inet_addr = (PTR_TO_INET_ADDR) GetProc ("inet_addr");
  if (NULL == ptr_to_inet_addr)
    {
      rcs_print_error ("Cannot find inet_addr function.\n");
      return -1;
    }
  ptr_to_inet_ntoa = (PTR_TO_INET_NTOA) GetProc ("inet_ntoa");
  if (NULL == ptr_to_inet_ntoa)
    {
      rcs_print_error ("Cannot find inet_ntoa function.\n");
      return -1;
    }

  ptr_to_htonl = (PTR_TO_HTONL) GetProc ("htonl");
  if (NULL == ptr_to_htonl)
    {
      rcs_print_error ("Cannot find htonl function.\n");
      return -1;
    }
  ptr_to_htons = (PTR_TO_HTONS) GetProc ("htons");
  if (NULL == ptr_to_htons)
    {
      rcs_print_error ("Cannot find htons function.\n");
      return -1;
    }
  ptr_to_ntohl = (PTR_TO_NTOHL) GetProc ("ntohl");
  if (NULL == ptr_to_ntohl)
    {
      rcs_print_error ("Cannot find ntohl function.\n");
      return -1;
    }
  ptr_to_ntohs = (PTR_TO_NTOHS) GetProc ("ntohs");
  if (NULL == ptr_to_ntohs)
    {
      rcs_print_error ("Cannot find ntohs function.\n");
      return -1;
    }
  ptr_to_setsockopt = (PTR_TO_SETSOCKOPT) GetProc ("setsockopt");
  if (NULL == ptr_to_setsockopt)
    {
      rcs_print_error ("Cannot find setsockopt function.\n");
      return -1;
    }
  ptr_to_ioctlsocket = (PTR_TO_IOCTLSOCKET) GetProc ("ioctlsocket");
  if (NULL == ptr_to_ioctlsocket)
    {
      rcs_print_error ("Cannot find ioctlsocket function.\n");
      return -1;
    }
  ptr_to_gethostbyname = (PTR_TO_GETHOSTBYNAME) GetProc ("gethostbyname");
  if (NULL == ptr_to_gethostbyname)
    {
      rcs_print_error ("Cannot find gethostbyname function.\n");
      return -1;
    }

  winsock_version = MAKEWORD (2, 0);
  wsa_startup_retval = (*ptr_to_wsastartup) (winsock_version, &startup_data);
  if (wsa_startup_retval)
    {
      rcs_print_error ("Error %d from WSAStartup.\n", wsa_startup_retval);
      return -1;
    }
  socket_availability = SOCKETS_AVAILABLE;
#else /* USE_DYNAMICALLY_LOADED_POINTERS */
#ifdef USE_WINSOCK
  winsock_version = MAKEWORD (2, 0);
  wsa_startup_retval = WSAStartup (winsock_version, &startup_data);
  if (wsa_startup_retval)
    {
      rcs_print_error ("Error %d from WSAStartup.\n", wsa_startup_retval);
      return -1;
    }
  socket_availability = SOCKETS_AVAILABLE;
  return 0;
#endif
#endif /* USE_DYNAMICALLY_LOADED_POINTERS */

#endif
}

void RCS_EXPORT
unload_socket_interface ()
{
#ifdef USE_DYNAMICALLY_LOADED_POINTERS
  if (SOCKETS_AVAILABLE == socket_availability
      && NULL != ptr_to_wsacleanup && socket_library_instance != NULL)
    {
      (*ptr_to_wsacleanup) ();
      FreeLibrary (socket_library_instance);
    }
  socket_library_instance = NULL;
  ptr_to_wsastartup = NULL;
  ptr_to_wsagetlasterror = NULL;
  ptr_to_wsacleanup = NULL;
#endif /* USE_DYNAMICALLY_LOADED_POINTERS */
  socket_availability = SOCKET_AVAIL_NOT_CHECKED;

}

#ifdef _WINDOWS
int
dl_WSAGetLastError ()
{
#ifndef USE_WINSOCK
  return errno;
#else
#ifdef USE_DYNAMICALLY_LOADED_POINTERS
  if (socket_availability != SOCKETS_AVAILABLE
      || NULL == ptr_to_wsagetlasterror)
    {
      rcs_print_error ("Can not call WSAGetLastError.\n");
      return 0;
    }
  return (*ptr_to_wsagetlasterror) ();
#else
  return WSAGetLastError ();
#endif
#endif
}
#endif

int
dl_fd_isset (SOCKET s, fd_set RCS_FAR * set)
{
#if !defined(_WINDOWS) || !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return ((int) FD_ISSET (s, set));
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_wsaisfdset)
    {
      rcs_print_error ("Can not call __WSAFDIsSet.\n");
      return 0;
    }
  return (*ptr_to_wsaisfdset) (s, set);
#endif
}


int
dl_accept (SOCKET s, struct sockaddr *name, int *plen)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return accept (s, name, plen);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_accept)
    {
      rcs_print_error ("Cannot call accept ().\n");
      return -1;
    }
  return (*ptr_to_accept) (s, name, plen);
#endif
}


int RCS_EXPORT
dl_bind (SOCKET s, struct sockaddr *name, int port)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return bind (s, name, port);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_bind)
    {
      rcs_print_error ("Cannot call bind ().\n");
      return -1;
    }
  return (*ptr_to_bind) (s, name, port);
#endif
}

int RCS_EXPORT
dl_closesocket (SOCKET s)
{
#ifndef USE_WINSOCK
  return close (s);
#else
#ifdef USE_DYNAMICALLY_LOADED_POINTERS
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_closesocket)
    {
      rcs_print_error ("Cannot call closesocket ().\n");
      return -1;
    }
  return (*ptr_to_closesocket) (s);
#else
  return closesocket (s);
#endif
#endif
}

int RCS_EXPORT
dl_ioctlsocket (SOCKET s, long cmd, unsigned long *argp)
{
#ifndef USE_WINSOCK
#ifndef VXWORKS
#if defined(MSDOS) && !defined(_Windows)
  return tk_ioctl (s, (int) cmd, (int *) argp);
#else
  return ioctl (s, (int) cmd, (caddr_t) argp);
#endif
#else
  return ioctl (s, (int) cmd, (int) argp);
#endif
#else
#ifdef USE_DYNAMICALLY_LOADED_POINTERS
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_ioctlsocket)
    {
      rcs_print_error ("Cannot call ioctlsocket ().\n");
      return -1;
    }
  return (*ptr_to_ioctlsocket) (s, cmd, argp);
#else
  return ioctlsocket (s, cmd, argp);
#endif
#endif
}

unsigned long RCS_EXPORT
dl_htonl (unsigned long hostlong)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return htonl (hostlong);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_htonl)
    {
      rcs_print_error ("Cannot call htonl ().\n");
      return hostlong;
    }
  return (*ptr_to_htonl) (hostlong);
#endif
}

unsigned long RCS_EXPORT
dl_ntohl (unsigned long netlong)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return ntohl (netlong);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_ntohl)
    {
      rcs_print_error ("Cannot call ntohl ().\n");
      return netlong;
    }
  return (*ptr_to_ntohl) (netlong);
#endif
}

unsigned short RCS_EXPORT
dl_htons (unsigned short hostshort)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return htons (hostshort);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_htons)
    {
      rcs_print_error ("Cannot call htons ().\n");
      return hostshort;
    }
  return (*ptr_to_htons) (hostshort);
#endif
}


unsigned short RCS_EXPORT
dl_ntohs (unsigned short netshort)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return ntohs (netshort);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_ntohs)
    {
      rcs_print_error ("Cannot call ntohs ().\n");
      return netshort;
    }
  return (*ptr_to_ntohs) (netshort);
#endif
}

unsigned long RCS_EXPORT
dl_inet_addr (char *addr_string)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return inet_addr (addr_string);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_inet_addr)
    {
      rcs_print_error ("Cannot call inet_addr ().\n");
      return 0;
    }
  return (*ptr_to_inet_addr) (addr_string);
#endif
}

char RCS_EXPORT *
dl_inet_ntoa (struct in_addr in)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return (char *) inet_ntoa (in);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_inet_ntoa)
    {
      rcs_print_error ("Cannot call inet_ntoa ().\n");
      return NULL;
    }
  return (*ptr_to_inet_ntoa) (in);
#endif
}

int RCS_EXPORT
dl_inet_netof (struct in_addr addr)
{
#ifdef WINDOWS
  return addr.S_un.S_addr & 0xffffff00;
#else
  return inet_netof (addr);
#endif
}

int RCS_EXPORT
dl_gethostname (char *hostname, int maxlen)
{
  return gethostname (hostname, maxlen);
}

struct in_addr
dl_inet_makeaddr (const int net, const int lna)
{
#ifdef WINDOWS
  struct in_addr tempAddress;
  tempAddress.S_un.S_addr = ((u_long) net) | ((u_long) lna);
  return tempAddress;
#else
  return (struct in_addr) inet_makeaddr (net, lna);
#endif
}

int RCS_EXPORT
dl_listen (SOCKET s, int backlog)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return listen (s, backlog);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_listen)
    {
      rcs_print_error ("Cannot call listen ().\n");
      return -1;
    }
  return (*ptr_to_listen) (s, backlog);
#endif
}

int RCS_EXPORT
dl_recv (SOCKET s, char *buf, int size, int flags)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return recv (s, buf, size, flags);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_recv)
    {
      rcs_print_error ("Cannot call recv ().\n");
      return -1;
    }
  return (*ptr_to_recv) (s, buf, size, flags);
#endif
}

int RCS_EXPORT
dl_send (SOCKET s, char *buf, int size, int flags)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return send (s, buf, size, flags);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_send)
    {
      rcs_print_error ("Cannot call recv ().\n");
      return -1;
    }
  return (*ptr_to_send) (s, buf, size, flags);
#endif
}

int RCS_EXPORT
dl_recvfrom (SOCKET s, char *buf, int size, int flags,
             struct sockaddr *from, int *namelen)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return recvfrom (s, buf, size, flags, from, namelen);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_recvfrom)
    {
      rcs_print_error ("Cannot call recvfrom ().\n");
      return -1;
    }
  return (*ptr_to_recvfrom) (s, buf, size, flags, from, namelen);
#endif
}

int RCS_EXPORT
dl_sendto (SOCKET s, char *buf, int size, int flags,
           struct sockaddr *to, int namelen)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return sendto (s, buf, size, flags, to, namelen);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_sendto)
    {
      rcs_print_error ("Cannot call sendto ().\n");
      return -1;
    }
  return (*ptr_to_sendto) (s, buf, size, flags, to, namelen);
#endif
}

int RCS_EXPORT
dl_select (int maxfd, fd_set * read_fds, fd_set * write_fds,
           fd_set * except_fds, struct timeval RCS_FAR * timeout)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
#ifdef MSDOS
  struct timeval far *temp = timeout;
  return select (maxfd, read_fds, write_fds, except_fds,
                 ((struct timeval far *) temp));
#else
  return select (maxfd, read_fds, write_fds, except_fds, timeout);
#endif
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_select)
    {
      rcs_print_error ("Cannot call select ().\n");
      return -1;
    }
  return (*ptr_to_select) (maxfd, read_fds, write_fds, except_fds, timeout);
#endif
}

SOCKET RCS_EXPORT
dl_socket (int domain, int type, int protocol)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return socket (domain, type, protocol);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_socket)
    {
      rcs_print_error ("Cannot call socket ().\n");
      return -1;
    }
  return (*ptr_to_socket) (domain, type, protocol);
#endif
}

int RCS_EXPORT
dl_connect (SOCKET s, struct sockaddr *name, int namelen)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return connect (s, name, namelen);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_connect)
    {
      rcs_print_error ("Cannot call connect ().\n");
      return -1;
    }
  return (*ptr_to_connect) (s, name, namelen);
#endif
}

#ifndef VXWORKS
int RCS_EXPORT
dl_gethostbyname (char *hostname, struct hostent **hpp)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
#ifdef VXWORKS
  rcs_print_error
    ("VxWorks programs must use hostGetByName() rather than dl_gethostbyname().");
  return NULL;
#else
  *hpp = (struct hostent *) gethostbyname (hostname);
  return 0;
#endif
#else
  if (socket_availability != SOCKETS_AVAILABLE
      || NULL == ptr_to_gethostbyname)
    {
      rcs_print_error ("Cannot call gethostbyname ().\n");
      return -1;
    }
  *hpp = (*ptr_to_gethostbyname) (hostname);
  return 0;
#endif
}
#endif

int RCS_EXPORT
dl_setsockopt (SOCKET s, int level, int opt, char RCS_FAR * optval, int len)
{
#if !defined(USE_DYNAMICALLY_LOADED_POINTERS)
  return setsockopt (s, level, opt, optval, len);
#else
  if (socket_availability != SOCKETS_AVAILABLE || NULL == ptr_to_setsockopt)
    {
      rcs_print_error ("Cannot call setsockopt().\n");
      return -1;
    }
  return (*ptr_to_setsockopt) (s, level, opt, optval, len);
#endif
}

---