---

cms.hh

Go to the documentation of this file.

/*************************************************************************
* File: cms.hh                                                           *
* Authors: Fred Proctor, Will Shackleford                                *
* Purpose: C++ Header file for the Communication Management System (CMS).*
*          Includes:                                                     *
*                    1. class CMS.                                       *
*                    2. class CMS_UPDATER                                *
*                    2. enum CMS_STATUS.                                 *
*                    3. enum CMSMODE.                                    *
*                    4. enum CMSBUFFERTYPE.                              *
*                    5. enum CMSPROCESSTYPE.                             *
*************************************************************************/

#ifndef CMS_HH
#define CMS_HH

#include "rcs_defs.hh"          /* RCS_EXPORT, EXTERN_C_STD_HEADERS */

/* Include Files */
#ifdef EXTERN_C_STD_HEADERS
extern "C"
{
#endif

#ifndef UNDER_CE
#include <stddef.h>             /* size_t */
#endif


#ifdef EXTERN_C_STD_HEADERS
}
#endif

#include "cms_cfg.hh"           /* CMS_CONFIG_LINELEN */
#include "linklist.hh"          // RCS_LINKED_LIST
#include "physmem.hh"           /* PHYSMEM_HANDLE */
#include "posemath.h"           // PM_CARTESIAN, etc ...

/* Enumerated Data Types */

/* Return values for CMS::read, CMS::write, ... */
enum CMS_STATUS
{
/* ERROR conditions */
  CMS_MISC_ERROR = -1,          /* A miscellaneous  error occured. */
  CMS_UPDATE_ERROR = -2,        /* An error occured during an update. */
  CMS_INTERNAL_ACCESS_ERROR = -3,       /* An error occured during an internal access function. */
  CMS_NO_MASTER_ERROR = -4,     /* An error occured becouse */
  /* the master was not started */
  CMS_CONFIG_ERROR = -5,        /* There was an error in the configuration */
  CMS_TIMED_OUT = -6,           /* operation timed out. */
  CMS_QUEUE_FULL = -7,          /* A write failed because queuing was */
  /* enabled but there was no room to add to */
  /* the queue. */
  CMS_CREATE_ERROR = -8,        /* Something could not be created.  */
  CMS_PERMISSIONS_ERROR = -9,   // Problem with permissions
  CMS_NO_SERVER_ERROR = -10,    // The server has not been started or could not be contacted.
  CMS_RESOURCE_CONFLICT_ERROR = -11,    // Two or more CMS buffers are trying to use the same resource.
  CMS_NO_IMPLEMENTATION_ERROR = -12,    // An operation was attempted which has not yet been implemented for the current platform or protocol.
  CMS_INSUFFICIENT_SPACE_ERROR = -13,   // The size of the buffer was insufficient for the requested operation.
  CMS_LIBRARY_UNAVAILABLE_ERROR = -14,  // A DLL or Shared Object library needed for the current protocol could not be found or initialized.
  CMS_SERVER_SIDE_ERROR = -15,  // The server reported an error.
  CMS_NO_BLOCKING_SEM_ERROR = -16,      // A blocking_read operartion was tried but no semaphore for the blocking was configured or available.

/* NON Error Conditions.*/
  CMS_STATUS_NOT_SET = 0,       /* The status variable has not been set yet. */
  CMS_READ_OLD = 1,             /* Read successful, but data is old. */
  CMS_READ_OK = 2,              /* Read successful so far. */
  CMS_WRITE_OK = 3,             /* Write successful so far. */
  CMS_WRITE_WAS_BLOCKED = 4,    /* Write if read did not succeed, because */
  /* the buffer had not been read yet. */
  CMS_CLEAR_OK = 5,             /* A clear operation was successful.  */
  CMS_CLOSED = 6                /* The channel has been closed.  */
};

/* Mode used within update functions. */
enum CMSMODE
{
  CMS_NOT_A_MODE = 0,
  CMS_ENCODE,
  CMS_DECODE,
  CMS_RAW_OUT,
  CMS_RAW_IN,
  CMS_READ,
  CMS_WRITE
};

typedef long int CMSID;

/* Mode stored for use by the internal access function. */
enum CMS_INTERNAL_ACCESS_TYPE
{
  CMS_ZERO_ACCESS = 0,
  CMS_READ_ACCESS,
  CMS_CHECK_IF_READ_ACCESS,
  CMS_PEEK_ACCESS,
  CMS_WRITE_ACCESS,
  CMS_WRITE_IF_READ_ACCESS,
  CMS_CLEAR_ACCESS,
  CMS_GET_MSG_COUNT_ACCESS,
  CMS_GET_DIAG_INFO_ACCESS
};

/* What type of global memory buffer. */
enum CMS_BUFFERTYPE
{
  CMS_SHMEM_TYPE,
  CMS_GLOBMEM_TYPE,
  CMS_PHANTOM_BUFFER,
  CMS_LOCMEM_TYPE,
  CMS_FILEMEM_TYPE,
  CMS_BBDMEM_TYPE,
  CMS_RTLMEM_TYPE
};

/* How will this process access the buffer. */
enum CMS_PROCESSTYPE
{
  CMS_REMOTE_TYPE,
  CMS_LOCAL_TYPE,
  CMS_PHANTOM_USER,
  CMS_AUTO_TYPE
};

enum CMS_REMOTE_PORT_TYPE
{
  CMS_NO_REMOTE_PORT_TYPE = 0,
  CMS_RPC_REMOTE_PORT_TYPE,
  CMS_TTY_REMOTE_PORT_TYPE,
  CMS_TCP_REMOTE_PORT_TYPE,
  CMS_STCP_REMOTE_PORT_TYPE,
  CMS_UDP_REMOTE_PORT_TYPE
};

/* This structure will be placed at the beginning of every */
 /* CMS buffer. */
struct RCS_EXPORT CMS_HEADER
{
  long was_read;                /* Has the buffer been read since */
  /* the last write? */
  long write_id;                /* Id of last write. */
  long in_buffer_size;          /* How much of the buffer is currently used. */
};

class RCS_EXPORT CMS_DIAG_PROC_INFO;
class RCS_EXPORT CMS_DIAG_HEADER;
class RCS_EXPORT CMS_DIAGNOSTICS_INFO;

struct RCS_EXPORT CMS_QUEUING_HEADER
{
  long head;
  long tail;
  long queue_length;
  long end_queue_space;
  long write_id;
};

enum CMS_NEUTRAL_ENCODING_METHOD
{
  CMS_NO_ENCODING,
  CMS_XDR_ENCODING,
  CMS_ASCII_ENCODING,
  CMS_DISPLAY_ASCII_ENCODING
};

/* CMS class declaration. */
class RCS_EXPORT CMS;
class RCS_EXPORT CMS_UPDATER;

/* CMS class definition. */
class RCS_EXPORT CMS
{
public:
  void *operator new (size_t);
  void operator delete (void *);

public:
  /* Constructors and Destructors. */
    CMS (long size);
    CMS (char *bufline, char *procline, int set_to_server = 0);
    virtual ~ CMS ();

  /* Simple read/write interface functions. */
  virtual CMS_STATUS clear ();  /* Has the buffer been read recently? */
  virtual int check_if_read (); /* Has the buffer been read recently? */
  virtual int get_msg_count (); /* Has the buffer been read recently? */
  virtual int check_if_transfers_complete ();   /* Has DMA completed */
  virtual CMS_STATUS read ();   /* Read from  buffer. */
  virtual CMS_STATUS blocking_read (double _timeout);   /* Read from  buffer, wait for new data. */
  virtual CMS_STATUS peek ();   /* Read without setting flag. */
  virtual CMS_STATUS write (void *user_data);   /* Write to buffer. */
  virtual CMS_STATUS write_if_read (void *user_data);   /* Write to buffer. */
  virtual int login (const char *name, const char *passwd);
  virtual void reconnect ();
  virtual void disconnect ();

  /* Protocol Defined Virtual Function Stubs. */
  virtual CMS_STATUS main_access (void *_local);

  /* Neutrally Encoded Buffer positioning functions. */
  void rewind ();               /* positions at beginning */
  int get_encoded_msg_size ();  /* Store last position in header.size */

  /* Buffer access control functions. */
  void set_mode (CMSMODE im);   /* Determine read/write mode.(check neutral) */

  /* Select a temparary updator -- This is used by the nml msg2string and string2msg functions. */
  void set_temp_updater (CMS_NEUTRAL_ENCODING_METHOD);

  /* Restore the normal update. */
  void restore_normal_updater ();


  /*******************************************************/
  /* CMS INTERNAL ACCESS FUNCTIONS located in cms_in.cc  */
  /*******************************************************/
  CMS_STATUS internal_access (PHYSMEM_HANDLE * _global, void *_local);
  CMS_STATUS internal_access (void *_global, long global_size, void *_local);
  CMS_STATUS internal_clear (); /* Zero the global memory.  */
  int check_if_read_raw ();
  int check_if_read_encoded ();
  int get_msg_count_raw ();
  int get_msg_count_encoded ();
  CMS_STATUS read_raw ();       /* Read from raw buffers. */
  CMS_STATUS read_encoded ();   /* Read from neutrally encoded buffers. */
  CMS_STATUS peek_raw ();       /* Read  without setting flags. */
  CMS_STATUS peek_encoded ();   /* Read  without setting flags. */
  CMS_STATUS write_raw (void *user_data);       /* Write to raw buffers. */
  CMS_STATUS write_encoded ();  /* Write to neutrally encoded buffers. */
  CMS_STATUS write_if_read_raw (void *user_data);       /* Write if read. */
  CMS_STATUS write_if_read_encoded ();  /* Write if read. */
  int queue_check_if_read_raw ();
  int queue_check_if_read_encoded ();
  CMS_STATUS queue_read_raw (); /* Read from raw buffers. */
  CMS_STATUS queue_read_encoded ();     /* Read from neutral buffers. */
  CMS_STATUS queue_peek_raw (); /* Read  without setting flags. */
  CMS_STATUS queue_peek_encoded ();     /* Read  without setting flags. */
  CMS_STATUS queue_write_raw (void *user_data); /* Write to raw bufs */
  CMS_STATUS queue_write_encoded ();    /* Write to neutral buffers. */
  CMS_STATUS queue_write_if_read_raw (void *user_data);
  CMS_STATUS queue_write_if_read_encoded ();    /* Write if read. */
  virtual void clean_buffers ();

  /***********************************************/
  /* CMS UPDATE  FUNCTIONS located in cms_up.cc  */
  /***********************************************/
  /* Access functions for primitive C language data types */
  CMS_STATUS update (char &x);
  CMS_STATUS update (unsigned char &x);
  CMS_STATUS update (short int &x);
  CMS_STATUS update (unsigned short int &x);
  CMS_STATUS update (int &x);
  CMS_STATUS update (unsigned int &x);
  CMS_STATUS update (long int &x);
  CMS_STATUS update (unsigned long int &x);
  CMS_STATUS update (float &x);
  CMS_STATUS update (double &x);
  CMS_STATUS update (long double &x);
  CMS_STATUS update (char *x, unsigned int len);
  CMS_STATUS update (unsigned char *x, unsigned int len);
  CMS_STATUS update (short *x, unsigned int len);
  CMS_STATUS update (unsigned short *x, unsigned int len);
  CMS_STATUS update (int *x, unsigned int len);
  CMS_STATUS update (unsigned int *x, unsigned int len);
  CMS_STATUS update (long *x, unsigned int len);
  CMS_STATUS update (unsigned long *x, unsigned int len);
  CMS_STATUS update (float *x, unsigned int len);
  CMS_STATUS update (double *x, unsigned int len);
  CMS_STATUS update (long double *x, unsigned int len);

  /*************************************************************************
   * CMS UPDATE FUNCTIONS for POSEMATH classes, defined in cms_pm.cc       *
   ************************************************************************/
  // translation types
  CMS_STATUS update (PM_CARTESIAN & x); // Cart
  CMS_STATUS update (PM_SPHERICAL & x); // Sph
  CMS_STATUS update (PM_CYLINDRICAL & x);       // Cyl

  // rotation types
  CMS_STATUS update (PM_ROTATION_VECTOR & x);   // Rot
  CMS_STATUS update (PM_ROTATION_MATRIX & x);   // Mat
  CMS_STATUS update (PM_QUATERNION & x);        // Quat
  CMS_STATUS update (PM_EULER_ZYZ & x); // Zyz
  CMS_STATUS update (PM_EULER_ZYX & x); // Zyx
  CMS_STATUS update (PM_RPY & x);       // Rpy

  // pose types
  CMS_STATUS update (PM_POSE & x);      // Pose
  CMS_STATUS update (PM_HOMOGENEOUS & x);       // Hom

  // CMS UPDATE FUNCTIONS for arrays of POSEMATH types.
  // translation types
  CMS_STATUS update (PM_CARTESIAN * x, int n);  // Cart
  CMS_STATUS update (PM_SPHERICAL * x, int n);  // Sph
  CMS_STATUS update (PM_CYLINDRICAL * x, int n);        // Cyl

  // rotation types
  CMS_STATUS update (PM_ROTATION_VECTOR * x, int n);    // Rot
  CMS_STATUS update (PM_ROTATION_MATRIX * x, int n);    // Mat
  CMS_STATUS update (PM_QUATERNION * x, int n); // Quat
  CMS_STATUS update (PM_EULER_ZYZ * x, int n);  // Zyz
  CMS_STATUS update (PM_EULER_ZYX * x, int n);  // Zyx
  CMS_STATUS update (PM_RPY * x, int n);        // Rpy

  // pose types
  CMS_STATUS update (PM_POSE * x, int n);       // Pose
  CMS_STATUS update (PM_HOMOGENEOUS * x, int n);        // Hom


#ifdef CMS_SUPPORT_POINTERS
  virtual CMS_STATUS update_ptr (int (*update_ptr_func) (void *, CMS *),
                                 void **x, long xsize);
  virtual CMS_STATUS set_pointer_buffer (char *buf, long size);
#endif
  /* comm protocol parameters shared by all protocols */
  int fatal_error_occurred;
  int consecutive_timeouts;
  CMS_HEADER header;            /* Information to be stored in CMS buffer. */
  int queuing_enabled;          /* queue messages in the buffer  */
  CMS_QUEUING_HEADER queuing_header;    /* information for multi-slot buffers.  */
  CMSMODE mode;                 /* This process is reading or writing? */
  long size;                    /* size of cms */
  long max_message_size;        /* size of cms buffer available for user */
  /* messages = size - CMS Header space */
  long max_encoded_message_size;        /* Maximum size of message after being encoded. */
  long guaranteed_message_space;        /* Largest size message before being encoded
                                           that can be guaranteed to fit after xdr. */
  int neutral;                  /* neutral data format in buffer */

  CMS_STATUS status;            /* Status of the last CMS access. */
  void set_cms_status (CMS_STATUS);     /* Catch changes in cms status.  */
  int spawn_server;

  /* Buffers for local copies of global buffer. */
  void *encoded_data;           /* pointer to local copy of  encoded data */
  int using_external_encoded_data;
  void set_encoded_data (void *, long _encoded_data_size);
  void *data;                   /* pointer to local copy of data (raw)  */
  void *subdiv_data;            // pointer to current subdiv;

  /* Intersting Info Saved from the Configuration File. */
  char BufferName[CMS_CONFIG_LINELEN];
  char BufferHost[CMS_CONFIG_LINELEN];
  char ProcessName[CMS_CONFIG_LINELEN];
  char BufferLine[CMS_CONFIG_LINELEN];
  char ProcessLine[CMS_CONFIG_LINELEN];
  char ProcessHost[CMS_CONFIG_LINELEN];
  char buflineupper[CMS_CONFIG_LINELEN];
  char proclineupper[CMS_CONFIG_LINELEN];
  char PermissionString[CMS_CONFIG_LINELEN];
  int is_local_master;
  int force_raw;
  int split_buffer;             /* Will the buffer be split into two areas */
  /* so that one area can be read while the */
  /* other is written to? */
  char toggle_bit;
  int first_read_done;
  int first_write_done;
  int write_permission_flag;
  int read_permission_flag;
  unsigned long rpc_program_number;
  int tcp_port_number;
  int stcp_port_number;
  int udp_port_number;
  long buffer_number;
  int delete_totally;
  long total_messages_missed;
  long messages_missed_on_last_read;
  char RCS_HUGE *format_low_ptr;
  char RCS_HUGE *format_high_ptr;
  long format_size;
  int check_pointer (char RCS_HUGE * ptr, long bytes);
  int isserver;                 /* Is the process a server. */
  int is_phantom;               /* Is this a phantom CMS channel? */
  CMS_BUFFERTYPE BufferType;
  CMS_PROCESSTYPE ProcessType;
  CMS_REMOTE_PORT_TYPE remote_port_type;
  int pointer_check_disabled;

  CMSID in_buffer_id;           /* Last id read, used to determine if new. */
  void *encoded_header;         /* pointer to local copy of encoded header */
  void *encoded_queuing_header; /* pointer to local copy of encoded queue info */
  long encoded_header_size;     /* Dynamically determined size */
  long encoded_queuing_header_size;     /* Dynamically determined size */

  /* Header Neutral Formatting Functions. */
  int encode_header ();         /* header-> ENCODE-> encoded_header */
  int decode_header ();         /* encoded_header -> DECODE -> header */
  int encode_queuing_header (); /* queuing_header -> encoded_queuing_header */
  int decode_queuing_header (); /* encoded_queuing_header ->queuing_header */
  /* XDR of ASCII */
  CMS_NEUTRAL_ENCODING_METHOD neutral_encoding_method;
  CMS_NEUTRAL_ENCODING_METHOD temp_updater_encoding_method;

public:
  /* Type of internal access. */
    CMS_INTERNAL_ACCESS_TYPE internal_access_type;
  PHYSMEM_HANDLE *handle_to_global_data;
  PHYSMEM_HANDLE *dummy_handle;
  int write_just_completed;
  CMSMODE read_mode;
  CMSMODE write_mode;
  int read_updater_mode;
  int write_updater_mode;
  CMSMODE last_im;
  /* data buffer stuff */


  CMS_STATUS check_id (CMSID id);       /* Determine if the buffer is new. */
  friend class CMS_SERVER;
  friend class CMS_SERVER_HANDLER;
public:
  double timeout;
  long connection_number;
  long total_connections;
  CMS_UPDATER *updater;
  CMS_UPDATER *normal_updater;
  CMS_UPDATER *temp_updater;

private:
  unsigned long encode_state;   /* Store position for save, restore. */
  unsigned long decode_state;   /* Store position for save, restore. */
  void open (void);             /* Allocate memory and intialize XDR streams */
  static int number_of_cms_objects;     /* Used to decide when to initialize */
  /* and cleanup PC-NFS Toolkit DLLs */

public:
  long sizeof_message_header;   /* Used by BBD protocol to strip off */
  double blocking_timeout;
  double min_compatible_version;
  int confirm_write;
  int disable_final_write_raw_for_dma;
  virtual const char *status_string (int);

  int total_subdivisions;
  int current_subdivision;
  long subdiv_size;
  int set_subdivision (int _subdiv);
  long encoded_data_size;
  long enc_max_size;
  long enable_diagnostics;
  CMS_DIAG_PROC_INFO *dpi;
  virtual CMS_DIAG_PROC_INFO *get_diag_proc_info ();
  virtual void set_diag_proc_info (CMS_DIAG_PROC_INFO *);
  virtual void setup_diag_proc_info ();
  virtual void calculate_and_store_diag_info (PHYSMEM_HANDLE * _handle,
                                              void *);
  virtual void internal_retrieve_diag_info (PHYSMEM_HANDLE * _handle, void *);
  CMS_DIAGNOSTICS_INFO *di;
  virtual CMS_DIAGNOSTICS_INFO *get_diagnostics_info ();
  int first_diag_store;
  double pre_op_total_bytes_moved;
  double time_bias;
  int skip_area;
  unsigned long half_offset;
  long half_size;
  int fast_mode;
  long size_without_diagnostics;
  int disable_diag_store;
  long diag_offset;
  int last_id_side0;
  int last_id_side1;
  int use_autokey_for_connection_number;
  /* RCS_CMD_MSG, RCS_STAT_MSG stuff */

private:
    CMS (CMS & cms);            // Don't copy me.

};

class CMS_HOST_ALIAS_ENTRY
{
public:
  char host[64];
  char alias[64];
};


extern RCS_LINKED_LIST *cmsHostAliases;

enum CMS_CONNECTION_MODE
{
  CMS_NORMAL_CONNECTION_MODE = 0,       // all config file parameters are honored.
  CMS_FORCE_LOCAL_CONNECTION_MODE = 1,  // all connections are forced to be local
  CMS_FORCE_REMOTE_CONNECTION_MODE = 2  // all connections are forced to be remote
};

extern CMS_CONNECTION_MODE cms_connection_mode;


extern char *cms_check_for_host_alias (char *in);
extern int cms_encoded_data_explosion_factor;
extern int cms_print_queue_free_space;
extern int cms_print_queue_full_messages;


#endif /* !defined(CMS_HH) */

---