[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.2 and 1.5

version 1.2, 2013/05/30 09:07:33 version 1.5, 2013/06/19 00:11:16
Line 136  e_n2port(sockaddr_t * __restrict addr) Line 136  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 str[INET6_ADDRSTRLEN] = { 0 };        char *s, str[INET6_ADDRSTRLEN] = { 0 };
         const char *ret = NULL;          const char *ret = NULL;
   
         if (!addr || !val)          if (!addr || !val)
Line 161  e_n2addr(sockaddr_t * __restrict addr, ait_val_t * __r Line 161  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;
                   case AF_LINK:
                           if (!(s = link_ntoa(&addr->sdl))) {
                                   LOGERR;
                                   return ret;
                           } else
                                   ret = s;
                           break;
                 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 280  e_usleep(u_int usec) Line 287  e_usleep(u_int usec)
         struct timeval tv = { (time_t) (usec / 1000000), (long) (usec % 1000000) };          struct timeval tv = { (time_t) (usec / 1000000), (long) (usec % 1000000) };
   
         return select(0, NULL, NULL, NULL, &tv);          return select(0, NULL, NULL, NULL, &tv);
   }
   
   /*
    * e_innet() - Test address match in network
    *
    * @net = network
    * @addr = address
    * return: -1 error, 0 match or 1 not match
    */
   int
   e_innet(netaddr_t * __restrict net, inaddr_t * __restrict addr)
   {
           register int i;
           int ret = 0;
   
           if (!net || !addr)
                   return -1;
   
           switch (net->addr.sa.sa_family) {
                   case AF_INET:
                           for (i = 0; i < sizeof(struct in_addr); i++) {
                                   ret = ((caddr_t) &net->addr.sin.sin_addr.s_addr)[i] & 
                                           net->mask.in.s4_addr[i];
                                   ret -= addr->in.s4_addr[i] & net->mask.in.s4_addr[i];
                                   if (ret)
                                           break;
                           }
                           break;
                   case AF_INET6:
                           for (i = 0; i < sizeof(struct in6_addr); i++) {
                                   ret = net->addr.sin6.sin6_addr.s6_addr[i] & 
                                           net->mask.in6.s6_addr[i];
                                   ret -= addr->in6.s6_addr[i] & net->mask.in6.s6_addr[i];
                                   if (ret)
                                           break;
                           }
                           break;
                   default:
                           return -1;
           }
   
           return !!ret;
   }
   
   /*
    * e_getnet() - Get network from string
    *
    * @net = Network string (format: <net[/cidr]>)
    * return: NULL error or !=NULL network should be e_free()
    */
   netaddr_t *
   e_getnet(const char *net)
   {
           netaddr_t *n;
           char *str, *wrk;
           struct hostent *host;
   
           n = e_malloc(sizeof(netaddr_t));
           if (!n) {
                   LOGERR;
                   return NULL;
           } else
                   memset(n, 0, sizeof(netaddr_t));
           str = e_strdup(net);
           if (!str) {
                   LOGERR;
                   e_free(n);
                   return NULL;
           }
           wrk = strchr(str, '/');
           if (wrk)
                   *wrk++ = 0;
   
           host = gethostbyname2(str, strchr(str, ':') ? AF_INET6 : AF_INET);
           if (!host) {
                   elwix_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));
                   e_free(str);
                   e_free(n);
                   return NULL;
           }
           switch (host->h_addrtype) {
                   case AF_INET:
                           n->addr.sin.sin_len = sizeof(struct sockaddr_in);
                           n->addr.sin.sin_family = host->h_addrtype;
                           memcpy(&n->addr.sin.sin_addr, host->h_addr, sizeof n->addr.sin.sin_addr);
                           if (wrk)
                                   n->mask.in.s_addr = E_CIDRMASK(strtol(wrk, NULL, 10));
                           else
                                   n->mask.in.s_addr = 0xFFFFFFFF;
                           break;
                   case AF_INET6:
                           n->addr.sin6.sin6_len = sizeof(struct sockaddr_in6);
                           n->addr.sin6.sin6_family = host->h_addrtype;
                           memcpy(&n->addr.sin6.sin6_addr, host->h_addr, sizeof n->addr.sin6.sin6_addr);
                           /* TODO: should support ipv6 mask */
                           break;
                   default:
                           elwix_SetErr(EINVAL, "Unsupported family #%d", host->h_addrtype);
                           e_free(str);
                           e_free(n);
                           return NULL;
           }
   
           e_free(str);
           return n;
 }  }
Removed from v.1.2  
changed lines
  Added in v.1.5

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