[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.17.4.2 and 1.17.4.8

version 1.17.4.2, 2013/08/20 23:49:54 version 1.17.4.8, 2013/08/21 15:28:16
Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = { Line 67  static sched_task_func_t cbProto[SOCK_RAW + 1][4] = {
 };  };
   
   
   ait_val_t *
   rpc_getBufVar(rpc_cli_t * __restrict c)
   {
           return array(c->cli_buf, RPC_ISNEXTBUF(c), ait_val_t*);
   }
   
   u_char *
   rpc_getBuffer(rpc_cli_t * __restrict c)
   {
           u_char *b = NULL;
   
           assert(c);
   
           if (RPC_ISNEXTBUF(c))
                   b = AIT_GET_BUF(array(c->cli_buf, 1, ait_val_t*));
           else
                   b = AIT_GET_BUF(array(c->cli_buf, 0, ait_val_t*)) + 
                           sizeof(struct tagRPCCall);
   
           return b;
   }
   
   struct tagRPCCall *
   rpc_getHeader(rpc_cli_t * __restrict c)
   {
           assert(c);
   
           return (struct tagRPCCall*) AIT_GET_BUF(array(c->cli_buf, 0, ait_val_t*));
   }
   
 void  void
 rpc_freeCli(rpc_cli_t * __restrict c)  rpc_freeCli(rpc_cli_t * __restrict c)
 {  {
Line 127  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t *  Line 157  _allocClient(rpc_srv_t * __restrict srv, sockaddr_t * 
                 }                  }
   
                 /* init buffer(s) */                  /* init buffer(s) */
                c->cli_buf = ait_allocVars(1);                c->cli_buf = ait_allocVars(2);
                 if (!c->cli_buf) {                  if (!c->cli_buf) {
                         rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());                          rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                         array_Del(srv->srv_clients, n, 42);                          array_Del(srv->srv_clients, n, 42);
Line 167  txPacket(sched_task_t *task) Line 197  txPacket(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;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
        u_char buf[USHRT_MAX] = { 0 };        u_char *buf;
        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;        struct tagRPCCall *rpc = (struct tagRPCCall*) TASK_DATA(task);
         int ret, wlen = sizeof(struct tagRPCCall);          int ret, wlen = sizeof(struct tagRPCCall);
           int len = sizeof(struct tagRPCCall) + ntohl(rpc->call_len);
   
        /* copy RPC header */        buf = e_malloc(len);
        memcpy(buf, TASK_DATA(task), wlen);        if (!buf) {
                 rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                 TASK_ARG(task), 0, NULL, 0);
                 return NULL;
         } else {
                 /* copy RPC header */
                 memcpy(buf, rpc, wlen);
                 rpc = (struct tagRPCCall*) buf;
         }
   
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                 if (!f) {                  if (!f) {
                         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->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                          rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                        ret = ait_vars2buffer(buf + wlen, sizeof buf - wlen, RPC_RETVARS(c));                        ret = ait_vars2buffer(buf + wlen, len - wlen, RPC_RETVARS(c));
                         /* Free return values */                          /* Free return values */
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
                         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->call_rep.ret = RPC_ERROR(-1);
                                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 197  txPacket(sched_task_t *task) Line 240  txPacket(sched_task_t *task)
                 }                  }
         }          }
   
        rpc->call_len = htons(wlen);        rpc->call_len = htonl(wlen);
   
 #if 0  
         /* calculate CRC */  
         rpc->call_crc ^= rpc->call_crc;  
         rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));  
 #endif  
   
         /* send reply */          /* send reply */
         ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);          ret = send(TASK_FD(task), buf, wlen, MSG_NOSIGNAL);
         if (ret == -1 || ret != wlen) {          if (ret == -1 || ret != wlen) {
Line 213  txPacket(sched_task_t *task) Line 250  txPacket(sched_task_t *task)
                                 TASK_ARG(task), 0, NULL, 0);                                  TASK_ARG(task), 0, NULL, 0);
         }          }
   
           e_free(buf);
         return NULL;          return NULL;
 }  }
   
Line 223  execCall(sched_task_t *task) Line 261  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 = AIT_GET_BUF(&c->cli_buf) + TASK_VAL(task);        u_char *buf = rpc_getBuffer(c);
        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;        struct tagRPCCall *rpc = rpc_getHeader(c);
         int argc = ntohs(rpc->call_argc);          int argc = ntohs(rpc->call_argc);
   
         /* Go decapsulate variables ... */          /* Go decapsulate variables ... */
         if (argc) {          if (argc) {
                arr = ait_buffer2vars(buf + sizeof(struct tagRPCCall),                 arr = ait_buffer2vars(buf, ntohl(rpc->call_len), argc, 42);
                                AIT_LEN(&c->cli_buf) - TASK_VAL(task) - sizeof(struct tagRPCCall),  
                                argc, 42); 
                 if (!arr) {                  if (!arr) {
                         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->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 244  execCall(sched_task_t *task) Line 281  execCall(sched_task_t *task)
   
         if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) {          if (!(f = rpc_srv_getCall(s, ntohs(rpc->call_tag)))) {
                 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->call_rep.ret = RPC_ERROR(-1);
                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 277  rxPacket(sched_task_t *task) Line 315  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;
         int len, rlen, noreply;          int len, rlen, noreply;
        u_short off = TASK_DATLEN(task);        ait_val_t *bufz = array(c->cli_buf, 0, ait_val_t*);
#if 0        u_char *buf = (u_char*) AIT_GET_BUF(bufz);
        u_short crc;        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
#endif 
        u_char *buf = AIT_GET_BUF(&c->cli_buf); 
        struct tagRPCCall *rpc; 
   
        if (!off)        memset(buf, 0, AIT_LEN(bufz));
                memset(buf, 0, AIT_LEN(&c->cli_buf));        /* 1st buffer is last */
        rlen = recv(TASK_FD(task), buf + off, AIT_LEN(&c->cli_buf) - off, 0);        RPC_CLR_NEXTBUF(c);
        if (rlen < 1) {
         /* read rpc header */
         rlen = recv(TASK_FD(task), rpc, MIN(sizeof(struct tagRPCCall), AIT_LEN(bufz)), 0);
         if (rlen < sizeof(struct tagRPCCall) || 
                         ntohl(rpc->call_len) < sizeof(struct tagRPCCall)) {
                 /* close connection */                  /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],                   schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                 TASK_ARG(task), 0, NULL, 0);                                  TASK_ARG(task), 0, NULL, 0);
                 return NULL;                  return NULL;
         } else {          } else {
                rlen += off; /* add reminded bytes from previous rxPacket, if exists! */                buf += sizeof(struct tagRPCCall);
                off = 0;        /* process buffer from start offset == 0 */                len = ntohl(rpc->call_len);
         }          }
   
        do {        if (len > (AIT_LEN(bufz) - sizeof(struct tagRPCCall))) {
                /* check RPC packet */                /* add extra buffer */
                if (rlen < sizeof(struct tagRPCCall)) {                if (!(bufz = ait_getVars(&c->cli_buf, 1))) {
                        rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                        /* close connection */
                        schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                        /* reminder received previous bytes ;) */                                        TASK_ARG(task), 0, NULL, 0);
                        schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task),  
                                        TASK_FD(task), TASK_DATA(task), rlen); 
                         return NULL;                          return NULL;
                } else                } else {
                        rpc = (struct tagRPCCall*) (buf + off);                        AIT_FREE_VAL(bufz);
                        AIT_SET_BUFSIZ(bufz, 0, len);
                len = ntohs(rpc->call_len);                        buf = AIT_GET_BUF(bufz);
                rlen -= len; 
 
                /* check RPC packet lengths */ 
                if (rlen < 0 || len < sizeof(struct tagRPCCall)) { 
                        rpc_SetErr(ERPCMISMATCH, "Broken RPC packet length"); 
                        /* skip entire packet */ 
                        break; 
                 }                  }
                   /* buffer isnt last */
                   RPC_SET_NEXTBUF(c);
           }
   
#if 0        /* read payload */
                /* check integrity of packet */        rlen = recv(TASK_FD(task), buf, len, 0);
                crc = ntohs(rpc->call_crc);        if (rlen < len) {
                rpc->call_crc ^= rpc->call_crc;                /* close connection */
                if (crc != crcFletcher16((u_short*) rpc, len / 2)) {                schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                        rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                                TASK_ARG(task), 0, NULL, 0);
                 return NULL;
         }
   
                        off += len;        noreply = RPC_CHK_NOREPLY(rpc);
                        /* try next packet remaining into buffer */ 
                        continue; 
                } 
#endif 
   
                noreply = RPC_CHK_NOREPLY(rpc);        /* check RPC packet session info */
         if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {
                 rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
   
                /* check RPC packet session info */                rpc->call_argc ^= rpc->call_argc;
                if (rpc_chkPktSession(&rpc->call_session, &s->srv_session)) {                rpc->call_rep.ret = RPC_ERROR(-1);
                        rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");                rpc->call_rep.eno = RPC_ERROR(errno);
                        rpc->call_argc ^= rpc->call_argc;        } else {
                        rpc->call_rep.ret = RPC_ERROR(-1);                /* execute RPC call */
                        rpc->call_rep.eno = RPC_ERROR(errno);                schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), noreply, rpc, len);
                } else {        }
                        /* execute RPC call */ 
                        schedEvent(TASK_ROOT(task), execCall, TASK_ARG(task), off, NULL, 0); 
                } 
   
                /* send RPC reply */        /* send RPC reply */
                if (!noreply)        if (!noreply)
                        schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET],                 schedWrite(TASK_ROOT(task), cbProto[s->srv_proto][CB_TXPACKET], 
                                        TASK_ARG(task), TASK_FD(task), rpc, len);                                TASK_ARG(task), TASK_FD(task), rpc, len);
   
                 off += len;  
         } while (rlen > 0);  
   
         /* lets get next packet */          /* lets get next packet */
        schedRead(TASK_ROOT(task), TASK_FUNC(task), TASK_ARG(task), TASK_FD(task), TASK_DATA(task), 0);        schedReadSelf(task);
         return NULL;          return NULL;
 }  }
   
Line 393  txUDPPacket(sched_task_t *task) Line 420  txUDPPacket(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;
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
        u_char buf[USHRT_MAX] = { 0 };        u_char *buf;
        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;        struct tagRPCCall *rpc = (struct tagRPCCall*) TASK_DATA(task);
         int ret, wlen = sizeof(struct tagRPCCall);          int ret, wlen = sizeof(struct tagRPCCall);
           int len = sizeof(struct tagRPCCall) + ntohl(rpc->call_len);
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
         schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);          schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
         schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                          TASK_ARG(task), ts, TASK_ARG(task), 0);                           TASK_ARG(task), ts, TASK_ARG(task), 0);
   
        /* copy RPC header */        buf = e_malloc(len);
        memcpy(buf, TASK_DATA(task), wlen);        if (!buf) {
                 rpc_SetErr(elwix_GetErrno(), "%s", elwix_GetError());
                 /* close connection */
                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                  TASK_ARG(task), 0, NULL, 0);
                 return NULL;
         } else {
                 /* copy RPC header */
                 memcpy(buf, rpc, wlen);
                 rpc = (struct tagRPCCall*) buf;
         }
   
         if (rpc->call_argc) {          if (rpc->call_argc) {
                 f = rpc_srv_getCall(s, ntohs(rpc->call_tag));                  f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                 if (!f) {                  if (!f) {
                         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->call_rep.ret = RPC_ERROR(-1);
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                 } else {                  } else {
                         rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                          rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                        ret = ait_vars2buffer(buf + wlen, sizeof buf - wlen, RPC_RETVARS(c));                        ret = ait_vars2buffer(buf + wlen, len - wlen, RPC_RETVARS(c));
                         /* Free return values */                          /* Free return values */
                         ait_freeVars(&c->cli_vars);                          ait_freeVars(&c->cli_vars);
                         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->call_rep.ret = RPC_ERROR(-1);
                                 rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                                  rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
Line 428  txUDPPacket(sched_task_t *task) Line 468  txUDPPacket(sched_task_t *task)
                 }                  }
         }          }
   
        rpc->call_len = htons(wlen);        rpc->call_len = htonl(wlen);
   
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
Line 443  txUDPPacket(sched_task_t *task) Line 483  txUDPPacket(sched_task_t *task)
                                  TASK_ARG(task), 0, NULL, 0);                                   TASK_ARG(task), 0, NULL, 0);
         }          }
   
           e_free(buf);
         return NULL;          return NULL;
 }  }
   
Line 452  rxUDPPacket(sched_task_t *task) Line 493  rxUDPPacket(sched_task_t *task)
         rpc_srv_t *srv = TASK_ARG(task);          rpc_srv_t *srv = TASK_ARG(task);
         rpc_cli_t *c = NULL;          rpc_cli_t *c = NULL;
         int len, rlen, noreply;          int len, rlen, noreply;
        u_short crc, off = 0;        ait_val_t *bufz;
        u_char buf[USHRT_MAX + 1];        u_char *buf = NULL;
        struct tagRPCCall *rpc = (struct tagRPCCall*) buf;        struct tagRPCCall rpcbuf, *rpc;
        sockaddr_t sa;        sockaddr_t sa[2];
         socklen_t salen;          socklen_t salen;
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
   
           memset(&rpcbuf, 0, sizeof rpcbuf);
   
         /* receive connect packet */          /* receive connect packet */
        salen = sa.ss.ss_len = sizeof(sockaddr_t);        salen = sa[0].ss.ss_len = sizeof(sockaddr_t);
        rlen = recvfrom(TASK_FD(task), buf, sizeof buf, 0, &sa.sa, &salen);        rlen = recvfrom(TASK_FD(task), &rpcbuf, sizeof rpcbuf, 0, &sa[0].sa, &salen);
        if (rlen < 1)        if (rlen < sizeof(struct tagRPCCall) || ntohl(rpcbuf.call_len) < sizeof(struct tagRPCCall))
                 goto end;                  goto end;
           else
                   len = ntohl(rpcbuf.call_len);
   
        c = _allocClient(srv, &sa);        buf = e_malloc(len);
         if (!buf)
                 goto end;
         else
                 memset(buf, 0, len);
 
         /* read payload */
         salen = sa[1].ss.ss_len = sizeof(sockaddr_t);
         rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa[1].sa, &salen);
         if (rlen < len || memcmp(&sa[0], &sa[1], sizeof sa[0]))
                 goto end;
 
         c = _allocClient(srv, sa);
         if (!c)          if (!c)
                 goto end;                  goto end;
         else {          else {
                   /* add extra buffer */
                   if (!(bufz = ait_getVars(&c->cli_buf, 1)))
                           goto end;
                   else {
                           AIT_FREE_VAL(bufz);
                           AIT_SET_BUFSIZ(bufz, 0, len);
                           /* buffer isnt last */
                           RPC_SET_NEXTBUF(c);
                   }
   
                   rpc = rpc_getHeader(c);
                   memcpy(rpc, &rpcbuf, sizeof(struct tagRPCCall));
                   memcpy(rpc_getBuffer(c), buf, len);
   
                 c->cli_sock = TASK_FD(task);                  c->cli_sock = TASK_FD(task);
                memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);                memcpy(&c->cli_sa, sa, sizeof c->cli_sa);
                memcpy(AIT_GET_BUF(&c->cli_buf), buf, AIT_LEN(&c->cli_buf)); 
                 /* armed timer for close stateless connection */                  /* armed timer for close stateless connection */
                 schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);                  schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);
                 schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT],                   schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                 c, ts, c, 0);                                  c, ts, c, 0);
         }          }
   
        do {        /* check integrity of packet */
                /* check RPC packet */        if (ntohs(rpc->call_crc) != crcFletcher16((u_short*) buf, len / 2)) {
                if (rlen < sizeof(struct tagRPCCall)) {                rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                        rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                goto end;
                        break;        }
                } else 
                        rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + off); 
   
                len = ntohs(rpc->call_len);        noreply = RPC_CHK_NOREPLY(rpc);
                rlen -= len; 
   
                /* check RPC packet lengths */        /* check RPC packet session info */
                if (rlen < 0 || len < sizeof(struct tagRPCCall)) {        if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) {
                        rpc_SetErr(ERPCMISMATCH, "Broken RPC packet length");                rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session");
                        /* skip entire packet */ 
                        break; 
                } 
   
                /* check integrity of packet */                rpc->call_argc ^= rpc->call_argc;
                crc = ntohs(rpc->call_crc);                rpc->call_rep.ret = RPC_ERROR(-1);
                rpc->call_crc ^= rpc->call_crc;                rpc->call_rep.eno = RPC_ERROR(errno);
                if (crc != crcFletcher16((u_short*) rpc, len / 2)) {        } else {
                        rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");                /* execute RPC call */
                 schedEvent(TASK_ROOT(task), execCall, c, noreply, rpc, len);
         }
   
                        off += len;        /* send RPC reply */
                        /* try next packet remaining into buffer */        if (!noreply)
                        continue;                schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                }                                c, TASK_FD(task), rpc, len);
 
                noreply = RPC_CHK_NOREPLY(rpc); 
 
                /* check RPC packet session info */ 
                if (rpc_chkPktSession(&rpc->call_session, &srv->srv_session)) { 
                        rpc_SetErr(ERPCMISMATCH, "Get invalid RPC session"); 
                        rpc->call_argc ^= rpc->call_argc; 
                        rpc->call_rep.ret = RPC_ERROR(-1); 
                        rpc->call_rep.eno = RPC_ERROR(errno); 
                } else { 
                        /* execute RPC call */ 
                        schedEvent(TASK_ROOT(task), execCall, c, off, NULL, 0); 
                } 
 
                /* send RPC reply */ 
                if (!noreply) 
                        schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],  
                                        c, TASK_FD(task), rpc, len); 
 
                off += len; 
        } while (rlen > 0); 
 
 end:  end:
           if (buf)
                   e_free(buf);
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
 }  }
Line 568  static void * Line 614  static void *
 txBLOB(sched_task_t *task)  txBLOB(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
        u_char *buf = AIT_GET_BUF(&c->cli_buf);        u_char *buf = AIT_GET_BUF(array(c->cli_buf, 0, ait_val_t*));
         int wlen = sizeof(struct tagBLOBHdr);          int wlen = sizeof(struct tagBLOBHdr);
   
         /* send reply */          /* send reply */
Line 660  rxBLOB(sched_task_t *task) Line 706  rxBLOB(sched_task_t *task)
         }          }
   
 end:  end:
        memcpy(AIT_ADDR(&c->cli_buf), &blob, sizeof blob);        memcpy(AIT_ADDR(array(c->cli_buf, 0, ait_val_t*)), &blob, sizeof blob);
         schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0);          schedWrite(TASK_ROOT(task), txBLOB, TASK_ARG(task), TASK_FD(task), NULL, 0);
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
Removed from v.1.17.4.2  
changed lines
  Added in v.1.17.4.8

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