[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.16 and 1.18

version 1.16, 2015/01/15 01:42:37 version 1.18, 2015/05/18 15:09:59
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 - 2014Copyright 2004 - 2015
         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 147  rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s) Line 147  rpc_addPktSession(rpc_sess_t *p, rpc_sess_t *s)
  * @type = type of socket   * @type = type of socket
  * @flags = receive flags   * @flags = receive flags
  * @sa = check client address, if you use udp protocol   * @sa = check client address, if you use udp protocol
 * @buf = buffer * @pkt = RPC packet
 * @blen = buffer length 
  * return: -1 error, 0 EOF or or >0 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, ait_val_t * __restrict pkt)
                u_char * __restrict buf, size_t blen) 
 {  {
         struct pollfd pfd;          struct pollfd pfd;
         sockaddr_t sa2;          sockaddr_t sa2;
         socklen_t salen;          socklen_t salen;
        int ret = 0, len, cx = 0;        int ret = 0, len, hlen, cx = 0;
         ait_val_t v = AIT_VAL_INIT;          ait_val_t v = AIT_VAL_INIT;
         struct ether_header *eh;          struct ether_header *eh;
         struct bpf_hdr *h;          struct bpf_hdr *h;
         ether_addr_t bcst = {{ [0 ... sizeof bcst - 1] = 0xff }};          ether_addr_t bcst = {{ [0 ... sizeof bcst - 1] = 0xff }};
           u_char *buf = AIT_GET_BUF(pkt);
           size_t blen = AIT_LEN(pkt);
           struct tagRPCCall *rpc = (struct tagRPCCall *) buf;
   
         if (type == SOCK_BPF && sa) {          if (type == SOCK_BPF && sa) {
                 AIT_SET_BUF(&v, NULL, blen);                  AIT_SET_BUF(&v, NULL, blen);
Line 188  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 189  rpc_Read(int sock, int type, int flags, sockaddr_t * _
                 }                  }
                 if (type == SOCK_STREAM)                  if (type == SOCK_STREAM)
                         ret = recv(sock, buf, len, flags);                          ret = recv(sock, buf, len, flags);
                   else if (type == SOCK_EXT)
                           ret = read(sock, buf, len);
                 else if (type == SOCK_BPF && sa) {                  else if (type == SOCK_BPF && sa) {
                         ret = read(sock, AIT_GET_BUF(&v), AIT_LEN(&v));                          ret = read(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                         if (ret > 0) {                          if (ret > 0) {
Line 216  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 219  rpc_Read(int sock, int type, int flags, sockaddr_t * _
                                                 return -1;                                                  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) ||                                   if (!memcmp(bcst.octet, eh->ether_dhost, sizeof bcst) || 
                                                 !memcmp(bcst.octet, eh->ether_shost, sizeof bcst)) {                                                  !memcmp(bcst.octet, eh->ether_shost, sizeof bcst)) {
 #endif  
                                         if (cx < 3) {                                          if (cx < 3) {
                                                 cx++;                                                  cx++;
                                                 ret ^= ret;                                                  ret ^= ret;
Line 240  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 238  rpc_Read(int sock, int type, int flags, sockaddr_t * _
                 } else {                  } 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)) {
                                ret ^= ret;                                if (cx < 3) {
                                continue;       /* wait for known address */                                        cx++;
                                         ret ^= ret;
                                         continue;       /* wait for known address */
                                 } else
                                         return -1;
                         }                          }
                 }                  }
                if (ret == -1) {                if (ret < 0) {
                         LOGERR;                          LOGERR;
                         if (type == SOCK_BPF)                          if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);                                  AIT_FREE_VAL(&v);
Line 255  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 257  rpc_Read(int sock, int type, int flags, sockaddr_t * _
                                 AIT_FREE_VAL(&v);                                  AIT_FREE_VAL(&v);
                         return 0;                          return 0;
                 }                  }
   
                   /* check RPC packet header */
                   if ((u_char*) rpc == buf) {
                           if (type == SOCK_RAW) {
                                   hlen = sa->sa.sa_family == AF_INET ? sizeof(struct ip) : sizeof(struct ip6_hdr);
                                   ret -= hlen;
                                   if (ret > 0)
                                           memmove(buf, buf + hlen, blen - hlen);
                           }
   
                           /* 1st read for RPC header */
                           if (ret < sizeof(struct tagRPCCall)) {
                                   rpc_SetErr(ERPCMISMATCH, "Short RPC packet %d bytes", ret);
                                   if (type == SOCK_BPF)
                                           AIT_FREE_VAL(&v);
                                   return -1;
                           }
                           /* check for loop request */
                           if (!(rpc->call_io & RPC_ACK)) {
                                   ret ^= ret;
                                   continue;
                           }
                           /* calc estimated length */
                           blen = len = ntohl(rpc->call_len);
                           if (blen > AIT_LEN(pkt)) {
                                   AIT_RE_BUF(pkt, blen);
                                   buf = AIT_GET_BUF(pkt);
                                   rpc = (struct tagRPCCall*) buf;
                           }
                   }
         }          }
         ret = blen - len;          ret = blen - len;
   
Line 270  rpc_Read(int sock, int type, int flags, sockaddr_t * _ Line 302  rpc_Read(int sock, int type, int flags, sockaddr_t * _
  * @type = type of socket   * @type = type of socket
  * @flags = send flags   * @flags = send flags
  * @sa = send to client address, if you use udp protocol   * @sa = send to client address, if you use udp protocol
 * @buf = buffer * @pkt = RPC packet
  * @blen = buffer length   * @blen = buffer length
  * return: -1 error, 0 EOF or >0 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, 
                u_char * __restrict buf, size_t blen)                ait_val_t * __restrict pkt, size_t blen)
 {  {
         struct pollfd pfd;          struct pollfd pfd;
         int ret = 0, len = 0;          int ret = 0, len = 0;
         ait_val_t v = AIT_VAL_INIT;          ait_val_t v = AIT_VAL_INIT;
         struct ether_header *eh;          struct ether_header *eh;
           u_char *buf = AIT_GET_BUF(pkt);
   
         if (type == SOCK_BPF && sa) {          if (type == SOCK_BPF && sa) {
                 AIT_SET_BUF(&v, NULL, blen + sizeof(struct ether_header));                  AIT_SET_BUF(&v, NULL, blen + sizeof(struct ether_header));
Line 311  rpc_Write(int sock, int type, int flags, sockaddr_t *  Line 344  rpc_Write(int sock, int type, int flags, sockaddr_t * 
                 }                  }
                 if (type == SOCK_STREAM)                  if (type == SOCK_STREAM)
                         ret = send(sock, buf, len, flags);                          ret = send(sock, buf, len, flags);
                   else if (type == SOCK_EXT)
                           ret = write(sock, buf, len);
                 else if (type == SOCK_BPF && sa) {                  else if (type == SOCK_BPF && sa) {
                         ret = write(sock, AIT_GET_BUF(&v), AIT_LEN(&v));                          ret = write(sock, AIT_GET_BUF(&v), AIT_LEN(&v));
                 } else if (sa)                  } else if (sa)
Line 321  rpc_Write(int sock, int type, int flags, sockaddr_t *  Line 356  rpc_Write(int sock, int type, int flags, sockaddr_t * 
                                 AIT_FREE_VAL(&v);                                  AIT_FREE_VAL(&v);
                         return -1;                          return -1;
                 }                  }
                if (ret == -1) {                if (ret < 0) {
                         LOGERR;                          LOGERR;
                         if (type == SOCK_BPF)                          if (type == SOCK_BPF)
                                 AIT_FREE_VAL(&v);                                  AIT_FREE_VAL(&v);
Removed from v.1.16  
changed lines
  Added in v.1.18

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