[BACK]Return to aitrpc.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitrpc / src

Diff for /libaitrpc/src/aitrpc.c between versions 1.15.6.1 and 1.15.6.2

version 1.15.6.1, 2014/12/11 01:15:34 version 1.15.6.2, 2014/12/19 02:12:49
Line 158  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 158  rpc_Read(int sock, int type, int flags, sockaddr_t * _
         struct pollfd pfd;          struct pollfd pfd;
         sockaddr_t sa2;          sockaddr_t sa2;
         socklen_t salen;          socklen_t salen;
        int ret = 0, len;        int ret = 0, len, cx = 0;
         ait_val_t v = AIT_VAL_INIT;
         struct ether_header *eh;
         struct bpf_hdr *h;
         ether_addr_t bcst = {{ [0 ... sizeof bcst - 1] = 0xff }};
   
           if (type == SOCK_BPF && sa) {
                   AIT_SET_BUF(&v, NULL, blen);
                   h = (struct bpf_hdr*) AIT_GET_BUF(&v);
           }
   
         pfd.fd = sock;          pfd.fd = sock;
         pfd.events = POLLIN | POLLPRI;          pfd.events = POLLIN | POLLPRI;
         memset(buf, 0, blen);          memset(buf, 0, blen);
Line 173  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 182  rpc_Read(int sock, int type, int flags, sockaddr_t * _
                                 LOGERR;                                  LOGERR;
                         else                          else
                                 rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");                                  rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                           if (type == SOCK_BPF)
                                   AIT_FREE_VAL(&v);
                         return -1;                          return -1;
                 }                  }
                 if (type == SOCK_STREAM)                  if (type == SOCK_STREAM)
                         ret = recv(sock, buf, len, flags);                          ret = recv(sock, buf, len, flags);
                else {                else if (type == SOCK_BPF && sa) {
                         ret = read(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                         if (ret > 0) {
                                 ret -= h->bh_hdrlen;
                                 if (ret < h->bh_caplen || h->bh_caplen != h->bh_datalen || 
                                                 ret < ETHER_HDR_LEN + sizeof(struct tagRPCCall)) {
                                         if (cx < 3) {
                                                 cx++;
                                                 ret ^= ret;
                                                 continue;       /* wait for known address */
                                         } else {
                                                 AIT_FREE_VAL(&v);
                                                 return -1;
                                         }
                                 }
                                 ret = h->bh_caplen;
                                 eh = (struct ether_header*) (AIT_GET_BUF(&v) + h->bh_hdrlen);
                                 ret -= ETHER_HDR_LEN;
                                 if (eh->ether_type != ntohs(RPC_DEFPORT)) {
                                         if (cx < 3) {
                                                 cx++;
                                                 ret ^= ret;
                                                 continue;       /* wait for known address */
                                         } else {
                                                 AIT_FREE_VAL(&v);
                                                 return -1;
                                         }
                                 }
 #if 0
                                 else
                                         e_getlinkbymac((const ether_addr_t*) eh->ether_shost, &sa2);
                                 if (sa && e_addrcmp(sa, &sa2, 0)) {
 #else
                                 if (!memcmp(bcst.octet, eh->ether_dhost, sizeof bcst) || 
                                                 !memcmp(bcst.octet, eh->ether_shost, sizeof bcst)) {
 #endif
                                         if (cx < 3) {
                                                 cx++;
                                                 ret ^= ret;
                                                 continue;       /* wait for known address */
                                         } else {
                                                 AIT_FREE_VAL(&v);
                                                 return -1;
                                         }
                                 }
                                 memcpy(buf, (u_char*) (eh + 1), MIN(ret, len));
                                 AIT_FREE_VAL(&v);
                                 return ret;
                         }
                 } else {
                         ret = recvfrom(sock, buf, len, flags, &sa2.sa, &salen);                          ret = recvfrom(sock, buf, len, flags, &sa2.sa, &salen);
                         if (ret > -1 && sa && e_addrcmp(sa, &sa2, 42)) {                          if (ret > -1 && sa && e_addrcmp(sa, &sa2, 42)) {
                                rpc_SetErr(ERPCMISMATCH,                                 ret ^= ret;
                                                "Received RPC response from unknown address");                                continue;       /* wait for known address */
                                return -1; 
                         }                          }
                 }                  }
                 if (ret == -1) {                  if (ret == -1) {
                         LOGERR;                          LOGERR;
                           if (type == SOCK_BPF)
                                   AIT_FREE_VAL(&v);
                         return -1;                          return -1;
                 }                  }
                if (!ret)       /* EOF */                if (!ret) {        /* EOF */
                         if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);
                         return 0;                          return 0;
                   }
         }          }
         ret = blen - len;          ret = blen - len;
   
           if (type == SOCK_BPF)
                   AIT_FREE_VAL(&v);
         return ret;          return ret;
 }  }
   
Removed from v.1.15.6.1  
changed lines
  Added in v.1.15.6.2

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