1  /********************************************************************
  2  * Description: rem_msg.hh
  3  *   Defines the structs passed between REMOTE clients and servers
  4  *   as part of CMS.
  5  *  Includes:
  6  *   1. struct REMOTE_READ_REQUEST,  REMOTE_READ_REPLY,
  7  *      REMOTE_WRITE_REPLY, REMOTE_WRITE_REQUEST.
  8  *   2. Function prototypes for functions that XDR encode and decode these
  9  *      structs.
 10  *
 11  *   Derived from a work by Fred Proctor & Will Shackleford
 12  *
 13  * Author:
 14  * License: LGPL Version 2
 15  * System: Linux
 16  *    
 17  * Copyright (c) 2004 All rights reserved.
 18  *
 19  * Last change: 
 20  ********************************************************************/
 21  
 22  #ifndef REM_MSG_HH
 23  #define REM_MSG_HH
 24  
 25  
 26  class CMS_DIAGNOSTICS_INFO;
 27  struct CMS_HEADER;
 28  
 29  struct REMOTE_CMS_MESSAGE {
 30  };
 31  
 32  enum REMOTE_CMS_REQUEST_TYPE {
 33      NO_REMOTE_CMS_REQUEST = 0,
 34      REMOTE_CMS_READ_REQUEST_TYPE = 1,
 35      REMOTE_CMS_WRITE_REQUEST_TYPE,
 36      REMOTE_CMS_CHECK_IF_READ_REQUEST_TYPE,
 37      REMOTE_CMS_CLEAN_REQUEST_TYPE,
 38      REMOTE_CMS_CLEAR_REQUEST_TYPE,
 39      REMOTE_CMS_CLOSE_CHANNEL_REQUEST_TYPE,
 40      REMOTE_CMS_GET_KEYS_REQUEST_TYPE,
 41      REMOTE_CMS_LOGIN_REQUEST_TYPE,
 42      REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE,
 43      REMOTE_CMS_READ_COMBINED_REQUEST_TYPE,
 44      REMOTE_CMS_BLOCKING_READ_REQUEST_TYPE,
 45      REMOTE_CMS_GET_BUF_NAME_REQUEST_TYPE,
 46      REMOTE_CMS_CANCEL_SUBSCRIPTION_REQUEST_TYPE,
 47      REMOTE_CMS_SET_DIAG_INFO_REQUEST_TYPE,
 48      REMOTE_CMS_GET_DIAG_INFO_REQUEST_TYPE,
 49      REMOTE_CMS_GET_MSG_COUNT_REQUEST_TYPE,
 50      REMOTE_CMS_GET_QUEUE_LENGTH_REQUEST_TYPE,
 51      REMOTE_CMS_GET_SPACE_AVAILABLE_REQUEST_TYPE,
 52  
 53  };
 54  
 55  struct REMOTE_CMS_REQUEST:public REMOTE_CMS_MESSAGE {
 56      REMOTE_CMS_REQUEST(REMOTE_CMS_REQUEST_TYPE _type) {
 57  	type = (int) _type;
 58  	buffer_number = 0;
 59  	subdiv = 0;
 60      };
 61      long buffer_number;
 62      int type;
 63      int subdiv;
 64  };
 65  
 66  struct REMOTE_CMS_REPLY:public REMOTE_CMS_MESSAGE {
 67      REMOTE_CMS_REPLY() {
 68  	status = 0;
 69      };
 70      int status;
 71  };
 72  
 73  /* Structure sent by client to server to initiate a read. */
 74  struct REMOTE_BLOCKING_READ_REQUEST:public REMOTE_CMS_REQUEST {
 75      REMOTE_BLOCKING_READ_REQUEST():REMOTE_CMS_REQUEST
 76  	(REMOTE_CMS_BLOCKING_READ_REQUEST_TYPE) {
 77      };
 78      int access_type;		/* read or just peek */
 79      long last_id_read;		/* The server can compare with id from buffer 
 80  				 */
 81      /* to determine if the buffer is new */
 82      /* to this client */
 83      long timeout_millis;	/* Milliseconds for blocking_timeout or -1 to 
 84  				   wait forever */
 85      void *_nml;
 86      void *_data;
 87      void *_reply;
 88  };
 89  
 90  /* Structure sent by client to server to initiate a read. */
 91  struct REMOTE_GET_BUF_NAME_REQUEST:public REMOTE_CMS_REQUEST {
 92      REMOTE_GET_BUF_NAME_REQUEST():REMOTE_CMS_REQUEST
 93  	(REMOTE_CMS_GET_BUF_NAME_REQUEST_TYPE) {
 94      };
 95  };
 96  
 97  struct REMOTE_READ_REQUEST:public REMOTE_CMS_REQUEST {
 98      REMOTE_READ_REQUEST():REMOTE_CMS_REQUEST(REMOTE_CMS_READ_REQUEST_TYPE) {
 99      };
100      int access_type;		/* read or just peek */
101      long last_id_read;		/* The server can compare with id from buffer 
102  				 */
103      /* to determine if the buffer is new */
104      /* to this client */
105  };
106  
107  /* Structure returned by server to client after a read. */
108  struct REMOTE_READ_REPLY:public REMOTE_CMS_REPLY {
109      int size;			/* size of message stored in data. */
110      long write_id;		/* Id from the buffer. */
111      long was_read;		/* Was this message already read? */
112      void *data;			/* Location of stored message. */
113  };
114  
115  /* Structure returned by server to client after a read. */
116  struct REMOTE_GET_BUF_NAME_REPLY:public REMOTE_CMS_REPLY {
117      char name[32];		/* Location of stored buffer name (truncated
118  				   to 31 characters). */
119  };
120  
121  /* Structure returned by server to client after a read. */
122  struct REMOTE_BLOCKING_READ_REPLY:public REMOTE_READ_REPLY {
123  };
124  
125  /* Structure sent by client to server to initiate a write. */
126  struct REMOTE_WRITE_REQUEST:public REMOTE_CMS_REQUEST {
127      REMOTE_WRITE_REQUEST():REMOTE_CMS_REQUEST(REMOTE_CMS_WRITE_REQUEST_TYPE) {
128  	data = NULL;
129  	size = 0;
130      };
131      int access_type;		/* write or write_if_read */
132      int size;			/* size of message in data */
133      void *data;			/* location of message to write into buffer */
134      void *_nml;
135  };
136  
137  /* Structure returned by server to client after a write. */
138  struct REMOTE_WRITE_REPLY:public REMOTE_CMS_REPLY {
139      long write_id;		/* Id from the buffer. */
140      long was_read;		/* Was the message to be overwriten ever
141  				   read? */
142      int confirm_write;
143  };
144  
145  struct REMOTE_CHECK_IF_READ_REQUEST:public REMOTE_CMS_REQUEST {
146      REMOTE_CHECK_IF_READ_REQUEST():REMOTE_CMS_REQUEST
147  	(REMOTE_CMS_CHECK_IF_READ_REQUEST_TYPE) {
148      };
149  };
150  
151  struct REMOTE_CHECK_IF_READ_REPLY:public REMOTE_CMS_REPLY {
152      int was_read;
153  };
154  
155  struct REMOTE_CLEAR_REQUEST:public REMOTE_CMS_REQUEST {
156      REMOTE_CLEAR_REQUEST():REMOTE_CMS_REQUEST(REMOTE_CMS_CLEAR_REQUEST_TYPE) {
157      };
158  };
159  
160  struct REMOTE_CLEAR_REPLY:public REMOTE_CMS_REPLY {
161  };
162  
163  struct REMOTE_CLOSE_CHANNEL_REQUEST:public REMOTE_CMS_REQUEST {
164      REMOTE_CLOSE_CHANNEL_REQUEST():REMOTE_CMS_REQUEST
165  	(REMOTE_CMS_CLOSE_CHANNEL_REQUEST_TYPE) {
166      };
167  };
168  
169  struct REMOTE_CLOSE_CHANNEL_REPLY:public REMOTE_CMS_REPLY {
170  };
171  
172  struct REMOTE_GET_KEYS_REQUEST:public REMOTE_CMS_REQUEST {
173      REMOTE_GET_KEYS_REQUEST():REMOTE_CMS_REQUEST
174  	(REMOTE_CMS_GET_KEYS_REQUEST_TYPE) {
175      };
176      char name[16];
177  };
178  
179  struct REMOTE_GET_KEYS_REPLY:public REMOTE_CMS_REPLY {
180      char key1[8];
181      char key2[8];
182  };
183  
184  struct REMOTE_LOGIN_REQUEST:public REMOTE_CMS_REQUEST {
185      REMOTE_LOGIN_REQUEST():REMOTE_CMS_REQUEST(REMOTE_CMS_LOGIN_REQUEST_TYPE) {
186      };
187      char name[16];
188      char passwd[16];
189  };
190  
191  struct REMOTE_LOGIN_REPLY:public REMOTE_CMS_REPLY {
192      int success;		// 1 = logged in, 0 = not
193  };
194  
195  enum CMS_REMOTE_SUBSCRIPTION_REQUEST_TYPE {
196      CMS_POLLED_SUBSCRIPTION = 1,
197      CMS_NO_SUBSCRIPTION,
198      CMS_VARIABLE_SUBSCRIPTION
199  };
200  
201  struct REMOTE_SET_SUBSCRIPTION_REQUEST:public REMOTE_CMS_REQUEST {
202      REMOTE_SET_SUBSCRIPTION_REQUEST():REMOTE_CMS_REQUEST
203  	(REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE) {
204      };
205      int subscription_type;
206      int poll_interval_millis;
207      int last_id_read;
208  };
209  
210  struct REMOTE_SET_SUBSCRIPTION_REPLY:public REMOTE_CMS_REPLY {
211      int success;		// 1 = logged in, 0 = not
212      int subscription_id;	// used by UDP clients to cancel a
213      // subscription.
214  };
215  
216  struct REMOTE_CANCEL_SUBSCRIPTION_REQUEST:public REMOTE_CMS_REQUEST {
217      REMOTE_CANCEL_SUBSCRIPTION_REQUEST():REMOTE_CMS_REQUEST
218  	(REMOTE_CMS_CANCEL_SUBSCRIPTION_REQUEST_TYPE) {
219      };
220      int subscription_id;
221  };
222  
223  struct REMOTE_CANCEL_SUBSCRIPTION_REPLY:public REMOTE_CMS_REPLY {
224      int success;		// 1 = logged in, 0 = not
225      int subscription_id;	// used by UDP clients to cancel a
226      // subscription.
227  };
228  
229  struct REMOTE_SET_DIAG_INFO_REQUEST:public REMOTE_CMS_REQUEST {
230      REMOTE_SET_DIAG_INFO_REQUEST():REMOTE_CMS_REQUEST
231  	(REMOTE_CMS_SET_DIAG_INFO_REQUEST_TYPE) {
232      };
233      char process_name[16];
234      char host_sysinfo[256];
235      int pid;
236      int c_num;
237      double rcslib_ver;
238      int reverse_flag;
239      double bytes_moved;
240      double bytes_moved_accross_socket;
241  };
242  
243  /* Structure returned by server to client after a read. */
244  struct REMOTE_SET_DIAG_INFO_REPLY:public REMOTE_CMS_REPLY {
245  };
246  
247  struct REMOTE_GET_DIAG_INFO_REQUEST:public REMOTE_CMS_REQUEST {
248      REMOTE_GET_DIAG_INFO_REQUEST():REMOTE_CMS_REQUEST
249  	(REMOTE_CMS_GET_DIAG_INFO_REQUEST_TYPE) {
250      };
251  };
252  
253  /* Structure returned by server to client after a read. */
254  struct REMOTE_GET_DIAG_INFO_REPLY:public REMOTE_CMS_REPLY {
255      CMS_DIAGNOSTICS_INFO *cdi;
256  };
257  
258  struct REMOTE_GET_MSG_COUNT_REQUEST:public REMOTE_CMS_REQUEST {
259      REMOTE_GET_MSG_COUNT_REQUEST():REMOTE_CMS_REQUEST
260  	(REMOTE_CMS_GET_MSG_COUNT_REQUEST_TYPE) {
261      };
262  };
263  
264  /* Structure returned by server to client after a read. */
265  struct REMOTE_GET_MSG_COUNT_REPLY:public REMOTE_CMS_REPLY {
266      long count;
267  };
268  
269  struct REMOTE_GET_QUEUE_LENGTH_REQUEST:public REMOTE_CMS_REQUEST {
270      REMOTE_GET_QUEUE_LENGTH_REQUEST():REMOTE_CMS_REQUEST
271  	(REMOTE_CMS_GET_QUEUE_LENGTH_REQUEST_TYPE) {
272      };
273  };
274  
275  /* Structure returned by server to client after a read. */
276  struct REMOTE_GET_QUEUE_LENGTH_REPLY:public REMOTE_CMS_REPLY {
277      long queue_length;
278  };
279  
280  struct REMOTE_GET_SPACE_AVAILABLE_REQUEST:public REMOTE_CMS_REQUEST {
281      REMOTE_GET_SPACE_AVAILABLE_REQUEST():REMOTE_CMS_REQUEST
282  	(REMOTE_CMS_GET_SPACE_AVAILABLE_REQUEST_TYPE) {
283      };
284  };
285  
286  /* Structure returned by server to client after a read. */
287  struct REMOTE_GET_SPACE_AVAILABLE_REPLY:public REMOTE_CMS_REPLY {
288      long space_available;
289  };
290  
291  /*! \todo Another #if 0 */
292  #if 0
293  #define MAX_BUFFERS_FOR_COMBINED_READ 32
294  
295  /* Structure sent by client to server to initiate a read of multiple buffers. */
296  struct REMOTE_READ_COMBINED_REQUEST:public REMOTE_CMS_REQUEST {
297      REMOTE_READ_COMBINED_REQUEST():REMOTE_CMS_REQUEST
298  	(REMOTE_CMS_READ_COMBINED_REQUEST_TYPE) {
299      };
300      int access_type;		/* read or just peek */
301      int num_buffers;
302  
303      struct combined_read_buf_req_info_struct {
304  	long buffer_number;
305  	long last_id_read;	/* The server can compare with id from buffer 
306  				 */
307  	/* to determine if the buffer is new */
308  	/* to this client */
309  	int header_only;	// non-zero means send only the header
310      } combined_read_buf_req_info[MAX_BUFFERS_FOR_COMBINED_READ];
311  
312  };
313  
314  /* Structure returned by server to client after a read. */
315  struct REMOTE_READ_COMBINED_REPLY:public REMOTE_CMS_REPLY {
316      int num_buffers;
317  
318      struct combined_read_buf_reply_info_struct {
319  	int size;		/* size of message stored in data. */
320  	long write_id;		/* Id from the buffer. */
321  	long was_read;		/* Was this message already read? */
322  	void *data;		/* Location of stored message. */
323      } combined_read_buf_reply_info[MAX_BUFFERS_FOR_COMBINED_READ];
324  };
325  #endif
326  
327  #endif