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

Diff for /ansh/src/utils.c between versions 1.1.1.1.2.8 and 1.5.2.1

version 1.1.1.1.2.8, 2011/10/13 16:08:52 version 1.5.2.1, 2015/05/19 23:30:06
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, 2011Copyright 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 120  PrepareL2(const char *psDev, int *bpflen) Line 120  PrepareL2(const char *psDev, int *bpflen)
                 return -1;                  return -1;
         }          }
   
         /*  
         n = fcntl(h, F_GETFL);          n = fcntl(h, F_GETFL);
         fcntl(h, F_SETFL, n | O_NONBLOCK);          fcntl(h, F_SETFL, n | O_NONBLOCK);
         */  
   
         VERB(3) LOG("Openned device handle %d with bpf buflen %d", h, *bpflen);          VERB(3) LOG("Openned device handle %d with bpf buflen %d", h, *bpflen);
         return h;          return h;
 }  }
   
 int  int
PrepareL3(const struct sockaddr *sa, int *bpflen)PrepareL3(const sockaddr_t *sa, int *bpflen)
 {  {
         int h, n = 1;          int h, n = 1;
   
         FTRACE(3);          FTRACE(3);
         assert(sa);          assert(sa);
   
        h = socket(sa->sa_family, SOCK_RAW, IPPROTO_ICMP);        h = socket(sa->sa.sa_family ? sa->sa.sa_family : AF_INET, SOCK_RAW, IPPROTO_ICMP);
         if (h == -1) {          if (h == -1) {
                 printf("Error:: Cant open raw socket #%d - %s\n", errno, strerror(errno));                  printf("Error:: Cant open raw socket #%d - %s\n", errno, strerror(errno));
                 return -1;                  return -1;
Line 149  PrepareL3(const struct sockaddr *sa, int *bpflen) Line 147  PrepareL3(const struct sockaddr *sa, int *bpflen)
                 return -1;                  return -1;
         }          }
         */          */
        if (bind(h, sa, sizeof(struct sockaddr)) == -1) {        if (sa->sa.sa_family && bind(h, &sa->sa, sa->sa.sa_len) == -1) {
                 printf("Error:: Cant bind to raw socket #%d - %s\n", errno, strerror(errno));                  printf("Error:: Cant bind to raw socket #%d - %s\n", errno, strerror(errno));
                 close(h);                  close(h);
                 return -1;                  return -1;
Line 165  PrepareL3(const struct sockaddr *sa, int *bpflen) Line 163  PrepareL3(const struct sockaddr *sa, int *bpflen)
   
 char  char
 icmpRecv(int s, u_int * __restrict seq, u_short * __restrict id, u_int * __restrict crypted,   icmpRecv(int s, u_int * __restrict seq, u_short * __restrict id, u_int * __restrict crypted, 
                u_char * __restrict data, int * __restrict datlen, struct sockaddr *sa, socklen_t *salen)                u_char * __restrict data, int * __restrict datlen, sockaddr_t *sa, socklen_t *salen)
 {  {
         int ret = 0;          int ret = 0;
         struct icmp *icmp;          struct icmp *icmp;
Line 173  icmpRecv(int s, u_int * __restrict seq, u_short * __re Line 171  icmpRecv(int s, u_int * __restrict seq, u_short * __re
         u_char buf[USHRT_MAX] = { 0 };          u_char buf[USHRT_MAX] = { 0 };
         u_int crc;          u_int crc;
   
        ret = recvfrom(s, buf, sizeof buf, 0, sa, salen);        ret = recvfrom(s, buf, sizeof buf, 0, &sa->sa, salen);
         if (ret == -1) {          if (ret == -1) {
                 ERR("Receive recvfrom() #%d - %s", errno, strerror(errno));                  ERR("Receive recvfrom() #%d - %s", errno, strerror(errno));
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
Line 208  icmpRecv(int s, u_int * __restrict seq, u_short * __re Line 206  icmpRecv(int s, u_int * __restrict seq, u_short * __re
                         VERB(3) LOG("Channel SECURED:: Plain text communication not supported at this moment ...");                          VERB(3) LOG("Channel SECURED:: Plain text communication not supported at this moment ...");
                         return ANSH_FLG_ERR;                          return ANSH_FLG_ERR;
                 }                  }
                   if (ntohl(hdr->ansh_nonce) != *crypted)
                           VERB(4) LOG("Detect change of nonce from %x to %x", *crypted, ntohl(hdr->ansh_nonce));
   
                 *crypted = ntohl(hdr->ansh_nonce);                  *crypted = ntohl(hdr->ansh_nonce);
         }          }
Line 237  icmpRecv(int s, u_int * __restrict seq, u_short * __re Line 237  icmpRecv(int s, u_int * __restrict seq, u_short * __re
   
 int  int
 icmpSend(int s, u_int seq, u_short id, char flg, u_int crypted, u_char *data, int datlen,   icmpSend(int s, u_int seq, u_short id, char flg, u_int crypted, u_char *data, int datlen, 
                struct sockaddr *sa, socklen_t salen)                sockaddr_t *sa, socklen_t salen)
 {  {
         u_char *pos, buf[USHRT_MAX] = { 0 };          u_char *pos, buf[USHRT_MAX] = { 0 };
         struct icmp *icmp;          struct icmp *icmp;
Line 270  icmpSend(int s, u_int seq, u_short id, char flg, u_int Line 270  icmpSend(int s, u_int seq, u_short id, char flg, u_int
         icmp->icmp_cksum = crcIP(buf, sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen);          icmp->icmp_cksum = crcIP(buf, sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen);
   
         if ((ret = sendto(s, buf, sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen,           if ((ret = sendto(s, buf, sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen, 
                                        0, sa, salen)) == -1) {                                        0, &sa->sa, salen)) == -1) {
                 ERR("Send sendto() #%d - %s", errno, strerror(errno));                  ERR("Send sendto() #%d - %s", errno, strerror(errno));
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         } else          } else
                 VERB(4) LOG("Put packet with len=%d", ret);                  VERB(4) LOG("Put packet with len=%d", ret);
         if (ret != sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen) {          if (ret != sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen) {
                 VERB(3) LOG("Sended data %d is different from source data len %d", ret,                   VERB(3) LOG("Sended data %d is different from source data len %d", ret, 
                                sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen);                                (int) (sizeof(struct icmp) + sizeof(struct ansh_hdr) + datlen));
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         }          }
   
Line 285  icmpSend(int s, u_int seq, u_short id, char flg, u_int Line 285  icmpSend(int s, u_int seq, u_short id, char flg, u_int
 }  }
   
 static int  static int
_pkt_Send(int s, u_int seq, char flg, u_int crypted, u_char *data, int datlen, struct ether_addr *ea)_pkt_Send(int s, u_int seq, char flg, u_int crypted, u_char *data, int datlen, ether_addr_t *ea)
 {  {
        u_char *pos, buf[USHRT_MAX] = { 0 };        u_char *pos, *str, buf[USHRT_MAX] = { 0 };
         struct ether_header *e = (struct ether_header*) buf;          struct ether_header *e = (struct ether_header*) buf;
         struct ansh_hdr *hdr;          struct ansh_hdr *hdr;
         int ret = 0;          int ret = 0;
Line 303  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u Line 303  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u
   
         memcpy(pos, data, datlen);          memcpy(pos, data, datlen);
   
           if (Crypted) {
                   str = cryptBuffer(pos, datlen, Crypted);
                   if (str) {
                           memcpy(pos, str, datlen);
                           e_free(str);
                   }
           }
   
         hdr->ansh_ver = ANSH_VERSION;          hdr->ansh_ver = ANSH_VERSION;
         hdr->ansh_flg = flg;          hdr->ansh_flg = flg;
         hdr->ansh_len = htons(datlen + sizeof(struct ansh_hdr));          hdr->ansh_len = htons(datlen + sizeof(struct ansh_hdr));
Line 318  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u Line 326  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u
                 VERB(4) LOG("Put packet with len=%d", ret);                  VERB(4) LOG("Put packet with len=%d", ret);
         if (ret != ETHER_HDR_LEN + sizeof(struct ansh_hdr) + datlen) {          if (ret != ETHER_HDR_LEN + sizeof(struct ansh_hdr) + datlen) {
                 VERB(3) LOG("Sended data %d is different from source data len %d", ret,                   VERB(3) LOG("Sended data %d is different from source data len %d", ret, 
                                ETHER_HDR_LEN + sizeof(struct ansh_hdr) + datlen);                                (int) (ETHER_HDR_LEN + sizeof(struct ansh_hdr) + datlen));
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         }          }
   
Line 326  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u Line 334  _pkt_Send(int s, u_int seq, char flg, u_int crypted, u
 }  }
   
 int  int
pktSend(int s, u_int seq, char flg, u_int crypted, u_char *data, int datlen, struct ether_addr *ea)pktSend(int s, u_int seq, char flg, u_int crypted, u_char *data, int datlen, struct e_ether_addr *ea)
 {  {
         int wlen, ret = 0;          int wlen, ret = 0;
         u_char *pos = data;          u_char *pos = data;
Line 354  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _ Line 362  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _
         struct bpf_hdr *bpf;          struct bpf_hdr *bpf;
         struct ansh_hdr *hdr;          struct ansh_hdr *hdr;
         u_int crc;          u_int crc;
           u_char *str;
   
         if (rlen < (sizeof(struct bpf_hdr) + ETHER_HDR_LEN + sizeof(struct ansh_hdr))) {          if (rlen < (sizeof(struct bpf_hdr) + ETHER_HDR_LEN + sizeof(struct ansh_hdr))) {
                 VERB(1) LOG("Discard packet too short %d ...", rlen);                  VERB(1) LOG("Discard packet too short %d ...", rlen);
Line 386  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _ Line 395  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _
                         VERB(3) LOG("Channel SECURED:: Plain text communication not supported at this moment ...");                          VERB(3) LOG("Channel SECURED:: Plain text communication not supported at this moment ...");
                         return ANSH_FLG_ERR;                          return ANSH_FLG_ERR;
                 }                  }
                   if (ntohl(hdr->ansh_nonce) != *crypted)
                           VERB(4) LOG("Detect change of nonce from %x to %x", *crypted, ntohl(hdr->ansh_nonce));
   
                 *crypted = ntohl(hdr->ansh_nonce);                  *crypted = ntohl(hdr->ansh_nonce);
         }          }
Line 402  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _ Line 413  _pkt_Recv(u_char * __restrict buf, int rlen, u_int * _
         /* select data */          /* select data */
         if (data) {          if (data) {
                 *datlen = ntohs(hdr->ansh_len) - sizeof(struct ansh_hdr);                  *datlen = ntohs(hdr->ansh_len) - sizeof(struct ansh_hdr);
                   if (Crypted) {
                           str = cryptBuffer(buf + bpf->bh_hdrlen + ETHER_HDR_LEN + sizeof(struct ansh_hdr), 
                                           *datlen, Crypted);
                           if (str) {
                                   memcpy(buf + bpf->bh_hdrlen + ETHER_HDR_LEN + sizeof(struct ansh_hdr), 
                                                   str, *datlen);
                                   e_free(str);
                           }
                   }
   
                 memcpy(data, buf + bpf->bh_hdrlen + ETHER_HDR_LEN + sizeof(struct ansh_hdr), *datlen);                  memcpy(data, buf + bpf->bh_hdrlen + ETHER_HDR_LEN + sizeof(struct ansh_hdr), *datlen);
         }          }
   
Line 425  pktRecv(int s, u_int * __restrict seq, u_int * __restr Line 446  pktRecv(int s, u_int * __restrict seq, u_int * __restr
         else          else
                 memset(data, 0, *datlen);                  memset(data, 0, *datlen);
   
        if (!(buf = malloc(*datlen))) {        if (!(buf = e_malloc(*datlen))) {
                 ERR("malloc() #%d - %s", errno, strerror(errno));                  ERR("malloc() #%d - %s", errno, strerror(errno));
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         }          }
Line 433  pktRecv(int s, u_int * __restrict seq, u_int * __restr Line 454  pktRecv(int s, u_int * __restrict seq, u_int * __restr
         rlen = read(s, buf, *datlen);          rlen = read(s, buf, *datlen);
         if (rlen == -1) {          if (rlen == -1) {
                 ERR("Receive packet() #%d - %s", errno, strerror(errno));                  ERR("Receive packet() #%d - %s", errno, strerror(errno));
                free(buf);                e_free(buf);
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         } else          } else
                 VERB(4) LOG("Get packet with len=%d", rlen);                  VERB(4) LOG("Get packet with len=%d", rlen);
Line 441  pktRecv(int s, u_int * __restrict seq, u_int * __restr Line 462  pktRecv(int s, u_int * __restrict seq, u_int * __restr
         /* check header len */          /* check header len */
         if (rlen < (sizeof(struct bpf_hdr) + ETHER_HDR_LEN + sizeof(struct ansh_hdr))) {          if (rlen < (sizeof(struct bpf_hdr) + ETHER_HDR_LEN + sizeof(struct ansh_hdr))) {
                 VERB(1) LOG("Discard packet too short %d ...", rlen);                  VERB(1) LOG("Discard packet too short %d ...", rlen);
                free(buf);                e_free(buf);
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         } else {          } else {
                 bpf = (struct bpf_hdr*) buf;                  bpf = (struct bpf_hdr*) buf;
Line 452  pktRecv(int s, u_int * __restrict seq, u_int * __restr Line 473  pktRecv(int s, u_int * __restrict seq, u_int * __restr
         ptr = next = buf;          ptr = next = buf;
         ptrlen = nextlen = rlen;          ptrlen = nextlen = rlen;
         if ((flg = _pkt_Recv(ptr, ptrlen, seq, crypted, pos, &buflen, &next, &nextlen)) == -1) {          if ((flg = _pkt_Recv(ptr, ptrlen, seq, crypted, pos, &buflen, &next, &nextlen)) == -1) {
                free(buf);                e_free(buf);
                 return ANSH_FLG_ERR;                  return ANSH_FLG_ERR;
         } else {          } else {
                 pos += buflen;                  pos += buflen;
Line 471  pktRecv(int s, u_int * __restrict seq, u_int * __restr Line 492  pktRecv(int s, u_int * __restrict seq, u_int * __restr
                         ptrlen = nextlen;                          ptrlen = nextlen;
                 }                  }
   
        free(buf);        e_free(buf);
   
         return flg;          return flg;
 }  }
Line 509  cryptBuffer(u_char *buf, int rlen, u_int ctr) Line 530  cryptBuffer(u_char *buf, int rlen, u_int ctr)
         memcpy(ivec + 8, &ctr, sizeof ctr);          memcpy(ivec + 8, &ctr, sizeof ctr);
         memcpy(ivec + 12, &rctr, sizeof rctr);          memcpy(ivec + 12, &rctr, sizeof rctr);
   
        if (io_ctr_AES(buf, rlen, &str, (u_char*) "_ansh_ELWIX_", ivec) == -1)        if (io_ctr_AES(buf, rlen, &str, (u_char*) Key, ivec) == -1)
                 return NULL;                  return NULL;
   
         return str;          return str;
Removed from v.1.1.1.1.2.8  
changed lines
  Added in v.1.5.2.1

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