[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.3.2.6 and 1.3.2.9

version 1.3.2.6, 2011/08/19 07:39:29 version 1.3.2.9, 2011/08/19 12:51:50
Line 73  rpc_srv_dispatchCall(void *arg) Line 73  rpc_srv_dispatchCall(void *arg)
                 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);
                 if (ret == -1) {                  if (ret == -1) {
                           if (errno == EINTR && s->srv_kill != kill)
                                   continue;
   
                           LOGERR;
                         ret = -2;                          ret = -2;
                           break;
                 }                  }
                 memset(buf, 0, BUFSIZ);                  memset(buf, 0, BUFSIZ);
                if ((ret = recv(c->cli_sock, buf, BUFSIZ, 0)) == -1) {                ret = recv(c->cli_sock, buf, BUFSIZ, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -3;                          ret = -3;
                         break;                          break;
Line 140  rpc_srv_dispatchCall(void *arg) Line 146  rpc_srv_dispatchCall(void *arg)
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 }                                                  }
                                                   if (s->srv_blob.state == kill) {
                                                           rpc_SetErr(ENOTSUP, "Error:: BLOB server is killed\n");
                                                           ret = -5;
                                                           goto makeReply;
                                                   }
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
Line 156  rpc_srv_dispatchCall(void *arg) Line 167  rpc_srv_dispatchCall(void *arg)
                         if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)                          if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)
                                 ret = -9;                                  ret = -9;
                         else                          else
                                argc = rpc_srv_getValsCall(f, &vals);                                argc = rpc_srv_getVars(f, &vals);
 makeReply:  makeReply:
                 memset(buf, 0, BUFSIZ);                  memset(buf, 0, BUFSIZ);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
Line 174  makeReply: Line 185  makeReply:
                         if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                          if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {
                                 for (i = 0; i < argc; i++)                                  for (i = 0; i < argc; i++)
                                         RPC_FREE_VAL(&vals[i]);                                          RPC_FREE_VAL(&vals[i]);
                                rpc_srv_freeValsCall(f);                                rpc_srv_freeVars(f);
                                 vals = NULL;                                  vals = NULL;
                                 argc = 0;                                  argc = 0;
                                 ret = -7;                                  ret = -7;
Line 217  makeReply: Line 228  makeReply:
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
                                                         break;                                                          break;
                                                 }                                                  }
                                                   if (s->srv_blob.state == kill) {
                                                           rpc_SetErr(ENOTSUP, "Error:: BLOB server is killed\n");
                                                           rrpc->ret_retcode = ret = -5;
                                                           rrpc->ret_argc = 0;
                                                           break;
                                                   }
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
   
                                 RPC_FREE_VAL(&vals[i]);                                  RPC_FREE_VAL(&vals[i]);
                         }                          }
                        rpc_srv_freeValsCall(f);                        rpc_srv_freeVars(f);
                         vals = NULL;                          vals = NULL;
                         argc = 0;                          argc = 0;
                 }                  }
   
                if ((ret = send(c->cli_sock, buf, Limit, 0)) == -1) {                ret = send(c->cli_sock, buf, Limit, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -8;                          ret = -8;
                         break;                          break;
Line 239  makeReply: Line 257  makeReply:
                         ret = -9;                          ret = -9;
                         break;                          break;
                 }                  }
        } while (ret > -1);        } while (ret > -1 || s->srv_kill != kill);
   
         shutdown(c->cli_sock, SHUT_RDWR);          shutdown(c->cli_sock, SHUT_RDWR);
         close(c->cli_sock);          close(c->cli_sock);
Line 254  rpc_srv_dispatchVars(void *arg) Line 272  rpc_srv_dispatchVars(void *arg)
         rpc_cli_t *c = arg;          rpc_cli_t *c = arg;
         rpc_srv_t *s;          rpc_srv_t *s;
         rpc_blob_t *b;          rpc_blob_t *b;
        int ret;        int ret = 0;
         fd_set fds;          fd_set fds;
         u_char buf[sizeof(struct tagBLOBHdr)];          u_char buf[sizeof(struct tagBLOBHdr)];
         struct tagBLOBHdr *blob;          struct tagBLOBHdr *blob;
Line 267  rpc_srv_dispatchVars(void *arg) Line 285  rpc_srv_dispatchVars(void *arg)
   
         do {          do {
                 // check for disable service at this moment?                  // check for disable service at this moment?
                if (s->srv_blob.state == disable) {                if (s->srv_blob.state == disable && s->srv_kill != kill) {
                        ret = 0;                        usleep(100000);
                        break;                        pthread_yield();
                         continue;
                 }                  }
   
                 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);
                 if (ret == -1) {                  if (ret == -1) {
                           if (errno == EINTR && s->srv_kill != kill && s->srv_blob.state != kill)
                                   continue;
   
                           LOGERR;
                         ret = -2;                          ret = -2;
                           break;
                 }                  }
   
                 memset(buf, 0, sizeof buf);                  memset(buf, 0, sizeof buf);
                if ((ret = recv(c->cli_sock, buf, sizeof buf, 0)) == -1) {                ret = recv(c->cli_sock, buf, sizeof buf, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -3;                          ret = -3;
                         break;                          break;
                 }                  }
                if (!ret || s->srv_blob.state == disable) {      // receive EOF or disable service                /* receive EOF, disable or kill service */
                 if (!ret || s->srv_blob.state == kill || s->srv_kill == kill) {
                         ret = 0;                          ret = 0;
                         break;                          break;
                 }                  }
Line 343  makeReply: Line 369  makeReply:
                 // Replay to client!                  // Replay to client!
                 blob->hdr_cmd = ret < 0 ? error : ok;                  blob->hdr_cmd = ret < 0 ? error : ok;
                 blob->hdr_ret = ret;                  blob->hdr_ret = ret;
                if ((ret = send(c->cli_sock, buf, sizeof buf, 0)) == -1) {                ret = send(c->cli_sock, buf, sizeof buf, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -8;                          ret = -8;
                         break;                          break;
Line 354  makeReply: Line 381  makeReply:
                         ret = -9;                          ret = -9;
                         break;                          break;
                 }                  }
        } while (ret > -1);        } while (ret > -1 || s->srv_kill != kill);
   
         shutdown(c->cli_sock, SHUT_RDWR);          shutdown(c->cli_sock, SHUT_RDWR);
         close(c->cli_sock);          close(c->cli_sock);
Line 367  makeReply: Line 394  makeReply:
 /*  /*
  * rpc_srv_initBLOBServer() Init & create BLOB Server   * rpc_srv_initBLOBServer() Init & create BLOB Server
  * @srv = RPC server instance   * @srv = RPC server instance
  * @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW  
  * @Port = Port for bind server, if Port == 0 default port is selected   * @Port = Port for bind server, if Port == 0 default port is selected
  * @diskDir = Disk place for BLOB file objects   * @diskDir = Disk place for BLOB file objects
  * return: -1 == error or 0 bind and created BLOB server instance   * return: -1 == error or 0 bind and created BLOB server instance
  */   */
 int  int
rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int sockType, u_short Port, const char *diskDir)rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_short Port, const char *diskDir)
 {  {
         int n = 1;          int n = 1;
         struct sockaddr sa;          struct sockaddr sa;
Line 421  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int Line 447  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int
         }          }
   
         /* create BLOB server socket */          /* create BLOB server socket */
        srv->srv_blob.server.cli_type = sockType ? sockType : SOCK_STREAM;        srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa_family, SOCK_STREAM, 0);
        srv->srv_blob.server.cli_sock = socket(srv->srv_server.cli_sa.sa_family,  
                        srv->srv_blob.server.cli_type, 0); 
         if (srv->srv_blob.server.cli_sock == -1) {          if (srv->srv_blob.server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 478  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 502  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                 rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n");                  rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n");
                 return;                  return;
         } else          } else
                srv->srv_blob.state = disable;                srv->srv_blob.state = kill;
   
         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);
Line 524  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 548  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 == disable) {        if (!srv || srv->srv_blob.state == kill) {
                 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;
         }          }
   
        if (srv->srv_blob.server.cli_type == SOCK_STREAM ||         if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) {
                        srv->srv_blob.server.cli_type == SOCK_SEQPACKET)                LOGERR;
                if (listen(srv->srv_blob.server.cli_sock, SOMAXCONN) == -1) {                return -1;
                        LOGERR;        }
                        return -1; 
                } 
   
         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 556  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 578  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                 if (!ret)                  if (!ret)
                         continue;                          continue;
   
                if (srv->srv_blob.server.cli_type == SOCK_STREAM ||                 c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa, &salen);
                                srv->srv_blob.server.cli_type == SOCK_SEQPACKET) 
                        c->cli_sock = accept(srv->srv_blob.server.cli_sock, &c->cli_sa, &salen); 
                else 
                        c->cli_sock = dup(srv->srv_blob.server.cli_sock); 
                 if (c->cli_sock == -1) {                  if (c->cli_sock == -1) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
Line 571  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 589  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                         LOGERR;                          LOGERR;
                         continue;                          continue;
                 } else                  } else
                        if (srv->srv_blob.server.cli_type == SOCK_STREAM ||                         pthread_detach(c->cli_tid);
                                        srv->srv_blob.server.cli_type == SOCK_SEQPACKET) 
                                pthread_detach(c->cli_tid); 
                        else 
                                pthread_join(c->cli_tid, NULL); 
         }          }
   
         srv->srv_blob.state = disable;          srv->srv_blob.state = disable;
Line 589  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 603  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
  * @sockType = Socket type, like SOCK_STREAM, SOCK_DGRAM or SOCK_RAW  
  * @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 597  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 610  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
  */   */
 rpc_srv_t *  rpc_srv_t *
 rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients,   rpc_srv_initServer(u_int regProgID, u_int regProcID, int concurentClients, 
                int sockType, u_short family, const char *csHost, u_short Port)                u_short family, const char *csHost, u_short Port)
 {  {
         rpc_srv_t *srv = NULL;          rpc_srv_t *srv = NULL;
         int n = 1;          int n = 1;
Line 674  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 687  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         }          }
   
         /* create server socket */          /* create server socket */
        srv->srv_server.cli_type = sockType ? sockType : SOCK_STREAM;        srv->srv_server.cli_sock = socket(family, SOCK_STREAM, 0);
        srv->srv_server.cli_sock = socket(family, srv->srv_server.cli_type, 0); 
         if (srv->srv_server.cli_sock == -1) {          if (srv->srv_server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 free(srv);                  free(srv);
Line 781  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 793  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        if (srv->srv_server.cli_type == SOCK_STREAM || srv->srv_server.cli_type == SOCK_SEQPACKET)        if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) {
                if (listen(srv->srv_server.cli_sock, SOMAXCONN) == -1) {                LOGERR;
                        LOGERR;                return -1;
                        return -1;        }
                } 
   
         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 807  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 818  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                 if (!ret)                  if (!ret)
                         continue;                          continue;
   
                if (srv->srv_server.cli_type == SOCK_STREAM || srv->srv_server.cli_type == SOCK_SEQPACKET)                c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa, &salen);
                        c->cli_sock = accept(srv->srv_server.cli_sock, &c->cli_sa, &salen); 
                else 
                        c->cli_sock = dup(srv->srv_server.cli_sock); 
                 if (c->cli_sock == -1) {                  if (c->cli_sock == -1) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
Line 820  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 828  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                 if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchCall, c)) {                  if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchCall, c)) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
                } else {                } else
                        if (srv->srv_server.cli_type == SOCK_STREAM || srv->srv_server.cli_type == SOCK_SEQPACKET)                        pthread_detach(c->cli_tid);
                                pthread_detach(c->cli_tid); 
                        else 
                                pthread_join(c->cli_tid, NULL); 
                } 
         }          }
   
         return 0;          return 0;
Removed from v.1.3.2.6  
changed lines
  Added in v.1.3.2.9

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