mserver.c File Reference

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


Function Documentation

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 33 of file mserver.c.

Referenced by main().

00034 {
00035    /* print message to system log */
00036    ss_syslog(msg);
00037 
00038    /* print message to stdout */
00039    return puts(msg);
00040 }

INT rpc_server_dispatch ( INT  index,
void *  prpc_param[] 
)

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 }


Variable Documentation

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

Definition at line 27 of file mserver.c.

Referenced by main(), and rpc_server_dispatch().


Midas DOC Version 3.0.0 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk