[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.6.2.10 and 1.7.2.4

version 1.6.2.10, 2012/03/15 01:22:55 version 1.7.2.4, 2012/03/29 01:23:59
Line 60  txPacket(sched_task_t *task) Line 60  txPacket(sched_task_t *task)
         int ret, wlen = sizeof(struct tagRPCCall);          int ret, wlen = sizeof(struct tagRPCCall);
         array_t *arr = NULL;          array_t *arr = NULL;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag), ntohl(rpc->call_hash));
Line 83  txPacket(sched_task_t *task) Line 83  txPacket(sched_task_t *task)
                 }                  }
         }          }
   
           rpc->call_len = htons(wlen);
   
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
        rpc->call_crc = htons(crcFletcher16((u_short*) buf, io_align(wlen, 1) / 2));        rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   
         /* send reply */          /* send reply */
         ret = send(TASK_FD(task), buf, wlen, 0);          ret = send(TASK_FD(task), buf, wlen, 0);
Line 95  txPacket(sched_task_t *task) Line 97  txPacket(sched_task_t *task)
                 rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "                  rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "
                                 "really sended %d bytes", wlen, ret);                                  "really sended %d bytes", wlen, ret);
         else          else
                LOGGER("Sended %d bytes", ret);                ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", ret);
   
         return NULL;          return NULL;
 }  }
Line 107  execCall(sched_task_t *task) Line 109  execCall(sched_task_t *task)
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
         array_t *arr = NULL;          array_t *arr = NULL;
        u_char *buf = TASK_DATA(task);        u_char *buf = TASK_DATA(task) + TASK_VAL(task);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
         int argc = ntohs(rpc->call_argc);          int argc = ntohs(rpc->call_argc);
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         /* Go decapsulate variables ... */          /* Go decapsulate variables ... */
        if (!(rpc->call_req.flags & RPC_NOREPLY) && argc) {        if (argc) {
                 arr = io_buffer2vars(buf + sizeof(struct tagRPCCall),                   arr = io_buffer2vars(buf + sizeof(struct tagRPCCall), 
                                TASK_DATLEN(task) - sizeof(struct tagRPCCall), argc, 1);                                TASK_DATLEN(task) - TASK_VAL(task) - sizeof(struct tagRPCCall), 
                                 argc, 1);
                 if (!arr) {                  if (!arr) {
                         rpc_SetErr(ERPCMISMATCH, "#%d - %s", io_GetErrno(), io_GetError());                          rpc_SetErr(ERPCMISMATCH, "#%d - %s", io_GetErrno(), io_GetError());
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
Line 132  execCall(sched_task_t *task) Line 135  execCall(sched_task_t *task)
                 rpc->call_rep.ret = RPC_ERROR(-1);                  rpc->call_rep.ret = RPC_ERROR(-1);
                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
         } else {          } else {
                LOGGER("RPC function %s from module %s", AIT_GET_STR(&f->func_name),                 ioDEBUG(RPC_DEBUG_LEVEL, "RPC function %s from module %s", 
                                AIT_GET_LIKE(&f->func_file, char*));                                AIT_GET_STR(&f->func_name), AIT_GET_LIKE(&f->func_file, char*));
   
                   /* if client doesn't want reply */
                   argc = rpc->call_req.flags & RPC_NOREPLY;
                 rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(f, rpc, arr));                  rpc->call_rep.ret = RPC_ERROR(rpc_srv_execCall(f, rpc, arr));
                 if (rpc->call_rep.ret == htonl(-1)) {                  if (rpc->call_rep.ret == htonl(-1)) {
                         rpc->call_rep.eno = RPC_ERROR(errno);                          rpc->call_rep.eno = RPC_ERROR(errno);
                         rpc->call_argc ^= rpc->call_argc;                          rpc->call_argc ^= rpc->call_argc;
                 } else {                  } else {
                         rpc->call_rep.eno ^= rpc->call_rep.eno;                          rpc->call_rep.eno ^= rpc->call_rep.eno;
                        rpc->call_argc = htons(rpc_srv_getVars(f, NULL));                        if (argc) {
                                 /* without reply */
                                 io_clrVars(f->func_vars);
                                 rpc->call_argc ^= rpc->call_argc;
                         } else
                                 rpc->call_argc = htons(rpc_srv_getVars(f, NULL));
                 }                  }
         }          }
   
Line 156  rxPacket(sched_task_t *task) Line 166  rxPacket(sched_task_t *task)
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
         rpc_srv_t *s = c->cli_parent;          rpc_srv_t *s = c->cli_parent;
         u_char *buf = TASK_DATA(task);          u_char *buf = TASK_DATA(task);
        int rlen;        int rlen, noreply;
        u_short crc;        u_short crc, off = 0;
         struct tagRPCCall *rpc;          struct tagRPCCall *rpc;
         struct timespec ts;          struct timespec ts;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         memset(buf, 0, TASK_DATLEN(task));          memset(buf, 0, TASK_DATLEN(task));
         rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);          rlen = recv(TASK_FD(task), buf, TASK_DATLEN(task), 0);
Line 173  rxPacket(sched_task_t *task) Line 183  rxPacket(sched_task_t *task)
                 s->srv_kill = s->srv_blob.state = kill;                  s->srv_kill = s->srv_blob.state = kill;
                 return NULL;                  return NULL;
         } else          } else
                LOGGER("Readed %d bytes", rlen);                ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen);
   
        if (rlen < sizeof(struct tagRPCCall)) {        do {
                rpc_SetErr(ERPCMISMATCH, "Too short RPC packet");                if (rlen < sizeof(struct tagRPCCall)) {
                         rpc_SetErr(ERPCMISMATCH, "Too short RPC packet");
   
                schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task),                         schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task), 
                                TASK_DATA(task), TASK_DATLEN(task));                                        TASK_DATA(task), TASK_DATLEN(task));
                return NULL;                        return NULL;
        } else                } else
                rpc = (struct tagRPCCall*) buf;                        rpc = (struct tagRPCCall*) (buf + off);
   
        /* check integrity of packet */                rlen -= ntohs(rpc->call_len);
        crc = ntohs(rpc->call_crc); 
        rpc->call_crc ^= rpc->call_crc; 
        if (crc != crcFletcher16((u_short*) buf, io_align(rlen, 1) / 2)) { 
                rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet"); 
   
                schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task),                 /* check integrity of packet */
                                TASK_DATA(task), TASK_DATLEN(task));                crc = ntohs(rpc->call_crc);
                return NULL;                rpc->call_crc ^= rpc->call_crc;
        }                if (crc != crcFletcher16((u_short*) (buf + off), ntohs(rpc->call_len) / 2)) {
                         rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
   
        /* check RPC packet session info */                        off += ntohs(rpc->call_len);
        if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {                        if (rlen < 1)
                rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                                break;
                rpc->call_argc ^= rpc->call_argc;                        else
                rpc->call_rep.ret = RPC_ERROR(-1);                                continue;
                rpc->call_rep.eno = RPC_ERROR(errno);                }
                goto end; 
        } else { 
                /* change socket timeout from last packet */ 
                ts.tv_sec = rpc->call_session.sess_timeout; 
                ts.tv_nsec = 0; 
                schedPolling(TASK_ROOT(task), &ts, NULL); 
        } 
   
        /* execute RPC call */                noreply = rpc->call_req.flags & RPC_NOREPLY;
        schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), 0,  
                        TASK_DATA(task), TASK_DATLEN(task)); 
   
end:                /* check RPC packet session info */
        /* send RPC reply */                if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {
        if (!(rpc->call_req.flags & RPC_NOREPLY))                        rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
                schedWrite(TASK_ROOT(task), txPacket, TASK_ARG(task), TASK_FD(task),                         rpc->call_argc ^= rpc->call_argc;
                                TASK_DATA(task), TASK_DATLEN(task));                        rpc->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(errno);
                 } else {
                         /* change socket timeout from last packet */
                         ts.tv_sec = rpc->call_session.sess_timeout;
                         ts.tv_nsec = 0;
                         schedPolling(TASK_ROOT(task), &ts, NULL);
 
                         /* execute RPC call */
                         schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), off, 
                                         TASK_DATA(task), TASK_DATLEN(task));
                 }
 
                 /* send RPC reply */
                 if (!noreply)
                         schedWrite(TASK_ROOT(task), txPacket, TASK_ARG(task), TASK_FD(task), 
                                         buf + off, TASK_DATLEN(task) - off);
 
                 off += ntohs(rpc->call_len);
         } while (rlen > 0);
 
         /* lets get next packet */          /* lets get next packet */
         schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task),           schedRead(TASK_ROOT(task), rxPacket, TASK_ARG(task), TASK_FD(task), 
                         TASK_DATA(task), TASK_DATLEN(task));                          TASK_DATA(task), TASK_DATLEN(task));
Line 233  rpc_srv_dispatchCall(void *arg) Line 252  rpc_srv_dispatchCall(void *arg)
         sched_root_task_t *root;          sched_root_task_t *root;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!arg) {          if (!arg) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t procced RPC client");                  rpc_SetErr(EINVAL, "Invalid parameter can`t procced RPC client");
Line 278  txBLOB(sched_task_t *task) Line 297  txBLOB(sched_task_t *task)
         struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf;          struct tagBLOBHdr *blob = (struct tagBLOBHdr *) buf;
         int wlen = sizeof(struct tagBLOBHdr);          int wlen = sizeof(struct tagBLOBHdr);
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         /* calculate CRC */          /* calculate CRC */
         blob->hdr_crc ^= blob->hdr_crc;          blob->hdr_crc ^= blob->hdr_crc;
        blob->hdr_crc = htons(crcFletcher16((u_short*) buf, io_align(wlen, 1) / 2));        blob->hdr_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   
         /* send reply */          /* send reply */
         wlen = send(TASK_FD(task), buf, wlen, 0);          wlen = send(TASK_FD(task), buf, wlen, 0);
Line 292  txBLOB(sched_task_t *task) Line 311  txBLOB(sched_task_t *task)
                 rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "                  rpc_SetErr(EPROCUNAVAIL, "RPC reply, should be send %d bytes, "
                                 "really sended %d bytes", sizeof(struct tagBLOBHdr), wlen);                                  "really sended %d bytes", sizeof(struct tagBLOBHdr), wlen);
         else          else
                LOGGER("Sended %d bytes", wlen);                ioDEBUG(RPC_DEBUG_LEVEL, "Sended %d bytes", wlen);
   
         return NULL;          return NULL;
 }  }
Line 309  rxBLOB(sched_task_t *task) Line 328  rxBLOB(sched_task_t *task)
         u_short crc;          u_short crc;
         struct timespec ts;          struct timespec ts;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         /* check for disable service at this moment? */          /* check for disable service at this moment? */
        if (s->srv_blob.state == disable) {        if (!s || s->srv_blob.state == disable) {
                 usleep(100000);                  usleep(100000);
 #ifdef HAVE_PTHREAD_YIELD  #ifdef HAVE_PTHREAD_YIELD
                 pthread_yield();                  pthread_yield();
Line 332  rxBLOB(sched_task_t *task) Line 351  rxBLOB(sched_task_t *task)
                 s->srv_blob.state = kill;                  s->srv_blob.state = kill;
                 return NULL;                  return NULL;
         } else          } else
                LOGGER("Readed %d bytes", rlen);                ioDEBUG(RPC_DEBUG_LEVEL, "Readed %d bytes", rlen);
   
         if (rlen < sizeof(struct tagBLOBHdr)) {          if (rlen < sizeof(struct tagBLOBHdr)) {
                 rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Too short BLOB packet");
Line 344  rxBLOB(sched_task_t *task) Line 363  rxBLOB(sched_task_t *task)
         /* check integrity of packet */          /* check integrity of packet */
         crc = ntohs(blob->hdr_crc);          crc = ntohs(blob->hdr_crc);
         blob->hdr_crc ^= blob->hdr_crc;          blob->hdr_crc ^= blob->hdr_crc;
        if (crc != crcFletcher16((u_short*) buf, io_align(rlen, 1) / 2)) {        if (crc != crcFletcher16((u_short*) buf, rlen / 2)) {
                 rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");                  rpc_SetErr(ERPCMISMATCH, "Bad CRC BLOB packet");
                 schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task),                   schedRead(TASK_ROOT(task), rxBLOB, TASK_ARG(task), TASK_FD(task), 
                                 TASK_DATA(task), TASK_DATLEN(task));                                  TASK_DATA(task), TASK_DATLEN(task));
Line 425  rpc_srv_dispatchVars(void *arg) Line 444  rpc_srv_dispatchVars(void *arg)
         u_char *buf;          u_char *buf;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!arg) {          if (!arg) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB");                  rpc_SetErr(EINVAL, "Invalid parameter can`t procced BLOB");
Line 478  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s Line 497  rpc_srv_initBLOBServer(rpc_srv_t * __restrict srv, u_s
         int n = 1;          int n = 1;
         io_sockaddr_t sa;          io_sockaddr_t sa;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server");                  rpc_SetErr(EINVAL, "Invalid parameters can`t init BLOB server");
Line 584  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 603  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
         register int i;          register int i;
         rpc_blob_t *f;          rpc_blob_t *f;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
        if (!srv) {        if (!srv || srv->srv_blob.state == disable)
                rpc_SetErr(EINVAL, "Can`t destroy server because parameter is null!"); 
                 return;                  return;
        } else        else
                 srv->srv_blob.state = kill;                  srv->srv_blob.state = kill;
   
         rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);          rpc_srv_unregisterCall(srv, NULL, CALL_BLOBSHUTDOWN);
Line 621  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv) Line 639  rpc_srv_endBLOBServer(rpc_srv_t * __restrict srv)
   
         while (pthread_mutex_trylock(&srv->srv_blob.mtx) == EBUSY);          while (pthread_mutex_trylock(&srv->srv_blob.mtx) == EBUSY);
         pthread_mutex_destroy(&srv->srv_blob.mtx);          pthread_mutex_destroy(&srv->srv_blob.mtx);
   
           /* at final, save disable BLOB service state */
           srv->srv_blob.state = disable;
 }  }
   
 /*  /*
Line 640  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv) Line 661  rpc_srv_loopBLOB(rpc_srv_t * __restrict srv)
         struct timeval tv = { DEF_RPC_TIMEOUT, 0 };          struct timeval tv = { DEF_RPC_TIMEOUT, 0 };
         pthread_attr_t attr;          pthread_attr_t attr;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!srv || srv->srv_blob.state == kill) {          if (!srv || srv->srv_blob.state == kill) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server");                  rpc_SetErr(EINVAL, "Invalid parameter can`t start BLOB server");
Line 724  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 745  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         struct hostent *host = NULL;          struct hostent *host = NULL;
         io_sockaddr_t sa;          io_sockaddr_t sa;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!concurentClients || !regProgID ||           if (!concurentClients || !regProgID || 
                         (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) {                          (family != AF_INET && family != AF_INET6 && family != AF_LOCAL)) {
Line 838  rpc_srv_initServer(u_int regProgID, u_int regProcID, i Line 859  rpc_srv_initServer(u_int regProgID, u_int regProcID, i
         rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 1);          rpc_srv_registerCall(srv, NULL, CALL_SRVCLIENTS, 1);
         rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);          rpc_srv_registerCall(srv, NULL, CALL_SRVSESSIONS, 4);
         rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 1);          rpc_srv_registerCall(srv, NULL, CALL_SRVCALLS, 1);
   
         return srv;          return srv;
 }  }
   
Line 854  rpc_srv_endServer(rpc_srv_t ** __restrict psrv) Line 876  rpc_srv_endServer(rpc_srv_t ** __restrict psrv)
         register int i;          register int i;
         rpc_func_t *f;          rpc_func_t *f;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!psrv || !*psrv) {          if (!psrv || !*psrv) {
                 rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n");                  rpc_SetErr(EINVAL, "Error:: Can`t destroy server because parameter is null!\n");
Line 912  rpc_srv_loopServer(rpc_srv_t * __restrict srv) Line 934  rpc_srv_loopServer(rpc_srv_t * __restrict srv)
         struct timeval tv = { DEF_RPC_TIMEOUT, 0 };          struct timeval tv = { DEF_RPC_TIMEOUT, 0 };
         pthread_attr_t attr;          pthread_attr_t attr;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!srv) {          if (!srv) {
                 rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n");                  rpc_SetErr(EINVAL, "Error:: Invalid parameter can`t start RPC server ...\n");
Line 993  rpc_srv_execCall(rpc_func_t * __restrict call, struct  Line 1015  rpc_srv_execCall(rpc_func_t * __restrict call, struct 
         rpc_callback_t func;          rpc_callback_t func;
         int ret;          int ret;
   
        FTRACE();        ioTRACE(RPC_TRACE_LEVEL);
   
         if (!call || !rpc || !call->func_parent) {          if (!call || !rpc || !call->func_parent) {
                 rpc_SetErr(EINVAL, "Invalid parameter can`t exec function");                  rpc_SetErr(EINVAL, "Invalid parameter can`t exec function");
Removed from v.1.6.2.10  
changed lines
  Added in v.1.7.2.4

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