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

version 1.3.2.2, 2011/08/18 19:04:10 version 1.3.2.13, 2011/08/19 14:44:34
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, sizeof buf);
                if ((ret = recv(c->cli_sock, buf, BUFSIZ, 0)) == -1) {                ret = recv(c->cli_sock, buf, sizeof buf, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -3;                          ret = -3;
                         break;                          break;
                 }                  }
                if (!ret) {             // receive EOF                if (!ret) {             /* receive EOF */
                         ret = 0;                          ret = 0;
                         break;                          break;
                 }                  }
Line 91  rpc_srv_dispatchCall(void *arg) Line 97  rpc_srv_dispatchCall(void *arg)
                         break;                          break;
                 } else                  } else
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
                // check RPC packet session info                /* check RPC packet session info */
                 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;
                         goto makeReply;                          goto makeReply;
                 } else                  } else
                         Limit = sizeof(struct tagRPCCall);                          Limit = sizeof(struct tagRPCCall);
                // RPC is OK! Go decapsulate variables ...                /* RPC is OK! Go decapsulate variables ... */
                 if (rpc->call_argc) {                  if (rpc->call_argc) {
                         v = (rpc_val_t*) (buf + Limit);                          v = (rpc_val_t*) (buf + Limit);
                        // check RPC packet length                        /* check RPC packet length */
                        if (rpc->call_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        if (rpc->call_argc * sizeof(rpc_val_t) > sizeof buf - Limit) {
                                rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                 ret = -5;                                  ret = -5;
                                 goto makeReply;                                  goto makeReply;
                         } else                          } else
                                 Limit += rpc->call_argc * sizeof(rpc_val_t);                                  Limit += rpc->call_argc * sizeof(rpc_val_t);
                        // RPC received variables types OK!                        /* RPC received variables types OK! */
                         data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);                          data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);
                         for (i = 0; i < rpc->call_argc; i++) {                          for (i = 0; i < rpc->call_argc; i++) {
                                 switch (v[i].val_type) {                                  switch (v[i].val_type) {
                                         case buffer:                                          case buffer:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (v[i].val_len > sizeof buf - Limit) {
                                                        rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                                        rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 } else                                                  } else
Line 124  rpc_srv_dispatchCall(void *arg) Line 130  rpc_srv_dispatchCall(void *arg)
                                                 data += v[i].val_len;                                                  data += v[i].val_len;
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (v[i].val_len > sizeof buf - Limit) {
                                                        rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                                        rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 } else                                                  } else
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 gone.\n");
                                                           ret = -5;
                                                           goto makeReply;
                                                   }
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
                         }                          }
                 }                  }
   
                   /* execute call */
                 argc = 0;                  argc = 0;
                 vals = NULL;                  vals = NULL;
                 memcpy(&ses, &rpc->call_session, sizeof ses);                  memcpy(&ses, &rpc->call_session, sizeof ses);
Line 156  rpc_srv_dispatchCall(void *arg) Line 168  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);                /* made reply */
                 memset(buf, 0, sizeof buf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
   
Line 171  makeReply: Line 184  makeReply:
   
                 if (argc && vals) {                  if (argc && vals) {
                         v = (rpc_val_t*) (buf + Limit);                          v = (rpc_val_t*) (buf + Limit);
                        if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        if (argc * sizeof(rpc_val_t) > sizeof buf - 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 187  makeReply: Line 200  makeReply:
                         for (ret = i = 0; i < argc; i++) {                          for (ret = i = 0; i < argc; i++) {
                                 switch (vals[i].val_type) {                                  switch (vals[i].val_type) {
                                         case buffer:                                          case buffer:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > sizeof buf) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");                                                          rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");
                                                         rrpc->ret_retcode = ret = -7;                                                          rrpc->ret_retcode = ret = -7;
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
Line 199  makeReply: Line 212  makeReply:
                                                 Limit += vals[i].val_len;                                                  Limit += vals[i].val_len;
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > sizeof buf) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");                                                          rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");
                                                         rrpc->ret_retcode = ret = -7;                                                          rrpc->ret_retcode = ret = -7;
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
Line 217  makeReply: Line 230  makeReply:
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
                                                         break;                                                          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:                                          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 259  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 274  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 266  rpc_srv_dispatchVars(void *arg) Line 286  rpc_srv_dispatchVars(void *arg)
                 s = c->cli_parent;                  s = c->cli_parent;
   
         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;#ifdef HAVE_PTHREAD_YIELD
                         pthread_yield();
 #endif
                         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 295  rpc_srv_dispatchVars(void *arg) Line 325  rpc_srv_dispatchVars(void *arg)
                         break;                          break;
                 } else                  } else
                         blob = (struct tagBLOBHdr*) buf;                          blob = (struct tagBLOBHdr*) buf;
                // check BLOB packet session info                /* check BLOB packet session info */
                 if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) {                  if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) {
                         rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n");                          rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n");
                         ret = -5;                          ret = -5;
                         goto makeReply;                          goto makeReply;
                 }                  }
                // Go to proceed packet ...                /* Go to proceed packet ... */
                 switch (blob->hdr_cmd) {                  switch (blob->hdr_cmd) {
                         case get:                          case get:
                                 if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) {                                  if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) {
Line 320  rpc_srv_dispatchVars(void *arg) Line 350  rpc_srv_dispatchVars(void *arg)
                                 break;                                  break;
                         case set:                          case set:
                                 if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) {                                  if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) {
                                        // set new BLOB variable for reply :)                                        /* set new BLOB variable for reply :) */
                                         blob->hdr_var = b->blob_var;                                          blob->hdr_var = b->blob_var;
   
                                         ret = rpc_srv_recvBLOB(c, b);                                          ret = rpc_srv_recvBLOB(c, b);
Line 340  rpc_srv_dispatchVars(void *arg) Line 370  rpc_srv_dispatchVars(void *arg)
                 }                  }
   
 makeReply:  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 385  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 366  makeReply: Line 397  makeReply:
   
 /*  /*
  * rpc_srv_initBLOBServer() Init & create BLOB Server   * rpc_srv_initBLOBServer() Init & create BLOB Server
    * @srv = RPC server instance
  * @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
Line 374  int Line 406  int
 rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, 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_in sin;        struct sockaddr sa;
        struct sockaddr_in6 sin6;        struct sockaddr_in *sin = (struct sockaddr_in*) &sa;
         struct sockaddr_in6 *sin6 = (struct sockaddr_in6*) &sa;
         struct sockaddr_un *sun = (struct sockaddr_un*) &sa;
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t init BLOB server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameters can`t init BLOB server ...\n");
Line 397  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 431  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
   
         srv->srv_blob.server.cli_tid = pthread_self();          srv->srv_blob.server.cli_tid = pthread_self();
         srv->srv_blob.server.cli_parent = srv;          srv->srv_blob.server.cli_parent = srv;
        if (srv->srv_server.cli_sa.sa_family == AF_INET) {
                memcpy(&sin, &srv->srv_server.cli_sa, sizeof sin);        memcpy(&sa, &srv->srv_server.cli_sa, sizeof sa);
                sin.sin_port = htons(Port);        switch (srv->srv_server.cli_sa.sa_family) {
                memcpy(&srv->srv_blob.server.cli_sa, &sin, sizeof(struct sockaddr));                case AF_INET:
        } else {                        sin->sin_port = htons(Port);
                memcpy(&sin6, &srv->srv_server.cli_sa, sizeof sin6);                        memcpy(&srv->srv_blob.server.cli_sa, sin, sizeof(struct sockaddr));
                sin6.sin6_port = htons(Port);                        break;
                memcpy(&srv->srv_blob.server.cli_sa, &sin6, sizeof(struct sockaddr));                case AF_INET6:
                         sin6->sin6_port = htons(Port);
                         memcpy(&srv->srv_blob.server.cli_sa, sin6, sizeof(struct sockaddr));
                         break;
                 case AF_LOCAL:
                         strlcat(sun->sun_path, ".blob", sizeof sun->sun_path);
                         memcpy(&srv->srv_blob.server.cli_sa, sun, sizeof(struct sockaddr));
                         break;
                 default:
                         return -1;
         }          }
   
           /* create BLOB server socket */
         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, SOCK_STREAM, 0);
         if (srv->srv_blob.server.cli_sock == -1) {          if (srv->srv_blob.server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
Line 424  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 468  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
                 return -1;                  return -1;
         }          }
   
           /* allocate pool for concurent clients */
         srv->srv_blob.clients = calloc(srv->srv_numcli, sizeof(rpc_cli_t));          srv->srv_blob.clients = calloc(srv->srv_numcli, sizeof(rpc_cli_t));
         if (!srv->srv_blob.clients) {          if (!srv->srv_blob.clients) {
                 LOGERR;                  LOGERR;
Line 441  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 486  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
         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);
   
        srv->srv_blob.state = enable;   // enable BLOB        srv->srv_blob.state = enable;   /* enable BLOB */
         return 0;          return 0;
 }  }
   
Line 461  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 506  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);
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBVARS);
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSTATE);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSTATE);
   
           /* close all clients connections & server socket */
         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);
Line 478  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 524  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
                 srv->srv_blob.clients = NULL;                  srv->srv_blob.clients = NULL;
         }          }
   
           /* detach blobs */
         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;
Line 505  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 552  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;
         }          }
Line 515  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 562  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        while (!blob_Kill && !rpc_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++)
                         if (!c->cli_sa.sa_family)                          if (!c->cli_sa.sa_family)
                                 break;                                  break;
Line 545  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 592  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                 if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchVars, c)) {                  if (pthread_create(&c->cli_tid, NULL, rpc_srv_dispatchVars, c)) {
                         LOGERR;                          LOGERR;
                         continue;                          continue;
                }                } else
                         pthread_detach(c->cli_tid);
         }          }
   
         srv->srv_blob.state = disable;          srv->srv_blob.state = disable;
Line 559  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 607  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 567  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 614  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 632  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 679  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         srv->srv_server.cli_parent = srv;          srv->srv_server.cli_parent = srv;
         switch (family) {          switch (family) {
                 case AF_INET:                  case AF_INET:
                        memcpy(&srv->srv_server.cli_sa, &sin, sizeof srv->srv_server.cli_sa);                        memcpy(&srv->srv_server.cli_sa, sin, sizeof srv->srv_server.cli_sa);
                         break;                          break;
                 case AF_INET6:                  case AF_INET6:
                        memcpy(&srv->srv_server.cli_sa, &sin6, sizeof srv->srv_server.cli_sa);                        memcpy(&srv->srv_server.cli_sa, sin6, sizeof srv->srv_server.cli_sa);
                         break;                          break;
                 case AF_LOCAL:                  case AF_LOCAL:
                        memcpy(&srv->srv_server.cli_sa, &sun, sizeof srv->srv_server.cli_sa);                        memcpy(&srv->srv_server.cli_sa, sun, sizeof srv->srv_server.cli_sa);
                         unlink(sun->sun_path);                          unlink(sun->sun_path);
                         break;                          break;
         }          }
   
         /* create server socket */          /* create server socket */
        srv->srv_server.cli_sock = socket(family, sockType ? sockType : SOCK_STREAM, 0);        srv->srv_server.cli_sock = socket(family, SOCK_STREAM, 0);
         if (srv->srv_server.cli_sock == -1) {          if (srv->srv_server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 free(srv);                  free(srv);
                 return NULL;                  return NULL;
        } else        }
                srv->srv_server.cli_type = sockType; 
         if (setsockopt(srv->srv_server.cli_sock, SOL_SOCKET, SO_REUSEADDR, &n, sizeof n) == -1) {          if (setsockopt(srv->srv_server.cli_sock, SOL_SOCKET, SO_REUSEADDR, &n, sizeof n) == -1) {
                 LOGERR;                  LOGERR;
                 close(srv->srv_server.cli_sock);                  close(srv->srv_server.cli_sock);
Line 756  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 802  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                 return -1;                  return -1;
         }          }
   
        while (!rpc_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++)
                         if (!c->cli_sa.sa_family)                          if (!c->cli_sa.sa_family)
                                 break;                                  break;
Line 786  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 832  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
                         pthread_detach(c->cli_tid);
         }          }
   
         return 0;          return 0;
Removed from v.1.3.2.2  
changed lines
  Added in v.1.3.2.13

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