[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.26

version 1.24.2.6, 2015/01/18 01:03:50 version 1.26, 2015/05/18 15:09:59
Line 58  static void *rxUDPPacket(sched_task_t *); Line 58  static void *rxUDPPacket(sched_task_t *);
 static void *txUDPPacket(sched_task_t *);  static void *txUDPPacket(sched_task_t *);
   
 /* SOCK_RAW */  /* SOCK_RAW */
   static void *rxRAWPacket(sched_task_t *);
   static void *txRAWPacket(sched_task_t *);
   
 /* SOCK_BPF */  /* SOCK_BPF */
 static void *rxBPFPacket(sched_task_t *);  static void *rxBPFPacket(sched_task_t *);
Line 71  static sched_task_func_t cbProto[SOCK_MAX_SUPPORT][4]  Line 73  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, rxUDPPacket, txUDPPacket },  /* SOCK_DGRAM */
        { NULL, NULL, NULL, NULL },                             /* SOCK_RAW */        { rxRAWPacket, freeClient, rxRAWPacket, txRAWPacket },        /* SOCK_RAW */
         { rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket },  /* SOCK_BPF */          { rxBPFPacket, freeClient, rxBPFPacket, txBPFPacket },  /* SOCK_BPF */
         { rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket }   /* SOCK_EXT */          { rxEXTPacket, freeClient, rxEXTPacket, txEXTPacket }   /* SOCK_EXT */
 };  };
Line 206  txPacket(sched_task_t *task) Line 208  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 226  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 270  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 311  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 381  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 497  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 514  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 620  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 646  end: Line 660  end:
   
   
 static void *  static void *
   txRAWPacket(sched_task_t *task)
   {
           rpc_cli_t *c = TASK_ARG(task);
           rpc_srv_t *s = c->cli_parent;
           rpc_func_t *f = NULL;
           u_char *buf = AIT_GET_BUF(&c->cli_buf);
           struct tagRPCCall *rpc = (struct tagRPCCall*) buf;
           int ret, estlen, wlen = sizeof(struct tagRPCCall);
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
           struct pollfd pfd;
   
           schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, TASK_ARG(task), NULL);
           schedTimer(TASK_ROOT(task), cbProto[s->srv_proto][CB_CLOSECLIENT], 
                            TASK_ARG(task), ts, TASK_ARG(task), 0);
   
           if (rpc->call_argc) {
                   f = rpc_srv_getCall(s, ntohs(rpc->call_tag));
                   if (!f) {
                           rpc_SetErr(EPROGUNAVAIL, "Function not found at RPC server");
                           rpc->call_argc ^= rpc->call_argc;
                           rpc->call_rep.ret = RPC_ERROR(-1);
                           rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                   } else {
                           /* calc estimated length */
                           estlen = ait_resideVars(RPC_RETVARS(c)) + wlen;
                           if (estlen > AIT_LEN(&c->cli_buf))
                                   AIT_RE_BUF(&c->cli_buf, estlen);
                           buf = AIT_GET_BUF(&c->cli_buf);
                           rpc = (struct tagRPCCall*) buf;
   
                           rpc->call_argc = (u_char) array_Size(RPC_RETVARS(c));
                           /* Go Encapsulate variables */
                           ret = ait_vars2buffer(buf + wlen, AIT_LEN(&c->cli_buf) - wlen, 
                                           RPC_RETVARS(c));
                           /* Free return values */
                           ait_freeVars(&c->cli_vars);
                           if (ret == -1) {
                                   rpc_SetErr(EBADRPC, "Prepare RPC packet failed");
                                   rpc->call_argc ^= rpc->call_argc;
                                   rpc->call_rep.ret = RPC_ERROR(-1);
                                   rpc->call_rep.eno = RPC_ERROR(rpc_Errno);
                           } else
                                   wlen += ret;
                   }
           }
   
           rpc->call_len = htonl(wlen);
           rpc->call_io = RPC_ACK;
   
           /* calculate CRC */
           rpc->call_crc ^= rpc->call_crc;
           rpc->call_crc = htons(crcFletcher16((u_short*) buf, wlen / 2));
   
           /* send reply */
           pfd.fd = TASK_FD(task);
           pfd.events = POLLOUT;
           for (; wlen > 0; wlen -= ret, buf += ret) {
                   if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                                   pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                           if (ret)
                                   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 = sendto(TASK_FD(task), buf, MIN(wlen, s->srv_netbuf), MSG_NOSIGNAL, 
                                   &c->cli_sa.sa, c->cli_sa.sa.sa_len);
                   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;
   }
   
   static void *
   rxRAWPacket(sched_task_t *task)
   {
           rpc_srv_t *srv = TASK_ARG(task);
           rpc_cli_t *c = NULL;
           int len, rlen, noreply, estlen;
           u_short crc;
           u_char *buf, b[sizeof(struct ip6_hdr) + sizeof(struct tagRPCCall)];
           struct tagRPCCall *rpc;
           sockaddr_t sa;
           socklen_t salen;
           struct timespec ts = { DEF_RPC_TIMEOUT, 0 };
           struct pollfd pfd;
   
           /* receive connect packet */
           salen = sa.ss.ss_len = sizeof(sockaddr_t);
           rlen = recvfrom(TASK_FD(task), b, sizeof b, MSG_PEEK, &sa.sa, &salen);
           if (rlen < sizeof(struct ip) + sizeof(struct tagRPCCall)) {
                   rpc_SetErr(ERPCMISMATCH, "Short RPC packet");
                   goto end;
           }
   
           c = _allocClient(srv, &sa);
           if (!c) {
                   EVERBOSE(1, "RPC client quota exceeded! Connection will be shutdown!\n");
                   usleep(2000);   /* blocked client delay */
                   goto end;
           } else {
                   estlen = sa.sa.sa_family == AF_INET ? 
                           sizeof(struct ip) : sizeof(struct ip6_hdr);
                   rpc = (struct tagRPCCall*) (b + estlen);
                   estlen += ntohl(rpc->call_len);
                   if (estlen > AIT_LEN(&c->cli_buf))
                           AIT_RE_BUF(&c->cli_buf, estlen);
                   rpc = (struct tagRPCCall*) (AIT_GET_BUF(&c->cli_buf) + 
                           (sa.sa.sa_family == AF_INET ? 
                           sizeof(struct ip) : sizeof(struct ip6_hdr)));
                   buf = AIT_GET_BUF(&c->cli_buf);
                   len = estlen;
   
                   c->cli_sock = TASK_FD(task);
                   memcpy(&c->cli_sa, &sa, sizeof c->cli_sa);
   
                   /* armed timer for close stateless connection */
                   schedCancelby(TASK_ROOT(task), taskTIMER, CRITERIA_DATA, c, NULL);
                   schedTimer(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                   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;
                   }
                   salen = sa.ss.ss_len = sizeof(sockaddr_t);
                   rlen = recvfrom(TASK_FD(task), buf, len, 0, &sa.sa, &salen);
                   if (rlen == -1) {
                           /* close connection */
                           schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                           c, 0, NULL, 0);
                           goto end;
                   }
                   if (e_addrcmp(&c->cli_sa, &sa, 42))
                           rlen ^= rlen;   /* skip if arrive from different address */
           }
           len = estlen;
           len -= sa.sa.sa_family == AF_INET ? 
                   sizeof(struct ip) : sizeof(struct ip6_hdr);
           memmove(AIT_GET_BUF(&c->cli_buf), rpc, len);
           rpc = (struct tagRPCCall*) AIT_GET_BUF(&c->cli_buf);
   
           /* skip loop packet */
           if (rpc->call_io & RPC_ACK)
                   goto end;
   
           /* check integrity of packet */
           crc = ntohs(rpc->call_crc);
           rpc->call_crc ^= rpc->call_crc;
           if (crc != crcFletcher16((u_short*) rpc, len / 2)) {
                   rpc_SetErr(ERPCMISMATCH, "Bad CRC RPC packet");
                   /* close connection */
                   schedEvent(TASK_ROOT(task), cbProto[srv->srv_proto][CB_CLOSECLIENT], 
                                   c, 0, NULL, 0);
                   goto end;
           }
   
           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, (int) noreply, rpc, len);
           }
   
           /* send RPC reply */
           if (!noreply)
                   schedWrite(TASK_ROOT(task), cbProto[srv->srv_proto][CB_TXPACKET], 
                                   c, TASK_FD(task), rpc, len);
   end:
           schedReadSelf(task);
           return NULL;
   }
   
   
   static void *
 txBPFPacket(sched_task_t *task)  txBPFPacket(sched_task_t *task)
 {  {
         rpc_cli_t *c = TASK_ARG(task);          rpc_cli_t *c = TASK_ARG(task);
Line 677  txBPFPacket(sched_task_t *task) Line 893  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 910  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 963  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 1041  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 1057  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 1080  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 1099  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 1140  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 1159  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;
 }  }
Line 1478  rpc_srv_initServer(u_char InstID, int concurentClients Line 1669  rpc_srv_initServer(u_char InstID, int concurentClients
         }          }
   
         /* create server socket */          /* create server socket */
        srv->srv_server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, srv->srv_proto, 0);        srv->srv_server.cli_sock = socket(srv->srv_server.cli_sa.sa.sa_family, 
                         srv->srv_proto, srv->srv_proto == SOCK_RAW ? IPPROTO_ERPC : 0);
         if (srv->srv_server.cli_sock == -1) {          if (srv->srv_server.cli_sock == -1) {
                 LOGERR;                  LOGERR;
                 array_Destroy(&srv->srv_clients);                  array_Destroy(&srv->srv_clients);
Removed from v.1.24.2.6  
changed lines
  Added in v.1.26

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