[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.24.2.6 and 1.24.2.7

version 1.24.2.6, 2015/01/18 01:03:50 version 1.24.2.7, 2015/01/21 00:37:04
Line 206  txPacket(sched_task_t *task) Line 206  txPacket(sched_task_t *task)
                         buf = AIT_GET_BUF(&c->cli_buf);                          buf = AIT_GET_BUF(&c->cli_buf);
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
   
                        rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                        rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                         ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen,                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));                                          RPC_RETVARS(c));
Line 224  txPacket(sched_task_t *task) Line 224  txPacket(sched_task_t *task)
         }          }
   
         rpc->call_len = htonl(wlen);          rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
 #if 0  #if 0
         /* calculate CRC */          /* calculate CRC */
Line 267  execCall(sched_task_t *task) Line 268  execCall(sched_task_t *task)
         array_t *arr = NULL;          array_t *arr = NULL;
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
        int argc = ntohs(rpc->call_argc);        int argc = rpc->call_argc;
   
         /* Go decapsulate variables ... */          /* Go decapsulate variables ... */
         if (argc) {          if (argc) {
Line 308  execCall(sched_task_t *task) Line 309  execCall(sched_task_t *task)
                                 rpc->call_argc ^= rpc->call_argc;                                  rpc->call_argc ^= rpc->call_argc;
                         } else {                          } else {
                                 /* reply */                                  /* reply */
                                rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                                rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         }                          }
                 }                  }
         }          }
Line 378  rxPacket(sched_task_t *task) Line 379  rxPacket(sched_task_t *task)
         }          }
         len = estlen;          len = estlen;
   
           /* skip loop packet */
           if (rpc->call_io & RPC_ACK) {
                   schedReadSelf(task);
                   return NULL;
           }
   
 #if 0  #if 0
         /* check integrity of packet */          /* check integrity of packet */
         crc = ntohs(rpc->call_crc);          crc = ntohs(rpc->call_crc);
Line 488  txUDPPacket(sched_task_t *task) Line 495  txUDPPacket(sched_task_t *task)
                         buf = AIT_GET_BUF(&c->cli_buf);                          buf = AIT_GET_BUF(&c->cli_buf);
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
   
                        rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                        rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                         ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen,                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));                                          RPC_RETVARS(c));
Line 505  txUDPPacket(sched_task_t *task) Line 512  txUDPPacket(sched_task_t *task)
         }          }
   
         rpc->call_len = htonl(wlen);          rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
Line 610  rxUDPPacket(sched_task_t *task) Line 618  rxUDPPacket(sched_task_t *task)
         }          }
         len = estlen;          len = estlen;
   
           /* skip loop packet */
           if (rpc->call_io & RPC_ACK)
                   goto end;
   
         /* check integrity of packet */          /* check integrity of packet */
         crc = ntohs(rpc->call_crc);          crc = ntohs(rpc->call_crc);
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
Line 677  txBPFPacket(sched_task_t *task) Line 689  txBPFPacket(sched_task_t *task)
                         buf = AIT_GET_BUF(&c->cli_buf);                          buf = AIT_GET_BUF(&c->cli_buf);
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
   
                        rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                        rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                         ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen,                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));                                          RPC_RETVARS(c));
Line 694  txBPFPacket(sched_task_t *task) Line 706  txBPFPacket(sched_task_t *task)
         }          }
   
         rpc->call_len = htonl(wlen);          rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
         /* calculate CRC */          /* calculate CRC */
         rpc->call_crc ^= rpc->call_crc;          rpc->call_crc ^= rpc->call_crc;
Line 746  rxBPFPacket(sched_task_t *task) Line 759  rxBPFPacket(sched_task_t *task)
                 eh = (struct ether_header*) (AIT_GET_BUF(&b) + h->bh_hdrlen);                  eh = (struct ether_header*) (AIT_GET_BUF(&b) + h->bh_hdrlen);
                 rlen -= ETHER_HDR_LEN;                  rlen -= ETHER_HDR_LEN;
                 rpc = (struct tagRPCCall*) (eh + 1);                  rpc = (struct tagRPCCall*) (eh + 1);
   
   #if 0
                   /* skip loop packet */
                   if (rpc->call_io & RPC_ACK)
                           goto end;
   #endif
   
                 if (eh->ether_type != ntohs(RPC_DEFPORT))                  if (eh->ether_type != ntohs(RPC_DEFPORT))
                         goto end;                          goto end;
                 else                  else
Line 817  txEXTPacket(sched_task_t *task) Line 837  txEXTPacket(sched_task_t *task)
         rpc_func_t *f = NULL;          rpc_func_t *f = NULL;
         u_char *buf = AIT_GET_BUF(&c->cli_buf);          u_char *buf = AIT_GET_BUF(&c->cli_buf);
         struct tagRPCCall *rpc = (struct tagRPCCall*) buf;          struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
        int ret, estlen, wlen = sizeof(struct tagRPCCall);        int ret, len, wlen = sizeof(struct tagRPCCall);
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
         struct pollfd pfd;  
   
         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], 
Line 834  txEXTPacket(sched_task_t *task) Line 853  txEXTPacket(sched_task_t *task)
                         rpc->call_rep.eno = RPC_ERROR(rpc_Errno);                          rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                 } else {                  } else {
                         /* calc estimated length */                          /* calc estimated length */
                        estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;                        len = ait_resideVars(RPC_RETVARS(c)) + wlen;
                        if (estlen > AIT_LEN(&c->cli_buf))                        if (len > AIT_LEN(&c->cli_buf))
                                AIT_RE_BUF(&c->cli_buf, estlen);                                AIT_RE_BUF(&c->cli_buf, len);
                         buf = AIT_GET_BUF(&c->cli_buf);                          buf = AIT_GET_BUF(&c->cli_buf);
                         rpc = (struct tagRPCCall*) buf;                          rpc = (struct tagRPCCall*) buf;
   
                        rpc->call_argc = htons(array_Size(RPC_RETVARS(c)));                        rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                         /* Go Encapsulate variables */                          /* Go Encapsulate variables */
                         ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen,                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                         RPC_RETVARS(c));                                          RPC_RETVARS(c));
                         /* Free return values */                          /* Free return values */
                        ait_freeVars(&c->cli_vars);                        ait_freeVars(&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;
Line 857  txEXTPacket(sched_task_t *task) Line 876  txEXTPacket(sched_task_t *task)
         }          }
   
         rpc->call_len = htonl(wlen);          rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
         /* send reply */          /* send reply */
        pfd.fd = TASK_FD(task);        ret = write(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf));
        pfd.events = POLLOUT;        if (ret == -1) {
        for (; wlen > 0; wlen -= ret, buf += ret) {                /* close connection */
                if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||                 schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {                                TASK_ARG(task), 0, NULL, 0);
                        if (ret)                return NULL;
                                LOGERR; 
                        else 
                                rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond"); 
                        /* close connection */ 
                        schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],  
                                        TASK_ARG(task), 0, NULL, 0); 
                        return NULL; 
                } 
                ret = write(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf)); 
                if (ret == -1) { 
                        /* close connection */ 
                        schedEvent(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT],  
                                        TASK_ARG(task), 0, NULL, 0); 
                        return NULL; 
                } 
         }          }
   
         return NULL;          return NULL;
Line 890  rxEXTPacket(sched_task_t *task) Line 895  rxEXTPacket(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, estlen;        int len, rlen, noreply;
        u_char *buf, b[sizeof(struct tagRPCCall)];        struct tagRPCCall *rpc;
        struct tagRPCCall *rpc = (struct tagRPCCall*) b; 
         struct timespec ts = { DEF_RPC_TIMEOUT, 0 };          struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
        struct pollfd pfd;        ait_val_t b = AIT_VAL_INIT;
         sockaddr_t sa;
   
           memset(&sa, 0, sizeof sa);
         /* receive connect packet */          /* receive connect packet */
        rlen = read(TASK_FD(task), b, sizeof b);        AIT_SET_BUF(&b, NULL, srv->srv_netbuf);
         rlen = read(TASK_FD(task), AIT_GET_BUF(&b), AIT_LEN(&b));
         if (rlen < sizeof(struct tagRPCCall)) {          if (rlen < sizeof(struct tagRPCCall)) {
                 rpc_SetErr(ERPCMISMATCH, "Short RPC packet");                  rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                 goto end;                  goto end;
           } else {
                   rpc = (struct tagRPCCall*) AIT_GET_BUF(&b);
   
                   /* skip loop packet */
                   if (rpc->call_io & RPC_ACK)
                           goto end;
         }          }
   
        c = _allocClient(srv, (sockaddr_t*) -1);        c = _allocClient(srv, &sa);
         if (!c) {          if (!c) {
                 EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");                  EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
                 usleep(2000);   /* blocked client delay */                  usleep(2000);   /* blocked client delay */
                 goto end;                  goto end;
         } else {          } else {
                estlen = ntohl(rpc->call_len);                len = ntohl(rpc->call_len);
                if (estlen > AIT_LEN(&c->cli_buf))                if (len > AIT_LEN(&c->cli_buf))
                        AIT_RE_BUF(&c->cli_buf, estlen);                        AIT_RE_BUF(&c->cli_buf, len);
                 memcpy(AIT_GET_BUF(&c->cli_buf), rpc, AIT_LEN(&c->cli_buf));
                 rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);                  rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
                 memcpy(rpc, b, sizeof b);  
                 buf = (u_char*) (rpc + 1);  
                 len = estlen;  
   
                 c->cli_sock = TASK_FD(task);                  c->cli_sock = TASK_FD(task);
   
Line 925  rxEXTPacket(sched_task_t *task) Line 936  rxEXTPacket(sched_task_t *task)
                                 c, ts, c, 0);                                  c, ts, c, 0);
         }          }
   
         /* get next part of packet */  
         memset(buf, 0, len);  
         pfd.fd = TASK_FD(task);  
         pfd.events = POLLIN | POLLPRI;  
         for (; len > 0; len -= rlen, buf += rlen) {  
                 if ((rlen = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||   
                                 pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {  
                         if (rlen)  
                                 LOGERR;  
                         else  
                                 rpc_SetErr(ETIMEDOUT, "Timeout reached! Client not respond");  
                         schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT],   
                                         c, 0, NULL, 0);  
                         goto end;  
                 }  
                 rlen = read(TASK_FD(task), buf, len);  
                 if (rlen == -1) {  
                         /* close connection */  
                         schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT],   
                                         c, 0, NULL, 0);  
                         goto end;  
                 }  
         }  
         len = estlen;  
   
         noreply = RPC_CHK_NOREPLY(rpc);          noreply = RPC_CHK_NOREPLY(rpc);
   
         /* check RPC packet session info */          /* check RPC packet session info */
Line 969  rxEXTPacket(sched_task_t *task) Line 955  rxEXTPacket(sched_task_t *task)
                 schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET],                   schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                 c, TASK_FD(task), rpc, len);                                  c, TASK_FD(task), rpc, len);
 end:  end:
           AIT_FREE_VAL(&b);
         schedReadSelf(task);          schedReadSelf(task);
         return NULL;          return NULL;
 }  }
Removed from v.1.24.2.6  
changed lines
  Added in v.1.24.2.7

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