[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.4.2.1 and 1.12

version 1.4.2.1, 2013/06/10 14:49:48 version 1.12, 2015/06/25 17:53:50
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 - 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 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
   static char hexlist[] = "0123456789abcdef";
   
 /*  /*
    * e_link_ntoa() - String ethernet address from link address
    *
    * @sdl = link address
    * return: =NULL error or !=NULL ethernet address, should be e_free()
    */
   char *
   e_link_ntoa(const struct sockaddr_dl *sdl)
   {
           static char obuf[64];
           char *out = obuf;
           int i;
           u_char *in = (u_char*) LLADDR(sdl);
           u_char *inlim = in + sdl->sdl_alen;
           int firsttime = 1;
   
           if (sdl->sdl_nlen) {
                   memcpy(obuf, sdl->sdl_data, sdl->sdl_nlen);
                   out += sdl->sdl_nlen;
                   if (sdl->sdl_alen)
                           *out++ = '!';
           }
   
           while (in < inlim) {
                   if (firsttime)
                           firsttime ^= firsttime;
                   else
                           *out++ = ':';
   
                   i = *in++;
                   if (i > 0xf) {
                           out[1] = hexlist[i & 0xf];
                           i >>= 4;
                   } else {
                           out[1] = hexlist[i];
                           i = 0;
                   }
   
                   out[0] = hexlist[i];
                   out += 2;
           }
   
           *out = 0;
           return obuf;
   }
   
   /*
    * e_link_addr() - String ethernet address to link address
    *
    * @mac = ethernet address
    * @sdl = link address
    * return: -1 error or 0 ok
    */
   int
   e_link_addr(const char *mac, struct sockaddr_dl * __restrict sdl)
   {
           if (!mac || !sdl)
                   return -1;
           if (!sdl->sdl_len)
                   sdl->sdl_len = sizeof(struct sockaddr_dl);
   
           link_addr(mac, sdl);
           return 0;
   }
   
   /*
  * e_ether_ntoa() - Convert ethernet address to string   * e_ether_ntoa() - Convert ethernet address to string
  *   *
  * @n = ethernet address structure, like struct ether_addr   * @n = ethernet address structure, like struct ether_addr
Line 55  SUCH DAMAGE. Line 122  SUCH DAMAGE.
  * return: NULL error or !=NULL string a   * return: NULL error or !=NULL string a
  */   */
 char *  char *
e_ether_ntoa(const struct e_ether_addr *n, char * __restrict a, int len)e_ether_ntoa(const ether_addr_t * __restrict n, char * __restrict a, int len)
 {  {
         if (!n || !a)          if (!n || !a)
                 return NULL;                  return NULL;
   
         memset(a, 0, len);          memset(a, 0, len);
        if (snprintf(a, len, "%02x:%02x:%02x:%02x:%02x:%02x",         if (snprintf(a, len, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx", 
                        n->ether_addr_octet[0], n->ether_addr_octet[1],                         n->octet[0], n->octet[1], 
                        n->ether_addr_octet[2], n->ether_addr_octet[3],                         n->octet[2], n->octet[3], 
                        n->ether_addr_octet[4], n->ether_addr_octet[5]) < 17)                        n->octet[4], n->octet[5]) < 17)
                 return NULL;                  return NULL;
   
         return a;          return a;
Line 77  e_ether_ntoa(const struct e_ether_addr *n, char * __re Line 144  e_ether_ntoa(const struct e_ether_addr *n, char * __re
  * @e = ethernet address structure, like struct ether_addr   * @e = ethernet address structure, like struct ether_addr
  * return: NULL error or !=NULL ethernet address structure   * return: NULL error or !=NULL ethernet address structure
  */   */
struct e_ether_addr *ether_addr_t *
e_ether_aton(const char *a, struct e_ether_addr *e)e_ether_aton(const char *a, ether_addr_t * __restrict e)
 {                         {                       
         int i;          int i;
         u_int o0, o1, o2, o3, o4, o5;  
   
         if (!a || !e)          if (!a || !e)
                 return NULL;                  return NULL;
   
        i = sscanf(a, "%x:%x:%x:%x:%x:%x", &o0, &o1, &o2, &o3, &o4, &o5);        i = sscanf(a, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 
                         &e->octet[0], 
                         &e->octet[1], 
                         &e->octet[2], 
                         &e->octet[3], 
                         &e->octet[4], 
                         &e->octet[5]);
         if (i != 6)          if (i != 6)
                 return NULL;                  return NULL;
   
         e->ether_addr_octet[0] = o0;  
         e->ether_addr_octet[1] = o1;  
         e->ether_addr_octet[2] = o2;  
         e->ether_addr_octet[3] = o3;  
         e->ether_addr_octet[4] = o4;  
         e->ether_addr_octet[5] = o5;  
   
         return e;          return e;
 }  }
   
Line 162  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r Line 227  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r
                         ret = addr->sun.sun_path;                          ret = addr->sun.sun_path;
                         break;                          break;
                 case AF_LINK:                  case AF_LINK:
                        if (!(s = link_ntoa(&addr->sdl))) {                        if (!(s = e_link_ntoa(&addr->sdl))) {
                                 LOGERR;                                  LOGERR;
                                 return ret;                                  return ret;
                         } else                          } else
Line 196  e_gethostbyname(const char *psHost, u_short port, sock Line 261  e_gethostbyname(const char *psHost, u_short port, sock
   
         if (*psHost != '/') {          if (*psHost != '/') {
                 /* resolver */                  /* resolver */
                if (!addr->sa.sa_family)                host = gethostbyname2(psHost, !strchr(psHost, ':') ? AF_INET : AF_INET6);
                        host = gethostbyname(psHost); 
                else 
                        host = gethostbyname2(psHost, addr->sa.sa_family); 
                 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 NULL;
Line 270  e_addrcmp(sockaddr_t * __restrict a, sockaddr_t * __re Line 332  e_addrcmp(sockaddr_t * __restrict a, sockaddr_t * __re
                         case AF_LINK:                          case AF_LINK:
                                 return memcmp(&a->sdl.sdl_data, &b->sdl.sdl_data,                                   return memcmp(&a->sdl.sdl_data, &b->sdl.sdl_data, 
                                                 sizeof a->sdl.sdl_data);                                                  sizeof a->sdl.sdl_data);
                           case AF_UNSPEC:
                                   return memcmp(a, b, sizeof(sockaddr_t));
                 }                  }
   
         return (int) !!(a - b);          return (int) !!(a - b);
Line 392  e_getnet(const char *net) Line 456  e_getnet(const char *net)
   
         e_free(str);          e_free(str);
         return n;          return n;
   }
   
   /*
    * e_ether_addr() - Get or set ethernet address from interface name
    *
    * @ifname = interface name
    * @addr = if addr is !=NULL then set this for new address
    * return: NULL error or !=NULL get ethernet address should be e_free()
    */
   ether_addr_t *
   e_ether_addr(const char *ifname, ether_addr_t * __restrict addr)
   {
           ether_addr_t *a = NULL;
           struct ifaddrs *p, *ifa = NULL;
   
           if (!ifname)
                   return NULL;
   
           a = e_malloc(sizeof(ether_addr_t));
           if (!a)
                   return NULL;
           else
                   memset(a, 0, sizeof(ether_addr_t));
   
           getifaddrs(&ifa);
           for (p = ifa; p && p->ifa_name; p++)
                   if (p->ifa_name && !strcmp(p->ifa_name, ifname) && p->ifa_addr && 
                                   p->ifa_addr->sa_family == AF_LINK) {
                           memcpy(a, LLADDR((struct sockaddr_dl*) p->ifa_addr), sizeof(ether_addr_t));
                           break;
                   }
           freeifaddrs(ifa);
   
           return a;
   }
   
   /*
    * e_get1stiface() - Get first interface of host
    *
    * @szIface = interface string buffer
    * @iflen = size of interface buffer
    * return: -1 error or 0 ok
    */
   int
   e_get1stiface(char *szIface, int iflen)
   {
           struct ifaddrs *ifa;
   
           if (!szIface || !iflen)
                   return -1;
   
           getifaddrs(&ifa);
           strlcpy(szIface, ifa->ifa_name, iflen);
           freeifaddrs(ifa);
           return 0;
   }
   
   /*
    * e_getifacebyname() - Get interface and make network structure
    *
    * @psIface = Interface, if =NULL first interface
    * @addr = Network address structure
    * return: NULL error or !=NULL network structure
    */
   sockaddr_t *
   e_getifacebyname(const char *psIface, sockaddr_t * __restrict addr)
   {
           char szIface[64] = { [0 ... 63] = 0 };
           struct ifaddrs *p, *ifa = NULL;
   
           if (!addr)
                   return NULL;
   
           memset(addr, 0, sizeof(sockaddr_t));
           getifaddrs(&ifa);
           strlcpy(szIface, psIface ? psIface : ifa->ifa_name, sizeof szIface);
           for (p = ifa; p && p->ifa_name; p++)
                   if (p->ifa_name && !strcmp(p->ifa_name, szIface) && p->ifa_addr && 
                                   p->ifa_addr->sa_family == AF_LINK) {
                           memcpy(&addr->sdl, p->ifa_addr, sizeof(struct sockaddr_dl));
                           break;
                   }
           freeifaddrs(ifa);
   
           return addr;
   }
   
   /*
    * e_getlinkbyname() - Get host ethernet address and make network structure
    *
    * @psHost = Host ethernet address
    * @addr = Network address structure
    * return: NULL error or !=NULL network structure
    */
   sockaddr_t *
   e_getlinkbyname(const char *psHost, sockaddr_t * __restrict addr)
   {
           ait_val_t v;
           sockaddr_t *a = addr;
   
           if (!psHost || !addr)
                   return NULL;
           else
                   memset(addr, 0, sizeof(sockaddr_t));
   
           AIT_INIT_VAL2(&v, string);
           if (!strchr(psHost, '.'))
                   AIT_SET_STR(&v, ":");
           AIT_SET_STRCAT(&v, psHost);
   
           addr->sdl.sdl_len = sizeof(struct sockaddr_dl);
           if (e_link_addr(AIT_GET_STR(&v), &addr->sdl))
                   a = NULL;
   
           AIT_FREE_VAL(&v);
           return a;
   }
   
   /*
    * e_getlinkbyether() - Get ethernet address and make network structure
    *
    * @mac = Ethernet address
    * @idx = Interface index
    * @type = Interface type
    * @iface = Interface name
    * @addr = Network address structure
    * return: NULL error or !=NULL network structure
    */
   sockaddr_t *
   e_getlinkbyether(const ether_addr_t * __restrict mac, u_short idx, u_char type, 
                   const char *iface, sockaddr_t * __restrict addr)
   {
           sockaddr_t *a = addr;
   
           if (!addr)
                   return NULL;
           else
                   memset(addr, 0, sizeof(sockaddr_t));
   
           addr->sdl.sdl_len = sizeof(struct sockaddr_dl);
           addr->sdl.sdl_family = AF_LINK;
           addr->sdl.sdl_index = idx;
           addr->sdl.sdl_type = type;
           if (iface && *iface) {
                   addr->sdl.sdl_nlen = strlen(iface);
                   memcpy(addr->sdl.sdl_data, iface, addr->sdl.sdl_nlen);
           }
           addr->sdl.sdl_alen = sizeof(ether_addr_t);
           memcpy(LLADDR(&addr->sdl), mac, addr->sdl.sdl_alen);
   
           return a;
 }  }
Removed from v.1.4.2.1  
changed lines
  Added in v.1.12

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