RPC Functions (rpc_xxx)

Classes
class	RPC_CLIENT_CONNECTION
struct	TR_FIFO
struct	TLS_POINTER

Macros
#define	RPC_CM_SET_CLIENT_INFO   11000
#define	RPC_CM_SET_WATCHDOG_PARAMS   11001
#define	RPC_CM_CLEANUP   11002
#define	RPC_CM_GET_WATCHDOG_INFO   11003
#define	RPC_CM_MSG_LOG   11004
#define	RPC_CM_EXECUTE   11005
#define	RPC_CM_SYNCHRONIZE   11006
#define	RPC_CM_ASCTIME   11007
#define	RPC_CM_TIME   11008
#define	RPC_CM_MSG   11009
#define	RPC_CM_EXIST   11011
#define	RPC_CM_MSG_RETRIEVE   11012
#define	RPC_CM_MSG_LOG1   11013
#define	RPC_CM_CHECK_CLIENT   11014
#define	RPC_BM_OPEN_BUFFER   11100
#define	RPC_BM_CLOSE_BUFFER   11101
#define	RPC_BM_CLOSE_ALL_BUFFERS   11102
#define	RPC_BM_GET_BUFFER_INFO   11103
#define	RPC_BM_GET_BUFFER_LEVEL   11104
#define	RPC_BM_INIT_BUFFER_COUNTERS   11105
#define	RPC_BM_SET_CACHE_SIZE   11106
#define	RPC_BM_ADD_EVENT_REQUEST   11107
#define	RPC_BM_REMOVE_EVENT_REQUEST   11108
#define	RPC_BM_SEND_EVENT   11109
#define	RPC_BM_FLUSH_CACHE   11110
#define	RPC_BM_RECEIVE_EVENT   11111
#define	RPC_BM_MARK_READ_WAITING   11112
#define	RPC_BM_EMPTY_BUFFERS   11113
#define	RPC_BM_SKIP_EVENT   11114
#define	RPC_DB_OPEN_DATABASE   11200
#define	RPC_DB_CLOSE_DATABASE   11201
#define	RPC_DB_CLOSE_ALL_DATABASES   11202
#define	RPC_DB_CREATE_KEY   11203
#define	RPC_DB_CREATE_LINK   11204
#define	RPC_DB_SET_VALUE   11205
#define	RPC_DB_GET_VALUE   11206
#define	RPC_DB_FIND_KEY   11207
#define	RPC_DB_FIND_LINK   11208
#define	RPC_DB_GET_PATH   11209
#define	RPC_DB_DELETE_KEY   11210
#define	RPC_DB_ENUM_KEY   11211
#define	RPC_DB_GET_KEY   11212
#define	RPC_DB_GET_DATA   11213
#define	RPC_DB_SET_DATA   11214
#define	RPC_DB_SET_DATA_INDEX   11215
#define	RPC_DB_SET_MODE   11216
#define	RPC_DB_GET_RECORD_SIZE   11219
#define	RPC_DB_GET_RECORD   11220
#define	RPC_DB_SET_RECORD   11221
#define	RPC_DB_ADD_OPEN_RECORD   11222
#define	RPC_DB_REMOVE_OPEN_RECORD   11223
#define	RPC_DB_SAVE   11224
#define	RPC_DB_LOAD   11225
#define	RPC_DB_SET_CLIENT_NAME   11226
#define	RPC_DB_RENAME_KEY   11227
#define	RPC_DB_ENUM_LINK   11228
#define	RPC_DB_REORDER_KEY   11229
#define	RPC_DB_CREATE_RECORD   11230
#define	RPC_DB_GET_DATA_INDEX   11231
#define	RPC_DB_GET_KEY_TIME   11232
#define	RPC_DB_GET_OPEN_RECORDS   11233
#define	RPC_DB_FLUSH_DATABASE   11235
#define	RPC_DB_SET_DATA_INDEX1   11236
#define	RPC_DB_GET_KEY_INFO   11237
#define	RPC_DB_GET_DATA1   11238
#define	RPC_DB_SET_NUM_VALUES   11239
#define	RPC_DB_CHECK_RECORD   11240
#define	RPC_DB_GET_NEXT_LINK   11241
#define	RPC_DB_GET_LINK   11242
#define	RPC_DB_GET_LINK_DATA   11243
#define	RPC_DB_SET_LINK_DATA   11244
#define	RPC_DB_SET_LINK_DATA_INDEX   11245
#define	RPC_DB_SET_DATA1   11246
#define	RPC_DB_NOTIFY_CLIENTS_ARRAY   11247
#define	RPC_DB_GET_PARENT   11248
#define	RPC_DB_COPY_XML   11249
#define	RPC_EL_SUBMIT   11400
#define	RPC_AL_CHECK   11500
#define	RPC_AL_TRIGGER_ALARM   11501
#define	RPC_RC_TRANSITION   12000
#define	RPC_ANA_CLEAR_HISTOS   13000
#define	RPC_LOG_REWIND   14000
#define	RPC_TEST   15000
#define	RPC_TEST2   15001
#define	RPC_CNAF16   16000
#define	RPC_CNAF24   16001
#define	RPC_MANUAL_TRIG   17000
#define	RPC_JRPC   18000
#define	RPC_BRPC   18001
#define	RPC_ID_WATCHDOG   99997
#define	RPC_ID_SHUTDOWN   99998
#define	RPC_ID_EXIT   99999

Functions
static RPC_SERVER_ACCEPTION *	rpc_get_server_acception (int idx)
RPC_SERVER_ACCEPTION *	rpc_get_mserver_acception ()
static RPC_SERVER_ACCEPTION *	rpc_new_server_acception ()
void	rpc_calc_convert_flags (INT hw_type, INT remote_hw_type, INT *convert_flags)
void	rpc_get_convert_flags (INT *convert_flags)
void	rpc_ieee2vax_float (float *var)
void	rpc_vax2ieee_float (float *var)
void	rpc_vax2ieee_double (double *var)
void	rpc_ieee2vax_double (double *var)
void	rpc_convert_single (void *data, INT tid, INT flags, INT convert_flags)
void	rpc_convert_data (void *data, INT tid, INT flags, INT total_size, INT convert_flags)
INT	rpc_tid_size (INT id)
const char *	rpc_tid_name (INT id)
const char *	rpc_tid_name_old (INT id)
int	rpc_name_tid (const char *name)
INT	rpc_register_client (const char *name, RPC_LIST *list)
INT	rpc_register_functions (const RPC_LIST *new_list, RPC_HANDLER func)
INT	rpc_deregister_functions ()
INT	rpc_register_function (INT id, INT(*func)(INT, void **))
static int	handle_msg_odb (int n, const NET_COMMAND *nc)
INT	rpc_client_dispatch (int sock)
INT	rpc_client_connect (const char *host_name, INT port, const char *client_name, HNDLE *hConnection)
void	rpc_client_check ()
INT	rpc_server_connect (const char *host_name, const char *exp_name)
static RPC_CLIENT_CONNECTION *	rpc_get_locked_client_connection (HNDLE hConn)
INT	rpc_client_disconnect (HNDLE hConn, BOOL bShutdown)
INT	rpc_server_disconnect ()
bool	rpc_is_remote (void)
bool	rpc_is_connected (void)
std::string	rpc_get_mserver_hostname (void)
bool	rpc_is_mserver (void)
INT	rpc_get_hw_type ()
INT	rpc_get_timeout (HNDLE hConn)
INT	rpc_set_timeout (HNDLE hConn, int timeout_msec, int *old_timeout_msec)
INT	rpc_get_convert_flags (void)
const char *	rpc_get_mserver_path ()
INT	rpc_set_mserver_path (const char *path)
std::string	rpc_get_name ()
INT	rpc_set_name (const char *name)
INT	rpc_set_debug (void(*func)(const char *), INT mode)
void	rpc_debug_printf (const char *format,...)
void	rpc_va_arg (va_list *arg_ptr, INT arg_type, void *arg)
static void	rpc_call_encode (va_list &ap, const RPC_LIST &rl, NET_COMMAND **nc)
static int	rpc_call_decode (va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size)
INT	rpc_client_call (HNDLE hConn, DWORD routine_id,...)
INT	rpc_call (DWORD routine_id,...)
INT	rpc_set_opt_tcp_size (INT tcp_size)
INT	rpc_get_opt_tcp_size ()
INT	rpc_send_event (INT buffer_handle, const EVENT_HEADER *pevent, int unused, INT async_flag, INT mode)
INT	rpc_send_event1 (INT buffer_handle, const EVENT_HEADER *pevent)
INT	rpc_send_event_sg (INT buffer_handle, int sg_n, const char *const sg_ptr[], const size_t sg_len[])
INT	rpc_flush_event ()
static INT	rpc_transition_dispatch (INT idx, void *prpc_param[])
int	cm_query_transition (int *transition, int *run_number, int *trans_time)
static int	recv_net_command_realloc (INT idx, char **pbuf, int *pbufsize, INT *remaining)
INT	recv_tcp_check (int sock)
static int	recv_event_server_realloc (INT idx, RPC_SERVER_ACCEPTION *psa, char **pbuffer, int *pbuffer_size)
INT	rpc_register_server (int port, int *plsock, int *pport)
INT	rpc_register_listener (int port, RPC_HANDLER func, int *plsock, int *pport)
INT	rpc_execute (INT sock, char *buffer, INT convert_flags)
int	rpc_test_rpc ()
static std::atomic_bool	gAllowedHostsEnabled (false)
INT	rpc_clear_allowed_hosts ()
INT	rpc_add_allowed_host (const char *hostname)
INT	rpc_check_allowed_host (const char *hostname)
static INT	rpc_socket_check_allowed_host (int sock)
INT	rpc_server_accept (int lsock)
INT	rpc_client_accept (int lsock)
INT	rpc_server_callback (struct callback_addr *pcallback)
INT	rpc_server_loop (void)
INT	rpc_server_receive_rpc (int idx, RPC_SERVER_ACCEPTION *sa)
INT	rpc_server_receive_event (int idx, RPC_SERVER_ACCEPTION *sa, int timeout_msec)
int	rpc_flush_event_socket (int timeout_msec)
INT	rpc_server_shutdown (void)
INT	rpc_check_channels (void)
void	rpc_server_acception_struct::close ()

Variables
static std::mutex	_client_connections_mutex
static std::vector< RPC_CLIENT_CONNECTION * >	_client_connections
static RPC_SERVER_CONNECTION	_server_connection
static bool	_rpc_is_remote = false
static std::vector< RPC_SERVER_ACCEPTION * >	_server_acceptions
static RPC_SERVER_ACCEPTION *	_mserver_acception = NULL
static std::vector< RPC_LIST >	rpc_list
static std::mutex	rpc_list_mutex
static int	_opt_tcp_size = OPT_TCP_SIZE
static std::string	_mserver_path
static std::mutex	_tr_fifo_mutex
static TR_FIFO	_tr_fifo [10]
static int	_tr_fifo_wp = 0
static int	_tr_fifo_rp = 0
static TLS_POINTER *	tls_buffer = NULL
static int	tls_size = 0
static std::vector< std::string >	gAllowedHosts
static std::mutex	gAllowedHostsMutex

Detailed Description

dox dox dox

Macro Definition Documentation

RPC_AL_CHECK

#define RPC_AL_CHECK   11500

Definition at line 113 of file mrpc.h.

RPC_AL_TRIGGER_ALARM

#define RPC_AL_TRIGGER_ALARM   11501

Definition at line 114 of file mrpc.h.

RPC_ANA_CLEAR_HISTOS

#define RPC_ANA_CLEAR_HISTOS   13000

Definition at line 118 of file mrpc.h.

RPC_BM_ADD_EVENT_REQUEST

#define RPC_BM_ADD_EVENT_REQUEST   11107

Definition at line 43 of file mrpc.h.

RPC_BM_CLOSE_ALL_BUFFERS

#define RPC_BM_CLOSE_ALL_BUFFERS   11102

Definition at line 38 of file mrpc.h.

RPC_BM_CLOSE_BUFFER

#define RPC_BM_CLOSE_BUFFER   11101

Definition at line 37 of file mrpc.h.

RPC_BM_EMPTY_BUFFERS

#define RPC_BM_EMPTY_BUFFERS   11113

Definition at line 49 of file mrpc.h.

RPC_BM_FLUSH_CACHE

#define RPC_BM_FLUSH_CACHE   11110

Definition at line 46 of file mrpc.h.

RPC_BM_GET_BUFFER_INFO

#define RPC_BM_GET_BUFFER_INFO   11103

Definition at line 39 of file mrpc.h.

RPC_BM_GET_BUFFER_LEVEL

#define RPC_BM_GET_BUFFER_LEVEL   11104

Definition at line 40 of file mrpc.h.

RPC_BM_INIT_BUFFER_COUNTERS

#define RPC_BM_INIT_BUFFER_COUNTERS   11105

Definition at line 41 of file mrpc.h.

RPC_BM_MARK_READ_WAITING

#define RPC_BM_MARK_READ_WAITING   11112

Definition at line 48 of file mrpc.h.

RPC_BM_OPEN_BUFFER

#define RPC_BM_OPEN_BUFFER   11100

Definition at line 36 of file mrpc.h.

RPC_BM_RECEIVE_EVENT

#define RPC_BM_RECEIVE_EVENT   11111

Definition at line 47 of file mrpc.h.

RPC_BM_REMOVE_EVENT_REQUEST

#define RPC_BM_REMOVE_EVENT_REQUEST   11108

Definition at line 44 of file mrpc.h.

RPC_BM_SEND_EVENT

#define RPC_BM_SEND_EVENT   11109

Definition at line 45 of file mrpc.h.

RPC_BM_SET_CACHE_SIZE

#define RPC_BM_SET_CACHE_SIZE   11106

Definition at line 42 of file mrpc.h.

RPC_BM_SKIP_EVENT

#define RPC_BM_SKIP_EVENT   11114

Definition at line 50 of file mrpc.h.

RPC_BRPC

#define RPC_BRPC   18001

Definition at line 131 of file mrpc.h.

RPC_CM_ASCTIME

#define RPC_CM_ASCTIME   11007

Definition at line 28 of file mrpc.h.

RPC_CM_CHECK_CLIENT

#define RPC_CM_CHECK_CLIENT   11014

Definition at line 34 of file mrpc.h.

RPC_CM_CLEANUP

#define RPC_CM_CLEANUP   11002

Definition at line 23 of file mrpc.h.

RPC_CM_EXECUTE

#define RPC_CM_EXECUTE   11005

Definition at line 26 of file mrpc.h.

RPC_CM_EXIST

#define RPC_CM_EXIST   11011

Definition at line 31 of file mrpc.h.

RPC_CM_GET_WATCHDOG_INFO

#define RPC_CM_GET_WATCHDOG_INFO   11003

Definition at line 24 of file mrpc.h.

RPC_CM_MSG

#define RPC_CM_MSG   11009

Definition at line 30 of file mrpc.h.

RPC_CM_MSG_LOG

#define RPC_CM_MSG_LOG   11004

Definition at line 25 of file mrpc.h.

RPC_CM_MSG_LOG1

#define RPC_CM_MSG_LOG1   11013

Definition at line 33 of file mrpc.h.

RPC_CM_MSG_RETRIEVE

#define RPC_CM_MSG_RETRIEVE   11012

Definition at line 32 of file mrpc.h.

RPC_CM_SET_CLIENT_INFO

#define RPC_CM_SET_CLIENT_INFO   11000

routine IDs for RPC calls

Definition at line 21 of file mrpc.h.

RPC_CM_SET_WATCHDOG_PARAMS

#define RPC_CM_SET_WATCHDOG_PARAMS   11001

Definition at line 22 of file mrpc.h.

RPC_CM_SYNCHRONIZE

#define RPC_CM_SYNCHRONIZE   11006

Definition at line 27 of file mrpc.h.

RPC_CM_TIME

#define RPC_CM_TIME   11008

Definition at line 29 of file mrpc.h.

RPC_CNAF16

#define RPC_CNAF16   16000

Definition at line 125 of file mrpc.h.

RPC_CNAF24

#define RPC_CNAF24   16001

Definition at line 126 of file mrpc.h.

RPC_DB_ADD_OPEN_RECORD

#define RPC_DB_ADD_OPEN_RECORD   11222

Definition at line 72 of file mrpc.h.

RPC_DB_CHECK_RECORD

#define RPC_DB_CHECK_RECORD   11240

Definition at line 89 of file mrpc.h.

RPC_DB_CLOSE_ALL_DATABASES

#define RPC_DB_CLOSE_ALL_DATABASES   11202

Definition at line 54 of file mrpc.h.

RPC_DB_CLOSE_DATABASE

#define RPC_DB_CLOSE_DATABASE   11201

Definition at line 53 of file mrpc.h.

RPC_DB_COPY_XML

#define RPC_DB_COPY_XML   11249

Definition at line 98 of file mrpc.h.

RPC_DB_CREATE_KEY

#define RPC_DB_CREATE_KEY   11203

Definition at line 55 of file mrpc.h.

RPC_DB_CREATE_LINK

#define RPC_DB_CREATE_LINK   11204

Definition at line 56 of file mrpc.h.

RPC_DB_CREATE_RECORD

#define RPC_DB_CREATE_RECORD   11230

Definition at line 80 of file mrpc.h.

RPC_DB_DELETE_KEY

#define RPC_DB_DELETE_KEY   11210

Definition at line 62 of file mrpc.h.

RPC_DB_ENUM_KEY

#define RPC_DB_ENUM_KEY   11211

Definition at line 63 of file mrpc.h.

RPC_DB_ENUM_LINK

#define RPC_DB_ENUM_LINK   11228

Definition at line 78 of file mrpc.h.

RPC_DB_FIND_KEY

#define RPC_DB_FIND_KEY   11207

Definition at line 59 of file mrpc.h.

RPC_DB_FIND_LINK

#define RPC_DB_FIND_LINK   11208

Definition at line 60 of file mrpc.h.

RPC_DB_FLUSH_DATABASE

#define RPC_DB_FLUSH_DATABASE   11235

Definition at line 84 of file mrpc.h.

RPC_DB_GET_DATA

#define RPC_DB_GET_DATA   11213

Definition at line 65 of file mrpc.h.

RPC_DB_GET_DATA1

#define RPC_DB_GET_DATA1   11238

Definition at line 87 of file mrpc.h.

RPC_DB_GET_DATA_INDEX

#define RPC_DB_GET_DATA_INDEX   11231

Definition at line 81 of file mrpc.h.

RPC_DB_GET_KEY

#define RPC_DB_GET_KEY   11212

Definition at line 64 of file mrpc.h.

RPC_DB_GET_KEY_INFO

#define RPC_DB_GET_KEY_INFO   11237

Definition at line 86 of file mrpc.h.

RPC_DB_GET_KEY_TIME

#define RPC_DB_GET_KEY_TIME   11232

Definition at line 82 of file mrpc.h.

RPC_DB_GET_LINK

#define RPC_DB_GET_LINK   11242

Definition at line 91 of file mrpc.h.

RPC_DB_GET_LINK_DATA

#define RPC_DB_GET_LINK_DATA   11243

Definition at line 92 of file mrpc.h.

RPC_DB_GET_NEXT_LINK

#define RPC_DB_GET_NEXT_LINK   11241

Definition at line 90 of file mrpc.h.

RPC_DB_GET_OPEN_RECORDS

#define RPC_DB_GET_OPEN_RECORDS   11233

Definition at line 83 of file mrpc.h.

RPC_DB_GET_PARENT

#define RPC_DB_GET_PARENT   11248

Definition at line 97 of file mrpc.h.

RPC_DB_GET_PATH

#define RPC_DB_GET_PATH   11209

Definition at line 61 of file mrpc.h.

RPC_DB_GET_RECORD

#define RPC_DB_GET_RECORD   11220

Definition at line 70 of file mrpc.h.

RPC_DB_GET_RECORD_SIZE

#define RPC_DB_GET_RECORD_SIZE   11219

Definition at line 69 of file mrpc.h.

RPC_DB_GET_VALUE

#define RPC_DB_GET_VALUE   11206

Definition at line 58 of file mrpc.h.

RPC_DB_LOAD

#define RPC_DB_LOAD   11225

Definition at line 75 of file mrpc.h.

RPC_DB_NOTIFY_CLIENTS_ARRAY

#define RPC_DB_NOTIFY_CLIENTS_ARRAY   11247

Definition at line 96 of file mrpc.h.

RPC_DB_OPEN_DATABASE

#define RPC_DB_OPEN_DATABASE   11200

Definition at line 52 of file mrpc.h.

RPC_DB_REMOVE_OPEN_RECORD

#define RPC_DB_REMOVE_OPEN_RECORD   11223

Definition at line 73 of file mrpc.h.

RPC_DB_RENAME_KEY

#define RPC_DB_RENAME_KEY   11227

Definition at line 77 of file mrpc.h.

RPC_DB_REORDER_KEY

#define RPC_DB_REORDER_KEY   11229

Definition at line 79 of file mrpc.h.

RPC_DB_SAVE

#define RPC_DB_SAVE   11224

Definition at line 74 of file mrpc.h.

RPC_DB_SET_CLIENT_NAME

#define RPC_DB_SET_CLIENT_NAME   11226

Definition at line 76 of file mrpc.h.

RPC_DB_SET_DATA

#define RPC_DB_SET_DATA   11214

Definition at line 66 of file mrpc.h.

RPC_DB_SET_DATA1

#define RPC_DB_SET_DATA1   11246

Definition at line 95 of file mrpc.h.

RPC_DB_SET_DATA_INDEX

#define RPC_DB_SET_DATA_INDEX   11215

Definition at line 67 of file mrpc.h.

RPC_DB_SET_DATA_INDEX1

#define RPC_DB_SET_DATA_INDEX1   11236

Definition at line 85 of file mrpc.h.

RPC_DB_SET_LINK_DATA

#define RPC_DB_SET_LINK_DATA   11244

Definition at line 93 of file mrpc.h.

RPC_DB_SET_LINK_DATA_INDEX

#define RPC_DB_SET_LINK_DATA_INDEX   11245

Definition at line 94 of file mrpc.h.

RPC_DB_SET_MODE

#define RPC_DB_SET_MODE   11216

Definition at line 68 of file mrpc.h.

RPC_DB_SET_NUM_VALUES

#define RPC_DB_SET_NUM_VALUES   11239

Definition at line 88 of file mrpc.h.

RPC_DB_SET_RECORD

#define RPC_DB_SET_RECORD   11221

Definition at line 71 of file mrpc.h.

RPC_DB_SET_VALUE

#define RPC_DB_SET_VALUE   11205

Definition at line 57 of file mrpc.h.

RPC_EL_SUBMIT

#define RPC_EL_SUBMIT   11400

Definition at line 111 of file mrpc.h.

RPC_ID_EXIT

#define RPC_ID_EXIT   99999

Definition at line 135 of file mrpc.h.

RPC_ID_SHUTDOWN

#define RPC_ID_SHUTDOWN   99998

Definition at line 134 of file mrpc.h.

RPC_ID_WATCHDOG

#define RPC_ID_WATCHDOG   99997

Definition at line 133 of file mrpc.h.

RPC_JRPC

#define RPC_JRPC   18000

Definition at line 130 of file mrpc.h.

RPC_LOG_REWIND

#define RPC_LOG_REWIND   14000

Definition at line 120 of file mrpc.h.

RPC_MANUAL_TRIG

#define RPC_MANUAL_TRIG   17000

Definition at line 128 of file mrpc.h.

RPC_RC_TRANSITION

#define RPC_RC_TRANSITION   12000

Definition at line 116 of file mrpc.h.

RPC_TEST

#define RPC_TEST   15000

Definition at line 122 of file mrpc.h.

RPC_TEST2

#define RPC_TEST2   15001

Definition at line 123 of file mrpc.h.

Function Documentation

close()

void RPC_SERVER_ACCEPTION::close

(

)

Definition at line 11510 of file midas.cxx.

{
   //printf("RPC_SERVER_ACCEPTION::close: connection from %s program %s mserver %d\n", host_name.c_str(), prog_name.c_str(), is_mserver);
 
   if (is_mserver) {
      assert(_mserver_acception == this);
      _mserver_acception = NULL;
      is_mserver = false;
   }
   
   /* close server connection */
   if (recv_sock)
      ss_socket_close(&recv_sock);
   if (send_sock)
      ss_socket_close(&send_sock);
   if (event_sock)
      ss_socket_close(&event_sock);
 
   /* free TCP cache */
   if (net_buffer) {
      //printf("free net_buffer %p+%d\n", net_buffer, net_buffer_size);
      free(net_buffer);
      net_buffer = NULL;
      net_buffer_size = 0;
   }
 
   /* mark this entry as invalid */
   clear();
}

Here is the call graph for this function:

Here is the caller graph for this function:

cm_query_transition()

int cm_query_transition	(	int *	transition,
		int *	run_number,
		int *	trans_time
	)

Definition at line 14087 of file midas.cxx.

{
   std::lock_guard<std::mutex> guard(_tr_fifo_mutex);
 
   if (_tr_fifo_wp == _tr_fifo_rp)
      return FALSE;
 
   if (transition)
      *transition = _tr_fifo[_tr_fifo_rp].transition;
 
   if (run_number)
      *run_number = _tr_fifo[_tr_fifo_rp].run_number;
 
   if (trans_time)
      *trans_time = (int) _tr_fifo[_tr_fifo_rp].trans_time;
 
   _tr_fifo_rp = (_tr_fifo_rp + 1) % 10;
 
   // implicit unlock
   return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gAllowedHostsEnabled()

static std::atomic_bool gAllowedHostsEnabled ( false  )

static

Here is the caller graph for this function:

handle_msg_odb()

static int handle_msg_odb ( int  n, const NET_COMMAND *  nc  )

static

Definition at line 11898 of file midas.cxx.

                                                        {
   //printf("rpc_client_dispatch: MSG_ODB: packet size %d, expected %d\n", n, (int)(sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT)));
   if (n == sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT)) {
      /* update a changed record */
      HNDLE hDB = *((INT *) nc->param);
      HNDLE hKeyRoot = *((INT *) nc->param + 1);
      HNDLE hKey = *((INT *) nc->param + 2);
      int index = *((INT *) nc->param + 3);
      return db_update_record_local(hDB, hKeyRoot, hKey, index);
   }
   return CM_VERSION_MISMATCH;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recv_event_server_realloc()

static int recv_event_server_realloc ( INT  idx, RPC_SERVER_ACCEPTION *  psa, char **  pbuffer, int *  pbuffer_size  )

static

Definition at line 14354 of file midas.cxx.

{
   int sock = psa->event_sock;
 
   //printf("recv_event_server: idx %d, buffer %p, buffer_size %d\n", idx, buffer, buffer_size);
 
   const size_t header_size = (sizeof(EVENT_HEADER) + sizeof(INT));
 
   char header_buf[header_size];
 
   // First read the header.
   //
   // Data format is:
   // INT buffer handle (4 bytes)
   // EVENT_HEADER (16 bytes)
   // event data
   // ALIGN8() padding
   // ...next event
 
   int hrd = recv_tcp2(sock, header_buf, header_size, 1);
 
   if (hrd == 0) {
      // timeout waiting for data
      return 0;
   }
 
   /* abort if connection broken */
   if (hrd < 0) {
      cm_msg(MERROR, "recv_event_server", "recv_tcp2(header) returned %d", hrd);
      return -1;
   }
 
   if (hrd < (int) header_size) {
      int hrd1 = recv_tcp2(sock, header_buf + hrd, header_size - hrd, 0);
 
      /* abort if connection broken */
      if (hrd1 <= 0) {
         cm_msg(MERROR, "recv_event_server", "recv_tcp2(more header) returned %d", hrd1);
         return -1;
      }
 
      hrd += hrd1;
   }
 
   /* abort if connection broken */
   if (hrd != (int) header_size) {
      cm_msg(MERROR, "recv_event_server", "recv_tcp2(header) returned %d instead of %d", hrd, (int) header_size);
      return -1;
   }
 
   INT *pbh = (INT *) header_buf;
   EVENT_HEADER *pevent = (EVENT_HEADER *) (((INT *) header_buf) + 1);
 
   /* convert header little endian/big endian */
   if (psa->convert_flags) {
      rpc_convert_single(&pbh, TID_INT32, 0, psa->convert_flags);
      rpc_convert_single(&pevent->event_id, TID_INT16, 0, psa->convert_flags);
      rpc_convert_single(&pevent->trigger_mask, TID_INT16, 0, psa->convert_flags);
      rpc_convert_single(&pevent->serial_number, TID_UINT32, 0, psa->convert_flags);
      rpc_convert_single(&pevent->time_stamp, TID_UINT32, 0, psa->convert_flags);
      rpc_convert_single(&pevent->data_size, TID_UINT32, 0, psa->convert_flags);
   }
 
   int event_size = pevent->data_size + sizeof(EVENT_HEADER);
   int total_size = ALIGN8(event_size);
 
   //printf("recv_event_server: buffer_handle %d, event_id 0x%04x, serial 0x%08x, data_size %d, event_size %d, total_size %d\n", *pbh, pevent->event_id, pevent->serial_number, pevent->data_size, event_size, total_size);
 
   if (pevent->data_size == 0) {
      for (int i=0; i<5; i++) {
         printf("recv_event_server: header[%d]: 0x%08x\n", i, pbh[i]);
      }
      abort();
   }
 
   /* check for sane event size */
   if (event_size <= 0 || total_size <= 0) {
      cm_msg(MERROR, "recv_event_server",
             "received event header with invalid data_size %d: event_size %d, total_size %d", pevent->data_size,
             event_size, total_size);
      return -1;
   }
 
   //printf("recv_event_server: idx %d, bh %d, event header: id %d, mask %d, serial %d, data_size %d, event_size %d, total_size %d\n", idx, *pbh, pevent->event_id, pevent->trigger_mask, pevent->serial_number, pevent->data_size, event_size, total_size);
 
 
   int bufsize = sizeof(INT) + total_size;
 
   // Second, check that output buffer is big enough
 
   /* check if data part fits in buffer */
   if (*pbuffer_size < bufsize) {
      int newsize = 1024 + ALIGN8(bufsize);
 
      //printf("recv_event_server: buffer realloc %d -> %d\n", *pbuffer_size, newsize);
 
      char *newbuf = (char *) realloc(*pbuffer, newsize);
      if (newbuf == NULL) {
         cm_msg(MERROR, "recv_event_server", "cannot realloc() event buffer from %d to %d bytes", *pbuffer_size,
                newsize);
         return -1;
      }
      *pbuffer = newbuf;
      *pbuffer_size = newsize;
   }
 
   // Third, copy header into output buffer
 
   memcpy(*pbuffer, header_buf, header_size);
 
   // Forth, read the event data
 
   int to_read = sizeof(INT) + total_size - header_size;
   int rptr = header_size;
 
   if (to_read > 0) {
      int drd = recv_tcp2(sock, (*pbuffer) + rptr, to_read, 0);
 
      /* abort if connection broken */
      if (drd <= 0) {
         cm_msg(MERROR, "recv_event_server", "recv_tcp2(data) returned %d instead of %d", drd, to_read);
         return -1;
      }
   }
 
   return bufsize;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recv_net_command_realloc()

static int recv_net_command_realloc ( INT  idx, char **  pbuf, int *  pbufsize, INT *  remaining  )

static

Definition at line 14164 of file midas.cxx.

{
   char *buffer = NULL; // buffer is changed to point to *pbuf when we receive the NET_COMMAND header
 
   RPC_SERVER_ACCEPTION* sa = rpc_get_server_acception(idx);
 
   int sock = sa->recv_sock;
 
   if (!sa->net_buffer) {
      if (sa->is_mserver)
         sa->net_buffer_size = NET_TCP_SIZE;
      else
         sa->net_buffer_size = NET_BUFFER_SIZE;
 
      sa->net_buffer = (char *) malloc(sa->net_buffer_size);
      //printf("sa %p idx %d, net_buffer %p+%d\n", sa, idx, sa->net_buffer, sa->net_buffer_size);
      sa->write_ptr = 0;
      sa->read_ptr = 0;
      sa->misalign = 0;
   }
   if (!sa->net_buffer) {
      cm_msg(MERROR, "recv_net_command", "Cannot allocate %d bytes for network buffer", sa->net_buffer_size);
      return -1;
   }
 
   int copied = 0;
   int param_size = -1;
 
   int write_ptr = sa->write_ptr;
   int read_ptr = sa->read_ptr;
   int misalign = sa->misalign;
   char *net_buffer = sa->net_buffer;
 
   do {
      if (write_ptr - read_ptr >= (INT) sizeof(NET_COMMAND_HEADER) - copied) {
         if (param_size == -1) {
            if (copied > 0) {
               /* assemble split header */
               memcpy(buffer + copied, net_buffer + read_ptr, (INT) sizeof(NET_COMMAND_HEADER) - copied);
               NET_COMMAND *nc = (NET_COMMAND *) (buffer);
               param_size = (INT) nc->header.param_size;
            } else {
               NET_COMMAND *nc = (NET_COMMAND *) (net_buffer + read_ptr);
               param_size = (INT) nc->header.param_size;
            }
 
            if (sa->convert_flags)
               rpc_convert_single(&param_size, TID_UINT32, 0, sa->convert_flags);
         }
 
         //printf("recv_net_command: param_size %d, NET_COMMAND_HEADER %d, buffer_size %d\n", param_size, (int)sizeof(NET_COMMAND_HEADER), *pbufsize);
 
         /* check if parameters fit in buffer */
         if (*pbufsize < (param_size + (int) sizeof(NET_COMMAND_HEADER))) {
            int new_size = param_size + sizeof(NET_COMMAND_HEADER) + 1024;
            char *p = (char *) realloc(*pbuf, new_size);
            //printf("recv_net_command: reallocate buffer %d -> %d, %p\n", *pbufsize, new_size, p);
            if (p == NULL) {
               cm_msg(MERROR, "recv_net_command", "cannot reallocate buffer from %d bytes to %d bytes", *pbufsize, new_size);
               sa->read_ptr = 0;
               sa->write_ptr = 0;
               return -1;
            }
            *pbuf = p;
            *pbufsize = new_size;
         }
 
         buffer = *pbuf;
 
         /* check if we have all parameters in buffer */
         if (write_ptr - read_ptr >= param_size + (INT) sizeof(NET_COMMAND_HEADER) - copied)
            break;
      }
 
      /* not enough data, so copy partially and get new */
      int size = write_ptr - read_ptr;
 
      if (size > 0) {
         memcpy(buffer + copied, net_buffer + read_ptr, size);
         copied += size;
         read_ptr = write_ptr;
      }
#ifdef OS_UNIX
      do {
         write_ptr = recv(sock, net_buffer + misalign, sa->net_buffer_size - 8, 0);
 
         /* don't return if an alarm signal was cought */
      } while (write_ptr == -1 && errno == EINTR);
#else
      write_ptr = recv(sock, net_buffer + misalign, sa->net_buffer_size - 8, 0);
#endif
 
      /* abort if connection broken */
      if (write_ptr <= 0) {
         if (write_ptr == 0)
            cm_msg(MERROR, "recv_net_command", "rpc connection from \'%s\' on \'%s\' unexpectedly closed", sa->prog_name.c_str(), sa->host_name.c_str());
         else
            cm_msg(MERROR, "recv_net_command", "recv() returned %d, errno: %d (%s)", write_ptr, errno, strerror(errno));
 
         if (remaining)
            *remaining = 0;
 
         return write_ptr;
      }
 
      read_ptr = misalign;
      write_ptr += misalign;
 
      misalign = write_ptr % 8;
   } while (TRUE);
 
   /* copy rest of parameters */
   int size = param_size + sizeof(NET_COMMAND_HEADER) - copied;
   memcpy(buffer + copied, net_buffer + read_ptr, size);
   read_ptr += size;
 
   if (remaining) {
      /* don't keep rpc_server_receive in an infinite loop */
      if (write_ptr - read_ptr < param_size)
         *remaining = 0;
      else
         *remaining = write_ptr - read_ptr;
   }
 
   sa->write_ptr = write_ptr;
   sa->read_ptr = read_ptr;
   sa->misalign = misalign;
 
   return size + copied;
}

Here is the call graph for this function:

Here is the caller graph for this function:

recv_tcp_check()

INT recv_tcp_check

(

int

sock

)

Definition at line 14324 of file midas.cxx.

{
   /* figure out to which connection socket belongs */
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++)
      if (_server_acceptions[idx] && _server_acceptions[idx]->recv_sock == sock) {
         return _server_acceptions[idx]->write_ptr - _server_acceptions[idx]->read_ptr;
      }
 
   return 0;
}

Here is the caller graph for this function:

rpc_add_allowed_host()

INT rpc_add_allowed_host

(

const char *

hostname

)

Definition at line 15202 of file midas.cxx.

{
   //cm_msg(MINFO, "rpc_add_allowed_host", "Adding allowed host \'%s\'", hostname); 
 
   gAllowedHostsMutex.lock();
   gAllowedHosts.push_back(hostname);
   gAllowedHostsEnabled = true;
   gAllowedHostsMutex.unlock();
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_calc_convert_flags()

void rpc_calc_convert_flags	(	INT	hw_type,
		INT	remote_hw_type,
		INT *	convert_flags
	)

• ASCII format *‍/

Definition at line 11550 of file midas.cxx.

                                                                                 {
   *convert_flags = 0;
 
   /* big/little endian conversion */
   if (((remote_hw_type & DRI_BIG_ENDIAN) &&
        (hw_type & DRI_LITTLE_ENDIAN)) || ((remote_hw_type & DRI_LITTLE_ENDIAN)
                                           && (hw_type & DRI_BIG_ENDIAN)))
      *convert_flags |= CF_ENDIAN;
 
   /* float conversion between IEEE and VAX G */
   if ((remote_hw_type & DRF_G_FLOAT) && (hw_type & DRF_IEEE))
      *convert_flags |= CF_VAX2IEEE;
 
   /* float conversion between VAX G and IEEE */
   if ((remote_hw_type & DRF_IEEE) && (hw_type & DRF_G_FLOAT))
      *convert_flags |= CF_IEEE2VAX;
 
   //if (remote_hw_type & DR_ASCII)
   //   *convert_flags |= CF_ASCII;
}

Here is the caller graph for this function:

rpc_call()

INT rpc_call	(	DWORD	routine_id,
			...
	)

Definition at line 13630 of file midas.cxx.

{
   va_list ap;
   INT i, status;
 
   BOOL rpc_no_reply = routine_id & RPC_NO_REPLY;
   routine_id &= ~RPC_NO_REPLY;
 
   //if (rpc_no_reply)
   //   printf("rpc_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
 
   int send_sock = _server_connection.send_sock;
   int rpc_timeout = _server_connection.rpc_timeout;
 
   if (!send_sock) {
      fprintf(stderr, "rpc_call(routine_id=%d) failed, no connection to mserver.\n", routine_id);
      return RPC_NET_ERROR;
   }
 
   if (!_mutex_rpc) {
      /* create a local mutex for multi-threaded applications */
      ss_mutex_create(&_mutex_rpc, FALSE);
   }
 
   status = ss_mutex_wait_for(_mutex_rpc, 10000 + rpc_timeout);
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_call", "Mutex timeout");
      return RPC_MUTEX_TIMEOUT;
   }
 
   /* find rpc definition */
 
   int idx = -1;
   const char* rpc_name = NULL;
   RPC_LIST rpc_entry;
 
   rpc_list_mutex.lock();
 
   for (size_t i = 0; i < rpc_list.size(); i++) {
      if (rpc_list[i].id == (int) routine_id) {
         idx = i;
         rpc_name = rpc_list[idx].name;
         rpc_entry = rpc_list[idx];
         break;
      }
   }
 
   rpc_list_mutex.unlock();
 
   if (idx < 0) {
      ss_mutex_release(_mutex_rpc);
      cm_msg(MERROR, "rpc_call", "invalid rpc ID (%d)", routine_id);
      return RPC_INVALID_ID;
   }
 
   /* prepare output buffer */
 
   NET_COMMAND* nc = NULL;
 
   /* examine variable argument list and convert it to parameter array */
   va_start(ap, routine_id);
 
   rpc_call_encode(ap, rpc_entry, &nc);
 
   va_end(ap);
 
   nc->header.routine_id = routine_id;
 
   if (rpc_no_reply)
      nc->header.routine_id |= RPC_NO_REPLY;
 
   int send_size = nc->header.param_size + sizeof(NET_COMMAND_HEADER);
 
   /* do not wait for reply if requested RPC_NO_REPLY */
   if (rpc_no_reply) {
      i = send_tcp(send_sock, (char *) nc, send_size, 0);
 
      if (i != send_size) {
         ss_mutex_release(_mutex_rpc);
         cm_msg(MERROR, "rpc_call", "rpc \"%s\" error: send_tcp() failed", rpc_name);
         free(nc);
         return RPC_NET_ERROR;
      }
 
      ss_mutex_release(_mutex_rpc);
      free(nc);
      return RPC_SUCCESS;
   }
 
   /* in TCP mode, send and wait for reply on send socket */
   i = send_tcp(send_sock, (char *) nc, send_size, 0);
   if (i != send_size) {
      ss_mutex_release(_mutex_rpc);
      cm_msg(MERROR, "rpc_call", "rpc \"%s\" error: send_tcp() failed", rpc_name);
      free(nc);
      return RPC_NET_ERROR;
   }
 
   free(nc);
   nc = NULL;
 
   bool restore_watchdog_timeout = false;
   BOOL watchdog_call;
   DWORD watchdog_timeout;
   cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
 
   //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, rpc_timeout);
 
   if (!rpc_is_remote()) {
      // if RPC is remote, we are connected to an mserver,
      // the mserver takes care of watchdog timeouts.
      // otherwise we should make sure the watchdog timeout
      // is longer than the RPC timeout. K.O.
      if (rpc_timeout >= (int) watchdog_timeout) {
         restore_watchdog_timeout = true;
         cm_set_watchdog_params_local(watchdog_call, rpc_timeout + 1000);
      }
   }
 
   DWORD rpc_status = 0;
   DWORD buf_size = 0;
   char* buf = NULL;
 
   status = ss_recv_net_command(send_sock, &rpc_status, &buf_size, &buf, rpc_timeout);
 
   if (restore_watchdog_timeout) {
      cm_set_watchdog_params_local(watchdog_call, watchdog_timeout);
   }
 
   /* drop the mutex, we are done with the socket, argument unpacking is done from our own buffer */
 
   ss_mutex_release(_mutex_rpc);
 
   /* check for reply errors */
 
   if (status == SS_TIMEOUT) {
      cm_msg(MERROR, "rpc_call", "routine \"%s\": timeout waiting for reply, program abort", rpc_name);
      if (buf)
         free(buf);
      abort(); // cannot continue - our mserver is not talking to us!
      return RPC_TIMEOUT;
   }
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_call", "routine \"%s\": error, ss_recv_net_command() status %d, program abort", rpc_name, status);
      if (buf)
         free(buf);
      abort(); // cannot continue - something is wrong with our mserver connection
      return RPC_NET_ERROR;
   }
 
   if (rpc_status == RPC_INVALID_ID) {
      cm_msg(MERROR, "rpc_call", "routine \"%s\": error, unknown RPC, status %d", rpc_name, rpc_status);
      if (buf)
         free(buf);
      return rpc_status;
   }
 
   /* extract result variables and place it to argument list */
 
   va_start(ap, routine_id);
 
   status = rpc_call_decode(ap, rpc_entry, buf, buf_size);
 
   if (status != RPC_SUCCESS) {
      rpc_status = status;
   }
 
   va_end(ap);
 
   if (buf)
      free(buf);
 
   return rpc_status;
}

Here is the call graph for this function:

rpc_call_decode()

static int rpc_call_decode ( va_list &  ap, const RPC_LIST &  rl, const char *  buf, size_t  buf_size  )

static

Definition at line 13369 of file midas.cxx.

{
   bool debug = false;
 
   if (debug)
      printf("decode reply to rpc_id %d \"%s\" has %d bytes\n", rl.id, rl.name, (int)buf_size);
 
   /* extract result variables and place it to argument list */
 
   const char* param_ptr = buf;
 
   for (int i = 0; rl.param[i].tid != 0; i++) {
      int tid = rl.param[i].tid;
      int flags = rl.param[i].flags;
      int arg_type = 0;
 
      bool bpointer = (flags & RPC_POINTER) || (flags & RPC_OUT) ||
                 (flags & RPC_FIXARRAY) || (flags & RPC_VARARRAY) ||
                 tid == TID_STRING || tid == TID_ARRAY || tid == TID_STRUCT || tid == TID_LINK;
 
      if (bpointer)
         arg_type = TID_ARRAY;
      else
         arg_type = rl.param[i].tid;
 
      if (tid == TID_FLOAT && !bpointer)
         arg_type = TID_DOUBLE;
 
      char arg[8];
      rpc_va_arg(&ap, arg_type, arg);
 
      if (rl.param[i].flags & RPC_OUT) {
 
         if (param_ptr == NULL) {
            cm_msg(MERROR, "rpc_call_decode", "routine \"%s\": no data in RPC reply, needed to decode an RPC_OUT parameter. param_ptr is NULL", rl.name);
            return RPC_NET_ERROR;
         }
 
         tid = rl.param[i].tid;
         int arg_size = rpc_tid_size(tid);
 
         if (tid == TID_STRING || tid == TID_LINK)
            arg_size = strlen((char *) (param_ptr)) + 1;
 
         if (flags & RPC_VARARRAY) {
            arg_size = *((INT *) param_ptr);
            param_ptr += ALIGN8(sizeof(INT));
         }
 
         if (tid == TID_STRUCT || (flags & RPC_FIXARRAY))
            arg_size = rl.param[i].n;
 
         /* parameter size is always aligned */
         int param_size = ALIGN8(arg_size);
 
         /* return parameters are always pointers */
         if (*((char **) arg)) {
            if (debug)
               printf("decode param %d, flags 0x%x, tid %d, arg_type %d, arg_size %d, param_size %d, memcpy %d\n", i, flags, tid, arg_type, arg_size, param_size, arg_size);
            memcpy((void *) *((char **) arg), param_ptr, arg_size);
         }
 
         param_ptr += param_size;
      }
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_call_encode()

static void rpc_call_encode ( va_list &  ap, const RPC_LIST &  rl, NET_COMMAND **  nc  )

static

Definition at line 13198 of file midas.cxx.

{
   bool debug = false;
 
   if (debug) {
      printf("encode rpc_id %d \"%s\"\n", rl.id, rl.name);
      for (int i=0; rl.param[i].tid != 0; i++) {
         int tid = rl.param[i].tid;
         int flags = rl.param[i].flags;
         int n = rl.param[i].n;
         printf("i=%d, tid %d, flags 0x%x, n %d\n", i, tid, flags, n);
      }
   }
 
   char args[MAX_RPC_PARAMS][8];
 
   for (int i=0; rl.param[i].tid != 0; i++) {
      int tid = rl.param[i].tid;
      int flags = rl.param[i].flags;
      int arg_type = 0;
 
      bool bpointer = (flags & RPC_POINTER) || (flags & RPC_OUT) ||
         (flags & RPC_FIXARRAY) || (flags & RPC_VARARRAY) ||
         tid == TID_STRING || tid == TID_ARRAY || tid == TID_STRUCT || tid == TID_LINK;
      
      if (bpointer)
         arg_type = TID_ARRAY;
      else
         arg_type = tid;
      
      /* floats are passed as doubles, at least under NT */
      if (tid == TID_FLOAT && !bpointer)
         arg_type = TID_DOUBLE;
      
      //printf("arg %d, tid %d, flags 0x%x, arg_type %d, bpointer %d\n", i, tid, flags, arg_type, bpointer);
 
      rpc_va_arg(&ap, arg_type, args[i]);
   }
 
   size_t buf_size = sizeof(NET_COMMAND) + 4 * 1024;
   char* buf = (char *)malloc(buf_size);
   assert(buf);
 
   (*nc) = (NET_COMMAND*) buf;
 
   /* find out if we are on a big endian system */
   bool bbig = ((rpc_get_hw_type() & DRI_BIG_ENDIAN) > 0);
 
   char* param_ptr = (*nc)->param;
 
   for (int i=0; rl.param[i].tid != 0; i++) {
      int tid = rl.param[i].tid;
      int flags = rl.param[i].flags;
      int arg_type = 0;
 
      bool bpointer = (flags & RPC_POINTER) || (flags & RPC_OUT) ||
                 (flags & RPC_FIXARRAY) || (flags & RPC_VARARRAY) ||
                 tid == TID_STRING || tid == TID_ARRAY || tid == TID_STRUCT || tid == TID_LINK;
 
      if (bpointer)
         arg_type = TID_ARRAY;
      else
         arg_type = tid;
 
      /* floats are passed as doubles, at least under NT */
      if (tid == TID_FLOAT && !bpointer)
         arg_type = TID_DOUBLE;
 
      /* get pointer to argument */
      //char arg[8];
      //rpc_va_arg(&ap, arg_type, arg);
 
      char* arg = args[i];
 
      /* shift 1- and 2-byte parameters to the LSB on big endian systems */
      if (bbig) {
         if (tid == TID_UINT8 || tid == TID_CHAR || tid == TID_INT8) {
            arg[0] = arg[3];
         }
         if (tid == TID_UINT16 || tid == TID_INT16) {
            arg[0] = arg[2];
            arg[1] = arg[3];
         }
      }
 
      if (flags & RPC_IN) {
         int arg_size = 0;
 
         if (bpointer)
            arg_size = rpc_tid_size(tid);
         else
            arg_size = rpc_tid_size(arg_type);
 
         /* for strings, the argument size depends on the string length */
         if (tid == TID_STRING || tid == TID_LINK) {
            arg_size = 1 + strlen((char *) *((char **) arg));
         }
 
         /* for varibale length arrays, the size is given by
            the next parameter on the stack */
         if (flags & RPC_VARARRAY) {
            //va_list aptmp;
            //va_copy(aptmp, ap);
 
            //char arg_tmp[8];
            //rpc_va_arg(&aptmp, TID_ARRAY, arg_tmp);
 
            const char* arg_tmp = args[i+1];
 
            /* for (RPC_IN+RPC_OUT) parameters, size argument is a pointer */
            if (flags & RPC_OUT)
               arg_size = *((INT *) *((void **) arg_tmp));
            else
               arg_size = *((INT *) arg_tmp);
 
            *((INT *) param_ptr) = ALIGN8(arg_size);
            param_ptr += ALIGN8(sizeof(INT));
 
            //va_end(aptmp);
         }
 
         if (tid == TID_STRUCT || (flags & RPC_FIXARRAY))
            arg_size = rl.param[i].n;
 
         /* always align parameter size */
         int param_size = ALIGN8(arg_size);
 
         {
            size_t param_offset = (char *) param_ptr - (char *)(*nc);
 
            if (param_offset + param_size + 16 > buf_size) {
               size_t new_size = param_offset + param_size + 1024;
               //printf("resize nc %zu to %zu\n", buf_size, new_size);
               buf = (char *) realloc(buf, new_size);
               assert(buf);
               buf_size = new_size;
               (*nc) = (NET_COMMAND*) buf;
               param_ptr = buf + param_offset;
            }
         }
 
         if (bpointer) {
            if (debug) {
               printf("encode param %d, flags 0x%x, tid %d, arg_type %d, arg_size %d, param_size %d, memcpy pointer %d\n", i, flags, tid, arg_type, arg_size, param_size, arg_size);
            }
            memcpy(param_ptr, (void *) *((void **) arg), arg_size);
         } else if (tid == TID_FLOAT) {
            if (debug) {
               printf("encode param %d, flags 0x%x, tid %d, arg_type %d, arg_size %d, param_size %d, double->float\n", i, flags, tid, arg_type, arg_size, param_size);
            }
            /* floats are passed as doubles on most systems */
            *((float *) param_ptr) = (float) *((double *) arg);
         } else {
            if (debug) {
               printf("encode param %d, flags 0x%x, tid %d, arg_type %d, arg_size %d, param_size %d, memcpy %d\n", i, flags, tid, arg_type, arg_size, param_size, arg_size);
            }
            memcpy(param_ptr, arg, arg_size);
         }
 
         param_ptr += param_size;
      }
   }
 
   (*nc)->header.param_size = (POINTER_T) param_ptr - (POINTER_T) (*nc)->param;
 
   if (debug)
      printf("encode rpc_id %d \"%s\" buf_size %d, param_size %d\n", rl.id, rl.name, (int)buf_size, (*nc)->header.param_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_check_allowed_host()

INT rpc_check_allowed_host

(

const char *

hostname

)

Definition at line 15231 of file midas.cxx.

{
   //printf("rpc_check_allowed_host: enabled %d, hostname [%s]\n", gAllowedHostsEnabled.load(), hostname);
 
   if (!gAllowedHostsEnabled)
      return RPC_SUCCESS;
 
   if (strcmp(hostname, "localhost") == 0)
      return RPC_SUCCESS;
   
   if (strcmp(hostname, "localhost.localdomain") == 0)
      return RPC_SUCCESS;
 
   if (strcmp(hostname, "localhost6") == 0) // RedHat el6, el7
      return RPC_SUCCESS;
 
   if (strcmp(hostname, "ip6-localhost") == 0) // Ubuntu-22
      return RPC_SUCCESS;
 
   int status = RPC_NOT_REGISTERED;
 
   gAllowedHostsMutex.lock();
 
   for (const auto& h: gAllowedHosts) {
      if (h == hostname) {
         status = RPC_SUCCESS;
         break;
      }
   }
 
   gAllowedHostsMutex.unlock();
 
   //if (status != RPC_SUCCESS)
   //   printf("rpc_check_allowed_host: enabled %d, hostname [%s] not found\n", gAllowedHostsEnabled.load(), hostname);
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_check_channels()

INT rpc_check_channels

(

void

)

Definition at line 16221 of file midas.cxx.

{
   INT status;
   NET_COMMAND nc;
   fd_set readfds;
   struct timeval timeout;
 
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++) {
      if (_server_acceptions[idx] && _server_acceptions[idx]->recv_sock) {
         RPC_SERVER_ACCEPTION* sa = _server_acceptions[idx];
         if (sa == NULL)
            continue;
         
         if (sa->watchdog_timeout == 0) {
            continue;
         }
 
         DWORD elapsed = ss_millitime() - sa->last_activity;
         //printf("rpc_check_channels: idx %d, watchdog_timeout %d, last_activity %d, elapsed %d\n", idx, sa->watchdog_timeout, sa->last_activity, elapsed);
 
         if (sa->watchdog_timeout && (elapsed > (DWORD)sa->watchdog_timeout)) {
         
            //printf("rpc_check_channels: send watchdog message to %s on %s\n", sa->prog_name.c_str(), sa->host_name.c_str());
 
            /* send a watchdog message */
            nc.header.routine_id = MSG_WATCHDOG;
            nc.header.param_size = 0;
 
            int convert_flags = sa->convert_flags;
            if (convert_flags) {
               rpc_convert_single(&nc.header.routine_id, TID_UINT32, RPC_OUTGOING, convert_flags);
               rpc_convert_single(&nc.header.param_size, TID_UINT32, RPC_OUTGOING, convert_flags);
            }
 
            /* send the header to the client */
            int i = send_tcp(sa->send_sock, (char *) &nc, sizeof(NET_COMMAND_HEADER), 0);
 
            if (i < 0) {
               cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, send_tcp() returned %d",
                      sa->prog_name.c_str(),
                      sa->host_name.c_str(),
                      sa->watchdog_timeout / 1000,
                      i);
               
               /* disconnect from experiment */
               if (rpc_is_mserver()) {
                  cm_disconnect_experiment();
                  return RPC_NET_ERROR;
               }
               
               sa->close();
               return RPC_NET_ERROR;
            }
 
            /* make some timeout checking */
            FD_ZERO(&readfds);
            FD_SET(sa->send_sock, &readfds);
            FD_SET(sa->recv_sock, &readfds);
 
            timeout.tv_sec = sa->watchdog_timeout / 1000;
            timeout.tv_usec = (sa->watchdog_timeout % 1000) * 1000;
 
            do {
               status = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
 
               /* if an alarm signal was cought, restart select with reduced timeout */
               if (status == -1 && timeout.tv_sec >= WATCHDOG_INTERVAL / 1000)
                  timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
 
            } while (status == -1);        /* dont return if an alarm signal was cought */
 
            if (!FD_ISSET(sa->send_sock, &readfds) &&
                !FD_ISSET(sa->recv_sock, &readfds)) {
 
               cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec",
                      sa->prog_name.c_str(),
                      sa->host_name.c_str(),
                      sa->watchdog_timeout / 1000);
               
               /* disconnect from experiment */
               if (rpc_is_mserver()) {
                  cm_disconnect_experiment();
                  return RPC_NET_ERROR;
               }               
 
               sa->close();
               return RPC_NET_ERROR;
            }
 
            /* receive result on send socket */
            if (FD_ISSET(sa->send_sock, &readfds)) {
               i = recv_tcp(sa->send_sock, (char *) &nc, sizeof(nc), 0);
               if (i <= 0) {
                  cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, recv_tcp() returned %d",
                         sa->prog_name.c_str(),
                         sa->host_name.c_str(),
                         sa->watchdog_timeout / 1000,
                         i);
                  
                  /* disconnect from experiment */
                  if (rpc_is_mserver()) {
                     cm_disconnect_experiment();
                     return RPC_NET_ERROR;
                  }
                  
                  sa->close();
                  return RPC_NET_ERROR;
               }
            }
         }
      }
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_clear_allowed_hosts()

INT rpc_clear_allowed_hosts

(

void

)

Definition at line 15177 of file midas.cxx.

{
   gAllowedHostsMutex.lock();
   gAllowedHosts.clear();
   gAllowedHostsEnabled = false;
   gAllowedHostsMutex.unlock();
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_accept()

INT rpc_client_accept

(

int

lsock

)

Definition at line 15565 of file midas.cxx.

{
   INT i, status;
   INT client_hw_type = 0, hw_type;
   std::string client_program;
   std::string host_name;
   INT convert_flags;
   char net_buffer[256], *p;
 
   int sock = accept(lsock, NULL, NULL);
 
   if (sock == -1)
      return RPC_NET_ERROR;
 
   /* check access control list */
   if (gAllowedHostsEnabled) {
      int status = rpc_socket_check_allowed_host(sock);
 
      if (status != RPC_SUCCESS) {
         ss_socket_close(&sock);
         return RPC_NET_ERROR;
      }
   }
 
   host_name = "(unknown)";
   client_program = "(unknown)";
 
   /* receive string with timeout */
   i = recv_string(sock, net_buffer, sizeof(net_buffer), 10000);
   if (i <= 0) {
      ss_socket_close(&sock);
      return RPC_NET_ERROR;
   }
 
   /* get remote computer info */
   p = strtok(net_buffer, " ");
   if (p != NULL) {
      client_hw_type = atoi(p);
      p = strtok(NULL, " ");
   }
   if (p != NULL) {
      //version = atoi(p);
      p = strtok(NULL, " ");
   }
   if (p != NULL) {
      client_program = p;
      p = strtok(NULL, " ");
   }
   if (p != NULL) {
      host_name = p;
      p = strtok(NULL, " ");
   }
 
   //printf("rpc_client_accept: client_hw_type %d, version %d, client_name \'%s\', hostname \'%s\'\n", client_hw_type, version, client_program, host_name);
 
   RPC_SERVER_ACCEPTION* sa = rpc_new_server_acception();
 
   /* save information in _server_acception structure */
   sa->recv_sock = sock;
   sa->send_sock = 0;
   sa->event_sock = 0;
   sa->remote_hw_type = client_hw_type;
   sa->host_name = host_name;
   sa->prog_name = client_program;
   sa->last_activity = ss_millitime();
   sa->watchdog_timeout = 0;
   sa->is_mserver = FALSE;
 
   /* send my own computer id */
   hw_type = rpc_get_hw_type();
   std::string str = msprintf("%d %s", hw_type, cm_get_version());
   status = send(sock, str.c_str(), str.length() + 1, 0);
   if (status != (INT) str.length() + 1)
      return RPC_NET_ERROR;
 
   rpc_calc_convert_flags(hw_type, client_hw_type, &convert_flags);
   sa->convert_flags = convert_flags;
 
   ss_suspend_set_server_acceptions(&_server_acceptions);
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_call()

INT rpc_client_call	(	HNDLE	hConn,
		DWORD	routine_id,
			...
	)

Definition at line 13439 of file midas.cxx.

{
   RPC_CLIENT_CONNECTION* c = rpc_get_locked_client_connection(hConn);
 
   if (!c) {
      cm_msg(MERROR, "rpc_client_call", "invalid rpc connection handle %d", hConn);
      return RPC_NO_CONNECTION;
   }
 
   //printf("rpc_client_call: handle %d, connection: ", hConn);
   //c->print();
   //printf("\n");
 
   INT i, status;
 
   BOOL rpc_no_reply = routine_id & RPC_NO_REPLY;
   routine_id &= ~RPC_NO_REPLY;
 
   //if (rpc_no_reply)
   //   printf("rpc_client_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
 
   // make local copy of the client name just in case _client_connection is erased by another thread
 
   /* find rpc_index */
 
   int rpc_index = -1;
   const char *rpc_name = NULL;
   RPC_LIST rpc_entry;
 
   rpc_list_mutex.lock();
   for (size_t i = 0; i < rpc_list.size(); i++) {
      if (rpc_list[i].id == (int) routine_id) {
         rpc_index = i;
         rpc_name = rpc_list[rpc_index].name;
         rpc_entry = rpc_list[rpc_index];
         break;
      }
   }
   rpc_list_mutex.unlock();
 
   if (rpc_index < 0) {
      cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" with invalid RPC ID %d", c->client_name.c_str(), c->host_name.c_str(), routine_id);
      c->mutex.unlock();
      return RPC_INVALID_ID;
   }
 
   NET_COMMAND *nc = NULL;
 
   /* examine variable argument list and convert it to parameter array */
   va_list ap;
   va_start(ap, routine_id);
 
   rpc_call_encode(ap, rpc_entry, &nc);
 
   va_end(ap);
 
   nc->header.routine_id = routine_id;
 
   if (rpc_no_reply)
      nc->header.routine_id |= RPC_NO_REPLY;
 
   int send_size = nc->header.param_size + sizeof(NET_COMMAND_HEADER);
 
   /* in FAST TCP mode, only send call and return immediately */
   if (rpc_no_reply) {
      i = send_tcp(c->send_sock, (char *) nc, send_size, 0);
 
      if (i != send_size) {
         cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" RPC \"%s\": send_tcp() failed", c->client_name.c_str(), c->host_name.c_str(), rpc_name);
         free(nc);
         c->mutex.unlock();
         return RPC_NET_ERROR;
      }
 
      free(nc);
 
      if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN) {
         //printf("rpc_client_call: routine_id %d is RPC_ID_EXIT %d or RPC_ID_SHUTDOWN %d, closing connection: ", routine_id, RPC_ID_EXIT, RPC_ID_SHUTDOWN);
         //c->print();
         //printf("\n");
         c->close_locked();
      }
 
      c->mutex.unlock();
      return RPC_SUCCESS;
   }
 
   /* in TCP mode, send and wait for reply on send socket */
   i = send_tcp(c->send_sock, (char *) nc, send_size, 0);
   if (i != send_size) {
      cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" RPC \"%s\": send_tcp() failed", c->client_name.c_str(), c->host_name.c_str(), rpc_name);
      c->mutex.unlock();
      return RPC_NET_ERROR;
   }
 
   free(nc);
   nc = NULL;
 
   bool restore_watchdog_timeout = false;
   BOOL watchdog_call;
   DWORD watchdog_timeout;
   cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
 
   //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, c->rpc_timeout);
 
   if (c->rpc_timeout >= (int) watchdog_timeout) {
      restore_watchdog_timeout = true;
      cm_set_watchdog_params(watchdog_call, c->rpc_timeout + 1000);
   }
 
   DWORD rpc_status = 0;
   DWORD buf_size = 0;
   char* buf = NULL;
 
   /* receive result on send socket */
   status = ss_recv_net_command(c->send_sock, &rpc_status, &buf_size, &buf, c->rpc_timeout);
 
   if (restore_watchdog_timeout) {
      cm_set_watchdog_params(watchdog_call, watchdog_timeout);
   }
 
   if (status == SS_TIMEOUT) {
      cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" RPC \"%s\": timeout waiting for reply", c->client_name.c_str(), c->host_name.c_str(), rpc_name);
      if (buf)
         free(buf);
      c->mutex.unlock();
      return RPC_TIMEOUT;
   }
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" RPC \"%s\": error, ss_recv_net_command() status %d", c->client_name.c_str(), c->host_name.c_str(), rpc_name, status);
      if (buf)
         free(buf);
      c->mutex.unlock();
      return RPC_NET_ERROR;
   }
 
   c->mutex.unlock();
 
   if (rpc_status == RPC_INVALID_ID) {
      cm_msg(MERROR, "rpc_client_call", "call to \"%s\" on \"%s\" RPC \"%s\": error, unknown RPC, status %d", c->client_name.c_str(), c->host_name.c_str(), rpc_name, rpc_status);
      if (buf)
         free(buf);
      return rpc_status;
   }
 
   /* extract result variables and place it to argument list */
 
   va_start(ap, routine_id);
 
   status = rpc_call_decode(ap, rpc_entry, buf, buf_size);
 
   if (status != RPC_SUCCESS) {
      rpc_status = status;
   }
 
   va_end(ap);
 
   if (buf)
      free(buf);
   buf = NULL;
   buf_size = 0;
 
   return rpc_status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_check()

void rpc_client_check

(

void

)

Definition at line 12237 of file midas.cxx.

{
#if 0
   for (i = 0; i < MAX_RPC_CONNECTION; i++)
      if (_client_connection[i].send_sock != 0)
         printf("slot %d, checking client %s socket %d, connected %d\n", i, _client_connection[i].client_name, _client_connection[i].send_sock, _client_connection[i].connected);
#endif
 
   std::lock_guard<std::mutex> guard(_client_connections_mutex);
 
   /* check for broken connections */
   for (unsigned i = 0; i < _client_connections.size(); i++) {
      RPC_CLIENT_CONNECTION* c = _client_connections[i];
      if (c && c->connected) {
         std::lock_guard<std::mutex> cguard(c->mutex);
 
         if (!c->connected) {
            // implicit unlock
            continue;
         }
 
         //printf("rpc_client_check: connection %d: ", i);
         //c->print();
         //printf("\n");
 
         int ok = 0;
 
         fd_set readfds;
         FD_ZERO(&readfds);
         FD_SET(c->send_sock, &readfds);
 
         struct timeval timeout;
         timeout.tv_sec = 0;
         timeout.tv_usec = 0;
 
         int status;
 
#ifdef OS_WINNT
         status = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
#else
         do {
            status = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
         } while (status == -1 && errno == EINTR); /* dont return if an alarm signal was cought */
#endif
 
         if (!FD_ISSET(c->send_sock, &readfds)) {
            // implicit unlock
            continue;
         }
 
         char buffer[64];
 
         status = recv(c->send_sock, (char *) buffer, sizeof(buffer), MSG_PEEK);
         //printf("recv %d status %d, errno %d (%s)\n", sock, status, errno, strerror(errno));
 
         if (status < 0) {
#ifndef OS_WINNT
            if (errno == EAGAIN) { // still connected
               ok = 1;
            } else
#endif
            {
               // connection error
               cm_msg(MERROR, "rpc_client_check",
                      "RPC client connection to \"%s\" on host \"%s\" is broken, recv() errno %d (%s)",
                      c->client_name.c_str(),
                      c->host_name.c_str(),
                      errno, strerror(errno));
               ok = 0;
            }
         } else if (status == 0) {
            // connection closed by remote end without sending an EXIT message
            // this can happen if the remote end has crashed, so this message
            // is still necessary as a useful diagnostic for unexpected crashes
            // of midas programs. K.O.
            cm_msg(MINFO, "rpc_client_check", "RPC client connection to \"%s\" on host \"%s\" unexpectedly closed", c->client_name.c_str(), c->host_name.c_str());
            ok = 0;
         } else {
            // read some data
            ok = 1;
            if (equal_ustring(buffer, "EXIT")) {
               /* normal exit */
               ok = 0;
            }
         }
 
         if (!ok) {
            //printf("rpc_client_check: closing connection %d: ", i);
            //c->print();
            //printf("\n");
 
            // connection lost, close the socket
            c->close_locked();
         }
 
         // implicit unlock
      }
   }
 
   // implicit unlock of _client_connections_mutex
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_connect()

INT rpc_client_connect	(	const char *	host_name,
		INT	port,
		const char *	client_name,
		HNDLE *	hConnection
	)

Definition at line 11979 of file midas.cxx.

{
   INT i, status;
   bool debug = false;
 
   /* check if cm_connect_experiment was called */
   if (_client_name.length() == 0) {
      cm_msg(MERROR, "rpc_client_connect", "cm_connect_experiment/rpc_set_name not called");
      return RPC_NOT_REGISTERED;
   }
 
   /* refuse connection to port 0 */
   if (port == 0) {
      cm_msg(MERROR, "rpc_client_connect", "invalid port %d", port);
      return RPC_NET_ERROR;
   }
 
   RPC_CLIENT_CONNECTION* c = NULL;
 
   static std::mutex gHostnameMutex;
 
   {
      std::lock_guard<std::mutex> guard(_client_connections_mutex);
 
      if (debug) {
         printf("rpc_client_connect: host \"%s\", port %d, client \"%s\"\n", host_name, port, client_name);
         for (size_t i = 0; i < _client_connections.size(); i++) {
            if (_client_connections[i]) {
               printf("client connection %d: ", (int)i);
               _client_connections[i]->print();
               printf("\n");
            }
         }
      }
 
      // slot with index 0 is not used, fill it with a NULL
      
      if (_client_connections.empty()) {
         _client_connections.push_back(NULL);
      }
 
      bool hostname_locked = false;
 
      /* check if connection already exists */
      for (size_t i = 1; i < _client_connections.size(); i++) {
         RPC_CLIENT_CONNECTION* c = _client_connections[i];
         if (c && c->connected) {
 
            if (!hostname_locked) {
               gHostnameMutex.lock();
               hostname_locked = true;
            }
 
            if ((c->host_name == host_name) && (c->port == port)) {
               // NB: we must release the hostname lock before taking
               // c->mutex to avoid a locking order inversion deadlock:
               // later on we lock the hostname mutex while holding the c->mutex
               gHostnameMutex.unlock();
               hostname_locked = false;
               std::lock_guard<std::mutex> cguard(c->mutex);
               // check if socket is still connected
               if (c->connected) {
                  // found connection slot with matching hostname and port number
                  status = ss_socket_wait(c->send_sock, 0);
                  if (status == SS_TIMEOUT) { // yes, still connected and empty
                     // so reuse it connection
                     *hConnection = c->index;
                     if (debug) {
                        printf("already connected: ");
                        c->print();
                        printf("\n");
                     }
                     // implicit unlock of c->mutex
                     // gHostnameLock is not locked here
                     return RPC_SUCCESS;
                  }
                  //cm_msg(MINFO, "rpc_client_connect", "Stale connection to \"%s\" on host %s is closed", _client_connection[i].client_name, _client_connection[i].host_name);
                  c->close_locked();
               }
               // implicit unlock of c->mutex
            }
         }
      }
 
      if (hostname_locked) {
         gHostnameMutex.unlock();
         hostname_locked = false;
      }
      
      // only start reusing connections once we have
      // a good number of slots allocated.
      if (_client_connections.size() > 10) {
         static int last_reused = 0;
 
         int size = _client_connections.size();
         for (int j = 1; j < size; j++) {
            int i = (last_reused + j) % size;
            if (_client_connections[i] && !_client_connections[i]->connected) {
               c = _client_connections[i];
               if (debug) {
                  printf("last reused %d, reusing slot %d: ", last_reused, (int)i);
                  c->print();
                  printf("\n");
               }
               last_reused = i;
               break;
            }
         }
      }
 
      // no slots to reuse, allocate a new slot.
      if (!c) {
         c = new RPC_CLIENT_CONNECTION;
 
         // if empty slot not found, add to end of array
         c->index = _client_connections.size();
         _client_connections.push_back(c);
 
         if (debug) {
            printf("new connection appended to array: ");
            c->print();
            printf("\n");
         }
      }
 
      c->mutex.lock();
      c->connected = true; // rpc_client_connect() in another thread may try to grab this slot
 
      // done with the array of connections
      // implicit unlock of _client_connections_mutex
   }
 
   // locked connection slot for new connection
   assert(c != NULL);
 
   std::string errmsg;
   
   /* create a new socket for connecting to remote server */
   status = ss_socket_connect_tcp(host_name, port, &c->send_sock, &errmsg);
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_client_connect", "cannot connect to \"%s\" port %d: %s", host_name, port, errmsg.c_str());
      c->mutex.unlock();
      return RPC_NET_ERROR;
   }
 
   gHostnameMutex.lock();
 
   c->host_name   = host_name;
   c->port        = port;
 
   gHostnameMutex.unlock();
 
   c->client_name = client_name;
   c->rpc_timeout = DEFAULT_RPC_TIMEOUT;
 
   /* set TCP_NODELAY option for better performance */
   i = 1;
   setsockopt(c->send_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &i, sizeof(i));
 
   /* send local computer info */
   std::string local_prog_name = rpc_get_name();
   std::string local_host_name = ss_gethostname();
 
   int hw_type = rpc_get_hw_type();
 
   std::string cstr = msprintf("%d %s %s %s", hw_type, cm_get_version(), local_prog_name.c_str(), local_host_name.c_str());
 
   int size = cstr.length() + 1;
   i = send(c->send_sock, cstr.c_str(), size, 0);
   if (i < 0 || i != size) {
      cm_msg(MERROR, "rpc_client_connect", "cannot send %d bytes, send() returned %d, errno %d (%s)", size, i, errno, strerror(errno));
      c->mutex.unlock();
      return RPC_NET_ERROR;
   }
 
   bool restore_watchdog_timeout = false;
   BOOL watchdog_call;
   DWORD watchdog_timeout;
   cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
 
   //printf("watchdog timeout: %d, rpc_connect_timeout: %d\n", watchdog_timeout, _rpc_connect_timeout);
 
   if (_rpc_connect_timeout >= (int) watchdog_timeout) {
      restore_watchdog_timeout = true;
      cm_set_watchdog_params(watchdog_call, _rpc_connect_timeout + 1000);
   }
 
   char str[256];
 
   /* receive remote computer info */
   i = recv_string(c->send_sock, str, sizeof(str), _rpc_connect_timeout);
 
   if (restore_watchdog_timeout) {
      cm_set_watchdog_params(watchdog_call, watchdog_timeout);
   }
 
   if (i <= 0) {
      cm_msg(MERROR, "rpc_client_connect", "timeout waiting for server reply");
      c->close_locked();
      c->mutex.unlock();
      return RPC_NET_ERROR;
   }
 
   int remote_hw_type = 0;
   char remote_version[32];
   remote_version[0] = 0;
   sscanf(str, "%d %s", &remote_hw_type, remote_version);
 
   c->remote_hw_type = remote_hw_type;
 
   /* print warning if version patch level doesn't agree */
   char v1[32];
   strlcpy(v1, remote_version, sizeof(v1));
   if (strchr(v1, '.'))
      if (strchr(strchr(v1, '.') + 1, '.'))
         *strchr(strchr(v1, '.') + 1, '.') = 0;
 
   strlcpy(str, cm_get_version(), sizeof(str));
   if (strchr(str, '.'))
      if (strchr(strchr(str, '.') + 1, '.'))
         *strchr(strchr(str, '.') + 1, '.') = 0;
 
   if (strcmp(v1, str) != 0) {
      cm_msg(MERROR, "rpc_client_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", remote_version, cm_get_version());
   }
 
   c->connected = true;
 
   *hConnection = c->index;
 
   c->mutex.unlock();
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_disconnect()

INT rpc_client_disconnect	(	HNDLE	hConn,
		BOOL	bShutdown
	)

Definition at line 12643 of file midas.cxx.

{
   /* notify server about exit */
   
   /* call exit and shutdown with RPC_NO_REPLY because client will exit immediately without possibility of replying */
   
   rpc_client_call(hConn, bShutdown ? (RPC_ID_SHUTDOWN | RPC_NO_REPLY) : (RPC_ID_EXIT | RPC_NO_REPLY));
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_client_dispatch()

INT rpc_client_dispatch

(

int

sock

)

Definition at line 11912 of file midas.cxx.

{
   INT status = 0;
   char net_buffer[256];
 
   int n = recv_tcp(sock, net_buffer, sizeof(net_buffer), 0);
   if (n <= 0)
      return SS_ABORT;
 
   NET_COMMAND *nc = (NET_COMMAND *) net_buffer;
 
   if (nc->header.routine_id == MSG_ODB) {
      status = handle_msg_odb(n, nc);
   } else if (nc->header.routine_id == MSG_WATCHDOG) {
      nc->header.routine_id = 1;
      nc->header.param_size = 0;
      send_tcp(sock, net_buffer, sizeof(NET_COMMAND_HEADER), 0);
      status = RPC_SUCCESS;
   } else if (nc->header.routine_id == MSG_BM) {
      fd_set readfds;
      struct timeval timeout;
 
      //printf("rpc_client_dispatch: received MSG_BM!\n");
 
      /* receive further messages to empty TCP queue */
      do {
         FD_ZERO(&readfds);
         FD_SET(sock, &readfds);
 
         timeout.tv_sec = 0;
         timeout.tv_usec = 0;
 
         select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
 
         if (FD_ISSET(sock, &readfds)) {
            n = recv_tcp(sock, net_buffer, sizeof(net_buffer), 0);
            if (n <= 0)
               return SS_ABORT;
 
            if (nc->header.routine_id == MSG_ODB) {
               status = handle_msg_odb(n, nc);
            } else if (nc->header.routine_id == MSG_WATCHDOG) {
               nc->header.routine_id = 1;
               nc->header.param_size = 0;
               send_tcp(sock, net_buffer, sizeof(NET_COMMAND_HEADER), 0);
               status = RPC_SUCCESS;
            }
         }
 
      } while (FD_ISSET(sock, &readfds));
 
      /* poll event from server */
      status = bm_poll_event();
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_convert_data()

void rpc_convert_data	(	void *	data,
		INT	tid,
		INT	flags,
		INT	total_size,
		INT	convert_flags
	)

Definition at line 11673 of file midas.cxx.

{
   /* convert array */
   if (flags & (RPC_FIXARRAY | RPC_VARARRAY)) {
      int single_size = rpc_tid_size(tid);
      /* don't convert TID_ARRAY & TID_STRUCT */
      if (single_size == 0)
         return;
 
      int n = total_size / single_size;
 
      for (int i = 0; i < n; i++) {
         char* p = (char *) data + (i * single_size);
         rpc_convert_single(p, tid, flags, convert_flags);
      }
   } else {
      rpc_convert_single(data, tid, flags, convert_flags);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_convert_single()

void rpc_convert_single	(	void *	data,
		INT	tid,
		INT	flags,
		INT	convert_flags
	)

Definition at line 11648 of file midas.cxx.

                                                                           {
 
   if (convert_flags & CF_ENDIAN) {
      if (tid == TID_UINT16 || tid == TID_INT16) WORD_SWAP(data);
      if (tid == TID_UINT32 || tid == TID_INT32 || tid == TID_BOOL || tid == TID_FLOAT) DWORD_SWAP(data);
      if (tid == TID_DOUBLE) QWORD_SWAP(data);
   }
 
   if (((convert_flags & CF_IEEE2VAX) && !(flags & RPC_OUTGOING)) ||
       ((convert_flags & CF_VAX2IEEE) && (flags & RPC_OUTGOING))) {
      if (tid == TID_FLOAT)
         rpc_ieee2vax_float((float *) data);
      if (tid == TID_DOUBLE)
         rpc_ieee2vax_double((double *) data);
   }
 
   if (((convert_flags & CF_IEEE2VAX) && (flags & RPC_OUTGOING)) ||
       ((convert_flags & CF_VAX2IEEE) && !(flags & RPC_OUTGOING))) {
      if (tid == TID_FLOAT)
         rpc_vax2ieee_float((float *) data);
      if (tid == TID_DOUBLE)
         rpc_vax2ieee_double((double *) data);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_debug_printf()

void rpc_debug_printf	(	const char *	format,
			...
	)

Definition at line 13128 of file midas.cxx.

{
   va_list argptr;
   char str[1000];
 
   if (_debug_mode) {
      va_start(argptr, format);
      vsprintf(str, (char *) format, argptr);
      va_end(argptr);
 
      if (_debug_print) {
         strcat(str, "\n");
         _debug_print(str);
      } else
         puts(str);
   }
}

Here is the caller graph for this function:

rpc_deregister_functions()

INT rpc_deregister_functions

(

void

)

dox

Definition at line 11837 of file midas.cxx.

{
   rpc_list_mutex.lock();
   rpc_list.clear();
   rpc_list_mutex.unlock();
 
   return RPC_SUCCESS;
}

Here is the caller graph for this function:

rpc_execute()

INT rpc_execute	(	INT	sock,
		char *	buffer,
		INT	convert_flags
	)

Definition at line 14617 of file midas.cxx.

{
   INT i, routine_id, status;
   char *in_param_ptr, *out_param_ptr, *last_param_ptr;
   INT tid, flags;
   NET_COMMAND *nc_in, *nc_out;
   INT param_size, max_size;
   void *prpc_param[20];
   char str[1024], debug_line[1024], *return_buffer;
   int return_buffer_size;
   int return_buffer_tls;
#ifdef FIXED_BUFFER
   int initial_buffer_size = NET_BUFFER_SIZE;
#else
   int initial_buffer_size = 1024;
#endif
 
   /* return buffer must must use thread local storage multi-thread servers */
   if (!tls_size) {
      tls_buffer = (TLS_POINTER *) malloc(sizeof(TLS_POINTER));
      tls_buffer[tls_size].thread_id = ss_gettid();
      tls_buffer[tls_size].buffer_size = initial_buffer_size;
      tls_buffer[tls_size].buffer = (char *) malloc(tls_buffer[tls_size].buffer_size);
      tls_size = 1;
   }
   for (i = 0; i < tls_size; i++)
      if (tls_buffer[i].thread_id == ss_gettid())
         break;
   if (i == tls_size) {
      /* new thread -> allocate new buffer */
      tls_buffer = (TLS_POINTER *) realloc(tls_buffer, (tls_size + 1) * sizeof(TLS_POINTER));
      tls_buffer[tls_size].thread_id = ss_gettid();
      tls_buffer[tls_size].buffer_size = initial_buffer_size;
      tls_buffer[tls_size].buffer = (char *) malloc(tls_buffer[tls_size].buffer_size);
      tls_size++;
   }
 
   return_buffer_tls = i;
   return_buffer_size = tls_buffer[i].buffer_size;
   return_buffer = tls_buffer[i].buffer;
   assert(return_buffer);
 
   // make valgrind happy - the RPC parameter encoder skips the alignement padding bytes
   // and valgrind complains that we transmit uninitialized data
   //memset(return_buffer, 0, return_buffer_size);
 
   /* extract pointer array to parameters */
   nc_in = (NET_COMMAND *) buffer;
 
   /* convert header format (byte swapping) */
   if (convert_flags) {
      rpc_convert_single(&nc_in->header.routine_id, TID_UINT32, 0, convert_flags);
      rpc_convert_single(&nc_in->header.param_size, TID_UINT32, 0, convert_flags);
   }
 
   //if (nc_in->header.routine_id & RPC_NO_REPLY) {
   //   printf("rpc_execute: routine_id %d, RPC_NO_REPLY\n", (int)(nc_in->header.routine_id & ~RPC_NO_REPLY));
   //}
 
   /* no result return as requested */
   if (nc_in->header.routine_id & RPC_NO_REPLY)
      sock = 0;
 
   /* find entry in rpc_list */
   routine_id = nc_in->header.routine_id & ~RPC_NO_REPLY;
 
   int idx = -1;
   RPC_LIST rl;
 
   rpc_list_mutex.lock();
 
   for (size_t i = 0; i < rpc_list.size(); i++) {
      if (rpc_list[i].id == routine_id) {
         idx = i;
         rl = rpc_list[idx];
         break;
      }
   }
 
   rpc_list_mutex.unlock();
 
   if (idx < 0) {
      cm_msg(MERROR, "rpc_execute", "Invalid rpc ID (%d)", routine_id);
      return RPC_INVALID_ID;
   }
 
   again:
 
   in_param_ptr = nc_in->param;
 
   nc_out = (NET_COMMAND *) return_buffer;
   out_param_ptr = nc_out->param;
 
   sprintf(debug_line, "%s(", rl.name);
 
   for (i = 0; rl.param[i].tid != 0; i++) {
      tid = rl.param[i].tid;
      flags = rl.param[i].flags;
 
      if (flags & RPC_IN) {
         param_size = ALIGN8(rpc_tid_size(tid));
 
         if (tid == TID_STRING || tid == TID_LINK)
            param_size = ALIGN8(1 + strlen((char *) (in_param_ptr)));
 
         if (flags & RPC_VARARRAY) {
            /* for arrays, the size is stored as a INT in front of the array */
            param_size = *((INT *) in_param_ptr);
            if (convert_flags)
               rpc_convert_single(&param_size, TID_INT32, 0, convert_flags);
            param_size = ALIGN8(param_size);
 
            in_param_ptr += ALIGN8(sizeof(INT));
         }
 
         if (tid == TID_STRUCT)
            param_size = ALIGN8(rl.param[i].n);
 
         prpc_param[i] = in_param_ptr;
 
         /* convert data format */
         if (convert_flags) {
            if (flags & RPC_VARARRAY)
               rpc_convert_data(in_param_ptr, tid, flags, param_size, convert_flags);
            else
               rpc_convert_data(in_param_ptr, tid, flags, rl.param[i].n * rpc_tid_size(tid),
                                convert_flags);
         }
 
         db_sprintf(str, in_param_ptr, param_size, 0, rl.param[i].tid);
         if (rl.param[i].tid == TID_STRING) {
            /* check for long strings (db_create_record...) */
            if (strlen(debug_line) + strlen(str) + 2 < sizeof(debug_line)) {
               strcat(debug_line, "\"");
               strcat(debug_line, str);
               strcat(debug_line, "\"");
            } else
               strcat(debug_line, "...");
         } else
            strcat(debug_line, str);
 
         in_param_ptr += param_size;
      }
 
      if (flags & RPC_OUT) {
         param_size = ALIGN8(rpc_tid_size(tid));
 
         if (flags & RPC_VARARRAY || tid == TID_STRING) {
 
            /* save maximum array length from the value of the next argument.
             * this means RPC_OUT arrays and strings should always be passed like this:
             * rpc_call(..., array_ptr, array_max_size, ...); */
 
            max_size = *((INT *) in_param_ptr);
 
            if (convert_flags)
               rpc_convert_single(&max_size, TID_INT32, 0, convert_flags);
            max_size = ALIGN8(max_size);
 
            *((INT *) out_param_ptr) = max_size;
 
            /* save space for return array length */
            out_param_ptr += ALIGN8(sizeof(INT));
 
            /* use maximum array length from input */
            param_size = max_size;
         }
 
         if (rl.param[i].tid == TID_STRUCT)
            param_size = ALIGN8(rl.param[i].n);
 
         if ((POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size > return_buffer_size) {
#ifdef FIXED_BUFFER
            cm_msg(MERROR, "rpc_execute",
                   "return parameters (%d) too large for network buffer (%d)",
                   (POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size, return_buffer_size);
 
            return RPC_EXCEED_BUFFER;
#else
            int itls;
            int new_size = (POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size + 1024;
 
#if 0
            cm_msg(MINFO, "rpc_execute",
                      "rpc_execute: return parameters (%d) too large for network buffer (%d), new buffer size (%d)",
                      (int)((POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size), return_buffer_size, new_size);
#endif
 
            itls = return_buffer_tls;
 
            tls_buffer[itls].buffer_size = new_size;
            tls_buffer[itls].buffer = (char *) realloc(tls_buffer[itls].buffer, new_size);
 
            if (!tls_buffer[itls].buffer) {
               cm_msg(MERROR, "rpc_execute", "Cannot allocate return buffer of size %d", new_size);
               return RPC_EXCEED_BUFFER;
            }
 
            return_buffer_size = tls_buffer[itls].buffer_size;
            return_buffer = tls_buffer[itls].buffer;
            assert(return_buffer);
 
            goto again;
#endif
         }
 
         /* if parameter goes both directions, copy input to output */
         if (rl.param[i].flags & RPC_IN)
            memcpy(out_param_ptr, prpc_param[i], param_size);
 
         if (_debug_print && !(flags & RPC_IN))
            strcat(debug_line, "-");
 
         prpc_param[i] = out_param_ptr;
         out_param_ptr += param_size;
      }
 
      if (rl.param[i + 1].tid)
         strcat(debug_line, ", ");
   }
 
   //printf("predicted return size %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out);
 
   strcat(debug_line, ")");
   rpc_debug_printf(debug_line);
 
   last_param_ptr = out_param_ptr;
 
   /*********************************\
   *   call dispatch function        *
   \*********************************/
   if (rl.dispatch)
      status = rl.dispatch(routine_id, prpc_param);
   else
      status = RPC_INVALID_ID;
 
   if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN || routine_id == RPC_ID_WATCHDOG)
      status = RPC_SUCCESS;
 
   /* return immediately for closed down client connections */
   if (!sock && routine_id == RPC_ID_EXIT)
      return SS_EXIT;
 
   if (!sock && routine_id == RPC_ID_SHUTDOWN)
      return RPC_SHUTDOWN;
 
   /* Return if TCP connection broken */
   if (status == SS_ABORT)
      return SS_ABORT;
 
   /* if sock == 0, we are in FTCP mode and may not sent results */
   if (!sock)
      return RPC_SUCCESS;
 
   /* compress variable length arrays */
   out_param_ptr = nc_out->param;
   for (i = 0; rl.param[i].tid != 0; i++)
      if (rl.param[i].flags & RPC_OUT) {
         tid = rl.param[i].tid;
         flags = rl.param[i].flags;
         param_size = ALIGN8(rpc_tid_size(tid));
 
         if (tid == TID_STRING) {
            max_size = *((INT *) out_param_ptr);
            // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
            // and prpc_param() is now pointing to the wrong place. here we know our string data
            // starts right after max_size and we do not need to use prpc_param[] to find it. K.O.
            //const char* param_ptr = (char *) prpc_param[i];
            const char* param_ptr = ((char *) out_param_ptr) + ALIGN8(sizeof(INT));
            //printf("string param [%s] max_size %d\n", param_ptr, max_size);
            param_size = strlen(param_ptr) + 1;
            param_size = ALIGN8(param_size);
 
            /* move string ALIGN8(sizeof(INT)) left */
            memmove(out_param_ptr, out_param_ptr + ALIGN8(sizeof(INT)), param_size);
 
            /* move remaining parameters to end of string */
            memmove(out_param_ptr + param_size,
                    out_param_ptr + max_size + ALIGN8(sizeof(INT)),
                    (POINTER_T) last_param_ptr - ((POINTER_T) out_param_ptr + max_size + ALIGN8(sizeof(INT))));
         }
 
         if (flags & RPC_VARARRAY) {
            /* store array length at current out_param_ptr */
            max_size = *((INT *) out_param_ptr);
            // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
            // and prpc_param() is now pointing to the wrong place. instead, compute location
            // of next parameter using max_size. K.O.
            // note: RPC_IN parameters are in the input buffer and we must use the prpc_param[] pointer. K.O.
            if (rl.param[i+1].flags & RPC_OUT)
               param_size = *((INT *) (out_param_ptr + ALIGN8(sizeof(INT)) + ALIGN8(max_size)));
            else
               param_size = *((INT *) prpc_param[i + 1]);
            *((INT *) out_param_ptr) = param_size;      // store new array size
            if (convert_flags)
               rpc_convert_single(out_param_ptr, TID_INT32, RPC_OUTGOING, convert_flags);
 
            out_param_ptr += ALIGN8(sizeof(INT));       // step over array size
 
            param_size = ALIGN8(param_size);
 
            /* move remaining parameters to end of array */
            memmove(out_param_ptr + param_size,
                    out_param_ptr + max_size,
                    (POINTER_T) last_param_ptr - ((POINTER_T) out_param_ptr + max_size));
         }
 
         if (tid == TID_STRUCT)
            param_size = ALIGN8(rl.param[i].n);
 
         /* convert data format */
         if (convert_flags) {
            if (flags & RPC_VARARRAY)
               rpc_convert_data(out_param_ptr, tid,
                                rl.param[i].flags | RPC_OUTGOING, param_size, convert_flags);
            else
               rpc_convert_data(out_param_ptr, tid,
                                rl.param[i].flags | RPC_OUTGOING,
                                rl.param[i].n * rpc_tid_size(tid), convert_flags);
         }
 
         out_param_ptr += param_size;
      }
 
   /* send return parameters */
   param_size = (POINTER_T) out_param_ptr - (POINTER_T) nc_out->param;
   nc_out->header.routine_id = status;
   nc_out->header.param_size = param_size;
 
   //printf("actual return size %d, buffer used %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out, sizeof(NET_COMMAND_HEADER) + param_size);
 
   /* convert header format (byte swapping) if necessary */
   if (convert_flags) {
      rpc_convert_single(&nc_out->header.routine_id, TID_UINT32, RPC_OUTGOING, convert_flags);
      rpc_convert_single(&nc_out->header.param_size, TID_UINT32, RPC_OUTGOING, convert_flags);
   }
 
   // valgrind complains about sending uninitialized data, if you care about this, uncomment
   // the memset(return_buffer,0) call above (search for "valgrind"). K.O.
 
   status = send_tcp(sock, return_buffer, sizeof(NET_COMMAND_HEADER) + param_size, 0);
 
   if (status < 0) {
      cm_msg(MERROR, "rpc_execute", "send_tcp() failed");
      return RPC_NET_ERROR;
   }
 
   /* print return buffer */
/*
  printf("Return buffer, ID %d:\n", routine_id);
  for (i=0; i<param_size ; i++)
    {
    status = (char) nc_out->param[i];
    printf("%02X ", status);
    if (i%8 == 7)
      printf("\n");
    }
*/
   /* return SS_EXIT if RPC_EXIT is called */
   if (routine_id == RPC_ID_EXIT)
      return SS_EXIT;
 
   /* return SS_SHUTDOWN if RPC_SHUTDOWN is called */
   if (routine_id == RPC_ID_SHUTDOWN)
      return RPC_SHUTDOWN;
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_flush_event()

INT rpc_flush_event

(

void

)

Send event residing in the TCP cache buffer filled by rpc_send_event. This routine should be called when a run is stopped.

Returns

RPC_SUCCESS, RPC_NET_ERROR

Definition at line 14005 of file midas.cxx.

                      {
   return RPC_SUCCESS;
}

Here is the caller graph for this function:

rpc_flush_event_socket()

int rpc_flush_event_socket

(

int

timeout_msec

)

Definition at line 16103 of file midas.cxx.

{
   bool has_data = ss_event_socket_has_data();
   
   //printf("ss_event_socket_has_data() returned %d\n", has_data);
 
   if (has_data) {
      if (timeout_msec == BM_NO_WAIT) {
         return BM_ASYNC_RETURN;
      } else if (timeout_msec == BM_WAIT) {
         return BM_ASYNC_RETURN;
      } else {
         int status = ss_suspend(timeout_msec, MSG_BM);
         if (status == SS_ABORT || status == SS_EXIT)
            return status;
         return BM_ASYNC_RETURN;
      }
   }
 
   int status = rpc_server_receive_event(0, NULL, timeout_msec);
   
   //printf("rpc_server_receive_event() status %d\n", status);
 
   if (status == BM_ASYNC_RETURN) {
      return BM_ASYNC_RETURN;
   }
 
   if (status == SS_ABORT || status == SS_EXIT)
      return status;
   
   return BM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_get_convert_flags() [1/2]

void rpc_get_convert_flags

(

INT *

convert_flags

)

Definition at line 11573 of file midas.cxx.

                                               {
   rpc_calc_convert_flags(rpc_get_hw_type(), _server_connection.remote_hw_type, convert_flags);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_get_convert_flags() [2/2]

INT rpc_get_convert_flags

(

void

)

dox

Definition at line 12997 of file midas.cxx.

{
   if (_mserver_acception)
      return _mserver_acception->convert_flags;
   else
      return 0;
}

rpc_get_hw_type()

INT rpc_get_hw_type

(

)

Definition at line 12801 of file midas.cxx.

{
   {
      {
         INT tmp_type, size;
         DWORD dummy;
         unsigned char *p;
         float f;
         double d;
 
         tmp_type = 0;
 
         /* test pointer size */
         size = sizeof(p);
         if (size == 2)
            tmp_type |= DRI_16;
         if (size == 4)
            tmp_type |= DRI_32;
         if (size == 8)
            tmp_type |= DRI_64;
 
         /* test if little or big endian machine */
         dummy = 0x12345678;
         p = (unsigned char *) &dummy;
         if (*p == 0x78)
            tmp_type |= DRI_LITTLE_ENDIAN;
         else if (*p == 0x12)
            tmp_type |= DRI_BIG_ENDIAN;
         else
            cm_msg(MERROR, "rpc_get_option", "unknown byte order format");
 
         /* floating point format */
         f = (float) 1.2345;
         dummy = 0;
         memcpy(&dummy, &f, sizeof(f));
         if ((dummy & 0xFF) == 0x19 &&
             ((dummy >> 8) & 0xFF) == 0x04 && ((dummy >> 16) & 0xFF) == 0x9E
             && ((dummy >> 24) & 0xFF) == 0x3F)
            tmp_type |= DRF_IEEE;
         else if ((dummy & 0xFF) == 0x9E &&
                  ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x19
                  && ((dummy >> 24) & 0xFF) == 0x04)
            tmp_type |= DRF_G_FLOAT;
         else
            cm_msg(MERROR, "rpc_get_option", "unknown floating point format");
 
         d = (double) 1.2345;
         dummy = 0;
         memcpy(&dummy, &d, sizeof(f));
         if ((dummy & 0xFF) == 0x8D &&  /* little endian */
             ((dummy >> 8) & 0xFF) == 0x97 && ((dummy >> 16) & 0xFF) == 0x6E
             && ((dummy >> 24) & 0xFF) == 0x12)
            tmp_type |= DRF_IEEE;
         else if ((dummy & 0xFF) == 0x83 &&     /* big endian */
                  ((dummy >> 8) & 0xFF) == 0xC0 && ((dummy >> 16) & 0xFF) == 0xF3
                  && ((dummy >> 24) & 0xFF) == 0x3F)
            tmp_type |= DRF_IEEE;
         else if ((dummy & 0xFF) == 0x13 &&
                  ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x83
                  && ((dummy >> 24) & 0xFF) == 0xC0)
            tmp_type |= DRF_G_FLOAT;
         else if ((dummy & 0xFF) == 0x9E &&
                  ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x18
                  && ((dummy >> 24) & 0xFF) == 0x04)
            cm_msg(MERROR, "rpc_get_option",
                   "MIDAS cannot handle VAX D FLOAT format. Please compile with the /g_float flag");
         else
            cm_msg(MERROR, "rpc_get_option", "unknown floating point format");
 
         return tmp_type;
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_get_locked_client_connection()

static RPC_CLIENT_CONNECTION* rpc_get_locked_client_connection ( HNDLE  hConn )

static

Definition at line 12579 of file midas.cxx.

{
   _client_connections_mutex.lock();
   if (hConn >= 0 && hConn < (int)_client_connections.size()) {
      RPC_CLIENT_CONNECTION* c = _client_connections[hConn];
      if (c && c->connected) {
         _client_connections_mutex.unlock();
         c->mutex.lock();
         if (!c->connected) {
            // disconnected while we were waiting for the lock
            c->mutex.unlock();
            return NULL;
         }
         return c;
      }
   }
   _client_connections_mutex.unlock();
   return NULL;
}

Here is the caller graph for this function:

rpc_get_mserver_acception()

RPC_SERVER_ACCEPTION* rpc_get_mserver_acception

(

void

)

Definition at line 11480 of file midas.cxx.

{
   return _mserver_acception;
}

Here is the caller graph for this function:

rpc_get_mserver_hostname()

std::string rpc_get_mserver_hostname

(

void

)

Definition at line 12772 of file midas.cxx.

{
   return _server_connection.host_name;
}

Here is the caller graph for this function:

rpc_get_mserver_path()

const char* rpc_get_mserver_path

(

void

)

Definition at line 13018 of file midas.cxx.

{
   return _mserver_path.c_str();
}

Here is the caller graph for this function:

rpc_get_name()

std::string rpc_get_name

(

)

Definition at line 13051 of file midas.cxx.

{
   return _client_name;
}

Here is the caller graph for this function:

rpc_get_opt_tcp_size()

INT rpc_get_opt_tcp_size

(

void

)

Definition at line 13839 of file midas.cxx.

                           {
   return _opt_tcp_size;
}

rpc_get_server_acception()

static RPC_SERVER_ACCEPTION* rpc_get_server_acception ( int  idx )

static

Definition at line 11472 of file midas.cxx.

{
   assert(idx >= 0);
   assert(idx < (int)_server_acceptions.size());
   assert(_server_acceptions[idx] != NULL);
   return _server_acceptions[idx];
}

Here is the caller graph for this function:

rpc_get_timeout()

INT rpc_get_timeout

(

HNDLE

hConn

)

dox Set RPC option

Parameters

hConn	RPC connection handle, -1 for server connection, -2 for rpc connect timeout
item	One of RPC_Oxxx
value	Value to set

Returns

RPC_SUCCESS Get RPC timeout

Parameters

hConn

RPC connection handle, RPC_HNDLE_MSERVER for mserver connection, RPC_HNDLE_CONNECT for rpc connect timeout

Returns

timeout value

Definition at line 12940 of file midas.cxx.

{
   if (hConn == RPC_HNDLE_MSERVER) {
      return _server_connection.rpc_timeout;
   } else if (hConn == RPC_HNDLE_CONNECT) {
      return _rpc_connect_timeout;
   } else {
      RPC_CLIENT_CONNECTION* c = rpc_get_locked_client_connection(hConn);
      if (c) {
         int timeout = c->rpc_timeout;
         c->mutex.unlock();
         return timeout;
      }
   }
   return 0;
}

Here is the call graph for this function:

rpc_ieee2vax_double()

void rpc_ieee2vax_double

(

double *

var

)

Definition at line 11628 of file midas.cxx.

                                      {
   unsigned short int i1, i2, i3, i4;
 
   /* swap words */
   i1 = *((short int *) (var) + 3);
   i2 = *((short int *) (var) + 2);
   i3 = *((short int *) (var) + 1);
   i4 = *((short int *) (var));
 
   /* correct exponent */
   if (i1 != 0)
      i1 += 0x20;
 
   *((short int *) (var) + 3) = i4;
   *((short int *) (var) + 2) = i3;
   *((short int *) (var) + 1) = i2;
   *((short int *) (var)) = i1;
}

Here is the caller graph for this function:

rpc_ieee2vax_float()

void rpc_ieee2vax_float

(

float *

var

)

Definition at line 11578 of file midas.cxx.

                                    {
   unsigned short int lo, hi;
 
   /* swap hi and lo word */
   lo = *((short int *) (var) + 1);
   hi = *((short int *) (var));
 
   /* correct exponent */
   if (lo != 0)
      lo += 0x100;
 
   *((short int *) (var) + 1) = hi;
   *((short int *) (var)) = lo;
}

Here is the caller graph for this function:

rpc_is_connected()

bool rpc_is_connected

(

void

)

Definition at line 12750 of file midas.cxx.

{
   return _server_connection.send_sock != 0;
}

Here is the caller graph for this function:

rpc_is_mserver()

bool rpc_is_mserver

(

void

)

Definition at line 12785 of file midas.cxx.

{
   return _mserver_acception != NULL;
}

Here is the caller graph for this function:

rpc_is_remote()

bool rpc_is_remote

(

void

)

Definition at line 12728 of file midas.cxx.

{
   return _rpc_is_remote;
}

rpc_name_tid()

int rpc_name_tid

(

const char *

name

)

Definition at line 11745 of file midas.cxx.

{
   for (int i=0; i<TID_LAST; i++) {
      if (strcmp(name, tid_name[i]) == 0)
         return i;
   }
 
   for (int i=0; i<TID_LAST; i++) {
      if (strcmp(name, tid_name_old[i]) == 0)
         return i;
   }
 
   return 0;
}

Here is the caller graph for this function:

rpc_new_server_acception()

static RPC_SERVER_ACCEPTION* rpc_new_server_acception ( )

static

Definition at line 11485 of file midas.cxx.

{
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++) {
      if (_server_acceptions[idx] && (_server_acceptions[idx]->recv_sock == 0)) {
         //printf("rpc_new_server_acception: reuse acception in slot %d\n", idx);
         return _server_acceptions[idx];
      }
   }
 
   RPC_SERVER_ACCEPTION* sa = new RPC_SERVER_ACCEPTION;
 
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++) {
      if (_server_acceptions[idx] == NULL) {
         //printf("rpc_new_server_acception: new acception, reuse slot %d\n", idx);
         _server_acceptions[idx] = sa;
         return _server_acceptions[idx];
      }
   }
 
   //printf("rpc_new_server_acception: new acception, array size %d, push_back\n", (int)_server_acceptions.size());
   _server_acceptions.push_back(sa);
   
   return sa;
}

Here is the caller graph for this function:

rpc_register_client()

INT rpc_register_client	(	const char *	name,
		RPC_LIST *	list
	)

Register RPC client for standalone mode (without standard midas server)

Parameters

list	Array of RPC_LIST structures containing function IDs and parameter definitions. The end of the list must be indicated by a function ID of zero.
name	Name of this client

Returns

RPC_SUCCESS

Definition at line 11775 of file midas.cxx.

                                                          {
   rpc_set_name(name);
   rpc_register_functions(rpc_get_internal_list(0), NULL);
   rpc_register_functions(list, NULL);
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_register_function()

INT rpc_register_function	(	INT	id,
		INT(*)(INT, void **)	func
	)

Definition at line 11864 of file midas.cxx.

{
   std::lock_guard<std::mutex> guard(rpc_list_mutex);
 
   for (size_t i = 0; i < rpc_list.size(); i++) {
      if (rpc_list[i].id == id) {
         rpc_list[i].dispatch = func;
         return RPC_SUCCESS;
      }
   }
 
   return RPC_INVALID_ID;
}

Here is the caller graph for this function:

rpc_register_functions()

INT rpc_register_functions	(	const RPC_LIST *	new_list,
		RPC_HANDLER	func
	)

Register a set of RPC functions (both as clients or servers)

Parameters

new_list	Array of RPC_LIST structures containing function IDs and parameter definitions. The end of the list must be indicated by a function ID of zero.
func	Default dispatch function

Returns

RPC_SUCCESS, RPC_NO_MEMORY, RPC_DOUBLE_DEFINED

Definition at line 11794 of file midas.cxx.

{
   for (int i = 0; new_list[i].id != 0; i++) {
      /* check valid ID for user functions */
      if (new_list != rpc_get_internal_list(0) &&
          new_list != rpc_get_internal_list(1) && (new_list[i].id < RPC_MIN_ID
                                                   || new_list[i].id > RPC_MAX_ID)) {
         cm_msg(MERROR, "rpc_register_functions", "registered RPC function with invalid ID %d", new_list[i].id);
      }
   }
 
   std::lock_guard<std::mutex> guard(rpc_list_mutex);
 
   /* check double defined functions */
   for (int i = 0; new_list[i].id != 0; i++) {
      for (size_t j = 0; j < rpc_list.size(); j++) {
         if (rpc_list[j].id == new_list[i].id) {
            return RPC_DOUBLE_DEFINED;
         }
      }
   }
 
   /* append new functions */
   for (int i = 0; new_list[i].id != 0; i++) {
      RPC_LIST e = new_list[i];
 
      /* set default dispatcher */
      if (e.dispatch == NULL) {
         e.dispatch = func;
      }
 
      rpc_list.push_back(e);
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_register_listener()

INT rpc_register_listener	(	int	port,
		RPC_HANDLER	func,
		int *	plsock,
		int *	pport
	)

Definition at line 14546 of file midas.cxx.

{
   /* register system functions: RPC_ID_EXIT, RPC_ID_SHUTDOWN, RPC_ID_WATCHDOG */
   rpc_register_functions(rpc_get_internal_list(0), func);
 
   /* create a socket for listening */
   int lsock = 0;
   int lport = 0;
   std::string errmsg;
 
   int status = ss_socket_listen_tcp(!disable_bind_rpc_to_localhost, port, &lsock, &lport, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_register_server", "cannot listen to tcp port %d: %s", port, errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   /* set close-on-exec flag to prevent child mserver processes from inheriting the listen socket */
#if defined(F_SETFD) && defined(FD_CLOEXEC)
   status = fcntl(lsock, F_SETFD, fcntl(lsock, F_GETFD) | FD_CLOEXEC);
   if (status < 0) {
      cm_msg(MERROR, "rpc_register_server", "fcntl(F_SETFD, FD_CLOEXEC) failed, errno %d (%s)", errno, strerror(errno));
      return RPC_NET_ERROR;
   }
#endif
 
   /* return port wich OS has choosen */
   if (pport) {
      *pport = lport;
   }
 
   if (plsock)
      *plsock = lsock;
 
   //printf("rpc_register_server: requested port %d, actual port %d, socket %d\n", port, *pport, *plsock);
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_register_server()

INT rpc_register_server	(	int	port,
		int *	plsock,
		int *	pport
	)

Definition at line 14505 of file midas.cxx.

{
   int status;
   int lsock;
 
   status = rpc_register_listener(port, NULL, &lsock, pport);
   if (status != RPC_SUCCESS)
      return status;
 
   status = ss_suspend_set_client_listener(lsock);
   if (status != SS_SUCCESS)
      return status;
 
   if (plsock)
      *plsock = lsock;
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_send_event()

INT rpc_send_event	(	INT	buffer_handle,
		const EVENT_HEADER *	pevent,
		int	unused,
		INT	async_flag,
		INT	mode
	)

dox Fast send_event routine which bypasses the RPC layer and sends the event directly at the TCP level.

Parameters

buffer_handle	Handle of the buffer to send the event to. Must be obtained via bm_open_buffer.
source	Address of the event to send. It must have a proper event header.
buf_size	Size of event in bytes with header.
async_flag	BM_WAIT / BM_NO_WAIT flag. In BM_NO_WAIT mode, the function returns immediately if it cannot send the event over the network. In BM_WAIT mode, it waits until the packet is sent (blocking).
mode	Determines in which mode the event is sent. If zero, use RPC socket, if one, use special event socket to bypass RPC layer on the server side.

Returns

BM_INVALID_PARAM, BM_ASYNC_RETURN, RPC_SUCCESS, RPC_NET_ERROR, RPC_NO_CONNECTION, RPC_EXCEED_BUFFER

Definition at line 13868 of file midas.cxx.

{
   if (rpc_is_remote()) {
      return rpc_send_event1(buffer_handle, pevent);
   } else {
      return bm_send_event(buffer_handle, pevent, unused, async_flag);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_send_event1()

INT rpc_send_event1	(	INT	buffer_handle,
		const EVENT_HEADER *	pevent
	)

Send event to mserver using the event socket connection, bypassing the RPC layer

Parameters

buffer_handle	Handle of the buffer to send the event to. Must be obtained via bm_open_buffer.
event	Pointer to event header

Returns

RPC_SUCCESS, RPC_NET_ERROR, RPC_NO_CONNECTION

Definition at line 13886 of file midas.cxx.

{
   const size_t event_size = sizeof(EVENT_HEADER) + pevent->data_size;
   return rpc_send_event_sg(buffer_handle, 1, (char**)&pevent, &event_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_send_event_sg()

INT rpc_send_event_sg	(	INT	buffer_handle,
		int	sg_n,
		const char *const	sg_ptr[],
		const size_t	sg_len[]
	)

Definition at line 13892 of file midas.cxx.

{
   if (sg_n < 1) {
      cm_msg(MERROR, "rpc_send_event_sg", "invalid sg_n %d", sg_n);
      return BM_INVALID_SIZE;
   }
 
   if (sg_ptr[0] == NULL) {
      cm_msg(MERROR, "rpc_send_event_sg", "invalid sg_ptr[0] is NULL");
      return BM_INVALID_SIZE;
   }
 
   if (sg_len[0] < sizeof(EVENT_HEADER)) {
      cm_msg(MERROR, "rpc_send_event_sg", "invalid sg_len[0] value %d is smaller than event header size %d", (int)sg_len[0], (int)sizeof(EVENT_HEADER));
      return BM_INVALID_SIZE;
   }
 
   const EVENT_HEADER* pevent = (const EVENT_HEADER*)sg_ptr[0];
   
   const DWORD MAX_DATA_SIZE = (0x7FFFFFF0 - 16); // event size computations are not 32-bit clean, limit event size to 2GB. K.O.
   const DWORD data_size = pevent->data_size; // 32-bit unsigned value
 
   if (data_size == 0) {
      cm_msg(MERROR, "rpc_send_event_sg", "invalid event data size zero");
      return BM_INVALID_SIZE;
   }
 
   if (data_size > MAX_DATA_SIZE) {
      cm_msg(MERROR, "rpc_send_event_sg", "invalid event data size %d (0x%x) maximum is %d (0x%x)", data_size, data_size, MAX_DATA_SIZE, MAX_DATA_SIZE);
      return BM_INVALID_SIZE;
   }
 
   const size_t event_size = sizeof(EVENT_HEADER) + data_size;
   const size_t total_size = ALIGN8(event_size);
 
   size_t count = 0;
   for (int i=0; i<sg_n; i++) {
      count += sg_len[i];
   }
 
   if (count != event_size) {
      cm_msg(MERROR, "rpc_send_event_sg", "data size mismatch: event data_size %d, event_size %d not same as sum of sg_len %d", (int)data_size, (int)event_size, (int)count);
      return BM_INVALID_SIZE;
   }
 
   // protect non-atomic access to _server_connection.event_sock. K.O.
   
   std::lock_guard<std::mutex> guard(_server_connection.event_sock_mutex);
 
   //printf("rpc_send_event_sg: pevent %p, event_id 0x%04x, serial 0x%08x, data_size %d, event_size %d, total_size %d\n", pevent, pevent->event_id, pevent->serial_number, (int)data_size, (int)event_size, (int)total_size);
 
   if (_server_connection.event_sock == 0) {
      return RPC_NO_CONNECTION;
   }
 
   //
   // event socket wire protocol: (see also rpc_server_receive_event() and recv_event_server_realloc())
   //
   // 4 bytes of buffer handle
   // 16 bytes of event header, includes data_size
   // ALIGN8(data_size) bytes of event data
   // 
 
   int status;
 
   /* send buffer handle */
 
   assert(sizeof(DWORD) == 4);
   DWORD bh_buf = buffer_handle;
   
   status = ss_write_tcp(_server_connection.event_sock, (const char *) &bh_buf, sizeof(DWORD));
   if (status != SS_SUCCESS) {
      ss_socket_close(&_server_connection.event_sock);
      cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(buffer handle) failed, event socket is now closed");
      return RPC_NET_ERROR;
   }
 
   /* send data */
 
   for (int i=0; i<sg_n; i++) {
      status = ss_write_tcp(_server_connection.event_sock, sg_ptr[i], sg_len[i]);
      if (status != SS_SUCCESS) {
         ss_socket_close(&_server_connection.event_sock);
         cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(event data) failed, event socket is now closed");
         return RPC_NET_ERROR;
      }
   }
 
   /* send padding */
 
   if (count < total_size) {
      char padding[8] = { 0,0,0,0,0,0,0,0 };
      size_t padlen = total_size - count;
      assert(padlen < 8);
      status = ss_write_tcp(_server_connection.event_sock, padding, padlen);
      if (status != SS_SUCCESS) {
         ss_socket_close(&_server_connection.event_sock);
         cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(padding) failed, event socket is now closed");
         return RPC_NET_ERROR;
      }
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_accept()

INT rpc_server_accept

(

int

lsock

)

Definition at line 15308 of file midas.cxx.

{
   INT i;
   INT sock;
   char version[NAME_LENGTH], v1[32];
   char experiment[NAME_LENGTH];
   INT port1, port2, port3;
   char *ptr;
   char net_buffer[256];
   struct linger ling;
 
   static struct callback_addr callback;
 
   if (lsock > 0) {
      sock = accept(lsock, NULL, NULL);
 
      if (sock == -1)
         return RPC_NET_ERROR;
   } else {
      /* lsock is stdin -> already connected from inetd */
 
      sock = lsock;
   }
 
   /* check access control list */
   if (gAllowedHostsEnabled) {
      int status = rpc_socket_check_allowed_host(sock);
 
      if (status != RPC_SUCCESS) {
         ss_socket_close(&sock);
         return RPC_NET_ERROR;
      }
   }
 
   /* receive string with timeout */
   i = recv_string(sock, net_buffer, 256, 10000);
   rpc_debug_printf("Received command: %s", net_buffer);
 
   if (i > 0) {
      char command = (char) toupper(net_buffer[0]);
 
      //printf("rpc_server_accept: command [%c]\n", command);
 
      switch (command) {
         case 'S': {
 
            /*----------- shutdown listener ----------------------*/
            ss_socket_close(&sock);
            return RPC_SHUTDOWN;
         }
         case 'I': {
 
            /*----------- return available experiments -----------*/
#ifdef LOCAL_ROUTINES
            exptab_struct exptab;
            cm_read_exptab(&exptab); // thread safe!
            for (unsigned i=0; i<exptab.exptab.size(); i++) {
               rpc_debug_printf("Return experiment: %s", exptab.exptab[i].name.c_str());
               const char* str = exptab.exptab[i].name.c_str();
               send(sock, str, strlen(str) + 1, 0);
            }
            send(sock, "", 1, 0);
#endif
            ss_socket_close(&sock);
            break;
         }
         case 'C': {
 
            /*----------- connect to experiment -----------*/
 
            /* get callback information */
            callback.experiment[0] = 0;
            port1 = port2 = version[0] = 0;
 
            //printf("rpc_server_accept: net buffer \'%s\'\n", net_buffer);
 
            /* parse string in format "C port1 port2 port3 version expt" */
            /* example: C 51046 45838 56832 2.0.0 alpha */
 
            port1 = strtoul(net_buffer + 2, &ptr, 0);
            port2 = strtoul(ptr, &ptr, 0);
            port3 = strtoul(ptr, &ptr, 0);
 
            while (*ptr == ' ')
               ptr++;
 
            i = 0;
            for (; *ptr != 0 && *ptr != ' ' && i < (int) sizeof(version) - 1;)
               version[i++] = *ptr++;
 
            // ensure that we do not overwrite buffer "version"
            assert(i < (int) sizeof(version));
            version[i] = 0;
 
            // skip wjatever is left from the "version" string
            for (; *ptr != 0 && *ptr != ' ';)
               ptr++;
 
            while (*ptr == ' ')
               ptr++;
 
            i = 0;
            for (; *ptr != 0 && *ptr != ' ' && *ptr != '\n' && *ptr != '\r' && i < (int) sizeof(experiment) - 1;)
               experiment[i++] = *ptr++;
 
            // ensure that we do not overwrite buffer "experiment"
            assert(i < (int) sizeof(experiment));
            experiment[i] = 0;
 
            callback.experiment = experiment;
 
            /* print warning if version patch level doesn't agree */
            strlcpy(v1, version, sizeof(v1));
            if (strchr(v1, '.'))
               if (strchr(strchr(v1, '.') + 1, '.'))
                  *strchr(strchr(v1, '.') + 1, '.') = 0;
 
            char str[100];
            strlcpy(str, cm_get_version(), sizeof(str));
            if (strchr(str, '.'))
               if (strchr(strchr(str, '.') + 1, '.'))
                  *strchr(strchr(str, '.') + 1, '.') = 0;
 
            if (strcmp(v1, str) != 0) {
               cm_msg(MERROR, "rpc_server_accept", "client MIDAS version %s differs from local version %s", version, cm_get_version());
               cm_msg(MERROR, "rpc_server_accept", "received string: %s", net_buffer + 2);
            }
 
            callback.host_port1 = (short) port1;
            callback.host_port2 = (short) port2;
            callback.host_port3 = (short) port3;
            callback.debug = _debug_mode;
 
            int status = ss_socket_get_peer_name(sock, &callback.host_name, NULL);
 
            if (status != SS_SUCCESS) {
               ss_socket_close(&sock);
               break;
            }
 
#ifdef LOCAL_ROUTINES
            /* update experiment definition */
            exptab_struct exptab;
            cm_read_exptab(&exptab); // thread safe!
 
            unsigned idx = 0;
            bool found = false;
            /* lookup experiment */
            if (equal_ustring(callback.experiment.c_str(), "Default")) {
               found = true;
               idx = 0;
            } else {
               for (idx = 0; idx < exptab.exptab.size(); idx++) {
                  if (exptab.exptab[idx].name == callback.experiment) {
                     if (ss_dir_exist(exptab.exptab[idx].directory.c_str())) {
                        found = true;
                        break;
                     }
                  }
               }
            }
 
            if (!found) {
               cm_msg(MERROR, "rpc_server_accept", "experiment \'%s\' not defined in exptab file \'%s\'", callback.experiment.c_str(), exptab.filename.c_str());
 
               send(sock, "2", 2, 0);   /* 2 means exp. not found */
               ss_socket_close(&sock);
               break;
            }
 
            callback.directory = exptab.exptab[idx].directory;
            callback.user = exptab.exptab[idx].user;
 
            /* create a new process */
            char host_port1_str[30], host_port2_str[30], host_port3_str[30];
            char debug_str[30];
 
            sprintf(host_port1_str, "%d", callback.host_port1);
            sprintf(host_port2_str, "%d", callback.host_port2);
            sprintf(host_port3_str, "%d", callback.host_port3);
            sprintf(debug_str, "%d", callback.debug);
 
            const char *mserver_path = rpc_get_mserver_path();
 
            const char *argv[10];
            argv[0] = mserver_path;
            argv[1] = callback.host_name.c_str();
            argv[2] = host_port1_str;
            argv[3] = host_port2_str;
            argv[4] = host_port3_str;
            argv[5] = debug_str;
            argv[6] = callback.experiment.c_str();
            argv[7] = callback.directory.c_str();
            argv[8] = callback.user.c_str();
            argv[9] = NULL;
 
            rpc_debug_printf("Spawn: %s %s %s %s %s %s %s %s %s %s",
                             argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8],
                             argv[9]);
 
            status = ss_spawnv(P_NOWAIT, mserver_path, argv);
 
            if (status != SS_SUCCESS) {
               rpc_debug_printf("Cannot spawn subprocess: %s\n", strerror(errno));
 
               sprintf(str, "3");       /* 3 means cannot spawn subprocess */
               send(sock, str, strlen(str) + 1, 0);
               ss_socket_close(&sock);
               break;
            }
 
            sprintf(str, "1 %s", cm_get_version());     /* 1 means ok */
            send(sock, str, strlen(str) + 1, 0);
#endif // LOCAL_ROUTINES
            ss_socket_close(&sock);
 
            break;
         }
         default: {
            cm_msg(MERROR, "rpc_server_accept", "received unknown command '%c' code %d", command, command);
            ss_socket_close(&sock);
            break;
         }
      }
   } else {                     /* if i>0 */
 
      /* lingering needed for PCTCP */
      ling.l_onoff = 1;
      ling.l_linger = 0;
      setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
      ss_socket_close(&sock);
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_callback()

INT rpc_server_callback

(

struct callback_addr *

pcallback

)

Definition at line 15669 of file midas.cxx.

{
   INT status;
   int recv_sock, send_sock, event_sock;
   char str[100];
   std::string client_program;
   INT client_hw_type, hw_type;
   INT convert_flags;
   char net_buffer[256];
   char *p;
   int flag;
 
   /* copy callback information */
   struct callback_addr callback = *pcallback;
   //idx = callback.index;
 
   std::string errmsg;
 
   /* create new sockets for TCP */
   status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port1, &recv_sock, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_callback", "cannot connect receive socket, host \"%s\", port %d: %s", callback.host_name.c_str(), callback.host_port1, errmsg.c_str());
      ss_socket_close(&recv_sock);
      //ss_socket_close(&send_sock);
      //ss_socket_close(&event_sock);
      return RPC_NET_ERROR;
   }
 
   status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port2, &send_sock, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_callback", "cannot connect send socket, host \"%s\", port %d: %s", callback.host_name.c_str(), callback.host_port2, errmsg.c_str());
      ss_socket_close(&recv_sock);
      ss_socket_close(&send_sock);
      //ss_socket_close(&event_sock);
      return RPC_NET_ERROR;
   }
 
   status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port3, &event_sock, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_callback", "cannot connect event socket, host \"%s\", port %d: %s", callback.host_name.c_str(), callback.host_port2, errmsg.c_str());
      ss_socket_close(&recv_sock);
      ss_socket_close(&send_sock);
      ss_socket_close(&event_sock);
      return RPC_NET_ERROR;
   }
#ifndef OS_ULTRIX               /* crashes ULTRIX... */
   /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
   flag = 2 * 1024 * 1024;
   status = setsockopt(event_sock, SOL_SOCKET, SO_RCVBUF, (char *) &flag, sizeof(INT));
   if (status != 0)
      cm_msg(MERROR, "rpc_server_callback", "cannot setsockopt(SOL_SOCKET, SO_RCVBUF), errno %d (%s)", errno,
             strerror(errno));
#endif
 
   if (recv_string(recv_sock, net_buffer, 256, _rpc_connect_timeout) <= 0) {
      cm_msg(MERROR, "rpc_server_callback", "timeout on receive remote computer info");
      ss_socket_close(&recv_sock);
      ss_socket_close(&send_sock);
      ss_socket_close(&event_sock);
      return RPC_NET_ERROR;
   }
   //printf("rpc_server_callback: \'%s\'\n", net_buffer);
 
   /* get remote computer info */
   client_hw_type = strtoul(net_buffer, &p, 0);
 
   while (*p == ' ')
      p++;
 
   client_program = p;
 
   //printf("hw type %d, name \'%s\'\n", client_hw_type, client_program);
 
   std::string host_name;
 
   status = ss_socket_get_peer_name(recv_sock, &host_name, NULL);
 
   if (status != SS_SUCCESS)
      host_name = "unknown";
 
   //printf("rpc_server_callback: mserver acception\n");
 
   RPC_SERVER_ACCEPTION* sa = rpc_new_server_acception();
 
   /* save information in _server_acception structure */
   sa->recv_sock = recv_sock;
   sa->send_sock = send_sock;
   sa->event_sock = event_sock;
   sa->remote_hw_type = client_hw_type;
   sa->host_name = host_name;
   sa->prog_name = client_program;
   sa->last_activity = ss_millitime();
   sa->watchdog_timeout = 0;
   sa->is_mserver = TRUE;
 
   assert(_mserver_acception == NULL);
 
   _mserver_acception = sa;
 
   //printf("rpc_server_callback: _mserver_acception %p\n", _mserver_acception);
 
   /* send my own computer id */
   hw_type = rpc_get_hw_type();
   sprintf(str, "%d", hw_type);
   send(recv_sock, str, strlen(str) + 1, 0);
 
   rpc_calc_convert_flags(hw_type, client_hw_type, &convert_flags);
   sa->convert_flags = convert_flags;
 
   ss_suspend_set_server_acceptions(&_server_acceptions);
 
   if (rpc_is_mserver()) {
      rpc_debug_printf("Connection to %s:%s established\n", sa->host_name.c_str(), sa->prog_name.c_str());
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_connect()

INT rpc_server_connect	(	const char *	host_name,
		const char *	exp_name
	)

Definition at line 12348 of file midas.cxx.

{
   INT i, status;
   INT remote_hw_type, hw_type;
   char str[200], version[32], v1[32];
   fd_set readfds;
   struct timeval timeout;
   int port = MIDAS_TCP_PORT;
   char *s;
 
#ifdef OS_WINNT
   {
      WSADATA WSAData;
 
      /* Start windows sockets */
      if (WSAStartup(MAKEWORD(1, 1), &WSAData) != 0)
         return RPC_NET_ERROR;
   }
#endif
 
   /* check if local connection */
   if (host_name[0] == 0)
      return RPC_SUCCESS;
 
   /* register system functions */
   rpc_register_functions(rpc_get_internal_list(0), NULL);
 
   /* check if cm_connect_experiment was called */
   if (_client_name.length() == 0) {
      cm_msg(MERROR, "rpc_server_connect", "cm_connect_experiment/rpc_set_name not called");
      return RPC_NOT_REGISTERED;
   }
 
   /* check if connection already exists */
   if (_server_connection.send_sock != 0)
      return RPC_SUCCESS;
 
   _server_connection.host_name = host_name;
   _server_connection.exp_name = exp_name;
   _server_connection.rpc_timeout = DEFAULT_RPC_TIMEOUT;
 
   bool listen_localhost = false;
 
   if (strcmp(host_name, "localhost") == 0)
      listen_localhost = true;
 
   int lsock1, lport1;
   int lsock2, lport2;
   int lsock3, lport3;
 
   std::string errmsg;
   
   status = ss_socket_listen_tcp(listen_localhost, 0, &lsock1, &lport1, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_connect", "cannot create listener socket: %s", errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   status = ss_socket_listen_tcp(listen_localhost, 0, &lsock2, &lport2, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_connect", "cannot create listener socket: %s", errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   status = ss_socket_listen_tcp(listen_localhost, 0, &lsock3, &lport3, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_connect", "cannot create listener socket: %s", errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   /* extract port number from host_name */
   strlcpy(str, host_name, sizeof(str));
   s = strchr(str, ':');
   if (s) {
      *s = 0;
      port = strtoul(s + 1, NULL, 0);
   }
 
   int sock;
 
   status = ss_socket_connect_tcp(str, port, &sock, &errmsg);
 
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "rpc_server_connect", "cannot connect to mserver on host \"%s\" port %d: %s", str, port, errmsg.c_str());
      return RPC_NET_ERROR;
   }
 
   /* connect to experiment */
   if (exp_name[0] == 0)
      sprintf(str, "C %d %d %d %s Default", lport1, lport2, lport3, cm_get_version());
   else
      sprintf(str, "C %d %d %d %s %s", lport1, lport2, lport3, cm_get_version(), exp_name);
 
   send(sock, str, strlen(str) + 1, 0);
   i = recv_string(sock, str, sizeof(str), _rpc_connect_timeout);
   ss_socket_close(&sock);
   if (i <= 0) {
      cm_msg(MERROR, "rpc_server_connect", "timeout on receive status from server");
      return RPC_NET_ERROR;
   }
 
   status = version[0] = 0;
   sscanf(str, "%d %s", &status, version);
 
   if (status == 2) {
/*  message "undefined experiment" should be displayed by application */
      return CM_UNDEF_EXP;
   }
 
   /* print warning if version patch level doesn't agree */
   strcpy(v1, version);
   if (strchr(v1, '.'))
      if (strchr(strchr(v1, '.') + 1, '.'))
         *strchr(strchr(v1, '.') + 1, '.') = 0;
 
   strcpy(str, cm_get_version());
   if (strchr(str, '.'))
      if (strchr(strchr(str, '.') + 1, '.'))
         *strchr(strchr(str, '.') + 1, '.') = 0;
 
   if (strcmp(v1, str) != 0) {
      cm_msg(MERROR, "rpc_server_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", version,
             cm_get_version());
   }
 
   /* wait for callback on send and recv socket with timeout */
   FD_ZERO(&readfds);
   FD_SET(lsock1, &readfds);
   FD_SET(lsock2, &readfds);
   FD_SET(lsock3, &readfds);
 
   timeout.tv_sec = _rpc_connect_timeout / 1000;
   timeout.tv_usec = 0;
 
   do {
      status = select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
 
      /* if an alarm signal was cought, restart select with reduced timeout */
      if (status == -1 && timeout.tv_sec >= WATCHDOG_INTERVAL / 1000)
         timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
 
   } while (status == -1);      /* dont return if an alarm signal was cought */
 
   if (!FD_ISSET(lsock1, &readfds)) {
      cm_msg(MERROR, "rpc_server_connect", "mserver subprocess could not be started (check path)");
      ss_socket_close(&lsock1);
      ss_socket_close(&lsock2);
      ss_socket_close(&lsock3);
      return RPC_NET_ERROR;
   }
 
   _server_connection.send_sock = accept(lsock1, NULL, NULL);
   _server_connection.recv_sock = accept(lsock2, NULL, NULL);
   _server_connection.event_sock = accept(lsock3, NULL, NULL);
 
   if (_server_connection.send_sock == -1 || _server_connection.recv_sock == -1 || _server_connection.event_sock == -1) {
      cm_msg(MERROR, "rpc_server_connect", "accept() failed");
      return RPC_NET_ERROR;
   }
 
   ss_socket_close(&lsock1);
   ss_socket_close(&lsock2);
   ss_socket_close(&lsock3);
 
   /* set TCP_NODELAY option for better performance */
   int flag = 1;
   setsockopt(_server_connection.send_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
   setsockopt(_server_connection.event_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
 
   /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
   flag = 2 * 1024 * 1024;
   status = setsockopt(_server_connection.event_sock, SOL_SOCKET, SO_SNDBUF, (char *) &flag, sizeof(flag));
   if (status != 0)
      cm_msg(MERROR, "rpc_server_connect", "cannot setsockopt(SOL_SOCKET, SO_SNDBUF), errno %d (%s)", errno, strerror(errno));
 
   /* send local computer info */
   std::string local_prog_name = rpc_get_name();
   hw_type = rpc_get_hw_type();
   sprintf(str, "%d %s", hw_type, local_prog_name.c_str());
 
   send(_server_connection.send_sock, str, strlen(str) + 1, 0);
 
   /* receive remote computer info */
   i = recv_string(_server_connection.send_sock, str, sizeof(str), _rpc_connect_timeout);
   if (i <= 0) {
      cm_msg(MERROR, "rpc_server_connect", "timeout on receive remote computer info");
      return RPC_NET_ERROR;
   }
 
   sscanf(str, "%d", &remote_hw_type);
   _server_connection.remote_hw_type = remote_hw_type;
 
   ss_suspend_set_client_connection(&_server_connection);
 
   _rpc_is_remote = true;
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_disconnect()

INT rpc_server_disconnect

(

void

)

Definition at line 12672 of file midas.cxx.

{
   static int rpc_server_disconnect_recursion_level = 0;
 
   if (rpc_server_disconnect_recursion_level)
      return RPC_SUCCESS;
 
   rpc_server_disconnect_recursion_level = 1;
 
   /* flush remaining events */
   rpc_flush_event();
 
   /* notify server about exit */
   if (rpc_is_connected()) {
      rpc_call(RPC_ID_EXIT);
   }
 
   /* close sockets */
   if (_server_connection.send_sock)
      ss_socket_close(&_server_connection.send_sock);
   if (_server_connection.recv_sock)
      ss_socket_close(&_server_connection.recv_sock);
   if (_server_connection.event_sock)
      ss_socket_close(&_server_connection.event_sock);
 
   _server_connection.clear();
 
   /* remove semaphore */
   if (_mutex_rpc)
      ss_mutex_delete(_mutex_rpc);
   _mutex_rpc = NULL;
 
   rpc_server_disconnect_recursion_level = 0;
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_loop()

INT rpc_server_loop

(

void

)

Definition at line 15810 of file midas.cxx.

{
   while (1) {
      int status = ss_suspend(1000, 0);
 
      if (status == SS_ABORT || status == SS_EXIT)
         break;
 
      if (rpc_check_channels() == RPC_NET_ERROR)
         break;
 
      /* check alarms, etc */
      status = cm_periodic_tasks();
 
      cm_msg_flush_buffer();
   }
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_receive_event()

INT rpc_server_receive_event	(	int	idx,
		RPC_SERVER_ACCEPTION *	sa,
		int	timeout_msec
	)

Definition at line 15948 of file midas.cxx.

{
   int status = 0;
 
   DWORD start_time = ss_millitime();
 
   //
   // THIS IS NOT THREAD SAFE!!!
   //
   // IT IS ONLY USED BY THE MSERVER
   // MSERVER IS SINGLE-THREADED!!!
   //
 
   static char *xbuf = NULL;
   static int   xbufsize = 0;
   static bool  xbufempty = true;
 
   // short cut
   if (sa == NULL && xbufempty)
      return RPC_SUCCESS;
 
   static bool  recurse = false;
 
   if (recurse) {
      cm_msg(MERROR, "rpc_server_receive_event", "internal error: called recursively");
      // do not do anything if we are called recursively
      // via recursive ss_suspend() or otherwise. K.O.
      if (xbufempty)
         return RPC_SUCCESS;
      else
         return BM_ASYNC_RETURN;
   }
 
   recurse = true;
   
   do {
      if (xbufempty && sa) {
         int n_received = recv_event_server_realloc(idx, sa, &xbuf, &xbufsize);
      
         if (n_received < 0) {
            status = SS_ABORT;
            cm_msg(MERROR, "rpc_server_receive_event", "recv_event_server_realloc() returned %d, abort", n_received);
            goto error;
         }
 
         if (n_received == 0) {
            // no more data in the tcp socket
            recurse = false;
            return RPC_SUCCESS;
         }
 
         xbufempty = false;
      }
 
      if (xbufempty) {
         // no event in xbuf buffer
         recurse = false;
         return RPC_SUCCESS;
      }
 
      /* send event to buffer */
      INT *pbh = (INT *) xbuf;
      EVENT_HEADER *pevent = (EVENT_HEADER *) (pbh + 1);
      
      status = bm_send_event(*pbh, pevent, 0, timeout_msec);
 
      //printf("rpc_server_receiv: buffer_handle %d, event_id 0x%04x, serial 0x%08x, data_size %d, status %d\n", *pbh, pevent->event_id, pevent->serial_number, pevent->data_size, status);
      
      if (status == SS_ABORT) {
         cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d (SS_ABORT), abort", status);
         goto error;
      }
      
      if (status == BM_ASYNC_RETURN) {
         //cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, event buffer is full", status);
         recurse = false;
         return status;
      }
      
      if (status != BM_SUCCESS) {
         cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, mserver dropped this event", status);
      }
      
      xbufempty = true;
 
      /* repeat for maximum 0.5 sec */
   } while (ss_millitime() - start_time < 500);
   
   recurse = false;
   return RPC_SUCCESS;
 
   error:
 
   {
      char str[80];
      strlcpy(str, sa->host_name.c_str(), sizeof(str));
      if (strchr(str, '.'))
         *strchr(str, '.') = 0;
      cm_msg(MTALK, "rpc_server_receive_event", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
   }
 
   //exit:
 
   cm_msg_flush_buffer();
 
   /* disconnect from experiment as MIDAS server */
   if (rpc_is_mserver()) {
      HNDLE hDB, hKey;
 
      cm_get_experiment_database(&hDB, &hKey);
 
      /* only disconnect from experiment if previously connected.
         Necessary for pure RPC servers (RPC_SRVR) */
      if (hDB) {
         bm_close_all_buffers();
         cm_delete_client_info(hDB, 0);
         db_close_all_databases();
 
         rpc_deregister_functions();
 
         cm_set_experiment_database(0, 0);
      }
   }
 
   bool is_mserver = sa->is_mserver;
 
   sa->close();
 
   /* signal caller a shutdonw */
   if (status == RPC_SHUTDOWN)
      return status;
 
   /* only the mserver should stop on server connection closure */
   if (!is_mserver) {
      return SS_SUCCESS;
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_receive_rpc()

INT rpc_server_receive_rpc	(	int	idx,
		RPC_SERVER_ACCEPTION *	sa
	)

Definition at line 15838 of file midas.cxx.

{
   int status = 0;
   int remaining = 0;
 
   char *buf = NULL;
   int bufsize = 0;
   
   do {
      int n_received = recv_net_command_realloc(idx, &buf, &bufsize, &remaining);
      
      if (n_received <= 0) {
         status = SS_ABORT;
         cm_msg(MERROR, "rpc_server_receive_rpc", "recv_net_command() returned %d, abort", n_received);
         goto error;
      }
      
      status = rpc_execute(sa->recv_sock, buf, sa->convert_flags);
      
      if (status == SS_ABORT) {
         cm_msg(MERROR, "rpc_server_receive_rpc", "rpc_execute() returned %d, abort", status);
         goto error;
      }
      
         if (status == SS_EXIT || status == RPC_SHUTDOWN) {
            if (rpc_is_mserver())
               rpc_debug_printf("Connection to %s:%s closed\n", sa->host_name.c_str(), sa->prog_name.c_str());
            goto exit;
         }
         
   } while (remaining);
   
   if (buf) {
      free(buf);
      buf = NULL;
      bufsize = 0;
   }
 
   return RPC_SUCCESS;
 
   error:
 
   {
      char str[80];
      strlcpy(str, sa->host_name.c_str(), sizeof(str));
      if (strchr(str, '.'))
         *strchr(str, '.') = 0;
      cm_msg(MTALK, "rpc_server_receive_rpc", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
   }
 
   exit:
 
   cm_msg_flush_buffer();
 
   if (buf) {
      free(buf);
      buf = NULL;
      bufsize = 0;
   }
 
   /* disconnect from experiment as MIDAS server */
   if (rpc_is_mserver()) {
      HNDLE hDB, hKey;
 
      cm_get_experiment_database(&hDB, &hKey);
 
      /* only disconnect from experiment if previously connected.
         Necessary for pure RPC servers (RPC_SRVR) */
      if (hDB) {
         bm_close_all_buffers();
         cm_delete_client_info(hDB, 0);
         db_close_all_databases();
 
         rpc_deregister_functions();
 
         cm_set_experiment_database(0, 0);
      }
   }
 
   bool is_mserver = sa->is_mserver;
 
   sa->close();
 
   /* signal caller a shutdonw */
   if (status == RPC_SHUTDOWN)
      return status;
 
   /* only the mserver should stop on server connection closure */
   if (!is_mserver) {
      return SS_SUCCESS;
   }
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_server_shutdown()

INT rpc_server_shutdown

(

void

)

Definition at line 16150 of file midas.cxx.

{
   //printf("rpc_server_shutdown!\n");
 
   struct linger ling;
 
   /* close all open connections */
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++) {
      if (_server_acceptions[idx] && _server_acceptions[idx]->recv_sock != 0) {
         RPC_SERVER_ACCEPTION* sa = _server_acceptions[idx];
         /* lingering needed for PCTCP */
         ling.l_onoff = 1;
         ling.l_linger = 0;
         setsockopt(sa->recv_sock, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
         ss_socket_close(&sa->recv_sock);
 
         if (sa->send_sock) {
            setsockopt(sa->send_sock, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
            ss_socket_close(&sa->send_sock);
         }
 
         if (sa->event_sock) {
            setsockopt(sa->event_sock, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
            ss_socket_close(&sa->event_sock);
         }
      }
   }
 
   /* avoid memory leak */
   for (unsigned idx = 0; idx < _server_acceptions.size(); idx++) {
      RPC_SERVER_ACCEPTION* sa = _server_acceptions[idx];
      if (sa) {
         //printf("rpc_server_shutdown: %d %p %p\n", idx, sa, _mserver_acception);
         if (sa == _mserver_acception) {
            // do not leave behind a stale pointer!
            _mserver_acception = NULL;
         }
         delete sa;
         _server_acceptions[idx] = NULL;
      }
   }
 
   if (_rpc_registered) {
      ss_socket_close(&_rpc_listen_socket);
      _rpc_registered = FALSE;
   }
 
   /* free suspend structures */
   ss_suspend_exit();
 
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_set_debug()

INT rpc_set_debug	(	void(*)(const char *)	func,
		INT	mode
	)

Definition at line 13101 of file midas.cxx.

{
   _debug_print = func;
   _debug_mode = mode;
   return RPC_SUCCESS;
}

Here is the caller graph for this function:

rpc_set_mserver_path()

INT rpc_set_mserver_path

(

const char *

path

)

Definition at line 13031 of file midas.cxx.

{
   _mserver_path = path;
   return RPC_SUCCESS;
}

Here is the caller graph for this function:

rpc_set_name()

INT rpc_set_name

(

const char *

name

)

Definition at line 13075 of file midas.cxx.

{
   _client_name = name;
 
   return RPC_SUCCESS;
}

Here is the caller graph for this function:

rpc_set_opt_tcp_size()

INT rpc_set_opt_tcp_size

(

INT

tcp_size

)

Definition at line 13831 of file midas.cxx.

                                       {
   INT old;
 
   old = _opt_tcp_size;
   _opt_tcp_size = tcp_size;
   return old;
}

Here is the caller graph for this function:

rpc_set_timeout()

INT rpc_set_timeout	(	HNDLE	hConn,
		int	timeout_msec,
		int *	old_timeout_msec
	)

Set RPC timeout

Parameters

hConn	RPC connection handle, RPC_HNDLE_MSERVER for mserver connection, RPC_HNDLE_CONNECT for rpc connect timeout
timeout_msec	RPC timeout in milliseconds
old_timeout_msec	returns old value of RPC timeout in milliseconds

Returns

RPC_SUCCESS

Definition at line 12965 of file midas.cxx.

{
   //printf("rpc_set_timeout: hConn %d, timeout_msec %d\n", hConn, timeout_msec);
 
   if (hConn == RPC_HNDLE_MSERVER) {
      if (old_timeout_msec)
         *old_timeout_msec = _server_connection.rpc_timeout;
      _server_connection.rpc_timeout = timeout_msec;
   } else if (hConn == RPC_HNDLE_CONNECT) {
      if (old_timeout_msec)
         *old_timeout_msec = _rpc_connect_timeout;
      _rpc_connect_timeout = timeout_msec;
   } else {
      RPC_CLIENT_CONNECTION* c = rpc_get_locked_client_connection(hConn);
      if (c) {
         if (old_timeout_msec)
            *old_timeout_msec = c->rpc_timeout;
         c->rpc_timeout = timeout_msec;
         c->mutex.unlock();
      } else {
         if (old_timeout_msec)
            *old_timeout_msec = 0;
      }
   }
   return RPC_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_socket_check_allowed_host()

static INT rpc_socket_check_allowed_host ( int  sock )

static

Definition at line 15280 of file midas.cxx.

{
   std::string hostname;
 
   int status = ss_socket_get_peer_name(sock, &hostname, NULL);
 
   if (status != SS_SUCCESS)
      return status;
   
   status = rpc_check_allowed_host(hostname.c_str());
   
   if (status == RPC_SUCCESS)
      return RPC_SUCCESS;
   
   static std::atomic_int max_report(10);
   if (max_report > 0) {
      max_report--;
      if (max_report == 0) {
         cm_msg(MERROR, "rpc_socket_check_allowed_host", "rejecting connection from unallowed host \'%s\', this message will no longer be reported", hostname.c_str());
      } else {
         cm_msg(MERROR, "rpc_socket_check_allowed_host", "rejecting connection from unallowed host \'%s\'. Add this host to \"/Experiment/Security/RPC hosts/Allowed hosts\"", hostname.c_str());
      }
   }
 
   return RPC_NET_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_test_rpc()

int rpc_test_rpc

(

)

Definition at line 15013 of file midas.cxx.

{
   int status = RPC_SUCCESS;
 
   printf("rpc_test_rpc!\n");
 
   int int_out = 0;
   int int_inout = 456;
   
   char string_out[32];
   char string2_out[48];
 
   char string_inout[25];
   strcpy(string_inout, "string_inout");
 
   KEY struct_in;
 
   struct_in.type = 111;
   struct_in.num_values = 222;
   strcpy(struct_in.name, "name");
   struct_in.last_written = 333;
   
   KEY struct_out;
   KEY struct_inout;
 
   struct_inout.type = 111111;
   struct_inout.num_values = 222222;
   strcpy(struct_inout.name, "name_name");
   struct_inout.last_written = 333333;
 
   uint32_t dwordarray_inout[10];
   size_t dwordarray_inout_size = sizeof(dwordarray_inout);
 
   for (int i=0; i<10; i++) {
      dwordarray_inout[i] = i*10;
   }
 
   char array_in[10];
 
   for (size_t i=0; i<sizeof(array_in); i++) {
      array_in[i] = 'a' + i;
   }
   
   char array_out[16];
   size_t array_out_size = sizeof(array_out);
 
   status = rpc_call(RPC_TEST2,
                     123,
                     &int_out,
                     &int_inout,
                     "test string",
                     string_out, sizeof(string_out),
                     string2_out, sizeof(string2_out),
                     string_inout, sizeof(string_inout),
                     &struct_in,
                     &struct_out,
                     &struct_inout,
                     dwordarray_inout, &dwordarray_inout_size,
                     array_in, sizeof(array_in),
                     array_out, &array_out_size
                     );
 
   printf("rpc_call(RPC_TEST2) status %d\n", status);
 
   if (int_out != 789) {
      printf("int_out mismatch!\n");
      status = 0;
   }
 
   if (int_inout != 456*2) {
      printf("int_inout mismatch!\n");
      status = 0;
   }
 
   if (strcmp(string_out, "string_out") != 0) {
      printf("string_out mismatch [%s] vs [%s]\n", string_out, "string_out");
      status = 0;
   }
 
   if (strcmp(string2_out, "second string_out") != 0) {
      printf("string2_out mismatch [%s] vs [%s]\n", string2_out, "second string_out");
      status = 0;
   }
 
   if (strcmp(string_inout, "return string_inout") != 0) {
      printf("string_inout mismatch [%s] vs [%s]\n", string_inout, "return string_inout");
      status = 0;
   }
 
   KEY* pkey;
 
   pkey = &struct_in;
 
   //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
 
   pkey = &struct_out;
 
   if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
      printf("struct_out mismatch: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
      status = 0;
   }
 
   pkey = &struct_inout;
 
   if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
      printf("struct_inout mismatch: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
      status = 0;
   }
 
#if 0
   if (dwordarray_inout_size != 4*5) {
      printf("dwordarray_inout_size mismatch %d vs %d\n", (int)dwordarray_inout_size, 4*5);
      status = 0;
   }
 
   for (size_t i=0; i<dwordarray_inout_size/sizeof(uint32_t); i++) {
      printf("dwordarray_inout[%d] is %d\n", (int)i, dwordarray_inout[i]);
   }
#endif
 
#if 0
   {RPC_TEST_CXX, "test_cxx",
    {{TID_INT32, RPC_IN},
     {TID_INT32, RPC_IN | RPC_OUT | RPC_VARARRAY | RPC_CXX},
     {TID_STRING, RPC_IN},
     {TID_STRING, RPC_IN | RPC_CXX},
     {TID_STRING, RPC_OUT | RPC_CXX},
     {TID_STRING, RPC_IN | RPC_OUT | RPC_CXX},
     {TID_STRUCT, RPC_IN | RPC_CXX, sizeof(KEY)},
     {TID_STRUCT, RPC_OUT | RPC_CXX, sizeof(KEY)},
     {TID_STRUCT, RPC_IN | RPC_OUT | RPC_CXX, sizeof(KEY)},
     {TID_ARRAY, RPC_IN | RPC_VARARRAY | RPC_CXX},
     {TID_ARRAY, RPC_OUT | RPC_VARARRAY | RPC_CXX},
     {TID_ARRAY, RPC_IN | RPC_OUT | RPC_VARARRAY | RPC_CXX},
     {0}}},
#endif
 
#if 0
   status = rpc_call(RPC_TEST_CXX, ...);
#endif
 
   return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_tid_name()

const char* rpc_tid_name

(

INT

id

)

Definition at line 11731 of file midas.cxx.

                                 {
   if (id >= 0 && id < TID_LAST)
      return tid_name[id];
   else
      return "<unknown>";
}

Here is the caller graph for this function:

rpc_tid_name_old()

const char* rpc_tid_name_old

(

INT

id

)

Definition at line 11738 of file midas.cxx.

                                     {
   if (id >= 0 && id < TID_LAST)
      return tid_name_old[id];
   else
      return "<unknown>";
}

Here is the caller graph for this function:

rpc_tid_size()

INT rpc_tid_size

(

INT

id

)

Definition at line 11724 of file midas.cxx.

                         {
   if (id >= 0 && id < TID_LAST)
      return tid_size[id];
 
   return 0;
}

Here is the caller graph for this function:

rpc_transition_dispatch()

static INT rpc_transition_dispatch ( INT  idx, void *  prpc_param[]  )

static

Definition at line 14023 of file midas.cxx.

{
   /* erase error string */
   *(CSTRING(2)) = 0;
 
   if (idx == RPC_RC_TRANSITION) {
      // find registered handler
      // NB: this code should match same code in cm_transition_call_direct()
      // NB: only use the first handler, this is how MIDAS always worked
      // NB: we could run all handlers, but we can return the status and error string of only one of them.
      _trans_table_mutex.lock();
      size_t n = _trans_table.size();
      _trans_table_mutex.unlock();
         
      for (size_t i = 0; i < n; i++) {
         _trans_table_mutex.lock();
         TRANS_TABLE tt = _trans_table[i];
         _trans_table_mutex.unlock();
         
         if (tt.transition == CINT(0) && tt.sequence_number == CINT(4)) {
            if (tt.func) {
               /* execute callback if defined */
               return tt.func(CINT(1), CSTRING(2));
            } else {
               std::lock_guard<std::mutex> guard(_tr_fifo_mutex);
               /* store transition in FIFO */
               _tr_fifo[_tr_fifo_wp].transition = CINT(0);
               _tr_fifo[_tr_fifo_wp].run_number = CINT(1);
               _tr_fifo[_tr_fifo_wp].trans_time = time(NULL);
               _tr_fifo[_tr_fifo_wp].sequence_number = CINT(4);
               _tr_fifo_wp = (_tr_fifo_wp + 1) % 10;
               // implicit unlock
               return RPC_SUCCESS;
            }
         }
      }
      // no handler for this transition
      cm_msg(MERROR, "rpc_transition_dispatch", "no handler for transition %d with sequence number %d", CINT(0), CINT(4));
      return CM_SUCCESS;
   } else {
      cm_msg(MERROR, "rpc_transition_dispatch", "received unrecognized command %d", idx);
      return RPC_INVALID_ID;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

rpc_va_arg()

void rpc_va_arg	(	va_list *	arg_ptr,
		INT	arg_type,
		void *	arg
	)

Definition at line 13160 of file midas.cxx.

                                                           {
   switch (arg_type) {
      /* On the stack, the minimum parameter size is sizeof(int).
         To avoid problems on little endian systems, treat all
         smaller parameters as int's */
      case TID_UINT8:
      case TID_INT8:
      case TID_CHAR:
      case TID_UINT16:
      case TID_INT16:
         *((int *) arg) = va_arg(*arg_ptr, int);
         break;
 
      case TID_INT32:
      case TID_BOOL:
         *((INT *) arg) = va_arg(*arg_ptr, INT);
         break;
 
      case TID_UINT32:
         *((DWORD *) arg) = va_arg(*arg_ptr, DWORD);
         break;
 
         /* float variables are passed as double by the compiler */
      case TID_FLOAT:
         *((float *) arg) = (float) va_arg(*arg_ptr, double);
         break;
 
      case TID_DOUBLE:
         *((double *) arg) = va_arg(*arg_ptr, double);
         break;
 
      case TID_ARRAY:
         *((char **) arg) = va_arg(*arg_ptr, char *);
         break;
   }
}

Here is the caller graph for this function:

rpc_vax2ieee_double()

void rpc_vax2ieee_double

(

double *

var

)

Definition at line 11609 of file midas.cxx.

                                      {
   unsigned short int i1, i2, i3, i4;
 
   /* swap words */
   i1 = *((short int *) (var) + 3);
   i2 = *((short int *) (var) + 2);
   i3 = *((short int *) (var) + 1);
   i4 = *((short int *) (var));
 
   /* correct exponent */
   if (i4 != 0)
      i4 -= 0x20;
 
   *((short int *) (var) + 3) = i4;
   *((short int *) (var) + 2) = i3;
   *((short int *) (var) + 1) = i2;
   *((short int *) (var)) = i1;
}

Here is the caller graph for this function:

rpc_vax2ieee_float()

void rpc_vax2ieee_float

(

float *

var

)

Definition at line 11593 of file midas.cxx.

                                    {
   unsigned short int lo, hi;
 
   /* swap hi and lo word */
   lo = *((short int *) (var) + 1);
   hi = *((short int *) (var));
 
   /* correct exponent */
   if (hi != 0)
      hi -= 0x100;
 
   *((short int *) (var) + 1) = hi;
   *((short int *) (var)) = lo;
 
}

Here is the caller graph for this function:

Variable Documentation

_client_connections

std::vector<RPC_CLIENT_CONNECTION*> _client_connections

static

Definition at line 11463 of file midas.cxx.

_client_connections_mutex

std::mutex _client_connections_mutex

static

Definition at line 11462 of file midas.cxx.

_mserver_acception

RPC_SERVER_ACCEPTION* _mserver_acception = NULL

static

Definition at line 11470 of file midas.cxx.

_mserver_path

std::string _mserver_path

static

Definition at line 13015 of file midas.cxx.

_opt_tcp_size

int _opt_tcp_size = OPT_TCP_SIZE

static

Definition at line 11543 of file midas.cxx.

_rpc_is_remote

bool _rpc_is_remote = false

static

Definition at line 11466 of file midas.cxx.

_server_acceptions

std::vector<RPC_SERVER_ACCEPTION*> _server_acceptions

static

Definition at line 11469 of file midas.cxx.

_server_connection

RPC_SERVER_CONNECTION _server_connection

static

Definition at line 11465 of file midas.cxx.

_tr_fifo

TR_FIFO _tr_fifo[10]

static

Definition at line 14019 of file midas.cxx.

_tr_fifo_mutex

std::mutex _tr_fifo_mutex

static

Definition at line 14018 of file midas.cxx.

_tr_fifo_rp

int _tr_fifo_rp = 0

static

Definition at line 14021 of file midas.cxx.

_tr_fifo_wp

int _tr_fifo_wp = 0

static

Definition at line 14020 of file midas.cxx.

gAllowedHosts

std::vector<std::string> gAllowedHosts

static

Definition at line 15173 of file midas.cxx.

gAllowedHostsMutex

std::mutex gAllowedHostsMutex

static

Definition at line 15174 of file midas.cxx.

rpc_list

std::vector<RPC_LIST> rpc_list

static

Definition at line 11540 of file midas.cxx.

rpc_list_mutex

std::mutex rpc_list_mutex

static

Definition at line 11541 of file midas.cxx.

tls_buffer

TLS_POINTER* tls_buffer = NULL

static

Definition at line 14613 of file midas.cxx.

tls_size

int tls_size = 0

static

Definition at line 14614 of file midas.cxx.