mserver.cxx File Reference

#include "midas.h"
#include "msystem.h"
#include "mstrlcpy.h"

Include dependency graph for mserver.cxx:

Go to the source code of this file.

Functions
INT	rpc_server_dispatch (INT index, void *prpc_param[])
void	debug_print (const 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
struct callback_addr	callback
BOOL	use_callback_addr = TRUE

Function Documentation

debug_print()

void debug_print

(

const char *

msg

)

Definition at line 30 of file mserver.cxx.

{
   std::string file_name;
   static std::string client_name;
   static DWORD start_time = 0;
 
   if (!start_time)
      start_time = ss_millitime();
 
   /* print message to file */
#ifdef OS_LINUX
   file_name = "/tmp/mserver.log";
#else
   file_name = ss_getcwd();
   if (!ends_with_char(file_name, DIR_SEPARATOR)) {
      file_name += DIR_SEPARATOR_STRING;
   }
   file_name += "mserver.log";
#endif
 
   FILE *f = fopen(file_name.c_str(), "a");
 
   if (!f) {
      fprintf(stderr, "Cannot open \"%s\", errno %d (%s)\n", file_name.c_str(), errno, strerror(errno));
      return;
   }
 
   if (client_name.empty())
      client_name = cm_get_client_name();
 
   std::string str = msprintf("%10.3lf [%d,%s,%s] ", (ss_millitime() - start_time) / 1000.0,
           ss_getpid(), callback.host_name.c_str(), client_name.c_str());
   str += msg;
   str += "\n";
 
   fputs(str.c_str(), f);
   fclose(f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

• save executable file name *‍/

Definition at line 71 of file mserver.cxx.

{
   int i, flag;
   socklen_t size;
   //char name[256];
   char str[1000];
   BOOL inetd, daemon, debug;
 
#if defined(SIGPIPE) && defined(SIG_IGN)
   signal(SIGPIPE, SIG_IGN);
#endif
 
   setbuf(stdout, NULL);
   setbuf(stderr, NULL);
 
   //if (argv[0] == NULL || argv[0][0] == 0)
   //  mstrlcpy(name, "mserver", sizeof(name));
   //else
   //  mstrlcpy(name, argv[0], sizeof(name));
 
#ifdef OS_UNIX
   //if (strchr(name, '/') == 0) {
   //   mstrlcpy(str, "/usr/local/bin/", sizeof(str));
   //   mstrlcat(str, name, sizeof(str));
   //   mstrlcpy(name, str, sizeof(name));
   //}
#endif
 
#if 0
   printf("mserver main, name [%s]\n", name);
   for (i=0; i<=argc; i++)
      printf("argv[%d] is [%s]\n", i, argv[i]);
   system("/bin/ls -la /proc/self/fd");
#endif
 
   if (getenv("MIDAS_MSERVER_DO_NOT_USE_CALLBACK_ADDR"))
      use_callback_addr = FALSE;
 
   //rpc_set_mserver_path(name);
 
   /* find out if we were started by inetd */
   size = sizeof(int);
   inetd = (getsockopt(0, SOL_SOCKET, SO_TYPE, (void *) &flag, &size) == 0);
 
   /* check for debug flag */
   debug = FALSE;
   for (i = 1; i < argc; i++)
      if (argv[i][0] == '-' && argv[i][1] == 'd')
         debug = TRUE;
 
   if (debug) {
      debug_print("mserver startup");
      for (i = 0; i < argc; i++)
         debug_print(argv[i]);
      rpc_set_debug(debug_print, 1);
   }
 
   if (argc < 7 && inetd) {
      /* accept connection from stdin */
      rpc_server_accept(0);
      return 0;
   }
 
   if (!inetd && argc < 7)
      printf("%s started interactively\n", argv[0]);
 
   debug = daemon = FALSE;
 
   if (argc < 7 || argv[1][0] == '-') {
      int status;
      char expt_name[NAME_LENGTH];
      int port = 0;
 
      /* Get if existing the pre-defined experiment */
      expt_name[0] = 0;
      cm_get_environment(NULL, 0, expt_name, sizeof(expt_name));
 
      /* parse command line parameters */
      for (i = 1; i < argc; i++) {
         if (strncmp(argv[i], "-e", 2) == 0) {
            mstrlcpy(expt_name, argv[++i], sizeof(expt_name));
         } else if (argv[i][0] == '-' && argv[i][1] == 'd')
            debug = TRUE;
         else if (argv[i][0] == '-' && argv[i][1] == 'D')
            daemon = TRUE;
         else if (argv[i][0] == '-' && argv[i][1] == 'p')
            port = strtoul(argv[++i], NULL, 0);
         else if (argv[i][0] == '-') {
            if (i + 1 >= argc || argv[i + 1][0] == '-')
               goto usage;
            else {
             usage:
               printf("usage: mserver [-e Experiment] [-s][-t][-m][-d][-p port]\n");
               printf("               -e    experiment to connect to\n");
               printf("               -m    Multi process server (default)\n");
               printf("               -p port Listen for connections on specifed tcp port. Default value is taken from ODB \"/Experiment/midas server port\"\n");
#ifdef OS_LINUX
               printf("               -D    Become a daemon\n");
               printf("               -d    Write debug info to stdout or to \"/tmp/mserver.log\"\n\n");
#else
               printf("               -d    Write debug info\"\n\n");
#endif
               return 0;
            }
         }
      }
 
      /* turn on debugging */
      if (debug) {
         if (daemon || inetd)
            rpc_set_debug(debug_print, 1);
         else
            rpc_set_debug((void (*)(const char *)) puts, 1);
 
         sprintf(str, "Arguments: ");
         for (i = 0; i < argc; i++)
            sprintf(str + strlen(str), " %s", argv[i]);
         rpc_debug_printf(str);
 
         rpc_debug_printf("Debugging mode is on");
      }
 
      /* become a daemon */
      if (daemon) {
         printf("Becoming a daemon...\n");
         ss_daemon_init(FALSE);
      }
 
      /* connect to experiment */
      status = cm_connect_experiment(NULL, expt_name, "mserver", 0);
      if (status != CM_SUCCESS) {
         printf("cannot connect to experiment \"%s\", status %d\n", expt_name, status);
         exit(1);
      }
      
      HNDLE hDB;
      HNDLE hClient;
 
      status = cm_get_experiment_database(&hDB, &hClient);
      assert(status == CM_SUCCESS);
      
      int odb_port = MIDAS_TCP_PORT;
      int size = sizeof(odb_port);
 
      status = db_get_value(hDB, 0, "/Experiment/Midas server port", &odb_port, &size, TID_DWORD, TRUE);
      assert(status == DB_SUCCESS);
 
      if (port == 0)
         port = odb_port;
      
      if (port == 0)
         port = MIDAS_TCP_PORT;
 
      printf("mserver will listen on TCP port %d\n", port);
 
      int lsock = 0; // mserver main listener socket
      int lport = 0; // mserver listener port number
 
      /* register server */
      status = rpc_register_listener(port, rpc_server_dispatch, &lsock, &lport);
      if (status != RPC_SUCCESS) {
         printf("Cannot start server, rpc_register_server() status %d\n", status);
         return 1;
      }
 
      /* register path of mserver executable */
      rpc_set_mserver_path(argv[0]);
 
      /* register MIDAS library functions */
      rpc_register_functions(rpc_get_internal_list(1), rpc_server_dispatch);
 
      ss_suspend_set_server_listener(lsock);
 
      /* run forever */
      while (1) {
         status = cm_yield(1000);
         //printf("status %d\n", status);
         if (status == RPC_SHUTDOWN)
            break;
      }
 
      closesocket(lsock);
 
      cm_disconnect_experiment();
   } else {
 
      /* here we come if this program is started as a subprocess */
 
      callback.clear();
 
      /* extract callback arguments and start receiver */
#ifdef OS_VMS
      mstrlcpy(callback.host_name, argv[2], sizeof(callback.host_name));
      callback.host_port1 = atoi(argv[3]);
      callback.host_port2 = atoi(argv[4]);
      callback.host_port3 = atoi(argv[5]);
      callback.debug = atoi(argv[6]);
      if (argc > 7)
         mstrlcpy(callback.experiment, argv[7], sizeof(callback.experiment));
      if (argc > 8)
         mstrlcpy(callback.directory, argv[8], sizeof(callback.directory));
      if (argc > 9)
         mstrlcpy(callback.user, argv[9], sizeof(callback.user));
#else
      callback.host_name = argv[1];
      callback.host_port1 = atoi(argv[2]);
      callback.host_port2 = atoi(argv[3]);
      callback.host_port3 = atoi(argv[4]);
      callback.debug = atoi(argv[5]);
      if (argc > 6)
         callback.experiment = argv[6];
      if (argc > 7)
         callback.directory = argv[7];
      if (argc > 8)
         callback.user = argv[8];
#endif
      //callback.index = 0;
 
      if (callback.debug) {
         rpc_set_debug(debug_print, 1);
         if (callback.directory[0]) {
            if (callback.user[0])
               rpc_debug_printf("Start subprocess in %s under user %s", callback.directory.c_str(), callback.user.c_str());
            else
               rpc_debug_printf("Start subprocess in %s", callback.directory.c_str());
 
         } else
            rpc_debug_printf("Start subprocess in current directory");
      }
 
      /* change the directory and uid */
      if (callback.directory.length() > 0)
         if (chdir(callback.directory.c_str()) != 0)
            rpc_debug_printf("Cannot change to directory \"%s\"", callback.directory.c_str());
 
      cm_msg_early_init();
 
      /* set the experiment name and expt path name */
 
      if (callback.directory.length() > 0)
         cm_set_path(callback.directory.c_str());
      
      if (callback.experiment.length() > 0)
         cm_set_experiment_name(callback.experiment.c_str());
 
      /* must be done after cm_set_path() */
      ss_suspend_init_odb_port();
 
      /* register system functions */
      rpc_register_functions(rpc_get_internal_list(0), rpc_server_dispatch);
 
      /* register MIDAS library functions */
      rpc_register_functions(rpc_get_internal_list(1), rpc_server_dispatch);
 
      int status = rpc_server_callback(&callback);
      
      if (status != RPC_SUCCESS) {
         cm_msg_flush_buffer();
         printf("Cannot start mserver, rpc_server_callback() status %d\n", status);
         return 1;
      }
      
      /* create alarm and elog semaphores */
      int semaphore_alarm, semaphore_elog, semaphore_history, semaphore_msg;
      ss_semaphore_create("ALARM", &semaphore_alarm);
      ss_semaphore_create("ELOG", &semaphore_elog);
      ss_semaphore_create("HISTORY", &semaphore_history);
      ss_semaphore_create("MSG", &semaphore_msg);
      cm_set_experiment_semaphore(semaphore_alarm, semaphore_elog, semaphore_history, semaphore_msg);
 
      rpc_server_loop();
      rpc_server_shutdown();
 
      ss_suspend_exit();
   }
 
   return 0;
}

Here is the call graph for this function:

rpc_server_dispatch()

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

Definition at line 414 of file mserver.cxx.

{
   INT status = 0;
 
   int convert_flags = rpc_get_convert_flags();
 
   switch (index) {
      /* common functions */
 
   case RPC_CM_SET_CLIENT_INFO:
      status = cm_set_client_info(CHNDLE(0), CPHNDLE(1), (use_callback_addr?callback.host_name.c_str():CSTRING(2)),
                                  CSTRING(3), CINT(4), CSTRING(5), CINT(6));
      break;
 
   case RPC_CM_CHECK_CLIENT:
      status = cm_check_client(CHNDLE(0), CHNDLE(1));
      break;
 
   case RPC_CM_SET_WATCHDOG_PARAMS:
      status = cm_set_watchdog_params(CBOOL(0), CINT(1));
      break;
 
   case RPC_CM_CLEANUP:
      status = cm_cleanup(CSTRING(0), CBOOL(1));
      break;
 
   case RPC_CM_GET_WATCHDOG_INFO:
      status = cm_get_watchdog_info(CHNDLE(0), CSTRING(1), CPDWORD(2), CPDWORD(3));
      break;
 
   case RPC_CM_MSG:
      status = cm_msg(CINT(0), CSTRING(1), CINT(2), CSTRING(3), "%s", CSTRING(4));
      break;
 
   case RPC_CM_MSG_LOG:
      status = cm_msg_log(CINT(0), CSTRING(1), CSTRING(2));
      break;
 
   case RPC_CM_EXECUTE:
      status = cm_execute(CSTRING(0), CSTRING(1), CINT(2));
      break;
 
   case RPC_CM_EXIST:
      status = cm_exist(CSTRING(0), CBOOL(1));
      break;
 
   case RPC_CM_SYNCHRONIZE:
      status = cm_synchronize(CPDWORD(0));
      break;
 
   case RPC_CM_ASCTIME: {
      std::string now = cm_asctime();
      mstrlcpy(CSTRING(0), now.c_str(), CINT(1));
      status = CM_SUCCESS;
      break;
   }
 
   case RPC_CM_TIME:
      status = cm_time(CPDWORD(0));
      break;
 
   case RPC_CM_MSG_RETRIEVE:
      status = cm_msg_retrieve(CINT(0), CSTRING(1), CINT(2));
      break;
 
      /* buffer manager functions */
 
   case RPC_BM_OPEN_BUFFER:
      status = bm_open_buffer(CSTRING(0), CINT(1), CPINT(2));
      break;
 
   case RPC_BM_CLOSE_BUFFER:
      //printf("RPC_BM_CLOSE_BUFFER(%d)!\n", CINT(0));
      status = bm_close_buffer(CINT(0));
      break;
 
   case RPC_BM_CLOSE_ALL_BUFFERS:
      //printf("RPC_BM_CLOSE_ALL_BUFFERS!\n");
      status = bm_close_all_buffers();
      break;
 
   case RPC_BM_GET_BUFFER_INFO:
      status = bm_get_buffer_info(CINT(0), (BUFFER_HEADER*)CARRAY(1));
      if (convert_flags) {
         BUFFER_HEADER *pb;
 
         /* convert event header */
         pb = (BUFFER_HEADER *) CARRAY(1);
         rpc_convert_single(&pb->num_clients, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->max_client_index, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->size, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->read_pointer, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->write_pointer, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->num_in_events, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pb->num_out_events, TID_INT, RPC_OUTGOING, convert_flags);
      }
      break;
 
   case RPC_BM_GET_BUFFER_LEVEL:
      status = bm_get_buffer_level(CINT(0), CPINT(1));
      break;
 
   case RPC_BM_INIT_BUFFER_COUNTERS:
      status = bm_init_buffer_counters(CINT(0));
      break;
 
   case RPC_BM_SET_CACHE_SIZE:
      status = bm_set_cache_size(CINT(0), CINT(1), CINT(2));
      break;
 
   case RPC_BM_ADD_EVENT_REQUEST:
      status = bm_add_event_request(CINT(0), CSHORT(1),
                                    CSHORT(2), CINT(3), (void (*)(HNDLE, HNDLE, EVENT_HEADER *, void *))
                                    (POINTER_T)
                                    CINT(4), CINT(5));
      break;
 
   case RPC_BM_REMOVE_EVENT_REQUEST:
      status = bm_remove_event_request(CINT(0), CINT(1));
      break;
 
   case RPC_BM_SEND_EVENT:
      if (convert_flags) {
         EVENT_HEADER *pevent;
 
         /* convert event header */
         pevent = (EVENT_HEADER *) CARRAY(1);
         rpc_convert_single(&pevent->event_id, TID_SHORT, 0, convert_flags);
         rpc_convert_single(&pevent->trigger_mask, TID_SHORT, 0, convert_flags);
         rpc_convert_single(&pevent->serial_number, TID_DWORD, 0, convert_flags);
         rpc_convert_single(&pevent->time_stamp, TID_DWORD, 0, convert_flags);
         rpc_convert_single(&pevent->data_size, TID_DWORD, 0, convert_flags);
      }
 
      status = bm_send_event(CINT(0), (const EVENT_HEADER*)(CARRAY(1)), CINT(2), CINT(3));
      break;
 
   case RPC_BM_RECEIVE_EVENT:
      status = bm_receive_event(CINT(0), CARRAY(1), CPINT(2), CINT(3));
      break;
 
   case RPC_BM_SKIP_EVENT:
      status = bm_skip_event(CINT(0));
      break;
 
   case RPC_BM_FLUSH_CACHE:
      //printf("RPC_BM_FLUSH_CACHE(%d,%d)!\n", CINT(0), CINT(1));
      if (CINT(0) == 0) {
         status = rpc_flush_event_socket(CINT(1));
      } else {
         status = bm_flush_cache(CINT(0), CINT(1));
      }
      break;
 
   case RPC_BM_MARK_READ_WAITING:
      status = BM_SUCCESS;
      break;
 
   case RPC_BM_EMPTY_BUFFERS:
      status = bm_empty_buffers();
      break;
 
      /* database functions */
 
   case RPC_DB_OPEN_DATABASE:
      status = db_open_database(CSTRING(0), CINT(1), CPHNDLE(2), CSTRING(3));
      break;
 
   case RPC_DB_CLOSE_DATABASE:
      status = db_close_database(CINT(0));
      break;
 
   case RPC_DB_FLUSH_DATABASE:
      status = db_flush_database(CINT(0));
      break;
 
   case RPC_DB_CLOSE_ALL_DATABASES:
      status = db_close_all_databases();
      break;
 
   case RPC_DB_CREATE_KEY:
      status = db_create_key(CHNDLE(0), CHNDLE(1), CSTRING(2), CDWORD(3));
      break;
 
   case RPC_DB_CREATE_LINK:
      status = db_create_link(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3));
      break;
 
   case RPC_DB_SET_VALUE:
      rpc_convert_data(CARRAY(3), CDWORD(6), RPC_FIXARRAY, CINT(4), convert_flags);
      status = db_set_value(CHNDLE(0), CHNDLE(1), CSTRING(2), CARRAY(3), CINT(4), CINT(5), CDWORD(6));
      break;
 
   case RPC_DB_GET_VALUE:
      rpc_convert_data(CARRAY(3), CDWORD(5), RPC_FIXARRAY, CINT(4), convert_flags);
      status = db_get_value(CHNDLE(0), CHNDLE(1), CSTRING(2), CARRAY(3), CPINT(4), CDWORD(5), CBOOL(6));
      rpc_convert_data(CARRAY(3), CDWORD(5), RPC_FIXARRAY | RPC_OUTGOING, CINT(4), convert_flags);
      break;
 
   case RPC_DB_FIND_KEY:
      status = db_find_key(CHNDLE(0), CHNDLE(1), CSTRING(2), CPHNDLE(3));
      break;
 
   case RPC_DB_FIND_LINK:
      status = db_find_link(CHNDLE(0), CHNDLE(1), CSTRING(2), CPHNDLE(3));
      break;
 
   case RPC_DB_GET_PATH: {
      std::string path = db_get_path(CHNDLE(0), CHNDLE(1));
      mstrlcpy(CSTRING(2), path.c_str(), CINT(3));
      status = DB_SUCCESS;
      break;
   }
 
   case RPC_DB_GET_PARENT:
      status = db_get_parent(CHNDLE(0), CHNDLE(1), CPHNDLE(2));
      break;
 
   case RPC_DB_DELETE_KEY:
      status = db_delete_key(CHNDLE(0), CHNDLE(1), CBOOL(2));
      break;
 
   case RPC_DB_ENUM_KEY:
      status = db_enum_key(CHNDLE(0), CHNDLE(1), CINT(2), CPHNDLE(3));
      break;
 
   case RPC_DB_ENUM_LINK:
      status = db_enum_link(CHNDLE(0), CHNDLE(1), CINT(2), CPHNDLE(3));
      break;
 
   case RPC_DB_GET_NEXT_LINK:
      status = db_get_next_link(CHNDLE(0), CHNDLE(1), CPHNDLE(2));
      break;
 
   case RPC_DB_GET_KEY:
      status = db_get_key(CHNDLE(0), CHNDLE(1), (KEY*)CARRAY(2));
      if (convert_flags) {
         KEY *pkey;
 
         pkey = (KEY *) CARRAY(2);
         rpc_convert_single(&pkey->type, TID_DWORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->num_values, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->data, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->total_size, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->item_size, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->access_mode, TID_WORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->notify_count, TID_WORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->next_key, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->parent_keylist, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->last_written, TID_INT, RPC_OUTGOING, convert_flags);
      }
      break;
 
   case RPC_DB_GET_LINK:
      status = db_get_link(CHNDLE(0), CHNDLE(1), (KEY*)CARRAY(2));
      if (convert_flags) {
         KEY *pkey;
 
         pkey = (KEY *) CARRAY(2);
         rpc_convert_single(&pkey->type, TID_DWORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->num_values, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->data, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->total_size, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->item_size, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->access_mode, TID_WORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->notify_count, TID_WORD, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->next_key, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->parent_keylist, TID_INT, RPC_OUTGOING, convert_flags);
         rpc_convert_single(&pkey->last_written, TID_INT, RPC_OUTGOING, convert_flags);
      }
      break;
 
   case RPC_DB_GET_KEY_INFO:
      status = db_get_key_info(CHNDLE(0), CHNDLE(1), CSTRING(2), CINT(3), CPINT(4), CPINT(5), CPINT(6));
      break;
 
   case RPC_DB_GET_KEY_TIME:
      status = db_get_key_time(CHNDLE(0), CHNDLE(1), CPDWORD(2));
      break;
 
   case RPC_DB_RENAME_KEY:
      status = db_rename_key(CHNDLE(0), CHNDLE(1), CSTRING(2));
      break;
 
   case RPC_DB_REORDER_KEY:
      status = db_reorder_key(CHNDLE(0), CHNDLE(1), CINT(2));
      break;
 
   case RPC_DB_GET_DATA:
      status = db_get_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4));
      rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags);
      break;
 
   case RPC_DB_GET_LINK_DATA:
      status = db_get_link_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4));
      rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags);
      break;
 
   case RPC_DB_GET_DATA1:
      status = db_get_data1(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CDWORD(4), CPINT(5));
      rpc_convert_data(CARRAY(2), CDWORD(4), RPC_FIXARRAY | RPC_OUTGOING, CINT(3), convert_flags);
      break;
 
   case RPC_DB_GET_DATA_INDEX:
      status = db_get_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CINT(4), CDWORD(5));
      rpc_convert_single(CARRAY(2), CDWORD(5), RPC_OUTGOING, convert_flags);
      break;
 
   case RPC_DB_SET_DATA:
      rpc_convert_data(CARRAY(2), CDWORD(5), RPC_FIXARRAY, CINT(3), convert_flags);
      status = db_set_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5));
      break;
 
   case RPC_DB_SET_DATA1:
         rpc_convert_data(CARRAY(2), CDWORD(5), RPC_FIXARRAY, CINT(3), convert_flags);
         status = db_set_data1(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5));
         break;
 
   case RPC_DB_NOTIFY_CLIENTS_ARRAY:
         rpc_convert_data(CARRAY(1), CINT(2), RPC_FIXARRAY, TID_DWORD, convert_flags);
         status = db_notify_clients_array(CHNDLE(0), (HNDLE*)CARRAY(1), CINT(2));
         break;
 
   case RPC_DB_SET_LINK_DATA:
      rpc_convert_data(CARRAY(2), CDWORD(5), RPC_FIXARRAY, CINT(3), convert_flags);
      status = db_set_link_data(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5));
      break;
 
   case RPC_DB_SET_DATA_INDEX:
      rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags);
      status = db_set_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5));
      break;
 
   case RPC_DB_SET_LINK_DATA_INDEX:
      rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags);
      status = db_set_link_data_index(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5));
      break;
 
   case RPC_DB_SET_DATA_INDEX1:
      rpc_convert_single(CARRAY(2), CDWORD(5), 0, convert_flags);
      status = db_set_data_index1(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4), CDWORD(5), CBOOL(6));
      break;
 
   case RPC_DB_SET_NUM_VALUES:
      status = db_set_num_values(CHNDLE(0), CHNDLE(1), CINT(2));
      break;
 
   case RPC_DB_SET_MODE:
      status = db_set_mode(CHNDLE(0), CHNDLE(1), CWORD(2), CBOOL(3));
      break;
 
   case RPC_DB_GET_RECORD:
      status = db_get_record(CHNDLE(0), CHNDLE(1), CARRAY(2), CPINT(3), CINT(4));
      break;
 
   case RPC_DB_SET_RECORD:
      status = db_set_record(CHNDLE(0), CHNDLE(1), CARRAY(2), CINT(3), CINT(4));
      break;
 
   case RPC_DB_GET_RECORD_SIZE:
      status = db_get_record_size(CHNDLE(0), CHNDLE(1), CINT(2), CPINT(3));
      break;
 
   case RPC_DB_CREATE_RECORD:
      status = db_create_record(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3));
      break;
 
   case RPC_DB_CHECK_RECORD:
      status = db_check_record(CHNDLE(0), CHNDLE(1), CSTRING(2), CSTRING(3), CBOOL(4));
      break;
 
   case RPC_DB_ADD_OPEN_RECORD:
      status = db_add_open_record(CHNDLE(0), CHNDLE(1), CWORD(2));
      break;
 
   case RPC_DB_REMOVE_OPEN_RECORD:
      status = db_remove_open_record(CHNDLE(0), CHNDLE(1), CBOOL(2));
      break;
 
   case RPC_DB_LOAD:
      status = db_load(CHNDLE(0), CHNDLE(1), CSTRING(2), CBOOL(3));
      break;
 
   case RPC_DB_SAVE:
      status = db_save(CHNDLE(0), CHNDLE(1), CSTRING(2), CBOOL(3));
      break;
 
   case RPC_DB_SET_CLIENT_NAME:
      status = db_set_client_name(CHNDLE(0), CSTRING(1));
      break;
 
   case RPC_DB_GET_OPEN_RECORDS:
      status = db_get_open_records(CHNDLE(0), CHNDLE(1), CSTRING(2), CINT(3), CBOOL(4));
      break;
 
   case RPC_DB_COPY_XML:
      status = db_copy_xml(CHNDLE(0), CHNDLE(1), CSTRING(2), CPINT(3), CBOOL(4));
      break;
 
   case RPC_EL_SUBMIT:
      status = el_submit(CINT(0), CSTRING(1), CSTRING(2), CSTRING(3), CSTRING(4),
                         CSTRING(5), CSTRING(6), CSTRING(7),
                         CSTRING(8), (char*)CARRAY(9), CINT(10),
                         CSTRING(11), (char*)CARRAY(12), CINT(13),
                         CSTRING(14), (char*)CARRAY(15), CINT(16), CSTRING(17), CINT(18));
      break;
 
   case RPC_AL_CHECK:
      status = al_check();
      break;
 
   case RPC_AL_TRIGGER_ALARM:
      status = al_trigger_alarm(CSTRING(0), CSTRING(1), CSTRING(2), CSTRING(3), CINT(4));
      break;
 
      /* exit functions */
   case RPC_ID_EXIT:
      //printf("RPC_ID_EXIT!\n");
      status = RPC_SUCCESS;
      break;
 
   case RPC_ID_SHUTDOWN:
      status = RPC_SUCCESS;
      break;
 
      /* various functions */
 
   case RPC_TEST:
      status = rpc_test(CBYTE(0), CWORD(1), CINT(2), CFLOAT(3), CDOUBLE(4),
                        CPBYTE(5), CPWORD(6), CPINT(7), CPFLOAT(8), CPDOUBLE(9));
      break;
 
   case RPC_TEST2: {
 
      status = RPC_SUCCESS;
 
      if (CINT(0) != 123) {
         cm_msg(MERROR, "rpc_test2", "CINT(0) mismatch");
         status = 0;
      }
 
      CINT(1) = 789;
 
      if (CINT(2) != 456) {
         cm_msg(MERROR, "rpc_test2", "CINT(2) mismatch");
         status = 0;
      }
      
      CINT(2) = 2*CINT(2);
 
      if (strcmp(CSTRING(3), "test string") != 0) {
         cm_msg(MERROR, "rpc_test2", "CSTRING(3) mismatch");
         status = 0;
      }
 
      if (CINT(5) != 32) {
         cm_msg(MERROR, "rpc_test2", "CINT(5) string_out size mismatch");
         status = 0;
      }
 
      strcpy(CSTRING(4), "string_out");
 
      if (CINT(7) != 48) {
         cm_msg(MERROR, "rpc_test2", "CINT(7) string2_out size mismatch");
         status = 0;
      }
 
      strcpy(CSTRING(6), "second string_out");
 
      if (CINT(9) != 25) {
         cm_msg(MERROR, "rpc_test2", "CINT(9) string_inout size mismatch");
         status = 0;
      }
 
      if (strcmp(CSTRING(8), "string_inout") != 0) {
         cm_msg(MERROR, "rpc_test2", "CSTRING(8) mismatch");
         status = 0;
      }
 
      strcpy(CSTRING(8), "return string_inout");
 
      // 10, 11, 12 is TID_STRUCT of type KEY
 
      KEY *pkey;
 
      pkey = (KEY*)CARRAY(10);
 
      if (pkey->type != 111 || pkey->num_values != 222 || strcmp(pkey->name, "name") || pkey->last_written != 333) {
         printf("CKEY(10): type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
 
         cm_msg(MERROR, "rpc_test2", "CARRAY(10) KEY mismatch");
         status = 0;
      }
 
      pkey = (KEY*)CARRAY(11);
 
      pkey->type = 444;
      pkey->num_values = 555;
      strcpy(pkey->name, "out_name");
      pkey->last_written = 666;
 
      //printf("CKEY(11): type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
 
      pkey = (KEY*)CARRAY(12);
 
      if (pkey->type != 111111 || pkey->num_values != 222222 || strcmp(pkey->name, "name_name") || pkey->last_written != 333333) {
         printf("CKEY(10): type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
 
         cm_msg(MERROR, "rpc_test2", "CARRAY(12) KEY mismatch");
         status = 0;
      }
 
      pkey->type = 444444;
      pkey->num_values = 555555;
      strcpy(pkey->name, "inout_name");
      pkey->last_written = 666666;
 
      //printf("CKEY(10): type %d, num_values %d, name [%s], last_written %d\n", pkey->type, pkey->num_values, pkey->name, pkey->last_written);
 
      if (CINT(14) != 40) {
         cm_msg(MERROR, "rpc_test2", "CINT(14) array_in size mismatch");
         status = 0;
      } else {
         //printf("CARRAY(13): %p, 0x%08x [%s]\n", CARRAY(9), *(uint32_t*)CARRAY(9), (char*)CARRAY(9));
 
         uint32_t size = CINT(14)/4;
         for (uint32_t i=0; i<size; i++) {
            if (((uint32_t*)CARRAY(13))[i] != i*10) {
               cm_msg(MERROR, "rpc_test2", "CARRAY(13) dwordarray_inout mismatch at %d, %d vs %d", i, ((uint32_t*)CARRAY(13))[i], i*10);
               status = 0;
            }
         }
      }
 
      for (int i=0; i<5; i++) {
         ((uint32_t*)CARRAY(13))[i] = i*10 + i;
      }
 
      CINT(14) = 20;
      
      if (CINT(16) != 10) {
         cm_msg(MERROR, "rpc_test2", "CINT(16) array_in size mismatch");
         status = 0;
      } else {
         //printf("CARRAY(15): %p, 0x%08x [%s]\n", CARRAY(15), *(uint32_t*)CARRAY(15), (char*)CARRAY(15));
 
         for (int i=0; i<CINT(16); i++) {
            if (((char*)CARRAY(15))[i] != 'a'+i) {
               cm_msg(MERROR, "rpc_test2", "CARRAY(15) array_in data mismatch at %d, %d vs %d", i, ((char*)CARRAY(15))[i], 'a'+i);
               status = 0;
            }
         }
      }
 
      if (CINT(18) != 16) {
         cm_msg(MERROR, "rpc_test2", "CINT(14) array_out size mismatch");
         status = 0;
      }
 
      break;
   }
 
   default:
      cm_msg(MERROR, "rpc_server_dispatch", "received unrecognized command %d", index);
      status = RPC_INVALID_ID;
   }
 
   return status;
}

Here is the caller graph for this function:

rpc_test()

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 399 of file mserver.cxx.

{
   printf("rpc_test: %d %d %d %1.1f %1.1lf\n", b, w, i, f, d);
 
   *b1 = b * 2;
   *w1 = w * 2;
   *i1 = i * 2;
   *f1 = f * 2;
   *d1 = d * 2;
 
   return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

callback

struct callback_addr callback

Definition at line 22 of file mserver.cxx.

use_callback_addr

BOOL use_callback_addr = TRUE

Definition at line 24 of file mserver.cxx.