[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.8 and 1.4.2.2

version 1.3.2.8, 2011/08/19 09:32:38 version 1.4.2.2, 2011/08/30 09:07:55
Line 51  rpc_srv_dispatchCall(void *arg) Line 51  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 = NULL, *v = NULL;        ait_val_t *vals = NULL, *v = NULL;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         struct tagRPCRet *rrpc;          struct tagRPCRet *rrpc;
         rpc_sess_t ses = { 0 };          rpc_sess_t ses = { 0 };
         fd_set fds;          fd_set fds;
        u_char buf[BUFSIZ], *data;        u_char *buf, *data;
         int ret, argc = 0, Limit = 0;          int ret, argc = 0, Limit = 0;
         register int i;          register int i;
   
Line 67  rpc_srv_dispatchCall(void *arg) Line 67  rpc_srv_dispatchCall(void *arg)
         } else          } else
                 s = c->cli_parent;                  s = c->cli_parent;
   
           buf = malloc(s->srv_netbuf);
           if (!buf) {
                   LOGERR;
                   return NULL;
           }
   
         do {          do {
                 v = NULL;                  v = NULL;
                 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)
                                   continue;
   
                           LOGERR;
                         ret = -2;                          ret = -2;
                           break;
                 }                  }
                memset(buf, 0, BUFSIZ);                memset(buf, 0, s->srv_netbuf);
                if ((ret = read(c->cli_sock, buf, BUFSIZ)) == -1) {                ret = recv(c->cli_sock, buf, s->srv_netbuf, 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 103  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 = (ait_val_t*) (buf + Limit);
                        // check RPC packet length                        if (rpc->call_argc * sizeof(ait_val_t) > s->srv_netbuf - Limit) {
                        if (rpc->call_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                                rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                rpc_SetErr(EMSGSIZE, "Error:: Too big 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(ait_val_t);
                        // RPC received variables types OK!
                        data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);                        /* RPC received variables types are OK! */
                         data = (u_char*) v + rpc->call_argc * sizeof(ait_val_t);
                         for (i = 0; i < rpc->call_argc; i++) {                          for (i = 0; i < rpc->call_argc; i++) {
                                switch (v[i].val_type) {                                switch (AIT_TYPE(&v[i])) {
                                         case buffer:                                          case buffer:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (AIT_LEN(&v[i]) > s->srv_netbuf - 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 += v[i].val_len;                                                        Limit += AIT_LEN(&v[i]);
   
                                                 v[i].val.buffer = data;                                                  v[i].val.buffer = data;
                                                data += v[i].val_len;                                                data += AIT_LEN(&v[i]);
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (AIT_LEN(&v[i]) > s->srv_netbuf - 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 += v[i].val_len;                                                        Limit += AIT_LEN(&v[i]);
   
                                                 v[i].val.string = (int8_t*) data;                                                  v[i].val.string = (int8_t*) data;
                                                data += v[i].val_len;                                                data += AIT_LEN(&v[i]);
                                                 break;                                                  break;
                                         case blob:                                          case blob:
                                                 if (s->srv_blob.state == disable) {                                                  if (s->srv_blob.state == disable) {
Line 140  rpc_srv_dispatchCall(void *arg) Line 153  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;
                                 }                                  }
   
                                   AIT_ADDZCOPY(&v[i]);
                         }                          }
                 }                  }
   
                   /* 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 158  rpc_srv_dispatchCall(void *arg) Line 179  rpc_srv_dispatchCall(void *arg)
                         else                          else
                                 argc = rpc_srv_getVars(f, &vals);                                  argc = rpc_srv_getVars(f, &vals);
 makeReply:  makeReply:
                memset(buf, 0, BUFSIZ);                /* made reply */
                 memset(buf, 0, s->srv_netbuf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
   
Line 170  makeReply: Line 192  makeReply:
                 rrpc->ret_argc = argc;                  rrpc->ret_argc = argc;
   
                 if (argc && vals) {                  if (argc && vals) {
                        v = (rpc_val_t*) (buf + Limit);                        /* Go Encapsulate variables ... */
                        if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        v = (ait_val_t*) (buf + Limit);
                         if (argc * sizeof(ait_val_t) > s->srv_netbuf - Limit) {
                                 for (i = 0; i < argc; i++)                                  for (i = 0; i < argc; i++)
                                        RPC_FREE_VAL(&vals[i]);                                        AIT_FREE_VAL(&vals[i]);
                                 rpc_srv_freeVars(f);                                  rpc_srv_freeVars(f);
                                 vals = NULL;                                  vals = NULL;
                                 argc = 0;                                  argc = 0;
Line 181  makeReply: Line 204  makeReply:
                                 rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n");                                  rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet values (-7) ...\n");
                                 goto makeReply;                                  goto makeReply;
                         } else                          } else
                                Limit += argc * sizeof(rpc_val_t);                                Limit += argc * sizeof(ait_val_t);
                        memcpy(v, vals, argc * sizeof(rpc_val_t));                        memcpy(v, vals, argc * sizeof(ait_val_t));
                        data = (u_char*) v + argc * sizeof(rpc_val_t);
                         /* RPC send variables types are OK! */
                         data = (u_char*) v + argc * sizeof(ait_val_t);
                         for (ret = i = 0; i < argc; i++) {                          for (ret = i = 0; i < argc; i++) {
                                switch (vals[i].val_type) {                                switch (AIT_TYPE(&vals[i])) {
                                         case buffer:                                          case buffer:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > s->srv_netbuf) {
                                                         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 195  makeReply: Line 220  makeReply:
                                                 }                                                  }
   
                                                 memcpy(data, vals[i].val.buffer, vals[i].val_len);                                                  memcpy(data, vals[i].val.buffer, vals[i].val_len);
                                                data += vals[i].val_len;                                                data += AIT_LEN(&vals[i]);
                                                Limit += vals[i].val_len;                                                Limit += AIT_LEN(&vals[i]);
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > s->srv_netbuf) {
                                                         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 207  makeReply: Line 232  makeReply:
                                                 }                                                  }
   
                                                 memcpy(data, vals[i].val.string, vals[i].val_len);                                                  memcpy(data, vals[i].val.string, vals[i].val_len);
                                                data += vals[i].val_len;                                                data += AIT_LEN(&vals[i]);
                                                Limit += vals[i].val_len;                                                Limit += AIT_LEN(&vals[i]);
                                                 break;                                                  break;
                                         case blob:                                          case blob:
                                                 if (s->srv_blob.state == disable) {                                                  if (s->srv_blob.state == disable) {
Line 217  makeReply: Line 242  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]);                                /* don't add zero copy at this position, because buffer/string must be freed! */
                                 AIT_FREE_VAL(&vals[i]);
                         }                          }
                         rpc_srv_freeVars(f);                          rpc_srv_freeVars(f);
                         vals = NULL;                          vals = NULL;
                         argc = 0;                          argc = 0;
                 }                  }
   
                if ((ret = write(c->cli_sock, buf, Limit)) == -1) {                ret = send(c->cli_sock, buf, Limit, 0);
                 if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -8;                          ret = -8;
                         break;                          break;
Line 239  makeReply: Line 272  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);
         memset(c, 0, sizeof(rpc_cli_t));          memset(c, 0, sizeof(rpc_cli_t));
           free(buf);
         return (void*) (long)ret;          return (void*) (long)ret;
 }  }
   
Line 254  rpc_srv_dispatchVars(void *arg) Line 288  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 300  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 = read(c->cli_sock, buf, sizeof buf)) == -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 339  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 364  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 384  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 = write(c->cli_sock, buf, sizeof buf)) == -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 399  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 412  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 465  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 433  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int Line 475  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int
                 close(srv->srv_blob.server.cli_sock);                  close(srv->srv_blob.server.cli_sock);
                 return -1;                  return -1;
         }          }
           n = srv->srv_netbuf;
           if (setsockopt(srv->srv_blob.server.cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) {
                   LOGERR;
                   close(srv->srv_blob.server.cli_sock);
                   return -1;
           }
           if (setsockopt(srv->srv_blob.server.cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) {
                   LOGERR;
                   close(srv->srv_blob.server.cli_sock);
                   return -1;
           }
         if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa,           if (bind(srv->srv_blob.server.cli_sock, &srv->srv_blob.server.cli_sa, 
                                 sizeof srv->srv_blob.server.cli_sa) == -1) {                                  sizeof srv->srv_blob.server.cli_sa) == -1) {
                 LOGERR;                  LOGERR;
Line 458  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int Line 511  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int
         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 478  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 531  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 577  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 542  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 593  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv)
                                 break;                                  break;
                 if (i >= srv->srv_numcli) {                  if (i >= srv->srv_numcli) {
                         usleep(1000000);                          usleep(1000000);
   #ifdef HAVE_PTHREAD_YIELD
                           pthread_yield();
   #endif
                         continue;                          continue;
                 }                  }
   
Line 556  rpc_srv_execBLOBServer(rpc_srv_t * __restrict srv) Line 610  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 621  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 635  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 * @netBuf = Network buffer length, if =0 == BUFSIZ
  * @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 643  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)                int netBuf, 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 614  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 660  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         }          }
         if (!Port)          if (!Port)
                 Port = RPC_DEFPORT;                  Port = RPC_DEFPORT;
           if (!netBuf)
                   netBuf = BUFSIZ;
         if (csHost && family != AF_LOCAL) {          if (csHost && family != AF_LOCAL) {
                 host = gethostbyname2(csHost, family);                  host = gethostbyname2(csHost, family);
                 if (!host) {                  if (!host) {
Line 653  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 701  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         } else          } else
                 memset(srv, 0, sizeof(rpc_srv_t));                  memset(srv, 0, sizeof(rpc_srv_t));
   
           srv->srv_netbuf = netBuf;
         srv->srv_numcli = concurentClients;          srv->srv_numcli = concurentClients;
         srv->srv_session.sess_version = RPC_VERSION;          srv->srv_session.sess_version = RPC_VERSION;
         srv->srv_session.sess_program = regProgID;          srv->srv_session.sess_program = regProgID;
Line 674  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 723  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 687  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 735  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
                 free(srv);                  free(srv);
                 return NULL;                  return NULL;
         }          }
           n = srv->srv_netbuf;
           if (setsockopt(srv->srv_server.cli_sock, SOL_SOCKET, SO_SNDBUF, &n, sizeof n) == -1) {
                   LOGERR;
                   close(srv->srv_server.cli_sock);
                   free(srv);
                   return NULL;
           }
           if (setsockopt(srv->srv_server.cli_sock, SOL_SOCKET, SO_RCVBUF, &n, sizeof n) == -1) {
                   LOGERR;
                   close(srv->srv_server.cli_sock);
                   free(srv);
                   return NULL;
           }
         if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa, sizeof srv->srv_server.cli_sa) == -1) {          if (bind(srv->srv_server.cli_sock, &srv->srv_server.cli_sa, sizeof srv->srv_server.cli_sa) == -1) {
                 LOGERR;                  LOGERR;
                 close(srv->srv_server.cli_sock);                  close(srv->srv_server.cli_sock);
Line 781  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 842  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 793  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 853  rpc_srv_execServer(rpc_srv_t * __restrict srv)
                                 break;                                  break;
                 if (i >= srv->srv_numcli) {                  if (i >= srv->srv_numcli) {
                         usleep(1000000);                          usleep(1000000);
   #ifdef HAVE_PTHREAD_YIELD
                           pthread_yield();
   #endif
                         continue;                          continue;
                 }                  }
   
Line 807  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 870  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 880  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;
Line 842  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 898  rpc_srv_execServer(rpc_srv_t * __restrict srv)
  */   */
 int  int
 rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc,   rpc_srv_execCall(rpc_func_t * __restrict call, struct tagRPCCall * __restrict rpc, 
                rpc_val_t * __restrict args)                ait_val_t * __restrict args)
 {  {
         void *dl;          void *dl;
         rpc_callback_t func;          rpc_callback_t func;
Removed from v.1.3.2.8  
changed lines
  Added in v.1.4.2.2

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