[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.7 and 1.4.2.6

version 1.3.2.7, 2011/08/19 08:24:13 version 1.4.2.6, 2011/09/01 14:28:41
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;  
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
           array_t *arr;
         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;
         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;  
                 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 = recv(c->cli_sock, buf, BUFSIZ, 0)) == -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 102  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);                        arr = io_buffer2vals(buf + Limit, s->srv_netbuf - Limit, rpc->call_argc, 1);
                        // check RPC packet length                        if (!arr) {
                        if (rpc->call_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) { 
                                rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n"); 
                                 ret = -5;                                  ret = -5;
                                 goto makeReply;                                  goto makeReply;
                         } else  
                                 Limit += rpc->call_argc * sizeof(rpc_val_t);  
                         // RPC received variables types OK!  
                         data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);  
                         for (i = 0; i < rpc->call_argc; i++) {  
                                 switch (v[i].val_type) {  
                                         case buffer:  
                                                 if (v[i].val_len > BUFSIZ - Limit) {  
                                                         rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 } else  
                                                         Limit += v[i].val_len;  
   
                                                 v[i].val.buffer = data;  
                                                 data += v[i].val_len;  
                                                 break;  
                                         case string:  
                                                 if (v[i].val_len > BUFSIZ - Limit) {  
                                                         rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 } else  
                                                         Limit += v[i].val_len;  
   
                                                 v[i].val.string = (int8_t*) data;  
                                                 data += v[i].val_len;  
                                                 break;  
                                         case blob:  
                                                 if (s->srv_blob.state == disable) {  
                                                         rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n");  
                                                         ret = -5;  
                                                         goto makeReply;  
                                                 }  
                                         default:  
                                                 break;  
                                 }  
                         }                          }
                 }                  }
   
                   /* execute call */
                 argc = 0;                  argc = 0;
                 vals = NULL;  
                 memcpy(&ses, &rpc->call_session, sizeof ses);                  memcpy(&ses, &rpc->call_session, sizeof ses);
                 if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) {                  if (!(f = rpc_srv_getCall(s, rpc->call_tag, rpc->call_hash))) {
                         rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n");                          rpc_SetErr(EINVAL, "Error:: call not found into RPC server ...\n");
                         ret = -6;                          ret = -6;
                 } else                  } else
                        if ((ret = rpc_srv_execCall(f, rpc, v)) == -1)                        if ((ret = rpc_srv_execCall(f, rpc, arr)) == -1)
                                 ret = -9;                                  ret = -9;
                        else                        else {
                                argc = rpc_srv_getVars(f, &vals);                                if (arr)
                                         io_arrayDestroy(&arr);
                                 argc = rpc_srv_getVars(f, &arr);
                                 goto makeReply;         /* Call finish OK */
                         }
 
                 if (arr)
                         io_arrayDestroy(&arr);
 
 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 169  makeReply: Line 151  makeReply:
                 rrpc->ret_retcode = ret;                  rrpc->ret_retcode = ret;
                 rrpc->ret_argc = argc;                  rrpc->ret_argc = argc;
   
                if (argc && vals) {                if (argc && arr) {
                        v = (rpc_val_t*) (buf + Limit);                        /* Go Encapsulate variables ... */
                        if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        if ((i = io_vals2buffer(buf + Limit, s->srv_netbuf - Limit, arr)) == -1) {
                                for (i = 0; i < argc; i++)                                rpc_srv_freeVals(f);
                                        RPC_FREE_VAL(&vals[i]); 
                                rpc_srv_freeVars(f); 
                                vals = NULL; 
                                 argc = 0;                                  argc = 0;
                                 ret = -7;                                  ret = -7;
                                 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 += i;
                        memcpy(v, vals, argc * sizeof(rpc_val_t)); 
                        data = (u_char*) v + argc * sizeof(rpc_val_t); 
                        for (ret = i = 0; i < argc; i++) { 
                                switch (vals[i].val_type) { 
                                        case buffer: 
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) { 
                                                        rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); 
                                                        rrpc->ret_retcode = ret = -7; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
   
                                                memcpy(data, vals[i].val.buffer, vals[i].val_len);                                rpc_srv_freeVals(f);
                                                data += vals[i].val_len; 
                                                Limit += vals[i].val_len; 
                                                break; 
                                        case string: 
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) { 
                                                        rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n"); 
                                                        rrpc->ret_retcode = ret = -7; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
 
                                                memcpy(data, vals[i].val.string, vals[i].val_len); 
                                                data += vals[i].val_len; 
                                                Limit += vals[i].val_len; 
                                                break; 
                                        case blob: 
                                                if (s->srv_blob.state == disable) { 
                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is disabled\n"); 
                                                        rrpc->ret_retcode = ret = -5; 
                                                        rrpc->ret_argc = 0; 
                                                        break; 
                                                } 
                                        default: 
                                                break; 
                                } 
 
                                RPC_FREE_VAL(&vals[i]); 
                         }                          }
                         rpc_srv_freeVars(f);  
                         vals = NULL;  
                         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 178  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 194  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 206  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 245  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 270  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 290  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 305  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 318  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 371  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 381  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 451  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int Line 410  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, int
   
         pthread_mutex_init(&srv->srv_blob.mtx, NULL);          pthread_mutex_init(&srv->srv_blob.mtx, NULL);
   
         pthread_mutex_lock(&srv->srv_mtx);  
         rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);          rpc_srv_registerCall(srv, NULL, CALL_BLOBSHUTDOWN, 0);
        rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 0);        rpc_srv_registerCall(srv, NULL, CALL_BLOBCLIENTS, 1);
        rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 0);        rpc_srv_registerCall(srv, NULL, CALL_BLOBVARS, 1);
        rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);        rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 0);
        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 435  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 481  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 497  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 514  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 525  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 539  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 (also meaning max RPC packet)
  * @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 547  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 564  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 605  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 627  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 639  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 707  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 672  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         pthread_mutex_init(&srv->srv_mtx, NULL);          pthread_mutex_init(&srv->srv_mtx, NULL);
   
         rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);          rpc_srv_registerCall(srv, NULL, CALL_SRVSHUTDOWN, 0);
        rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 1);
        rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);
        rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 0);        rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 1);
         return srv;          return srv;
 }  }
   
Line 781  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 746  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 757  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 774  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 784  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 837  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 797  rpc_srv_execServer(rpc_srv_t * __restrict srv)
  * rpc_srv_execCall() Execute registered call from RPC server   * rpc_srv_execCall() Execute registered call from RPC server
  * @call = Register RPC call   * @call = Register RPC call
  * @rpc = IN RPC call structure   * @rpc = IN RPC call structure
 * @args = IN RPC call array of rpc values * @args = IN RPC calling arguments from RPC client
  * return: -1 error, !=-1 ok   * return: -1 error, !=-1 ok
  */   */
 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)                array_t * __restrict args)
 {  {
         void *dl;          void *dl;
         rpc_callback_t func;          rpc_callback_t func;
Removed from v.1.3.2.7  
changed lines
  Added in v.1.4.2.6

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