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

version 1.7.2.4, 2012/05/16 13:52:59 version 1.7.2.8, 2012/05/17 08:45:08
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, int ic, array_t *iv)rpcServerClients(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_cli_t *cli;          rpc_cli_t *cli;
Line 60  rpcServerClients(rpc_func_t *call, int ic, array_t *iv Line 60  rpcServerClients(rpc_func_t *call, int ic, array_t *iv
         ait_val_t v;          ait_val_t v;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         len = io_arraySize(srv->srv_clients) * STRSIZ;          len = io_arraySize(srv->srv_clients) * STRSIZ;
         if (!(val = malloc(len))) {          if (!(val = malloc(len))) {
Line 86  rpcServerClients(rpc_func_t *call, int ic, array_t *iv Line 83  rpcServerClients(rpc_func_t *call, int ic, array_t *iv
                 AIT_FREE_VAL(&v);                  AIT_FREE_VAL(&v);
         }          }
   
        AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), val);        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);
         free(val);          free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerCalls(rpc_func_t *call, int ic, array_t *iv)rpcServerCalls(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_func_t *f;          rpc_func_t *f;
Line 101  rpcServerCalls(rpc_func_t *call, int ic, array_t *iv) Line 98  rpcServerCalls(rpc_func_t *call, int ic, array_t *iv)
         char *val, str[MAXPATHLEN];          char *val, str[MAXPATHLEN];
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         TAILQ_FOREACH(f, &srv->srv_funcs, func_node)          TAILQ_FOREACH(f, &srv->srv_funcs, func_node)
                 i++;                  i++;
Line 120  rpcServerCalls(rpc_func_t *call, int ic, array_t *iv) Line 114  rpcServerCalls(rpc_func_t *call, int ic, array_t *iv)
                 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(%d); ", AIT_KEY(&f->func_name), 
                                        AIT_ADDR(&f->func_name), io_arraySize(f->func_vars));                                        AIT_ADDR(&f->func_name), io_arraySize(RPC_FUNC_RETVARS(f)));
                         strlcat(val, str, len);                          strlcat(val, str, len);
                 }                  }
   
        AIT_SET_STR(io_array(f->func_vars, 0, ait_val_t*), val);        AIT_SET_STR(io_getVars(RPC_FUNC_RETVARS(call), 0), val);
         free(val);          free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerSessions(rpc_func_t *call, int ic, array_t *iv)rpcServerSessions(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         ait_val_t *v;          ait_val_t *v;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
        v = io_array(call->func_vars, 0, ait_val_t*);        v = io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*);
         AIT_SET_U8(v, srv->srv_session.sess_version);          AIT_SET_U8(v, srv->srv_session.sess_version);
        v = io_array(call->func_vars, 1, ait_val_t*);        v = io_array(RPC_FUNC_RETVARS(call), 1, ait_val_t*);
         AIT_SET_U32(v, srv->srv_session.sess_program);          AIT_SET_U32(v, srv->srv_session.sess_program);
        v = io_array(call->func_vars, 2, ait_val_t*);        v = io_array(RPC_FUNC_RETVARS(call), 2, ait_val_t*);
         AIT_SET_U8(v, srv->srv_session.sess_process);          AIT_SET_U8(v, srv->srv_session.sess_process);
        v = io_array(call->func_vars, 3, ait_val_t*);        v = io_array(RPC_FUNC_RETVARS(call), 3, ait_val_t*);
         AIT_SET_I32(v, io_arraySize(srv->srv_clients));          AIT_SET_I32(v, io_arraySize(srv->srv_clients));
   
         return 0;          return 0;
 }  }
   
 static int  static int
rpcServerShutdown(rpc_func_t *call, int ic, array_t *iv)rpcServerShutdown(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         srv->srv_kill = 1;          srv->srv_kill = 1;
   
         return 0;          return 0;
 }  }
   
   static int
   rpcServerPing(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
   {
           if (rpc->call_req.flags == RPC_REPLY)
                   AIT_SET_U16(io_getVars(RPC_FUNC_RETVARS(call), 0), ntohs(rpc->call_seq));
   
           return 0;
   }
   
 /* ---------------------------------------------------- */  /* ---------------------------------------------------- */
   
 static int  static int
rpcBLOBServerShutdown(rpc_func_t *call, int ic, array_t *iv)rpcBLOBServerShutdown(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         srv->srv_blob.kill = 1;          srv->srv_blob.kill = 1;
   
Line 188  rpcBLOBServerShutdown(rpc_func_t *call, int ic, array_ Line 182  rpcBLOBServerShutdown(rpc_func_t *call, int ic, array_
 }  }
   
 static int  static int
rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *iv)rpcBLOBServerVars(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_blob_t *b;          rpc_blob_t *b;
Line 197  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i Line 191  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i
         int len;          int len;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         if (srv->srv_blob.kill) {          if (srv->srv_blob.kill) {
                AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), "BLOB Server is killed");                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");
                 return 1;                  return 1;
         }          }
   
Line 212  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i Line 203  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i
         len = i * sizeof str;          len = i * sizeof str;
   
         if (!len) {          if (!len) {
                AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), "");                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "");
                 return 0;                  return 0;
         }          }
   
Line 228  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i Line 219  rpcBLOBServerVars(rpc_func_t *call, int ic, array_t *i
                 strlcat(val, str, len);                  strlcat(val, str, len);
         }          }
   
        AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), val);        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);
         free(val);          free(val);
         return 0;          return 0;
 }  }
   
 static int  static int
rpcBLOBServerClients(rpc_func_t *call, int ic, array_t *iv)rpcBLOBServerClients(rpc_func_t *call, struct tagRPCCall *rpc, array_t *iv)
 {  {
         rpc_srv_t *srv;          rpc_srv_t *srv;
         rpc_cli_t *cli;          rpc_cli_t *cli;
Line 245  rpcBLOBServerClients(rpc_func_t *call, int ic, array_t Line 236  rpcBLOBServerClients(rpc_func_t *call, int ic, array_t
         ait_val_t v;          ait_val_t v;
   
         RPC_CALLBACK_CHECK_INPUT(call);          RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)        srv = RPC_FUNC_SERVER(call);
                return -1; 
        else 
                srv = call->func_parent; 
   
         if (srv->srv_blob.kill) {          if (srv->srv_blob.kill) {
                AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), "BLOB Server is killed");                AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), "BLOB Server is killed");
                 return 1;                  return 1;
         }          }
   
Line 276  rpcBLOBServerClients(rpc_func_t *call, int ic, array_t Line 264  rpcBLOBServerClients(rpc_func_t *call, int ic, array_t
                 AIT_FREE_VAL(&v);                  AIT_FREE_VAL(&v);
         }          }
   
        AIT_SET_STR(io_array(call->func_vars, 0, ait_val_t*), val);        AIT_SET_STR(io_array(RPC_FUNC_RETVARS(call), 0, ait_val_t*), val);
         free(val);          free(val);
         return 0;          return 0;
 }  }
   
 /* ----------------------------------------------------------------- */  /* ----------------------------------------------------------------- */
   
   /*
    * rpc_register_srvPing() - Register ping service function
    *
    * @srv = RPC server instance
    * return: -1 error or 0 ok
    */
   inline int
   rpc_register_srvPing(rpc_srv_t * __restrict srv)
   {
           if (!srv)
                   return -1;
   
           if (rpc_srv_registerCall(srv, CALL_SRVPING, rpcServerPing, 1) < 1)
                   return -1;
   
           return 0;
   }
   
 /*  /*
  * rpc_register_srvServices() - Register internal service functions   * rpc_register_srvServices() - Register internal service functions

Removed from v.1.7.2.4  
changed lines
  Added in v.1.7.2.8


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