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 11565 of file midas.cxx.
11566{
11567 //printf("RPC_SERVER_ACCEPTION::close: connection from %s program %s mserver %d\n", host_name.c_str(), prog_name.c_str(), is_mserver);
11568
11573 }
11574
11575 /* close server connection */
11582
11583 /* free TCP cache */
11585 //printf("free net_buffer %p+%d\n", net_buffer, net_buffer_size);
11586 free(net_buffer);
11588 net_buffer_size = 0;
11589 }
11590
11591 /* mark this entry as invalid */
11592 clear();
11593}
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 11953 of file midas.cxx.
11953 {
11954 //printf("rpc_client_dispatch: MSG_ODB: packet size %d, expected %d\n", n, (int)(sizeof(NET_COMMAND_HEADER) + 4 * sizeof(INT)));
11956 /* update a changed record */
11962 }
11964}
INT db_update_record_local(INT hDB, INT hKeyRoot, INT hKey, int index)
Definition odb.cxx:13562
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 14409 of file midas.cxx.
14431{
14433
14434 //printf("recv_event_server: idx %d, buffer %p, buffer_size %d\n", idx, buffer, buffer_size);
14435
14437
14439
14440 // First read the header.
14441 //
14442 // Data format is:
14443 // INT buffer handle (4 bytes)
14444 // EVENT_HEADER (16 bytes)
14445 // event data
14446 // ALIGN8() padding
14447 // ...next event
14448
14450
14452 // timeout waiting for data
14453 return 0;
14454 }
14455
14456 /* abort if connection broken */
14459 return -1;
14460 }
14461
14464
14465 /* abort if connection broken */
14468 return -1;
14469 }
14470
14472 }
14473
14474 /* abort if connection broken */
14476 cm_msg(MERROR, "recv_event_server", "recv_tcp2(header) returned %d instead of %d", hrd, (int) header_size);
14477 return -1;
14478 }
14479
14482
14483 /* convert header little endian/big endian */
14491 }
14492
14495
14496 //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);
14497
14501 }
14502 abort();
14503 }
14504
14505 /* check for sane event size */
14508 "received event header with invalid data_size %d: event_size %d, total_size %d", pevent->data_size,
14509 event_size, total_size);
14510 return -1;
14511 }
14512
14513 //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);
14514
14515
14517
14518 // Second, check that output buffer is big enough
14519
14520 /* check if data part fits in buffer */
14523
14524 //printf("recv_event_server: buffer realloc %d -> %d\n", *pbuffer_size, newsize);
14525
14528 cm_msg(MERROR, "recv_event_server", "cannot realloc() event buffer from %d to %d bytes", *pbuffer_size,
14529 newsize);
14530 return -1;
14531 }
14534 }
14535
14536 // Third, copy header into output buffer
14537
14539
14540 // Forth, read the event data
14541
14544
14547
14548 /* abort if connection broken */
14550 cm_msg(MERROR, "recv_event_server", "recv_tcp2(data) returned %d instead of %d", drd, to_read);
14551 return -1;
14552 }
14553 }
14554
14556}
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:929
void rpc_convert_single(void *data, INT tid, INT flags, INT convert_flags)
Definition midas.cxx:11703
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 14219 of file midas.cxx.
14247{
14248 char *buffer = NULL; // buffer is changed to point to *pbuf when we receive the NET_COMMAND header
14249
14251
14253
14257 else
14259
14261 //printf("sa %p idx %d, net_buffer %p+%d\n", sa, idx, sa->net_buffer, sa->net_buffer_size);
14262 sa->write_ptr = 0;
14263 sa->read_ptr = 0;
14264 sa->misalign = 0;
14265 }
14267 cm_msg(MERROR, "recv_net_command", "Cannot allocate %d bytes for network buffer", sa->net_buffer_size);
14268 return -1;
14269 }
14270
14272 int param_size = -1;
14273
14278
14279 do {
14281 if (param_size == -1) {
14283 /* assemble split header */
14287 } else {
14290 }
14291
14294 }
14295
14296 //printf("recv_net_command: param_size %d, NET_COMMAND_HEADER %d, buffer_size %d\n", param_size, (int)sizeof(NET_COMMAND_HEADER), *pbufsize);
14297
14298 /* check if parameters fit in buffer */
14302 //printf("recv_net_command: reallocate buffer %d -> %d, %p\n", *pbufsize, new_size, p);
14304 cm_msg(MERROR, "recv_net_command", "cannot reallocate buffer from %d bytes to %d bytes", *pbufsize, new_size);
14305 sa->read_ptr = 0;
14306 sa->write_ptr = 0;
14307 return -1;
14308 }
14309 *pbuf = p;
14311 }
14312
14313 buffer = *pbuf;
14314
14315 /* check if we have all parameters in buffer */
14317 break;
14318 }
14319
14320 /* not enough data, so copy partially and get new */
14321 int size = write_ptr - read_ptr;
14322
14323 if (size > 0) {
14325 copied += size;
14326 read_ptr = write_ptr;
14327 }
14328#ifdef OS_UNIX
14329 do {
14331
14332 /* don't return if an alarm signal was cought */
14334#else
14336#endif
14337
14338 /* abort if connection broken */
14339 if (write_ptr <= 0) {
14340 if (write_ptr == 0)
14341 cm_msg(MERROR, "recv_net_command", "rpc connection from \'%s\' on \'%s\' unexpectedly closed", sa->prog_name.c_str(), sa->host_name.c_str());
14342 else
14343 cm_msg(MERROR, "recv_net_command", "recv() returned %d, errno: %d (%s)", write_ptr, errno, strerror(errno));
14344
14346 *remaining = 0;
14347
14348 return write_ptr;
14349 }
14350
14351 read_ptr = misalign;
14352 write_ptr += misalign;
14353
14354 misalign = write_ptr % 8;
14356
14357 /* copy rest of parameters */
14360 read_ptr += size;
14361
14363 /* don't keep rpc_server_receive in an infinite loop */
14364 if (write_ptr - read_ptr < param_size)
14365 *remaining = 0;
14366 else
14367 *remaining = write_ptr - read_ptr;
14368 }
14369
14370 sa->write_ptr = write_ptr;
14371 sa->read_ptr = read_ptr;
14372 sa->misalign = misalign;
14373
14375}
static RPC_SERVER_ACCEPTION * rpc_get_server_acception(int idx)
Definition midas.cxx:11527
Definition msystem.h:292
Definition msystem.h:362
Here is the call graph for this function:
Here is the caller graph for this function:
◆ recv_tcp_check()
Definition at line 14379 of file midas.cxx.
14397{
14398 /* figure out to which connection socket belongs */
14402 }
14403
14404 return 0;
14405}
static std::vector< RPC_SERVER_ACCEPTION * > _server_acceptions
Definition midas.cxx:11524
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_add_allowed_host()
Definition at line 15257 of file midas.cxx.
15274{
15275 //cm_msg(MINFO, "rpc_add_allowed_host", "Adding allowed host \'%s\'", hostname);
15276
15277 gAllowedHostsMutex.lock();
15278 gAllowedHosts.push_back(hostname);
15280 gAllowedHostsMutex.unlock();
15281
15283}
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 11605 of file midas.cxx.
11605 {
11606 *convert_flags = 0;
11607
11608 /* big/little endian conversion */
11612 *convert_flags |= CF_ENDIAN;
11613
11614 /* float conversion between IEEE and VAX G */
11616 *convert_flags |= CF_VAX2IEEE;
11617
11618 /* float conversion between VAX G and IEEE */
11620 *convert_flags |= CF_IEEE2VAX;
11621
11623 //if (remote_hw_type & DR_ASCII)
11624 // *convert_flags |= CF_ASCII;
11625}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call()
Definition at line 13685 of file midas.cxx.
13709{
13712
13714 routine_id &= ~RPC_NO_REPLY;
13715
13716 //if (rpc_no_reply)
13717 // printf("rpc_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
13718
13721
13722 if (!send_sock) {
13725 }
13726
13728 /* create a local mutex for multi-threaded applications */
13730 }
13731
13736 }
13737
13738 /* find rpc definition */
13739
13743
13744 rpc_list_mutex.lock();
13745
13751 break;
13752 }
13753 }
13754
13755 rpc_list_mutex.unlock();
13756
13761 }
13762
13763 /* prepare output buffer */
13764
13766
13767 /* examine variable argument list and convert it to parameter array */
13768 va_start(ap, routine_id);
13769
13771
13772 va_end(ap);
13773
13775
13778
13780
13781 /* do not wait for reply if requested RPC_NO_REPLY */
13784
13788 free(nc);
13790 }
13791
13793 free(nc);
13795 }
13796
13797 /* in TCP mode, send and wait for reply on send socket */
13802 free(nc);
13804 }
13805
13806 free(nc);
13807 nc = NULL;
13808
13811 DWORD watchdog_timeout;
13813
13814 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, rpc_timeout);
13815
13817 // if RPC is remote, we are connected to an mserver,
13818 // the mserver takes care of watchdog timeouts.
13819 // otherwise we should make sure the watchdog timeout
13820 // is longer than the RPC timeout. K.O.
13821 if (rpc_timeout >= (int) watchdog_timeout) {
13824 }
13825 }
13826
13828 DWORD buf_size = 0;
13830
13832
13835 }
13836
13837 /* drop the mutex, we are done with the socket, argument unpacking is done from our own buffer */
13838
13840
13841 /* check for reply errors */
13842
13844 cm_msg(MERROR, "rpc_call", "routine \"%s\": timeout waiting for reply, program abort", rpc_name);
13845 if (buf)
13846 free(buf);
13849 }
13850
13852 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, ss_recv_net_command() status %d, program abort", rpc_name, status);
13853 if (buf)
13854 free(buf);
13857 }
13858
13860 cm_msg(MERROR, "rpc_call", "routine \"%s\": error, unknown RPC, status %d", rpc_name, rpc_status);
13861 if (buf)
13862 free(buf);
13864 }
13865
13866 /* extract result variables and place it to argument list */
13867
13868 va_start(ap, routine_id);
13869
13871
13874 }
13875
13876 va_end(ap);
13877
13878 if (buf)
13879 free(buf);
13880
13882}
INT cm_get_watchdog_params(BOOL *call_watchdog, DWORD *timeout)
Definition midas.cxx:3339
INT cm_set_watchdog_params_local(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3258
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:13253
static int rpc_call_decode(va_list &ap, const RPC_LIST &rl, const char *buf, size_t buf_size)
Definition midas.cxx:13424
Definition midas.h:1595
Here is the call graph for this function:
◆ rpc_call_decode()
|
static |
Definition at line 13424 of file midas.cxx.
13425{
13427
13430
13431 /* extract result variables and place it to argument list */
13432
13434
13439
13443
13446 else
13448
13451
13452 char arg[8];
13454
13456
13458 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);
13460 }
13461
13464
13467
13471 }
13472
13475
13476 /* parameter size is always aligned */
13478
13479 /* return parameters are always pointers */
13480 if (*((char **) arg)) {
13482 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);
13484 }
13485
13486 param_ptr += param_size;
13487 }
13488 }
13489
13491}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_call_encode()
Definition at line 13253 of file midas.cxx.
13254{
13256
13264 }
13265 }
13266
13268
13273
13277
13280 else
13281 arg_type = tid;
13282
13283 /* floats are passed as doubles, at least under NT */
13286
13287 //printf("arg %d, tid %d, flags 0x%x, arg_type %d, bpointer %d\n", i, tid, flags, arg_type, bpointer);
13288
13290 }
13291
13294 assert(buf);
13295
13296 (*nc) = (NET_COMMAND*) buf;
13297
13298 /* find out if we are on a big endian system */
13300
13302
13307
13311
13314 else
13315 arg_type = tid;
13316
13317 /* floats are passed as doubles, at least under NT */
13320
13321 /* get pointer to argument */
13322 //char arg[8];
13323 //rpc_va_arg(&ap, arg_type, arg);
13324
13326
13327 /* shift 1- and 2-byte parameters to the LSB on big endian systems */
13330 arg[0] = arg[3];
13331 }
13333 arg[0] = arg[2];
13334 arg[1] = arg[3];
13335 }
13336 }
13337
13340
13343 else
13345
13346 /* for strings, the argument size depends on the string length */
13349 }
13350
13351 /* for varibale length arrays, the size is given by
13352 the next parameter on the stack */
13354 //va_list aptmp;
13356 //va_copy(aptmp, ap);
13357
13358 //char arg_tmp[8];
13359 //rpc_va_arg(&aptmp, TID_ARRAY, arg_tmp);
13360
13362
13363 /* for (RPC_IN+RPC_OUT) parameters, size argument is a pointer */
13366 else
13368
13371
13372 //va_end(aptmp);
13373 }
13374
13377
13378 /* always align parameter size */
13380
13381 {
13383
13386 //printf("resize nc %zu to %zu\n", buf_size, new_size);
13388 assert(buf);
13389 buf_size = new_size;
13390 (*nc) = (NET_COMMAND*) buf;
13392 }
13393 }
13394
13397 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);
13398 }
13402 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);
13403 }
13404 /* floats are passed as doubles on most systems */
13406 } else {
13408 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);
13409 }
13411 }
13412
13413 param_ptr += param_size;
13414 }
13415 }
13416
13418
13420 printf("encode rpc_id %d \"%s\" buf_size %d, param_size %d\n", rl.id, rl.name, (int)buf_size, (*nc)->header.param_size);
13421}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_check_allowed_host()
Definition at line 15286 of file midas.cxx.
15297{
15298 //printf("rpc_check_allowed_host: enabled %d, hostname [%s]\n", gAllowedHostsEnabled.load(), hostname);
15299
15302
15305
15308
15311
15314
15316
15317 gAllowedHostsMutex.lock();
15318
15320 if (h == hostname) {
15322 break;
15323 }
15324 }
15325
15326 gAllowedHostsMutex.unlock();
15327
15328 //if (status != RPC_SUCCESS)
15329 // printf("rpc_check_allowed_host: enabled %d, hostname [%s] not found\n", gAllowedHostsEnabled.load(), hostname);
15330
15332}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_check_channels()
Definition at line 16276 of file midas.cxx.
16294{
16296 NET_COMMAND nc;
16299
16304 continue;
16305
16307 continue;
16308 }
16309
16311 //printf("rpc_check_channels: idx %d, watchdog_timeout %d, last_activity %d, elapsed %d\n", idx, sa->watchdog_timeout, sa->last_activity, elapsed);
16312
16314
16315 //printf("rpc_check_channels: send watchdog message to %s on %s\n", sa->prog_name.c_str(), sa->host_name.c_str());
16316
16317 /* send a watchdog message */
16320
16322 if (convert_flags) {
16325 }
16326
16327 /* send the header to the client */
16329
16331 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, send_tcp() returned %d",
16332 sa->prog_name.c_str(),
16333 sa->host_name.c_str(),
16334 sa->watchdog_timeout / 1000,
16335 i);
16336
16337 /* disconnect from experiment */
16339 cm_disconnect_experiment();
16341 }
16342
16343 sa->close();
16345 }
16346
16347 /* make some timeout checking */
16351
16352 timeout.tv_sec = sa->watchdog_timeout / 1000;
16353 timeout.tv_usec = (sa->watchdog_timeout % 1000) * 1000;
16354
16355 do {
16357
16358 /* if an alarm signal was cought, restart select with reduced timeout */
16360 timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
16361
16363
16366
16367 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec",
16368 sa->prog_name.c_str(),
16369 sa->host_name.c_str(),
16370 sa->watchdog_timeout / 1000);
16371
16372 /* disconnect from experiment */
16374 cm_disconnect_experiment();
16376 }
16377
16378 sa->close();
16380 }
16381
16382 /* receive result on send socket */
16386 cm_msg(MINFO, "rpc_check_channels", "client \"%s\" on host \"%s\" failed watchdog test after %d sec, recv_tcp() returned %d",
16387 sa->prog_name.c_str(),
16388 sa->host_name.c_str(),
16389 sa->watchdog_timeout / 1000,
16390 i);
16391
16392 /* disconnect from experiment */
16394 cm_disconnect_experiment();
16396 }
16397
16398 sa->close();
16400 }
16401 }
16402 }
16403 }
16404 }
16405
16407}
INT recv_tcp(int sock, char *net_buffer, DWORD buffer_size, INT flags)
Definition system.cxx:5526
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_clear_allowed_hosts()
Definition at line 15232 of file midas.cxx.
15248{
15249 gAllowedHostsMutex.lock();
15250 gAllowedHosts.clear();
15252 gAllowedHostsMutex.unlock();
15254}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_accept()
Definition at line 15620 of file midas.cxx.
15641{
15644 std::string client_program;
15645 std::string host_name;
15646 INT convert_flags;
15647 char net_buffer[256], *p;
15648
15650
15651 if (sock == -1)
15653
15654 /* check access control list */
15657
15659 ss_socket_close(&sock);
15661 }
15662 }
15663
15666
15667 /* receive string with timeout */
15670 ss_socket_close(&sock);
15672 }
15673
15674 /* get remote computer info */
15679 }
15681 //version = atoi(p);
15683 }
15685 client_program = p;
15687 }
15689 host_name = p;
15691 }
15692
15693 //printf("rpc_client_accept: client_hw_type %d, version %d, client_name \'%s\', hostname \'%s\'\n", client_hw_type, version, client_program, host_name);
15694
15696
15697 /* save information in _server_acception structure */
15698 sa->recv_sock = sock;
15699 sa->send_sock = 0;
15700 sa->event_sock = 0;
15705 sa->watchdog_timeout = 0;
15707
15708 /* send my own computer id */
15714
15716 sa->convert_flags = convert_flags;
15717
15719
15721}
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:11605
static RPC_SERVER_ACCEPTION * rpc_new_server_acception()
Definition midas.cxx:11540
static INT rpc_socket_check_allowed_host(int sock)
Definition midas.cxx:15335
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_call()
Definition at line 13494 of file midas.cxx.
13519{
13521
13525 }
13526
13527 //printf("rpc_client_call: handle %d, connection: ", hConn);
13528 //c->print();
13529 //printf("\n");
13530
13532
13534 routine_id &= ~RPC_NO_REPLY;
13535
13536 //if (rpc_no_reply)
13537 // printf("rpc_client_call: routine_id %d, RPC_NO_REPLY\n", routine_id);
13538
13539 // make local copy of the client name just in case _client_connection is erased by another thread
13540
13541 /* find rpc_index */
13542
13546
13547 rpc_list_mutex.lock();
13553 break;
13554 }
13555 }
13556 rpc_list_mutex.unlock();
13557
13559 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);
13560 c->mutex.unlock();
13562 }
13563
13565
13566 /* examine variable argument list and convert it to parameter array */
13568 va_start(ap, routine_id);
13569
13571
13572 va_end(ap);
13573
13575
13578
13580
13581 /* in FAST TCP mode, only send call and return immediately */
13584
13586 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);
13587 free(nc);
13588 c->mutex.unlock();
13590 }
13591
13592 free(nc);
13593
13595 //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);
13596 //c->print();
13597 //printf("\n");
13598 c->close_locked();
13599 }
13600
13601 c->mutex.unlock();
13603 }
13604
13605 /* in TCP mode, send and wait for reply on send socket */
13608 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);
13609 c->mutex.unlock();
13611 }
13612
13613 free(nc);
13614 nc = NULL;
13615
13618 DWORD watchdog_timeout;
13620
13621 //printf("watchdog timeout: %d, rpc_timeout: %d\n", watchdog_timeout, c->rpc_timeout);
13622
13626 }
13627
13629 DWORD buf_size = 0;
13631
13632 /* receive result on send socket */
13634
13637 }
13638
13640 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);
13641 if (buf)
13642 free(buf);
13643 c->mutex.unlock();
13645 }
13646
13648 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);
13649 if (buf)
13650 free(buf);
13651 c->mutex.unlock();
13653 }
13654
13655 c->mutex.unlock();
13656
13658 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);
13659 if (buf)
13660 free(buf);
13662 }
13663
13664 /* extract result variables and place it to argument list */
13665
13666 va_start(ap, routine_id);
13667
13669
13672 }
13673
13674 va_end(ap);
13675
13676 if (buf)
13677 free(buf);
13678 buf = NULL;
13679 buf_size = 0;
13680
13682}
Definition midas.cxx:11454
INT cm_set_watchdog_params(BOOL call_watchdog, DWORD timeout)
Definition midas.cxx:3297
static RPC_CLIENT_CONNECTION * rpc_get_locked_client_connection(HNDLE hConn)
Definition midas.cxx:12634
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_check()
Definition at line 12292 of file midas.cxx.
12300{
12301#if 0
12304 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);
12305#endif
12306
12308
12309 /* check for broken connections */
12314
12316 // implicit unlock
12317 continue;
12318 }
12319
12320 //printf("rpc_client_check: connection %d: ", i);
12321 //c->print();
12322 //printf("\n");
12323
12325
12329
12331 timeout.tv_sec = 0;
12332 timeout.tv_usec = 0;
12333
12335
12336#ifdef OS_WINNT
12338#else
12339 do {
12342#endif
12343
12345 // implicit unlock
12346 continue;
12347 }
12348
12349 char buffer[64];
12350
12352 //printf("recv %d status %d, errno %d (%s)\n", sock, status, errno, strerror(errno));
12353
12355#ifndef OS_WINNT
12357 ok = 1;
12358 } else
12359#endif
12360 {
12361 // connection error
12363 "RPC client connection to \"%s\" on host \"%s\" is broken, recv() errno %d (%s)",
12364 c->client_name.c_str(),
12365 c->host_name.c_str(),
12367 ok = 0;
12368 }
12370 // connection closed by remote end without sending an EXIT message
12371 // this can happen if the remote end has crashed, so this message
12372 // is still necessary as a useful diagnostic for unexpected crashes
12373 // of midas programs. K.O.
12374 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());
12375 ok = 0;
12376 } else {
12377 // read some data
12378 ok = 1;
12380 /* normal exit */
12381 ok = 0;
12382 }
12383 }
12384
12386 //printf("rpc_client_check: closing connection %d: ", i);
12387 //c->print();
12388 //printf("\n");
12389
12390 // connection lost, close the socket
12391 c->close_locked();
12392 }
12393
12394 // implicit unlock
12395 }
12396 }
12397
12398 // implicit unlock of _client_connections_mutex
12399}
static std::vector< RPC_CLIENT_CONNECTION * > _client_connections
Definition midas.cxx:11518
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 12034 of file midas.cxx.
12057{
12060
12061 /* check if cm_connect_experiment was called */
12065 }
12066
12067 /* refuse connection to port 0 */
12068 if (port == 0) {
12071 }
12072
12074
12076
12077 {
12079
12081 printf("rpc_client_connect: host \"%s\", port %d, client \"%s\"\n", host_name, port, client_name);
12087 }
12088 }
12089 }
12090
12091 // slot with index 0 is not used, fill it with a NULL
12092
12095 }
12096
12098
12099 /* check if connection already exists */
12103
12105 gHostnameMutex.lock();
12107 }
12108
12110 // NB: we must release the hostname lock before taking
12111 // c->mutex to avoid a locking order inversion deadlock:
12112 // later on we lock the hostname mutex while holding the c->mutex
12113 gHostnameMutex.unlock();
12116 // check if socket is still connected
12118 // found connection slot with matching hostname and port number
12121 // so reuse it connection
12125 c->print();
12127 }
12128 // implicit unlock of c->mutex
12129 // gHostnameLock is not locked here
12131 }
12132 //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);
12133 c->close_locked();
12134 }
12135 // implicit unlock of c->mutex
12136 }
12137 }
12138 }
12139
12141 gHostnameMutex.unlock();
12143 }
12144
12145 // only start reusing connections once we have
12146 // a good number of slots allocated.
12149
12157 c->print();
12159 }
12161 break;
12162 }
12163 }
12164 }
12165
12166 // no slots to reuse, allocate a new slot.
12169
12170 // if empty slot not found, add to end of array
12173
12176 c->print();
12178 }
12179 }
12180
12181 c->mutex.lock();
12183
12184 // done with the array of connections
12185 // implicit unlock of _client_connections_mutex
12186 }
12187
12188 // locked connection slot for new connection
12190
12191 std::string errmsg;
12192
12193 /* create a new socket for connecting to remote server */
12196 cm_msg(MERROR, "rpc_client_connect", "cannot connect to \"%s\" port %d: %s", host_name, port, errmsg.c_str());
12197 c->mutex.unlock();
12199 }
12200
12201 gHostnameMutex.lock();
12202
12204 c->port = port;
12205
12206 gHostnameMutex.unlock();
12207
12208 c->client_name = client_name;
12210
12211 /* set TCP_NODELAY option for better performance */
12212 i = 1;
12214
12215 /* send local computer info */
12218
12220
12221 std::string cstr = msprintf("%d %s %s %s", hw_type, cm_get_version(), local_prog_name.c_str(), local_host_name.c_str());
12222
12226 cm_msg(MERROR, "rpc_client_connect", "cannot send %d bytes, send() returned %d, errno %d (%s)", size, i, errno, strerror(errno));
12227 c->mutex.unlock();
12229 }
12230
12233 DWORD watchdog_timeout;
12235
12236 //printf("watchdog timeout: %d, rpc_connect_timeout: %d\n", watchdog_timeout, _rpc_connect_timeout);
12237
12241 }
12242
12244
12245 /* receive remote computer info */
12247
12250 }
12251
12254 c->close_locked();
12255 c->mutex.unlock();
12257 }
12258
12259 int remote_hw_type = 0;
12261 remote_version[0] = 0;
12263
12264 c->remote_hw_type = remote_hw_type;
12265
12266 /* print warning if version patch level doesn't agree */
12272
12277
12279 cm_msg(MERROR, "rpc_client_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", remote_version, cm_get_version());
12280 }
12281
12283
12285
12286 c->mutex.unlock();
12287
12289}
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 12698 of file midas.cxx.
12716{
12717 /* notify server about exit */
12718
12719 /* call exit and shutdown with RPC_NO_REPLY because client will exit immediately without possibility of replying */
12720
12721 rpc_client_call(hConn, bShutdown ? (RPC_ID_SHUTDOWN | RPC_NO_REPLY) : (RPC_ID_EXIT | RPC_NO_REPLY));
12722
12724}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_client_dispatch()
Definition at line 11967 of file midas.cxx.
11975{
11977 char net_buffer[256];
11978
11982
11984
11995
11996 //printf("rpc_client_dispatch: received MSG_BM!\n");
11997
11998 /* receive further messages to empty TCP queue */
11999 do {
12002
12003 timeout.tv_sec = 0;
12004 timeout.tv_usec = 0;
12005
12007
12012
12020 }
12021 }
12022
12024
12025 /* poll event from server */
12027 }
12028
12030}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_data()
Definition at line 11728 of file midas.cxx.
11756{
11757 /* convert array */
11760 /* don't convert TID_ARRAY & TID_STRUCT */
11762 return;
11763
11765
11768 rpc_convert_single(p, tid, flags, convert_flags);
11769 }
11770 } else {
11772 }
11773}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_convert_single()
Definition at line 11703 of file midas.cxx.
11703 {
11704
11707 if (tid == TID_UINT32 || tid == TID_INT32 || tid == TID_BOOL || tid == TID_FLOAT) DWORD_SWAP(data);
11709 }
11710
11717 }
11718
11725 }
11726}
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 11892 of file midas.cxx.
11909{
11910 rpc_list_mutex.lock();
11911 rpc_list.clear();
11912 rpc_list_mutex.unlock();
11913
11915}
Here is the caller graph for this function:
◆ rpc_execute()
Definition at line 14672 of file midas.cxx.
14699{
14702 INT tid, flags;
14709#ifdef FIXED_BUFFER
14711#else
14713#endif
14714
14715 /* return buffer must must use thread local storage multi-thread servers */
14721 tls_size = 1;
14722 }
14725 break;
14727 /* new thread -> allocate new buffer */
14732 tls_size++;
14733 }
14734
14738 assert(return_buffer);
14739
14740 // make valgrind happy - the RPC parameter encoder skips the alignement padding bytes
14741 // and valgrind complains that we transmit uninitialized data
14742 //memset(return_buffer, 0, return_buffer_size);
14743
14744 /* extract pointer array to parameters */
14746
14747 /* convert header format (byte swapping) */
14748 if (convert_flags) {
14751 }
14752
14753 //if (nc_in->header.routine_id & RPC_NO_REPLY) {
14754 // printf("rpc_execute: routine_id %d, RPC_NO_REPLY\n", (int)(nc_in->header.routine_id & ~RPC_NO_REPLY));
14755 //}
14756
14757 /* no result return as requested */
14759 sock = 0;
14760
14761 /* find entry in rpc_list */
14763
14766
14767 rpc_list_mutex.lock();
14768
14773 break;
14774 }
14775 }
14776
14777 rpc_list_mutex.unlock();
14778
14782 }
14783
14784 again:
14785
14787
14790
14792
14796
14799
14802
14804 /* for arrays, the size is stored as a INT in front of the array */
14806 if (convert_flags)
14808 param_size = ALIGN8(param_size);
14809
14811 }
14812
14815
14817
14818 /* convert data format */
14819 if (convert_flags) {
14822 else
14824 convert_flags);
14825 }
14826
14829 /* check for long strings (db_create_record...) */
14834 } else
14836 } else
14838
14839 in_param_ptr += param_size;
14840 }
14841
14844
14846
14847 /* save maximum array length from the value of the next argument.
14848 * this means RPC_OUT arrays and strings should always be passed like this:
14849 * rpc_call(..., array_ptr, array_max_size, ...); */
14850
14852
14853 if (convert_flags)
14856
14858
14859 /* save space for return array length */
14861
14862 /* use maximum array length from input */
14863 param_size = max_size;
14864 }
14865
14868
14870#ifdef FIXED_BUFFER
14872 "return parameters (%d) too large for network buffer (%d)",
14874
14876#else
14879
14880#if 0
14882 "rpc_execute: return parameters (%d) too large for network buffer (%d), new buffer size (%d)",
14883 (int)((POINTER_T) out_param_ptr - (POINTER_T) nc_out + param_size), return_buffer_size, new_size);
14884#endif
14885
14887
14890
14894 }
14895
14898 assert(return_buffer);
14899
14901#endif
14902 }
14903
14904 /* if parameter goes both directions, copy input to output */
14907
14910
14912 out_param_ptr += param_size;
14913 }
14914
14917 }
14918
14919 //printf("predicted return size %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out);
14920
14923
14925
14926 /*********************************\
14927 * call dispatch function *
14928 \*********************************/
14931 else
14933
14934 if (routine_id == RPC_ID_EXIT || routine_id == RPC_ID_SHUTDOWN || routine_id == RPC_ID_WATCHDOG)
14936
14937 /* return immediately for closed down client connections */
14940
14943
14944 /* Return if TCP connection broken */
14947
14948 /* if sock == 0, we are in FTCP mode and may not sent results */
14949 if (!sock)
14951
14952 /* compress variable length arrays */
14959
14962 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
14963 // and prpc_param() is now pointing to the wrong place. here we know our string data
14964 // starts right after max_size and we do not need to use prpc_param[] to find it. K.O.
14965 //const char* param_ptr = (char *) prpc_param[i];
14967 //printf("string param [%s] max_size %d\n", param_ptr, max_size);
14969 param_size = ALIGN8(param_size);
14970
14971 /* move string ALIGN8(sizeof(INT)) left */
14973
14974 /* move remaining parameters to end of string */
14978 }
14979
14981 /* store array length at current out_param_ptr */
14983 // note: RPC_OUT parameters may have been shifted in the output buffer by memmove()
14984 // and prpc_param() is now pointing to the wrong place. instead, compute location
14985 // of next parameter using max_size. K.O.
14986 // note: RPC_IN parameters are in the input buffer and we must use the prpc_param[] pointer. K.O.
14989 else
14992 if (convert_flags)
14994
14996
14997 param_size = ALIGN8(param_size);
14998
14999 /* move remaining parameters to end of array */
15003 }
15004
15007
15008 /* convert data format */
15009 if (convert_flags) {
15013 else
15017 }
15018
15019 out_param_ptr += param_size;
15020 }
15021
15022 /* send return parameters */
15025 nc_out->header.param_size = param_size;
15026
15027 //printf("actual return size %d, buffer used %d\n", (POINTER_T) out_param_ptr - (POINTER_T) nc_out, sizeof(NET_COMMAND_HEADER) + param_size);
15028
15029 /* convert header format (byte swapping) if necessary */
15030 if (convert_flags) {
15033 }
15034
15035 // valgrind complains about sending uninitialized data, if you care about this, uncomment
15036 // the memset(return_buffer,0) call above (search for "valgrind"). K.O.
15037
15039
15043 }
15044
15045 /* print return buffer */
15046/*
15047 printf("Return buffer, ID %d:\n", routine_id);
15048 for (i=0; i<param_size ; i++)
15049 {
15050 status = (char) nc_out->param[i];
15051 printf("%02X ", status);
15052 if (i%8 == 7)
15053 printf("\n");
15054 }
15055*/
15056 /* return SS_EXIT if RPC_EXIT is called */
15059
15060 /* return SS_SHUTDOWN if RPC_SHUTDOWN is called */
15063
15065}
INT db_sprintf(char *string, const void *data, INT data_size, INT idx, DWORD type)
Definition odb.cxx:10849
void rpc_convert_data(void *data, INT tid, INT flags, INT total_size, INT convert_flags)
Definition midas.cxx:11728
Definition midas.cxx:14662
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 16158 of file midas.cxx.
16172{
16174
16175 //printf("ss_event_socket_has_data() returned %d\n", has_data);
16176
16182 } else {
16187 }
16188 }
16189
16191
16192 //printf("rpc_server_receive_event() status %d\n", status);
16193
16196 }
16197
16200
16202}
INT rpc_server_receive_event(int idx, RPC_SERVER_ACCEPTION *sa, int timeout_msec)
Definition midas.cxx:16003
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 12856 of file midas.cxx.
12867{
12868 {
12869 {
12872 unsigned char *p;
12873 float f;
12875
12876 tmp_type = 0;
12877
12878 /* test pointer size */
12879 size = sizeof(p);
12880 if (size == 2)
12882 if (size == 4)
12884 if (size == 8)
12886
12887 /* test if little or big endian machine */
12888 dummy = 0x12345678;
12890 if (*p == 0x78)
12892 else if (*p == 0x12)
12894 else
12896
12897 /* floating point format */
12898 f = (float) 1.2345;
12899 dummy = 0;
12903 && ((dummy >> 24) & 0xFF) == 0x3F)
12907 && ((dummy >> 24) & 0xFF) == 0x04)
12909 else
12911
12913 dummy = 0;
12917 && ((dummy >> 24) & 0xFF) == 0x12)
12921 && ((dummy >> 24) & 0xFF) == 0x3F)
12925 && ((dummy >> 24) & 0xFF) == 0xC0)
12929 && ((dummy >> 24) & 0xFF) == 0x04)
12931 "MIDAS cannot handle VAX D FLOAT format. Please compile with the /g_float flag");
12932 else
12934
12936 }
12937 }
12938}
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 12634 of file midas.cxx.
12635{
12636 _client_connections_mutex.lock();
12640 _client_connections_mutex.unlock();
12643 // disconnected while we were waiting for the lock
12644 c->mutex.unlock();
12646 }
12648 }
12649 }
12650 _client_connections_mutex.unlock();
12652}
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 12995 of file midas.cxx.
12996{
13001 } else {
13005 c->mutex.unlock();
13006 return timeout;
13007 }
13008 }
13009 return 0;
13010}
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 11540 of file midas.cxx.
11541{
11544 //printf("rpc_new_server_acception: reuse acception in slot %d\n", idx);
11546 }
11547 }
11548
11550
11553 //printf("rpc_new_server_acception: new acception, reuse slot %d\n", idx);
11556 }
11557 }
11558
11559 //printf("rpc_new_server_acception: new acception, array size %d, push_back\n", (int)_server_acceptions.size());
11560 _server_acceptions.push_back(sa);
11561
11562 return sa;
11563}
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 11830 of file midas.cxx.
11830 {
11834
11836}
INT rpc_register_functions(const RPC_LIST *new_list, RPC_HANDLER func)
Definition midas.cxx:11849
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 11849 of file midas.cxx.
11850{
11852 /* check valid ID for user functions */
11856 cm_msg(MERROR, "rpc_register_functions", "registered RPC function with invalid ID %d", new_list[i].id);
11857 }
11858 }
11859
11861
11862 /* check double defined functions */
11867 }
11868 }
11869 }
11870
11871 /* append new functions */
11874
11875 /* set default dispatcher */
11878 }
11879
11881 }
11882
11884}
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 14601 of file midas.cxx.
14624{
14625 /* register system functions: RPC_ID_EXIT, RPC_ID_SHUTDOWN, RPC_ID_WATCHDOG */
14627
14628 /* create a socket for listening */
14631 std::string errmsg;
14632
14633 int status = ss_socket_listen_tcp(!disable_bind_rpc_to_localhost, port, &lsock, &lport, &errmsg);
14634
14636 cm_msg(MERROR, "rpc_register_server", "cannot listen to tcp port %d: %s", port, errmsg.c_str());
14638 }
14639
14640 /* set close-on-exec flag to prevent child mserver processes from inheriting the listen socket */
14641#if defined(F_SETFD) && defined(FD_CLOEXEC)
14644 cm_msg(MERROR, "rpc_register_server", "fcntl(F_SETFD, FD_CLOEXEC) failed, errno %d (%s)", errno, strerror(errno));
14646 }
14647#endif
14648
14649 /* return port wich OS has choosen */
14652 }
14653
14656
14657 //printf("rpc_register_server: requested port %d, actual port %d, socket %d\n", port, *pport, *plsock);
14658
14660}
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()
Definition at line 14560 of file midas.cxx.
14582{
14585
14589
14593
14596
14598}
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:14601
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 13923 of file midas.cxx.
13924{
13927 } else {
13929 }
13930}
INT bm_send_event(INT buffer_handle, const EVENT_HEADER *pevent, int unused, int timeout_msec)
Definition midas.cxx:9700
INT rpc_send_event1(INT buffer_handle, const EVENT_HEADER *pevent)
Definition midas.cxx:13941
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 13941 of file midas.cxx.
13942{
13945}
INT rpc_send_event_sg(INT buffer_handle, int sg_n, const char *const sg_ptr[], const size_t sg_len[])
Definition midas.cxx:13947
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 13947 of file midas.cxx.
13948{
13952 }
13953
13957 }
13958
13960 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));
13962 }
13963
13965
13966 const DWORD MAX_DATA_SIZE = (0x7FFFFFF0 - 16); // event size computations are not 32-bit clean, limit event size to 2GB. K.O.
13968
13969 if (data_size == 0) {
13972 }
13973
13975 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);
13977 }
13978
13981
13985 }
13986
13988 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);
13990 }
13991
13992 // protect non-atomic access to _server_connection.event_sock. K.O.
13993
13995
13996 //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);
13997
14000 }
14001
14002 //
14003 // event socket wire protocol: (see also rpc_server_receive_event() and recv_event_server_realloc())
14004 //
14005 // 4 bytes of buffer handle
14006 // 16 bytes of event header, includes data_size
14007 // ALIGN8(data_size) bytes of event data
14008 //
14009
14011
14012 /* send buffer handle */
14013
14016
14020 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(buffer handle) failed, event socket is now closed");
14022 }
14023
14024 /* send data */
14025
14030 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(event data) failed, event socket is now closed");
14032 }
14033 }
14034
14035 /* send padding */
14036
14040 assert(padlen < 8);
14044 cm_msg(MERROR, "rpc_send_event_sg", "ss_write_tcp(padding) failed, event socket is now closed");
14046 }
14047 }
14048
14050}
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()
Definition at line 15363 of file midas.cxx.
15384{
15386 INT sock;
15390 char *ptr;
15391 char net_buffer[256];
15393
15395
15398
15399 if (sock == -1)
15401 } else {
15402 /* lsock is stdin -> already connected from inetd */
15403
15404 sock = lsock;
15405 }
15406
15407 /* check access control list */
15410
15412 ss_socket_close(&sock);
15414 }
15415 }
15416
15417 /* receive string with timeout */
15420
15423
15424 //printf("rpc_server_accept: command [%c]\n", command);
15425
15426 switch (command) {
15427 case 'S': {
15428
15429 /*----------- shutdown listener ----------------------*/
15430 ss_socket_close(&sock);
15432 }
15433 case 'I': {
15434
15435 /*----------- return available experiments -----------*/
15436#ifdef LOCAL_ROUTINES
15437 exptab_struct exptab;
15443 }
15445#endif
15446 ss_socket_close(&sock);
15447 break;
15448 }
15449 case 'C': {
15450
15451 /*----------- connect to experiment -----------*/
15452
15453 /* get callback information */
15456
15457 //printf("rpc_server_accept: net buffer \'%s\'\n", net_buffer);
15458
15459 /* parse string in format "C port1 port2 port3 version expt" */
15460 /* example: C 51046 45838 56832 2.0.0 alpha */
15461
15465
15466 while (*ptr == ' ')
15467 ptr++;
15468
15469 i = 0;
15471 version[i++] = *ptr++;
15472
15473 // ensure that we do not overwrite buffer "version"
15475 version[i] = 0;
15476
15477 // skip wjatever is left from the "version" string
15478 for (; *ptr != 0 && *ptr != ' ';)
15479 ptr++;
15480
15481 while (*ptr == ' ')
15482 ptr++;
15483
15484 i = 0;
15485 for (; *ptr != 0 && *ptr != ' ' && *ptr != '\n' && *ptr != '\r' && i < (int) sizeof(experiment) - 1;)
15487
15488 // ensure that we do not overwrite buffer "experiment"
15491
15493
15494 /* print warning if version patch level doesn't agree */
15499
15505
15507 cm_msg(MERROR, "rpc_server_accept", "client MIDAS version %s differs from local version %s", version, cm_get_version());
15509 }
15510
15515
15517
15519 ss_socket_close(&sock);
15520 break;
15521 }
15522
15523#ifdef LOCAL_ROUTINES
15524 /* update experiment definition */
15525 exptab_struct exptab;
15527
15530 /* lookup experiment */
15533 idx = 0;
15534 } else {
15539 break;
15540 }
15541 }
15542 }
15543 }
15544
15546 cm_msg(MERROR, "rpc_server_accept", "experiment \'%s\' not defined in exptab file \'%s\'", callback.experiment.c_str(), exptab.filename.c_str());
15547
15549 ss_socket_close(&sock);
15550 break;
15551 }
15552
15555
15556 /* create a new process */
15559
15564
15566
15578
15581 argv[9]);
15582
15584
15587
15590 ss_socket_close(&sock);
15591 break;
15592 }
15593
15596#endif // LOCAL_ROUTINES
15597 ss_socket_close(&sock);
15598
15599 break;
15600 }
15601 default: {
15602 cm_msg(MERROR, "rpc_server_accept", "received unknown command '%c' code %d", command, command);
15603 ss_socket_close(&sock);
15604 break;
15605 }
15606 }
15607 } else { /* if i>0 */
15608
15609 /* lingering needed for PCTCP */
15610 ling.l_onoff = 1;
15611 ling.l_linger = 0;
15613 ss_socket_close(&sock);
15614 }
15615
15617}
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:1614
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 15724 of file midas.cxx.
15743{
15745 int recv_sock, send_sock, event_sock;
15747 std::string client_program;
15749 INT convert_flags;
15750 char net_buffer[256];
15751 char *p;
15753
15754 /* copy callback information */
15756 //idx = callback.index;
15757
15758 std::string errmsg;
15759
15760 /* create new sockets for TCP */
15761 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port1, &recv_sock, &errmsg);
15762
15764 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());
15765 ss_socket_close(&recv_sock);
15766 //ss_socket_close(&send_sock);
15767 //ss_socket_close(&event_sock);
15769 }
15770
15771 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port2, &send_sock, &errmsg);
15772
15774 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());
15775 ss_socket_close(&recv_sock);
15776 ss_socket_close(&send_sock);
15777 //ss_socket_close(&event_sock);
15779 }
15780
15781 status = ss_socket_connect_tcp(callback.host_name.c_str(), callback.host_port3, &event_sock, &errmsg);
15782
15784 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());
15785 ss_socket_close(&recv_sock);
15786 ss_socket_close(&send_sock);
15787 ss_socket_close(&event_sock);
15789 }
15790#ifndef OS_ULTRIX /* crashes ULTRIX... */
15791 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
15792 flag = 2 * 1024 * 1024;
15795 cm_msg(MERROR, "rpc_server_callback", "cannot setsockopt(SOL_SOCKET, SO_RCVBUF), errno %d (%s)", errno,
15797#endif
15798
15801 ss_socket_close(&recv_sock);
15802 ss_socket_close(&send_sock);
15803 ss_socket_close(&event_sock);
15805 }
15806 //printf("rpc_server_callback: \'%s\'\n", net_buffer);
15807
15808 /* get remote computer info */
15810
15811 while (*p == ' ')
15812 p++;
15813
15814 client_program = p;
15815
15816 //printf("hw type %d, name \'%s\'\n", client_hw_type, client_program);
15817
15818 std::string host_name;
15819
15821
15824
15825 //printf("rpc_server_callback: mserver acception\n");
15826
15828
15829 /* save information in _server_acception structure */
15830 sa->recv_sock = recv_sock;
15831 sa->send_sock = send_sock;
15832 sa->event_sock = event_sock;
15837 sa->watchdog_timeout = 0;
15839
15841
15842 _mserver_acception = sa;
15843
15844 //printf("rpc_server_callback: _mserver_acception %p\n", _mserver_acception);
15845
15846 /* send my own computer id */
15850
15852 sa->convert_flags = convert_flags;
15853
15855
15857 rpc_debug_printf("Connection to %s:%s established\n", sa->host_name.c_str(), sa->prog_name.c_str());
15858 }
15859
15861}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_connect()
Definition at line 12403 of file midas.cxx.
12431{
12438 char *s;
12439
12440#ifdef OS_WINNT
12441 {
12443
12444 /* Start windows sockets */
12447 }
12448#endif
12449
12450 /* check if local connection */
12453
12454 /* register system functions */
12456
12457 /* check if cm_connect_experiment was called */
12461 }
12462
12463 /* check if connection already exists */
12466
12470
12472
12475
12479
12480 std::string errmsg;
12481
12483
12487 }
12488
12490
12494 }
12495
12497
12501 }
12502
12503 /* extract port number from host_name */
12506 if (s) {
12507 *s = 0;
12509 }
12510
12511 int sock;
12512
12514
12516 cm_msg(MERROR, "rpc_server_connect", "cannot connect to mserver on host \"%s\" port %d: %s", str, port, errmsg.c_str());
12518 }
12519
12520 /* connect to experiment */
12523 else
12525
12528 ss_socket_close(&sock);
12532 }
12533
12534 status = version[0] = 0;
12536
12538/* message "undefined experiment" should be displayed by application */
12540 }
12541
12542 /* print warning if version patch level doesn't agree */
12543 strcpy(v1, version);
12547
12552
12554 cm_msg(MERROR, "rpc_server_connect", "remote MIDAS version \'%s\' differs from local version \'%s\'", version,
12555 cm_get_version());
12556 }
12557
12558 /* wait for callback on send and recv socket with timeout */
12563
12564 timeout.tv_sec = _rpc_connect_timeout / 1000;
12565 timeout.tv_usec = 0;
12566
12567 do {
12569
12570 /* if an alarm signal was cought, restart select with reduced timeout */
12572 timeout.tv_sec -= WATCHDOG_INTERVAL / 1000;
12573
12575
12582 }
12583
12587
12588 if (_server_connection.send_sock == -1 || _server_connection.recv_sock == -1 || _server_connection.event_sock == -1) {
12591 }
12592
12596
12597 /* set TCP_NODELAY option for better performance */
12599 setsockopt(_server_connection.send_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12600 setsockopt(_server_connection.event_sock, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
12601
12602 /* increase send buffer size to 2 Mbytes, on Linux also limited by sysctl net.ipv4.tcp_rmem and net.ipv4.tcp_wmem */
12603 flag = 2 * 1024 * 1024;
12604 status = setsockopt(_server_connection.event_sock, SOL_SOCKET, SO_SNDBUF, (char *) &flag, sizeof(flag));
12606 cm_msg(MERROR, "rpc_server_connect", "cannot setsockopt(SOL_SOCKET, SO_SNDBUF), errno %d (%s)", errno, strerror(errno));
12607
12608 /* send local computer info */
12612
12614
12615 /* receive remote computer info */
12620 }
12621
12624
12626
12628
12630}
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()
Definition at line 12727 of file midas.cxx.
12747{
12749
12752
12753 rpc_server_disconnect_recursion_level = 1;
12754
12755 /* flush remaining events */
12756 rpc_flush_event();
12757
12758 /* notify server about exit */
12761 }
12762
12763 /* close sockets */
12770
12772
12773 /* remove semaphore */
12777
12778 rpc_server_disconnect_recursion_level = 0;
12780}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_loop()
Definition at line 15865 of file midas.cxx.
15873{
15874 while (1) {
15876
15878 break;
15879
15881 break;
15882
15883 /* check alarms, etc */
15885
15886 cm_msg_flush_buffer();
15887 }
15888
15890}
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 16003 of file midas.cxx.
16017{
16019
16021
16022 //
16023 // THIS IS NOT THREAD SAFE!!!
16024 //
16025 // IT IS ONLY USED BY THE MSERVER
16026 // MSERVER IS SINGLE-THREADED!!!
16027 //
16028
16032
16033 // short cut
16036
16038
16041 // do not do anything if we are called recursively
16042 // via recursive ss_suspend() or otherwise. K.O.
16045 else
16047 }
16048
16050
16051 do {
16054
16057 cm_msg(MERROR, "rpc_server_receive_event", "recv_event_server_realloc() returned %d, abort", n_received);
16058 goto error;
16059 }
16060
16062 // no more data in the tcp socket
16065 }
16066
16068 }
16069
16071 // no event in xbuf buffer
16074 }
16075
16076 /* send event to buffer */
16079
16081
16082 //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);
16083
16085 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d (SS_ABORT), abort", status);
16086 goto error;
16087 }
16088
16090 //cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, event buffer is full", status);
16093 }
16094
16096 cm_msg(MERROR, "rpc_server_receive_event", "bm_send_event() error %d, mserver dropped this event", status);
16097 }
16098
16100
16101 /* repeat for maximum 0.5 sec */
16103
16106
16107 error:
16108
16109 {
16114 cm_msg(MTALK, "rpc_server_receive_event", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
16115 }
16116
16117 //exit:
16118
16119 cm_msg_flush_buffer();
16120
16121 /* disconnect from experiment as MIDAS server */
16124
16126
16127 /* only disconnect from experiment if previously connected.
16128 Necessary for pure RPC servers (RPC_SRVR) */
16130 bm_close_all_buffers();
16132 db_close_all_databases();
16133
16134 rpc_deregister_functions();
16135
16136 cm_set_experiment_database(0, 0);
16137 }
16138 }
16139
16141
16142 sa->close();
16143
16144 /* signal caller a shutdonw */
16147
16148 /* only the mserver should stop on server connection closure */
16149 if (!is_mserver) {
16151 }
16152
16154}
INT cm_get_experiment_database(HNDLE *hDB, HNDLE *hKeyClient)
Definition midas.cxx:3025
INT cm_set_experiment_database(HNDLE hDB, HNDLE hKeyClient)
Definition midas.cxx:2953
static int recv_event_server_realloc(INT idx, RPC_SERVER_ACCEPTION *psa, char **pbuffer, int *pbuffer_size)
Definition midas.cxx:14409
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 15893 of file midas.cxx.
15908{
15911
15914
15915 do {
15917
15920 cm_msg(MERROR, "rpc_server_receive_rpc", "recv_net_command() returned %d, abort", n_received);
15921 goto error;
15922 }
15923
15925
15928 goto error;
15929 }
15930
15933 rpc_debug_printf("Connection to %s:%s closed\n", sa->host_name.c_str(), sa->prog_name.c_str());
15934 goto exit;
15935 }
15936
15938
15939 if (buf) {
15940 free(buf);
15941 buf = NULL;
15942 bufsize = 0;
15943 }
15944
15946
15947 error:
15948
15949 {
15954 cm_msg(MTALK, "rpc_server_receive_rpc", "Program \'%s\' on host \'%s\' aborted", sa->prog_name.c_str(), str);
15955 }
15956
15957 exit:
15958
15959 cm_msg_flush_buffer();
15960
15961 if (buf) {
15962 free(buf);
15963 buf = NULL;
15964 bufsize = 0;
15965 }
15966
15967 /* disconnect from experiment as MIDAS server */
15970
15972
15973 /* only disconnect from experiment if previously connected.
15974 Necessary for pure RPC servers (RPC_SRVR) */
15976 bm_close_all_buffers();
15978 db_close_all_databases();
15979
15980 rpc_deregister_functions();
15981
15982 cm_set_experiment_database(0, 0);
15983 }
15984 }
15985
15987
15988 sa->close();
15989
15990 /* signal caller a shutdonw */
15993
15994 /* only the mserver should stop on server connection closure */
15995 if (!is_mserver) {
15997 }
15998
16000}
static int recv_net_command_realloc(INT idx, char **pbuf, int *pbufsize, INT *remaining)
Definition midas.cxx:14219
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_server_shutdown()
Definition at line 16205 of file midas.cxx.
16222{
16223 //printf("rpc_server_shutdown!\n");
16224
16226
16227 /* close all open connections */
16231 /* lingering needed for PCTCP */
16232 ling.l_onoff = 1;
16233 ling.l_linger = 0;
16236
16240 }
16241
16245 }
16246 }
16247 }
16248
16249 /* avoid memory leak */
16252 if (sa) {
16253 //printf("rpc_server_shutdown: %d %p %p\n", idx, sa, _mserver_acception);
16255 // do not leave behind a stale pointer!
16257 }
16258 delete sa;
16260 }
16261 }
16262
16266 }
16267
16268 /* free suspend structures */
16269 ss_suspend_exit();
16270
16272}
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 13020 of file midas.cxx.
13021{
13022 //printf("rpc_set_timeout: hConn %d, timeout_msec %d\n", hConn, timeout_msec);
13023
13032 } else {
13038 c->mutex.unlock();
13039 } else {
13041 *old_timeout_msec = 0;
13042 }
13043 }
13045}
Here is the call graph for this function:
Here is the caller graph for this function:
◆ rpc_socket_check_allowed_host()
Definition at line 15335 of file midas.cxx.
15336{
15337 std::string hostname;
15338
15340
15343
15345
15348
15351 max_report--;
15353 cm_msg(MERROR, "rpc_socket_check_allowed_host", "rejecting connection from unallowed host \'%s\', this message will no longer be reported", hostname.c_str());
15354 } else {
15355 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());
15356 }
15357 }
15358
15360}
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 15068 of file midas.cxx.
15084{
15086
15088
15091
15094
15097
15099
15101 struct_in.num_values = 222;
15103 struct_in.last_written = 333;
15104
15107
15109 struct_inout.num_values = 222222;
15111 struct_inout.last_written = 333333;
15112
15115
15118 }
15119
15121
15124 }
15125
15128
15130 123,
15131 &int_out,
15132 &int_inout,
15133 "test string",
15137 &struct_in,
15138 &struct_out,
15139 &struct_inout,
15143 );
15144
15146
15149 status = 0;
15150 }
15151
15154 status = 0;
15155 }
15156
15159 status = 0;
15160 }
15161
15164 status = 0;
15165 }
15166
15169 status = 0;
15170 }
15171
15173
15175
15176 //printf("struct_in: type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
15177
15179
15180 if (pkey->type != 444 || pkey->num_values != 555 || strcmp(pkey->name, "out_name") || pkey->last_written != 666) {
15181 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);
15182 status = 0;
15183 }
15184
15186
15187 if (pkey->type != 444444 || pkey->num_values != 555555 || strcmp(pkey->name, "inout_name") || pkey->last_written != 666666) {
15188 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);
15189 status = 0;
15190 }
15191
15192#if 0
15195 status = 0;
15196 }
15197
15200 }
15201#endif
15202
15203#if 0
15217 {0}}},
15218#endif
15219
15220#if 0
15222#endif
15223
15225}
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 14078 of file midas.cxx.
14097{
14098 /* erase error string */
14099 *(CSTRING(2)) = 0;
14100
14102 // find registered handler
14103 // NB: this code should match same code in cm_transition_call_direct()
14104 // NB: only use the first handler, this is how MIDAS always worked
14105 // NB: we could run all handlers, but we can return the status and error string of only one of them.
14106 _trans_table_mutex.lock();
14108 _trans_table_mutex.unlock();
14109
14111 _trans_table_mutex.lock();
14113 _trans_table_mutex.unlock();
14114
14117 /* execute callback if defined */
14119 } else {
14121 /* store transition in FIFO */
14127 // implicit unlock
14129 }
14130 }
14131 }
14132 // no handler for this transition
14133 cm_msg(MERROR, "rpc_transition_dispatch", "no handler for transition %d with sequence number %d", CINT(0), CINT(4));
14135 } else {
14138 }
14139}
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 13215 of file midas.cxx.
13215 {
13217 /* On the stack, the minimum parameter size is sizeof(int).
13218 To avoid problems on little endian systems, treat all
13219 smaller parameters as int's */
13226 break;
13227
13231 break;
13232
13235 break;
13236
13237 /* float variables are passed as double by the compiler */
13240 break;
13241
13244 break;
13245
13248 break;
13249 }
13250}
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 |
