---

stcpmem.cc

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"          /* EXTERN_C_STD_HEADERS */

#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif
#include <stdio.h>              // sprintf()
#include <ctype.h>              // isdigit()

#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

#include <string.h>             /* strerror() */
#include <stdlib.h>             // malloc()
#ifdef CenterLine
  char *strerror (int errnum);
#endif
#include <errno.h>              /* errno  */

#ifdef EXTERN_C_STD_HEADERS
}
#endif

#include "rem_msg.hh"           /* REMOTE_CMS_READ_REQUEST_TYPE, etc. */
#include "rcs_prnt.hh"          /* rcs_print_error() */


#define REQUEST_TIMEOUT (2.0)
#include "timer.hh"             /* esleep() */

#include "stcpmem.hh"

#include "recvline.h"           /* recvline() */
#include "sendline.h"           /* sendline() */
#include "stcpopts.hh"          /* SET_TCP_NODELAY */
#include "sokintrf.h"           /* dl_closesocket(), dl_gethostbyname(), dl_socket() */
#include "crypt2.hh"            // crypt()
                                                                        /* dl_connect(), load_socket_interface(), unload_socket_interface() */


STCPMEM::STCPMEM (char *_bufline, char *_procline):
CMS (_bufline, _procline)
{
#if defined(_Windows) && !defined(USE_PCNFS)
  WSA_count++;
#endif
  if (load_socket_interface () < 0)
    {
      rcs_print_error ("Can't load socket interface.\n");
      status = CMS_LIBRARY_UNAVAILABLE_ERROR;
    }
  socket_fd = 0;
  read_request_issued = 0;
  temp_buffer = NULL;
  polling = 0;
  lines_to_skip = 0;
  bytes_at_beginning_of_line = 0;



  if (CMS_DISPLAY_ASCII_ENCODING != neutral_encoding_method)
    {
      rcs_print_error
        ("The neutral_encoding_method must be ASCII_DISPLAY_ENCODING to use STCPMEM.\n");
      status = CMS_CONFIG_ERROR;
    }


  temp_buffer = (char *) malloc (cms_encoded_data_explosion_factor * size);
  if (temp_buffer == NULL)
    {
      rcs_print_error ("Out of memory!\n");
      status = CMS_CREATE_ERROR;
      return;
    }
  temp_buffer_size = cms_encoded_data_explosion_factor * size;

#ifndef VXWORKS
  server_host_entry = NULL;
#endif
  serial_number = 0;

  /* Set up the socket address stucture. */
  memset (&server_socket_address, 0, sizeof (server_socket_address));
  server_socket_address.sin_family = AF_INET;
  server_socket_address.sin_port = dl_htons (((u_short) stcp_port_number));

  int hostname_was_address = 0;
  if (isdigit (BufferHost[0]))
    {
      server_socket_address.sin_addr.s_addr = dl_inet_addr (BufferHost);
      if (server_socket_address.sin_addr.s_addr != 0 &&
          ((long) server_socket_address.sin_addr.s_addr) != -1)
        {
          hostname_was_address = 1;
        }
    }
  if (!hostname_was_address)
    {
      /* Get the IP address of the server using it's BufferHost. */
#ifndef VXWORKS
      dl_gethostbyname (BufferHost, &server_host_entry);
      if (NULL == server_host_entry)
        {
          status = CMS_CONFIG_ERROR;
          rcs_print_error ("STCPMEM: Couldn't get host address for (%s).\n",
                           BufferHost);
#if defined(_WINDOWS) && !defined(gnuwin32)
          rcs_print_error ("WSA error = %d\n", dl_WSAGetLastError ());
#endif
          return;
        }
#ifdef __MSDOS__
      server_socket_address.sin_addr.s_addr =
        *((u_long *) server_host_entry->h_addr_list[0]);
#else
      server_socket_address.sin_addr.s_addr =
        *((int *) server_host_entry->h_addr_list[0]);
#endif
      server_socket_address.sin_family = server_host_entry->h_addrtype;
#else
      server_socket_address.sin_addr.s_addr = hostGetByName (BufferHost);
      if (server_socket_address.sin_addr.s_addr == ERROR)
        {
          rcs_print_error ("STCPMEM: Couldn't get host address for (%s).\n",
                           BufferHost);
          status = CMS_CONFIG_ERROR;
          return;
        }
#endif
    }
  rcs_print_debug (PRINT_CMS_CONFIG_INFO,
                   "Using server on %s with IP address %s and port %d.\n",
                   BufferHost,
                   dl_inet_ntoa (server_socket_address.sin_addr),
                   stcp_port_number);

  rcs_print_debug (PRINT_CMS_CONFIG_INFO, "Creating socket . . .\n");

  socket_fd = dl_socket (AF_INET, SOCK_STREAM, 0);
  if (socket_fd < 0)
    {
      rcs_print_error ("STCPMEM: Error from socket() (errno = %d:%s)\n",
                       errno, strerror (errno));
      status = CMS_CREATE_ERROR;
      return;
    }
  rcs_print_debug (PRINT_CMS_CONFIG_INFO, "Setting socket options . . . \n");
  if (set_stcp_socket_options (socket_fd) < 0)
    {
      return;
    }
  sockaddr_in cli_addr;
  cli_addr.sin_family = AF_INET;
  cli_addr.sin_addr.s_addr = dl_htonl (INADDR_ANY);
  cli_addr.sin_port = dl_htons (0);
  rcs_print_debug (PRINT_CMS_CONFIG_INFO, "Binding . . . \n");
  if (dl_bind (socket_fd, (struct sockaddr *) &cli_addr, sizeof (cli_addr)) <
      0)
    {
#if defined(_Windows) && !defined(USE_PCNFS) && !defined(gnuwin32)
      rcs_print_error ("STCPMEM: bind error %d\n", dl_WSAGetLastError ());
#else
      rcs_print_error ("STCPMEM: bind error %d = %s\n", errno,
                       strerror (errno));
#endif
      status = CMS_CREATE_ERROR;
    }
  rcs_print_debug (PRINT_CMS_CONFIG_INFO, "Connecting . . .\n");
  if (dl_connect (socket_fd, (struct sockaddr *) &server_socket_address,
                  sizeof (server_socket_address)) < 0)
    {
#if  defined(_Windows) && !defined(gnuwin32)
      if (WSAEWOULDBLOCK == dl_WSAGetLastError ())
        {
#else
      if (EINPROGRESS == errno)
        {
#endif
          struct timeval tm;
          int socket_ret;
          double start_time, current_time;
#ifdef _Windows
          tm.tv_sec = 0;
          tm.tv_usec = 0;
#else
          // Timeout after 30 seconds on connect even if we
          // have no timeouts on other operations.
          if (timeout < 0)
            {
              tm.tv_sec = 30;
              tm.tv_usec = 0;
            }
          else
            {
              tm.tv_sec = (long) timeout;
              tm.tv_usec = (long) (timeout * 1000000.0);
              if (tm.tv_usec >= 1000000)
                {
                  tm.tv_usec = tm.tv_usec % 1000000;
                }
            }
#endif
          fd_set fds;
          FD_ZERO (&fds);
          RCS_FD_SET (socket_fd, &fds);
          start_time = etime ();
          while (!
                 (socket_ret =
                  dl_select (socket_fd + 1, NULL, &fds, NULL, &tm)))
            {
              RCS_FD_SET (socket_fd, &fds);
              esleep (0.001);
              current_time = etime ();
              if (current_time - start_time > timeout && timeout >= 0.0)
                {
                  rcs_print_error
                    ("STCPMEM: Timed out waiting for connection.\n");
                  status = CMS_NO_SERVER_ERROR;
                  return;
                }
            }
#if  defined(_Windows) && !defined(gnuwin32)
          if (socket_ret == SOCKET_ERROR)
            {
              rcs_print_error ("select error: %d\n", dl_WSAGetLastError ());
#else
          if (socket_ret == -1)
            {
              rcs_print_error ("select error: %d -- %s\n", errno,
                               strerror (errno));
#endif
              rcs_print_error ("STCPMEM: Couldn't connect.\n");
              status = CMS_NO_SERVER_ERROR;
              return;
            }
        }
      else
        {
#if defined(_WINDOWS) && !defined(gnuwin32)
          rcs_print_error ("connect error: %d\n", dl_WSAGetLastError ());
#else
          rcs_print_error ("connect error: %d -- %s\n", errno,
                           strerror (errno));
#endif
          rcs_print_error
            ("STCPMEM: Error trying to connect to STCP port %d of host %s.\n",
             dl_ntohs (server_socket_address.sin_port), BufferHost);
        }
    }

  polling = (NULL != strstr (ProcessLine, "poll"));
  if (polling)
    {
      timeout = 0;
    }
}


STCPMEM::~STCPMEM ()
{
  if (socket_fd > 0)
    {
      clean_prev_read_info (socket_fd);
      dl_closesocket (socket_fd);
      socket_fd = 0;
    }
#if defined(_Windows) && !defined(USE_PCNFS)
  if (WSA_count == 0)
    {
      unload_socket_interface ();
    }
  WSA_count--;
#endif
  if (NULL == temp_buffer)
    {
      delete temp_buffer;
      temp_buffer = NULL;
    }
}

CMS_STATUS
STCPMEM::skip_lines ()
{

  while (lines_to_skip > 0)
    {
      if (recvline
          (socket_fd, ((char *) encoded_data),
           cms_encoded_data_explosion_factor * size, 0, timeout, NULL) < 0)
        {
          if (recvline_timedout)
            {
              return (status = CMS_TIMED_OUT);
            }
          else
            {
              bytes_at_beginning_of_line = 0;
              return (status = CMS_MISC_ERROR);
            }
        }
      bytes_at_beginning_of_line = 0;
      lines_to_skip--;
    }
  bytes_at_beginning_of_line = 0;
  return (status);
}


CMS_STATUS
STCPMEM::read ()
{
  long message_size, id;
  id = in_buffer_id;
  int read_request_issued_last_time;
  char request_string[32];
  sprintf (request_string, "read(%d):", (int) buffer_number);

  if (socket_fd <= 0)
    {
      rcs_print_error ("STCPMEM::read: Invalid socket descriptor. (%d)\n",
                       socket_fd);
      return (status = CMS_MISC_ERROR);
    }
  if (((int) skip_lines ()) < 0)
    {
      return status;
    }

  read_request_issued_last_time = read_request_issued;

  if (!read_request_issued_last_time || !polling)
    {
      if (sendline (socket_fd, request_string, 0, timeout) < 0)
        {
          return (status = CMS_MISC_ERROR);
        }
      read_request_issued = 1;
      read_request_time = etime ();
    }

  if (read_request_issued_last_time || !polling)
    {
      read_request_issued = 0;
      if (
          (message_size =
           recvline (socket_fd,
                     ((char *) encoded_data) + bytes_at_beginning_of_line,
                     cms_encoded_data_explosion_factor * size, 0, timeout,
                     &bytes_at_beginning_of_line)) < 0)
        {
          if (recvline_timedout)
            {
              if (polling)
                {
                  read_request_issued = 1;
                  return (status = CMS_READ_OLD);
                }
              else
                {
                  lines_to_skip++;
                  bytes_at_beginning_of_line = 0;
                  return (status = CMS_TIMED_OUT);
                }
            }
          else
            {
              bytes_at_beginning_of_line = 0;
              return (status = CMS_MISC_ERROR);
            }
        }
      bytes_at_beginning_of_line = 0;
      if (!strncmp ((char *) encoded_data, "ERR", 3))
        {
          long errcode;
          errcode = strtol (((char *) encoded_data) + 4, NULL, 0);
          if (errcode == 0)
            {
              return (status = CMS_READ_OLD);
            }
          else
            {
              return (status = CMS_MISC_ERROR);
            }
        }
      id++;
    }
  header.was_read = 1;
  check_id (id);
  return (status);
}


CMS_STATUS
STCPMEM::peek ()
{
  long message_size, id;
  id = in_buffer_id;
  int read_request_issued_last_time;
  char request_string[32];
  sprintf (request_string, "peek(%d):", (int) buffer_number);

  if (socket_fd <= 0)
    {
      rcs_print_error ("STCPMEM::peek: Invalid socket descriptor. (%d)\n",
                       socket_fd);
      return (status = CMS_MISC_ERROR);
    }
  if (((int) skip_lines ()) < 0)
    {
      return status;
    }
  read_request_issued_last_time = read_request_issued;

  if (!read_request_issued_last_time || !polling)
    {
      if (sendline (socket_fd, request_string, 0, timeout) < 0)
        {
          return (status = CMS_MISC_ERROR);
        }
      read_request_issued = 1;
      read_request_time = etime ();
    }

  if (read_request_issued_last_time || !polling)
    {
      read_request_issued = 0;
      if (
          (message_size =
           recvline (socket_fd,
                     ((char *) encoded_data) + bytes_at_beginning_of_line,
                     cms_encoded_data_explosion_factor * size, 0, timeout,
                     &bytes_at_beginning_of_line)) < 0)
        {
          if (recvline_timedout)
            {
              if (polling)
                {
                  read_request_issued = 1;
                  return (status = CMS_READ_OLD);
                }
              else
                {
                  lines_to_skip++;
                  bytes_at_beginning_of_line = 0;
                  return (status = CMS_TIMED_OUT);
                }
            }
          else
            {
              bytes_at_beginning_of_line = 0;
              return (status = CMS_MISC_ERROR);
            }
        }
      bytes_at_beginning_of_line = 0;
      if (!strncmp ((char *) encoded_data, "ERR", 3))
        {
          long errcode;
          errcode = strtol (((char *) encoded_data) + 4, NULL, 0);
          if (errcode == 0)
            {
              return (status = CMS_READ_OLD);
            }
          else
            {
              return (status = CMS_MISC_ERROR);
            }
        }
      id++;
    }
  header.was_read = 1;
  check_id (id);
  return (status);
}




CMS_STATUS
STCPMEM::write (void *user_data)
{
  read_request_issued = 0;
  char request_string[32];
  sprintf (request_string, "write(%d): ", (int) buffer_number);

  if (socket_fd <= 0)
    {
      rcs_print_error ("STCPMEM::write: Invalid socket descriptor. (%d)\n",
                       socket_fd);
      return (status = CMS_MISC_ERROR);
    }
  memset (temp_buffer, 0, temp_buffer_size);
  strcpy (temp_buffer, request_string);
  strcat (temp_buffer, (char *) encoded_data);
  if (sendline (socket_fd, temp_buffer, 0, timeout) < 0)
    {
      return (status = CMS_MISC_ERROR);
    }
  status = CMS_WRITE_OK;
  return (status);
}

CMS_STATUS
STCPMEM::write_if_read (void *user_data)
{
  read_request_issued = 0;
  char request_string[32];
  sprintf (request_string, "write_if_read(%d): ", (int) buffer_number);
  static int poll_error_message_sent = 0;
  if (socket_fd <= 0)
    {
      rcs_print_error ("STCPMEM::write: Invalid socket descriptor. (%d)\n",
                       socket_fd);
      return (status = CMS_MISC_ERROR);
    }
  if (polling)
    {
      if (poll_error_message_sent < 100)
        {
          rcs_print_error
            ("STCPMEM: Can not write_if_read when polling is enabled.\n");
        }
      poll_error_message_sent++;
      return (status = CMS_MISC_ERROR);
    }

  memset (temp_buffer, 0, temp_buffer_size);
  strcpy (temp_buffer, request_string);
  strcat (temp_buffer, (char *) encoded_data);
  if (sendline (socket_fd, temp_buffer, 0, timeout) < 0)
    {
      return (status = CMS_MISC_ERROR);
    }
  if (recvline (socket_fd, temp_buffer, temp_buffer_size, 0, timeout, NULL) <
      0)
    {
      rcs_print_error ("write_if_read: timed out.\n");
      return (status = CMS_TIMED_OUT);
    }
  if (!strncmp (temp_buffer, "write_if_read_succeeded", 22))
    {
      return (status = CMS_WRITE_OK);
    }
  rcs_print_error ("write_if_read_failed %s", temp_buffer);
  return (status = CMS_MISC_ERROR);
}

int
STCPMEM::check_if_read ()
{
  read_request_issued = 0;
  char request_string[32];
  sprintf (request_string, "check_if_read(%d): ", (int) buffer_number);

  if (socket_fd <= 0)
    {
      rcs_print_error ("STCPMEM::write: Invalid socket descriptor. (%d)\n",
                       socket_fd);
      return (status = CMS_MISC_ERROR);
    }
  if (recvline (socket_fd, temp_buffer, temp_buffer_size, 0, timeout, NULL) <
      0)
    {
      status = CMS_TIMED_OUT;
      return 0;
    }
  if (!strncmp (temp_buffer, "was_read", 8))
    {
      return (1);
    }
  return (0);
}


CMS_STATUS
STCPMEM::clear ()
{
  // FIXME: unimplemented function.
  return (status);
}

int
STCPMEM::login (const char *name, const char *passwd)
{

  status = CMS_STATUS_NOT_SET;
  double start_time = etime ();
  while (read_request_issued
         && (status == CMS_STATUS_NOT_SET || status == CMS_TIMED_OUT
             || status == CMS_READ_OLD) && start_time - etime () < 60.0)
    {
      peek ();
    }
  read_request_issued = 0;
  char request_string[32];
  sprintf (request_string, "get_keys(%d):%s", (int) buffer_number, name);

  if (sendline (socket_fd, request_string, 0, 30.0) < 0)
    {
      return (status = CMS_MISC_ERROR);
    }
  if (recvline (socket_fd, temp_buffer, temp_buffer_size, 0, 30.0, NULL) < 0)
    {
      rcs_print_error ("login: timed out.\n");
      return (0);
    }
  if (strncmp (temp_buffer, "keys:", 5))
    {
      rcs_print_error
        ("Bad reply from server on request for login keys: %s\n",
         temp_buffer);
      return 0;
    }
  char key1[8];
  memset (key1, 0, 8);
  int i = 0;
  for (i = 0; i < 8 && temp_buffer[i + 5] != ':'; i++)
    {
      key1[i] = temp_buffer[i + 5];
    }
  int key2_offset = i + 6;
  char key2[8];
  memset (key2, 0, 8);
  for (i = 0; i < 8 && temp_buffer[i + key2_offset] != ':'; i++)
    {
      key2[i] = temp_buffer[i + key2_offset];
    }
  char passwd_pass1[16];
  char *crypt1_ret;
  crypt1_ret = rcs_crypt (passwd, key1);
  if (NULL == crypt1_ret)
    {
      rcs_print_error ("STCPMEM:login -- crypt failed.\n");
      return 0;
    }
  strncpy (passwd_pass1, crypt1_ret, 16);
  char passwd_pass2[16];
  char *crypt2_ret;
  crypt2_ret = rcs_crypt (passwd_pass1, key2);
  if (NULL == crypt2_ret)
    {
      rcs_print_error ("STCPMEM:login -- crypt failed.\n");
      return 0;
    }
  strncpy (passwd_pass2, crypt2_ret, 16);
  sprintf (request_string, "login(%d):%s:%s", (int) buffer_number, name,
           passwd_pass2);
  if (sendline (socket_fd, request_string, 0, 30.0) < 0)
    {
      return (status = CMS_MISC_ERROR);
    }
  if (recvline (socket_fd, temp_buffer, temp_buffer_size, 0, 30.0, NULL) < 0)
    {
      rcs_print_error ("login: timed out.\n");
      return (0);
    }
  if (strncmp (temp_buffer, "login", 5))
    {
      rcs_print_error ("Bad reply from server on request for login: %s\n",
                       temp_buffer);
      return 0;
    }
  return !strcmp (temp_buffer, "login succeeded");
}

---