---

recvmsgt.c

Go to the documentation of this file.

/* This is neccessary to avoid muliple definitions of fd_set, etc when both
* RPC via PCNFS and Windows Sockets are to be available. */
#ifdef USE_PCNFS
#undef USE_PCNFS
#endif


#include "rcs_defs.hh"          /* MSDOS, _Windows */

#include "recvmsgt.h"           /* Forward Prototype */
#include "_timer.h"             /* etime(), etime_disabled */

#if  !defined(_Windows) || defined(USE_PCNFS) || defined(gnuwin32)
#ifdef MSDOS
#include <tklib.h>
#else
#include <sys/types.h>          /* u_char etc needed by sys/socket.h */
                                /* fd_set, FD_ZERO, FD_SET */
#include <sys/socket.h>         /* stuct msghdr, sendmsg() */
#ifndef VXWORKS
#include <sys/time.h>           /* struct timeval */
#else
#include <sys/times.h>          /* struct timeval */
#include <sockLib.h>            /* recvmsg() */
#endif
#ifndef _Windows
#include <unistd.h>             /* select() */
#endif
#endif
#else
#ifdef USE_OLD_WINSOCK
#ifdef UNDER_CE
#include <windows.h>
#endif
#include <winsock.h>            /* select(), typedef fd_set, FD_ZERO, FD_SET, struct */
#else
#include <winsock2.h>
#endif

#endif
#ifndef irix6
#include <math.h>               /* fmod() */
#else
/*
 Work around for the conflict between the gcc includes and /usr/includes
 on some of our SGI's regarding the definition of initstate()
 */
extern double fmod (double, double);
#endif

#ifndef UNDER_CE
#include <errno.h>              /* errno variable */
#endif
#include <string.h>             /* strerror() */
#include <stdlib.h>             /* malloc(), free() */
#include "rcs_prnt.hh"          /* rcs_print_error() */
#include "sokintrf.h"           /* dl_recvfrom(), dl_select() */
#include "dbg_mem.h"            /* DEBUG_FREE,DEBUG_MALLOC,DEBUG_CALLOC */

static long total_bytes_read = 0;

#if defined(_Windows)
static char RCS_FAR *collection_buffer = NULL;
static long collection_buffer_size = 0;
#endif

int recvmsgt_timed_out = 0;

int recvmsgt_implementation (int _socket_fd, struct msghdr *_msg_header,
                             int _flags, double _timeout,
                             int print_timeout_errors);

int
recvmsgt (int _socket_fd, struct msghdr *_msg_header, int _flags,
          double _timeout)
{
  return (recvmsgt_implementation
          (_socket_fd, _msg_header, _flags, _timeout, 1));
}

int
recvmsgtq (int _socket_fd, struct msghdr *_msg_header, int _flags,
           double _timeout)
{
  return (recvmsgt_implementation
          (_socket_fd, _msg_header, _flags, _timeout, 0));
}

int
recvmsgt_implementation (int _socket_fd, struct msghdr *_msg_header,
                         int _flags, double _timeout,
                         int print_timeout_errors)
{
  struct timeval timeout_timeval;
  fd_set read_fd_set;
  int bytes_read;
  int recvmsgt_timed_out = 0;
#if defined(_Windows)
  long required_size, bytes_copied, bytes_to_copy;
  int i = 0;
  char *temp_pointer;
  if (_msg_header->msg_iovlen > 1)
    {
      for (i = 0, required_size = 0; i < _msg_header->msg_iovlen; i++)
        {
          required_size += _msg_header->msg_iov[i].iov_len;
        }
      if (required_size > collection_buffer_size)
        {
          if (NULL != collection_buffer)
            {
              DEBUG_FREE (collection_buffer);
              collection_buffer = NULL;
            }
          collection_buffer = (char *) DEBUG_MALLOC (required_size);
          collection_buffer_size = required_size;
        }
      if (NULL == collection_buffer)
        {
          collection_buffer_size = 0;
          rcs_print_error ("Couldn't malloc collection buffer of size.\n");
          return (-1);
        }
    }
#endif
  if (etime_disabled)
    {
      _timeout = -1.0;
    }

  if (_timeout > 1E-6)
    {
      timeout_timeval.tv_sec = (long) _timeout;
      timeout_timeval.tv_usec = (long) (_timeout * 1000000.0);
      if (timeout_timeval.tv_usec >= 1000000)
        {
          timeout_timeval.tv_usec = timeout_timeval.tv_usec % 1000000;
        }
      FD_ZERO (&read_fd_set);
      RCS_FD_SET (_socket_fd, &read_fd_set);
      switch (dl_select
              (_socket_fd + 1, &read_fd_set, NULL, NULL, &timeout_timeval))
        {
        case -1:
#ifndef UNDER_CE
          rcs_print_error ("recvmsgt: select error: %d %s\n",
                           errno, strerror (errno));
#endif
          return -1;

        case 0:
          recvmsgt_timed_out = 1;
          if (print_timeout_errors)
            {
              rcs_print_error
                ("recvmgt: select timed out after %f seconds.\n", _timeout);
            }
          return (0);

        default:
          break;
        }
    }
  else if (_timeout > -1E-6)
    {
      timeout_timeval.tv_sec = (long) 0;
      timeout_timeval.tv_usec = (long) 0;
      FD_ZERO (&read_fd_set);
      RCS_FD_SET (_socket_fd, &read_fd_set);
      switch (dl_select
              (_socket_fd + 1, &read_fd_set, NULL, NULL, &timeout_timeval))
        {
        case -1:
#ifndef UNDER_CE
          rcs_print_error ("recvmsgt: select error: %d %s\n",
                           errno, strerror (errno));
#endif
          return -1;

        case 0:
          recvmsgt_timed_out = 1;
          return (0);

        default:
          break;
        }
    }
#if defined(_Windows)
  if (_msg_header->msg_iovlen > 1)
    {
      bytes_read =
        dl_recvfrom (_socket_fd, collection_buffer, required_size, _flags,
                     (struct sockaddr *) _msg_header->msg_name,
                     &_msg_header->msg_namelen);
      if (bytes_read == -1)
        {
#ifdef gnuwin32
          rcs_print_error ("recvmsgt: recvfrom error %d:%s\n", errno,
                           strerror (errno));
#else
          rcs_print_error ("recvmsgt: recvfrom error %d\n",
                           dl_WSAGetLastError ());
#endif
          return (-1);
        }
      for (i = 0, temp_pointer = collection_buffer, bytes_copied = 0;
           i < _msg_header->msg_iovlen && bytes_copied < bytes_read; i++)
        {
          bytes_to_copy =
            (bytes_read - bytes_copied) <
            _msg_header->msg_iov[i].iov_len ? bytes_read -
            bytes_copied : _msg_header->msg_iov[i].iov_len;
          memcpy (_msg_header->msg_iov[i].iov_base, temp_pointer,
                  bytes_to_copy);
          temp_pointer += bytes_to_copy;
          bytes_copied += bytes_to_copy;
        }
    }
  else
    {
      bytes_read = dl_recvfrom (_socket_fd, _msg_header->msg_iov[0].iov_base,
                                _msg_header->msg_iov[0].iov_len, _flags,
                                (struct sockaddr *) _msg_header->msg_name,
                                &_msg_header->msg_namelen);
      if (bytes_read == -1)
        {
#ifdef gnuwin32
          rcs_print_error ("recvmsgt: recvfrom error %d:%s\n", errno,
                           strerror (errno));
#else
          rcs_print_error ("recvmsgt: recvfrom error %d\n",
                           dl_WSAGetLastError ());
#endif
          return (-1);
        }
    }
#else
  bytes_read = recvmsg (_socket_fd, _msg_header, _flags);
  if (bytes_read < 0)
    {
#ifndef UNDER_CE
      rcs_print_error ("recvmsg(%d (0x%X), %p, %d (0x%X) error: %d = %s\n",
                       _socket_fd, _socket_fd, _msg_header, _flags, _flags,
                       errno, strerror (errno));
#endif
    }
#endif
  total_bytes_read += bytes_read;
  rcs_print_debug (PRINT_SOCKET_READ_SIZE, "recvmsg %d bytes from %d\n",
                   bytes_read, _socket_fd);
  return (bytes_read);
}

void
free_recvmsg_collection_buffer ()
{
#if  defined(_Windows)
  if (NULL != collection_buffer)
    {
      DEBUG_FREE (collection_buffer);
      collection_buffer = NULL;
      collection_buffer_size = 0;
    }
#endif
}

---