00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012 #include "midas.h"
00013 #include "msystem.h"
00014
00015 #ifdef OS_UNIX
00016 #include <grp.h>
00017 #include <sys/types.h>
00018 #endif
00019
00020 #ifdef OS_WINNT
00021
00022 CRITICAL_SECTION buffer_critial_section;
00023 #endif
00024
00025 struct callback_addr callback;
00026
00027 BOOL use_callback_addr = TRUE;
00028
00029 INT rpc_server_dispatch(INT index, void *prpc_param[]);
00030
00031
00032
00033 INT msg_print(const char *msg)
00034 {
00035
00036 ss_syslog(msg);
00037
00038
00039 return puts(msg);
00040 }
00041
00042
00043
00044 void debug_print(char *msg)
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
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 }
00080
00081
00082
00083 int main(int argc, char **argv)
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
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
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
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
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
00174 cm_set_msg_print(MT_ALL, MT_ALL, msg_print);
00175
00176
00177 size = sizeof(int);
00178 inetd = (getsockopt(0, SOL_SOCKET, SO_TYPE, (void *) &flag, (void *) &size) == 0);
00179
00180
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
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
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
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
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
00273 if (daemon) {
00274 printf("Becoming a daemon...\n");
00275 ss_daemon_init(FALSE);
00276 }
00277
00278
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
00285 rpc_register_functions(rpc_get_internal_list(1), rpc_server_dispatch);
00286
00287
00288 while (ss_suspend(5000, 0) != RPC_SHUTDOWN);
00289 } else {
00290
00291
00292
00293 memset(&callback, 0, sizeof(callback));
00294
00295
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
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
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
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 }
00381
00382
00383
00384
00385 INT rpc_test(BYTE b, WORD w, INT i, float f, double d, BYTE * b1, WORD * w1, INT * i1, float *f1, double *d1)
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 }
00397
00398
00399
00400 INT rpc_server_dispatch(INT index, void *prpc_param[])
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
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
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
00489
00490 case RPC_BM_OPEN_BUFFER:
00491
00492 #ifdef OS_WINNT
00493
00494
00495
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
00513
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
00531
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
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
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
00621
00622 case RPC_DB_OPEN_DATABASE:
00623
00624 #ifdef OS_WINNT
00625
00626
00627
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
00645
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
00667
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
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
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
00956 case RPC_ID_EXIT:
00957 case RPC_ID_SHUTDOWN:
00958 status = RPC_SUCCESS;
00959 break;
00960
00961
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 }