[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.11 and 1.4.2.1

version 1.3.2.11, 2011/08/19 14:39:23 version 1.4.2.1, 2011/08/29 23:26:56
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;
Line 106  rpc_srv_dispatchCall(void *arg) Line 106  rpc_srv_dispatchCall(void *arg)
                         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 */                          /* check RPC packet length */
                        if (rpc->call_argc * sizeof(rpc_val_t) > sizeof buf - Limit) {                        if (rpc->call_argc * sizeof(ait_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! */                          /* RPC received variables types OK! */
                        data = (u_char*) v + rpc->call_argc * sizeof(rpc_val_t);                        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 (v[i].val_type) {
                                         case buffer:                                          case buffer:
Line 183  makeReply: Line 183  makeReply:
                 rrpc->ret_argc = argc;                  rrpc->ret_argc = argc;
   
                 if (argc && vals) {                  if (argc && vals) {
                        v = (rpc_val_t*) (buf + Limit);                        v = (ait_val_t*) (buf + Limit);
                        if (argc * sizeof(rpc_val_t) > sizeof buf - Limit) {                        if (argc * sizeof(ait_val_t) > sizeof buf - 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 194  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);                        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 (vals[i].val_type) {
                                         case buffer:                                          case buffer:
Line 240  makeReply: Line 240  makeReply:
                                                 break;                                                  break;
                                 }                                  }
   
                                RPC_FREE_VAL(&vals[i]);                                AIT_FREE_VAL(&vals[i]);
                         }                          }
                         rpc_srv_freeVars(f);                          rpc_srv_freeVars(f);
                         vals = NULL;                          vals = NULL;
Line 289  rpc_srv_dispatchVars(void *arg) Line 289  rpc_srv_dispatchVars(void *arg)
                 /* 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 484  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;
 }  }
   
Line 848  rpc_srv_execServer(rpc_srv_t * __restrict srv) Line 850  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.11  
changed lines
  Added in v.1.4.2.1

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