[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.8.2.6 and 1.9.2.3

version 1.8.2.6, 2012/05/11 13:23:12 version 1.9.2.3, 2012/05/14 15:35:58
Line 94  txPacket(sched_task_t *task) Line 94  txPacket(sched_task_t *task)
         else if (ret != wlen)          else if (ret != wlen)
                 rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "                  rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "
                                 "really sended %d bytes", wlen, ret);                                  "really sended %d bytes", wlen, ret);
         else  
                 ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", ret);  
   
         return NULL;          return NULL;
 }  }
Line 131  execCall(sched_task_t *task) Line 129  execCall(sched_task_t *task)
                 rpc->call_rep.ret = RPC_ERROR(-1);                  rpc->call_rep.ret = RPC_ERROR(-1);
                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
         } else {          } else {
                 ioDEBUG(RPC_DEBUG_LEVEL, "RPC function %s from module %s",   
                                 AIT_GET_STR(&f->func_name), AIT_GET_LIKE(&f->func_file, char*));  
   
                 /* if client doesn't want reply */                  /* if client doesn't want reply */
                 argc = rpc->call_req.flags & RPC_NOREPLY;                  argc = rpc->call_req.flags & RPC_NOREPLY;
                 rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(f, rpc, arr));                  rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(f, rpc, arr));
Line 171  rxPacket(sched_task_t *task) Line 166  rxPacket(sched_task_t *task)
         rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);          rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);
         if (rlen == -1) {          if (rlen == -1) {
                 LOGERR;                  LOGERR;
                s->srv_kill = s->srv_blob.state = kill;                c->cli_kill = kill;
                 return NULL;                  return NULL;
         } else if (!rlen) {     /* receive EOF */          } else if (!rlen) {     /* receive EOF */
                s->srv_kill = s->srv_blob.state = kill;                c->cli_kill = kill;
                 return NULL;                  return NULL;
        } else        }
                ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen); 
   
         do {          do {
                 if (rlen < sizeof(struct tagRPCCall)) {                  if (rlen < sizeof(struct tagRPCCall)) {
Line 271  rpc_srv_dispatchCall(void *arg) Line 265  rpc_srv_dispatchCall(void *arg)
   
         schedRead(root, rxPacket, c, c->cli_sock, buf, s->srv_netbuf);          schedRead(root, rxPacket, c, c->cli_sock, buf, s->srv_netbuf);
   
        schedRun(root, (void*) &s->srv_kill);        schedRun(root, (void*) &c->cli_kill);
         schedEnd(&root);          schedEnd(&root);
   
         shutdown(c->cli_sock, SHUT_RDWR);          shutdown(c->cli_sock, SHUT_RDWR);
Line 300  txBLOB(sched_task_t *task) Line 294  txBLOB(sched_task_t *task)
         else if (wlen != sizeof(struct tagBLOBHdr))          else if (wlen != sizeof(struct tagBLOBHdr))
                 rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "                  rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "
                                 "really sended %d bytes", sizeof(struct tagBLOBHdr), wlen);                                  "really sended %d bytes", sizeof(struct tagBLOBHdr), wlen);
         else  
                 ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", wlen);  
   
         return NULL;          return NULL;
 }  }
Line 333  rxBLOB(sched_task_t *task) Line 325  rxBLOB(sched_task_t *task)
         rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);          rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);
         if (rlen == -1) {          if (rlen == -1) {
                 LOGERR;                  LOGERR;
                s->srv_blob.state = kill;                c->cli_kill = kill;
                 return NULL;                  return NULL;
        } else if (!rlen || s->srv_kill == kill) { /* receive EOF */        } else if (!rlen) { /* receive EOF */
                s->srv_blob.state = kill;                c->cli_kill = kill;
                 return NULL;                  return NULL;
        } else        }
                ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen); 
   
         if (rlen < sizeof(struct tagBLOBHdr)) {          if (rlen < sizeof(struct tagBLOBHdr)) {
                 rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet");
Line 457  rpc_srv_dispatchVars(void *arg) Line 448  rpc_srv_dispatchVars(void *arg)
   
         schedRead(root, rxBLOB, c, c->cli_sock, buf, sizeof(struct tagBLOBHdr));          schedRead(root, rxBLOB, c, c->cli_sock, buf, sizeof(struct tagBLOBHdr));
   
        schedRun(root, (void*) &s->srv_blob.state);        schedRun(root, (void*) &c->cli_kill);
         schedEnd(&root);          schedEnd(&root);
   
         shutdown(c->cli_sock, SHUT_RDWR);          shutdown(c->cli_sock, SHUT_RDWR);
Line 660  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 651  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
                 if (i >= srv->srv_numcli) {                  if (i >= srv->srv_numcli) {
 #ifdef HAVE_PTHREAD_YIELD  #ifdef HAVE_PTHREAD_YIELD
                         pthread_yield();                          pthread_yield();
 #else  
                         usleep(1000000);  
 #endif  #endif
                           usleep(1000000);
                         continue;                          continue;
                 }                  }
   
Line 682  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 672  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
                         c->cli_parent = srv;                          c->cli_parent = srv;
   
                 /* spawn dispatch thread for BLOB client */                  /* spawn dispatch thread for BLOB client */
                   c->cli_kill = enable;
                 if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchVars, c)) {                  if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchVars, c)) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
Line 713  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 704  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
 {  {
         rpc_srv_t *srv = NULL;          rpc_srv_t *srv = NULL;
         int n = 1;          int n = 1;
         struct hostent *host = NULL;  
         io_sockaddr_t sa;          io_sockaddr_t sa;
   
        if (!concurentClients || !regProgID ||         if (!concurentClients || !regProgID) {
                        (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) {                rpc_SetErr(EINVAL, "Invalid parameters can`t init RPC server");
                rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t init RPC server ...\n"); 
                 return NULL;                  return NULL;
         }          }
           if (!io_gethostbyname(csHost, Port, &sa))
                   return NULL;
         if (!Port)          if (!Port)
                 Port = RPC_DEFPORT;                  Port = RPC_DEFPORT;
         if (!netBuf)          if (!netBuf)
                 netBuf = BUFSIZ;                  netBuf = BUFSIZ;
         else          else
                 netBuf = io_align(netBuf, 1);   /* align netBuf length */                  netBuf = io_align(netBuf, 1);   /* align netBuf length */
         if (csHost && family != AF_LOCAL) {  
                 host = gethostbyname2(csHost, family);  
                 if (!host) {  
                         rpc_SetErr(h_errno, "Error:: %s\n", hstrerror(h_errno));  
                         return NULL;  
                 }  
         }  
         memset(&sa, 0, sizeof sa);  
         sa.sa.sa_family = family;  
         switch (family) {  
                 case AF_INET:  
                         sa.sin.sin_len = sizeof(struct sockaddr_in);  
                         sa.sin.sin_port = htons(Port);  
                         if (csHost)  
                                 memcpy(&sa.sin.sin_addr, host->h_addr, host->h_length);  
                         break;  
                 case AF_INET6:  
                         sa.sin6.sin6_len = sizeof(struct sockaddr_in6);  
                         sa.sin6.sin6_port = htons(Port);  
                         if (csHost)  
                                 memcpy(&sa.sin6.sin6_addr, host->h_addr, host->h_length);  
                         break;  
                 case AF_LOCAL:  
                         sa.sun.sun_len = sizeof(struct sockaddr_un);  
                         if (csHost)  
                                 strlcpy(sa.sun.sun_path, csHost, sizeof sa.sun.sun_path);  
                         unlink(sa.sun.sun_path);  
                         break;  
                 default:  
                         rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t start RPC server ...\n");  
                         return NULL;  
         }  
   
         srv = malloc(sizeof(rpc_srv_t));          srv = malloc(sizeof(rpc_srv_t));
         if (!srv) {          if (!srv) {
Line 779  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 738  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         memcpy(&srv->srv_server.cli_sa, &sa, sizeof sa);          memcpy(&srv->srv_server.cli_sa, &sa, sizeof sa);
   
         /* create server socket */          /* create server socket */
        srv->srv_server.cli_sock = socket(family, SOCK_STREAM, 0);        srv->srv_server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, SOCK_STREAM, 0);
         if (srv->srv_server.cli_sock == -1) {          if (srv->srv_server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 free(srv);                  free(srv);
Line 844  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 803  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
         rpc_func_t *f;          rpc_func_t *f;
   
         if (!psrv || !*psrv) {          if (!psrv || !*psrv) {
                rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n");                rpc_SetErr(EINVAL, "Can`t destroy server because parameter is null!");
                 return;                  return;
         }          }
   
Line 894  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 853  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         struct pollfd pfd;          struct pollfd pfd;
   
         if (!srv) {          if (!srv) {
                rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n");                rpc_SetErr(EINVAL, "Invalid parameter can`t start RPC server");
                 return -1;                  return -1;
         }          }
   
         /* 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, srv->srv_numcli) == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
        } /*else        } else
                 fcntl(srv->srv_server.cli_sock, F_SETFL, fcntl(srv->srv_server.cli_sock, F_GETFL) | O_NONBLOCK);                  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);
Line 921  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 879  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
                 if (i >= srv->srv_numcli) {                  if (i >= srv->srv_numcli) {
 #ifdef HAVE_PTHREAD_YIELD  #ifdef HAVE_PTHREAD_YIELD
                         pthread_yield();                          pthread_yield();
 #else  
                         usleep(1000000);  
 #endif  #endif
                           usleep(1000000);
                         continue;                          continue;
                 }                  }
   
Line 943  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 900  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
                         c->cli_parent = srv;                          c->cli_parent = srv;
   
                 /* spawn rpc client dispatcher */                  /* spawn rpc client dispatcher */
                   c->cli_kill = enable;
                 if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchCall, c)) {                  if (pthread_create(&c->cli_tid, &attr, rpc_srv_dispatchCall, c)) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
Removed from v.1.8.2.6  
changed lines
  Added in v.1.9.2.3

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