[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 and 1.12.4.1

version 1.12, 2015/06/25 17:53:50 version 1.12.4.1, 2016/05/14 11:31:38
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
   #ifndef __linux__
 static char hexlist[] = "0123456789abcdef";  static char hexlist[] = "0123456789abcdef";
   
 /*  /*
Line 112  e_link_addr(const char *mac, struct sockaddr_dl * __re Line 113  e_link_addr(const char *mac, struct sockaddr_dl * __re
         link_addr(mac, sdl);          link_addr(mac, sdl);
         return 0;          return 0;
 }  }
   #endif
   
 /*  /*
  * e_ether_ntoa() - Convert ethernet address to string   * e_ether_ntoa() - Convert ethernet address to string
Line 201  e_n2port(sockaddr_t * __restrict addr) Line 203  e_n2port(sockaddr_t * __restrict addr)
 const char *  const char *
 e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __restrict val)  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __restrict val)
 {  {
        char *s, str[INET6_ADDRSTRLEN] = { 0 };#ifndef __linux__
         char *s;
 #endif
         char str[INET6_ADDRSTRLEN] = { 0 };
         const char *ret = NULL;          const char *ret = NULL;
   
         if (!addr || !val)          if (!addr || !val)
Line 226  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r Line 231  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r
                 case AF_LOCAL:                  case AF_LOCAL:
                         ret = addr->sun.sun_path;                          ret = addr->sun.sun_path;
                         break;                          break;
   #ifndef __linux__
                 case AF_LINK:                  case AF_LINK:
                         if (!(s = e_link_ntoa(&addr->sdl))) {                          if (!(s = e_link_ntoa(&addr->sdl))) {
                                 LOGERR;                                  LOGERR;
Line 233  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r Line 239  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r
                         } else                          } else
                                 ret = s;                                  ret = s;
                         break;                          break;
   #endif
                 default:                  default:
                         elwix_SetErr(EPROTONOSUPPORT, "Unsuported address family %d",                           elwix_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", 
                                         addr->sa.sa_family);                                          addr->sa.sa_family);
Line 277  e_gethostbyname(const char *psHost, u_short port, sock Line 284  e_gethostbyname(const char *psHost, u_short port, sock
   
         switch (addr->sa.sa_family) {          switch (addr->sa.sa_family) {
                 case AF_INET:                  case AF_INET:
   #ifndef __linux__
                         addr->sin.sin_len = sizeof(struct sockaddr_in);                          addr->sin.sin_len = sizeof(struct sockaddr_in);
   #endif
                         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 addr;
                 case AF_INET6:                  case AF_INET6:
   #ifndef __linux__
                         addr->sin6.sin6_len = sizeof(struct sockaddr_in6);                          addr->sin6.sin6_len = sizeof(struct sockaddr_in6);
   #endif
                         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 addr;
                 case AF_LOCAL:                  case AF_LOCAL:
   #ifndef __linux__
                         addr->sun.sun_len = sizeof(struct sockaddr_un);                          addr->sun.sun_len = sizeof(struct sockaddr_un);
   #endif
                         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);
Line 329  e_addrcmp(sockaddr_t * __restrict a, sockaddr_t * __re Line 342  e_addrcmp(sockaddr_t * __restrict a, sockaddr_t * __re
                                 else                                  else
                                         return memcmp(&a->sin6.sin6_addr, &b->sin6.sin6_addr,                                           return memcmp(&a->sin6.sin6_addr, &b->sin6.sin6_addr, 
                                                         sizeof a->sin6.sin6_addr);                                                          sizeof a->sin6.sin6_addr);
   #ifndef __linux__
                         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);
   #endif
                         case AF_UNSPEC:                          case AF_UNSPEC:
                                 return memcmp(a, b, sizeof(sockaddr_t));                                  return memcmp(a, b, sizeof(sockaddr_t));
                 }                  }
Line 433  e_getnet(const char *net) Line 448  e_getnet(const char *net)
         }          }
         switch (host->h_addrtype) {          switch (host->h_addrtype) {
                 case AF_INET:                  case AF_INET:
   #ifndef __linux__
                         n->addr.sin.sin_len = sizeof(struct sockaddr_in);                          n->addr.sin.sin_len = sizeof(struct sockaddr_in);
   #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)
Line 442  e_getnet(const char *net) Line 459  e_getnet(const char *net)
                                 n->mask.in.s_addr = 0xFFFFFFFF;                                  n->mask.in.s_addr = 0xFFFFFFFF;
                         break;                          break;
                 case AF_INET6:                  case AF_INET6:
   #ifndef __linux__
                         n->addr.sin6.sin6_len = sizeof(struct sockaddr_in6);                          n->addr.sin6.sin6_len = sizeof(struct sockaddr_in6);
   #endif
                         n->addr.sin6.sin6_family = host->h_addrtype;                          n->addr.sin6.sin6_family = host->h_addrtype;
                         memcpy(&n->addr.sin6.sin6_addr, host->h_addr, sizeof n->addr.sin6.sin6_addr);                          memcpy(&n->addr.sin6.sin6_addr, host->h_addr, sizeof n->addr.sin6.sin6_addr);
                         /* TODO: should support ipv6 mask */                          /* TODO: should support ipv6 mask */
Line 470  e_ether_addr(const char *ifname, ether_addr_t * __rest Line 489  e_ether_addr(const char *ifname, ether_addr_t * __rest
 {  {
         ether_addr_t *a = NULL;          ether_addr_t *a = NULL;
         struct ifaddrs *p, *ifa = NULL;          struct ifaddrs *p, *ifa = NULL;
   #ifdef __linux__
           int s;
           struct ifreq req;
   
           memset(&req, 0, sizeof req);
   #endif
   
         if (!ifname)          if (!ifname)
                 return NULL;                  return NULL;
   
Line 482  e_ether_addr(const char *ifname, ether_addr_t * __rest Line 507  e_ether_addr(const char *ifname, ether_addr_t * __rest
   
         getifaddrs(&ifa);          getifaddrs(&ifa);
         for (p = ifa; p && p->ifa_name; p++)          for (p = ifa; p && p->ifa_name; p++)
   #ifndef __linux__
                 if (p->ifa_name && !strcmp(p->ifa_name, ifname) && p->ifa_addr &&                   if (p->ifa_name && !strcmp(p->ifa_name, ifname) && p->ifa_addr && 
                                 p->ifa_addr->sa_family == AF_LINK) {                                  p->ifa_addr->sa_family == AF_LINK) {
                         memcpy(a, LLADDR((struct sockaddr_dl*) p->ifa_addr), sizeof(ether_addr_t));                          memcpy(a, LLADDR((struct sockaddr_dl*) p->ifa_addr), sizeof(ether_addr_t));
                         break;                          break;
                 }                  }
   #else
                   if (p->ifa_name && !strcmp(p->ifa_name, ifname)) {
                           s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
                           if (s == -1) {
                                   e_free(a);
                                   a = NULL;
                                   break;
                           } else
                                   strlcpy(req.ifr_name, ifname, sizeof req.ifr_name);
                           if (ioctl(s, SIOCGIFHWADDR, &req) == -1) {
                                   e_free(a);
                                   a = NULL;
                           } else
                                   memcpy(a, req.ifr_addr.sa_data, sizeof(ether_addr_t));
                           break;
                   }
   #endif
         freeifaddrs(ifa);          freeifaddrs(ifa);
   
         return a;          return a;
Line 523  e_get1stiface(char *szIface, int iflen) Line 566  e_get1stiface(char *szIface, int iflen)
 sockaddr_t *  sockaddr_t *
 e_getifacebyname(const char *psIface, sockaddr_t * __restrict addr)  e_getifacebyname(const char *psIface, sockaddr_t * __restrict addr)
 {  {
   #ifndef __linux__
         char szIface[64] = { [0 ... 63] = 0 };          char szIface[64] = { [0 ... 63] = 0 };
         struct ifaddrs *p, *ifa = NULL;          struct ifaddrs *p, *ifa = NULL;
   
Line 541  e_getifacebyname(const char *psIface, sockaddr_t * __r Line 585  e_getifacebyname(const char *psIface, sockaddr_t * __r
         freeifaddrs(ifa);          freeifaddrs(ifa);
   
         return addr;          return addr;
   #else
           elwix_SetErr(ENOSYS, "Unsuported routine on linux");
           return NULL;
   #endif
 }  }
   
 /*  /*
Line 553  e_getifacebyname(const char *psIface, sockaddr_t * __r Line 601  e_getifacebyname(const char *psIface, sockaddr_t * __r
 sockaddr_t *  sockaddr_t *
 e_getlinkbyname(const char *psHost, sockaddr_t * __restrict addr)  e_getlinkbyname(const char *psHost, sockaddr_t * __restrict addr)
 {  {
   #ifndef __linux__
         ait_val_t v;          ait_val_t v;
         sockaddr_t *a = addr;          sockaddr_t *a = addr;
   
Line 572  e_getlinkbyname(const char *psHost, sockaddr_t * __res Line 621  e_getlinkbyname(const char *psHost, sockaddr_t * __res
   
         AIT_FREE_VAL(&v);          AIT_FREE_VAL(&v);
         return a;          return a;
   #else
           elwix_SetErr(ENOSYS, "Unsuported routine on linux");
           return NULL;
   #endif
 }  }
   
 /*  /*
Line 588  sockaddr_t * Line 641  sockaddr_t *
 e_getlinkbyether(const ether_addr_t * __restrict mac, u_short idx, u_char type,   e_getlinkbyether(const ether_addr_t * __restrict mac, u_short idx, u_char type, 
                 const char *iface, sockaddr_t * __restrict addr)                  const char *iface, sockaddr_t * __restrict addr)
 {  {
   #ifndef __linux__
         sockaddr_t *a = addr;          sockaddr_t *a = addr;
   
         if (!addr)          if (!addr)
Line 607  e_getlinkbyether(const ether_addr_t * __restrict mac,  Line 661  e_getlinkbyether(const ether_addr_t * __restrict mac, 
         memcpy(LLADDR(&addr->sdl), mac, addr->sdl.sdl_alen);          memcpy(LLADDR(&addr->sdl), mac, addr->sdl.sdl_alen);
   
         return a;          return a;
   #else
           elwix_SetErr(ENOSYS, "Unsuported routine on linux");
           return NULL;
   #endif
 }  }
Removed from v.1.12  
changed lines
  Added in v.1.12.4.1

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