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

version 1.4, 2011/08/29 22:37:06 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);
Line 80  rpc_srv_dispatchCall(void *arg) Line 86  rpc_srv_dispatchCall(void *arg)
                         ret = -2;                          ret = -2;
                         break;                          break;
                 }                  }
                memset(buf, 0, sizeof buf);                memset(buf, 0, s->srv_netbuf);
                ret = recv(c->cli_sock, buf, sizeof buf, 0);                ret = recv(c->cli_sock, buf, s->srv_netbuf, 0);
                 if (ret == -1) {                  if (ret == -1) {
                         LOGERR;                          LOGERR;
                         ret = -3;                          ret = -3;
Line 104  rpc_srv_dispatchCall(void *arg) Line 110  rpc_srv_dispatchCall(void *arg)
                         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) > sizeof buf - Limit) { 
                                 rpc_SetErr(EMSGSIZE, "Error:: too long 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(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 > sizeof buf - Limit) {                                                if (AIT_LEN(&v[i]) > s->srv_netbuf - Limit) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: too long 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 > sizeof buf - Limit) {                                                if (AIT_LEN(&v[i]) > s->srv_netbuf - Limit) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: too long 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 154  rpc_srv_dispatchCall(void *arg) Line 161  rpc_srv_dispatchCall(void *arg)
                                         default:                                          default:
                                                 break;                                                  break;
                                 }                                  }
   
                                   AIT_ADDZCOPY(&v[i]);
                         }                          }
                 }                  }
   
Line 171  rpc_srv_dispatchCall(void *arg) Line 180  rpc_srv_dispatchCall(void *arg)
                                 argc = rpc_srv_getVars(f, &vals);                                  argc = rpc_srv_getVars(f, &vals);
 makeReply:  makeReply:
                 /* made reply */                  /* made reply */
                memset(buf, 0, sizeof buf);                memset(buf, 0, s->srv_netbuf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
   
Line 183  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) > sizeof buf - 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 194  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 > sizeof buf) {                                                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 208  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 > sizeof buf) {                                                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 220  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 240  makeReply: Line 252  makeReply:
                                                 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;
Line 264  makeReply: Line 277  makeReply:
         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 461  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 475  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
                 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 568  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 607  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
    * @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 614  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, 
                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 631  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 670  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 703  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 808  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 850  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.4  
changed lines
  Added in v.1.4.2.2

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