Loading...
Searching...
No Matches
Classes | |
| class | RPC_CLIENT_CONNECTION |
| struct | TR_FIFO |
| struct | TLS_POINTER |
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_REMOVE_EVENT_REQUEST
◆ RPC_BM_SEND_EVENT
◆ RPC_BM_SET_CACHE_SIZE
◆ RPC_BM_SKIP_EVENT
◆ RPC_BRPC
◆ 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_LOG_REWIND
◆ RPC_MANUAL_TRIG
◆ RPC_RC_TRANSITION
◆ RPC_TEST
◆ RPC_TEST2
Function Documentation
◆ close()
| void RPC_SERVER_ACCEPTION::close | ( | ) |
Definition at line 11551 of file midas.cxx.
11552{
11553 //printf("RPC_SERVER_ACCEPTION::close: connection from %s program %s mserver %d\n", host_name.c_str(), prog_name.c_str(), is_mserver);
11554
11559 }
11560
11561 /* close server connection */
11568
11569 /* free TCP cache */
11571 //printf("free net_buffer %p+%d\n", net_buffer, net_buffer_size);
11572 free(net_buffer);
11574 net_buffer_size = 0;
11575 }
11576
11577 /* mark this entry as invalid */
11578 clear();
11579}
TH1X EXPRT * h1_book(const char *name, const char *title, int bins, double min, double max)
Definition rmidas.h:24
Here is the call graph for this function:
Here is the caller graph for this function:
◆ cm_query_transition()
◆ gAllowedHostsEnabled()
|
static |
Here is the caller graph for this function:
◆ handle_msg_odb()
|
static |
Definition at line 11939 of file midas.cxx.
11939 {
11940 //printf("rpc_client_dispatch: MSG_ODB: packet size %d, expected %d\n", n, (int)(sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT)));
11942 /* update a changed record */
11948 }
11950}
INT db_update_record_local(INT hDB, INT hKeyRoot, INT hKey, int index)
Definition odb.cxx:13553
Definition msystem.h:280
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_event_server_realloc()
|
static |
Definition at line 14395 of file midas.cxx.
14417{
14419
14420 //printf("recv_event_server: idx %d, buffer %p, buffer_size %d\n", idx, buffer, buffer_size);
14421
14423
14425
14426 // First read the header.
14427 //
14428 // Data format is:
14429 // INT buffer handle (4 bytes)
14430 // EVENT_HEADER (16 bytes)
14431 // event data
14432 // ALIGN8() padding
14433 // ...next event
14434
14436
14438 // timeout waiting for data
14439 return 0;
14440 }
14441
14442 /* abort if connection broken */
14445 return -1;
14446 }
14447
14450
14451 /* abort if connection broken */
14454 return -1;
14455 }
14456
14458 }
14459
14460 /* abort if connection broken */
14462 cm_msg(MERROR, "recv_event_server", "recv_tcp2(header) returned %d instead of %d", hrd, (int) header_size);
14463 return -1;
14464 }
14465
14468
14469 /* convert header little endian/big endian */
14477 }
14478
14481
14482 //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);
14483
14487 }
14488 abort();
14489 }
14490
14491 /* check for sane event size */
14494 "received event header with invalid data_size %d: event_size %d, total_size %d", pevent->data_size,
14495 event_size, total_size);
14496 return -1;
14497 }
14498
14499 //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);
14500
14501
14503
14504 // Second, check that output buffer is big enough
14505
14506 /* check if data part fits in buffer */
14509
14510 //printf("recv_event_server: buffer realloc %d -> %d\n", *pbuffer_size, newsize);
14511
14514 cm_msg(MERROR, "recv_event_server", "cannot realloc() event buffer from %d to %d bytes", *pbuffer_size,
14515 newsize);
14516 return -1;
14517 }
14520 }
14521
14522 // Third, copy header into output buffer
14523
14525
14526 // Forth, read the event data
14527
14530
14533
14534 /* abort if connection broken */
14536 cm_msg(MERROR, "recv_event_server", "recv_tcp2(data) returned %d instead of %d", drd, to_read);
14537 return -1;
14538 }
14539 }
14540
14542}
INT recv_tcp2(int sock, char *net_buffer, int buffer_size, int timeout_ms)
Definition system.cxx:5562
INT cm_msg(INT message_type, const char *filename, INT line, const char *routine, const char *format,...)
Definition midas.cxx:915
void rpc_convert_single(void *data, INT tid, INT flags, INT convert_flags)
Definition midas.cxx:11689
Definition midas.h:851
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_net_command_realloc()
|
static |
Definition at line 14205 of file midas.cxx.
14233{
14234 char *buffer = NULL; // buffer is changed to point to *pbuf when we receive the NET_COMMAND header
14235
14237
14239
14243 else
14245
14247 //printf("sa %p idx %d, net_buffer %p+%d\n", sa, idx, sa->net_buffer, sa->net_buffer_size);
14248 sa->write_ptr = 0;
14249 sa->read_ptr = 0;
14250 sa->misalign = 0;
14251 }
14253 cm_msg(MERROR, "recv_net_command", "Cannot allocate %d bytes for network buffer", sa->net_buffer_size);
14254 return -1;
14255 }
14256
14258 int param_size = -1;
14259
14264
14265 do {
14267 if (param_size == -1) {
14269 /* assemble split header */
14273 } else {
14276 }
14277
14280 }
14281
14282 //printf("recv_net_command: param_size %d, NET_COMMAND_HEADER %d, buffer_size %d\n", param_size, (int)sizeof(NET_COMMAND_HEADER), *pbufsize);
14283
14284 /* check if parameters fit in buffer */
14288 //printf("recv_net_command: reallocate buffer %d -> %d, %p\n", *pbufsize, new_size, p);
14290 cm_msg(MERROR, "recv_net_command", "cannot reallocate buffer from %d bytes to %d bytes", *pbufsize, new_size);
14291 sa->read_ptr = 0;
14292 sa->write_ptr = 0;
14293 return -1;
14294 }
14295 *pbuf = p;
14297 }
14298
14299 buffer = *pbuf;
14300
14301 /* check if we have all parameters in buffer */
14303 break;
14304 }
14305
14306 /* not enough data, so copy partially and get new */
14307 int size = write_ptr - read_ptr;
14308
14309 if (size > 0) {
14311 copied += size;
14312 read_ptr = write_ptr;
14313 }
14314#ifdef OS_UNIX
14315 do {
14317
14318 /* don't return if an alarm signal was cought */
14320#else
14322#endif
14323
14324 /* abort if connection broken */
14325 if (write_ptr <= 0) {
14326 if (write_ptr == 0)
14327 cm_msg(MERROR, "recv_net_command", "rpc connection from \'%s\' on \'%s\' unexpectedly closed", sa->prog_name.c_str(), sa->host_name.c_str());
14328 else
14329 cm_msg(MERROR, "recv_net_command", "recv() returned %d, errno: %d (%s)", write_ptr, errno, strerror(errno));
14330
14332 *remaining = 0;
14333
14334 return write_ptr;
14335 }
14336
14337 read_ptr = misalign;
14338 write_ptr += misalign;
14339
14340 misalign = write_ptr % 8;
14342
14343 /* copy rest of parameters */
14346 read_ptr += size;
14347
14349 /* don't keep rpc_server_receive in an infinite loop */
14350 if (write_ptr - read_ptr < param_size)
14351 *remaining = 0;
14352 else
14353 *remaining = write_ptr - read_ptr;
14354 }
14355
14356 sa->write_ptr = write_ptr;
14357 sa->read_ptr = read_ptr;
14358 sa->misalign = misalign;
14359
14361}
static RPC_SERVER_ACCEPTION * rpc_get_server_acception(int idx)
Definition midas.cxx:11513
Definition msystem.h:285
Definition msystem.h:355
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_tcp_check()
Definition at line 14365 of file midas.cxx.
14383{
14384 /* figure out to which connection socket belongs */
14388 }
14389
14390 return 0;
14391}
static std::vector< RPC_SERVER_ACCEPTION * > _server_acceptions
Definition midas.cxx:11510
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_add_allowed_host()
Definition at line 15243 of file midas.cxx.
15260{
15261 //cm_msg(MINFO, "rpc_add_allowed_host", "Adding allowed host \'%s\'", hostname);
15262
15263 gAllowedHostsMutex.lock();
15264 gAllowedHosts.push_back(hostname);
15266 gAllowedHostsMutex.unlock();
15267
15269}
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 11591 of file midas.cxx.
11591 {
11592 *convert_flags = 0;
11593
11594 /* big/little endian conversion */
11598 *convert_flags |= CF_ENDIAN;
11599
11600 /* float conversion between IEEE and VAX G */
11602 *convert_flags |= CF_VAX2IEEE;
11603
11604 /* float conversion between VAX G and IEEE */
11606 *convert_flags |= CF_IEEE2VAX;
11607
11609 //if (remote_hw_type & DR_ASCII)
11610 // *convert_flags |= CF_ASCII;
11611}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call()
Definition at line 13671 of file midas.cxx.
13695{
13698
13700 routine_id &= ~RPC_NO_REPLY;
13701
13702 //if (rpc_no_reply)
13703 // printf("rpc_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
13704
13707
13708 if (!send_sock) {
13711 }
13712
13714 /* create a local mutex for multi-threaded applications */
13716 }
13717
13722 }
13723
13724 /* find rpc definition */
13725
13729
13730 rpc_list_mutex.lock();
13731
13737 break;
13738 }
13739 }
13740
13741 rpc_list_mutex.unlock();
13742
13747 }
13748
13749 /* prepare output buffer */
13750
13752
13753 /* examine variable argument list and convert it to parameter array */
13754 va_start(ap, routine_id);
13755
13757
13758 va_end(ap);
13759
13761
13764
13766
13767 /* do not wait for reply if requested RPC_NO_REPLY */
13770
13774 free(nc);
13776 }
13777
13779 free(nc);
13781 }
13782
13783 /* in TCP mode, send and wait for reply on send socket */
13788 free(nc);
13790 }
13791
13792 free(nc);
13793 nc = NULL;
13794
13797 DWORD watchdog_timeout;
13799
13800 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, rpc_timeout);
13801
13803 // if RPC is remote, we are connected to an mserver,
13804 // the mserver takes care of watchdog timeouts.
13805 // otherwise we should make sure the watchdog timeout
13806 // is longer than the RPC timeout. K.O.
13807 if (rpc_timeout >= (int) watchdog_timeout) {
13810 }
13811 }
13812
13814 DWORD buf_size = 0;
13816
13818
13821 }
13822
13823 /* drop the mutex, we are done with the socket, argument unpacking is done from our own buffer */
13824
13826
13827 /* check for reply errors */
13828
13830 cm_msg(MERROR, "rpc_call", "routine \"%s\": timeout waiting for reply, program abort", rpc_name);
13831 if (buf)
13832 free(buf);
13835 }
13836
13838 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, ss_recv_net_command() status %d, program abort", rpc_name, status);
13839 if (buf)
13840 free(buf);
13843 }
13844
13846 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, unknown RPC, status %d", rpc_name, rpc_status);
13847 if (buf)
13848 free(buf);
13850 }
13851
13852 /* extract result variables and place it to argument list */
13853
13854 va_start(ap, routine_id);
13855
13857
13860 }
13861
13862 va_end(ap);
13863
13864 if (buf)
13865 free(buf);
13866
13868}
INT cm_get_watchdog_params(BOOL *call_watchdog, DWORD *timeout)
Definition midas.cxx:3325
INT cm_set_watchdog_params_local(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3244
INT ss_recv_net_command(int sock, DWORD *routine_id, DWORD *param_size, char **param_ptr, int timeout_ms)
Definition system.cxx:5635
INT send_tcp(int sock, char *buffer, DWORD buffer_size, INT flags)
Definition system.cxx:5285
static void rpc_call_encode(va_list &ap, const RPC_LIST &rl, NET_COMMAND **nc)
Definition midas.cxx:13239
static int rpc_call_decode(va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size)
Definition midas.cxx:13410
Definition midas.h:1595
Here is the call graph for this function:
◆ rpc_call_decode()
|
static |
Definition at line 13410 of file midas.cxx.
13411{
13413
13416
13417 /* extract result variables and place it to argument list */
13418
13420
13425
13429
13432 else
13434
13437
13438 char arg[8];
13440
13442
13444 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);
13446 }
13447
13450
13453
13457 }
13458
13461
13462 /* parameter size is always aligned */
13464
13465 /* return parameters are always pointers */
13466 if (*((char **) arg)) {
13468 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);
13470 }
13471
13472 param_ptr += param_size;
13473 }
13474 }
13475
13477}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call_encode()
Definition at line 13239 of file midas.cxx.
13240{
13242
13250 }
13251 }
13252
13254
13259
13263
13266 else
13267 arg_type = tid;
13268
13269 /* floats are passed as doubles, at least under NT */
13272
13273 //printf("arg %d, tid %d, flags 0x%x, arg_type %d, bpointer %d\n", i, tid, flags, arg_type, bpointer);
13274
13276 }
13277
13280 assert(buf);
13281
13282 (*nc) = (NET_COMMAND*) buf;
13283
13284 /* find out if we are on a big endian system */
13286
13288
13293
13297
13300 else
13301 arg_type = tid;
13302
13303 /* floats are passed as doubles, at least under NT */
13306
13307 /* get pointer to argument */
13308 //char arg[8];
13309 //rpc_va_arg(&ap, arg_type, arg);
13310
13312
13313 /* shift 1- and 2-byte parameters to the LSB on big endian systems */
13316 arg[0] = arg[3];
13317 }
13319 arg[0] = arg[2];
13320 arg[1] = arg[3];
13321 }
13322 }
13323
13326
13329 else
13331
13332 /* for strings, the argument size depends on the string length */
13335 }
13336
13337 /* for varibale length arrays, the size is given by
13338 the next parameter on the stack */
13340 //va_list aptmp;
13342 //va_copy(aptmp, ap);
13343
13344 //char arg_tmp[8];
13345 //rpc_va_arg(&aptmp, TID_ARRAY, arg_tmp);
13346
13348
13349 /* for (RPC_IN+RPC_OUT) parameters, size argument is a pointer */
13352 else
13354
13357
13358 //va_end(aptmp);
13359 }
13360
13363
13364 /* always align parameter size */
13366
13367 {
13369
13372 //printf("resize nc %zu to %zu\n", buf_size, new_size);
13374 assert(buf);
13375 buf_size = new_size;
13376 (*nc) = (NET_COMMAND*) buf;
13378 }
13379 }
13380
13383 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);
13384 }
13388 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);
13389 }
13390 /* floats are passed as doubles on most systems */
13392 } else {
13394 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);
13395 }
13397 }
13398
13399 param_ptr += param_size;
13400 }
13401 }
13402
13404
13406 printf("encode rpc_id %d \"%s\" buf_size %d, param_size %d\n", rl.id, rl.name, (int)buf_size, (*nc)->header.param_size);
13407}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_check_allowed_host()
Definition at line 15272 of file midas.cxx.
15283{
15284 //printf("rpc_check_allowed_host: enabled %d, hostname [%s]\n", gAllowedHostsEnabled.load(), hostname);
15285
15288
15291
15294
15297
15300
15302
15303 gAllowedHostsMutex.lock();
15304
15306 if (h == hostname) {
15308 break;
15309 }
15310 }
15311
15312 gAllowedHostsMutex.unlock();
15313
15314 //if (status != RPC_SUCCESS)
15315 // printf("rpc_check_allowed_host: enabled %d, hostname [%s] not found\n", gAllowedHostsEnabled.load(), hostname);
15316
15318}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_check_channels()
Definition at line 16262 of file midas.cxx.
16280{
16282 NET_COMMAND nc;
16285
16290 continue;
16291
16293 continue;
16294 }
16295
16297 //printf("rpc_check_channels: idx %d, watchdog_timeout %d, last_activity %d, elapsed %d\n", idx, sa->watchdog_timeout, sa->last_activity, elapsed);
16298
16300
16301 //printf("rpc_check_channels: send watchdog message to %s on %s\n", sa->prog_name.c_str(), sa->host_name.c_str());
16302
16303 /* send a watchdog message */
16306
16308 if (convert_flags) {
16311 }
16312
16313 /* send the header to the client */
16315
16317 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, send_tcp() returned %d",
16318 sa->prog_name.c_str(),
16319 sa->host_name.c_str(),
16320 sa->watchdog_timeout / 1000,
16321 i);
16322
16323 /* disconnect from experiment */
16325 cm_disconnect_experiment();
16327 }
16328
16329 sa->close();
16331 }
16332
16333 /* make some timeout checking */
16337
16338 timeout.tv_sec = sa->watchdog_timeout / 1000;
16339 timeout.tv_usec = (sa->watchdog_timeout % 1000) * 1000;
16340
16341 do {
16343
16344 /* if an alarm signal was cought, restart select with reduced timeout */
16346 timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
16347
16349
16352
16353 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec",
16354 sa->prog_name.c_str(),
16355 sa->host_name.c_str(),
16356 sa->watchdog_timeout / 1000);
16357
16358 /* disconnect from experiment */
16360 cm_disconnect_experiment();
16362 }
16363
16364 sa->close();
16366 }
16367
16368 /* receive result on send socket */
16372 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, recv_tcp() returned %d",
16373 sa->prog_name.c_str(),
16374 sa->host_name.c_str(),
16375 sa->watchdog_timeout / 1000,
16376 i);
16377
16378 /* disconnect from experiment */
16380 cm_disconnect_experiment();
16382 }
16383
16384 sa->close();
16386 }
16387 }
16388 }
16389 }
16390 }
16391
16393}
INT recv_tcp(int sock, char *net_buffer, DWORD buffer_size, INT flags)
Definition system.cxx:5454
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_clear_allowed_hosts()
Definition at line 15218 of file midas.cxx.
15234{
15235 gAllowedHostsMutex.lock();
15236 gAllowedHosts.clear();
15238 gAllowedHostsMutex.unlock();
15240}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_accept()
Definition at line 15606 of file midas.cxx.
15627{
15630 std::string client_program;
15631 std::string host_name;
15632 INT convert_flags;
15633 char net_buffer[256], *p;
15634
15636
15637 if (sock == -1)
15639
15640 /* check access control list */
15643
15645 ss_socket_close(&sock);
15647 }
15648 }
15649
15652
15653 /* receive string with timeout */
15656 ss_socket_close(&sock);
15658 }
15659
15660 /* get remote computer info */
15665 }
15667 //version = atoi(p);
15669 }
15671 client_program = p;
15673 }
15675 host_name = p;
15677 }
15678
15679 //printf("rpc_client_accept: client_hw_type %d, version %d, client_name \'%s\', hostname \'%s\'\n", client_hw_type, version, client_program, host_name);
15680
15682
15683 /* save information in _server_acception structure */
15684 sa->recv_sock = sock;
15685 sa->send_sock = 0;
15686 sa->event_sock = 0;
15691 sa->watchdog_timeout = 0;
15693
15694 /* send my own computer id */
15700
15702 sa->convert_flags = convert_flags;
15703
15705
15707}
INT ss_suspend_set_server_acceptions(RPC_SERVER_ACCEPTION_LIST *acceptions)
Definition system.cxx:4298
INT recv_string(int sock, char *buffer, DWORD buffer_size, INT millisec)
Definition system.cxx:5399
void rpc_calc_convert_flags(INT hw_type, INT remote_hw_type, INT *convert_flags)
Definition midas.cxx:11591
static RPC_SERVER_ACCEPTION * rpc_new_server_acception()
Definition midas.cxx:11526
static INT rpc_socket_check_allowed_host(int sock)
Definition midas.cxx:15321
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_call()
Definition at line 13480 of file midas.cxx.
13505{
13507
13511 }
13512
13513 //printf("rpc_client_call: handle %d, connection: ", hConn);
13514 //c->print();
13515 //printf("\n");
13516
13518
13520 routine_id &= ~RPC_NO_REPLY;
13521
13522 //if (rpc_no_reply)
13523 // printf("rpc_client_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
13524
13525 // make local copy of the client name just in case _client_connection is erased by another thread
13526
13527 /* find rpc_index */
13528
13532
13533 rpc_list_mutex.lock();
13539 break;
13540 }
13541 }
13542 rpc_list_mutex.unlock();
13543
13545 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);
13546 c->mutex.unlock();
13548 }
13549
13551
13552 /* examine variable argument list and convert it to parameter array */
13554 va_start(ap, routine_id);
13555
13557
13558 va_end(ap);
13559
13561
13564
13566
13567 /* in FAST TCP mode, only send call and return immediately */
13570
13572 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);
13573 free(nc);
13574 c->mutex.unlock();
13576 }
13577
13578 free(nc);
13579
13581 //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);
13582 //c->print();
13583 //printf("\n");
13584 c->close_locked();
13585 }
13586
13587 c->mutex.unlock();
13589 }
13590
13591 /* in TCP mode, send and wait for reply on send socket */
13594 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);
13595 c->mutex.unlock();
13597 }
13598
13599 free(nc);
13600 nc = NULL;
13601
13604 DWORD watchdog_timeout;
13606
13607 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, c->rpc_timeout);
13608
13612 }
13613
13615 DWORD buf_size = 0;
13617
13618 /* receive result on send socket */
13620
13623 }
13624
13626 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);
13627 if (buf)
13628 free(buf);
13629 c->mutex.unlock();
13631 }
13632
13634 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);
13635 if (buf)
13636 free(buf);
13637 c->mutex.unlock();
13639 }
13640
13641 c->mutex.unlock();
13642
13644 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);
13645 if (buf)
13646 free(buf);
13648 }
13649
13650 /* extract result variables and place it to argument list */
13651
13652 va_start(ap, routine_id);
13653
13655
13658 }
13659
13660 va_end(ap);
13661
13662 if (buf)
13663 free(buf);
13664 buf = NULL;
13665 buf_size = 0;
13666
13668}
Definition midas.cxx:11440
INT cm_set_watchdog_params(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3283
static RPC_CLIENT_CONNECTION * rpc_get_locked_client_connection(HNDLE hConn)
Definition midas.cxx:12620
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_check()
Definition at line 12278 of file midas.cxx.
12286{
12287#if 0
12290 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);
12291#endif
12292
12294
12295 /* check for broken connections */
12300
12302 // implicit unlock
12303 continue;
12304 }
12305
12306 //printf("rpc_client_check: connection %d: ", i);
12307 //c->print();
12308 //printf("\n");
12309
12311
12315
12317 timeout.tv_sec = 0;
12318 timeout.tv_usec = 0;
12319
12321
12322#ifdef OS_WINNT
12324#else
12325 do {
12328#endif
12329
12331 // implicit unlock
12332 continue;
12333 }
12334
12335 char buffer[64];
12336
12338 //printf("recv %d status %d, errno %d (%s)\n", sock, status, errno, strerror(errno));
12339
12341#ifndef OS_WINNT
12343 ok = 1;
12344 } else
12345#endif
12346 {
12347 // connection error
12349 "RPC client connection to \"%s\" on host \"%s\" is broken, recv() errno %d (%s)",
12350 c->client_name.c_str(),
12351 c->host_name.c_str(),
12353 ok = 0;
12354 }
12356 // connection closed by remote end without sending an EXIT message
12357 // this can happen if the remote end has crashed, so this message
12358 // is still necessary as a useful diagnostic for unexpected crashes
12359 // of midas programs. K.O.
12360 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());
12361 ok = 0;
12362 } else {
12363 // read some data
12364 ok = 1;
12366 /* normal exit */
12367 ok = 0;
12368 }
12369 }
12370
12372 //printf("rpc_client_check: closing connection %d: ", i);
12373 //c->print();
12374 //printf("\n");
12375
12376 // connection lost, close the socket
12377 c->close_locked();
12378 }
12379
12380 // implicit unlock
12381 }
12382 }
12383
12384 // implicit unlock of _client_connections_mutex
12385}
static std::vector< RPC_CLIENT_CONNECTION * > _client_connections
Definition midas.cxx:11504
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 12020 of file midas.cxx.
12043{
12046
12047 /* check if cm_connect_experiment was called */
12051 }
12052
12053 /* refuse connection to port 0 */
12054 if (port == 0) {
12057 }
12058
12060
12062
12063 {
12065
12067 printf("rpc_client_connect: host \"%s\", port %d, client \"%s\"\n", host_name, port, client_name);
12073 }
12074 }
12075 }
12076
12077 // slot with index 0 is not used, fill it with a NULL
12078
12081 }
12082
12084
12085 /* check if connection already exists */
12089
12091 gHostnameMutex.lock();
12093 }
12094
12096 // NB: we must release the hostname lock before taking
12097 // c->mutex to avoid a locking order inversion deadlock:
12098 // later on we lock the hostname mutex while holding the c->mutex
12099 gHostnameMutex.unlock();
12102 // check if socket is still connected
12104 // found connection slot with matching hostname and port number
12107 // so reuse it connection
12111 c->print();
12113 }
12114 // implicit unlock of c->mutex
12115 // gHostnameLock is not locked here
12117 }
12118 //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);
12119 c->close_locked();
12120 }
12121 // implicit unlock of c->mutex
12122 }
12123 }
12124 }
12125
12127 gHostnameMutex.unlock();
12129 }
12130
12131 // only start reusing connections once we have
12132 // a good number of slots allocated.
12135
12143 c->print();
12145 }
12147 break;
12148 }
12149 }
12150 }
12151
12152 // no slots to reuse, allocate a new slot.
12155
12156 // if empty slot not found, add to end of array
12159
12162 c->print();
12164 }
12165 }
12166
12167 c->mutex.lock();
12169
12170 // done with the array of connections
12171 // implicit unlock of _client_connections_mutex
12172 }
12173
12174 // locked connection slot for new connection
12176
12177 std::string errmsg;
12178
12179 /* create a new socket for connecting to remote server */
12182 cm_msg(MERROR, "rpc_client_connect", "cannot connect to \"%s\" port %d: %s", host_name, port, errmsg.c_str());
12183 c->mutex.unlock();
12185 }
12186
12187 gHostnameMutex.lock();
12188
12190 c->port = port;
12191
12192 gHostnameMutex.unlock();
12193
12194 c->client_name = client_name;
12196
12197 /* set TCP_NODELAY option for better performance */
12198 i = 1;
12200
12201 /* send local computer info */
12204
12206
12207 std::string cstr = msprintf("%d %s %s %s", hw_type, cm_get_version(), local_prog_name.c_str(), local_host_name.c_str());
12208
12212 cm_msg(MERROR, "rpc_client_connect", "cannot send %d bytes, send() returned %d, errno %d (%s)", size, i, errno, strerror(errno));
12213 c->mutex.unlock();
12215 }
12216
12219 DWORD watchdog_timeout;
12221
12222 //printf("watchdog timeout: %d, rpc_connect_timeout: %d\n", watchdog_timeout, _rpc_connect_timeout);
12223
12227 }
12228
12230
12231 /* receive remote computer info */
12233
12236 }
12237
12240 c->close_locked();
12241 c->mutex.unlock();
12243 }
12244
12245 int remote_hw_type = 0;
12247 remote_version[0] = 0;
12249
12250 c->remote_hw_type = remote_hw_type;
12251
12252 /* print warning if version patch level doesn't agree */
12258
12263
12265 cm_msg(MERROR, "rpc_client_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", remote_version, cm_get_version());
12266 }
12267
12269
12271
12272 c->mutex.unlock();
12273
12275}
INT ss_socket_connect_tcp(const char *hostname, int tcp_port, int *sockp, std::string *error_msg_p)
Definition system.cxx:4967
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_disconnect()
Definition at line 12684 of file midas.cxx.
12702{
12703 /* notify server about exit */
12704
12705 /* call exit and shutdown with RPC_NO_REPLY because client will exit immediately without possibility of replying */
12706
12707 rpc_client_call(hConn, bShutdown ? (RPC_ID_SHUTDOWN | RPC_NO_REPLY) : (RPC_ID_EXIT | RPC_NO_REPLY));
12708
12710}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_dispatch()
Definition at line 11953 of file midas.cxx.
11961{
11963 char net_buffer[256];
11964
11968
11970
11981
11982 //printf("rpc_client_dispatch: received MSG_BM!\n");
11983
11984 /* receive further messages to empty TCP queue */
11985 do {
11988
11989 timeout.tv_sec = 0;
11990 timeout.tv_usec = 0;
11991
11993
11998
12006 }
12007 }
12008
12010
12011 /* poll event from server */
12013 }
12014
12016}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_data()
Definition at line 11714 of file midas.cxx.
11742{
11743 /* convert array */
11746 /* don't convert TID_ARRAY & TID_STRUCT */
11748 return;
11749
11751
11754 rpc_convert_single(p, tid, flags, convert_flags);
11755 }
11756 } else {
11758 }
11759}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_single()
Definition at line 11689 of file midas.cxx.
11689 {
11690
11693 if (tid == TID_UINT32 || tid == TID_INT32 || tid == TID_BOOL || tid == TID_FLOAT) DWORD_SWAP(data);
11695 }
11696
11703 }
11704
11711 }
11712}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_debug_printf()
◆ rpc_deregister_functions()
dox
Definition at line 11878 of file midas.cxx.
11895{
11896 rpc_list_mutex.lock();
11897 rpc_list.clear();
11898 rpc_list_mutex.unlock();
11899
11901}
Here is the caller graph for this function:
◆ rpc_execute()
Definition at line 14658 of file midas.cxx.
14685{
14688 INT tid, flags;
14695#ifdef FIXED_BUFFER
14697#else
14699#endif
14700
14701 /* return buffer must must use thread local storage multi-thread servers */
14707 tls_size = 1;
14708 }
14711 break;
14713 /* new thread -> allocate new buffer */
14718 tls_size++;
14719 }
14720
14724 assert(return_buffer);
14725
14726 // make valgrind happy - the RPC parameter encoder skips the alignement padding bytes
14727 // and valgrind complains that we transmit uninitialized data
14728 //memset(return_buffer, 0, return_buffer_size);
14729
14730 /* extract pointer array to parameters */
14732
14733 /* convert header format (byte swapping) */
14734 if (convert_flags) {
14737 }
14738
14739 //if (nc_in->header.routine_id & RPC_NO_REPLY) {
14740 // printf("rpc_execute: routine_id %d, RPC_NO_REPLY\n", (int)(nc_in->header.routine_id & ~RPC_NO_REPLY));
14741 //}
14742
14743 /* no result return as requested */
14745 sock = 0;
14746
14747 /* find entry in rpc_list */
14749
14752
14753 rpc_list_mutex.lock();
14754
14759 break;
14760 }
14761 }
14762
14763 rpc_list_mutex.unlock();
14764
14768 }
14769
14770 again:
14771
14773
14776
14778
14782
14785
14788
14790 /* for arrays, the size is stored as a INT in front of the array */
14792 if (convert_flags)
14794 param_size = ALIGN8(param_size);
14795
14797 }
14798
14801
14803
14804 /* convert data format */
14805 if (convert_flags) {
14808 else
14810 convert_flags);
14811 }
14812
14815 /* check for long strings (db_create_record...) */
14820 } else
14822 } else
14824
14825 in_param_ptr += param_size;
14826 }
14827
14830
14832
14833 /* save maximum array length from the value of the next argument.
14834 * this means RPC_OUT arrays and strings should always be passed like this:
14835 * rpc_call(..., array_ptr, array_max_size, ...); */
14836
14838
14839 if (convert_flags)
14842
14844
14845 /* save space for return array length */
14847
14848 /* use maximum array length from input */
14849 param_size = max_size;
14850 }
14851
14854
14856#ifdef FIXED_BUFFER
14858 "return parameters (%d) too large for network buffer (%d)",
14860
14862#else
14865
14866#if 0
14868 "rpc_execute: return parameters (%d) too large for network buffer (%d), new buffer size (%d)",
14869 (int)((POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size), return_buffer_size, new_size);
14870#endif
14871
14873
14876
14880 }
14881
14884 assert(return_buffer);
14885
14887#endif
14888 }
14889
14890 /* if parameter goes both directions, copy input to output */
14893
14896
14898 out_param_ptr += param_size;
14899 }
14900
14903 }
14904
14905 //printf("predicted return size %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out);
14906
14909
14911
14912 /*********************************\
14913 * call dispatch function *
14914 \*********************************/
14917 else
14919
14920 if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN || routine_id == RPC_ID_WATCHDOG)
14922
14923 /* return immediately for closed down client connections */
14926
14929
14930 /* Return if TCP connection broken */
14933
14934 /* if sock == 0, we are in FTCP mode and may not sent results */
14935 if (!sock)
14937
14938 /* compress variable length arrays */
14945
14948 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
14949 // and prpc_param() is now pointing to the wrong place. here we know our string data
14950 // starts right after max_size and we do not need to use prpc_param[] to find it. K.O.
14951 //const char* param_ptr = (char *) prpc_param[i];
14953 //printf("string param [%s] max_size %d\n", param_ptr, max_size);
14955 param_size = ALIGN8(param_size);
14956
14957 /* move string ALIGN8(sizeof(INT)) left */
14959
14960 /* move remaining parameters to end of string */
14964 }
14965
14967 /* store array length at current out_param_ptr */
14969 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
14970 // and prpc_param() is now pointing to the wrong place. instead, compute location
14971 // of next parameter using max_size. K.O.
14972 // note: RPC_IN parameters are in the input buffer and we must use the prpc_param[] pointer. K.O.
14975 else
14978 if (convert_flags)
14980
14982
14983 param_size = ALIGN8(param_size);
14984
14985 /* move remaining parameters to end of array */
14989 }
14990
14993
14994 /* convert data format */
14995 if (convert_flags) {
14999 else
15003 }
15004
15005 out_param_ptr += param_size;
15006 }
15007
15008 /* send return parameters */
15011 nc_out->header.param_size = param_size;
15012
15013 //printf("actual return size %d, buffer used %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out, sizeof(NET_COMMAND_HEADER) + param_size);
15014
15015 /* convert header format (byte swapping) if necessary */
15016 if (convert_flags) {
15019 }
15020
15021 // valgrind complains about sending uninitialized data, if you care about this, uncomment
15022 // the memset(return_buffer,0) call above (search for "valgrind"). K.O.
15023
15025
15029 }
15030
15031 /* print return buffer */
15032/*
15033 printf("Return buffer, ID %d:\n", routine_id);
15034 for (i=0; i<param_size ; i++)
15035 {
15036 status = (char) nc_out->param[i];
15037 printf("%02X ", status);
15038 if (i%8 == 7)
15039 printf("\n");
15040 }
15041*/
15042 /* return SS_EXIT if RPC_EXIT is called */
15045
15046 /* return SS_SHUTDOWN if RPC_SHUTDOWN is called */
15049
15051}
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
Definition odb.cxx:10843
void rpc_convert_data(void *data, INT tid, INT flags, INT total_size, INT convert_flags)
Definition midas.cxx:11714
Definition midas.cxx:14648
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_flush_event()
◆ rpc_flush_event_socket()
Definition at line 16144 of file midas.cxx.
16158{
16160
16161 //printf("ss_event_socket_has_data() returned %d\n", has_data);
16162
16168 } else {
16173 }
16174 }
16175
16177
16178 //printf("rpc_server_receive_event() status %d\n", status);
16179
16182 }
16183
16186
16188}
INT rpc_server_receive_event(int idx, RPC_SERVER_ACCEPTION *sa, int timeout_msec)
Definition midas.cxx:15989
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_get_convert_flags() [1/2]
◆ rpc_get_convert_flags() [2/2]
◆ rpc_get_hw_type()
| INT rpc_get_hw_type | ( | ) |
Definition at line 12842 of file midas.cxx.
12853{
12854 {
12855 {
12858 unsigned char *p;
12859 float f;
12861
12862 tmp_type = 0;
12863
12864 /* test pointer size */
12865 size = sizeof(p);
12866 if (size == 2)
12868 if (size == 4)
12870 if (size == 8)
12872
12873 /* test if little or big endian machine */
12874 dummy = 0x12345678;
12876 if (*p == 0x78)
12878 else if (*p == 0x12)
12880 else
12882
12883 /* floating point format */
12884 f = (float) 1.2345;
12885 dummy = 0;
12889 && ((dummy >> 24) & 0xFF) == 0x3F)
12893 && ((dummy >> 24) & 0xFF) == 0x04)
12895 else
12897
12899 dummy = 0;
12903 && ((dummy >> 24) & 0xFF) == 0x12)
12907 && ((dummy >> 24) & 0xFF) == 0x3F)
12911 && ((dummy >> 24) & 0xFF) == 0xC0)
12915 && ((dummy >> 24) & 0xFF) == 0x04)
12917 "MIDAS cannot handle VAX D FLOAT format. Please compile with the /g_float flag");
12918 else
12920
12922 }
12923 }
12924}
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 12620 of file midas.cxx.
12621{
12622 _client_connections_mutex.lock();
12626 _client_connections_mutex.unlock();
12629 // disconnected while we were waiting for the lock
12630 c->mutex.unlock();
12632 }
12634 }
12635 }
12636 _client_connections_mutex.unlock();
12638}
Here is the call graph for this function:
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()
◆ rpc_get_name()
| std::string rpc_get_name | ( | ) |
◆ rpc_get_opt_tcp_size()
◆ rpc_get_server_acception()
|
static |
◆ 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 12981 of file midas.cxx.
12982{
12987 } else {
12991 c->mutex.unlock();
12992 return timeout;
12993 }
12994 }
12995 return 0;
12996}
Here is the call graph for this function:
◆ rpc_ieee2vax_double()
◆ rpc_ieee2vax_float()
◆ rpc_is_connected()
◆ rpc_is_mserver()
◆ rpc_is_remote()
◆ rpc_name_tid()
◆ rpc_new_server_acception()
|
static |
Definition at line 11526 of file midas.cxx.
11527{
11530 //printf("rpc_new_server_acception: reuse acception in slot %d\n", idx);
11532 }
11533 }
11534
11536
11539 //printf("rpc_new_server_acception: new acception, reuse slot %d\n", idx);
11542 }
11543 }
11544
11545 //printf("rpc_new_server_acception: new acception, array size %d, push_back\n", (int)_server_acceptions.size());
11546 _server_acceptions.push_back(sa);
11547
11548 return sa;
11549}
struct rpc_server_acception_struct RPC_SERVER_ACCEPTION
Here is the call graph for this function:
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 11816 of file midas.cxx.
11816 {
11820
11822}
INT rpc_register_functions(const RPC_LIST *new_list, RPC_HANDLER func)
Definition midas.cxx:11835
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_register_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 11835 of file midas.cxx.
11836{
11838 /* check valid ID for user functions */
11842 cm_msg(MERROR, "rpc_register_functions", "registered RPC function with invalid ID %d", new_list[i].id);
11843 }
11844 }
11845
11847
11848 /* check double defined functions */
11853 }
11854 }
11855 }
11856
11857 /* append new functions */
11860
11861 /* set default dispatcher */
11864 }
11865
11867 }
11868
11870}
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 14587 of file midas.cxx.
14610{
14611 /* register system functions: RPC_ID_EXIT, RPC_ID_SHUTDOWN, RPC_ID_WATCHDOG */
14613
14614 /* create a socket for listening */
14617 std::string errmsg;
14618
14619 int status = ss_socket_listen_tcp(!disable_bind_rpc_to_localhost, port, &lsock, &lport, &errmsg);
14620
14622 cm_msg(MERROR, "rpc_register_server", "cannot listen to tcp port %d: %s", port, errmsg.c_str());
14624 }
14625
14626 /* set close-on-exec flag to prevent child mserver processes from inheriting the listen socket */
14627#if defined(F_SETFD) && defined(FD_CLOEXEC)
14630 cm_msg(MERROR, "rpc_register_server", "fcntl(F_SETFD, FD_CLOEXEC) failed, errno %d (%s)", errno, strerror(errno));
14632 }
14633#endif
14634
14635 /* return port wich OS has choosen */
14638 }
14639
14642
14643 //printf("rpc_register_server: requested port %d, actual port %d, socket %d\n", port, *pport, *plsock);
14644
14646}
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:5062
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_register_server()
Definition at line 14546 of file midas.cxx.
14568{
14571
14575
14579
14582
14584}
INT ss_suspend_set_client_listener(int listen_socket)
Definition system.cxx:4284
INT rpc_register_listener(int port, RPC_HANDLER func, int *plsock, int *pport)
Definition midas.cxx:14587
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 13909 of file midas.cxx.
13910{
13913 } else {
13915 }
13916}
INT bm_send_event(INT buffer_handle, const EVENT_HEADER *pevent, int unused, int timeout_msec)
Definition midas.cxx:9686
INT rpc_send_event1(INT buffer_handle, const EVENT_HEADER *pevent)
Definition midas.cxx:13927
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 13927 of file midas.cxx.
13928{
13931}
INT rpc_send_event_sg(INT buffer_handle, int sg_n, const char *const sg_ptr[], const size_t sg_len[])
Definition midas.cxx:13933
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 13933 of file midas.cxx.
13934{
13938 }
13939
13943 }
13944
13946 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));
13948 }
13949
13951
13952 const DWORD MAX_DATA_SIZE = (0x7FFFFFF0 - 16); // event size computations are not 32-bit clean, limit event size to 2GB. K.O.
13954
13955 if (data_size == 0) {
13958 }
13959
13961 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);
13963 }
13964
13967
13971 }
13972
13974 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);
13976 }
13977
13978 // protect non-atomic access to _server_connection.event_sock. K.O.
13979
13981
13982 //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);
13983
13986 }
13987
13988 //
13989 // event socket wire protocol: (see also rpc_server_receive_event() and recv_event_server_realloc())
13990 //
13991 // 4 bytes of buffer handle
13992 // 16 bytes of event header, includes data_size
13993 // ALIGN8(data_size) bytes of event data
13994 //
13995
13997
13998 /* send buffer handle */
13999
14002
14006 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(buffer handle) failed, event socket is now closed");
14008 }
14009
14010 /* send data */
14011
14016 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(event data) failed, event socket is now closed");
14018 }
14019 }
14020
14021 /* send padding */
14022
14026 assert(padlen < 8);
14030 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(padding) failed, event socket is now closed");
14032 }
14033 }
14034
14036}
INT ss_write_tcp(int sock, const char *buffer, size_t buffer_size)
Definition system.cxx:5352
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_accept()
Definition at line 15349 of file midas.cxx.
15370{
15372 INT sock;
15376 char *ptr;
15377 char net_buffer[256];
15379
15381
15384
15385 if (sock == -1)
15387 } else {
15388 /* lsock is stdin -> already connected from inetd */
15389
15390 sock = lsock;
15391 }
15392
15393 /* check access control list */
15396
15398 ss_socket_close(&sock);
15400 }
15401 }
15402
15403 /* receive string with timeout */
15406
15409
15410 //printf("rpc_server_accept: command [%c]\n", command);
15411
15412 switch (command) {
15413 case 'S': {
15414
15415 /*----------- shutdown listener ----------------------*/
15416 ss_socket_close(&sock);
15418 }
15419 case 'I': {
15420
15421 /*----------- return available experiments -----------*/
15422#ifdef LOCAL_ROUTINES
15423 exptab_struct exptab;
15429 }
15431#endif
15432 ss_socket_close(&sock);
15433 break;
15434 }
15435 case 'C': {
15436
15437 /*----------- connect to experiment -----------*/
15438
15439 /* get callback information */
15442
15443 //printf("rpc_server_accept: net buffer \'%s\'\n", net_buffer);
15444
15445 /* parse string in format "C port1 port2 port3 version expt" */
15446 /* example: C 51046 45838 56832 2.0.0 alpha */
15447
15451
15452 while (*ptr == ' ')
15453 ptr++;
15454
15455 i = 0;
15457 version[i++] = *ptr++;
15458
15459 // ensure that we do not overwrite buffer "version"
15461 version[i] = 0;
15462
15463 // skip wjatever is left from the "version" string
15464 for (; *ptr != 0 && *ptr != ' ';)
15465 ptr++;
15466
15467 while (*ptr == ' ')
15468 ptr++;
15469
15470 i = 0;
15471 for (; *ptr != 0 && *ptr != ' ' && *ptr != '\n' && *ptr != '\r' && i < (int) sizeof(experiment) - 1;)
15473
15474 // ensure that we do not overwrite buffer "experiment"
15477
15479
15480 /* print warning if version patch level doesn't agree */
15485
15491
15493 cm_msg(MERROR, "rpc_server_accept", "client MIDAS version %s differs from local version %s", version, cm_get_version());
15495 }
15496
15501
15503
15505 ss_socket_close(&sock);
15506 break;
15507 }
15508
15509#ifdef LOCAL_ROUTINES
15510 /* update experiment definition */
15511 exptab_struct exptab;
15513
15516 /* lookup experiment */
15519 idx = 0;
15520 } else {
15525 break;
15526 }
15527 }
15528 }
15529 }
15530
15532 cm_msg(MERROR, "rpc_server_accept", "experiment \'%s\' not defined in exptab file \'%s\'", callback.experiment.c_str(), exptab.filename.c_str());
15533
15535 ss_socket_close(&sock);
15536 break;
15537 }
15538
15541
15542 /* create a new process */
15545
15550
15552
15564
15567 argv[9]);
15568
15570
15573
15576 ss_socket_close(&sock);
15577 break;
15578 }
15579
15582#endif // LOCAL_ROUTINES
15583 ss_socket_close(&sock);
15584
15585 break;
15586 }
15587 default: {
15588 cm_msg(MERROR, "rpc_server_accept", "received unknown command '%c' code %d", command, command);
15589 ss_socket_close(&sock);
15590 break;
15591 }
15592 }
15593 } else { /* if i>0 */
15594
15595 /* lingering needed for PCTCP */
15596 ling.l_onoff = 1;
15597 ling.l_linger = 0;
15599 ss_socket_close(&sock);
15600 }
15601
15603}
INT ss_socket_get_peer_name(int sock, std::string *hostp, int *portp)
Definition system.cxx:5246
INT ss_spawnv(INT mode, const char *cmdname, const char *const argv[])
Definition system.cxx:1630
Definition msystem.h:310
Definition midas.cxx:1600
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 15710 of file midas.cxx.
15729{
15731 int recv_sock, send_sock, event_sock;
15733 std::string client_program;
15735 INT convert_flags;
15736 char net_buffer[256];
15737 char *p;
15739
15740 /* copy callback information */
15742 //idx = callback.index;
15743
15744 std::string errmsg;
15745
15746 /* create new sockets for TCP */
15747 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port1, &recv_sock, &errmsg);
15748
15750 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());
15751 ss_socket_close(&recv_sock);
15752 //ss_socket_close(&send_sock);
15753 //ss_socket_close(&event_sock);
15755 }
15756
15757 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port2, &send_sock, &errmsg);
15758
15760 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());
15761 ss_socket_close(&recv_sock);
15762 ss_socket_close(&send_sock);
15763 //ss_socket_close(&event_sock);
15765 }
15766
15767 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port3, &event_sock, &errmsg);
15768
15770 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());
15771 ss_socket_close(&recv_sock);
15772 ss_socket_close(&send_sock);
15773 ss_socket_close(&event_sock);
15775 }
15776#ifndef OS_ULTRIX /* crashes ULTRIX... */
15777 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
15778 flag = 2 * 1024 * 1024;
15781 cm_msg(MERROR, "rpc_server_callback", "cannot setsockopt(SOL_SOCKET, SO_RCVBUF), errno %d (%s)", errno,
15783#endif
15784
15787 ss_socket_close(&recv_sock);
15788 ss_socket_close(&send_sock);
15789 ss_socket_close(&event_sock);
15791 }
15792 //printf("rpc_server_callback: \'%s\'\n", net_buffer);
15793
15794 /* get remote computer info */
15796
15797 while (*p == ' ')
15798 p++;
15799
15800 client_program = p;
15801
15802 //printf("hw type %d, name \'%s\'\n", client_hw_type, client_program);
15803
15804 std::string host_name;
15805
15807
15810
15811 //printf("rpc_server_callback: mserver acception\n");
15812
15814
15815 /* save information in _server_acception structure */
15816 sa->recv_sock = recv_sock;
15817 sa->send_sock = send_sock;
15818 sa->event_sock = event_sock;
15823 sa->watchdog_timeout = 0;
15825
15827
15828 _mserver_acception = sa;
15829
15830 //printf("rpc_server_callback: _mserver_acception %p\n", _mserver_acception);
15831
15832 /* send my own computer id */
15836
15838 sa->convert_flags = convert_flags;
15839
15841
15843 rpc_debug_printf("Connection to %s:%s established\n", sa->host_name.c_str(), sa->prog_name.c_str());
15844 }
15845
15847}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_connect()
Definition at line 12389 of file midas.cxx.
12417{
12424 char *s;
12425
12426#ifdef OS_WINNT
12427 {
12429
12430 /* Start windows sockets */
12433 }
12434#endif
12435
12436 /* check if local connection */
12439
12440 /* register system functions */
12442
12443 /* check if cm_connect_experiment was called */
12447 }
12448
12449 /* check if connection already exists */
12452
12456
12458
12461
12465
12466 std::string errmsg;
12467
12469
12473 }
12474
12476
12480 }
12481
12483
12487 }
12488
12489 /* extract port number from host_name */
12492 if (s) {
12493 *s = 0;
12495 }
12496
12497 int sock;
12498
12500
12502 cm_msg(MERROR, "rpc_server_connect", "cannot connect to mserver on host \"%s\" port %d: %s", str, port, errmsg.c_str());
12504 }
12505
12506 /* connect to experiment */
12509 else
12511
12514 ss_socket_close(&sock);
12518 }
12519
12520 status = version[0] = 0;
12522
12524/* message "undefined experiment" should be displayed by application */
12526 }
12527
12528 /* print warning if version patch level doesn't agree */
12529 strcpy(v1, version);
12533
12538
12540 cm_msg(MERROR, "rpc_server_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", version,
12541 cm_get_version());
12542 }
12543
12544 /* wait for callback on send and recv socket with timeout */
12549
12550 timeout.tv_sec = _rpc_connect_timeout / 1000;
12551 timeout.tv_usec = 0;
12552
12553 do {
12555
12556 /* if an alarm signal was cought, restart select with reduced timeout */
12558 timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
12559
12561
12568 }
12569
12573
12574 if (_server_connection.send_sock == -1 || _server_connection.recv_sock == -1 || _server_connection.event_sock == -1) {
12577 }
12578
12582
12583 /* set TCP_NODELAY option for better performance */
12585 setsockopt(_server_connection.send_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12586 setsockopt(_server_connection.event_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12587
12588 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
12589 flag = 2 * 1024 * 1024;
12590 status = setsockopt(_server_connection.event_sock, SOL_SOCKET, SO_SNDBUF, (char *) &flag, sizeof(flag));
12592 cm_msg(MERROR, "rpc_server_connect", "cannot setsockopt(SOL_SOCKET, SO_SNDBUF), errno %d (%s)", errno, strerror(errno));
12593
12594 /* send local computer info */
12598
12600
12601 /* receive remote computer info */
12606 }
12607
12610
12612
12614
12616}
INT ss_suspend_set_client_connection(RPC_SERVER_CONNECTION *connection)
Definition system.cxx:4291
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_disconnect()
Definition at line 12713 of file midas.cxx.
12733{
12735
12738
12739 rpc_server_disconnect_recursion_level = 1;
12740
12741 /* flush remaining events */
12742 rpc_flush_event();
12743
12744 /* notify server about exit */
12747 }
12748
12749 /* close sockets */
12756
12758
12759 /* remove semaphore */
12763
12764 rpc_server_disconnect_recursion_level = 0;
12766}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_loop()
Definition at line 15851 of file midas.cxx.
15859{
15860 while (1) {
15862
15864 break;
15865
15867 break;
15868
15869 /* check alarms, etc */
15871
15872 cm_msg_flush_buffer();
15873 }
15874
15876}
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 15989 of file midas.cxx.
16003{
16005
16007
16008 //
16009 // THIS IS NOT THREAD SAFE!!!
16010 //
16011 // IT IS ONLY USED BY THE MSERVER
16012 // MSERVER IS SINGLE-THREADED!!!
16013 //
16014
16018
16019 // short cut
16022
16024
16027 // do not do anything if we are called recursively
16028 // via recursive ss_suspend() or otherwise. K.O.
16031 else
16033 }
16034
16036
16037 do {
16040
16043 cm_msg(MERROR, "rpc_server_receive_event", "recv_event_server_realloc() returned %d, abort", n_received);
16044 goto error;
16045 }
16046
16048 // no more data in the tcp socket
16051 }
16052
16054 }
16055
16057 // no event in xbuf buffer
16060 }
16061
16062 /* send event to buffer */
16065
16067
16068 //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);
16069
16071 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d (SS_ABORT), abort", status);
16072 goto error;
16073 }
16074
16076 //cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, event buffer is full", status);
16079 }
16080
16082 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, mserver dropped this event", status);
16083 }
16084
16086
16087 /* repeat for maximum 0.5 sec */
16089
16092
16093 error:
16094
16095 {
16100 cm_msg(MTALK, "rpc_server_receive_event", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
16101 }
16102
16103 //exit:
16104
16105 cm_msg_flush_buffer();
16106
16107 /* disconnect from experiment as MIDAS server */
16110
16112
16113 /* only disconnect from experiment if previously connected.
16114 Necessary for pure RPC servers (RPC_SRVR) */
16116 bm_close_all_buffers();
16118 db_close_all_databases();
16119
16120 rpc_deregister_functions();
16121
16122 cm_set_experiment_database(0, 0);
16123 }
16124 }
16125
16127
16128 sa->close();
16129
16130 /* signal caller a shutdonw */
16133
16134 /* only the mserver should stop on server connection closure */
16135 if (!is_mserver) {
16137 }
16138
16140}
INT cm_get_experiment_database(HNDLE *hDB, HNDLE *hKeyClient)
Definition midas.cxx:3011
INT cm_set_experiment_database(HNDLE hDB, HNDLE hKeyClient)
Definition midas.cxx:2939
static int recv_event_server_realloc(INT idx, RPC_SERVER_ACCEPTION *psa, char **pbuffer, int *pbuffer_size)
Definition midas.cxx:14395
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_receive_rpc()
| INT rpc_server_receive_rpc | ( | int | idx, |
| RPC_SERVER_ACCEPTION * | sa | ||
| ) |
Definition at line 15879 of file midas.cxx.
15894{
15897
15900
15901 do {
15903
15906 cm_msg(MERROR, "rpc_server_receive_rpc", "recv_net_command() returned %d, abort", n_received);
15907 goto error;
15908 }
15909
15911
15914 goto error;
15915 }
15916
15919 rpc_debug_printf("Connection to %s:%s closed\n", sa->host_name.c_str(), sa->prog_name.c_str());
15920 goto exit;
15921 }
15922
15924
15925 if (buf) {
15926 free(buf);
15927 buf = NULL;
15928 bufsize = 0;
15929 }
15930
15932
15933 error:
15934
15935 {
15940 cm_msg(MTALK, "rpc_server_receive_rpc", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
15941 }
15942
15943 exit:
15944
15945 cm_msg_flush_buffer();
15946
15947 if (buf) {
15948 free(buf);
15949 buf = NULL;
15950 bufsize = 0;
15951 }
15952
15953 /* disconnect from experiment as MIDAS server */
15956
15958
15959 /* only disconnect from experiment if previously connected.
15960 Necessary for pure RPC servers (RPC_SRVR) */
15962 bm_close_all_buffers();
15964 db_close_all_databases();
15965
15966 rpc_deregister_functions();
15967
15968 cm_set_experiment_database(0, 0);
15969 }
15970 }
15971
15973
15974 sa->close();
15975
15976 /* signal caller a shutdonw */
15979
15980 /* only the mserver should stop on server connection closure */
15981 if (!is_mserver) {
15983 }
15984
15986}
static int recv_net_command_realloc(INT idx, char **pbuf, int *pbufsize, INT *remaining)
Definition midas.cxx:14205
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_shutdown()
Definition at line 16191 of file midas.cxx.
16208{
16209 //printf("rpc_server_shutdown!\n");
16210
16212
16213 /* close all open connections */
16217 /* lingering needed for PCTCP */
16218 ling.l_onoff = 1;
16219 ling.l_linger = 0;
16222
16226 }
16227
16231 }
16232 }
16233 }
16234
16235 /* avoid memory leak */
16238 if (sa) {
16239 //printf("rpc_server_shutdown: %d %p %p\n", idx, sa, _mserver_acception);
16241 // do not leave behind a stale pointer!
16243 }
16244 delete sa;
16246 }
16247 }
16248
16252 }
16253
16254 /* free suspend structures */
16255 ss_suspend_exit();
16256
16258}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_set_debug()
◆ rpc_set_mserver_path()
◆ rpc_set_name()
◆ rpc_set_opt_tcp_size()
◆ 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 13006 of file midas.cxx.
13007{
13008 //printf("rpc_set_timeout: hConn %d, timeout_msec %d\n", hConn, timeout_msec);
13009
13018 } else {
13024 c->mutex.unlock();
13025 } else {
13027 *old_timeout_msec = 0;
13028 }
13029 }
13031}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_socket_check_allowed_host()
Definition at line 15321 of file midas.cxx.
15322{
15323 std::string hostname;
15324
15326
15329
15331
15334
15337 max_report--;
15339 cm_msg(MERROR, "rpc_socket_check_allowed_host", "rejecting connection from unallowed host \'%s\', this message will no longer be reported", hostname.c_str());
15340 } else {
15341 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());
15342 }
15343 }
15344
15346}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_test_rpc()
| int rpc_test_rpc | ( | ) |
Definition at line 15054 of file midas.cxx.
15070{
15072
15074
15077
15080
15083
15085
15087 struct_in.num_values = 222;
15089 struct_in.last_written = 333;
15090
15093
15095 struct_inout.num_values = 222222;
15097 struct_inout.last_written = 333333;
15098
15101
15104 }
15105
15107
15110 }
15111
15114
15116 123,
15117 &int_out,
15118 &int_inout,
15119 "test string",
15123 &struct_in,
15124 &struct_out,
15125 &struct_inout,
15129 );
15130
15132
15135 status = 0;
15136 }
15137
15140 status = 0;
15141 }
15142
15145 status = 0;
15146 }
15147
15150 status = 0;
15151 }
15152
15155 status = 0;
15156 }
15157
15159
15161
15162 //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
15163
15165
15166 if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
15167 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);
15168 status = 0;
15169 }
15170
15172
15173 if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
15174 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);
15175 status = 0;
15176 }
15177
15178#if 0
15181 status = 0;
15182 }
15183
15186 }
15187#endif
15188
15189#if 0
15203 {0}}},
15204#endif
15205
15206#if 0
15208#endif
15209
15211}
Definition midas.h:1026
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_tid_name()
◆ rpc_tid_name_old()
◆ rpc_tid_size()
◆ rpc_transition_dispatch()
Definition at line 14064 of file midas.cxx.
14083{
14084 /* erase error string */
14085 *(CSTRING(2)) = 0;
14086
14088 // find registered handler
14089 // NB: this code should match same code in cm_transition_call_direct()
14090 // NB: only use the first handler, this is how MIDAS always worked
14091 // NB: we could run all handlers, but we can return the status and error string of only one of them.
14092 _trans_table_mutex.lock();
14094 _trans_table_mutex.unlock();
14095
14097 _trans_table_mutex.lock();
14099 _trans_table_mutex.unlock();
14100
14103 /* execute callback if defined */
14105 } else {
14107 /* store transition in FIFO */
14113 // implicit unlock
14115 }
14116 }
14117 }
14118 // no handler for this transition
14119 cm_msg(MERROR, "rpc_transition_dispatch", "no handler for transition %d with sequence number %d", CINT(0), CINT(4));
14121 } else {
14124 }
14125}
Definition midas.cxx:241
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_va_arg()
Definition at line 13201 of file midas.cxx.
13201 {
13203 /* On the stack, the minimum parameter size is sizeof(int).
13204 To avoid problems on little endian systems, treat all
13205 smaller parameters as int's */
13212 break;
13213
13217 break;
13218
13221 break;
13222
13223 /* float variables are passed as double by the compiler */
13226 break;
13227
13230 break;
13231
13234 break;
13235 }
13236}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_vax2ieee_double()
◆ rpc_vax2ieee_float()
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 |
