[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.1.1.1.2.1 and 1.1.1.1.2.8

version 1.1.1.1.2.1, 2010/06/18 13:36:01 version 1.1.1.1.2.8, 2011/03/15 15:46:58
Line 12 Line 12
 /* builtin RPC server functions */  /* builtin RPC server functions */
   
 int  int
rpcServerClients(rpc_srv_t * __restrict srv, rpc_func_t *call, int ic, rpc_val_t *iv)rpcServerClients(rpc_func_t *call, int ic, rpc_val_t *iv)
 {  {
        rpc_val_t *v, *vals = NULL;        rpc_srv_t *srv;
         rpc_val_t *v, *vals;
         rpc_cli_t *cli;          rpc_cli_t *cli;
         register int i;          register int i;
         const char *str;          const char *str;
Line 22  rpcServerClients(rpc_srv_t * __restrict srv, rpc_func_ Line 23  rpcServerClients(rpc_srv_t * __restrict srv, rpc_func_
         struct sockaddr_in *s;          struct sockaddr_in *s;
         struct sockaddr_in6 *s6;          struct sockaddr_in6 *s6;
   
        RPC_CALLBACK_CHECK_INPUT(srv, call);        RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)
        if (rpc_srv_declValsCall(call, srv->srv_numcli) == -1) 
                 return -1;                  return -1;
         else          else
                rpc_srv_delValsCall(call);                srv = call->func_parent;
        if (rpc_srv_getValsCall(call, &vals) == -1)
         if (!(vals = rpc_srv_retValsCall(call, srv->srv_numcli)))
                 return -1;                  return -1;
   
        for (i = 0, cli = srv->srv_clients, v = vals; i < srv->srv_numcli; cli++) {        for (i = 0, cli = srv->srv_clients, v = vals; i < srv->srv_numcli; i++, cli++) {
                if (!cli->cli_sa.sa_family)                if (!cli->cli_sa.sa_family) {
                         RPC_SET_STR(v++, "");
                         continue;                          continue;
                   }
   
                 if (AF_INET == cli->cli_sa.sa_family) {                  if (AF_INET == cli->cli_sa.sa_family) {
                         s = (struct sockaddr_in*) &cli->cli_sa;                          s = (struct sockaddr_in*) &cli->cli_sa;
Line 42  rpcServerClients(rpc_srv_t * __restrict srv, rpc_func_ Line 45  rpcServerClients(rpc_srv_t * __restrict srv, rpc_func_
                         s6 = (struct sockaddr_in6*) &cli->cli_sa;                          s6 = (struct sockaddr_in6*) &cli->cli_sa;
                         str = inet_ntop(cli->cli_sa.sa_family, &s6->sin6_addr, wrk, sizeof wrk);                          str = inet_ntop(cli->cli_sa.sa_family, &s6->sin6_addr, wrk, sizeof wrk);
                 }                  }
                if (str) {                if (str)
                         RPC_SET_STR(v++, (char*) str);                          RPC_SET_STR(v++, (char*) str);
                        i++;                else
                }                        RPC_SET_STR(v++, "0.0.0.0");
         }          }
   
         return 0;          return 0;
 }  }
   
 int  int
rpcServerCalls(rpc_srv_t * __restrict srv, rpc_func_t *call, int ic, rpc_val_t *iv)rpcServerCalls(rpc_func_t *call, int ic, rpc_val_t *iv)
 {  {
        rpc_val_t *v, *vals = NULL;        rpc_srv_t *srv;
         rpc_val_t *v, *vals;
         rpc_func_t *f;          rpc_func_t *f;
         register int i;          register int i;
         char str[MAXPATHLEN];          char str[MAXPATHLEN];
   
        RPC_CALLBACK_CHECK_INPUT(srv, call);        RPC_CALLBACK_CHECK_INPUT(call);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
   
         for (i = 0, f = srv->srv_funcs; f; i++, f = f->func_next);          for (i = 0, f = srv->srv_funcs; f; i++, f = f->func_next);
        if (!(vals = rpc_srv_retValsCall(call, i)))
        if (rpc_srv_declValsCall(call, i) == -1) 
                 return -1;                  return -1;
         else  
                 rpc_srv_delValsCall(call);  
         if (rpc_srv_getValsCall(call, &vals) == -1)  
                 return -1;  
   
         for (f = srv->srv_funcs, v = vals; f; f = f->func_next) {          for (f = srv->srv_funcs, v = vals; f; f = f->func_next) {
                 if (*f->func_name) {                  if (*f->func_name) {
Line 82  rpcServerCalls(rpc_srv_t * __restrict srv, rpc_func_t  Line 85  rpcServerCalls(rpc_srv_t * __restrict srv, rpc_func_t 
 }  }
   
 int  int
rpcServerSessions(rpc_srv_t * __restrict srv, rpc_func_t *call, int ic, rpc_val_t *iv)rpcServerSessions(rpc_func_t *call, int ic, rpc_val_t *iv)
 {  {
        rpc_val_t *vals = NULL;        rpc_srv_t *srv;
         rpc_val_t *vals;
   
        RPC_CALLBACK_CHECK_INPUT(srv, call);        RPC_CALLBACK_CHECK_INPUT(call);
        if (!call->func_parent)
        if (rpc_srv_declValsCall(call, 4) == -1) 
                 return -1;                  return -1;
         else          else
                rpc_srv_delValsCall(call);                srv = call->func_parent;
        if (rpc_srv_getValsCall(call, &vals) == -1)
         if (!(vals = rpc_srv_retValsCall(call, 4)))
                 return -1;                  return -1;
   
         RPC_SET_U8(&vals[0], srv->srv_session.sess_version);          RPC_SET_U8(&vals[0], srv->srv_session.sess_version);
Line 104  rpcServerSessions(rpc_srv_t * __restrict srv, rpc_func Line 108  rpcServerSessions(rpc_srv_t * __restrict srv, rpc_func
 }  }
   
 int  int
rpcServerShutdown(rpc_srv_t * __restrict srv, rpc_func_t *call, int ic, rpc_val_t *iv)rpcServerShutdown(rpc_func_t *call, int ic, rpc_val_t *iv)
 {  {
        RPC_CALLBACK_CHECK_INPUT(srv, call);        rpc_srv_t *srv;
   
        pthread_mutex_lock(&rpc_mtx);        RPC_CALLBACK_CHECK_INPUT(call);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
 
         pthread_mutex_lock(&srv->srv_mtx);
         rpc_Kill = 1;          rpc_Kill = 1;
        pthread_mutex_unlock(&rpc_mtx);        pthread_mutex_unlock(&srv->srv_mtx);
 
         return 0;
 }
 
 // ----------------------------------------------------
 
 int
 rpcBLOBServerShutdown(rpc_func_t *call, int ic, rpc_val_t *iv)
 {
         rpc_srv_t *srv;
 
         RPC_CALLBACK_CHECK_INPUT(call);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
 
         pthread_mutex_lock(&srv->srv_blob.mtx);
         blob_Kill = 1;
         pthread_mutex_unlock(&srv->srv_blob.mtx);
 
         return 0;
 }
 
 int
 rpcBLOBServerVars(rpc_func_t *call, int ic, rpc_val_t *iv)
 {
         rpc_srv_t *srv;
         rpc_val_t *v, *vals;
         rpc_blob_t *b;
         register int i;
 
         RPC_CALLBACK_CHECK_INPUT(call);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
 
         pthread_mutex_lock(&srv->srv_blob.mtx);
         for (i = 0, b = srv->srv_blob.blobs; b; i++, b = b->blob_next);
         if (!(vals = rpc_srv_retValsCall(call, i))) {
                 pthread_mutex_unlock(&srv->srv_blob.mtx);
                 return 0;
         }
 
         for (b = srv->srv_blob.blobs, v = vals; b; b = b->blob_next)
                 RPC_SET_U32(v++, b->blob_var);
         pthread_mutex_unlock(&srv->srv_blob.mtx);
 
         return 0;
 }
 
 int
 rpcBLOBServerState(rpc_func_t *call, int ic, rpc_val_t *iv)
 {
         rpc_srv_t *srv;
 
         RPC_CALLBACK_CHK_ARGS(call, ic);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
 
         if (iv[0].val_type != i32)
                 return -1;
 
         srv->srv_blob.state = RPC_GET_I32(&iv[0]);
         return 0;
 }
 
 int
 rpcBLOBServerClients(rpc_func_t *call, int ic, rpc_val_t *iv)
 {
         rpc_srv_t *srv;
         rpc_val_t *v, *vals;
         rpc_cli_t *cli;
         register int i;
         const char *str;
         char wrk[INET6_ADDRSTRLEN];
         struct sockaddr_in *s;
         struct sockaddr_in6 *s6;
 
         RPC_CALLBACK_CHECK_INPUT(call);
         if (!call->func_parent)
                 return -1;
         else
                 srv = call->func_parent;
 
         if (!(vals = rpc_srv_retValsCall(call, srv->srv_numcli)))
                 return -1;
 
         for (i = 0, cli = srv->srv_blob.clients, v = vals; i < srv->srv_numcli; i++, cli++) {
                 if (!cli->cli_sa.sa_family) {
                         RPC_SET_STR(v++, "");
                         continue;
                 }
 
                 if (AF_INET == cli->cli_sa.sa_family) {
                         s = (struct sockaddr_in*) &cli->cli_sa;
                         str = inet_ntop(cli->cli_sa.sa_family, &s->sin_addr, wrk, sizeof wrk);
                 } else {
                         s6 = (struct sockaddr_in6*) &cli->cli_sa;
                         str = inet_ntop(cli->cli_sa.sa_family, &s6->sin6_addr, wrk, sizeof wrk);
                 }
                 if (str)
                         RPC_SET_STR(v++, (char*) str);
                 else
                         RPC_SET_STR(v++, "0.0.0.0");
         }
   
         return 0;          return 0;
 }  }
Removed from v.1.1.1.1.2.1  
changed lines
  Added in v.1.1.1.1.2.8

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