[BACK]Return to builtin.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

Diff for /libaitrpc/src/builtin.c between versions 1.7.2.8 and 1.23

version 1.7.2.8, 2012/05/17 08:45:08 version 1.23, 2015/07/22 20:01:46
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012Copyright 2004 - 2015
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
 /* builtin RPC server functions */  /* builtin RPC server functions */
   
 static int  static int
rpcServerClients(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcServerClients(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
        rpc_cli_t *cli;        rpc_cli_t *c;
         register int i;          register int i;
         int len;          int len;
         const char *str = NULL;          const char *str = NULL;
         char *val;          char *val;
         ait_val_t v;          ait_val_t v;
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
        len = io_arraySize(srv->srv_clients) * STRSIZ;        len = array_Size(srv->srv_clients) * STRSIZ;
        if (!(val = malloc(len))) {        if (!(val = e_malloc(len))) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(val, 0, len);                  memset(val, 0, len);
   
        for (i = 0; i < io_arraySize(srv->srv_clients); i++) {        for (i = 0; i < array_Size(srv->srv_clients); i++) {
                cli = io_array(srv->srv_clients, i, rpc_cli_t*);                c = array(srv->srv_clients, i, rpc_cli_t*);
                if (!cli)                if (!c)
                         continue;                          continue;
   
                str = io_n2addr(&cli->cli_sa, &v);                str = e_n2addr(&c->cli_sa, &v);
                 if (str)                  if (str)
                         strlcat(val, (char*) str, len);                          strlcat(val, (char*) str, len);
                 else                  else
Line 83  rpcServerClients(rpc_func_t *call, struct tagRPCCall * Line 83  rpcServerClients(rpc_func_t *call, struct tagRPCCall *
                 AIT_FREE_VAL(&v);                  AIT_FREE_VAL(&v);
         }          }
   
        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);        /* return values */
        free(val);        AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
         e_free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerCalls(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcServerCalls(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_func_t *f;          rpc_func_t *f;
Line 97  rpcServerCalls(rpc_func_t *call, struct tagRPCCall *rp Line 98  rpcServerCalls(rpc_func_t *call, struct tagRPCCall *rp
         int len;          int len;
         char *val, str[MAXPATHLEN];          char *val, str[MAXPATHLEN];
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
        TAILQ_FOREACH(f, &srv->srv_funcs, func_node)        SLIST_FOREACH(f, &srv->srv_funcs, func_next)
                 i++;                  i++;
         len = i * STRSIZ;          len = i * STRSIZ;
   
        if (!(val = malloc(len))) {        if (!(val = e_malloc(len))) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(val, 0, len);                  memset(val, 0, len);
   
        TAILQ_FOREACH(f, &srv->srv_funcs, func_node)        SLIST_FOREACH(f, &srv->srv_funcs, func_next)
                 if (AIT_ADDR(&f->func_name)) {                  if (AIT_ADDR(&f->func_name)) {
                         memset(str, 0, sizeof str);                          memset(str, 0, sizeof str);
                        snprintf(str, sizeof str, "/%hu/0x%p(%d); ", AIT_KEY(&f->func_name),                         snprintf(str, sizeof str, "/%hu/0x%p; ", AIT_KEY(&f->func_name), 
                                        AIT_ADDR(&f->func_name), io_arraySize(RPC_FUNC_RETVARS(f)));                                        AIT_ADDR(&f->func_name));
                         strlcat(val, str, len);                          strlcat(val, str, len);
                 }                  }
   
        AIT_SET_STR(io_getVars(RPC_FUNC_RETVARS(call), 0), val);        /* return variables */
        free(val);        AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
         e_free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerSessions(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcServerSessions(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         ait_val_t *v;  
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
        v = io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*);        AIT_SET_I32(ait_getVars(&RPC_RETVARS(cli), 2), array_Size(srv->srv_clients));
        AIT_SET_U8(v, srv->srv_session.sess_version);        AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 0), srv->srv_session.sess_version);
        v = io_array(RPC_FUNC_RETVARS(call), 1, ait_val_t*);        AIT_SET_U8(ait_getVars(&RPC_RETVARS(cli), 1), srv->srv_session.sess_instance);
        AIT_SET_U32(v, srv->srv_session.sess_program); 
        v = io_array(RPC_FUNC_RETVARS(call), 2, ait_val_t*); 
        AIT_SET_U8(v, srv->srv_session.sess_process); 
        v = io_array(RPC_FUNC_RETVARS(call), 3, ait_val_t*); 
        AIT_SET_I32(v, io_arraySize(srv->srv_clients)); 
   
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerShutdown(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcServerShutdown(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
        
         srv->srv_blob.kill = 1;
         if (srv->srv_blob.tid)
                 pthread_kill(srv->srv_blob.tid, SIGFBLOB);
         srv->srv_kill = 1;          srv->srv_kill = 1;
   
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerPing(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcServerPing(RPC_CALL_STDARGS)
 {  {
        if (rpc->call_req.flags == RPC_REPLY)        if (ntohl((u_long) rpc->call_req.flags) == RPC_REPLY)
                AIT_SET_U16(io_getVars(RPC_FUNC_RETVARS(call), 0), ntohs(rpc->call_seq));                AIT_SET_U16(ait_getVars(&RPC_RETVARS(cli), 0), random() % USHRT_MAX);
 
         return 0;          return 0;
 }  }
   
 /* ---------------------------------------------------- */  /* ---------------------------------------------------- */
   
 static int  static int
rpcBLOBServerShutdown(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcBLOBServerShutdown(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
        srv->srv_blob.kill = 1;        rpc_freeBLOBCli(cli);
   
           srv->srv_blob.kill = 1;
         return 0;          return 0;
 }  }
   
 static int  static int
rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcBLOBServerVars(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_blob_t *b;          rpc_blob_t *b;
Line 190  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall  Line 188  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall 
         char *val, str[64];          char *val, str[64];
         int len;          int len;
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
         if (srv->srv_blob.kill) {          if (srv->srv_blob.kill) {
                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");                AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
                 return 1;                  return 1;
         }          }
   
Line 203  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall  Line 201  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall 
         len = i * sizeof str;          len = i * sizeof str;
   
         if (!len) {          if (!len) {
                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "");                AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "");
                 return 0;                  return 0;
         }          }
   
        if (!(val = malloc(len))) {        if (!(val = e_malloc(len))) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
Line 219  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall  Line 217  rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall 
                 strlcat(val, str, len);                  strlcat(val, str, len);
         }          }
   
        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);        AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
        free(val);        e_free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)rpcBLOBServerClients(RPC_CALL_STDARGS)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
        rpc_cli_t *cli;        rpc_cli_t *c;
         register int i;          register int i;
         int len;          int len;
         const char *str = NULL;          const char *str = NULL;
         char *val;          char *val;
         ait_val_t v;          ait_val_t v;
   
        RPC_CALLBACK_CHECK_INPUT(call);        RPC_CALLBACK_CHECK_INPUT(cli);
        srv = RPC_FUNC_SERVER(call);        srv = RPC_SRV_SERVER(cli);
   
         if (srv->srv_blob.kill) {          if (srv->srv_blob.kill) {
                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");                AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), "BLOB Server is killed");
                 return 1;                  return 1;
         }          }
   
        len = io_arraySize(srv->srv_blob.clients) * STRSIZ;        len = array_Size(srv->srv_blob.clients) * STRSIZ;
        if (!(val = malloc(len))) {        if (!(val = e_malloc(len))) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
         } else          } else
                 memset(val, 0, len);                  memset(val, 0, len);
   
        for (i = 0; i < io_arraySize(srv->srv_clients); i++) {        for (i = 0; i < array_Size(srv->srv_clients); i++) {
                cli = io_array(srv->srv_blob.clients, i, rpc_cli_t*);                c = array(srv->srv_blob.clients, i, rpc_cli_t*);
                if (!cli)                if (!c)
                         continue;                          continue;
   
                str = io_n2addr(&cli->cli_sa, &v);                str = e_n2addr(&c->cli_sa, &v);
                 if (str)                  if (str)
                         strlcat(val, (char*) str, len);                          strlcat(val, (char*) str, len);
                 else                  else
Line 264  rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCa Line 262  rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCa
                 AIT_FREE_VAL(&v);                  AIT_FREE_VAL(&v);
         }          }
   
        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);        AIT_SET_STR(ait_getVars(&RPC_RETVARS(cli), 0), val);
        free(val);        e_free(val);
         return 0;          return 0;
 }  }
   
Line 277  rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCa Line 275  rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCa
  * @srv = RPC server instance   * @srv = RPC server instance
  * return: -1 error or 0 ok   * return: -1 error or 0 ok
  */   */
inline intint
 rpc_register_srvPing(rpc_srv_t * __restrict srv)  rpc_register_srvPing(rpc_srv_t * __restrict srv)
 {  {
         if (!srv)          if (!srv)
                 return -1;                  return -1;
   
        if (rpc_srv_registerCall(srv, CALL_SRVPING, rpcServerPing, 1) < 1)        if (rpc_srv_registerCall(srv, CALL_SRVPING, rpcServerPing) < 1)
                 return -1;                  return -1;
   
         return 0;          return 0;
Line 301  rpc_register_srvServices(rpc_srv_t * __restrict srv) Line 299  rpc_register_srvServices(rpc_srv_t * __restrict srv)
         if (!srv)          if (!srv)
                 return -1;                  return -1;
   
        if (rpc_srv_registerCall(srv, CALL_SRVSHUTDOWN, rpcServerShutdown, 0) < 1)        if (rpc_srv_registerCall(srv, CALL_SRVSHUTDOWN, rpcServerShutdown) < 1)
                 return -1;                  return -1;
        if (rpc_srv_registerCall(srv, CALL_SRVCLIENTS, rpcServerClients, 1) < 1)        if (rpc_srv_registerCall(srv, CALL_SRVCLIENTS, rpcServerClients) < 1)
                 return -1;                  return -1;
        if (rpc_srv_registerCall(srv, CALL_SRVSESSIONS, rpcServerSessions, 4) < 1)        if (rpc_srv_registerCall(srv, CALL_SRVSESSIONS, rpcServerSessions) < 1)
                 return -1;                  return -1;
        if (rpc_srv_registerCall(srv, CALL_SRVCALLS, rpcServerCalls, 1) < 1)        if (rpc_srv_registerCall(srv, CALL_SRVCALLS, rpcServerCalls) < 1)
                 return -1;                  return -1;
   
         return 0;          return 0;
Line 325  rpc_register_blobServices(rpc_srv_t * __restrict srv) Line 323  rpc_register_blobServices(rpc_srv_t * __restrict srv)
         if (!srv)          if (!srv)
                 return -1;                  return -1;
   
        if (rpc_srv_registerCall(srv, CALL_BLOBSHUTDOWN, rpcBLOBServerShutdown, 0) < 1)        if (rpc_srv_registerCall(srv, CALL_BLOBSHUTDOWN, rpcBLOBServerShutdown) < 1)
                 return -1;                  return -1;
        if (rpc_srv_registerCall(srv, CALL_BLOBCLIENTS, rpcBLOBServerClients, 1) < 1)        if (rpc_srv_registerCall(srv, CALL_BLOBCLIENTS, rpcBLOBServerClients) < 1)
                 return -1;                  return -1;
        if (rpc_srv_registerCall(srv, CALL_BLOBVARS, rpcBLOBServerVars, 1) < 1)        if (rpc_srv_registerCall(srv, CALL_BLOBVARS, rpcBLOBServerVars) < 1)
                 return -1;                  return -1;
   
         return 0;          return 0;
Removed from v.1.7.2.8  
changed lines
  Added in v.1.23

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>