Loading...
Searching...
No Matches
Classes | |
| class | RPC_CLIENT_CONNECTION |
| struct | TR_FIFO |
| struct | TLS_POINTER |
| class | RPE |
Functions | |
| 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) |
| static void | rpc_call_encode_cxx (va_list &ap, const RPC_LIST &rl, NET_COMMAND **nc) |
| static int | rpc_call_decode_cxx (va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size) |
| static int | rpc_find_rpc (int routine_id, RPC_LIST *pentry, bool *prpc_cxx) |
| 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 (RPC_SERVER_ACCEPTION *sa, 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) |
| static INT | rpc_execute_old (INT sock, int xroutine_id, const RPC_LIST &rl, char *buffer, INT convert_flags) |
| static INT | rpc_execute_cxx (INT sock, int xroutine_id, const RPC_LIST &rl, char *buffer, INT convert_flags) |
| int | rpc_test_rpc_test2 () |
| int | rpc_test_rpc_test2_cxx () |
| int | rpc_test_rpc_test3_cxx () |
| int | rpc_test_rpc_test4_cxx () |
| 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 (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
◆ RPC_AL_TRIGGER_ALARM
◆ RPC_ANA_CLEAR_HISTOS
◆ RPC_BM_ADD_EVENT_REQUEST
◆ RPC_BM_CLOSE_ALL_BUFFERS
◆ RPC_BM_CLOSE_BUFFER
◆ RPC_BM_EMPTY_BUFFERS
◆ RPC_BM_FLUSH_CACHE
◆ RPC_BM_GET_BUFFER_INFO
◆ RPC_BM_GET_BUFFER_LEVEL
◆ RPC_BM_INIT_BUFFER_COUNTERS
◆ RPC_BM_MARK_READ_WAITING
◆ RPC_BM_OPEN_BUFFER
◆ RPC_BM_RECEIVE_EVENT
◆ RPC_BM_RECEIVE_EVENT_CXX
◆ RPC_BM_REMOVE_EVENT_REQUEST
◆ RPC_BM_SEND_EVENT
◆ RPC_BM_SET_CACHE_SIZE
◆ RPC_BM_SKIP_EVENT
◆ RPC_BRPC
◆ RPC_BRPC_CXX
◆ RPC_CM_ASCTIME
◆ RPC_CM_CHECK_CLIENT
◆ RPC_CM_CLEANUP
◆ RPC_CM_EXECUTE
◆ RPC_CM_EXIST
◆ RPC_CM_GET_WATCHDOG_INFO
◆ RPC_CM_MSG
◆ RPC_CM_MSG_LOG
◆ RPC_CM_MSG_LOG1
◆ RPC_CM_MSG_RETRIEVE
◆ RPC_CM_SET_CLIENT_INFO
| #define RPC_CM_SET_CLIENT_INFO 11000 |
◆ RPC_CM_SET_WATCHDOG_PARAMS
◆ RPC_CM_SYNCHRONIZE
◆ RPC_CM_TIME
◆ RPC_CNAF16
◆ RPC_CNAF24
◆ RPC_DB_ADD_OPEN_RECORD
◆ RPC_DB_CHECK_RECORD
◆ RPC_DB_CLOSE_ALL_DATABASES
◆ RPC_DB_CLOSE_DATABASE
◆ RPC_DB_COPY_XML
◆ RPC_DB_CREATE_KEY
◆ RPC_DB_CREATE_LINK
◆ RPC_DB_CREATE_RECORD
◆ RPC_DB_DELETE_KEY
◆ RPC_DB_ENUM_KEY
◆ RPC_DB_ENUM_LINK
◆ RPC_DB_FIND_KEY
◆ RPC_DB_FIND_LINK
◆ RPC_DB_FLUSH_DATABASE
◆ RPC_DB_GET_DATA
◆ RPC_DB_GET_DATA1
◆ RPC_DB_GET_DATA_INDEX
◆ RPC_DB_GET_KEY
◆ RPC_DB_GET_KEY_INFO
◆ RPC_DB_GET_KEY_TIME
◆ RPC_DB_GET_LINK
◆ RPC_DB_GET_LINK_DATA
◆ RPC_DB_GET_NEXT_LINK
◆ RPC_DB_GET_OPEN_RECORDS
◆ RPC_DB_GET_PARENT
◆ RPC_DB_GET_PATH
◆ RPC_DB_GET_RECORD
◆ RPC_DB_GET_RECORD_SIZE
◆ RPC_DB_GET_VALUE
◆ RPC_DB_LOAD
◆ RPC_DB_NOTIFY_CLIENTS_ARRAY
◆ RPC_DB_OPEN_DATABASE
◆ RPC_DB_REMOVE_OPEN_RECORD
◆ RPC_DB_RENAME_KEY
◆ RPC_DB_REORDER_KEY
◆ RPC_DB_SAVE
◆ RPC_DB_SET_CLIENT_NAME
◆ RPC_DB_SET_DATA
◆ RPC_DB_SET_DATA1
◆ RPC_DB_SET_DATA_INDEX
◆ RPC_DB_SET_DATA_INDEX1
◆ RPC_DB_SET_LINK_DATA
◆ RPC_DB_SET_LINK_DATA_INDEX
◆ RPC_DB_SET_MODE
◆ RPC_DB_SET_NUM_VALUES
◆ RPC_DB_SET_RECORD
◆ RPC_DB_SET_VALUE
◆ RPC_EL_SUBMIT
◆ RPC_ID_EXIT
◆ RPC_ID_SHUTDOWN
◆ RPC_ID_WATCHDOG
◆ RPC_JRPC
◆ RPC_JRPC_CXX
◆ RPC_LOG_REWIND
◆ RPC_MANUAL_TRIG
◆ RPC_RC_TRANSITION
◆ RPC_TEST
◆ RPC_TEST2
◆ RPC_TEST2_CXX
◆ RPC_TEST3_CXX
◆ RPC_TEST4_CXX
Function Documentation
◆ close()
| void RPC_SERVER_ACCEPTION::close | ( | ) |
Definition at line 11674 of file midas.cxx.
11675{
11676 //printf("RPC_SERVER_ACCEPTION::close: connection from %s program %s mserver %d\n", host_name.c_str(), prog_name.c_str(), is_mserver);
11677
11680 _mserver_acception = NULL;
11682 }
11683
11684 /* close server connection */
11691
11692 /* free TCP cache */
11694 //printf("free net_buffer %p+%d\n", net_buffer, net_buffer_size);
11695 free(net_buffer);
11696 net_buffer = NULL;
11697 net_buffer_size = 0;
11698 }
11699
11700 /* mark this entry as invalid */
11701 clear();
11702}
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 14568 of file midas.cxx.
14592{
14593 std::lock_guard<std::mutex> guard(_tr_fifo_mutex);
14594
14597
14600
14603
14604 if (trans_time)
14606
14608
14609 // implicit unlock
14611}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ gAllowedHostsEnabled()
|
static |
Here is the caller graph for this function:
◆ handle_msg_odb()
|
static |
Definition at line 12062 of file midas.cxx.
12062 {
12063 //printf("rpc_client_dispatch: MSG_ODB: packet size %d, expected %d\n", n, (int)(sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT)));
12065 /* update a changed record */
12071 }
12073}
INT db_update_record_local(INT hDB, INT hKeyRoot, INT hKey, int index)
Definition odb.cxx:13584
Definition msystem.h:287
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_event_server_realloc()
|
static |
Definition at line 14833 of file midas.cxx.
14855{
14857
14858 //printf("recv_event_server: idx %d, buffer %p, buffer_size %d\n", idx, buffer, buffer_size);
14859
14861
14862 char header_buf[header_size];
14863
14864 // First read the header.
14865 //
14866 // Data format is:
14867 // INT buffer handle (4 bytes)
14868 // EVENT_HEADER (16 bytes)
14869 // event data
14870 // ALIGN8() padding
14871 // ...next event
14872
14874
14875 if (hrd == 0) {
14876 // timeout waiting for data
14877 return 0;
14878 }
14879
14880 /* abort if connection broken */
14881 if (hrd < 0) {
14883 return -1;
14884 }
14885
14886 if (hrd < (int) header_size) {
14888
14889 /* abort if connection broken */
14890 if (hrd1 <= 0) {
14892 return -1;
14893 }
14894
14895 hrd += hrd1;
14896 }
14897
14898 /* abort if connection broken */
14899 if (hrd != (int) header_size) {
14900 cm_msg(MERROR, "recv_event_server", "recv_tcp2(header) returned %d instead of %d", hrd, (int) header_size);
14901 return -1;
14902 }
14903
14906
14907 /* convert header little endian/big endian */
14915 }
14916
14919
14920 //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);
14921
14925 }
14926 abort();
14927 }
14928
14929 /* check for sane event size */
14932 "received event header with invalid data_size %d: event_size %d, total_size %d", pevent->data_size,
14933 event_size, total_size);
14934 return -1;
14935 }
14936
14937 //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);
14938
14939
14941
14942 // Second, check that output buffer is big enough
14943
14944 /* check if data part fits in buffer */
14945 if (*pbuffer_size < bufsize) {
14947
14948 //printf("recv_event_server: buffer realloc %d -> %d\n", *pbuffer_size, newsize);
14949
14950 char *newbuf = (char *) realloc(*pbuffer, newsize);
14951 if (newbuf == NULL) {
14952 cm_msg(MERROR, "recv_event_server", "cannot realloc() event buffer from %d to %d bytes", *pbuffer_size,
14953 newsize);
14954 return -1;
14955 }
14956 *pbuffer = newbuf;
14957 *pbuffer_size = newsize;
14958 }
14959
14960 // Third, copy header into output buffer
14961
14962 memcpy(*pbuffer, header_buf, header_size);
14963
14964 // Forth, read the event data
14965
14967 int rptr = header_size;
14968
14969 if (to_read > 0) {
14971
14972 /* abort if connection broken */
14973 if (drd <= 0) {
14974 cm_msg(MERROR, "recv_event_server", "recv_tcp2(data) returned %d instead of %d", drd, to_read);
14975 return -1;
14976 }
14977 }
14978
14979 return bufsize;
14980}
INT recv_tcp2(int sock, char *net_buffer, int buffer_size, int timeout_ms)
Definition system.cxx:5634
INT cm_msg(INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
Definition midas.cxx:931
void rpc_convert_single(void *data, INT tid, INT flags, INT convert_flags)
Definition midas.cxx:11812
Definition midas.h:852
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_net_command_realloc()
|
static |
Definition at line 14645 of file midas.cxx.
14673{
14674 char *buffer = NULL; // buffer is changed to point to *pbuf when we receive the NET_COMMAND header
14675
14677
14681 else
14683
14685 //printf("sa %p idx %d, net_buffer %p+%d\n", sa, idx, sa->net_buffer, sa->net_buffer_size);
14686 sa->write_ptr = 0;
14687 sa->read_ptr = 0;
14688 sa->misalign = 0;
14689 }
14691 cm_msg(MERROR, "recv_net_command_realloc", "Cannot allocate %d bytes for network buffer", sa->net_buffer_size);
14692 return -1;
14693 }
14694
14695 int copied = 0;
14696 int param_size = -1;
14697
14702
14703 do {
14705 if (param_size == -1) {
14706 if (copied > 0) {
14707 /* assemble split header */
14711 } else {
14714 }
14715
14718 }
14719
14720 //printf("recv_net_command_realloc: param_size %d, NET_COMMAND_HEADER %d, buffer_size %d\n", param_size, (int)sizeof(NET_COMMAND_HEADER), *pbufsize);
14721
14722 /* check if parameters fit in buffer */
14725 char *p = (char *) realloc(*pbuf, new_size);
14726 //printf("recv_net_command_realloc: reallocate buffer %d -> %d, %p\n", *pbufsize, new_size, p);
14727 if (p == NULL) {
14728 cm_msg(MERROR, "recv_net_command_realloc", "cannot reallocate buffer from %d bytes to %d bytes", *pbufsize, new_size);
14729 sa->read_ptr = 0;
14730 sa->write_ptr = 0;
14731 return -1;
14732 }
14733 *pbuf = p;
14734 *pbufsize = new_size;
14735 }
14736
14737 buffer = *pbuf;
14738
14739 /* check if we have all parameters in buffer */
14741 break;
14742 }
14743
14744 /* not enough data, so copy partially and get new */
14745 int size = write_ptr - read_ptr;
14746
14747 if (size > 0) {
14748 memcpy(buffer + copied, net_buffer + read_ptr, size);
14749 copied += size;
14750 read_ptr = write_ptr;
14751 }
14752#ifdef OS_UNIX
14753 do {
14754 write_ptr = recv(sock, net_buffer + misalign, sa->net_buffer_size - 8, 0);
14755
14756 /* don't return if an alarm signal was cought */
14757 } while (write_ptr == -1 && errno == EINTR);
14758#else
14759 write_ptr = recv(sock, net_buffer + misalign, sa->net_buffer_size - 8, 0);
14760#endif
14761
14762 /* abort if connection broken */
14763 if (write_ptr <= 0) {
14764 if (write_ptr == 0)
14765 cm_msg(MERROR, "recv_net_command_realloc", "rpc connection from \'%s\' on \'%s\' unexpectedly closed", sa->prog_name.c_str(), sa->host_name.c_str());
14766 else
14767 cm_msg(MERROR, "recv_net_command_realloc", "recv() returned %d, errno: %d (%s)", write_ptr, errno, strerror(errno));
14768
14769 if (remaining)
14770 *remaining = 0;
14771
14772 return write_ptr;
14773 }
14774
14775 read_ptr = misalign;
14776 write_ptr += misalign;
14777
14778 misalign = write_ptr % 8;
14780
14781 /* copy rest of parameters */
14783 memcpy(buffer + copied, net_buffer + read_ptr, size);
14784 read_ptr += size;
14785
14786 if (remaining) {
14787 /* don't keep rpc_server_receive in an infinite loop */
14788 if (write_ptr - read_ptr < param_size)
14789 *remaining = 0;
14790 else
14791 *remaining = write_ptr - read_ptr;
14792 }
14793
14794 sa->write_ptr = write_ptr;
14795 sa->read_ptr = read_ptr;
14796 sa->misalign = misalign;
14797
14798 return size + copied;
14799}
Definition msystem.h:292
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 14803 of file midas.cxx.
14821{
14822 /* figure out to which connection socket belongs */
14826 }
14827
14828 return 0;
14829}
static std::vector< RPC_SERVER_ACCEPTION * > _server_acceptions
Definition midas.cxx:11641
Here is the caller graph for this function:
◆ rpc_add_allowed_host()
| INT rpc_add_allowed_host | ( | const char * | hostname | ) |
Definition at line 16594 of file midas.cxx.
16611{
16612 //cm_msg(MINFO, "rpc_add_allowed_host", "Adding allowed host \'%s\'", hostname);
16613
16614 gAllowedHostsMutex.lock();
16615 gAllowedHosts.push_back(hostname);
16617 gAllowedHostsMutex.unlock();
16618
16620}
static std::atomic_bool gAllowedHostsEnabled(false)
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_calc_convert_flags()
- ASCII format */
Definition at line 11714 of file midas.cxx.
11714 {
11715 *convert_flags = 0;
11716
11717 /* big/little endian conversion */
11720 && (hw_type & DRI_BIG_ENDIAN)))
11721 *convert_flags |= CF_ENDIAN;
11722
11723 /* float conversion between IEEE and VAX G */
11725 *convert_flags |= CF_VAX2IEEE;
11726
11727 /* float conversion between VAX G and IEEE */
11729 *convert_flags |= CF_IEEE2VAX;
11730
11732 //if (remote_hw_type & DR_ASCII)
11733 // *convert_flags |= CF_ASCII;
11734}
Here is the caller graph for this function:
◆ rpc_call()
Definition at line 14115 of file midas.cxx.
14139{
14140 va_list ap;
14142
14144 routine_id &= ~RPC_NO_REPLY;
14145
14146 //if (rpc_no_reply)
14147 // printf("rpc_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
14148
14151
14152 if (!send_sock) {
14153 fprintf(stderr, "rpc_call(routine_id=%d) failed, no connection to mserver.\n", routine_id);
14155 }
14156
14158 /* create a local mutex for multi-threaded applications */
14160 }
14161
14166 }
14167
14168 /* find rpc definition */
14169
14170 RPC_LIST rpc_entry;
14171 bool rpc_cxx = false;
14172
14174
14179 }
14180
14182
14183 /* prepare output buffer */
14184
14185 NET_COMMAND* nc = NULL;
14186
14187 /* examine variable argument list and convert it to parameter array */
14188 va_start(ap, routine_id);
14189
14190 if (rpc_cxx)
14191 rpc_call_encode_cxx(ap, rpc_entry, &nc);
14192 else
14193 rpc_call_encode(ap, rpc_entry, &nc);
14194
14195 va_end(ap);
14196
14198
14199 if (rpc_no_reply)
14201
14203
14204 /* do not wait for reply if requested RPC_NO_REPLY */
14205 if (rpc_no_reply) {
14207
14211 free(nc);
14213 }
14214
14216 free(nc);
14218 }
14219
14220 /* in TCP mode, send and wait for reply on send socket */
14225 free(nc);
14227 }
14228
14229 free(nc);
14230 nc = NULL;
14231
14232 bool restore_watchdog_timeout = false;
14233 BOOL watchdog_call;
14234 DWORD watchdog_timeout;
14235 cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
14236
14237 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, rpc_timeout);
14238
14240 // if RPC is remote, we are connected to an mserver,
14241 // the mserver takes care of watchdog timeouts.
14242 // otherwise we should make sure the watchdog timeout
14243 // is longer than the RPC timeout. K.O.
14244 if (rpc_timeout >= (int) watchdog_timeout) {
14245 restore_watchdog_timeout = true;
14246 cm_set_watchdog_params_local(watchdog_call, rpc_timeout + 1000);
14247 }
14248 }
14249
14250 DWORD rpc_status = 0;
14251 DWORD buf_size = 0;
14252 char* buf = NULL;
14253
14255
14256 if (restore_watchdog_timeout) {
14257 cm_set_watchdog_params_local(watchdog_call, watchdog_timeout);
14258 }
14259
14260 /* drop the mutex, we are done with the socket, argument unpacking is done from our own buffer */
14261
14263
14264 /* check for reply errors */
14265
14267 cm_msg(MERROR, "rpc_call", "routine \"%s\": timeout waiting for reply, program abort", rpc_name);
14268 if (buf)
14269 free(buf);
14270 abort(); // cannot continue - our mserver is not talking to us!
14272 }
14273
14275 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, ss_recv_net_command() status %d, program abort", rpc_name, status);
14276 if (buf)
14277 free(buf);
14278 abort(); // cannot continue - something is wrong with our mserver connection
14280 }
14281
14283 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, unknown RPC, status %d", rpc_name, rpc_status);
14284 if (buf)
14285 free(buf);
14286 return rpc_status;
14287 }
14288
14289 /* extract result variables and place it to argument list */
14290
14291 va_start(ap, routine_id);
14292
14293 if (rpc_cxx)
14295 else
14297
14299 rpc_status = status;
14300 }
14301
14302 va_end(ap);
14303
14304 if (buf)
14305 free(buf);
14306
14307 return rpc_status;
14308}
INT cm_get_watchdog_params(BOOL *call_watchdog, DWORD *timeout)
Definition midas.cxx:3341
INT cm_set_watchdog_params_local(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3260
INT ss_recv_net_command(int sock, DWORD *routine_id, DWORD *param_size, char **param_ptr, int timeout_ms)
Definition system.cxx:5707
INT send_tcp(int sock, char *buffer, DWORD buffer_size, INT flags)
Definition system.cxx:5357
static void rpc_call_encode(va_list &ap, const RPC_LIST &rl, NET_COMMAND **nc)
Definition midas.cxx:13362
static void rpc_call_encode_cxx(va_list &ap, const RPC_LIST &rl, NET_COMMAND **nc)
Definition midas.cxx:13607
static int rpc_find_rpc(int routine_id, RPC_LIST *pentry, bool *prpc_cxx)
Definition midas.cxx:13900
static int rpc_call_decode(va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size)
Definition midas.cxx:13535
static int rpc_call_decode_cxx(va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size)
Definition midas.cxx:13807
Definition midas.h:1597
Here is the call graph for this function:
◆ rpc_call_decode()
|
static |
Definition at line 13535 of file midas.cxx.
13536{
13537 //printf("rpc_call_decode!\n");
13538
13540
13543
13544 /* extract result variables and place it to argument list */
13545
13546 const char* param_ptr = buf;
13547
13551 int arg_type = 0;
13552
13556
13557 if (bpointer)
13558 arg_type = TID_ARRAY;
13559 else
13561
13563 arg_type = TID_DOUBLE;
13564
13565 char arg[8];
13566 rpc_va_arg(&ap, arg_type, arg);
13567
13569
13570 if (param_ptr == NULL) {
13571 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);
13573 }
13574
13577
13579 arg_size = strlen((char *) (param_ptr)) + 1;
13580
13582 arg_size = *((INT *) param_ptr);
13584 }
13585
13588
13589 /* parameter size is always aligned */
13591
13592 /* return parameters are always pointers */
13593 if (*((char **) arg)) {
13595 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);
13596 memcpy((void *) *((char **) arg), param_ptr, arg_size);
13597 }
13598
13599 param_ptr += param_size;
13600 }
13601 }
13602
13604}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call_decode_cxx()
|
static |
Definition at line 13807 of file midas.cxx.
13808{
13809 //printf("rpc_call_decode_cxx!\n");
13810
13812
13813 //if (rl.id == RPC_TEST2)
13814 // debug = true;
13815
13816 //if (rl.id == RPC_TEST2_CXX)
13817 // debug = true;
13818
13821
13822 /* extract result variables and place it to argument list */
13823
13824 const char* param_ptr = buf;
13825
13829 int arg_type = 0;
13830
13834
13835 if (bpointer)
13836 arg_type = TID_ARRAY;
13837 else
13838 arg_type = tid;
13839
13841 arg_type = TID_DOUBLE;
13842
13843 char arg[sizeof(double)+sizeof(uint64_t)+sizeof(char*)];
13844 rpc_va_arg(&ap, arg_type, arg);
13845
13847
13848 if (param_ptr == NULL) {
13849 cm_msg(MERROR, "rpc_call_decode_cxx", "routine \"%s\": no data in RPC reply, needed to decode an RPC_OUT parameter. param_ptr is NULL", rl.name);
13851 }
13852
13854
13856 arg_size = strlen((char *) (param_ptr)) + 1;
13857
13859 printf("decode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, string [%s]\n", i, flags, tid, arg_type, arg_size, (char *) (param_ptr));
13860 }
13861
13863 arg_size = *((INT *) param_ptr);
13865 }
13866
13869
13870 /* parameter size is always aligned */
13872
13873 /* return parameters are always pointers */
13874 void* parg = *(char**) arg;
13875 if (parg) {
13878 printf("decode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, assign %3d to std::string at %p, offset %zu, string [%s]\n", i, flags, tid, arg_type, arg_size, param_size, arg_size, parg, param_ptr - buf, param_ptr);
13879 *(std::string*)parg = param_ptr;
13882 printf("decode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, assign %3d to std::vector at %p, offset %zu\n", i, flags, tid, arg_type, arg_size, param_size, arg_size, parg, param_ptr - buf);
13883 std::vector<char>* pvec = (std::vector<char>*)parg;
13884 pvec->clear();
13885 pvec->insert(pvec->end(), param_ptr, param_ptr + arg_size);
13886 } else {
13888 printf("decode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, memcpy %3d to %p, offset %zu\n", i, flags, tid, arg_type, arg_size, param_size, arg_size, parg, param_ptr - buf);
13889 memcpy(parg, param_ptr, arg_size);
13890 }
13891 }
13892
13893 param_ptr += param_size;
13894 }
13895 }
13896
13898}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call_encode()
|
static |
Definition at line 13362 of file midas.cxx.
13363{
13364 //printf("rpc_call_encode!\n");
13365
13367
13375 }
13376 }
13377
13379
13383 int arg_type = 0;
13384
13388
13389 if (bpointer)
13390 arg_type = TID_ARRAY;
13391 else
13392 arg_type = tid;
13393
13394 /* floats are passed as doubles, at least under NT */
13396 arg_type = TID_DOUBLE;
13397
13398 //printf("arg %d, tid %d, flags 0x%x, arg_type %d, bpointer %d\n", i, tid, flags, arg_type, bpointer);
13399
13401 }
13402
13404 char* buf = (char *)malloc(buf_size);
13405 assert(buf);
13406
13407 (*nc) = (NET_COMMAND*) buf;
13408
13409 /* find out if we are on a big endian system */
13411
13412 char* param_ptr = (*nc)->param;
13413
13417 int arg_type = 0;
13418
13422
13423 if (bpointer)
13424 arg_type = TID_ARRAY;
13425 else
13426 arg_type = tid;
13427
13428 /* floats are passed as doubles, at least under NT */
13430 arg_type = TID_DOUBLE;
13431
13432 /* get pointer to argument */
13433 //char arg[8];
13434 //rpc_va_arg(&ap, arg_type, arg);
13435
13437
13438 /* shift 1- and 2-byte parameters to the LSB on big endian systems */
13439 if (bbig) {
13441 arg[0] = arg[3];
13442 }
13444 arg[0] = arg[2];
13445 arg[1] = arg[3];
13446 }
13447 }
13448
13450 int arg_size = 0;
13451
13452 if (bpointer)
13453 arg_size = rpc_tid_size(tid);
13454 else
13455 arg_size = rpc_tid_size(arg_type);
13456
13457 /* for strings, the argument size depends on the string length */
13459 arg_size = 1 + strlen((char *) *((char **) arg));
13460 }
13461
13462 /* for varibale length arrays, the size is given by
13463 the next parameter on the stack */
13465 //va_list aptmp;
13467 //va_copy(aptmp, ap);
13468
13469 //char arg_tmp[8];
13470 //rpc_va_arg(&aptmp, TID_ARRAY, arg_tmp);
13471
13473
13474 /* for (RPC_IN+RPC_OUT) parameters, size argument is a pointer */
13477 else
13478 arg_size = *((INT *) arg_tmp);
13479
13482
13483 //va_end(aptmp);
13484 }
13485
13488
13489 /* always align parameter size */
13491
13492 {
13493 size_t param_offset = (char *) param_ptr - (char *)(*nc);
13494
13495 if (param_offset + param_size + 16 > buf_size) {
13496 size_t new_size = param_offset + param_size + 1024;
13497 //printf("resize nc %zu to %zu\n", buf_size, new_size);
13498 buf = (char *) realloc(buf, new_size);
13499 assert(buf);
13500 buf_size = new_size;
13501 (*nc) = (NET_COMMAND*) buf;
13502 param_ptr = buf + param_offset;
13503 }
13504 }
13505
13506 if (bpointer) {
13508 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);
13509 }
13510 memcpy(param_ptr, (void *) *((void **) arg), arg_size);
13513 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);
13514 }
13515 /* floats are passed as doubles on most systems */
13516 *((float *) param_ptr) = (float) *((double *) arg);
13517 } else {
13519 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);
13520 }
13521 memcpy(param_ptr, arg, arg_size);
13522 }
13523
13524 param_ptr += param_size;
13525 }
13526 }
13527
13529
13531 printf("encode rpc_id %d \"%s\" buf_size %d, param_size %d\n", rl.id, rl.name, (int)buf_size, (*nc)->header.param_size);
13532}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call_encode_cxx()
|
static |
Definition at line 13607 of file midas.cxx.
13608{
13609 //printf("rpc_call_encode_cxx!\n");
13610
13612
13613 //if (rl.id == RPC_TEST2)
13614 // debug = true;
13615
13616 //if (rl.id == RPC_TEST2_CXX)
13617 // debug = true;
13618
13626 }
13627 }
13628
13630
13634 int arg_type = 0;
13635
13639
13640 if (bpointer)
13641 arg_type = TID_ARRAY;
13642 else
13643 arg_type = tid;
13644
13645 /* floats are passed as doubles, at least under NT */
13647 arg_type = TID_DOUBLE;
13648
13649 //printf("arg %d, tid %d, flags 0x%x, arg_type %d, bpointer %d\n", i, tid, flags, arg_type, bpointer);
13650
13652 }
13653
13655 char* buf = (char *)malloc(buf_size);
13656 assert(buf);
13657
13658 (*nc) = (NET_COMMAND*) buf;
13659
13660 /* find out if we are on a big endian system */
13662
13663 char* param_ptr = (*nc)->param;
13664
13668 int arg_type = 0;
13669
13673
13674 if (bpointer)
13675 arg_type = TID_ARRAY;
13676 else
13677 arg_type = tid;
13678
13679 /* floats are passed as doubles, at least under NT */
13681 arg_type = TID_DOUBLE;
13682
13683 /* get pointer to argument */
13684 //char arg[8];
13685 //rpc_va_arg(&ap, arg_type, arg);
13686
13688
13689 /* shift 1- and 2-byte parameters to the LSB on big endian systems */
13690 if (bbig) {
13692 arg[0] = arg[3];
13693 }
13695 arg[0] = arg[2];
13696 arg[1] = arg[3];
13697 }
13698 }
13699
13701 int arg_size = 0;
13702
13703 if (bpointer)
13704 arg_size = rpc_tid_size(tid);
13705 else
13706 arg_size = rpc_tid_size(arg_type);
13707
13708 void* parg = (void *) *((void **) arg);
13709
13710 /* for strings, the argument size depends on the string length */
13712 std::string* s = (std::string*)parg;
13713 arg_size = 1 + s->length();
13714 parg = (void*)s->c_str();
13715 bpointer = TRUE;
13716 //printf("STRING %p, len %zu, [%s]\n", s, s->length(), s->c_str());
13718 arg_size = 1 + strlen((char *) *((char **) arg));
13719 }
13720
13721 /* for varibale length arrays, the size is given by
13722 the next parameter on the stack */
13724 //va_list aptmp;
13726 //va_copy(aptmp, ap);
13727
13728 //char arg_tmp[8];
13729 //rpc_va_arg(&aptmp, TID_ARRAY, arg_tmp);
13730
13732 std::vector<char>* pv = (std::vector<char>*)parg;
13733 arg_size = pv->size();
13734 parg = (void*)pv->data();
13735 bpointer = TRUE;
13736 //printf("VECTOR %p, size %zu\n", pv, pv->size());
13737
13738 *((INT *) param_ptr) = arg_size; // NB: for std:vector<char> data, pass true data size. it is safe because decoder always aligns it themselves.
13739
13740 } else {
13742
13743 /* for (RPC_IN+RPC_OUT) parameters, size argument is a pointer */
13746 } else {
13747 arg_size = *((INT *) arg_tmp);
13748 }
13749
13751 }
13752
13754
13755 //va_end(aptmp);
13756 }
13757
13760
13761 /* always align parameter size */
13763
13764 {
13765 size_t param_offset = (char *) param_ptr - (char *)(*nc);
13766
13767 if (param_offset + param_size + 16 > buf_size) {
13768 size_t new_size = param_offset + param_size + 1024;
13769 //printf("resize nc %zu to %zu\n", buf_size, new_size);
13770 buf = (char *) realloc(buf, new_size);
13771 assert(buf);
13772 buf_size = new_size;
13773 (*nc) = (NET_COMMAND*) buf;
13774 param_ptr = buf + param_offset;
13775 }
13776 }
13777
13778 if (bpointer) {
13780 printf("encode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, memcpy pointer %3d\n", i, flags, tid, arg_type, arg_size, param_size, arg_size);
13781 }
13782 memcpy(param_ptr, parg, arg_size);
13785 printf("encode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, double->float\n", i, flags, tid, arg_type, arg_size, param_size);
13786 }
13787 /* floats are passed as doubles on most systems */
13788 *((float *) param_ptr) = (float) *((double *) arg);
13789 } else {
13791 printf("encode param %2d, flags 0x%02x, tid %2d, arg_type %2d, arg_size %3d, param_size %3d, memcpy %3d\n", i, flags, tid, arg_type, arg_size, param_size, arg_size);
13792 }
13793 memcpy(param_ptr, arg, arg_size);
13794 }
13795
13796 param_ptr += param_size;
13797 }
13798 }
13799
13801
13803 printf("encode rpc_id %d \"%s\" buf_size %d, param_size %d\n", rl.id, rl.name, (int)buf_size, (*nc)->header.param_size);
13804}
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 16623 of file midas.cxx.
16634{
16635 //printf("rpc_check_allowed_host: enabled %d, hostname [%s]\n", gAllowedHostsEnabled.load(), hostname);
16636
16639
16640 if (strcmp(hostname, "localhost") == 0)
16642
16643 if (strcmp(hostname, "localhost.localdomain") == 0)
16645
16646 if (strcmp(hostname, "localhost6") == 0) // RedHat el6, el7
16648
16649 if (strcmp(hostname, "ip6-localhost") == 0) // Ubuntu-22
16651
16653
16654 gAllowedHostsMutex.lock();
16655
16657 if (h == hostname) {
16659 break;
16660 }
16661 }
16662
16663 gAllowedHostsMutex.unlock();
16664
16665 //if (status != RPC_SUCCESS)
16666 // printf("rpc_check_allowed_host: enabled %d, hostname [%s] not found\n", gAllowedHostsEnabled.load(), hostname);
16667
16669}
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 17643 of file midas.cxx.
17661{
17663 NET_COMMAND nc;
17664 fd_set readfds;
17665 struct timeval timeout;
17666
17667 //printf("rpc_check_channels!\n");
17668
17672 if (sa == NULL)
17673 continue;
17674
17676 continue;
17677 }
17678
17680
17681 //printf("rpc_check_channels: idx %d, watchdog_timeout %d, last_activity %d, elapsed %d\n", idx, sa->watchdog_timeout, sa->last_activity, elapsed);
17682
17684
17685 //printf("rpc_check_channels: send watchdog message to %s on %s\n", sa->prog_name.c_str(), sa->host_name.c_str());
17686
17687 /* send a watchdog message */
17690
17692 if (convert_flags) {
17695 }
17696
17697 /* send the header to the client */
17699
17701 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, send_tcp() returned %d",
17702 sa->prog_name.c_str(),
17703 sa->host_name.c_str(),
17704 sa->watchdog_timeout / 1000,
17705 i);
17706
17707 /* disconnect from experiment */
17709 cm_disconnect_experiment();
17711 }
17712
17713 sa->close();
17715 }
17716
17718
17719 while (1) {
17720 FD_ZERO(&readfds);
17721 FD_SET(sa->send_sock, &readfds);
17722 FD_SET(sa->recv_sock, &readfds);
17723
17724 timeout.tv_sec = 1;
17725 timeout.tv_usec = 0;
17726
17728
17730
17731 //printf("waiting for reply: %d %d, diff %d, select() status %d\n", now, timeout_end_ms, timeout_end_ms - now, status);
17732
17733 if (now > timeout_end_ms) // timeout
17734 break;
17735
17737 break;
17738
17739 // select() returned 0, timeout
17740 // select() returned -1, error, likely EAGAIN or EINTR
17741
17742 cm_periodic_tasks();
17743 cm_msg_flush_buffer();
17744 }
17745
17747 !FD_ISSET(sa->recv_sock, &readfds)) {
17748
17749 cm_msg(MERROR, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec",
17750 sa->prog_name.c_str(),
17751 sa->host_name.c_str(),
17752 sa->watchdog_timeout / 1000);
17753
17754 /* disconnect from experiment */
17756 cm_disconnect_experiment();
17758 }
17759
17760 sa->close();
17762 }
17763
17764 /* receive result on send socket */
17768 cm_msg(MERROR, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, recv_tcp() returned %d",
17769 sa->prog_name.c_str(),
17770 sa->host_name.c_str(),
17771 sa->watchdog_timeout / 1000,
17772 i);
17773
17774 /* disconnect from experiment */
17776 cm_disconnect_experiment();
17778 }
17779
17780 sa->close();
17782 }
17783 }
17784 }
17785 }
17786 }
17787
17789}
INT recv_tcp(int sock, char *net_buffer, DWORD buffer_size, INT flags)
Definition system.cxx:5526
Definition msystem.h:362
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 16569 of file midas.cxx.
16585{
16586 gAllowedHostsMutex.lock();
16587 gAllowedHosts.clear();
16589 gAllowedHostsMutex.unlock();
16591}
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 16957 of file midas.cxx.
16978{
16980 INT client_hw_type = 0, hw_type;
16981 std::string client_program;
16982 std::string host_name;
16983 INT convert_flags;
16984 char net_buffer[256], *p;
16985
16986 int sock = accept(lsock, NULL, NULL);
16987
16988 if (sock == -1)
16990
16991 /* check access control list */
16994
16996 ss_socket_close(&sock);
16998 }
16999 }
17000
17002 client_program = "(unknown)";
17003
17004 /* receive string with timeout */
17007 ss_socket_close(&sock);
17009 }
17010
17011 /* get remote computer info */
17012 p = strtok(net_buffer, " ");
17013 if (p != NULL) {
17014 client_hw_type = atoi(p);
17015 p = strtok(NULL, " ");
17016 }
17017 if (p != NULL) {
17018 //version = atoi(p);
17019 p = strtok(NULL, " ");
17020 }
17021 if (p != NULL) {
17022 client_program = p;
17023 p = strtok(NULL, " ");
17024 }
17025 if (p != NULL) {
17026 host_name = p;
17027 p = strtok(NULL, " ");
17028 }
17029
17030 //printf("rpc_client_accept: client_hw_type %d, version %d, client_name \'%s\', hostname \'%s\'\n", client_hw_type, version, client_program, host_name);
17031
17033
17034 /* save information in _server_acception structure */
17035 sa->recv_sock = sock;
17036 sa->send_sock = 0;
17037 sa->event_sock = 0;
17038 sa->remote_hw_type = client_hw_type;
17040 sa->prog_name = client_program;
17042 sa->watchdog_timeout = 0;
17044
17045 /* send my own computer id */
17046 hw_type = rpc_get_hw_type();
17051
17052 rpc_calc_convert_flags(hw_type, client_hw_type, &convert_flags);
17053 sa->convert_flags = convert_flags;
17054
17056
17058}
INT ss_suspend_set_server_acceptions(RPC_SERVER_ACCEPTION_LIST *acceptions)
Definition system.cxx:4370
INT recv_string(int sock, char *buffer, DWORD buffer_size, INT millisec)
Definition system.cxx:5471
void rpc_calc_convert_flags(INT hw_type, INT remote_hw_type, INT *convert_flags)
Definition midas.cxx:11714
static RPC_SERVER_ACCEPTION * rpc_new_server_acception()
Definition midas.cxx:11649
static INT rpc_socket_check_allowed_host(int sock)
Definition midas.cxx:16672
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_call()
Definition at line 13926 of file midas.cxx.
13951{
13953
13957 }
13958
13959 //printf("rpc_client_call: handle %d, connection: ", hConn);
13960 //c->print();
13961 //printf("\n");
13962
13964
13966 routine_id &= ~RPC_NO_REPLY;
13967
13968 //if (rpc_no_reply)
13969 // printf("rpc_client_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
13970
13971 // make local copy of the client name just in case _client_connection is erased by another thread
13972
13973 /* find rpc_index */
13974
13975 RPC_LIST rpc_entry;
13976 bool rpc_cxx = false;
13977
13979
13981 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);
13982 c->mutex.unlock();
13984 }
13985
13987
13988 NET_COMMAND *nc = NULL;
13989
13990 /* examine variable argument list and convert it to parameter array */
13991 va_list ap;
13992 va_start(ap, routine_id);
13993
13994 if (rpc_cxx)
13995 rpc_call_encode_cxx(ap, rpc_entry, &nc);
13996 else
13997 rpc_call_encode(ap, rpc_entry, &nc);
13998
13999 va_end(ap);
14000
14002
14003 if (rpc_no_reply)
14005
14007
14008 /* in FAST TCP mode, only send call and return immediately */
14009 if (rpc_no_reply) {
14011
14013 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);
14014 free(nc);
14015 c->mutex.unlock();
14017 }
14018
14019 free(nc);
14020
14022 //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);
14023 //c->print();
14024 //printf("\n");
14025 c->close_locked();
14026 }
14027
14028 c->mutex.unlock();
14030 }
14031
14032 /* in TCP mode, send and wait for reply on send socket */
14035 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);
14036 c->mutex.unlock();
14038 }
14039
14040 free(nc);
14041 nc = NULL;
14042
14043 bool restore_watchdog_timeout = false;
14044 BOOL watchdog_call;
14045 DWORD watchdog_timeout;
14046 cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
14047
14048 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, c->rpc_timeout);
14049
14051 restore_watchdog_timeout = true;
14053 }
14054
14055 DWORD rpc_status = 0;
14056 DWORD buf_size = 0;
14057 char* buf = NULL;
14058
14059 /* receive result on send socket */
14061
14062 if (restore_watchdog_timeout) {
14063 cm_set_watchdog_params(watchdog_call, watchdog_timeout);
14064 }
14065
14067 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);
14068 if (buf)
14069 free(buf);
14070 c->mutex.unlock();
14072 }
14073
14075 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);
14076 if (buf)
14077 free(buf);
14078 c->mutex.unlock();
14080 }
14081
14082 c->mutex.unlock();
14083
14085 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);
14086 if (buf)
14087 free(buf);
14088 return rpc_status;
14089 }
14090
14091 /* extract result variables and place it to argument list */
14092
14093 va_start(ap, routine_id);
14094
14095 if (rpc_cxx)
14097 else
14099
14101 rpc_status = status;
14102 }
14103
14104 va_end(ap);
14105
14106 if (buf)
14107 free(buf);
14108 buf = NULL;
14109 buf_size = 0;
14110
14111 return rpc_status;
14112}
Definition midas.cxx:11571
INT cm_set_watchdog_params(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3299
static RPC_CLIENT_CONNECTION * rpc_get_locked_client_connection(HNDLE hConn)
Definition midas.cxx:12743
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 12401 of file midas.cxx.
12409{
12410#if 0
12413 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);
12414#endif
12415
12416 std::lock_guard<std::mutex> guard(_client_connections_mutex);
12417
12418 /* check for broken connections */
12422 std::lock_guard<std::mutex> cguard(c->mutex);
12423
12425 // implicit unlock
12426 continue;
12427 }
12428
12429 //printf("rpc_client_check: connection %d: ", i);
12430 //c->print();
12431 //printf("\n");
12432
12433 int ok = 0;
12434
12435 fd_set readfds;
12436 FD_ZERO(&readfds);
12437 FD_SET(c->send_sock, &readfds);
12438
12439 struct timeval timeout;
12440 timeout.tv_sec = 0;
12441 timeout.tv_usec = 0;
12442
12444
12445#ifdef OS_WINNT
12447#else
12448 do {
12451#endif
12452
12454 // implicit unlock
12455 continue;
12456 }
12457
12458 char buffer[64];
12459
12461 //printf("recv %d status %d, errno %d (%s)\n", sock, status, errno, strerror(errno));
12462
12464#ifndef OS_WINNT
12465 if (errno == EAGAIN) { // still connected
12466 ok = 1;
12467 } else
12468#endif
12469 {
12470 // connection error
12472 "RPC client connection to \"%s\" on host \"%s\" is broken, recv() errno %d (%s)",
12473 c->client_name.c_str(),
12474 c->host_name.c_str(),
12475 errno, strerror(errno));
12476 ok = 0;
12477 }
12479 // connection closed by remote end without sending an EXIT message
12480 // this can happen if the remote end has crashed, so this message
12481 // is still necessary as a useful diagnostic for unexpected crashes
12482 // of midas programs. K.O.
12483 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());
12484 ok = 0;
12485 } else {
12486 // read some data
12487 ok = 1;
12489 /* normal exit */
12490 ok = 0;
12491 }
12492 }
12493
12494 if (!ok) {
12495 //printf("rpc_client_check: closing connection %d: ", i);
12496 //c->print();
12497 //printf("\n");
12498
12499 // connection lost, close the socket
12500 c->close_locked();
12501 }
12502
12503 // implicit unlock
12504 }
12505 }
12506
12507 // implicit unlock of _client_connections_mutex
12508}
static std::vector< RPC_CLIENT_CONNECTION * > _client_connections
Definition midas.cxx:11635
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 12143 of file midas.cxx.
12166{
12169
12170 /* check if cm_connect_experiment was called */
12174 }
12175
12176 /* refuse connection to port 0 */
12177 if (port == 0) {
12180 }
12181
12183
12184 static std::mutex gHostnameMutex;
12185
12186 {
12187 std::lock_guard<std::mutex> guard(_client_connections_mutex);
12188
12190 printf("rpc_client_connect: host \"%s\", port %d, client \"%s\"\n", host_name, port, client_name);
12195 printf("\n");
12196 }
12197 }
12198 }
12199
12200 // slot with index 0 is not used, fill it with a NULL
12201
12203 _client_connections.push_back(NULL);
12204 }
12205
12206 bool hostname_locked = false;
12207
12208 /* check if connection already exists */
12212
12213 if (!hostname_locked) {
12214 gHostnameMutex.lock();
12215 hostname_locked = true;
12216 }
12217
12219 // NB: we must release the hostname lock before taking
12220 // c->mutex to avoid a locking order inversion deadlock:
12221 // later on we lock the hostname mutex while holding the c->mutex
12222 gHostnameMutex.unlock();
12223 hostname_locked = false;
12224 std::lock_guard<std::mutex> cguard(c->mutex);
12225 // check if socket is still connected
12227 // found connection slot with matching hostname and port number
12230 // so reuse it connection
12231 *hConnection = c->index;
12233 printf("already connected: ");
12234 c->print();
12235 printf("\n");
12236 }
12237 // implicit unlock of c->mutex
12238 // gHostnameLock is not locked here
12240 }
12241 //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);
12242 c->close_locked();
12243 }
12244 // implicit unlock of c->mutex
12245 }
12246 }
12247 }
12248
12249 if (hostname_locked) {
12250 gHostnameMutex.unlock();
12251 hostname_locked = false;
12252 }
12253
12254 // only start reusing connections once we have
12255 // a good number of slots allocated.
12257 static int last_reused = 0;
12258
12266 c->print();
12267 printf("\n");
12268 }
12269 last_reused = i;
12270 break;
12271 }
12272 }
12273 }
12274
12275 // no slots to reuse, allocate a new slot.
12278
12279 // if empty slot not found, add to end of array
12282
12284 printf("new connection appended to array: ");
12285 c->print();
12286 printf("\n");
12287 }
12288 }
12289
12290 c->mutex.lock();
12292
12293 // done with the array of connections
12294 // implicit unlock of _client_connections_mutex
12295 }
12296
12297 // locked connection slot for new connection
12298 assert(c != NULL);
12299
12300 std::string errmsg;
12301
12302 /* create a new socket for connecting to remote server */
12305 cm_msg(MERROR, "rpc_client_connect", "cannot connect to \"%s\" port %d: %s", host_name, port, errmsg.c_str());
12306 c->mutex.unlock();
12308 }
12309
12310 gHostnameMutex.lock();
12311
12313 c->port = port;
12314
12315 gHostnameMutex.unlock();
12316
12317 c->client_name = client_name;
12319
12320 /* set TCP_NODELAY option for better performance */
12321 i = 1;
12323
12324 /* send local computer info */
12325 std::string local_prog_name = rpc_get_name();
12326 std::string local_host_name = ss_gethostname();
12327
12329
12330 std::string cstr = msprintf("%d %s %s %s", hw_type, cm_get_version(), local_prog_name.c_str(), local_host_name.c_str());
12331
12332 int size = cstr.length() + 1;
12335 cm_msg(MERROR, "rpc_client_connect", "cannot send %d bytes, send() returned %d, errno %d (%s)", size, i, errno, strerror(errno));
12336 c->mutex.unlock();
12338 }
12339
12340 bool restore_watchdog_timeout = false;
12341 BOOL watchdog_call;
12342 DWORD watchdog_timeout;
12343 cm_get_watchdog_params(&watchdog_call, &watchdog_timeout);
12344
12345 //printf("watchdog timeout: %d, rpc_connect_timeout: %d\n", watchdog_timeout, _rpc_connect_timeout);
12346
12348 restore_watchdog_timeout = true;
12350 }
12351
12353
12354 /* receive remote computer info */
12356
12357 if (restore_watchdog_timeout) {
12358 cm_set_watchdog_params(watchdog_call, watchdog_timeout);
12359 }
12360
12363 c->close_locked();
12364 c->mutex.unlock();
12366 }
12367
12368 int remote_hw_type = 0;
12369 char remote_version[32];
12370 remote_version[0] = 0;
12372
12373 c->remote_hw_type = remote_hw_type;
12374
12375 /* print warning if version patch level doesn't agree */
12376 char v1[32];
12377 mstrlcpy(v1, remote_version, sizeof(v1));
12378 if (strchr(v1, '.'))
12379 if (strchr(strchr(v1, '.') + 1, '.'))
12380 *strchr(strchr(v1, '.') + 1, '.') = 0;
12381
12386
12388 cm_msg(MERROR, "rpc_client_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", remote_version, cm_get_version());
12389 }
12390
12392
12393 *hConnection = c->index;
12394
12395 c->mutex.unlock();
12396
12398}
INT ss_socket_connect_tcp(const char *hostname, int tcp_port, int *sockp, std::string *error_msg_p)
Definition system.cxx:5039
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_disconnect()
Definition at line 12807 of file midas.cxx.
12825{
12826 /* notify server about exit */
12827
12828 /* call exit and shutdown with RPC_NO_REPLY because client will exit immediately without possibility of replying */
12829
12830 rpc_client_call(hConn, bShutdown ? (RPC_ID_SHUTDOWN | RPC_NO_REPLY) : (RPC_ID_EXIT | RPC_NO_REPLY));
12831
12833}
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 12076 of file midas.cxx.
12084{
12086 char net_buffer[256];
12087
12091
12093
12102 fd_set readfds;
12103 struct timeval timeout;
12104
12105 //printf("rpc_client_dispatch: received MSG_BM!\n");
12106
12107 /* receive further messages to empty TCP queue */
12108 do {
12109 FD_ZERO(&readfds);
12110 FD_SET(sock, &readfds);
12111
12112 timeout.tv_sec = 0;
12113 timeout.tv_usec = 0;
12114
12115 select(FD_SETSIZE, &readfds, NULL, NULL, &timeout);
12116
12117 if (FD_ISSET(sock, &readfds)) {
12121
12129 }
12130 }
12131
12132 } while (FD_ISSET(sock, &readfds));
12133
12134 /* poll event from server */
12136 }
12137
12139}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_data()
Definition at line 11837 of file midas.cxx.
11865{
11866 /* convert array */
11869 /* don't convert TID_ARRAY & TID_STRUCT */
11870 if (single_size == 0)
11871 return;
11872
11874
11877 rpc_convert_single(p, tid, flags, convert_flags);
11878 }
11879 } else {
11881 }
11882}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_single()
Definition at line 11812 of file midas.cxx.
11812 {
11813
11816 if (tid == TID_UINT32 || tid == TID_INT32 || tid == TID_BOOL || tid == TID_FLOAT) DWORD_SWAP(data);
11818 }
11819
11826 }
11827
11834 }
11835}
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, |
| ... | |||
| ) |
◆ rpc_deregister_functions()
| INT rpc_deregister_functions | ( | void | ) |
dox
Definition at line 12001 of file midas.cxx.
12018{
12019 rpc_list_mutex.lock();
12020 rpc_list.clear();
12021 rpc_list_mutex.unlock();
12022
12024}
Here is the caller graph for this function:
◆ rpc_execute_cxx()
|
static |
Definition at line 15503 of file midas.cxx.
15530{
15532
15534
15535 /* extract pointer array to parameters */
15537
15538 /* convert header format (byte swapping) */
15539 if (convert_flags) {
15542 }
15543
15544 //if (nc_in->header.routine_id & RPC_NO_REPLY) {
15545 // printf("rpc_execute: routine_id %d, RPC_NO_REPLY\n", (int)(nc_in->header.routine_id & ~RPC_NO_REPLY));
15546 //}
15547
15548 /* no result return as requested */
15550 sock = 0;
15551
15553
15554 assert(xroutine_id == routine_id);
15555
15556#if 0
15559
15562
15565
15568#endif
15569
15570 /* find entry in rpc_list */
15571
15573
15576
15578
15581
15582 std::vector<RPE> params;
15583
15584 int nparams = 0;
15586 nparams++;
15587 }
15588
15589 params.resize(nparams);
15590
15591 size_t in_offset = 0;
15592
15594 in_param_size[i] = 0;
15595 in_param_offset[i] = 0;
15596
15599
15602
15604 arg_size = 1 + strlen((char *) (in_param_ptr));
15605 }
15606
15608 /* for arrays, the size is stored as a INT in front of the array */
15610 if (convert_flags)
15615 /* for std::vector<char> data, it is the true length of the array */
15616 arg_size = arg_size_align8;
15617 } else {
15618 /* true size is stored in the next parameter */
15619 arg_size = *((INT *) (((char*)in_param_ptr) + ALIGN8(arg_size_align8))); // NB: this ALIGN8() is redundant with ALIGN8() in the RPC client *encoder*
15620 if (convert_flags)
15622 }
15623 //printf("RPC_VARARRAY: arg_size %d %d\n", arg_size_align8, arg_size);
15624
15626 cm_msg(MERROR, "rpc_execute_cxx", "RPC %d, param %d tid %d flags 0x%x size mismatch: header %d vs next param %d", routine_id, i, tid, flags, arg_size_align8, arg_size);
15628 }
15629 }
15630
15633 }
15634
15636
15637 in_param_size[i] = param_size;
15638 in_param_offset[i] = in_offset;
15639
15640 params[i].offset = in_offset;
15641 params[i].arg_size = arg_size;
15642 params[i].param_size = param_size;
15643
15644 /* convert data format */
15645 if (convert_flags) {
15647 rpc_convert_data(in_param_ptr, tid, flags, param_size, convert_flags);
15648 } else {
15650 }
15651 }
15652
15653 in_param_ptr += param_size;
15654 in_offset += param_size;
15655 }
15656
15659
15663
15664 /* save maximum array length from the value of the next argument.
15665 * this means RPC_OUT arrays and strings should always be passed like this:
15666 * rpc_call(..., array_ptr, array_max_size, ...); */
15667
15668 params[i].out_max_size_offset = in_offset;
15669
15671
15672 if (convert_flags)
15674
15675 params[i].out_max_size = max_size;
15676 }
15677
15680 }
15681 }
15682
15688 //printf("STRING %d decode [%s]\n", i, (char*)nc_in->param + in_param_offset[i]);
15689 }
15694 params[i].pv->insert(params[i].pv->end(), (char*)nc_in->param + in_param_offset[i], (char*)nc_in->param + in_param_offset[i] + params[i].arg_size);
15695 //printf("VECTOR %d decode %zu bytes\n", i, params[i].pv->size());
15696 }
15698 } else {
15699 cm_msg(MERROR, "rpc_execute_cxx", "RPC %d: param %d tid %d flags 0x%x, TID not compatible with flag RPC_CXX", routine_id, i, tid, flags);
15701 }
15702 } else {
15705 params[i].pv->insert(params[i].pv->end(), (char*)nc_in->param + in_param_offset[i], (char*)nc_in->param + in_param_offset[i] + params[i].arg_size);
15707 //printf("param %d size %zu want %zu\n", i, params[i].pv->size(), want_size);
15709 params[i].pv->resize(want_size);
15713 //printf("param %d input value %d [%s]\n", i, *(int*)prpc_param[i], (char*)prpc_param[i]);
15718 //printf("param %d size %zu\n", i, params[i].pv->size());
15719 }
15720 }
15721
15723 printf("rpc_execute_cxx: param %2d, tid %2d, flags 0x%04x, in %3zu+%-3zu+%-3zu, out max size %3zu at %3zu, ptr %p\n", i, tid, flags, params[i].offset, params[i].arg_size, params[i].param_size, params[i].out_max_size, params[i].out_max_size_offset, prpc_param[i]);
15724 }
15725
15727 printf("rpc_execute_cxx: nc_in size %d, in_offset %zu\n", nc_in->header.param_size, in_offset);
15728
15730 bool ok = true;
15731
15732 ok &= in_param_offset[ 0] == 0; ok &= in_param_size[ 0] == 8; // int_in
15733 ok &= in_param_offset[ 1] == 0; ok &= in_param_size[ 1] == 0; // int_out
15734 ok &= in_param_offset[ 2] == 8; ok &= in_param_size[ 2] == 8; // &int_inout
15735 ok &= in_param_offset[ 3] == 16; ok &= in_param_size[ 3] == 16; // string_in
15736 ok &= in_param_offset[ 4] == 0; ok &= in_param_size[ 4] == 0; // string_out
15737 ok &= in_param_offset[ 5] == 32; ok &= in_param_size[ 5] == 8; // string_out size
15738 ok &= in_param_offset[ 6] == 0; ok &= in_param_size[ 6] == 0; // string2_out
15739 ok &= in_param_offset[ 7] == 40; ok &= in_param_size[ 7] == 8; // string2_out size
15740 ok &= in_param_offset[ 8] == 48; ok &= in_param_size[ 8] == 16; // string_inout
15741 ok &= in_param_offset[ 9] == 64; ok &= in_param_size[ 9] == 8; // string_inout size
15742 ok &= in_param_offset[10] == 72; ok &= in_param_size[10] == 72; // struct_in
15743 ok &= in_param_offset[11] == 0; ok &= in_param_size[11] == 0; // struct_out
15744 ok &= in_param_offset[12] == 144; ok &= in_param_size[12] == 72; // struct_inout
15745 ok &= in_param_offset[13] == 224; ok &= in_param_size[13] == 40; // uint32_t[10] array inout
15746 ok &= in_param_offset[14] == 264; ok &= in_param_size[14] == 8; // &size
15747 ok &= in_param_offset[15] == 280; ok &= in_param_size[15] == 16; // char[10] array in
15748 ok &= in_param_offset[16] == 296; ok &= in_param_size[16] == 8; // size
15749 ok &= in_param_offset[17] == 0; ok &= in_param_size[17] == 0; // char[16] array out
15750 ok &= in_param_offset[18] == 304; ok &= in_param_size[18] == 8; // &size
15751 ok &= in_offset == 312;
15752
15753 if (!ok) {
15756 }
15757 }
15758
15760 printf("rpc_execute_cxx: calling dispatch()\n");
15761 }
15762
15763 /*********************************\
15764 * call dispatch function *
15765 \*********************************/
15768 else
15770
15773 }
15774
15775 if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN || routine_id == RPC_ID_WATCHDOG)
15777
15778 /* return immediately for closed down client connections */
15781 }
15782
15785 }
15786
15787 /* Return if TCP connection broken */
15790 }
15791
15792 /* if sock == 0, we are in FTCP mode and may not sent results */
15793 if (!sock) {
15795 }
15796
15797 std::vector<char> v_out;
15798
15800
15805
15810
15812 printf("rpc_execute_cxx: param %2d, std::string arg_size %zu, param_size %zu, string [%s]\n", i, arg_size, param_size, params[i].ps->c_str());
15813
15815 v_out.resize(v_out.size() + param_size - arg_size); // pad to 8 bytes
15819
15821 printf("rpc_execute_cxx: param %2d, std::vector arg_size %zu, param_size %zu\n", i, arg_size, param_size);
15822
15825 if (convert_flags)
15829 v_out.resize(v_out.size() + param_size - arg_size); // pad data to 8 bytes
15830 } else {
15831 cm_msg(MERROR, "rpc_execute_cxx", "RPC %d: param %d tid %d flags 0x%x, TID not compatible with flag RPC_CXX", routine_id, i, tid, flags);
15833 }
15834 } else {
15835 size_t convert_offset = 0;
15836 size_t convert_size = 0;
15837
15841 //printf("param %d string param [%s] max_size %zu\n", i, param_ptr, max_size);
15842 size_t arg_size = 1 + strlen(param_ptr);
15843 if (arg_size > max_size) {
15844 param_ptr[max_size] = 0; // truncate!
15845 size_t arg_size = 1 + strlen(param_ptr);
15846 assert(arg_size == max_size);
15847 }
15849
15851 printf("rpc_execute_cxx: param %2d, string max_size %zu, string_size %zu, param_size %zu\n", i, max_size, arg_size, param_size);
15852
15853 v_out.insert(v_out.end(), param_ptr, param_ptr + arg_size);
15854 v_out.resize(v_out.size() + param_size - arg_size); // pad to 8 bytes
15860
15862 printf("rpc_execute_cxx: param %2d, array max_size %zu, param_size %zu\n", i, max_size, param_size);
15863
15866 if (convert_flags)
15869 convert_offset = v_out.size();
15870 convert_size = arg_size;
15871 v_out.insert(v_out.end(), param_ptr, param_ptr + arg_size); // data
15872 v_out.resize(v_out.size() + param_size - arg_size); // pad data to 8 bytes
15873 } else {
15879
15882 printf("rpc_execute_cxx: param %2d, tid %2d, arg_size %zu, param_size %zu, value %d\n", i, tid, arg_size, param_size, *(int*)param_ptr);
15883 } else {
15884 printf("rpc_execute_cxx: param %2d, tid %2d, arg_size %zu, param_size %zu\n", i, tid, arg_size, param_size);
15885 }
15886 }
15887
15888 convert_offset = v_out.size();
15889 convert_size = arg_size;
15890 v_out.insert(v_out.end(), param_ptr, param_ptr + arg_size); // data
15891 v_out.resize(v_out.size() + param_size - arg_size); // pad data to 8 bytes
15892 }
15893
15894 /* convert data format */
15895 if (convert_flags) {
15897 rpc_convert_data(v_out.data()+convert_offset, tid, rl.param[i].flags | RPC_OUTGOING, convert_size, convert_flags);
15898 else
15899 rpc_convert_data(v_out.data()+convert_offset, tid, rl.param[i].flags | RPC_OUTGOING, rl.param[i].n * rpc_tid_size(tid), convert_flags);
15900 }
15901 }
15902 }
15903 }
15904
15906
15907 /* send return parameters */
15910
15911
15912 /* convert header format (byte swapping) if necessary */
15913 if (convert_flags) {
15916 }
15917
15919
15923 }
15924
15927
15928 /* return SS_EXIT if RPC_EXIT is called */
15931
15932 /* return SS_SHUTDOWN if RPC_SHUTDOWN is called */
15935
15937}
void rpc_convert_data(void *data, INT tid, INT flags, INT total_size, INT convert_flags)
Definition midas.cxx:11837
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_execute_old()
|
static |
Definition at line 15096 of file midas.cxx.
15123{
15125 char *in_param_ptr, *out_param_ptr, *last_param_ptr;
15126 INT tid, flags;
15127 NET_COMMAND *nc_in, *nc_out;
15128 INT param_size, max_size;
15129 void *prpc_param[20];
15130 char debug_line[1024], *return_buffer;
15131 int return_buffer_size;
15132 int return_buffer_tls;
15133#ifdef FIXED_BUFFER
15135#else
15136 int initial_buffer_size = 1024;
15137#endif
15138
15139 /* return buffer must must use thread local storage multi-thread servers */
15145 tls_size = 1;
15146 }
15149 break;
15151 /* new thread -> allocate new buffer */
15156 tls_size++;
15157 }
15158
15159 return_buffer_tls = i;
15162 assert(return_buffer);
15163
15164 // make valgrind happy - the RPC parameter encoder skips the alignement padding bytes
15165 // and valgrind complains that we transmit uninitialized data
15166 //memset(return_buffer, 0, return_buffer_size);
15167
15168 /* extract pointer array to parameters */
15169 nc_in = (NET_COMMAND *) buffer;
15170
15171 /* convert header format (byte swapping) */
15172 if (convert_flags) {
15175 }
15176
15177 //if (nc_in->header.routine_id & RPC_NO_REPLY) {
15178 // printf("rpc_execute: routine_id %d, RPC_NO_REPLY\n", (int)(nc_in->header.routine_id & ~RPC_NO_REPLY));
15179 //}
15180
15181 /* no result return as requested */
15183 sock = 0;
15184
15185 /* find entry in rpc_list */
15187
15188 assert(xroutine_id == routine_id);
15189
15190 again:
15191
15192 in_param_ptr = nc_in->param;
15193
15194 nc_out = (NET_COMMAND *) return_buffer;
15195 out_param_ptr = nc_out->param;
15196
15198
15202
15205
15208
15210 /* for arrays, the size is stored as a INT in front of the array */
15211 param_size = *((INT *) in_param_ptr);
15212 if (convert_flags)
15214 param_size = ALIGN8(param_size);
15215
15217 }
15218
15221
15222 prpc_param[i] = in_param_ptr;
15223
15224 /* convert data format */
15225 if (convert_flags) {
15227 rpc_convert_data(in_param_ptr, tid, flags, param_size, convert_flags);
15228 else
15230 convert_flags);
15231 }
15232
15235 /* check for long strings (db_create_record...) */
15237 strcat(debug_line, "\"");
15238 strcat(debug_line, str.c_str());
15239 strcat(debug_line, "\"");
15240 } else
15241 strcat(debug_line, "...");
15242 } else
15243 strcat(debug_line, str.c_str());
15244
15245 in_param_ptr += param_size;
15246 }
15247
15250
15252
15253 /* save maximum array length from the value of the next argument.
15254 * this means RPC_OUT arrays and strings should always be passed like this:
15255 * rpc_call(..., array_ptr, array_max_size, ...); */
15256
15257 max_size = *((INT *) in_param_ptr);
15258
15259 if (convert_flags)
15261 max_size = ALIGN8(max_size);
15262
15263 *((INT *) out_param_ptr) = max_size;
15264
15265 /* save space for return array length */
15267
15268 /* use maximum array length from input */
15269 param_size = max_size;
15270 }
15271
15274
15276#ifdef FIXED_BUFFER
15278 "return parameters (%d) too large for network buffer (%d)",
15280
15282#else
15283 int itls;
15285
15286#if 0
15288 "rpc_execute: return parameters (%d) too large for network buffer (%d), new buffer size (%d)",
15289 (int)((POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size), return_buffer_size, new_size);
15290#endif
15291
15292 itls = return_buffer_tls;
15293
15296
15300 }
15301
15304 assert(return_buffer);
15305
15306 goto again;
15307#endif
15308 }
15309
15310 /* if parameter goes both directions, copy input to output */
15312 memcpy(out_param_ptr, prpc_param[i], param_size);
15313
15315 strcat(debug_line, "-");
15316
15317 prpc_param[i] = out_param_ptr;
15318 out_param_ptr += param_size;
15319 }
15320
15322 strcat(debug_line, ", ");
15323 }
15324
15325 //printf("predicted return size %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out);
15326
15327 strcat(debug_line, ")");
15328 rpc_debug_printf(debug_line);
15329
15330 last_param_ptr = out_param_ptr;
15331
15332 /*********************************\
15333 * call dispatch function *
15334 \*********************************/
15337 else
15339
15340 if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN || routine_id == RPC_ID_WATCHDOG)
15342
15343 /* return immediately for closed down client connections */
15346
15349
15350 /* Return if TCP connection broken */
15353
15354 /* if sock == 0, we are in FTCP mode and may not sent results */
15355 if (!sock)
15357
15358 /* compress variable length arrays */
15359 out_param_ptr = nc_out->param;
15365
15367 max_size = *((INT *) out_param_ptr);
15368 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
15369 // and prpc_param() is now pointing to the wrong place. here we know our string data
15370 // starts right after max_size and we do not need to use prpc_param[] to find it. K.O.
15371 //const char* param_ptr = (char *) prpc_param[i];
15373 //printf("string param [%s] max_size %d\n", param_ptr, max_size);
15374 param_size = strlen(param_ptr) + 1;
15375 param_size = ALIGN8(param_size);
15376
15377 /* move string ALIGN8(sizeof(INT)) left */
15379
15380 /* move remaining parameters to end of string */
15381 memmove(out_param_ptr + param_size,
15384 }
15385
15387 /* store array length at current out_param_ptr */
15388 max_size = *((INT *) out_param_ptr);
15389 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
15390 // and prpc_param() is now pointing to the wrong place. instead, compute location
15391 // of next parameter using max_size. K.O.
15392 // note: RPC_IN parameters are in the input buffer and we must use the prpc_param[] pointer. K.O.
15395 else
15398 if (convert_flags)
15400
15402
15403 param_size = ALIGN8(param_size);
15404
15405 /* move remaining parameters to end of array */
15406 memmove(out_param_ptr + param_size,
15407 out_param_ptr + max_size,
15409 }
15410
15413
15414 /* convert data format */
15415 if (convert_flags) {
15417 rpc_convert_data(out_param_ptr, tid,
15419 else
15420 rpc_convert_data(out_param_ptr, tid,
15423 }
15424
15425 out_param_ptr += param_size;
15426 }
15427
15428 /* send return parameters */
15432
15433 //printf("actual return size %d, buffer used %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out, sizeof(NET_COMMAND_HEADER) + param_size);
15434
15435 /* convert header format (byte swapping) if necessary */
15436 if (convert_flags) {
15439 }
15440
15441 // valgrind complains about sending uninitialized data, if you care about this, uncomment
15442 // the memset(return_buffer,0) call above (search for "valgrind"). K.O.
15443
15445
15449 }
15450
15451 /* print return buffer */
15452/*
15453 printf("Return buffer, ID %d:\n", routine_id);
15454 for (i=0; i<param_size ; i++)
15455 {
15456 status = (char) nc_out->param[i];
15457 printf("%02X ", status);
15458 if (i%8 == 7)
15459 printf("\n");
15460 }
15461*/
15462 /* return SS_EXIT if RPC_EXIT is called */
15465
15466 /* return SS_SHUTDOWN if RPC_SHUTDOWN is called */
15469
15471}
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
Definition odb.cxx:10865
Definition midas.cxx:15086
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_find_rpc()
|
static |
Definition at line 13900 of file midas.cxx.
13901{
13902 rpc_list_mutex.lock();
13903
13907
13908 rpc_list_mutex.unlock();
13909
13910 *prpc_cxx = false;
13911
13914 *prpc_cxx = true;
13915
13917 }
13918 }
13919
13920 rpc_list_mutex.unlock();
13921
13923}
Here is the caller graph for this function:
◆ rpc_flush_event()
| INT rpc_flush_event | ( | void | ) |
◆ rpc_flush_event_socket()
| int rpc_flush_event_socket | ( | int | timeout_msec | ) |
Definition at line 17525 of file midas.cxx.
17539{
17541
17542 //printf("ss_event_socket_has_data() returned %d\n", has_data);
17543
17544 if (has_data) {
17549 } else {
17554 }
17555 }
17556
17558
17559 //printf("rpc_server_receive_event() status %d\n", status);
17560
17563 }
17564
17567
17569}
INT rpc_server_receive_event(int idx, RPC_SERVER_ACCEPTION *sa, int timeout_msec)
Definition midas.cxx:17370
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 | ) |
◆ rpc_get_convert_flags() [2/2]
| INT rpc_get_convert_flags | ( | void | ) |
◆ rpc_get_hw_type()
| INT rpc_get_hw_type | ( | ) |
Definition at line 12965 of file midas.cxx.
12976{
12977 {
12978 {
12979 INT tmp_type, size;
12980 DWORD dummy;
12981 unsigned char *p;
12982 float f;
12984
12985 tmp_type = 0;
12986
12987 /* test pointer size */
12988 size = sizeof(p);
12989 if (size == 2)
12990 tmp_type |= DRI_16;
12991 if (size == 4)
12992 tmp_type |= DRI_32;
12993 if (size == 8)
12994 tmp_type |= DRI_64;
12995
12996 /* test if little or big endian machine */
12997 dummy = 0x12345678;
12998 p = (unsigned char *) &dummy;
12999 if (*p == 0x78)
13000 tmp_type |= DRI_LITTLE_ENDIAN;
13001 else if (*p == 0x12)
13002 tmp_type |= DRI_BIG_ENDIAN;
13003 else
13005
13006 /* floating point format */
13007 f = (float) 1.2345;
13008 dummy = 0;
13009 memcpy(&dummy, &f, sizeof(f));
13010 if ((dummy & 0xFF) == 0x19 &&
13011 ((dummy >> 8) & 0xFF) == 0x04 && ((dummy >> 16) & 0xFF) == 0x9E
13012 && ((dummy >> 24) & 0xFF) == 0x3F)
13013 tmp_type |= DRF_IEEE;
13014 else if ((dummy & 0xFF) == 0x9E &&
13015 ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x19
13016 && ((dummy >> 24) & 0xFF) == 0x04)
13017 tmp_type |= DRF_G_FLOAT;
13018 else
13020
13021 d = (double) 1.2345;
13022 dummy = 0;
13024 if ((dummy & 0xFF) == 0x8D && /* little endian */
13025 ((dummy >> 8) & 0xFF) == 0x97 && ((dummy >> 16) & 0xFF) == 0x6E
13026 && ((dummy >> 24) & 0xFF) == 0x12)
13027 tmp_type |= DRF_IEEE;
13028 else if ((dummy & 0xFF) == 0x83 && /* big endian */
13029 ((dummy >> 8) & 0xFF) == 0xC0 && ((dummy >> 16) & 0xFF) == 0xF3
13030 && ((dummy >> 24) & 0xFF) == 0x3F)
13031 tmp_type |= DRF_IEEE;
13032 else if ((dummy & 0xFF) == 0x13 &&
13033 ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x83
13034 && ((dummy >> 24) & 0xFF) == 0xC0)
13035 tmp_type |= DRF_G_FLOAT;
13036 else if ((dummy & 0xFF) == 0x9E &&
13037 ((dummy >> 8) & 0xFF) == 0x40 && ((dummy >> 16) & 0xFF) == 0x18
13038 && ((dummy >> 24) & 0xFF) == 0x04)
13040 "MIDAS cannot handle VAX D FLOAT format. Please compile with the /g_float flag");
13041 else
13043
13044 return tmp_type;
13045 }
13046 }
13047}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_get_locked_client_connection()
|
static |
Definition at line 12743 of file midas.cxx.
12744{
12745 _client_connections_mutex.lock();
12749 _client_connections_mutex.unlock();
12752 // disconnected while we were waiting for the lock
12753 c->mutex.unlock();
12754 return NULL;
12755 }
12757 }
12758 }
12759 _client_connections_mutex.unlock();
12760 return NULL;
12761}
Here is the caller graph for this function:
◆ rpc_get_mserver_acception()
| RPC_SERVER_ACCEPTION * rpc_get_mserver_acception | ( | void | ) |
◆ rpc_get_mserver_hostname()
| std::string rpc_get_mserver_hostname | ( | void | ) |
◆ rpc_get_mserver_path()
| const char * rpc_get_mserver_path | ( | void | ) |
◆ rpc_get_name()
| std::string rpc_get_name | ( | ) |
◆ rpc_get_opt_tcp_size()
◆ rpc_get_timeout()
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 13104 of file midas.cxx.
13105{
13110 } else {
13114 c->mutex.unlock();
13115 return timeout;
13116 }
13117 }
13118 return 0;
13119}
Here is the call graph for this function:
◆ rpc_ieee2vax_double()
| void rpc_ieee2vax_double | ( | double * | var | ) |
Definition at line 11792 of file midas.cxx.
11792 {
11793 unsigned short int i1, i2, i3, i4;
11794
11795 /* swap words */
11796 i1 = *((short int *) (var) + 3);
11797 i2 = *((short int *) (var) + 2);
11798 i3 = *((short int *) (var) + 1);
11799 i4 = *((short int *) (var));
11800
11801 /* correct exponent */
11802 if (i1 != 0)
11803 i1 += 0x20;
11804
11805 *((short int *) (var) + 3) = i4;
11806 *((short int *) (var) + 2) = i3;
11807 *((short int *) (var) + 1) = i2;
11808 *((short int *) (var)) = i1;
11809}
Here is the caller graph for this function:
◆ rpc_ieee2vax_float()
| void rpc_ieee2vax_float | ( | float * | var | ) |
Definition at line 11742 of file midas.cxx.
11742 {
11743 unsigned short int lo, hi;
11744
11745 /* swap hi and lo word */
11746 lo = *((short int *) (var) + 1);
11747 hi = *((short int *) (var));
11748
11749 /* correct exponent */
11750 if (lo != 0)
11751 lo += 0x100;
11752
11753 *((short int *) (var) + 1) = hi;
11754 *((short int *) (var)) = lo;
11755}
Here is the caller graph for this function:
◆ rpc_is_connected()
| bool rpc_is_connected | ( | void | ) |
◆ rpc_is_mserver()
| bool rpc_is_mserver | ( | void | ) |
◆ rpc_is_remote()
◆ rpc_name_tid()
| int rpc_name_tid | ( | const char * | name | ) |
◆ rpc_new_server_acception()
|
static |
Definition at line 11649 of file midas.cxx.
11650{
11653 //printf("rpc_new_server_acception: reuse acception in slot %d\n", idx);
11655 }
11656 }
11657
11659
11662 //printf("rpc_new_server_acception: new acception, reuse slot %d\n", idx);
11663 _server_acceptions[idx] = sa;
11665 }
11666 }
11667
11668 //printf("rpc_new_server_acception: new acception, array size %d, push_back\n", (int)_server_acceptions.size());
11669 _server_acceptions.push_back(sa);
11670
11671 return sa;
11672}
struct rpc_server_acception_struct RPC_SERVER_ACCEPTION
Here is the caller graph for this function:
◆ rpc_register_client()
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 11939 of file midas.cxx.
11939 {
11943
11945}
INT rpc_register_functions(const RPC_LIST *new_list, RPC_HANDLER func)
Definition midas.cxx:11958
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_register_function()
Definition at line 12028 of file midas.cxx.
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 11958 of file midas.cxx.
11959{
11961 /* check valid ID for user functions */
11965 cm_msg(MERROR, "rpc_register_functions", "registered RPC function with invalid ID %d", new_list[i].id);
11966 }
11967 }
11968
11969 std::lock_guard<std::mutex> guard(rpc_list_mutex);
11970
11971 /* check double defined functions */
11976 }
11977 }
11978 }
11979
11980 /* append new functions */
11983
11984 /* set default dispatcher */
11987 }
11988
11990 }
11991
11993}
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 15025 of file midas.cxx.
15048{
15049 /* register system functions: RPC_ID_EXIT, RPC_ID_SHUTDOWN, RPC_ID_WATCHDOG */
15051
15052 /* create a socket for listening */
15053 int lsock = 0;
15054 int lport = 0;
15055 std::string errmsg;
15056
15057 int status = ss_socket_listen_tcp(!disable_bind_rpc_to_localhost, port, &lsock, &lport, &errmsg);
15058
15060 cm_msg(MERROR, "rpc_register_server", "cannot listen to tcp port %d: %s", port, errmsg.c_str());
15062 }
15063
15064 /* set close-on-exec flag to prevent child mserver processes from inheriting the listen socket */
15065#if defined(F_SETFD) && defined(FD_CLOEXEC)
15066 status = fcntl(lsock, F_SETFD, fcntl(lsock, F_GETFD) | FD_CLOEXEC);
15068 cm_msg(MERROR, "rpc_register_server", "fcntl(F_SETFD, FD_CLOEXEC) failed, errno %d (%s)", errno, strerror(errno));
15070 }
15071#endif
15072
15073 /* return port wich OS has choosen */
15074 if (pport) {
15075 *pport = lport;
15076 }
15077
15078 if (plsock)
15079 *plsock = lsock;
15080
15081 //printf("rpc_register_server: requested port %d, actual port %d, socket %d\n", port, *pport, *plsock);
15082
15084}
INT ss_socket_listen_tcp(bool listen_localhost, int tcp_port, int *sockp, int *tcp_port_p, std::string *error_msg_p)
Definition system.cxx:5134
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 14984 of file midas.cxx.
15006{
15008 int lsock;
15009
15013
15017
15018 if (plsock)
15019 *plsock = lsock;
15020
15022}
INT ss_suspend_set_client_listener(int listen_socket)
Definition system.cxx:4356
INT rpc_register_listener(int port, RPC_HANDLER func, int *plsock, int *pport)
Definition midas.cxx:15025
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 14349 of file midas.cxx.
14350{
14353 } else {
14355 }
14356}
INT bm_send_event(INT buffer_handle, const EVENT_HEADER *pevent, int unused, int timeout_msec)
Definition midas.cxx:9689
INT rpc_send_event1(INT buffer_handle, const EVENT_HEADER *pevent)
Definition midas.cxx:14367
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 14367 of file midas.cxx.
14368{
14371}
INT rpc_send_event_sg(INT buffer_handle, int sg_n, const char *const sg_ptr[], const size_t sg_len[])
Definition midas.cxx:14373
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 14373 of file midas.cxx.
14374{
14375 if (sg_n < 1) {
14378 }
14379
14380 if (sg_ptr[0] == NULL) {
14383 }
14384
14386 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));
14388 }
14389
14391
14392 const DWORD MAX_DATA_SIZE = (0x7FFFFFF0 - 16); // event size computations are not 32-bit clean, limit event size to 2GB. K.O.
14394
14395 if (data_size == 0) {
14398 }
14399
14400 if (data_size > MAX_DATA_SIZE) {
14401 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);
14403 }
14404
14407
14411 }
14412
14414 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);
14416 }
14417
14418 // protect non-atomic access to _server_connection.event_sock. K.O.
14419
14421
14422 //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);
14423
14426 }
14427
14428 //
14429 // event socket wire protocol: (see also rpc_server_receive_event() and recv_event_server_realloc())
14430 //
14431 // 4 bytes of buffer handle
14432 // 16 bytes of event header, includes data_size
14433 // ALIGN8(data_size) bytes of event data
14434 //
14435
14437
14438 /* send buffer handle */
14439
14441 DWORD bh_buf = buffer_handle;
14442
14446 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(buffer handle) failed, event socket is now closed");
14448 }
14449
14450 /* send data */
14451
14456 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(event data) failed, event socket is now closed");
14458 }
14459 }
14460
14461 /* send padding */
14462
14464 char padding[8] = { 0,0,0,0,0,0,0,0 };
14466 assert(padlen < 8);
14470 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(padding) failed, event socket is now closed");
14472 }
14473 }
14474
14476}
INT ss_write_tcp(int sock, const char *buffer, size_t buffer_size)
Definition system.cxx:5424
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 16700 of file midas.cxx.
16721{
16723 INT sock;
16726 INT port1, port2, port3;
16727 char *ptr;
16728 char net_buffer[256];
16729 struct linger ling;
16730
16732
16733 if (lsock > 0) {
16734 sock = accept(lsock, NULL, NULL);
16735
16736 if (sock == -1)
16738 } else {
16739 /* lsock is stdin -> already connected from inetd */
16740
16741 sock = lsock;
16742 }
16743
16744 /* check access control list */
16747
16749 ss_socket_close(&sock);
16751 }
16752 }
16753
16754 /* receive string with timeout */
16757
16759 char command = (char) toupper(net_buffer[0]);
16760
16761 //printf("rpc_server_accept: command [%c]\n", command);
16762
16763 switch (command) {
16764 case 'S': {
16765
16766 /*----------- shutdown listener ----------------------*/
16767 ss_socket_close(&sock);
16769 }
16770 case 'I': {
16771
16772 /*----------- return available experiments -----------*/
16773#ifdef LOCAL_ROUTINES
16774 exptab_struct exptab;
16780 }
16781 send(sock, "", 1, 0);
16782#endif
16783 ss_socket_close(&sock);
16784 break;
16785 }
16786 case 'C': {
16787
16788 /*----------- connect to experiment -----------*/
16789
16790 /* get callback information */
16792 port1 = port2 = version[0] = 0;
16793
16794 //printf("rpc_server_accept: net buffer \'%s\'\n", net_buffer);
16795
16796 /* parse string in format "C port1 port2 port3 version expt" */
16797 /* example: C 51046 45838 56832 2.0.0 alpha */
16798
16799 port1 = strtoul(net_buffer + 2, &ptr, 0);
16800 port2 = strtoul(ptr, &ptr, 0);
16801 port3 = strtoul(ptr, &ptr, 0);
16802
16803 while (*ptr == ' ')
16804 ptr++;
16805
16806 i = 0;
16808 version[i++] = *ptr++;
16809
16810 // ensure that we do not overwrite buffer "version"
16812 version[i] = 0;
16813
16814 // skip wjatever is left from the "version" string
16815 for (; *ptr != 0 && *ptr != ' ';)
16816 ptr++;
16817
16818 while (*ptr == ' ')
16819 ptr++;
16820
16821 i = 0;
16822 for (; *ptr != 0 && *ptr != ' ' && *ptr != '\n' && *ptr != '\r' && i < (int) sizeof(experiment) - 1;)
16824
16825 // ensure that we do not overwrite buffer "experiment"
16828
16830
16831 /* print warning if version patch level doesn't agree */
16832 mstrlcpy(v1, version, sizeof(v1));
16833 if (strchr(v1, '.'))
16834 if (strchr(strchr(v1, '.') + 1, '.'))
16835 *strchr(strchr(v1, '.') + 1, '.') = 0;
16836
16842
16844 cm_msg(MERROR, "rpc_server_accept", "client MIDAS version %s differs from local version %s", version, cm_get_version());
16846 }
16847
16852
16854
16856 ss_socket_close(&sock);
16857 break;
16858 }
16859
16860#ifdef LOCAL_ROUTINES
16861 /* update experiment definition */
16862 exptab_struct exptab;
16864
16865 unsigned idx = 0;
16866 bool found = false;
16867 /* lookup experiment */
16869 found = true;
16870 idx = 0;
16871 } else {
16875 found = true;
16876 break;
16877 }
16878 }
16879 }
16880 }
16881
16882 if (!found) {
16883 cm_msg(MERROR, "rpc_server_accept", "experiment \'%s\' not defined in exptab file \'%s\'", callback.experiment.c_str(), exptab.filename.c_str());
16884
16885 send(sock, "2", 2, 0); /* 2 means exp. not found */
16886 ss_socket_close(&sock);
16887 break;
16888 }
16889
16892
16893 /* create a new process */
16894 char host_port1_str[30], host_port2_str[30], host_port3_str[30];
16895 char debug_str[30];
16896
16901
16903
16904 const char *argv[10];
16905 argv[0] = mserver_path;
16907 argv[2] = host_port1_str;
16908 argv[3] = host_port2_str;
16909 argv[4] = host_port3_str;
16910 argv[5] = debug_str;
16914 argv[9] = NULL;
16915
16917 argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8],
16918 argv[9]);
16919
16921
16924
16927 ss_socket_close(&sock);
16928 break;
16929 }
16930
16933#endif // LOCAL_ROUTINES
16934 ss_socket_close(&sock);
16935
16936 break;
16937 }
16938 default: {
16939 cm_msg(MERROR, "rpc_server_accept", "received unknown command '%c' code %d", command, command);
16940 ss_socket_close(&sock);
16941 break;
16942 }
16943 }
16944 } else { /* if i>0 */
16945
16946 /* lingering needed for PCTCP */
16947 ling.l_onoff = 1;
16948 ling.l_linger = 0;
16949 setsockopt(sock, SOL_SOCKET, SO_LINGER, (char *) &ling, sizeof(ling));
16950 ss_socket_close(&sock);
16951 }
16952
16954}
INT ss_socket_get_peer_name(int sock, std::string *hostp, int *portp)
Definition system.cxx:5318
INT ss_spawnv(INT mode, const char *cmdname, const char *const argv[])
Definition system.cxx:1702
Definition msystem.h:317
Definition midas.cxx:1616
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 17061 of file midas.cxx.
17080{
17082 int recv_sock, send_sock, event_sock;
17084 std::string client_program;
17085 INT client_hw_type, hw_type;
17086 INT convert_flags;
17087 char net_buffer[256];
17088 char *p;
17089 int flag;
17090
17091 /* copy callback information */
17093 //idx = callback.index;
17094
17095 std::string errmsg;
17096
17097 /* create new sockets for TCP */
17098 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port1, &recv_sock, &errmsg);
17099
17101 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());
17102 ss_socket_close(&recv_sock);
17103 //ss_socket_close(&send_sock);
17104 //ss_socket_close(&event_sock);
17106 }
17107
17108 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port2, &send_sock, &errmsg);
17109
17111 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());
17112 ss_socket_close(&recv_sock);
17113 ss_socket_close(&send_sock);
17114 //ss_socket_close(&event_sock);
17116 }
17117
17118 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port3, &event_sock, &errmsg);
17119
17121 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());
17122 ss_socket_close(&recv_sock);
17123 ss_socket_close(&send_sock);
17124 ss_socket_close(&event_sock);
17126 }
17127#ifndef OS_ULTRIX /* crashes ULTRIX... */
17128 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
17129 flag = 2 * 1024 * 1024;
17132 cm_msg(MERROR, "rpc_server_callback", "cannot setsockopt(SOL_SOCKET, SO_RCVBUF), errno %d (%s)", errno,
17133 strerror(errno));
17134#endif
17135
17138 ss_socket_close(&recv_sock);
17139 ss_socket_close(&send_sock);
17140 ss_socket_close(&event_sock);
17142 }
17143 //printf("rpc_server_callback: \'%s\'\n", net_buffer);
17144
17145 /* get remote computer info */
17146 client_hw_type = strtoul(net_buffer, &p, 0);
17147
17148 while (*p == ' ')
17149 p++;
17150
17151 client_program = p;
17152
17153 //printf("hw type %d, name \'%s\'\n", client_hw_type, client_program);
17154
17155 std::string host_name;
17156
17158
17161
17162 //printf("rpc_server_callback: mserver acception\n");
17163
17165
17166 /* save information in _server_acception structure */
17167 sa->recv_sock = recv_sock;
17168 sa->send_sock = send_sock;
17169 sa->event_sock = event_sock;
17170 sa->remote_hw_type = client_hw_type;
17172 sa->prog_name = client_program;
17174 sa->watchdog_timeout = 0;
17176
17177 assert(_mserver_acception == NULL);
17178
17179 _mserver_acception = sa;
17180
17181 //printf("rpc_server_callback: _mserver_acception %p\n", _mserver_acception);
17182
17183 /* send my own computer id */
17184 hw_type = rpc_get_hw_type();
17187
17188 rpc_calc_convert_flags(hw_type, client_hw_type, &convert_flags);
17189 sa->convert_flags = convert_flags;
17190
17192
17194 rpc_debug_printf("Connection to %s:%s established\n", sa->host_name.c_str(), sa->prog_name.c_str());
17195 }
17196
17198}
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 12512 of file midas.cxx.
12540{
12542 INT remote_hw_type, hw_type;
12544 fd_set readfds;
12545 struct timeval timeout;
12547 char *s;
12548
12549#ifdef OS_WINNT
12550 {
12551 WSADATA WSAData;
12552
12553 /* Start windows sockets */
12554 if (WSAStartup(MAKEWORD(1, 1), &WSAData) != 0)
12556 }
12557#endif
12558
12559 /* check if local connection */
12562
12563 /* register system functions */
12565
12566 /* check if cm_connect_experiment was called */
12570 }
12571
12572 /* check if connection already exists */
12575
12579
12580 bool listen_localhost = false;
12581
12583 listen_localhost = true;
12584
12585 int lsock1, lport1;
12586 int lsock2, lport2;
12587 int lsock3, lport3;
12588
12589 std::string errmsg;
12590
12592
12596 }
12597
12599
12603 }
12604
12606
12610 }
12611
12612 /* extract port number from host_name */
12615 if (s) {
12616 *s = 0;
12617 port = strtoul(s + 1, NULL, 0);
12618 }
12619
12620 int sock;
12621
12623
12625 cm_msg(MERROR, "rpc_server_connect", "cannot connect to mserver on host \"%s\" port %d: %s", str, port, errmsg.c_str());
12627 }
12628
12629 /* connect to experiment */
12632 else
12634
12637 ss_socket_close(&sock);
12641 }
12642
12643 status = version[0] = 0;
12645
12647/* message "undefined experiment" should be displayed by application */
12649 }
12650
12651 /* print warning if version patch level doesn't agree */
12652 strcpy(v1, version);
12653 if (strchr(v1, '.'))
12654 if (strchr(strchr(v1, '.') + 1, '.'))
12655 *strchr(strchr(v1, '.') + 1, '.') = 0;
12656
12661
12663 cm_msg(MERROR, "rpc_server_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", version,
12664 cm_get_version());
12665 }
12666
12667 /* wait for callback on send and recv socket with timeout */
12668 FD_ZERO(&readfds);
12669 FD_SET(lsock1, &readfds);
12670 FD_SET(lsock2, &readfds);
12671 FD_SET(lsock3, &readfds);
12672
12673 timeout.tv_sec = _rpc_connect_timeout / 1000;
12674 timeout.tv_usec = 0;
12675
12676 do {
12678
12679 /* if an alarm signal was cought, restart select with reduced timeout */
12681 timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
12682
12684
12685 if (!FD_ISSET(lsock1, &readfds)) {
12687 ss_socket_close(&lsock1);
12688 ss_socket_close(&lsock2);
12689 ss_socket_close(&lsock3);
12691 }
12692
12696
12697 if (_server_connection.send_sock == -1 || _server_connection.recv_sock == -1 || _server_connection.event_sock == -1) {
12700 }
12701
12702 ss_socket_close(&lsock1);
12703 ss_socket_close(&lsock2);
12704 ss_socket_close(&lsock3);
12705
12706 /* set TCP_NODELAY option for better performance */
12707 int flag = 1;
12708 setsockopt(_server_connection.send_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12709 setsockopt(_server_connection.event_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12710
12711 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
12712 flag = 2 * 1024 * 1024;
12713 status = setsockopt(_server_connection.event_sock, SOL_SOCKET, SO_SNDBUF, (char *) &flag, sizeof(flag));
12715 cm_msg(MERROR, "rpc_server_connect", "cannot setsockopt(SOL_SOCKET, SO_SNDBUF), errno %d (%s)", errno, strerror(errno));
12716
12717 /* send local computer info */
12718 std::string local_prog_name = rpc_get_name();
12719 hw_type = rpc_get_hw_type();
12721
12723
12724 /* receive remote computer info */
12729 }
12730
12733
12735
12737
12739}
INT ss_suspend_set_client_connection(RPC_SERVER_CONNECTION *connection)
Definition system.cxx:4363
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 12836 of file midas.cxx.
12856{
12857 static int rpc_server_disconnect_recursion_level = 0;
12858
12859 if (rpc_server_disconnect_recursion_level)
12861
12862 rpc_server_disconnect_recursion_level = 1;
12863
12864 /* flush remaining events */
12865 rpc_flush_event();
12866
12867 /* notify server about exit */
12870 }
12871
12872 /* close sockets */
12879
12881
12882 /* remove semaphore */
12885 _mutex_rpc = NULL;
12886
12887 rpc_server_disconnect_recursion_level = 0;
12889}
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 17202 of file midas.cxx.
17210{
17211 while (1) {
17213
17215 break;
17216
17218 break;
17219
17220 /* check alarms, etc */
17222
17223 cm_msg_flush_buffer();
17224 }
17225
17227}
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 17370 of file midas.cxx.
17384{
17386
17388
17389 //
17390 // THIS IS NOT THREAD SAFE!!!
17391 //
17392 // IT IS ONLY USED BY THE MSERVER
17393 // MSERVER IS SINGLE-THREADED!!!
17394 //
17395
17396 static char *xbuf = NULL;
17397 static int xbufsize = 0;
17398 static bool xbufempty = true;
17399
17400 // short cut
17401 if (sa == NULL && xbufempty)
17403
17404 static bool recurse = false;
17405
17406 if (recurse) {
17408 // do not do anything if we are called recursively
17409 // via recursive ss_suspend() or otherwise. K.O.
17410 if (xbufempty)
17412 else
17414 }
17415
17416 recurse = true;
17417
17418 do {
17419 if (xbufempty && sa) {
17421
17422 if (n_received < 0) {
17424 cm_msg(MERROR, "rpc_server_receive_event", "recv_event_server_realloc() returned %d, abort", n_received);
17425 goto error;
17426 }
17427
17428 if (n_received == 0) {
17429 // no more data in the tcp socket
17430 recurse = false;
17432 }
17433
17434 xbufempty = false;
17435 }
17436
17437 if (xbufempty) {
17438 // no event in xbuf buffer
17439 recurse = false;
17441 }
17442
17443 /* send event to buffer */
17446
17448
17449 //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);
17450
17452 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d (SS_ABORT), abort", status);
17453 goto error;
17454 }
17455
17457 //cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, event buffer is full", status);
17458 recurse = false;
17460 }
17461
17463 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, mserver dropped this event", status);
17464 }
17465
17466 xbufempty = true;
17467
17468 /* repeat for maximum 0.5 sec */
17470
17471 recurse = false;
17473
17474 error:
17475
17476 {
17481 cm_msg(MTALK, "rpc_server_receive_event", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
17482 }
17483
17484 //exit:
17485
17486 cm_msg_flush_buffer();
17487
17488 /* disconnect from experiment as MIDAS server */
17491
17493
17494 /* only disconnect from experiment if previously connected.
17495 Necessary for pure RPC servers (RPC_SRVR) */
17497 bm_close_all_buffers();
17499 db_close_all_databases();
17500
17501 rpc_deregister_functions();
17502
17503 cm_set_experiment_database(0, 0);
17504 }
17505 }
17506
17508
17509 sa->close();
17510
17511 /* signal caller a shutdonw */
17514
17515 /* only the mserver should stop on server connection closure */
17516 if (!is_mserver) {
17518 }
17519
17521}
INT cm_get_experiment_database(HNDLE *hDB, HNDLE *hKeyClient)
Definition midas.cxx:3027
INT cm_set_experiment_database(HNDLE hDB, HNDLE hKeyClient)
Definition midas.cxx:2955
static int recv_event_server_realloc(INT idx, RPC_SERVER_ACCEPTION *psa, char **pbuffer, int *pbuffer_size)
Definition midas.cxx:14833
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 | ( | RPC_SERVER_ACCEPTION * | sa | ) |
Definition at line 17230 of file midas.cxx.
17245{
17247 int remaining = 0;
17248
17249 char *buf = NULL;
17250 int bufsize = 0;
17251
17252 do {
17254
17255 if (n_received <= 0) {
17258 goto error;
17259 }
17260
17261 /* extract pointer array to parameters */
17262 NET_COMMAND nc_in;
17263
17264 memcpy(&nc_in, buf, sizeof(nc_in));
17265
17266 /* convert header format (byte swapping) */
17270 }
17271
17273
17274 RPC_LIST rpc_entry;
17275 bool rpc_cxx = false;
17276
17278
17281 goto error;
17282 }
17283
17284 if (rpc_cxx)
17286 else
17288
17291 goto error;
17292 }
17293
17296 rpc_debug_printf("Connection to %s:%s closed\n", sa->host_name.c_str(), sa->prog_name.c_str());
17297 goto exit;
17298 }
17299
17300 } while (remaining);
17301
17302 if (buf) {
17303 free(buf);
17304 buf = NULL;
17305 bufsize = 0;
17306 }
17307
17309
17310 error:
17311
17312 {
17317 cm_msg(MTALK, "rpc_server_receive_rpc", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
17318 }
17319
17320 exit:
17321
17322 cm_msg_flush_buffer();
17323
17324 if (buf) {
17325 free(buf);
17326 buf = NULL;
17327 bufsize = 0;
17328 }
17329
17330 /* disconnect from experiment as MIDAS server */
17332
17335
17337
17339
17340 /* only disconnect from experiment if previously connected.
17341 Necessary for pure RPC servers (RPC_SRVR) */
17343 bm_close_all_buffers();
17345 db_close_all_databases();
17346
17347 rpc_deregister_functions();
17348
17349 cm_set_experiment_database(0, 0);
17350 }
17351 }
17352
17354
17355 sa->close();
17356
17357 /* signal caller a shutdonw */
17360
17361 /* only the mserver should stop on server connection closure */
17362 if (!is_mserver) {
17364 }
17365
17367}
static INT rpc_execute_old(INT sock, int xroutine_id, const RPC_LIST &rl, char *buffer, INT convert_flags)
Definition midas.cxx:15096
static INT rpc_execute_cxx(INT sock, int xroutine_id, const RPC_LIST &rl, char *buffer, INT convert_flags)
Definition midas.cxx:15503
static int recv_net_command_realloc(RPC_SERVER_ACCEPTION *sa, char **pbuf, int *pbufsize, INT *remaining)
Definition midas.cxx:14645
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 17572 of file midas.cxx.
17589{
17590 //printf("rpc_server_shutdown!\n");
17591
17592 struct linger ling;
17593
17594 /* close all open connections */
17598 /* lingering needed for PCTCP */
17599 ling.l_onoff = 1;
17600 ling.l_linger = 0;
17603
17607 }
17608
17612 }
17613 }
17614 }
17615
17616 /* avoid memory leak */
17619 if (sa) {
17620 //printf("rpc_server_shutdown: %d %p %p\n", idx, sa, _mserver_acception);
17622 // do not leave behind a stale pointer!
17623 _mserver_acception = NULL;
17624 }
17625 delete sa;
17626 _server_acceptions[idx] = NULL;
17627 }
17628 }
17629
17633 }
17634
17635 /* free suspend structures */
17636 ss_suspend_exit();
17637
17639}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_set_debug()
◆ rpc_set_mserver_path()
| INT rpc_set_mserver_path | ( | const char * | path | ) |
◆ rpc_set_name()
| INT rpc_set_name | ( | const char * | name | ) |
◆ rpc_set_opt_tcp_size()
Definition at line 14312 of file midas.cxx.
14312 {
14313 INT old;
14314
14315 old = _opt_tcp_size;
14316 _opt_tcp_size = tcp_size;
14317 return old;
14318}
Here is the caller graph for this function:
◆ rpc_set_timeout()
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 13129 of file midas.cxx.
13130{
13131 //printf("rpc_set_timeout: hConn %d, timeout_msec %d\n", hConn, timeout_msec);
13132
13134 if (old_timeout_msec)
13138 if (old_timeout_msec)
13139 *old_timeout_msec = _rpc_connect_timeout;
13140 _rpc_connect_timeout = timeout_msec;
13141 } else {
13144 if (old_timeout_msec)
13145 *old_timeout_msec = c->rpc_timeout;
13146 c->rpc_timeout = timeout_msec;
13147 c->mutex.unlock();
13148 } else {
13149 if (old_timeout_msec)
13150 *old_timeout_msec = 0;
13151 }
13152 }
13154}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_socket_check_allowed_host()
|
static |
Definition at line 16672 of file midas.cxx.
16673{
16674 std::string hostname;
16675
16677
16680
16682
16685
16686 static std::atomic_int max_report(10);
16687 if (max_report > 0) {
16688 max_report--;
16689 if (max_report == 0) {
16690 cm_msg(MERROR, "rpc_socket_check_allowed_host", "rejecting connection from unallowed host \'%s\', this message will no longer be reported", hostname.c_str());
16691 } else {
16692 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());
16693 }
16694 }
16695
16697}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_test_rpc()
| int rpc_test_rpc | ( | ) |
◆ rpc_test_rpc_test2()
| int rpc_test_rpc_test2 | ( | ) |
Definition at line 15940 of file midas.cxx.
15956{
15958
15959 printf("rpc_test_rpc_test2!\n");
15960
15961 int int_out = 0;
15962 int int_inout = 456;
15963
15964 char string_out[33];
15965 char string2_out[49];
15966
15967 char string_inout[25];
15968 strcpy(string_inout, "string_inout");
15969
15970 KEY struct_in;
15971
15972 struct_in.type = 111;
15973 struct_in.num_values = 222;
15975 struct_in.last_written = 333;
15976
15977 KEY struct_out;
15978 KEY struct_inout;
15979
15980 struct_inout.type = 111111;
15981 struct_inout.num_values = 222222;
15983 struct_inout.last_written = 333333;
15984
15985 uint32_t dwordarray_inout[9];
15986 size_t dwordarray_inout_size = sizeof(dwordarray_inout);
15987
15990 }
15991
15992 char array_in[10];
15993
15996 }
15997
15998 char array_out[16];
15999 size_t array_out_size = sizeof(array_out);
16000
16003 }
16004
16006 123,
16007 &int_out,
16008 &int_inout,
16009 "test string",
16010 string_out, sizeof(string_out),
16011 string2_out, sizeof(string2_out),
16012 string_inout, sizeof(string_inout),
16013 &struct_in,
16014 &struct_out,
16015 &struct_inout,
16016 dwordarray_inout, &dwordarray_inout_size,
16017 array_in, sizeof(array_in),
16018 array_out, &array_out_size
16019 );
16020
16024 }
16025
16026 if (int_out != 789) {
16027 printf("int_out mismatch!\n");
16028 status = 0;
16029 }
16030
16031 if (int_inout != 456*2) {
16032 printf("int_inout mismatch!\n");
16033 status = 0;
16034 }
16035
16036 if (strcmp(string_out, "string_out") != 0) {
16037 printf("string_out mismatch [%s] vs [%s]\n", string_out, "string_out");
16038 status = 0;
16039 }
16040
16041 if (strcmp(string2_out, "second string_out") != 0) {
16042 printf("string2_out mismatch [%s] vs [%s]\n", string2_out, "second string_out");
16043 status = 0;
16044 }
16045
16046 if (strcmp(string_inout, "return string_inout") != 0) {
16047 printf("string_inout mismatch [%s] vs [%s]\n", string_inout, "return string_inout");
16048 status = 0;
16049 }
16050
16051 KEY* pkey;
16052
16053 pkey = &struct_in;
16054
16055 //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
16056
16057 pkey = &struct_out;
16058
16059 if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
16060 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);
16061 status = 0;
16062 }
16063
16064 pkey = &struct_inout;
16065
16066 if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
16067 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);
16068 status = 0;
16069 }
16070
16071 if (dwordarray_inout_size != 4*5) {
16072 printf("dwordarray_inout_size mismatch %d vs %d\n", (int)dwordarray_inout_size, 4*5);
16073 status = 0;
16074 } else {
16077 printf("dwordarray_inout[%d] data mismatch %d vs %zu\n", (int)i, dwordarray_inout[i], i*10+i);
16078 status = 0;
16079 }
16080 }
16081 }
16082
16083 //printf("array_out_size %d\n", array_out_size);
16084 //for (int i=0; i<array_out_size; i++) {
16085 // printf("array_out[%d] is %3d (%c)\n", i, array_out[i], array_out[i]);
16086 //}
16087
16088 if (array_out_size != 15) {
16089 printf("array_out_size mismatch %d vs %d\n", (int)array_out_size, 15);
16090 status = 0;
16091 } else {
16092 if (strcmp(array_out, "test test test") != 0) {
16093 printf("array_out data mismatch\n");
16094 status = 0;
16095 }
16096 }
16097
16099}
Definition midas.h:1027
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_test_rpc_test2_cxx()
| int rpc_test_rpc_test2_cxx | ( | ) |
Definition at line 16102 of file midas.cxx.
16118{
16120
16121 printf("rpc_test_rpc_test2_cxx!\n");
16122
16123 int int_out = 0;
16124 int int_inout = 456;
16125
16126 char string_out[33];
16127 std::string string2_out;
16128 std::string string_inout = "string_inout";
16129
16130 KEY struct_in;
16131
16132 struct_in.type = 111;
16133 struct_in.num_values = 222;
16135 struct_in.last_written = 333;
16136
16137 KEY struct_out;
16138 KEY struct_inout;
16139
16140 struct_inout.type = 111111;
16141 struct_inout.num_values = 222222;
16143 struct_inout.last_written = 333333;
16144
16145 uint32_t dwordarray_inout[9];
16146 size_t dwordarray_inout_size = sizeof(dwordarray_inout);
16147
16150 }
16151
16152 std::vector<char> array_in;
16153 int array_in_size = 10;
16154
16157 }
16158
16159 std::vector<char> array_out;
16160 size_t array_out_size = 16;
16161
16163 123,
16164 &int_out,
16165 &int_inout,
16166 "test string",
16167 string_out, sizeof(string_out),
16168 &string2_out, 48,
16169 &string_inout, 25,
16170 &struct_in,
16171 &struct_out,
16172 &struct_inout,
16173 dwordarray_inout, &dwordarray_inout_size,
16174 &array_in, array_in_size,
16175 &array_out, &array_out_size
16176 );
16177
16181 }
16182
16183 if (int_out != 789) {
16184 printf("int_out mismatch!\n");
16185 status = 0;
16186 }
16187
16188 if (int_inout != 456*2) {
16189 printf("int_inout mismatch!\n");
16190 status = 0;
16191 }
16192
16193 if (strcmp(string_out, "string_out") != 0) {
16194 printf("string_out mismatch [%s] vs [%s]\n", string_out, "string_out");
16195 status = 0;
16196 }
16197
16198 if (string2_out != "second string_out") {
16199 printf("string2_out mismatch [%s] vs [%s]\n", string2_out.c_str(), "second string_out");
16200 status = 0;
16201 }
16202
16203 if (string_inout != "return string_inout") {
16204 printf("string_inout mismatch [%s] vs [%s]\n", string_inout.c_str(), "return string_inout");
16205 status = 0;
16206 }
16207
16208 KEY* pkey;
16209
16210 pkey = &struct_in;
16211
16212 //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
16213
16214 pkey = &struct_out;
16215
16216 if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
16217 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);
16218 status = 0;
16219 }
16220
16221 pkey = &struct_inout;
16222
16223 if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
16224 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);
16225 status = 0;
16226 }
16227
16228 if (dwordarray_inout_size != 4*5) {
16229 printf("dwordarray_inout_size mismatch %d vs %d\n", (int)dwordarray_inout_size, 4*5);
16230 status = 0;
16231 } else {
16234 printf("dwordarray_inout[%d] data mismatch %d vs %zu\n", (int)i, dwordarray_inout[i], i*10+i);
16235 status = 0;
16236 }
16237 }
16238 }
16239
16240 //printf("array_out_size %d\n", array_out_size);
16241 //for (int i=0; i<array_out_size; i++) {
16242 // printf("array_out[%d] is %3d (%c)\n", i, array_out[i], array_out[i]);
16243 //}
16244
16245 if (array_out_size != 15) {
16246 printf("array_out_size mismatch %d vs %d\n", (int)array_out_size, 15);
16247 status = 0;
16248 } else if (array_out.size() != 15) {
16249 printf("array_out.size() mismatch %d vs %d\n", (int)array_out.size(), 15);
16250 status = 0;
16251 } else {
16252 if (strcmp(array_out.data(), "test test test") != 0) {
16253 printf("array_out data mismatch\n");
16254 status = 0;
16255 }
16256 }
16257
16259}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_test_rpc_test3_cxx()
| int rpc_test_rpc_test3_cxx | ( | ) |
Definition at line 16262 of file midas.cxx.
16278{
16280
16281 printf("rpc_test_rpc_test3_cxx!\n");
16282
16283 int int_out = 0;
16284 int int_inout = 456;
16285
16286 char string_out[33];
16287 std::string string2_out;
16288 std::string string_inout = "string_inout";
16289
16290 KEY struct_in;
16291
16292 struct_in.type = 111;
16293 struct_in.num_values = 222;
16295 struct_in.last_written = 333;
16296
16297 KEY struct_out;
16298 KEY struct_inout;
16299
16300 struct_inout.type = 111111;
16301 struct_inout.num_values = 222222;
16303 struct_inout.last_written = 333333;
16304
16305 uint32_t dwordarray_inout[9];
16306 size_t dwordarray_inout_size = sizeof(dwordarray_inout);
16307
16310 }
16311
16312 std::vector<char> array_in;
16313 int array_in_size = 10;
16314
16317 }
16318
16319 std::vector<char> array_out;
16320
16322 123,
16323 &int_out,
16324 &int_inout,
16325 "test string",
16326 string_out, sizeof(string_out),
16327 &string2_out,
16328 &string_inout,
16329 &struct_in,
16330 &struct_out,
16331 &struct_inout,
16332 dwordarray_inout, &dwordarray_inout_size,
16333 &array_in,
16334 &array_out
16335 );
16336
16340 }
16341
16342 if (int_out != 789) {
16343 printf("int_out mismatch!\n");
16344 status = 0;
16345 }
16346
16347 if (int_inout != 456*2) {
16348 printf("int_inout mismatch!\n");
16349 status = 0;
16350 }
16351
16352 if (strcmp(string_out, "string_out") != 0) {
16353 printf("string_out mismatch [%s] vs [%s]\n", string_out, "string_out");
16354 status = 0;
16355 }
16356
16357 if (string2_out != "second string_out") {
16358 printf("string2_out mismatch [%s] vs [%s]\n", string2_out.c_str(), "second string_out");
16359 status = 0;
16360 }
16361
16362 if (string_inout != "return string_inout") {
16363 printf("string_inout mismatch [%s] vs [%s]\n", string_inout.c_str(), "return string_inout");
16364 status = 0;
16365 }
16366
16367 KEY* pkey;
16368
16369 pkey = &struct_in;
16370
16371 //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
16372
16373 pkey = &struct_out;
16374
16375 if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
16376 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);
16377 status = 0;
16378 }
16379
16380 pkey = &struct_inout;
16381
16382 if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
16383 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);
16384 status = 0;
16385 }
16386
16387 if (dwordarray_inout_size != 4*5) {
16388 printf("dwordarray_inout_size mismatch %d vs %d\n", (int)dwordarray_inout_size, 4*5);
16389 status = 0;
16390 } else {
16393 printf("dwordarray_inout[%d] data mismatch %d vs %zu\n", (int)i, dwordarray_inout[i], i*10+i);
16394 status = 0;
16395 }
16396 }
16397 }
16398
16399 //printf("array_out_size %d\n", array_out_size);
16400 //for (int i=0; i<array_out_size; i++) {
16401 // printf("array_out[%d] is %3d (%c)\n", i, array_out[i], array_out[i]);
16402 //}
16403
16404 if (array_out.size() != 15) {
16405 printf("array_out.size() mismatch %d vs %d\n", (int)array_out.size(), 15);
16406 status = 0;
16407 } else {
16408 if (strcmp(array_out.data(), "test test test") != 0) {
16409 printf("array_out data mismatch\n");
16410 status = 0;
16411 }
16412 }
16413
16415}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_test_rpc_test4_cxx()
| int rpc_test_rpc_test4_cxx | ( | ) |
Definition at line 16418 of file midas.cxx.
16434{
16436
16437 printf("rpc_test_rpc_test4_cxx!\n");
16438
16439 int int_out = 0;
16440 int int_inout = 456;
16441
16442 std::string string_in = "test string";
16443 std::string string_out;
16444 std::string string_inout = "string_inout";
16445
16446 std::vector<char> array_in;
16447 int array_in_size = 10;
16448
16451 }
16452
16453 std::vector<char> array_out;
16454
16455 std::vector<char> array_inout;
16456 int array_inout_size = 6;
16457
16460 }
16461
16463 123,
16464 &int_out,
16465 &int_inout,
16466 &string_in,
16467 &string_out,
16468 &string_inout,
16469 &array_in,
16470 &array_out,
16471 &array_inout
16472 );
16473
16477 }
16478
16479 if (int_out != 789) {
16480 printf("int_out mismatch!\n");
16481 status = 0;
16482 }
16483
16484 if (int_inout != 456*2) {
16485 printf("int_inout mismatch!\n");
16486 status = 0;
16487 }
16488
16489 if (string_out != "return string_out") {
16490 printf("string_out mismatch [%s] vs [%s]\n", string_out.c_str(), "return string_out");
16491 status = 0;
16492 }
16493
16494 if (string_inout != "return string_inout") {
16495 printf("string_inout mismatch [%s] vs [%s]\n", string_inout.c_str(), "return string_inout");
16496 status = 0;
16497 }
16498
16499 if (array_out.size() != 15) {
16500 printf("array_out.size() mismatch %d vs %d\n", (int)array_out.size(), 15);
16501 status = 0;
16502 } else {
16503 if (strcmp(array_out.data(), "test test test") != 0) {
16504 printf("array_out data mismatch\n");
16505 status = 0;
16506 }
16507 }
16508
16509 if (array_inout.size() != 12) {
16510 printf("array_inout.size() mismatch %d vs %d\n", (int)array_inout.size(), 12);
16511 status = 0;
16512 } else {
16515 printf("array_inout data mismatch, index %d, value %d should be %d\n", i, array_inout[i], ('0'+i));
16516 status = 0;
16517 }
16518 }
16521 printf("array_inout data mismatch, index %d, value %d should be %d\n", i, array_inout[i], 2*('0'+i));
16522 status = 0;
16523 }
16524 }
16525 }
16526
16528}
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 | ) |
◆ rpc_tid_name_old()
| const char * rpc_tid_name_old | ( | INT | id | ) |
◆ rpc_tid_size()
◆ rpc_transition_dispatch()
Definition at line 14504 of file midas.cxx.
14523{
14524 /* erase error string */
14525 *(CSTRING(2)) = 0;
14526
14528 // find registered handler
14529 // NB: this code should match same code in cm_transition_call_direct()
14530 // NB: only use the first handler, this is how MIDAS always worked
14531 // NB: we could run all handlers, but we can return the status and error string of only one of them.
14532 _trans_table_mutex.lock();
14534 _trans_table_mutex.unlock();
14535
14537 _trans_table_mutex.lock();
14539 _trans_table_mutex.unlock();
14540
14543 /* execute callback if defined */
14545 } else {
14546 std::lock_guard<std::mutex> guard(_tr_fifo_mutex);
14547 /* store transition in FIFO */
14553 // implicit unlock
14555 }
14556 }
14557 }
14558 // no handler for this transition
14559 cm_msg(MERROR, "rpc_transition_dispatch", "no handler for transition %d with sequence number %d", CINT(0), CINT(4));
14561 } else {
14564 }
14565}
Definition midas.cxx:241
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 13324 of file midas.cxx.
13324 {
13325 switch (arg_type) {
13326 /* On the stack, the minimum parameter size is sizeof(int).
13327 To avoid problems on little endian systems, treat all
13328 smaller parameters as int's */
13334 *((int *) arg) = va_arg(*arg_ptr, int);
13335 break;
13336
13340 break;
13341
13344 break;
13345
13346 /* float variables are passed as double by the compiler */
13348 *((float *) arg) = (float) va_arg(*arg_ptr, double);
13349 break;
13350
13352 *((double *) arg) = va_arg(*arg_ptr, double);
13353 break;
13354
13356 *((char **) arg) = va_arg(*arg_ptr, char *);
13357 break;
13358 }
13359}
Here is the caller graph for this function:
◆ rpc_vax2ieee_double()
| void rpc_vax2ieee_double | ( | double * | var | ) |
Definition at line 11773 of file midas.cxx.
11773 {
11774 unsigned short int i1, i2, i3, i4;
11775
11776 /* swap words */
11777 i1 = *((short int *) (var) + 3);
11778 i2 = *((short int *) (var) + 2);
11779 i3 = *((short int *) (var) + 1);
11780 i4 = *((short int *) (var));
11781
11782 /* correct exponent */
11783 if (i4 != 0)
11784 i4 -= 0x20;
11785
11786 *((short int *) (var) + 3) = i4;
11787 *((short int *) (var) + 2) = i3;
11788 *((short int *) (var) + 1) = i2;
11789 *((short int *) (var)) = i1;
11790}
Here is the caller graph for this function:
◆ rpc_vax2ieee_float()
| void rpc_vax2ieee_float | ( | float * | var | ) |
Definition at line 11757 of file midas.cxx.
11757 {
11758 unsigned short int lo, hi;
11759
11760 /* swap hi and lo word */
11761 lo = *((short int *) (var) + 1);
11762 hi = *((short int *) (var));
11763
11764 /* correct exponent */
11765 if (hi != 0)
11766 hi -= 0x100;
11767
11768 *((short int *) (var) + 1) = hi;
11769 *((short int *) (var)) = lo;
11770
11771}
Here is the caller graph for this function:
Variable Documentation
◆ _client_connections
|
static |
◆ _client_connections_mutex
◆ _mserver_acception
|
static |
◆ _mserver_path
◆ _opt_tcp_size
|
static |
◆ _rpc_is_remote
◆ _server_acceptions
|
static |
◆ _server_connection
|
static |
◆ _tr_fifo
◆ _tr_fifo_mutex
◆ _tr_fifo_rp
◆ _tr_fifo_wp
◆ gAllowedHosts
◆ gAllowedHostsMutex
◆ rpc_list
◆ rpc_list_mutex
◆ tls_buffer
|
static |
