[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.2 and 1.4.2.5

version 1.4.2.2, 2011/08/30 09:07:55 version 1.4.2.5, 2011/09/01 11:39:27
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);                                if (arr)
                                         io_arrayDestroy(&arr);
                                 argc = rpc_srv_getVars(f, &arr);
                                 goto makeReply;         /* Call finish OK */
                         }
 
                 if (arr)
                         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 151  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) {                                rpc_srv_freeVals(f);
                                for (i = 0; i < argc; i++) 
                                        AIT_FREE_VAL(&vals[i]); 
                                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_freeVals(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 506  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 412  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
   
         pthread_mutex_lock(&srv->srv_mtx);          pthread_mutex_lock(&srv->srv_mtx);
         rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);          rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);
        rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0);        rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1);
        rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);        rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1);
         rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);          rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
Line 635  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 541  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
  * @regProgID = ProgramID for authentication & recognition   * @regProgID = ProgramID for authentication & recognition
  * @regProcID = ProcessID for authentication & recognition   * @regProcID = ProcessID for authentication & recognition
  * @concurentClients = Concurent clients at same time to this server   * @concurentClients = Concurent clients at same time to this server
 * @netBuf = Network buffer length, if =0 == BUFSIZ * @netBuf = Network buffer length, if =0 == BUFSIZ (also meaning max RPC packet)
  * @family = Family type, AF_INET, AF_INET6 or AF_LOCAL   * @family = Family type, AF_INET, AF_INET6 or AF_LOCAL
  * @csHost = Host name or address for bind server, if NULL any address   * @csHost = Host name or address for bind server, if NULL any address
  * @Port = Port for bind server, if Port == 0 default port is selected   * @Port = Port for bind server, if Port == 0 default port is selected
Line 768  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 674  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         pthread_mutex_init(&srv->srv_mtx, NULL);          pthread_mutex_init(&srv->srv_mtx, NULL);
   
         rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);          rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);
        rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 1);
        rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);
        rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 1);
         return srv;          return srv;
 }  }
   
Line 893  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 799  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.2  
changed lines
  Added in v.1.4.2.5

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