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

Diff for /libelwix/src/net.c between versions 1.12.4.4 and 1.20.4.1

version 1.12.4.4, 2016/05/14 19:55:52 version 1.20.4.1, 2020/05/27 15:02:33
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 - 2016Copyright 2004 - 2020
         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 49  SUCH DAMAGE. Line 49  SUCH DAMAGE.
 #ifndef __linux__  #ifndef __linux__
 static char hexlist[] = "0123456789abcdef";  static char hexlist[] = "0123456789abcdef";
   
   #ifndef HAVE_LINK_ADDR
   
   /* States*/
   #define NAMING  0
   #define GOTONE  1
   #define GOTTWO  2
   #define RESET   3
   /* Inputs */
   #define DIGIT   (4*0)
   #define END     (4*1)
   #define DELIM   (4*2)
   #define LETTER  (4*3)
   
   void
   link_addr(const char *addr, struct sockaddr_dl *sdl)
   {
           char *cp = sdl->sdl_data;
           char *cplim = sdl->sdl_len + (char *)sdl;
           int byte = 0, state = NAMING, new = 0;
   
           bzero((char *)&sdl->sdl_family, sdl->sdl_len - 1);
           sdl->sdl_family = AF_LINK;
           do {
                   state &= ~LETTER;
                   if ((*addr >= '0') && (*addr <= '9')) {
                           new = *addr - '0';
                   } else if ((*addr >= 'a') && (*addr <= 'f')) {
                           new = *addr - 'a' + 10;
                   } else if ((*addr >= 'A') && (*addr <= 'F')) {
                           new = *addr - 'A' + 10;
                   } else if (*addr == 0) {
                           state |= END;
                   } else if (state == NAMING &&
                              (((*addr >= 'A') && (*addr <= 'Z')) ||
                              ((*addr >= 'a') && (*addr <= 'z'))))
                           state |= LETTER;
                   else
                           state |= DELIM;
                   addr++;
                   switch (state /* | INPUT */) {
                   case NAMING | DIGIT:
                   case NAMING | LETTER:
                           *cp++ = addr[-1];
                           continue;
                   case NAMING | DELIM:
                           state = RESET;
                           sdl->sdl_nlen = cp - sdl->sdl_data;
                           continue;
                   case GOTTWO | DIGIT:
                           *cp++ = byte;
                           /* FALLTHROUGH */
                   case RESET | DIGIT:
                           state = GOTONE;
                           byte = new;
                           continue;
                   case GOTONE | DIGIT:
                           state = GOTTWO;
                           byte = new + (byte << 4);
                           continue;
                   default: /* | DELIM */
                           state = RESET;
                           *cp++ = byte;
                           byte = 0;
                           continue;
                   case GOTONE | END:
                   case GOTTWO | END:
                           *cp++ = byte;
                           /* FALLTHROUGH */
                   case RESET | END:
                           break;
                   }
                   break;
           } while (cp < cplim);
           sdl->sdl_alen = cp - LLADDR(sdl);
           new = cp - (char *)sdl;
           if (new > sizeof(*sdl))
                   sdl->sdl_len = new;
           return;
   }
   #endif
   
   
 /*  /*
  * e_link_ntoa() - String ethernet address from link address   * e_link_ntoa() - String ethernet address from link address
  *   *
Line 256  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r Line 338  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r
  * @psHost = Hostname   * @psHost = Hostname
  * @port = Port   * @port = Port
  * @addr = Network address structure   * @addr = Network address structure
 * return: NULL error or !=NULL network structure * return: 0 is error or >0 length of network structure
  */   */
sockaddr_t *socklen_t 
 e_gethostbyname(const char *psHost, u_short port, sockaddr_t * __restrict addr)  e_gethostbyname(const char *psHost, u_short port, sockaddr_t * __restrict addr)
 {  {
         struct hostent *host = NULL;          struct hostent *host = NULL;
   
         if (!psHost || !addr)          if (!psHost || !addr)
                return NULL;                return 0;
   
         if (*psHost != '/') {          if (*psHost != '/') {
                 /* resolver */                  /* resolver */
                 host = gethostbyname2(psHost, !strchr(psHost, ':') ? AF_INET : AF_INET6);                  host = gethostbyname2(psHost, !strchr(psHost, ':') ? AF_INET : AF_INET6);
                 if (!host) {                  if (!host) {
                         elwix_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));                          elwix_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));
                        return NULL;                        return 0;
                 } else {                  } else {
                         memset(addr, 0, sizeof(sockaddr_t));                          memset(addr, 0, sizeof(sockaddr_t));
                         addr->sa.sa_family = host->h_addrtype;                          addr->sa.sa_family = host->h_addrtype;
Line 290  e_gethostbyname(const char *psHost, u_short port, sock Line 372  e_gethostbyname(const char *psHost, u_short port, sock
                         addr->sin.sin_family = AF_INET;                          addr->sin.sin_family = AF_INET;
                         addr->sin.sin_port = htons(port);                          addr->sin.sin_port = htons(port);
                         memcpy(&addr->sin.sin_addr, host->h_addr, sizeof addr->sin.sin_addr);                          memcpy(&addr->sin.sin_addr, host->h_addr, sizeof addr->sin.sin_addr);
                        return addr;                        return sizeof addr->sin;
                 case AF_INET6:                  case AF_INET6:
 #ifndef __linux__  #ifndef __linux__
                         addr->sin6.sin6_len = sizeof(struct sockaddr_in6);                          addr->sin6.sin6_len = sizeof(struct sockaddr_in6);
Line 298  e_gethostbyname(const char *psHost, u_short port, sock Line 380  e_gethostbyname(const char *psHost, u_short port, sock
                         addr->sin6.sin6_family = AF_INET6;                          addr->sin6.sin6_family = AF_INET6;
                         addr->sin6.sin6_port = htons(port);                          addr->sin6.sin6_port = htons(port);
                         memcpy(&addr->sin6.sin6_addr, host->h_addr, sizeof addr->sin6.sin6_addr);                          memcpy(&addr->sin6.sin6_addr, host->h_addr, sizeof addr->sin6.sin6_addr);
                        return addr;                        return sizeof addr->sin6;
                 case AF_LOCAL:                  case AF_LOCAL:
 #ifndef __linux__  #ifndef __linux__
                         addr->sun.sun_len = sizeof(struct sockaddr_un);                          addr->sun.sun_len = sizeof(struct sockaddr_un);
Line 306  e_gethostbyname(const char *psHost, u_short port, sock Line 388  e_gethostbyname(const char *psHost, u_short port, sock
                         addr->sun.sun_family = AF_LOCAL;                          addr->sun.sun_family = AF_LOCAL;
                         memset(addr->sun.sun_path, 0, sizeof addr->sun.sun_path);                          memset(addr->sun.sun_path, 0, sizeof addr->sun.sun_path);
                         snprintf(addr->sun.sun_path, sizeof addr->sun.sun_path, "%s-%hu", psHost, port);                          snprintf(addr->sun.sun_path, sizeof addr->sun.sun_path, "%s-%hu", psHost, port);
                        return addr;                        return sizeof addr->sun;
                 default:                  default:
                         elwix_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", addr->sa.sa_family);                          elwix_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", addr->sa.sa_family);
                         break;                          break;
         }          }
   
        return NULL;        return 0;
 }  }
   
 /*  /*
    * e_addrlen() - Get address length from network structure
    *
    * @addr = address
    * return: 0 is error or >0 length of network structure
    */
   socklen_t
   e_addrlen(const sockaddr_t *addr)
   {
           if (!addr)
                   return 0;
   
           switch (addr->sa.sa_family) {
                   case AF_INET:
                           return sizeof addr->sin;
                   case AF_INET6:
                           return sizeof addr->sin6;
                   case AF_LOCAL:
                           return sizeof addr->sun;
   #ifndef __linux__
                   case AF_LINK:
                           return sizeof addr->sdl;
   #endif
           }
   
           return E_SOCKADDR_MAX;
   }
   
   /*
  * e_addrcmp() - Compare network addresses   * e_addrcmp() - Compare network addresses
  *   *
  * @a = 1st address   * @a = 1st address
Line 388  e_innet(netaddr_t * __restrict net, inaddr_t * __restr Line 498  e_innet(netaddr_t * __restrict net, inaddr_t * __restr
                 case AF_INET:                  case AF_INET:
                         for (i = 0; i < sizeof(struct in_addr); i++) {                          for (i = 0; i < sizeof(struct in_addr); i++) {
                                 ret = ((caddr_t) &net->addr.sin.sin_addr.s_addr)[i] &                                   ret = ((caddr_t) &net->addr.sin.sin_addr.s_addr)[i] & 
                                        net->mask.in.s4_addr[i];                                        net->mask.in4.s4_addr[i];
                                ret -= addr->in.s4_addr[i] & net->mask.in.s4_addr[i];                                ret -= addr->in4.s4_addr[i] & net->mask.in4.s4_addr[i];
                                 if (ret)                                  if (ret)
                                         break;                                          break;
                         }                          }
Line 453  e_getnet(const char *net) Line 563  e_getnet(const char *net)
 #endif  #endif
                         n->addr.sin.sin_family = host->h_addrtype;                          n->addr.sin.sin_family = host->h_addrtype;
                         memcpy(&n->addr.sin.sin_addr, host->h_addr, sizeof n->addr.sin.sin_addr);                          memcpy(&n->addr.sin.sin_addr, host->h_addr, sizeof n->addr.sin.sin_addr);
                        if (wrk)                        if (wrk && strtol(wrk, NULL, 10) != 32)
                                 n->mask.in.s_addr = E_CIDRMASK(strtol(wrk, NULL, 10));                                  n->mask.in.s_addr = E_CIDRMASK(strtol(wrk, NULL, 10));
                         else                          else
                                 n->mask.in.s_addr = 0xFFFFFFFF;                                  n->mask.in.s_addr = 0xFFFFFFFF;
Line 521  e_ether_addr(const char *ifname, ether_addr_t * __rest Line 631  e_ether_addr(const char *ifname, ether_addr_t * __rest
                 }                  }
 #else  #else
                 if (p->ifa_name && !strcmp(p->ifa_name, ifname)) {                  if (p->ifa_name && !strcmp(p->ifa_name, ifname)) {
                        s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);                        s = socket(AF_INET, SOCK_DGRAM, 0);
                         if (s == -1)                          if (s == -1)
                                 break;                                  break;
                         strlcpy(req.ifr_name, ifname, sizeof req.ifr_name);                          strlcpy(req.ifr_name, ifname, sizeof req.ifr_name);
Line 529  e_ether_addr(const char *ifname, ether_addr_t * __rest Line 639  e_ether_addr(const char *ifname, ether_addr_t * __rest
                                 a = e_malloc(sizeof(ether_addr_t));                                  a = e_malloc(sizeof(ether_addr_t));
                                 if (a)                                  if (a)
                                         memcpy(a, req.ifr_addr.sa_data, sizeof(ether_addr_t));                                          memcpy(a, req.ifr_addr.sa_data, sizeof(ether_addr_t));
   
                                   /* should set mac address */
                                   if (addr) {
                                           memset(&req, 0, sizeof req);
                                           strlcpy(req.ifr_name, ifname, sizeof req.ifr_name);
                                           sa.sa.sa_family = ARPHRD_ETHER;
                                           memcpy(sa.sa.sa_data, addr, sizeof(ether_addr_t));
                                           req.ifr_hwaddr = sa.sa;
                                           ioctl(s, SIOCSIFHWADDR, &req);
                                   }
                         }                          }
                         close(s);                          close(s);
                         break;                          break;
Line 658  e_getlinkbyether(const ether_addr_t * __restrict mac,  Line 778  e_getlinkbyether(const ether_addr_t * __restrict mac, 
         return a;          return a;
 }  }
 #endif  #endif
   
   /*
    * e_network() - Get network from address string
    *
    * @csAddr = Address string with CIDR mask /xx
    * @net = Network information structure
    * return: -1 error, 1 nothing for return or 0 ok
    */
   int
   e_network(const char *csAddr, netaddr_t * __restrict net)
   {
           int ret = 0;
           u_char mask = 0;
           inaddr_t a;
           char *pos, szAddr[STRSIZ];
           register int i;
   
           if (!csAddr || !net)
                   return -1;
           else
                   strlcpy(szAddr, csAddr, sizeof szAddr);
   
           memset(net, 0, sizeof(netaddr_t));
   
           pos = strrchr(szAddr, '/');
           if (pos) {
                   *pos++ = 0;
                   mask = (u_char) strtol(pos, NULL, 10);
           } else
                   return 1;
   
           if (strchr(szAddr, ':')) {
                   if (mask > 128)
                           return -1;
                   else {
                           for (i = 0; i < 4 && (mask / 32); i++, mask -= 32)
                                   net->mask.in6.__u6_addr.__u6_addr32[i] = 0xFFFFFFFF;
                           if (mask)
                                   net->mask.in6.__u6_addr.__u6_addr32[i] = E_CIDRMASK(mask % 32);
                   }
   
                   inet_pton(AF_INET6, szAddr, &a.in6);
   
   #ifndef __linux__
                   net->addr.sin6.sin6_len = sizeof net->addr.sin6;
   #endif
                   for (i = 0; i < 4; i++)
                           net->addr.sin6.sin6_addr.__u6_addr.__u6_addr32[i] = 
                                   a.in6.__u6_addr.__u6_addr32[i] & net->mask.in6.__u6_addr.__u6_addr32[i];
           } else {
                   if (mask > 32)
                           return -1;
                   else {
                           if (mask == 32)
                                   net->mask.in.s_addr = 0xFFFFFFFF;
                           else
                                   net->mask.in.s_addr = E_CIDRMASK(mask);
                   }
   
                   inet_pton(AF_INET, szAddr, &a.in4);
   
   #ifndef __linux__
                   net->addr.sin.sin_len = sizeof net->addr.sin;
   #endif
                   net->addr.sin.sin_addr.s_addr = a.in.s_addr & net->mask.in.s_addr;
           }
   
           return ret;
   }
Removed from v.1.12.4.4  
changed lines
  Added in v.1.20.4.1

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