[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.1.1.1.2.10 and 1.1.1.1.2.16

version 1.1.1.1.2.10, 2010/06/24 13:58:17 version 1.1.1.1.2.16, 2010/07/08 07:16:36
Line 14  rpc_srv_dispatchCall(void *arg) Line 14  rpc_srv_dispatchCall(void *arg)
 {  {
         rpc_cli_t *c = arg;          rpc_cli_t *c = arg;
         rpc_srv_t *s;          rpc_srv_t *s;
        rpc_val_t *vals, *v = NULL;        rpc_val_t *vals = NULL, *v = NULL;
         rpc_func_t *f;          rpc_func_t *f;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         struct tagRPCRet rrpc;          struct tagRPCRet rrpc;
         fd_set fds;          fd_set fds;
         u_char buf[BUFSIZ], *data;          u_char buf[BUFSIZ], *data;
        int ret, argc, Limit = 0;        int ret, argc = 0, Limit = 0;
         register int i;          register int i;
   
         if (!arg) {          if (!arg) {
Line 57  rpc_srv_dispatchCall(void *arg) Line 57  rpc_srv_dispatchCall(void *arg)
                 if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) {                  if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) {
                         rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");                          rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");
                         ret = -5;                          ret = -5;
                        break;                        goto makeReply;
                 }                  }
                 // RPC is OK! Go decapsulate variables ...                  // RPC is OK! Go decapsulate variables ...
                 if (rpc->call_argc) {                  if (rpc->call_argc) {
Line 74  rpc_srv_dispatchCall(void *arg) Line 74  rpc_srv_dispatchCall(void *arg)
                                                 v[i].val.string = (int8_t*) data;                                                  v[i].val.string = (int8_t*) data;
                                                 data += v[i].val_len + 1;                                                  data += v[i].val_len + 1;
                                                 break;                                                  break;
                                           case blob:
                                                   if (s->srv_blob.state == disable) {
                                                           rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n");
                                                           ret = -5;
                                                           goto makeReply;
                                                   }
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
Line 86  rpc_srv_dispatchCall(void *arg) Line 92  rpc_srv_dispatchCall(void *arg)
                         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(s, f, rpc, v)) == -1)                        if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)
                                ret = -6;                                ret = -9;
                         else                          else
                                 argc = rpc_srv_getValsCall(f, &vals);                                  argc = rpc_srv_getValsCall(f, &vals);
   
                   printf("finish func %d\n", argc);
   makeReply:
                 memcpy(&rrpc.ret_session, &rpc->call_session, sizeof rrpc.ret_session);                  memcpy(&rrpc.ret_session, &rpc->call_session, sizeof rrpc.ret_session);
                 rrpc.ret_tag = rpc->call_tag;                  rrpc.ret_tag = rpc->call_tag;
                 rrpc.ret_hash = rpc->call_hash;                  rrpc.ret_hash = rpc->call_hash;
Line 131  rpc_srv_dispatchCall(void *arg) Line 139  rpc_srv_dispatchCall(void *arg)
                                                 data += vals[i].val_len + 1;                                                  data += vals[i].val_len + 1;
                                                 Limit += vals[i].val_len + 1;                                                  Limit += vals[i].val_len + 1;
                                                 break;                                                  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;
                                                   }
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
Line 178  rpc_srv_dispatchVars(void *arg) Line 193  rpc_srv_dispatchVars(void *arg)
   
         cx = -1;          cx = -1;
         do {          do {
                   // check for disable service at this moment?
                   if (s->srv_blob.state == disable) {
                           ret = 0;
                           break;
                   }
   
                 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 206  rpc_srv_dispatchVars(void *arg) Line 227  rpc_srv_dispatchVars(void *arg)
                                 blob->hdr_seq != cx) {                                  blob->hdr_seq != cx) {
                         rpc_SetErr(EINVAL, "Error:: get invalid BLOB session in seq=%d...\n", blob->hdr_seq);                          rpc_SetErr(EINVAL, "Error:: get invalid BLOB session in seq=%d...\n", blob->hdr_seq);
                         ret = -5;                          ret = -5;
                        break;                        goto makeReply;
                 }                  }
                 // Go to proceed packet ...                  // Go to proceed packet ...
                 switch (blob->hdr_cmd) {                  switch (blob->hdr_cmd) {
Line 217  rpc_srv_dispatchVars(void *arg) Line 238  rpc_srv_dispatchVars(void *arg)
                                         ret = -6;                                          ret = -6;
                                         break;                                          break;
                                 }                                  }
                                   printf("++++++ %p\n", b);
   
                                 if (rpc_srv_blobMap(s, b) != -1) {                                  if (rpc_srv_blobMap(s, b) != -1) {
                                         ret = rpc_srv_sendBLOB(c, b);                                          ret = rpc_srv_sendBLOB(c, b);
Line 244  rpc_srv_dispatchVars(void *arg) Line 266  rpc_srv_dispatchVars(void *arg)
                                                 blob->hdr_cmd);                                                  blob->hdr_cmd);
                                 ret = -7;                                  ret = -7;
                 }                  }
                   cx++;
   
   makeReply:
                 // Replay to client!                  // Replay to client!
                 blob->hdr_cmd = ret < 0 ? error : ok;                  blob->hdr_cmd = ret < 0 ? error : ok;
                 blob->hdr_seq = ret;                  blob->hdr_seq = ret;
Line 259  rpc_srv_dispatchVars(void *arg) Line 283  rpc_srv_dispatchVars(void *arg)
                         ret = -9;                          ret = -9;
                         break;                          break;
                 }                  }
                   cx = -1;
   
         } while (ret > -1);          } while (ret > -1);
   
         shutdown(c->cli_sock, SHUT_RDWR);          shutdown(c->cli_sock, SHUT_RDWR);
Line 343  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 369  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
         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, 0);
         rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);          rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);
           rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
         srv->srv_blob.state = enable;   // enable BLOB          srv->srv_blob.state = enable;   // enable BLOB
Line 370  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 397  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBCLIENTS);
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);
           rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSTATE);
   
         for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++)          for (i = 0, c = srv->srv_blob.clients; i < srv->srv_numcli && c; i++, c++)
                 if (c->cli_sa.sa_family)                  if (c->cli_sa.sa_family)
                         shutdown(c->cli_sock, SHUT_RDWR);                          shutdown(c->cli_sock, SHUT_RDWR);
         close(srv->srv_blob.server.cli_sock);          close(srv->srv_blob.server.cli_sock);
   
        if (srv->srv_blob.clients)        if (srv->srv_blob.clients) {
                 free(srv->srv_blob.clients);                  free(srv->srv_blob.clients);
                   srv->srv_blob.clients = NULL;
           }
   
         pthread_mutex_lock(&srv->srv_blob.mtx);          pthread_mutex_lock(&srv->srv_blob.mtx);
         while ((f = srv->srv_blob.blobs)) {          while ((f = srv->srv_blob.blobs)) {
                 srv->srv_blob.blobs = f->blob_next;                  srv->srv_blob.blobs = f->blob_next;
                   rpc_srv_blobFree(srv, f);
                 free(f);                  free(f);
         }          }
         pthread_mutex_unlock(&srv->srv_blob.mtx);          pthread_mutex_unlock(&srv->srv_blob.mtx);
Line 404  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 435  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
         int ret;          int ret;
         struct timeval tv = { DEF_RPC_TIMEOUT, 0 };          struct timeval tv = { DEF_RPC_TIMEOUT, 0 };
   
        if (!srv || !srv->srv_blob.state) {        if (!srv || srv->srv_blob.state == disable) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start BLOB server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start BLOB server ...\n");
                 return -1;                  return -1;
         }          }
Line 414  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 445  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        while (!rpc_Kill) {        while (!blob_Kill && !rpc_Kill) {
                 for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++)                  for (c = srv->srv_blob.clients, i = 0; i < srv->srv_numcli && c; i++, c++)
                         if (!c->cli_sa.sa_family)                          if (!c->cli_sa.sa_family)
                                 break;                                  break;
                if (c && c->cli_sa.sa_family && c->cli_parent) {                if (i >= srv->srv_numcli) {
                         usleep(1000000);                          usleep(1000000);
                         continue;                          continue;
                 }                  }
Line 447  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 478  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                 }                  }
         }          }
   
           srv->srv_blob.state = disable;
   
         return 0;          return 0;
 }  }
   
Line 587  rpc_srv_endServer(rpc_srv_t * __restrict srv) Line 620  rpc_srv_endServer(rpc_srv_t * __restrict srv)
   
         if (srv->srv_clients) {          if (srv->srv_clients) {
                 free(srv->srv_clients);                  free(srv->srv_clients);
                   srv->srv_clients = NULL;
                 srv->srv_numcli = 0;                  srv->srv_numcli = 0;
         }          }
   
Line 632  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 666  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                 for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++)                  for (c = srv->srv_clients, i = 0; i < srv->srv_numcli && c; i++, c++)
                         if (!c->cli_sa.sa_family)                          if (!c->cli_sa.sa_family)
                                 break;                                  break;
                if (c && c->cli_sa.sa_family && c->cli_parent) {                if (i >= srv->srv_numcli) {
                         usleep(1000000);                          usleep(1000000);
                         continue;                          continue;
                 }                  }
Line 668  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 702  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
  * @data = RPC const data  
  * @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 call array of rpc values
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
 int  int
rpc_srv_execCall(void * const data, rpc_func_t * __restrict call, rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, 
                struct tagRPCCall * __restrict rpc, rpc_val_t * __restrict args)                rpc_val_t * __restrict args)
 {  {
         void *dl;          void *dl;
         rpc_callback_t func;          rpc_callback_t func;
         int ret;          int ret;
   
        if (!data || !call || !rpc) {        if (!call || !rpc || !call->func_parent) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t exec call from RPC server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t exec call from RPC server ...\n");
                 return -1;                  return -1;
         }          }
Line 695  rpc_srv_execCall(void * const data, rpc_func_t * __res Line 728  rpc_srv_execCall(void * const data, rpc_func_t * __res
   
         func = dlsym(dl, (char*) call->func_name);          func = dlsym(dl, (char*) call->func_name);
         if (func)          if (func)
                ret = func(data, call, rpc->call_argc, args);                ret = func(call, rpc->call_argc, args);
         else {          else {
                 rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror());                  rpc_SetErr(ENOEXEC, "Error:: Can`t find function %s!\n", dlerror());
                 ret = -1;                  ret = -1;
Removed from v.1.1.1.1.2.10  
changed lines
  Added in v.1.1.1.1.2.16

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