Go to the source code of this file.
Functions | |
INT | rpc_server_dispatch (INT index, void *prpc_param[]) |
INT | msg_print (const char *msg) |
void | debug_print (char *msg) |
int | main (int argc, char **argv) |
INT | rpc_test (BYTE b, WORD w, INT i, float f, double d, BYTE *b1, WORD *w1, INT *i1, float *f1, double *d1) |
Variables | |
callback_addr | callback |
BOOL | use_callback_addr = TRUE |
void debug_print | ( | char * | msg | ) |
Definition at line 44 of file mserver.c.
Referenced by main().
00045 { 00046 FILE *f; 00047 char file_name[256], str[1000]; 00048 static char client_name[NAME_LENGTH] = ""; 00049 static DWORD start_time = 0; 00050 00051 if (!start_time) 00052 start_time = ss_millitime(); 00053 00054 /* print message to file */ 00055 #ifdef OS_LINUX 00056 strlcpy(file_name, "/tmp/mserver.log", sizeof(file_name)); 00057 #else 00058 getcwd(file_name, sizeof(file_name)); 00059 if (file_name[strlen(file_name) - 1] != DIR_SEPARATOR) 00060 strlcat(file_name, DIR_SEPARATOR_STR, sizeof(file_name)); 00061 strlcat(file_name, "mserver.log", sizeof(file_name)); 00062 #endif 00063 f = fopen(file_name, "a"); 00064 00065 if (!client_name[0]) 00066 cm_get_client_info(client_name); 00067 00068 sprintf(str, "%10.3lf [%d,%s,%s] ", (ss_millitime() - start_time) / 1000.0, 00069 ss_getpid(), callback.host_name, client_name); 00070 strlcat(str, msg, sizeof(str)); 00071 strlcat(str, "\n", sizeof(str)); 00072 00073 if (f != NULL) { 00074 fputs(str, f); 00075 fclose(f); 00076 } else { 00077 printf("Cannot open \"%s\": %s\n", file_name, strerror(errno)); 00078 } 00079 }
int main | ( | int | argc, | |
char ** | argv | |||
) |
Definition at line 83 of file mserver.c.
00086 : main (server.exe) 00087 00088 Purpose: Main routine for MIDAS server process. If called one 00089 parameter, it listens for a connection under 00090 MIDAS_TCP_PORT. If a connection is requested, the action 00091 depends on the parameter: 00092 00093 0: Single process server: This process executes RPC calls 00094 even if there are several connections. 00095 00096 1: Multi thread server (only Windows NT): For each conn- 00097 ection, a seperate thread is started which servers this 00098 connection. 00099 00100 2: Multi process server (Not MS-DOS): For each conn- 00101 ection, a seperate subprocess is started which servers 00102 this connection. The subprocess is again server.exe, now 00103 with four parameters: the IP address of the calling 00104 host, the two port numbers used by the calling 00105 host and optionally the name of the experiment to connect 00106 to. With this information it calles back the client. 00107 00108 This technique is necessary since the usual fork() doesn't 00109 work on some of the supported systems. 00110 00111 Input: 00112 int argc Number of parameters in command line 00113 char **argv Command line parameters: 00114 00115 ip-addr callback address as longword 00116 port-no port number 00117 program program name as string 00118 experiment experiment name as string 00119 00120 00121 Output: 00122 none 00123 00124 Function value: 00125 BM_SUCCESS Successful completion 00126 00127 \********************************************************************/ 00128 { 00129 int i, flag, size, server_type; 00130 char name[256], str[1000]; 00131 BOOL inetd, daemon, debug; 00132 int port = MIDAS_TCP_PORT; 00133 00134 #ifdef OS_WINNT 00135 /* init critical section object for open/close buffer */ 00136 InitializeCriticalSection(&buffer_critial_section); 00137 #endif 00138 00139 #if defined(SIGPIPE) && defined(SIG_IGN) 00140 signal(SIGPIPE, SIG_IGN); 00141 #endif 00142 00143 setbuf(stdout, NULL); 00144 setbuf(stderr, NULL); 00145 00146 /* save executable file name */ 00147 if (argv[0] == NULL || argv[0][0] == 0) 00148 strlcpy(name, "mserver", sizeof(name)); 00149 else 00150 strlcpy(name, argv[0], sizeof(name)); 00151 00152 #ifdef OS_UNIX 00153 /* if no full path given, assume /usr/local/bin */ 00154 if (strchr(name, '/') == 0) { 00155 strlcpy(str, "/usr/local/bin/", sizeof(str)); 00156 strlcat(str, name, sizeof(str)); 00157 strlcpy(name, str, sizeof(name)); 00158 } 00159 #endif 00160 00161 #if 0 00162 printf("mserver main, name [%s]\n", name); 00163 for (i=0; i<=argc; i++) 00164 printf("argv[%d] is [%s]\n", i, argv[i]); 00165 system("/bin/ls -la /proc/self/fd"); 00166 #endif 00167 00168 if (getenv("MIDAS_MSERVER_DO_NOT_USE_CALLBACK_ADDR")) 00169 use_callback_addr = FALSE; 00170 00171 rpc_set_server_option(RPC_OSERVER_NAME, (POINTER_T) name); 00172 00173 /* redirect message print */ 00174 cm_set_msg_print(MT_ALL, MT_ALL, msg_print); 00175 00176 /* find out if we were started by inetd */ 00177 size = sizeof(int); 00178 inetd = (getsockopt(0, SOL_SOCKET, SO_TYPE, (void *) &flag, (void *) &size) == 0); 00179 00180 /* check for debug flag */ 00181 debug = FALSE; 00182 for (i = 1; i < argc; i++) 00183 if (argv[i][0] == '-' && argv[i][1] == 'd') 00184 debug = TRUE; 00185 00186 if (debug) { 00187 debug_print("mserver startup"); 00188 for (i = 0; i < argc; i++) 00189 debug_print(argv[i]); 00190 rpc_set_debug(debug_print, 1); 00191 } 00192 00193 if (argc < 7 && inetd) { 00194 /* accept connection from stdin */ 00195 rpc_set_server_option(RPC_OSERVER_TYPE, ST_MPROCESS); 00196 rpc_server_accept(0); 00197 00198 return 0; 00199 } 00200 00201 if (!inetd && argc < 7) 00202 printf("%s started interactively\n", argv[0]); 00203 00204 debug = daemon = FALSE; 00205 server_type = ST_MPROCESS; 00206 00207 if (argc < 7) { 00208 /* parse command line parameters */ 00209 for (i = 1; i < argc; i++) { 00210 if (argv[i][0] == '-' && argv[i][1] == 'd') 00211 debug = TRUE; 00212 else if (argv[i][0] == '-' && argv[i][1] == 'D') 00213 daemon = TRUE; 00214 else if (argv[i][0] == '-' && argv[i][1] == 's') 00215 server_type = ST_SINGLE; 00216 else if (argv[i][0] == '-' && argv[i][1] == 't') 00217 server_type = ST_MTHREAD; 00218 else if (argv[i][0] == '-' && argv[i][1] == 'm') 00219 server_type = ST_MPROCESS; 00220 else if (argv[i][0] == '-' && argv[i][1] == 'p') 00221 port = strtoul(argv[++i], NULL, 0); 00222 else if (argv[i][1] == 'a') 00223 rpc_add_allowed_host(argv[++i]); 00224 else if (argv[i][0] == '-') { 00225 if (i + 1 >= argc || argv[i + 1][0] == '-') 00226 goto usage; 00227 else { 00228 usage: 00229 printf("usage: mserver [-s][-t][-m][-d][-p port][-a hostname]\n"); 00230 printf(" -s Single process server (DO NOT USE!)\n"); 00231 printf(" -t Multi threaded server (DO NOT USE!)\n"); 00232 printf(" -m Multi process server (default)\n"); 00233 printf(" -p port Listen for connections on non-default tcp port\n"); 00234 #ifdef OS_LINUX 00235 printf(" -D Become a daemon\n"); 00236 printf(" -d Write debug info to stdout or to \"/tmp/mserver.log\"\n\n"); 00237 #else 00238 printf(" -d Write debug info\"\n\n"); 00239 #endif 00240 printf(" -a hostname Only allow access for specified hosts\n"); 00241 return 0; 00242 } 00243 } 00244 } 00245 00246 /* turn on debugging */ 00247 if (debug) { 00248 if (daemon || inetd) 00249 rpc_set_debug(debug_print, 1); 00250 else 00251 rpc_set_debug((void (*)(char *)) puts, 1); 00252 00253 sprintf(str, "Arguments: "); 00254 for (i = 0; i < argc; i++) 00255 sprintf(str + strlen(str), " %s", argv[i]); 00256 rpc_debug_printf(str); 00257 00258 rpc_debug_printf("Debugging mode is on"); 00259 } 00260 00261 /* if command line parameter given, start according server type */ 00262 if (server_type == ST_MTHREAD) { 00263 if (ss_thread_create(NULL, NULL) == 0) { 00264 printf("MIDAS doesn't support threads on this OS.\n"); 00265 return 0; 00266 } 00267 00268 printf("NOTE: THE MULTI THREADED SERVER IS BUGGY, ONLY USE IT FOR TEST PURPOSES\n"); 00269 printf("Multi thread server started\n"); 00270 } 00271 00272 /* become a daemon */ 00273 if (daemon) { 00274 printf("Becoming a daemon...\n"); 00275 ss_daemon_init(FALSE); 00276 } 00277 00278 /* register server */ 00279 if (rpc_register_server(server_type, argv[0], &port, rpc_server_dispatch) != RPC_SUCCESS) { 00280 printf("Cannot start server\n"); 00281 return 0; 00282 } 00283 00284 /* register MIDAS library functions */ 00285 rpc_register_functions(rpc_get_internal_list(1), rpc_server_dispatch); 00286 00287 /* run forever */ 00288 while (ss_suspend(5000, 0) != RPC_SHUTDOWN); 00289 } else { 00290 00291 /* here we come if this program is started as a subprocess */ 00292 00293 memset(&callback, 0, sizeof(callback)); 00294 00295 /* extract callback arguments and start receiver */ 00296 #ifdef OS_VMS 00297 strlcpy(callback.host_name, argv[2], sizeof(callback.host_name)); 00298 callback.host_port1 = atoi(argv[3]); 00299 callback.host_port2 = atoi(argv[4]); 00300 callback.host_port3 = atoi(argv[5]); 00301 callback.debug = atoi(argv[6]); 00302 if (argc > 7) 00303 strlcpy(callback.experiment, argv[7], sizeof(callback.experiment)); 00304 if (argc > 8) 00305 strlcpy(callback.directory, argv[8], sizeof(callback.directory)); 00306 if (argc > 9) 00307 strlcpy(callback.user, argv[9], sizeof(callback.user)); 00308 #else 00309 strlcpy(callback.host_name, argv[1], sizeof(callback.host_name)); 00310 callback.host_port1 = atoi(argv[2]); 00311 callback.host_port2 = atoi(argv[3]); 00312 callback.host_port3 = atoi(argv[4]); 00313 callback.debug = atoi(argv[5]); 00314 if (argc > 6) 00315 strlcpy(callback.experiment, argv[6], sizeof(callback.experiment)); 00316 if (argc > 7) 00317 strlcpy(callback.directory, argv[7], sizeof(callback.directory)); 00318 if (argc > 8) 00319 strlcpy(callback.user, argv[8], sizeof(callback.user)); 00320 #endif 00321 callback.index = 0; 00322 00323 if (callback.debug) { 00324 rpc_set_debug(debug_print, 1); 00325 if (callback.directory[0]) { 00326 if (callback.user[0]) 00327 rpc_debug_printf("Start subprocess in %s under user %s", callback.directory, callback.user); 00328 else 00329 rpc_debug_printf("Start subprocess in %s", callback.directory); 00330 00331 } else 00332 rpc_debug_printf("Start subprocess in current directory"); 00333 } 00334 00335 /* change the directory and uid */ 00336 if (callback.directory[0]) 00337 if (chdir(callback.directory) != 0) 00338 rpc_debug_printf("Cannot change to directory \"%s\"", callback.directory); 00339 00340 #ifdef OS_UNIX 00341 00342 /* under UNIX, change user and group ID if started under root */ 00343 if (callback.user[0] && geteuid() == 0) { 00344 struct passwd *pw; 00345 00346 pw = getpwnam(callback.user); 00347 if (pw == NULL) { 00348 rpc_debug_printf("Cannot change UID, unknown user \"%s\"", callback.user); 00349 cm_msg(MERROR, "main", "Cannot change UID, unknown user \"%s\"", callback.user); 00350 } else { 00351 if (setgid(pw->pw_gid) < 0 || initgroups(pw->pw_name, pw->pw_gid) < 0) { 00352 rpc_debug_printf("Unable to set group premission for user %s", callback.user); 00353 cm_msg(MERROR, "main", "Unable to set group premission for user %s", callback.user); 00354 } else { 00355 if (setuid(pw->pw_uid) < 0) { 00356 rpc_debug_printf("Unable to set user ID for %s", callback.user); 00357 cm_msg(MERROR, "main", "Unable to set user ID for %s", callback.user); 00358 } else { 00359 if (debug) { 00360 rpc_debug_printf("Changed UID to user %s (GID %d, UID %d)", 00361 callback.user, pw->pw_gid, pw->pw_uid); 00362 cm_msg(MLOG, "main", "Changed UID to user %s (GID %d, UID %d)", 00363 callback.user, pw->pw_gid, pw->pw_uid); 00364 } 00365 } 00366 } 00367 } 00368 } 00369 #endif 00370 00371 rpc_register_server(ST_SUBPROCESS, NULL, NULL, rpc_server_dispatch); 00372 00373 /* register MIDAS library functions */ 00374 rpc_register_functions(rpc_get_internal_list(1), rpc_server_dispatch); 00375 00376 rpc_server_thread(&callback); 00377 } 00378 00379 return BM_SUCCESS; 00380 }
INT msg_print | ( | const char * | msg | ) |
Definition at line 400 of file mserver.c.
Referenced by main().
00403 : rpc_server_dispatch 00404 00405 Purpose: This routine gets registered as the callback function 00406 for all RPC calls via rpc_server_register. It acts as a 00407 stub to call the local midas subroutines. It uses the 00408 Cxxx(i) macros to cast parameters in prpc_param to 00409 their appropriate types. 00410 00411 Input: 00412 int index RPC index defined in RPC.H 00413 void *prpc_param pointer to rpc parameter array 00414 00415 Output: 00416 none 00417 00418 Function value: 00419 status status returned from local midas function 00420 00421 \********************************************************************/ 00422 { 00423 INT status = 0; 00424 INT convert_flags; 00425 00426 convert_flags = rpc_get_server_option(RPC_CONVERT_FLAGS); 00427 00428 switch (index) { 00429 /* common functions */ 00430 00431 case RPC_CM_SET_CLIENT_INFO: 00432 status = cm_set_client_info(CHNDLE(0), CPHNDLE(1), (use_callback_addr?callback.host_name:CSTRING(2)), 00433 CSTRING(3), CINT(4), CSTRING(5), CINT(6)); 00434 break; 00435 00436 case RPC_CM_CHECK_CLIENT: 00437 status = cm_check_client(CHNDLE(0), CHNDLE(1)); 00438 break; 00439 00440 case RPC_CM_SET_WATCHDOG_PARAMS: 00441 status = cm_set_watchdog_params(CBOOL(0), CINT(1)); 00442 break; 00443 00444 case RPC_CM_CLEANUP: 00445 status = cm_cleanup(CSTRING(0), CBOOL(1)); 00446 break; 00447 00448 case RPC_CM_GET_WATCHDOG_INFO: 00449 status = cm_get_watchdog_info(CHNDLE(0), CSTRING(1), CPDWORD(2), CPDWORD(3)); 00450 break; 00451 00452 case RPC_CM_MSG: 00453 status = cm_msg(CINT(0), CSTRING(1), CINT(2), CSTRING(3), CSTRING(4)); 00454 break; 00455 00456 case RPC_CM_MSG_LOG: 00457 status = cm_msg_log(CINT(0), CSTRING(1)); 00458 break; 00459 00460 case RPC_CM_MSG_LOG1: 00461 status = cm_msg_log1(CINT(0), CSTRING(1), CSTRING(2)); 00462 break; 00463 00464 case RPC_CM_EXECUTE: 00465 status = cm_execute(CSTRING(0), CSTRING(1), CINT(2)); 00466 break; 00467 00468 case RPC_CM_EXIST: 00469 status = cm_exist(CSTRING(0), CBOOL(1)); 00470 break; 00471 00472 case RPC_CM_SYNCHRONIZE: 00473 status = cm_synchronize(CPDWORD(0)); 00474 break; 00475 00476 case RPC_CM_ASCTIME: 00477 status = cm_asctime(CSTRING(0), CINT(1)); 00478 break; 00479 00480 case RPC_CM_TIME: 00481 status = cm_time(CPDWORD(0)); 00482 break; 00483 00484 case RPC_CM_MSG_RETRIEVE: 00485 status = cm_msg_retrieve(CINT(0), CSTRING(1), CINT(2)); 00486 break; 00487 00488 /* buffer manager functions */ 00489 00490 case RPC_BM_OPEN_BUFFER: 00491 00492 #ifdef OS_WINNT 00493 /* 00494 bm_open_buffer may only be called from one thread at a time, 00495 so use critical section object for synchronization. 00496 */ 00497 EnterCriticalSection(&buffer_critial_section); 00498 #endif 00499 00500 status = bm_open_buffer(CSTRING(0), CINT(1), CPINT(2)); 00501 00502 #ifdef OS_WINNT 00503 LeaveCriticalSection(&buffer_critial_section); 00504 #endif 00505 00506 break; 00507 00508 case RPC_BM_CLOSE_BUFFER: 00509 00510 #ifdef OS_WINNT 00511 /* 00512 bm_close_buffer may only be called from one thread at a time, 00513 so use critical section object for synchronization. 00514 */ 00515 EnterCriticalSection(&buffer_critial_section); 00516 #endif 00517 00518 status = bm_close_buffer(CINT(0)); 00519 00520 #ifdef OS_WINNT 00521 LeaveCriticalSection(&buffer_critial_section); 00522 #endif 00523 00524 break; 00525 00526 case RPC_BM_CLOSE_ALL_BUFFERS: 00527 00528 #ifdef OS_WINNT 00529 /* 00530 bm_close_all_buffers may only be called from one thread at a time, 00531 so use critical section object for synchronization. 00532 */ 00533 EnterCriticalSection(&buffer_critial_section); 00534 #endif 00535 00536 status = bm_close_all_buffers(); 00537 00538 #ifdef OS_WINNT 00539 LeaveCriticalSection(&buffer_critial_section); 00540 #endif 00541 00542 break; 00543 00544 case RPC_BM_GET_BUFFER_INFO: 00545 status = bm_get_buffer_info(CINT(0), CARRAY(1)); 00546 if (convert_flags) { 00547 BUFFER_HEADER *pb; 00548 00549 /* convert event header */ 00550 pb = (BUFFER_HEADER *) CARRAY(1); 00551 rpc_convert_single(&pb->num_clients, TID_INT, RPC_OUTGOING, convert_flags); 00552 rpc_convert_single(&pb->max_client_index, TID_INT, RPC_OUTGOING, convert_flags); 00553 rpc_convert_single(&pb->size, TID_INT, RPC_OUTGOING, convert_flags); 00554 rpc_convert_single(&pb->read_pointer, TID_INT, RPC_OUTGOING, convert_flags); 00555 rpc_convert_single(&pb->write_pointer, TID_INT, RPC_OUTGOING, convert_flags); 00556 rpc_convert_single(&pb->num_in_events, TID_INT, RPC_OUTGOING, convert_flags); 00557 rpc_convert_single(&pb->num_out_events, TID_INT, RPC_OUTGOING, convert_flags); 00558 } 00559 break; 00560 00561 case RPC_BM_GET_BUFFER_LEVEL: 00562 status = bm_get_buffer_level(CINT(0), CPINT(1)); 00563 break; 00564 00565 case RPC_BM_INIT_BUFFER_COUNTERS: 00566 status = bm_init_buffer_counters(CINT(0)); 00567 break; 00568 00569 case RPC_BM_SET_CACHE_SIZE: 00570 status = bm_set_cache_size(CINT(0), CINT(1), CINT(2)); 00571 break; 00572 00573 case RPC_BM_ADD_EVENT_REQUEST: 00574 status = bm_add_event_request(CINT(0), CSHORT(1), 00575 CSHORT(2), CINT(3), (void (*)(HNDLE, HNDLE, EVENT_HEADER *, void *)) 00576 (POINTER_T) 00577 CINT(4), CINT(5)); 00578 break; 00579 00580 case RPC_BM_REMOVE_EVENT_REQUEST: 00581 status = bm_remove_event_request(CINT(0), CINT(1)); 00582 break; 00583 00584 case RPC_BM_SEND_EVENT: 00585 if (convert_flags) { 00586 EVENT_HEADER *pevent; 00587 00588 /* convert event header */ 00589 pevent = (EVENT_HEADER *) CARRAY(1); 00590 rpc_convert_single(&pevent->event_id, TID_SHORT, 0, convert_flags); 00591 rpc_convert_single(&pevent->trigger_mask, TID_SHORT, 0, convert_flags); 00592 rpc_convert_single(&pevent->serial_number, TID_DWORD, 0, convert_flags); 00593 rpc_convert_single(&pevent->time_stamp, TID_DWORD, 0, convert_flags); 00594 rpc_convert_single(&pevent->data_size, TID_DWORD, 0, convert_flags); 00595 } 00596 00597 status = bm_send_event(CINT(0), CARRAY(1), CINT(2), CINT(3)); 00598 break; 00599 00600 case RPC_BM_RECEIVE_EVENT: 00601 status = bm_receive_event(CINT(0), CARRAY(1), CPINT(2), CINT(3)); 00602 break; 00603 00604 case RPC_BM_SKIP_EVENT: 00605 status = bm_skip_event(CINT(0)); 00606 break; 00607 00608 case RPC_BM_FLUSH_CACHE: 00609 status = bm_flush_cache(CINT(0), CINT(1)); 00610 break; 00611 00612 case RPC_BM_MARK_READ_WAITING: 00613 status = bm_mark_read_waiting(CBOOL(0)); 00614 break; 00615 00616 case RPC_BM_EMPTY_BUFFERS: 00617 status = bm_empty_buffers(); 00618 break; 00619 00620 /* database functions */ 00621 00622 case RPC_DB_OPEN_DATABASE: 00623 00624 #ifdef OS_WINNT 00625 /* 00626 db_open_database may only be called from one thread at a time, 00627 so use critical section object for synchronization. 00628 */ 00629 EnterCriticalSection(&buffer_critial_section); 00630 #endif 00631 00632 status = db_open_database(CSTRING(0), CINT(1), CPHNDLE(2), CSTRING(3)); 00633 00634 #ifdef OS_WINNT 00635 LeaveCriticalSection(&buffer_critial_section); 00636 #endif 00637 00638 break; 00639 00640 case RPC_DB_CLOSE_DATABASE: 00641 00642 #ifdef OS_WINNT 00643 /* 00644 db_close_database may only be called from one thread at a time, 00645 so use critical section object for synchronization. 00646 */ 00647 EnterCriticalSection(&buffer_critial_section); 00648 #endif 00649 00650 status = db_close_database(CINT(0)); 00651 00652 #ifdef OS_WINNT 00653 LeaveCriticalSection(&buffer_critial_section); 00654 #endif 00655 00656 break; 00657 00658 case RPC_DB_FLUSH_DATABASE: 00659 status = db_flush_database(CINT(0)); 00660 break; 00661 00662 case RPC_DB_CLOSE_ALL_DATABASES: 00663 00664 #ifdef OS_WINNT 00665 /* 00666 db_close_allo_databases may only be called from one thread at a time, 00667 so use critical section object for synchronization. 00668 */ 00669 EnterCriticalSection(&buffer_critial_section); 00670 #endif 00671 00672 status = db_close_all_databases(); 00673 00674 #ifdef OS_WINNT 00675 LeaveCriticalSection(&buffer_critial_section); 00676 #endif 00677 00678 break; 00679 00680 case RPC_DB_CREATE_KEY: 00681 status = db_create_key(CHNDLE(0), CHNDLE(1), CSTRING(2), CDWORD(3)); 00682 break; 00683 00684 case RPC_DB_CREATE_LINK: 00685 status = db_create_link(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3)); 00686 break; 00687 00688 case RPC_DB_SET_VALUE: 00689 rpc_convert_data(CARRAY(3), CDWORD(6), RPC_FIXARRAY, CINT(4), convert_flags); 00690 status = db_set_value(CHNDLE(0), CHNDLE(1), CSTRING(2), CARRAY(3), CINT(4), CINT(5), CDWORD(6)); 00691 break; 00692 00693 case RPC_DB_GET_VALUE: 00694 rpc_convert_data(CARRAY(3), CDWORD(5), RPC_FIXARRAY, CINT(4), convert_flags); 00695 status = db_get_value(CHNDLE(0), CHNDLE(1), CSTRING(2), CARRAY(3), CPINT(4), CDWORD(5), CBOOL(6)); 00696 rpc_convert_data(CARRAY(3), CDWORD(5), RPC_FIXARRAY | RPC_OUTGOING, CINT(4), convert_flags); 00697 break; 00698 00699 case RPC_DB_FIND_KEY: 00700 status = db_find_key(CHNDLE(0), CHNDLE(1), CSTRING(2), CPHNDLE(3)); 00701 break; 00702 00703 case RPC_DB_FIND_LINK: 00704 status = db_find_link(CHNDLE(0), CHNDLE(1), CSTRING(2), CPHNDLE(3)); 00705 break; 00706 00707 case RPC_DB_GET_PATH: 00708 status = db_get_path(CHNDLE(0), CHNDLE(1), CSTRING(2), CINT(3)); 00709 break; 00710 00711 case RPC_DB_DELETE_KEY: 00712 status = db_delete_key(CHNDLE(0), CHNDLE(1), CBOOL(2)); 00713 break; 00714 00715 case RPC_DB_ENUM_KEY: 00716 status = db_enum_key(CHNDLE(0), CHNDLE(1), CINT(2), CPHNDLE(3)); 00717 break; 00718 00719 case RPC_DB_ENUM_LINK: 00720 status = db_enum_link(CHNDLE(0), CHNDLE(1), CINT(2), CPHNDLE(3)); 00721 break; 00722 00723 case RPC_DB_GET_NEXT_LINK: 00724 status = db_get_next_link(CHNDLE(0), CHNDLE(1), CPHNDLE(2)); 00725 break; 00726 00727 case RPC_DB_GET_KEY: 00728 status = db_get_key(CHNDLE(0), CHNDLE(1), CARRAY(2)); 00729 if (convert_flags) { 00730 KEY *pkey; 00731 00732 pkey = (KEY *) CARRAY(2); 00733 rpc_convert_single(&pkey->type, TID_DWORD, RPC_OUTGOING, convert_flags); 00734 rpc_convert_single(&pkey->num_values, TID_INT, RPC_OUTGOING, convert_flags); 00735 rpc_convert_single(&pkey->data, TID_INT, RPC_OUTGOING, convert_flags); 00736 rpc_convert_single(&pkey->total_size, TID_INT, RPC_OUTGOING, convert_flags); 00737 rpc_convert_single(&pkey->item_size, TID_INT, RPC_OUTGOING, convert_flags); 00738 rpc_convert_single(&pkey->access_mode, TID_WORD, RPC_OUTGOING, convert_flags); 00739 rpc_convert_single(&pkey->notify_count, TID_WORD, RPC_OUTGOING, convert_flags); 00740 rpc_convert_single(&pkey->next_key, TID_INT, RPC_OUTGOING, convert_flags); 00741 rpc_convert_single(&pkey->parent_keylist, TID_INT, RPC_OUTGOING, convert_flags); 00742 rpc_convert_single(&pkey->last_written, TID_INT, RPC_OUTGOING, convert_flags); 00743 } 00744 break; 00745 00746 case RPC_DB_GET_LINK: 00747 status = db_get_link(CHNDLE(0), CHNDLE(1), CARRAY(2)); 00748 if (convert_flags) { 00749 KEY *pkey; 00750 00751 pkey = (KEY *) CARRAY(2); 00752 rpc_convert_single(&pkey->type, TID_DWORD, RPC_OUTGOING, convert_flags); 00753 rpc_convert_single(&pkey->num_values, TID_INT, RPC_OUTGOING, convert_flags); 00754 rpc_convert_single(&pkey->data, TID_INT, RPC_OUTGOING, convert_flags); 00755 rpc_convert_single(&pkey->total_size, TID_INT, RPC_OUTGOING, convert_flags); 00756 rpc_convert_single(&pkey->item_size, TID_INT, RPC_OUTGOING, convert_flags); 00757 rpc_convert_single(&pkey->access_mode, TID_WORD, RPC_OUTGOING, convert_flags); 00758 rpc_convert_single(&pkey->notify_count, TID_WORD, RPC_OUTGOING, convert_flags); 00759 rpc_convert_single(&pkey->next_key, TID_INT, RPC_OUTGOING, convert_flags); 00760 rpc_convert_single(&pkey->parent_keylist, TID_INT, RPC_OUTGOING, convert_flags); 00761 rpc_convert_single(&pkey->last_written, TID_INT, RPC_OUTGOING, convert_flags); 00762 } 00763 break; 00764 00765 case RPC_DB_GET_KEY_INFO: 00766 status = db_get_key_info(CHNDLE(0), CHNDLE(1), CSTRING(2), CINT(3), CPINT(4), CPINT(5), CPINT(6)); 00767 break; 00768 00769 case RPC_DB_GET_KEY_TIME: 00770 status = db_get_key_time(CHNDLE(0), CHNDLE(1), CPDWORD(2)); 00771 break; 00772 00773 case RPC_DB_RENAME_KEY: 00774 status = db_rename_key(CHNDLE(0), CHNDLE(1), CSTRING(2)); 00775 break; 00776 00777 case RPC_DB_REORDER_KEY: 00778 status = db_reorder_key(CHNDLE(0), CHNDLE(1), CINT(2)); 00779 break; 00780 00781 case RPC_DB_GET_DATA: 00782 status = db_get_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4)); 00783 rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags); 00784 break; 00785 00786 case RPC_DB_GET_LINK_DATA: 00787 status = db_get_link_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4)); 00788 rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags); 00789 break; 00790 00791 case RPC_DB_GET_DATA1: 00792 status = db_get_data1(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4), CPINT(5)); 00793 rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags); 00794 break; 00795 00796 case RPC_DB_GET_DATA_INDEX: 00797 status = db_get_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CINT(4), CDWORD(5)); 00798 rpc_convert_single(CARRAY(2), CDWORD(5), RPC_OUTGOING, convert_flags); 00799 break; 00800 00801 case RPC_DB_SET_DATA: 00802 rpc_convert_data(CARRAY(2), CDWORD(5), RPC_FIXARRAY, CINT(3), convert_flags); 00803 status = db_set_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5)); 00804 break; 00805 00806 case RPC_DB_SET_LINK_DATA: 00807 rpc_convert_data(CARRAY(2), CDWORD(5), RPC_FIXARRAY, CINT(3), convert_flags); 00808 status = db_set_link_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5)); 00809 break; 00810 00811 case RPC_DB_SET_DATA_INDEX: 00812 rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags); 00813 status = db_set_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5)); 00814 break; 00815 00816 case RPC_DB_SET_LINK_DATA_INDEX: 00817 rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags); 00818 status = db_set_link_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5)); 00819 break; 00820 00821 case RPC_DB_SET_DATA_INDEX2: 00822 rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags); 00823 status = db_set_data_index2(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5), CBOOL(6)); 00824 break; 00825 00826 case RPC_DB_SET_NUM_VALUES: 00827 status = db_set_num_values(CHNDLE(0), CHNDLE(1), CINT(2)); 00828 break; 00829 00830 case RPC_DB_SET_MODE: 00831 status = db_set_mode(CHNDLE(0), CHNDLE(1), CWORD(2), CBOOL(3)); 00832 break; 00833 00834 case RPC_DB_GET_RECORD: 00835 status = db_get_record(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CINT(4)); 00836 break; 00837 00838 case RPC_DB_SET_RECORD: 00839 status = db_set_record(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4)); 00840 break; 00841 00842 case RPC_DB_GET_RECORD_SIZE: 00843 status = db_get_record_size(CHNDLE(0), CHNDLE(1), CINT(2), CPINT(3)); 00844 break; 00845 00846 case RPC_DB_CREATE_RECORD: 00847 status = db_create_record(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3)); 00848 break; 00849 00850 case RPC_DB_CHECK_RECORD: 00851 status = db_check_record(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3), CBOOL(4)); 00852 break; 00853 00854 case RPC_DB_ADD_OPEN_RECORD: 00855 status = db_add_open_record(CHNDLE(0), CHNDLE(1), CWORD(2)); 00856 break; 00857 00858 case RPC_DB_REMOVE_OPEN_RECORD: 00859 status = db_remove_open_record(CHNDLE(0), CHNDLE(1), CBOOL(2)); 00860 break; 00861 00862 case RPC_DB_LOAD: 00863 status = db_load(CHNDLE(0), CHNDLE(1), CSTRING(2), CBOOL(3)); 00864 break; 00865 00866 case RPC_DB_SAVE: 00867 status = db_save(CHNDLE(0), CHNDLE(1), CSTRING(2), CBOOL(3)); 00868 break; 00869 00870 case RPC_DB_SET_CLIENT_NAME: 00871 status = db_set_client_name(CHNDLE(0), CSTRING(1)); 00872 break; 00873 00874 case RPC_DB_GET_OPEN_RECORDS: 00875 status = db_get_open_records(CHNDLE(0), CHNDLE(1), CSTRING(2), CINT(3), CBOOL(4)); 00876 break; 00877 00878 /* history functions */ 00879 00880 case RPC_HS_SET_PATH: 00881 status = hs_set_path(CSTRING(0)); 00882 break; 00883 00884 case RPC_HS_DEFINE_EVENT: 00885 if (convert_flags) { 00886 TAG *tag; 00887 INT i; 00888 00889 /* convert tags */ 00890 tag = (TAG *) CARRAY(2); 00891 for (i = 0; i < CINT(3); i++) { 00892 rpc_convert_single(&tag[i].type, TID_DWORD, 0, convert_flags); 00893 rpc_convert_single(&tag[i].n_data, TID_DWORD, 0, convert_flags); 00894 } 00895 } 00896 00897 status = hs_define_event(CDWORD(0), CSTRING(1), CARRAY(2), CDWORD(3)); 00898 break; 00899 00900 case RPC_HS_WRITE_EVENT: 00901 status = hs_write_event(CDWORD(0), CARRAY(1), CDWORD(2)); 00902 break; 00903 00904 case RPC_HS_COUNT_EVENTS: 00905 status = hs_count_events(CDWORD(0), CPDWORD(1)); 00906 break; 00907 00908 case RPC_HS_ENUM_EVENTS: 00909 status = hs_enum_events(CDWORD(0), CSTRING(1), CPDWORD(2), CPINT(3), CPDWORD(4)); 00910 break; 00911 00912 case RPC_HS_COUNT_VARS: 00913 status = hs_count_vars(CDWORD(0), CDWORD(1), CPDWORD(2)); 00914 break; 00915 00916 case RPC_HS_ENUM_VARS: 00917 status = hs_enum_vars(CDWORD(0), CDWORD(1), CSTRING(2), CPDWORD(3), CPDWORD(4), CPDWORD(5)); 00918 break; 00919 00920 case RPC_HS_GET_VAR: 00921 status = hs_get_var(CDWORD(0), CDWORD(1), CSTRING(2), CPDWORD(3), CPINT(4)); 00922 break; 00923 00924 case RPC_HS_GET_EVENT_ID: 00925 status = hs_get_event_id(CDWORD(0), CSTRING(1), CPDWORD(2)); 00926 break; 00927 00928 case RPC_HS_READ: 00929 status = hs_read(CDWORD(0), CDWORD(1), CDWORD(2), CDWORD(3), CSTRING(4), 00930 CDWORD(5), CARRAY(6), CPDWORD(7), CARRAY(8), CPDWORD(9), CPDWORD(10), CPDWORD(11)); 00931 if (convert_flags && rpc_tid_size(CDWORD(10)) > 0) { 00932 rpc_convert_data(CARRAY(6), TID_DWORD, RPC_FIXARRAY | RPC_OUTGOING, 00933 CDWORD(7) / sizeof(DWORD), convert_flags); 00934 rpc_convert_data(CARRAY(8), CDWORD(10), RPC_FIXARRAY | RPC_OUTGOING, 00935 CDWORD(11) / rpc_tid_size(CDWORD(10)), convert_flags); 00936 } 00937 break; 00938 00939 case RPC_EL_SUBMIT: 00940 status = el_submit(CINT(0), CSTRING(1), CSTRING(2), CSTRING(3), CSTRING(4), 00941 CSTRING(5), CSTRING(6), CSTRING(7), 00942 CSTRING(8), CARRAY(9), CINT(10), 00943 CSTRING(11), CARRAY(12), CINT(13), 00944 CSTRING(14), CARRAY(15), CINT(16), CSTRING(17), CINT(18)); 00945 break; 00946 00947 case RPC_AL_CHECK: 00948 status = al_check(); 00949 break; 00950 00951 case RPC_AL_TRIGGER_ALARM: 00952 status = al_trigger_alarm(CSTRING(0), CSTRING(1), CSTRING(2), CSTRING(3), CINT(4)); 00953 break; 00954 00955 /* exit functions */ 00956 case RPC_ID_EXIT: 00957 case RPC_ID_SHUTDOWN: 00958 status = RPC_SUCCESS; 00959 break; 00960 00961 /* various functions */ 00962 00963 case RPC_TEST: 00964 status = rpc_test(CBYTE(0), CWORD(1), CINT(2), CFLOAT(3), CDOUBLE(4), 00965 CPBYTE(5), CPWORD(6), CPINT(7), CPFLOAT(8), CPDOUBLE(9)); 00966 break; 00967 00968 default: 00969 cm_msg(MERROR, "rpc_server_dispatch", "received unrecognized command %d", index); 00970 } 00971 00972 return status; 00973 }
INT rpc_test | ( | BYTE | b, | |
WORD | w, | |||
INT | i, | |||
float | f, | |||
double | d, | |||
BYTE * | b1, | |||
WORD * | w1, | |||
INT * | i1, | |||
float * | f1, | |||
double * | d1 | |||
) |
Definition at line 385 of file mserver.c.
Referenced by rpc_server_dispatch().
00386 { 00387 printf("rpc_test: %d %d %d %1.1f %1.1lf\n", b, w, i, f, d); 00388 00389 *b1 = b * 2; 00390 *w1 = w * 2; 00391 *i1 = i * 2; 00392 *f1 = f * 2; 00393 *d1 = d * 2; 00394 00395 return 1; 00396 }
struct callback_addr callback |
Definition at line 25 of file mserver.c.
Referenced by debug_print(), main(), and rpc_server_dispatch().
BOOL use_callback_addr = TRUE |