[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.12 and 1.16

version 1.12, 2013/11/11 22:48:53 version 1.16, 2015/01/15 01:42:37
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013Copyright 2004 - 2014
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 149  rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s) Line 149  rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s)
  * @sa = check client address, if you use udp protocol   * @sa = check client address, if you use udp protocol
  * @buf = buffer   * @buf = buffer
  * @blen = buffer length   * @blen = buffer length
 * return: -1 error or >-1 readed bytes into buffer * return: -1 error, 0 EOF or or >0 readed bytes into buffer
  */   */
 ssize_t  ssize_t
 rpc_Read(int sock, int type, int flags, sockaddr_t * __restrict sa,   rpc_Read(int sock, int type, int flags, sockaddr_t * __restrict sa, 
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);
         memset(&sa2, 0, sizeof sa2);          memset(&sa2, 0, sizeof sa2);
         salen = sa2.ss.ss_len = sizeof(sockaddr_t);          salen = sa2.ss.ss_len = sizeof(sockaddr_t);
   
        if (type == SOCK_STREAM) {        for (len = blen; len > 0; len -= ret, buf += ret) {
                for (len = blen; len > 0; len -= ret, buf += ret) {                if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||                                 pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {                        if (ret)
                                 LOGERR;                                  LOGERR;
                                return -1;                        else
                        } else                                rpc_SetErr(ETIMEDOUT, "Timeout reached! Server not respond");
                                ret = recv(sock, buf, len, flags);                        if (type == SOCK_BPF)
                        if (ret == -1) {                                AIT_FREE_VAL(&v);
                                LOGERR;                        return -1;
                                return -1; 
                        } 
                 }                  }
                if (ret > -1)                if (type == SOCK_STREAM)
                        ret = blen - len;                        ret = recv(sock, buf, len, flags);
        } else {                else if (type == SOCK_BPF && sa) {
                do {                        ret = read(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||                         if (ret > 0) {
                                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {                                ret -= h->bh_hdrlen;
                                LOGERR;                                if (ret < h->bh_caplen || h->bh_caplen != h->bh_datalen || 
                                return -1;                                                ret < ETHER_HDR_LEN + sizeof(struct tagRPCCall)) {
                        } else                                        if (cx < 3) {
                                ret = recvfrom(sock, buf, blen, flags, &sa2.sa, &salen);                                                cx++;
                        if (ret < 0) {                                                ret ^= ret;
                                LOGERR;                                                continue;       /* wait for known address */
                                return -1;                                        } 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;
                         }                          }
                        if (e_addrcmp(sa, &sa2, 42))                } else {
                                rpc_SetErr(ERPCMISMATCH, "Received RPC response from unknown address");                        ret = recvfrom(sock, buf, len, flags, &sa2.sa, &salen);
                        else                        if (ret > -1 && sa && e_addrcmp(sa, &sa2, 42)) {
                                break;                                ret ^= ret;
                } while (42);                                continue;       /* wait for known address */
                         }
                 }
                 if (ret == -1) {
                         LOGERR;
                         if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);
                         return -1;
                 }
                 if (!ret) {     /* EOF */
                         if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);
                         return 0;
                 }
         }          }
           ret = blen - len;
   
           if (type == SOCK_BPF)
                   AIT_FREE_VAL(&v);
         return ret;          return ret;
 }  }
   
Line 212  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 272  rpc_Read(int sock, int type, int flags, sockaddr_t * _
  * @sa = send to client address, if you use udp protocol   * @sa = send to client address, if you use udp protocol
  * @buf = buffer   * @buf = buffer
  * @blen = buffer length   * @blen = buffer length
 * return: -1 error or >-1 written bytes into buffer * return: -1 error, 0 EOF or >0 written bytes into buffer
  */   */
 ssize_t  ssize_t
 rpc_Write(int sock, int type, int flags, sockaddr_t * __restrict sa,   rpc_Write(int sock, int type, int flags, sockaddr_t * __restrict sa, 
Line 220  rpc_Write(int sock, int type, int flags, sockaddr_t *  Line 280  rpc_Write(int sock, int type, int flags, sockaddr_t * 
 {  {
         struct pollfd pfd;          struct pollfd pfd;
         int ret = 0, len = 0;          int ret = 0, len = 0;
           ait_val_t v = AIT_VAL_INIT;
           struct ether_header *eh;
   
           if (type == SOCK_BPF && sa) {
                   AIT_SET_BUF(&v, NULL, blen + sizeof(struct ether_header));
                   eh = (struct ether_header*) AIT_GET_BUF(&v);
                   memcpy(eh->ether_dhost, LLADDR(&sa->sdl), ETHER_ADDR_LEN);
                   eh->ether_type = htons(RPC_DEFPORT);
                   memcpy(eh + 1, buf, blen);
                   blen += sizeof(struct ether_header);
           }
   
         pfd.fd = sock;          pfd.fd = sock;
         pfd.events = POLLOUT;          pfd.events = POLLOUT;
        for (len = blen; len > 0; len -= ret, buf += ret) {
        if (type == SOCK_STREAM) {                if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || 
                for (len = blen; len > 0; len -= ret, buf += ret) {                                pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
                        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 || #if 0
                                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {                        if (!ret)
                                if (!ret)                                continue;
                                        continue;#endif
                                if (ret > 0)                        if (ret > 0)
                                        rpc_SetErr(EPIPE, "Disconnected RPC session\n");                                rpc_SetErr(EPIPE, "Disconnected RPC session\n");
                                else                        else
                                        LOGERR; 
                                return -1; 
                        } else 
                                ret = send(sock, buf, len, flags); 
                        if (ret == -1) { 
                                 LOGERR;                                  LOGERR;
                                return -1;                        if (type == SOCK_BPF)
                        }                                AIT_FREE_VAL(&v);
                         return -1;
                 }                  }
                if (ret > -1)                if (type == SOCK_STREAM)
                        ret = blen - len;                        ret = send(sock, buf, len, flags);
        } else if (sa) {                else if (type == SOCK_BPF && sa) {
                do {                        ret = write(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                        if ((ret = poll(&pfd, 1, DEF_RPC_TIMEOUT * 1000)) < 1 ||                 } else if (sa)
                                        pfd.revents & (POLLERR | POLLHUP | POLLNVAL)) {                        ret = sendto(sock, buf, len, flags, &sa->sa, sa->sa.sa_len);
                                if (!ret)                else {
                                        continue;                        rpc_SetErr(EINVAL, "Invalid argument(s)!");
                                if (ret > 0)                        if (type == SOCK_BPF)
                                        rpc_SetErr(EPIPE, "Disconnected RPC session\n");                                AIT_FREE_VAL(&v);
                                else                        return -1;
                                        LOGERR;                }
                                return -1;                if (ret == -1) {
                        } else                        LOGERR;
                                ret = sendto(sock, buf, blen, flags, &sa->sa, sa->sa.sa_len);                        if (type == SOCK_BPF)
                } while (0);                                AIT_FREE_VAL(&v);
        } else {                        return -1;
                rpc_SetErr(EINVAL, "Invalid argument(s)!");                }
                return -1;                if (!ret) {     /* EOF */
                         if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);
                         return 0;
                 }
         }          }
        if (ret == -1) {        ret = blen - len;
                LOGERR;        if (ret != blen) {
                return -1; 
        } else if (ret != blen) { 
                 rpc_SetErr(EPROCUNAVAIL, "RPC request, should be send %d bytes, "                  rpc_SetErr(EPROCUNAVAIL, "RPC request, should be send %d bytes, "
                                "really sended %d bytes", len, ret);                                "really sended %d bytes", blen, ret);
                 if (type == SOCK_BPF)
                         AIT_FREE_VAL(&v);
                 return -1;                  return -1;
         }          }
   
           if (type == SOCK_BPF)
                   AIT_FREE_VAL(&v);
         return ret;          return ret;
 }  }
Removed from v.1.12  
changed lines
  Added in v.1.16

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