[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 and 1.1.1.1.2.6

version 1.1.1.1, 2010/06/18 01:48:06 version 1.1.1.1.2.6, 2010/07/08 09:18:51
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;
   
        if (!srv || !call) {        RPC_CALLBACK_CHECK_INPUT(call);
                rpc_SetErr(EINVAL, "Error:: invalid parameters ...\n");        if (!call->func_parent)
                 return -1;                  return -1;
         }  
         if (rpc_srv_declValsCall(call, srv->srv_numcli) == -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 44  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];
   
        if (!srv || !call) {        RPC_CALLBACK_CHECK_INPUT(call);
                rpc_SetErr(EINVAL, "Error:: invalid parameters ...\n");        if (!call->func_parent)
                 return -1;                  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 87  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;
   
        if (!srv || !call) {        RPC_CALLBACK_CHECK_INPUT(call);
                rpc_SetErr(EINVAL, "Error:: invalid parameters ...\n");        if (!call->func_parent)
                 return -1;                  return -1;
        }        else
                 srv = call->func_parent;
   
        if (rpc_srv_declValsCall(call, 4) == -1)        if (!(vals = rpc_srv_retValsCall(call, 4)))
                 return -1;                  return -1;
         else  
                 rpc_srv_delValsCall(call);  
         if (rpc_srv_getValsCall(call, &vals) == -1)  
                 return -1;  
   
         RPC_SET_U8(&vals[0], srv->srv_session.sess_version);          RPC_SET_U8(&vals[0], srv->srv_session.sess_version);
         RPC_SET_U32(&vals[1], srv->srv_session.sess_program);          RPC_SET_U32(&vals[1], srv->srv_session.sess_program);
         RPC_SET_U32(&vals[2], srv->srv_session.sess_process);          RPC_SET_U32(&vals[2], srv->srv_session.sess_process);
         RPC_SET_I32(&vals[3], srv->srv_numcli);          RPC_SET_I32(&vals[3], srv->srv_numcli);
   
           return 0;
   }
   
   int
   rpcServerShutdown(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_mtx);
           rpc_Kill = 1;
           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 -1;
           }
   
           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_CHECK_INPUT(call);
           RPC_CALLBACK_CHK_RETARGS(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  
changed lines
  Added in v.1.1.1.1.2.6

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