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

Diff for /libaitio/src/Attic/tools.c between versions 1.4.4.3 and 1.7.2.2

version 1.4.4.3, 2011/05/17 20:25:20 version 1.7.2.2, 2011/12/14 09:26:58
Line 295  io_FreeNullTerm(char *** __restrict arr) Line 295  io_FreeNullTerm(char *** __restrict arr)
                 *arr = NULL;                  *arr = NULL;
         }          }
 }  }
   
   /*
    * io_ether_ntoa() Convert ethernet address to string
    * @n = ethernet address structure, like struct ether_addr
    * @a = string
    * @len = string length
    * return: NULL error or !=NULL string a
    */
   inline char *
   io_ether_ntoa(const struct io_ether_addr *n, char * __restrict a, int len)
   {
           if (!n || !a)
                   return NULL;
   
           memset(a, 0, len);
           if (snprintf(a, len, "%02x:%02x:%02x:%02x:%02x:%02x", 
                           n->ether_addr_octet[0], n->ether_addr_octet[1], 
                           n->ether_addr_octet[2], n->ether_addr_octet[3], 
                           n->ether_addr_octet[4], n->ether_addr_octet[5]) < 17)
                   return NULL;
   
           return a;
   }
   
   /*
    * io_ether_aton() Convert string to ethernet address
    * @a = string
    * @e = ethernet address structure, like struct ether_addr
    * return: NULL error or !=NULL ethernet address structure
    */
   inline struct io_ether_addr *
   io_ether_aton(const char *a, struct io_ether_addr *e)
   {                       
           int i;
           u_int o0, o1, o2, o3, o4, o5;
   
           if (!a || !e)
                   return NULL;
   
           i = sscanf(a, "%x:%x:%x:%x:%x:%x", &o0, &o1, &o2, &o3, &o4, &o5);
           if (i != 6)
                   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;
   }
   
   /*
    * io_n2port() Extract port from network structure
    * @addr = Address
    * return: 0 not supported family type or port number
    */
   inline u_short
   io_n2port(io_sockaddr_t * __restrict addr)
   {
           u_short port = 0;
   
           if (!addr)
                   return port;
   
           switch (addr->sa.sa_family) {
                   case AF_INET:
                           return ntohs(addr->sin.sin_port);
                   case AF_INET6:
                           return ntohs(addr->sin6.sin6_port);
                   default:
                           io_SetErr(ESOCKTNOSUPPORT, "Unsuported address family %d", 
                                           addr->sa.sa_family);
                           break;
           }
   
           return port;
   }
   
   /*
    * io_n2addr() Extract address from network structure
    * @addr = Address
    * @val = Value for store string address
    * return: NULL error or !=NULL string address from val
    */
   const char *
   io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * __restrict val)
   {
           char str[INET6_ADDRSTRLEN] = { 0 };
           const char *ret = NULL;
   
           if (!addr || !val)
                   return ret;
   
           switch (addr->sa.sa_family) {
                   case AF_INET:
                           if (!inet_ntop(AF_INET, &addr->sin.sin_addr, str, INET_ADDRSTRLEN)) {
                                   LOGERR;
                                   return ret;
                           } else
                                   ret = str;
                           break;
                   case AF_INET6:
                           if (!inet_ntop(AF_INET6, &addr->sin6.sin6_addr, str, INET6_ADDRSTRLEN)) {
                                   LOGERR;
                                   return ret;
                           } else
                                   ret = str;
                           break;
                   default:
                           io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", 
                                           addr->sa.sa_family);
                           return ret;
           }
   
           if (!AIT_ISEMPTY(val))
                   AIT_FREE_VAL(val);
           AIT_SET_STR(val, ret);
           return AIT_GET_STR(val);
   }
   
   /*
    * io_gethostbyname() Get host and port and make network structure
    * @psHost = Hostname
    * @port = Port
    * @addr = Network address structure
    * return: NULL error or !=NULL network structure
    */
   io_sockaddr_t *
   io_gethostbyname(const char *psHost, u_short port, io_sockaddr_t * __restrict addr)
   {
           struct hostent *host;
   
           if (!psHost || !addr)
                   return NULL;
   
           /* resolver */
           if (!addr->sa.sa_family)
                   host = gethostbyname(psHost);
           else
                   host = gethostbyname2(psHost, addr->sa.sa_family);
           if (!host) {
                   io_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));
                   return NULL;
           }
   
           memset(addr, 0, sizeof(io_sockaddr_t));
           switch (host->h_addrtype) {
                   case AF_INET:
                           addr->sin.sin_len = sizeof(struct sockaddr_in);
                           addr->sin.sin_family = AF_INET;
                           addr->sin.sin_port = htons(port);
                           memcpy(&addr->sin.sin_addr, host->h_addr, sizeof addr->sin.sin_addr);
                           return addr;
                   case AF_INET6:
                           addr->sin6.sin6_len = sizeof(struct sockaddr_in6);
                           addr->sin6.sin6_family = AF_INET6;
                           addr->sin6.sin6_port = htons(port);
                           memcpy(&addr->sin6.sin6_addr, host->h_addr, sizeof addr->sin6.sin6_addr);
                           return addr;
                   default:
                           io_SetErr(EPROTONOSUPPORT, "Unsuported address family %d", 
                                           host->h_addrtype);
                           break;
           }
   
           return NULL;
   }
Removed from v.1.4.4.3  
changed lines
  Added in v.1.7.2.2

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