[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.26.2.8 and 1.26.2.12

version 1.26.2.8, 2015/06/29 22:29:26 version 1.26.2.12, 2015/07/02 21:52:29
Line 70  static void *rxEXTPacket(sched_task_t *); Line 70  static void *rxEXTPacket(sched_task_t *);
 static void *txEXTPacket(sched_task_t *);  static void *txEXTPacket(sched_task_t *);
   
 static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4] = {  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4] = {
        { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */        { acceptClients, closeClient, rxPacket, txPacket },             /* SOCK_STREAM */
        { acceptClients, closeClient, rxPacket, txPacket },     /* SOCK_STREAM */        { acceptClients, closeClient, rxPacket, txPacket },             /* SOCK_STREAM */
        { rxUDPPacket, freeClient, rxUDPPacket, txUDPPacket },        /* SOCK_DGRAM */        { rxUDPPacket, freeClient, NULL /*rxUDPPacket*/, txUDPPacket },        /* SOCK_DGRAM */
        { rxRAWPacket, freeClient, rxRAWPacket, txRAWPacket },        /* SOCK_RAW */        { rxRAWPacket, freeClient, NULL /*rxRAWPacket*/, txRAWPacket },        /* SOCK_RAW */
        { rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket },        /* SOCK_BPF */        { rxBPFPacket, freeClient, NULL /*rxBPFPacket*/, txBPFPacket },        /* SOCK_BPF */
        { rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket } /* SOCK_EXT */        { rxEXTPacket, freeClient, NULL /*rxEXTPacket*/, txEXTPacket } /* SOCK_EXT */
 };  };
   
 /* Global Signal Argument when kqueue support disabled */  /* Global Signal Argument when kqueue support disabled */
   
 static volatile uintptr_t _glSigArg = 0;  static volatile uintptr_t _glSigArg = 0;
   
   #pragma GCC visibility push(hidden)
   
   static int
   rpc_funcs_cmp(struct tagRPCFunc *a, struct tagRPCFunc *b)
   {
           int ret;
   
           assert(a && b);
   
           ret = AIT_KEY(&a->func_name) - AIT_KEY(&b->func_name);
   
           if (ret < 0)
                   return -1;
           else if (ret > 0)
                   return 1;
   
           return ret;
   }
   
   AVL_GENERATE(tagRPCFuncs, tagRPCFunc, func_node, rpc_funcs_cmp);
   
   #pragma GCC visibility pop
   
 void  void
 rpc_freeCli(rpc_cli_t * __restrict c)  rpc_freeCli(rpc_cli_t * __restrict c)
 {  {
Line 197  txPacket(sched_task_t *task) Line 219  txPacket(sched_task_t *task)
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 214  txPacket(sched_task_t *task) Line 236  txPacket(sched_task_t *task)
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                rpc->call_rep.ret = RPC_ERROR(-1);                                RPC_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 263  execCall(sched_task_t *task) Line 285  execCall(sched_task_t *task)
                         rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());                          rpc_SetErr(ERPCMISMATCH, "#%d - %s", elwix_GetErrno(), elwix_GetError());
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                         taskExit(task, NULL);                          taskExit(task, NULL);
                 }                  }
         } else          } else
Line 274  execCall(sched_task_t *task) Line 296  execCall(sched_task_t *task)
                 rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                  rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
         } else {          } else {
                 /* if client doesn't want reply */                  /* if client doesn't want reply */
                rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(c, rpc, f->func_name, arr));                RPC_SET_RETURN(rpc, rpc_srv_execCall(c, rpc, f->func_name, arr));
                 if (rpc->call_rep.ret == htonl(-1)) {                  if (rpc->call_rep.ret == htonl(-1)) {
                         if (!rpc->call_rep.eno) {                          if (!rpc->call_rep.eno) {
                                 LOGERR;                                  LOGERR;
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         }                          }
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
Line 313  rxPacket(sched_task_t *task) Line 335  rxPacket(sched_task_t *task)
         u_short crc;          u_short crc;
 #endif  #endif
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
           u_char b[sizeof(struct tagRPCCall)];
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
 #ifdef TCP_SESSION_TIMEOUT  #ifdef TCP_SESSION_TIMEOUT
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
Line 322  rxPacket(sched_task_t *task) Line 345  rxPacket(sched_task_t *task)
                          TASK_ARG(task), ts, TASK_ARG(task), 0);                           TASK_ARG(task), ts, TASK_ARG(task), 0);
 #endif  #endif
   
           /* prepare rx */
           len = recv(TASK_FD(task), b, sizeof b, MSG_PEEK);
           if (len == sizeof b)
                   rlen = ntohl(((struct tagRPCCall*) b)->call_len);
   
         rlen = recv(TASK_FD(task), buf, rlen, 0);          rlen = recv(TASK_FD(task), buf, rlen, 0);
         if (rlen == -1) {          if (rlen == -1) {
                 /* close connection */                  /* close connection */
Line 333  rxPacket(sched_task_t *task) Line 361  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         } else          } else
                 len = ntohl(rpc->call_len);                  len = ntohl(rpc->call_len);
Line 342  rxPacket(sched_task_t *task) Line 370  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
   
Line 361  rxPacket(sched_task_t *task) Line 389  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
 #endif  #endif
Line 372  rxPacket(sched_task_t *task) Line 400  rxPacket(sched_task_t *task)
                 rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                  rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
   
                 rpc->call_argc ^= rpc->call_argc;                  rpc->call_argc ^= rpc->call_argc;
                rpc->call_rep.ret = RPC_ERROR(-1);                RPC_SET_RETURN(rpc, -1);
                rpc->call_rep.eno = RPC_ERROR(errno);                RPC_SET_ERRNO(rpc, rpc_Errno);
                 goto err;                  goto err;
         }          }
   
Line 458  txUDPPacket(sched_task_t *task) Line 486  txUDPPacket(sched_task_t *task)
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 475  txUDPPacket(sched_task_t *task) Line 503  txUDPPacket(sched_task_t *task)
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                rpc->call_rep.ret = RPC_ERROR(-1);                                RPC_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 598  txRAWPacket(sched_task_t *task) Line 626  txRAWPacket(sched_task_t *task)
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 613  txRAWPacket(sched_task_t *task) Line 641  txRAWPacket(sched_task_t *task)
                                         RPC_RETVARS(c));                                          RPC_RETVARS(c));
                         if (ret == -1) {                          if (ret == -1) {
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                rpc->call_rep.ret = RPC_ERROR(-1);                                RPC_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 758  txBPFPacket(sched_task_t *task) Line 787  txBPFPacket(sched_task_t *task)
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 775  txBPFPacket(sched_task_t *task) Line 804  txBPFPacket(sched_task_t *task)
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                rpc->call_rep.ret = RPC_ERROR(-1);                                RPC_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 921  txEXTPacket(sched_task_t *task) Line 950  txEXTPacket(sched_task_t *task)
                         rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");                          rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {                  } else if (rpc_pktFreeSpace(c) > s->srv_netbuf) {
                         rpc_SetErr(EMSGSIZE, "Message too long");                          rpc_SetErr(EMSGSIZE, "Message too long");
   
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                        rpc->call_rep.ret = RPC_ERROR(-1);                        RPC_SET_RETURN(rpc, -1);
                        rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                        RPC_SET_ERRNO(rpc, rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));                          rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
Line 938  txEXTPacket(sched_task_t *task) Line 967  txEXTPacket(sched_task_t *task)
                                 rpc_SetErr(EBADRPC, "Prepare RPC packet failed");                                  rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
   
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                                rpc->call_rep.ret = RPC_ERROR(-1);                                RPC_SET_RETURN(rpc, -1);
                                rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                RPC_SET_ERRNO(rpc, rpc_Errno);
                         } else                          } else
                                 wlen += ret;                                  wlen += ret;
                 }                  }
Line 1111  rxBLOB(sched_task_t *task) Line 1140  rxBLOB(sched_task_t *task)
                         if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {                          if (!(b = rpc_srv_getBLOB(s, ntohl(blob.hdr_var)))) {
                                 rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));                                  rpc_SetErr(EINVAL, "Var=%x not found", ntohl(blob.hdr_var));
                                 blob.hdr_cmd = no;                                  blob.hdr_cmd = no;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                                 break;                                  break;
                         } else                          } else
                                 blob.hdr_len = htonl(b->blob_len);                                  blob.hdr_len = htonl(b->blob_len);
Line 1122  rxBLOB(sched_task_t *task) Line 1151  rxBLOB(sched_task_t *task)
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 case set:                  case set:
Line 1136  rxBLOB(sched_task_t *task) Line 1165  rxBLOB(sched_task_t *task)
                                 rpc_srv_blobUnmap(b);                                  rpc_srv_blobUnmap(b);
                         } else {                          } else {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 case unset:                  case unset:
                         if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) {                          if (rpc_srv_unregisterBLOB(s, ntohl(blob.hdr_var)) == -1) {
                                 blob.hdr_cmd = error;                                  blob.hdr_cmd = error;
                                blob.hdr_ret = RPC_ERROR(-1);                                RPC_SET_BLOB_RET(&blob, -1);
                         }                          }
                         break;                          break;
                 default:                  default:
                         rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);                          rpc_SetErr(EPROCUNAVAIL, "Unsupported BLOB command %d", blob.hdr_cmd);
                         blob.hdr_cmd = error;                          blob.hdr_cmd = error;
                        blob.hdr_ret = RPC_ERROR(-1);                        RPC_SET_BLOB_RET(&blob, -1);
         }          }
   
 end:  end:
Removed from v.1.26.2.8  
changed lines
  Added in v.1.26.2.12

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