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

version 1.3.2.9, 2011/08/19 12:51:50 version 1.3.2.13, 2011/08/19 14:44:34
Line 80  rpc_srv_dispatchCall(void *arg) Line 80  rpc_srv_dispatchCall(void *arg)
                         ret = -2;                          ret = -2;
                         break;                          break;
                 }                  }
                memset(buf, 0, BUFSIZ);                memset(buf, 0, sizeof buf);
                ret = recv(c->cli_sock, buf, BUFSIZ, 0);                ret = recv(c->cli_sock, buf, sizeof buf, 0);
                 if (ret == -1) {                  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 97  rpc_srv_dispatchCall(void *arg) Line 97  rpc_srv_dispatchCall(void *arg)
                         break;                          break;
                 } else                  } else
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
                // check RPC packet session info                /* check RPC packet session info */
                 if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) {                  if (memcmp(&rpc->call_session, &s->srv_session, sizeof rpc->call_session)) {
                         rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");                          rpc_SetErr(EINVAL, "Error:: get invalid RPC session ...\n");
                         ret = -5;                          ret = -5;
                         goto makeReply;                          goto makeReply;
                 } else                  } else
                         Limit = sizeof(struct tagRPCCall);                          Limit = sizeof(struct tagRPCCall);
                // RPC is OK! Go decapsulate variables ...                /* RPC is OK! Go decapsulate variables ... */
                 if (rpc->call_argc) {                  if (rpc->call_argc) {
                         v = (rpc_val_t*) (buf + Limit);                          v = (rpc_val_t*) (buf + Limit);
                        // check RPC packet length                        /* check RPC packet length */
                        if (rpc->call_argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        if (rpc->call_argc * sizeof(rpc_val_t) > sizeof buf - Limit) {
                                rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                 ret = -5;                                  ret = -5;
                                 goto makeReply;                                  goto makeReply;
                         } else                          } else
                                 Limit += rpc->call_argc * sizeof(rpc_val_t);                                  Limit += rpc->call_argc * sizeof(rpc_val_t);
                        // RPC received variables types OK!                        /* RPC received variables types OK! */
                         data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);                          data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);
                         for (i = 0; i < rpc->call_argc; i++) {                          for (i = 0; i < rpc->call_argc; i++) {
                                 switch (v[i].val_type) {                                  switch (v[i].val_type) {
                                         case buffer:                                          case buffer:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (v[i].val_len > sizeof buf - Limit) {
                                                        rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                                        rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 } else                                                  } else
Line 130  rpc_srv_dispatchCall(void *arg) Line 130  rpc_srv_dispatchCall(void *arg)
                                                 data += v[i].val_len;                                                  data += v[i].val_len;
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (v[i].val_len > BUFSIZ - Limit) {                                                if (v[i].val_len > sizeof buf - Limit) {
                                                        rpc_SetErr(EMSGSIZE, "Error:: Too big RPC packet ...\n");                                                        rpc_SetErr(EMSGSIZE, "Error:: too long RPC packet ...\n");
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 } else                                                  } else
Line 147  rpc_srv_dispatchCall(void *arg) Line 147  rpc_srv_dispatchCall(void *arg)
                                                         goto makeReply;                                                          goto makeReply;
                                                 }                                                  }
                                                 if (s->srv_blob.state == kill) {                                                  if (s->srv_blob.state == kill) {
                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is killed\n");                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is gone.\n");
                                                         ret = -5;                                                          ret = -5;
                                                         goto makeReply;                                                          goto makeReply;
                                                 }                                                  }
Line 157  rpc_srv_dispatchCall(void *arg) Line 157  rpc_srv_dispatchCall(void *arg)
                         }                          }
                 }                  }
   
                   /* 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 169  rpc_srv_dispatchCall(void *arg) Line 170  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, sizeof buf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
   
Line 182  makeReply: Line 184  makeReply:
   
                 if (argc && vals) {                  if (argc && vals) {
                         v = (rpc_val_t*) (buf + Limit);                          v = (rpc_val_t*) (buf + Limit);
                        if (argc * sizeof(rpc_val_t) > BUFSIZ - Limit) {                        if (argc * sizeof(rpc_val_t) > sizeof buf - Limit) {
                                 for (i = 0; i < argc; i++)                                  for (i = 0; i < argc; i++)
                                         RPC_FREE_VAL(&vals[i]);                                          RPC_FREE_VAL(&vals[i]);
                                 rpc_srv_freeVars(f);                                  rpc_srv_freeVars(f);
Line 198  makeReply: Line 200  makeReply:
                         for (ret = i = 0; i < argc; i++) {                          for (ret = i = 0; i < argc; i++) {
                                 switch (vals[i].val_type) {                                  switch (vals[i].val_type) {
                                         case buffer:                                          case buffer:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > sizeof buf) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");                                                          rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");
                                                         rrpc->ret_retcode = ret = -7;                                                          rrpc->ret_retcode = ret = -7;
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
Line 210  makeReply: Line 212  makeReply:
                                                 Limit += vals[i].val_len;                                                  Limit += vals[i].val_len;
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                if (ret || Limit + vals[i].val_len > BUFSIZ) {                                                if (ret || Limit + vals[i].val_len > sizeof buf) {
                                                         rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");                                                          rpc_SetErr(EMSGSIZE, "Error:: in prepare RPC packet (-7) ...\n");
                                                         rrpc->ret_retcode = ret = -7;                                                          rrpc->ret_retcode = ret = -7;
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
Line 229  makeReply: Line 231  makeReply:
                                                         break;                                                          break;
                                                 }                                                  }
                                                 if (s->srv_blob.state == kill) {                                                  if (s->srv_blob.state == kill) {
                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is killed\n");                                                        rpc_SetErr(ENOTSUP, "Error:: BLOB server is gone.\n");
                                                         rrpc->ret_retcode = ret = -5;                                                          rrpc->ret_retcode = ret = -5;
                                                         rrpc->ret_argc = 0;                                                          rrpc->ret_argc = 0;
                                                         break;                                                          break;
Line 284  rpc_srv_dispatchVars(void *arg) Line 286  rpc_srv_dispatchVars(void *arg)
                 s = c->cli_parent;                  s = c->cli_parent;
   
         do {          do {
                // check for disable service at this moment?                /* check for disable service at this moment? */
                 if (s->srv_blob.state == disable && s->srv_kill != kill) {                  if (s->srv_blob.state == disable && s->srv_kill != kill) {
                         usleep(100000);                          usleep(100000);
   #ifdef HAVE_PTHREAD_YIELD
                         pthread_yield();                          pthread_yield();
   #endif
                         continue;                          continue;
                 }                  }
   
Line 321  rpc_srv_dispatchVars(void *arg) Line 325  rpc_srv_dispatchVars(void *arg)
                         break;                          break;
                 } else                  } else
                         blob = (struct tagBLOBHdr*) buf;                          blob = (struct tagBLOBHdr*) buf;
                // check BLOB packet session info                /* check BLOB packet session info */
                 if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) {                  if (memcmp(&blob->hdr_session, &s->srv_session, sizeof blob->hdr_session)) {
                         rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n");                          rpc_SetErr(EINVAL, "Error:: get invalid BLOB session ...\n");
                         ret = -5;                          ret = -5;
                         goto makeReply;                          goto makeReply;
                 }                  }
                // Go to proceed packet ...                /* Go to proceed packet ... */
                 switch (blob->hdr_cmd) {                  switch (blob->hdr_cmd) {
                         case get:                          case get:
                                 if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) {                                  if (!(b = rpc_srv_getBLOB(s, blob->hdr_var))) {
Line 346  rpc_srv_dispatchVars(void *arg) Line 350  rpc_srv_dispatchVars(void *arg)
                                 break;                                  break;
                         case set:                          case set:
                                 if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) {                                  if ((b = rpc_srv_registerBLOB(s, blob->hdr_len))) {
                                        // set new BLOB variable for reply :)                                        /* set new BLOB variable for reply :) */
                                         blob->hdr_var = b->blob_var;                                          blob->hdr_var = b->blob_var;
   
                                         ret = rpc_srv_recvBLOB(c, b);                                          ret = rpc_srv_recvBLOB(c, b);
Line 366  rpc_srv_dispatchVars(void *arg) Line 370  rpc_srv_dispatchVars(void *arg)
                 }                  }
   
 makeReply:  makeReply:
                // Replay to client!                /* Replay to client! */
                 blob->hdr_cmd = ret < 0 ? error : ok;                  blob->hdr_cmd = ret < 0 ? error : ok;
                 blob->hdr_ret = ret;                  blob->hdr_ret = ret;
                 ret = send(c->cli_sock, buf, sizeof buf, 0);                  ret = send(c->cli_sock, buf, sizeof buf, 0);
Line 482  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 486  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
         rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);          rpc_srv_registerCall(srv, NULL, CALL_BLOBSTATE, 1);
         pthread_mutex_unlock(&srv->srv_mtx);          pthread_mutex_unlock(&srv->srv_mtx);
   
        srv->srv_blob.state = enable;   // enable BLOB        srv->srv_blob.state = enable;   /* enable BLOB */
         return 0;          return 0;
 }  }
   
Removed from v.1.3.2.9  
changed lines
  Added in v.1.3.2.13

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