[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.7.2.4 and 1.8.2.4

version 1.7.2.4, 2012/03/29 01:23:59 version 1.8.2.4, 2012/05/11 09:11:01
Line 579  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 579  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
         } else          } else
                 memset(srv->srv_blob.clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));                  memset(srv->srv_blob.clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));
   
         pthread_mutex_init(&srv->srv_blob.mtx, NULL);  
   
         rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);          rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);
         rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1);          rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1);
         rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1);          rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1);
Line 621  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 619  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                         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);
   
         pthread_mutex_lock(&srv->srv_blob.mtx);  
         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;                  srv->srv_blob.clients = NULL;
Line 633  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 630  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                 rpc_srv_blobFree(srv, f);                  rpc_srv_blobFree(srv, f);
                 free(f);                  free(f);
         }          }
         pthread_mutex_unlock(&srv->srv_blob.mtx);  
   
         AIT_FREE_VAL(&srv->srv_blob.dir);          AIT_FREE_VAL(&srv->srv_blob.dir);
   
         while (pthread_mutex_trylock(&srv->srv_blob.mtx) == EBUSY);  
         pthread_mutex_destroy(&srv->srv_blob.mtx);  
   
         /* at final, save disable BLOB service state */          /* at final, save disable BLOB service state */
         srv->srv_blob.state = disable;          srv->srv_blob.state = disable;
 }  }
Line 656  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 649  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
         socklen_t salen = sizeof(io_sockaddr_t);          socklen_t salen = sizeof(io_sockaddr_t);
         register int i;          register int i;
         rpc_cli_t *c;          rpc_cli_t *c;
         fd_set fds;  
         int ret;          int ret;
         struct timeval tv = { DEF_RPC_TIMEOUT, 0 };  
         pthread_attr_t attr;          pthread_attr_t attr;
           struct pollfd pfd;
   
         ioTRACE(RPC_TRACE_LEVEL);          ioTRACE(RPC_TRACE_LEVEL);
   
Line 668  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 660  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
         tv.tv_sec = srv->srv_session.sess_timeout;  
   
         if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) {          if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
        }        } else
                 fcntl(srv->srv_blob.server.cli_sock, F_SETFL, 
                                 fcntl(srv->srv_blob.server.cli_sock, F_GETFL) | O_NONBLOCK);
   
         pthread_attr_init(&attr);          pthread_attr_init(&attr);
         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   
           pfd.fd = srv->srv_blob.server.cli_sock;
           pfd.events = POLLIN | POLLPRI;
         /* main BLOB loop */          /* main BLOB loop */
         while (srv->srv_blob.state != kill && srv->srv_kill != kill) {          while (srv->srv_blob.state != kill && srv->srv_kill != 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++)
Line 692  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 686  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
                         continue;                          continue;
                 }                  }
   
                FD_ZERO(&fds);                if ((ret = poll(&pfd, 1, srv->srv_session.sess_timeout * 1000)) == -1 || 
                FD_SET(srv->srv_blob.server.cli_sock, &fds);                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                ret = select(srv->srv_blob.server.cli_sock + 1, &fds, NULL, NULL, &tv); 
                if (ret == -1) { 
                         LOGERR;                          LOGERR;
                         ret = 1;                          ret = 1;
                         break;                          break;
                }                } else if (!ret)
                if (!ret) 
                         continue;                          continue;
   
                 c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen);                  c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa.sa, &salen);
Line 853  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 844  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         } else          } else
                 memset(srv->srv_clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));                  memset(srv->srv_clients, 0, srv->srv_numcli * sizeof(rpc_cli_t));
   
         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, 1);          rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 1);
         rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);          rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);
Line 900  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 889  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
         }          }
   
         /* detach exported calls */          /* detach exported calls */
         pthread_mutex_lock(&(*psrv)->srv_mtx);  
         while ((f = (*psrv)->srv_funcs)) {          while ((f = (*psrv)->srv_funcs)) {
                 (*psrv)->srv_funcs = f->func_next;                  (*psrv)->srv_funcs = f->func_next;
                 io_freeVars(&f->func_vars);                  io_freeVars(&f->func_vars);
Line 908  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 896  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
                 AIT_FREE_VAL(&f->func_file);                  AIT_FREE_VAL(&f->func_file);
                 free(f);                  free(f);
         }          }
         pthread_mutex_unlock(&(*psrv)->srv_mtx);  
   
         while (pthread_mutex_trylock(&(*psrv)->srv_mtx) == EBUSY);  
         pthread_mutex_destroy(&(*psrv)->srv_mtx);  
   
         free(*psrv);          free(*psrv);
         *psrv = NULL;          *psrv = NULL;
 }  }
Line 929  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 913  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         socklen_t salen = sizeof(io_sockaddr_t);          socklen_t salen = sizeof(io_sockaddr_t);
         register int i;          register int i;
         rpc_cli_t *c;          rpc_cli_t *c;
         fd_set fds;  
         int ret;          int ret;
         struct timeval tv = { DEF_RPC_TIMEOUT, 0 };  
         pthread_attr_t attr;          pthread_attr_t attr;
           struct pollfd pfd;
   
         ioTRACE(RPC_TRACE_LEVEL);          ioTRACE(RPC_TRACE_LEVEL);
   
Line 941  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 924  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
         tv.tv_sec = srv->srv_session.sess_timeout;  
   
         /* activate BLOB server worker if srv->srv_blob.state == enable */          /* activate BLOB server worker if srv->srv_blob.state == enable */
         rpc_srv_execBLOBServer(srv);          rpc_srv_execBLOBServer(srv);
   
         if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) {          if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
        }        } else
                 fcntl(srv->srv_server.cli_sock, F_SETFL, fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK);
   
         pthread_attr_init(&attr);          pthread_attr_init(&attr);
         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);          pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   
           pfd.fd = srv->srv_server.cli_sock;
           pfd.events = POLLIN | POLLPRI;
         /* main rpc loop */          /* main rpc loop */
         while (srv->srv_kill != kill) {          while (srv->srv_kill != kill) {
                 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++)
Line 968  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 952  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
                         continue;                          continue;
                 }                  }
   
                FD_ZERO(&fds);                if ((ret = poll(&pfd, 1, srv->srv_session.sess_timeout * 1000)) == -1 || 
                FD_SET(srv->srv_server.cli_sock, &fds);                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                ret = select(srv->srv_server.cli_sock + 1, &fds, NULL, NULL, &tv); 
                if (ret == -1) { 
                         LOGERR;                          LOGERR;
                         ret = 1;                          ret = 1;
                         break;                          break;
                }                } else if (!ret)
                if (!ret) 
                         continue;                          continue;
   
                 c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen);                  c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa.sa, &salen);
Line 1022  rpc_srv_execCall(rpc_func_t * __restrict call, struct  Line 1003  rpc_srv_execCall(rpc_func_t * __restrict call, struct 
                 return -1;                  return -1;
         }          }
   
        dl = dlopen(AIT_VOID(&call->func_file), RTLD_NOW);        dl = dlopen(AIT_ADDR(&call->func_file), RTLD_NOW);
         if (!dl) {          if (!dl) {
                 rpc_SetErr(ENOENT, "Can`t attach module %s!", dlerror());                  rpc_SetErr(ENOENT, "Can`t attach module %s!", dlerror());
                 return -1;                  return -1;
Removed from v.1.7.2.4  
changed lines
  Added in v.1.8.2.4

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