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

Diff for /libaitrpc/src/srv.c between versions 1.4.2.3 and 1.4.2.4

version 1.4.2.3, 2011/08/30 11:13:29 version 1.4.2.4, 2011/08/31 17:11:58
Line 51  rpc_srv_dispatchCall(void *arg) Line 51  rpc_srv_dispatchCall(void *arg)
 {  {
         rpc_cli_t *c = arg;          rpc_cli_t *c = arg;
         rpc_srv_t *s;          rpc_srv_t *s;
         ait_val_t *vals = NULL, *v = NULL;  
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
           array_t *arr;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         struct tagRPCRet *rrpc;          struct tagRPCRet *rrpc;
         rpc_sess_t ses = { 0 };          rpc_sess_t ses = { 0 };
         fd_set fds;          fd_set fds;
        u_char *buf, *data;        u_char *buf;
         int ret, argc = 0, Limit = 0;          int ret, argc = 0, Limit = 0;
         register int i;          register int i;
   
Line 74  rpc_srv_dispatchCall(void *arg) Line 74  rpc_srv_dispatchCall(void *arg)
         }          }
   
         do {          do {
                 v = NULL;  
                 FD_ZERO(&fds);                  FD_ZERO(&fds);
                 FD_SET(c->cli_sock, &fds);                  FD_SET(c->cli_sock, &fds);
                 ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL);                  ret = select(c->cli_sock + 1, &fds, NULL, NULL, NULL);
Line 113  rpc_srv_dispatchCall(void *arg) Line 112  rpc_srv_dispatchCall(void *arg)
   
                 /* RPC is OK! Go decapsulate variables ... */                  /* RPC is OK! Go decapsulate variables ... */
                 if (rpc->call_argc) {                  if (rpc->call_argc) {
                        v = (ait_val_t*) (buf + Limit);                        arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, rpc->call_argc, 1);
                        if (rpc->call_argc * sizeof(ait_val_t) > s->srv_netbuf - Limit) {                        if (!arr) {
                                rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n"); 
                                 ret = -5;                                  ret = -5;
                                 goto makeReply;                                  goto makeReply;
                         } else  
                                 Limit += rpc->call_argc * sizeof(ait_val_t);  
   
                         /* RPC received variables types are OK! */  
                         data = (u_char*) v + rpc->call_argc * sizeof(ait_val_t);  
                         for (i = 0; i < rpc->call_argc; i++) {  
                                 switch (AIT_TYPE(&v[i])) {  
                                         case buffer:  
                                                 if (AIT_LEN(&v[i]) > s->srv_netbuf - Limit) {  
                                                         rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 } else  
                                                         Limit += AIT_LEN(&v[i]);  
   
                                                 v[i].val.buffer = data;  
                                                 data += AIT_LEN(&v[i]);  
                                                 break;  
                                         case string:  
                                                 if (AIT_LEN(&v[i]) > s->srv_netbuf - Limit) {  
                                                         rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 } else  
                                                         Limit += AIT_LEN(&v[i]);  
   
                                                 v[i].val.string = (int8_t*) data;  
                                                 data += AIT_LEN(&v[i]);  
                                                 break;  
                                         case blob:  
                                                 if (s->srv_blob.state == disable) {  
                                                         rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 }  
                                                 if (s->srv_blob.state == kill) {  
                                                         rpc_SetErr(ENOTSUP, "Error:: BLOB server is gone.\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 }  
                                         default:  
                                                 break;  
                                 }  
   
                                 AIT_ADDZCOPY(&v[i]);  
                         }                          }
                 }                  }
   
                 /* execute call */                  /* execute call */
                 argc = 0;                  argc = 0;
                 vals = NULL;  
                 memcpy(&ses, &rpc->call_session, sizeof ses);                  memcpy(&ses, &rpc->call_session, sizeof ses);
                 if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) {                  if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) {
                         rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n");                          rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n");
                         ret = -6;                          ret = -6;
                 } else                  } else
                        if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)                        if ((ret = rpc_srv_execCall(f, rpc, arr)) == -1)
                                 ret = -9;                                  ret = -9;
                        else                        else {
                                argc = rpc_srv_getVars(f, &vals);                                io_arrayDestroy(&arr);
                                 argc = rpc_srv_getVars(f, &arr);
                                 goto makeReply;         /* Call finish OK */
                         }
 
                 io_arrayDestroy(&arr);
 
 makeReply:  makeReply:
                /* made reply */                /* Made reply */
                 memset(buf, 0, s->srv_netbuf);                  memset(buf, 0, s->srv_netbuf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
Line 191  makeReply: Line 149  makeReply:
                 rrpc->ret_retcode = ret;                  rrpc->ret_retcode = ret;
                 rrpc->ret_argc = argc;                  rrpc->ret_argc = argc;
   
                if (argc && vals) {                if (argc && arr) {
                         /* Go Encapsulate variables ... */                          /* Go Encapsulate variables ... */
                        v = (ait_val_t*) (buf + Limit);                        if ((i = io_vals2buffer(buf + Limit, s->srv_netbuf - Limit, arr)) == -1) {
                        if (argc * sizeof(ait_val_t) > s->srv_netbuf - Limit) { 
                                for (i = 0; i < argc; i++) 
                                        AIT_FREE_VAL(&vals[i]); 
                                 rpc_srv_freeVars(f);                                  rpc_srv_freeVars(f);
                                 vals = NULL;  
                                 argc = 0;                                  argc = 0;
                                 ret = -7;                                  ret = -7;
                                 rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n");                                  rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n");
                                 goto makeReply;                                  goto makeReply;
                        } else                        } else {
                                Limit += argc * sizeof(ait_val_t);                                Limit += i;
                        memcpy(v, vals, argc * sizeof(ait_val_t)); 
   
                        /* RPC send variables types are OK! */                                rpc_srv_freeVars(f);
                        data = (u_char*) v + argc * sizeof(ait_val_t); 
                        for (ret = i = 0; i < argc; i++) { 
                                switch (AIT_TYPE(&vals[i])) { 
                                        case buffer: 
                                                if (ret || Limit + vals[i].val_len > s->srv_netbuf) { 
                                                        rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); 
                                                        rrpc->ret_retcode = ret = -7; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
 
                                                memcpy(data, vals[i].val.buffer, vals[i].val_len); 
                                                data += AIT_LEN(&vals[i]); 
                                                Limit += AIT_LEN(&vals[i]); 
                                                break; 
                                        case string: 
                                                if (ret || Limit + vals[i].val_len > s->srv_netbuf) { 
                                                        rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); 
                                                        rrpc->ret_retcode = ret = -7; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
 
                                                memcpy(data, vals[i].val.string, vals[i].val_len); 
                                                data += AIT_LEN(&vals[i]); 
                                                Limit += AIT_LEN(&vals[i]); 
                                                break; 
                                        case blob: 
                                                if (s->srv_blob.state == disable) { 
                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n"); 
                                                        rrpc->ret_retcode = ret = -5; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
                                                if (s->srv_blob.state == kill) { 
                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is gone.\n"); 
                                                        rrpc->ret_retcode = ret = -5; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
                                        default: 
                                                break; 
                                } 
 
                                /* don't add zero copy at this position, because buffer/string must be freed! */ 
                                AIT_FREE_VAL(&vals[i]); 
                         }                          }
                         rpc_srv_freeVars(f);  
                         vals = NULL;  
                         argc = 0;  
                 }                  }
   
                 ret = send(c->cli_sock, buf, Limit, 0);                  ret = send(c->cli_sock, buf, Limit, 0);
Line 893  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 797  rpc_srv_execServer(rpc_srv_t * __restrict srv)
  * rpc_srv_execCall() Execute registered call from RPC server   * rpc_srv_execCall() Execute registered call from RPC server
  * @call = Register RPC call   * @call = Register RPC call
  * @rpc = IN RPC call structure   * @rpc = IN RPC call structure
 * @args = IN RPC call array of rpc values * @args = IN RPC calling arguments from RPC client
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
 int  int
 rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc,   rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, 
                ait_val_t * __restrict args)                array_t * __restrict args)
 {  {
         void *dl;          void *dl;
         rpc_callback_t func;          rpc_callback_t func;
Removed from v.1.4.2.3  
changed lines
  Added in v.1.4.2.4

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