---

sendmsgt.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 "dbg_mem.h"            // DEBUG_MALLOC, DEBUG_FREE


#include "sendmsgt.h"           /* Forward Prototype */

#ifndef UNDER_CE
#include <sys/types.h>          /* u_char etc needed by sys/socket.h */
                                /* fd_set, FD_ZERO, FD_SET */
#else
#include <windows.h>            /* WORD */
#endif

#if !defined(DOS_WINDOWS) || defined(gnuwin32)
#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>            /* sendmsg() */
#endif
#ifndef _Windows
#include <unistd.h>             /* select() */
#endif
#else
#if defined(MSDOS) && !defined(WINDOWS)
#include <tklib.h>
#include <sys/socket.h>         /* stuct msghdr, sendmsg() */
#include <sys/uio.h>            /* stuct iovec */
#else
#ifdef USE_OLD_WINSOCK
#include <winsock.h>            /* select(), typedef fd_set, FD_ZERO, FD_SET, struct */
#else
#include <winsock2.h>
#endif

#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>             /* DEBUG_MALLOC(), free() */
#include "rcs_prnt.hh"          /* rcs_print_error() */
#include "sokintrf.h"           /* dl_sendto(), dl_select(), dl_WSAGetLastError() */

static long total_bytes_sent = 0;

#define USE_SENDTO
#if defined(_Windows) && !defined(USE_PCNFS)
#ifndef USE_SENDTO
#define USE_SENDTO
#endif
#endif



#ifdef USE_SENDTO
static char RCS_FAR *collection_buffer = NULL;
static long collection_buffer_size = 0;
#endif

int sendmsgt_timed_out = 0;

int
sendmsgt (int _socket_fd, struct msghdr *_msg_header, int _flags,
          double _timeout)
{
  struct timeval timeout_timeval;
  fd_set write_fd_set;
  int bytes_sent, i;
  long required_size = 0;
  char *temp_pointer;
  sendmsgt_timed_out = 0;

#ifdef USE_SENDTO
  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 %ld.\n",
                           required_size);
          return (-1);
        }
      for (i = 0, temp_pointer = collection_buffer;
           i < _msg_header->msg_iovlen; i++)
        {
          memcpy (temp_pointer, _msg_header->msg_iov[i].iov_base,
                  _msg_header->msg_iov[i].iov_len);
          temp_pointer += _msg_header->msg_iov[i].iov_len;
        }
    }
#endif

  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 (&write_fd_set);
      RCS_FD_SET (_socket_fd, &write_fd_set);
      switch (dl_select
              (_socket_fd + 1, NULL, &write_fd_set, NULL, &timeout_timeval))
        {
        case -1:
#ifndef UNDER_CE
          rcs_print_error ("sendmsgt: select error: %d %s\n",
                           errno, strerror (errno));
#endif
          return -1;

        case 0:
          sendmsgt_timed_out = 1;
          rcs_print_error ("sendmgt: select timed out.\n");
          return (0);

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

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

        default:
          break;
        }
    }
#ifdef USE_SENDTO
  if (_msg_header->msg_iovlen > 1)
    {
      bytes_sent =
        dl_sendto (_socket_fd, collection_buffer, required_size, _flags,
                   (struct sockaddr *) _msg_header->msg_name,
                   _msg_header->msg_namelen);
    }
  else
    {
      bytes_sent = dl_sendto (_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 defined(_Windows) && !defined(gnuwin32)
  if (bytes_sent == SOCKET_ERROR)
    {
      rcs_print_error ("sendmsgt: send_to error %d\n", dl_WSAGetLastError ());
      return (-1);
    }
#else
  if (bytes_sent < 0)
    {
      rcs_print_error ("sendto(%d,%p,%d,0x%X,%s,%d) failed: %d -- %s \n",
                       _socket_fd, _msg_header->msg_iov[0].iov_base,
                       _msg_header->msg_iov[0].iov_len, _flags,
                       dl_inet_ntoa (
                                     ((struct sockaddr_in *)
                                      _msg_header->msg_name)->sin_addr),
                       _msg_header->msg_namelen,
#ifndef UNDER_CE
                       errno, strerror (errno));
#else
                       0, "?");
#endif
    }
#endif
#else
  bytes_sent = sendmsg (_socket_fd, _msg_header, _flags);
  if (bytes_sent < 0)
    {
      rcs_print_error ("sendmsg(%d,%p,%d) error: %d = %s\n",
                       _socket_fd, _msg_header, _flags,
#ifndef UNDER_CE
                       errno, strerror (errno));
#else
                       0, "?");
#endif
      rcs_print_error (" _msg_header->msg_iovlen = %d\n",
                       _msg_header->msg_iovlen);
      rcs_print_error ("_msg_header->msg_iov[0].iov_len = %d\n",
                       _msg_header->msg_iov[0].iov_len);
    }
#endif
  total_bytes_sent += bytes_sent;
  rcs_print_debug (PRINT_SOCKET_WRITE_SIZE, "sendmsg %d bytes to %d\n",
                   bytes_sent, _socket_fd);
  return (bytes_sent);
}


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

---