[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.10 and 1.3.2.12

version 1.3.2.10, 2011/08/19 14:24:54 version 1.3.2.12, 2011/08/19 14:41:23
Line 87  rpc_srv_dispatchCall(void *arg) Line 87  rpc_srv_dispatchCall(void *arg)
                         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) > sizeof buf - 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 > sizeof buf - 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 131  rpc_srv_dispatchCall(void *arg) Line 131  rpc_srv_dispatchCall(void *arg)
                                                 break;                                                  break;
                                         case string:                                          case string:
                                                 if (v[i].val_len > sizeof buf - 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:
                   /* made reply */
                 memset(buf, 0, sizeof buf);                  memset(buf, 0, sizeof buf);
                 rrpc = (struct tagRPCRet*) buf;                  rrpc = (struct tagRPCRet*) buf;
                 Limit = sizeof(struct tagRPCRet);                  Limit = sizeof(struct tagRPCRet);
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);
                         pthread_yield();                          pthread_yield();
Line 321  rpc_srv_dispatchVars(void *arg) Line 323  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 348  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 368  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 484  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.10  
changed lines
  Added in v.1.3.2.12

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