/** * @file * API functions for name resolving * *//* * Redistribution and use in source and binary forms, with or without modification,  * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, *    this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, *    this list of conditions and the following disclaimer in the documentation *    and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products *    derived from this software without specific prior written permission.  * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY  * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. *  * Author: Simon Goldschmidt * */#include "lwip/netdb.h"#if LWIP_DNS && LWIP_SOCKET#include "lwip/err.h"#include "lwip/mem.h"#include "lwip/ip_addr.h"#include "lwip/api.h"/** helper struct for gethostbyname_r to access the char* buffer */struct gethostbyname_r_helper {  struct ip_addr *addrs;  struct ip_addr addr;  char *aliases;};/** h_errno is exported in netdb.h for access by applications. */#if LWIP_DNS_API_DECLARE_H_ERRNOint h_errno;#endif /* LWIP_DNS_API_DECLARE_H_ERRNO *//** define "hostent" variables storage: 0 if we use a static (but unprotected) * set of variables for lwip_gethostbyname, 1 if we use a local storage */#ifndef LWIP_DNS_API_HOSTENT_STORAGE#define LWIP_DNS_API_HOSTENT_STORAGE 0#endif/** define "hostent" variables storage */#if LWIP_DNS_API_HOSTENT_STORAGE#define HOSTENT_STORAGE#else#define HOSTENT_STORAGE static#endif /* LWIP_DNS_API_STATIC_HOSTENT *//** * Returns an entry containing addresses of address family AF_INET * for the host with name name. * Due to dns_gethostbyname limitations, only one address is returned. * * @param name the hostname to resolve * @return an entry containing addresses of address family AF_INET *         for the host with name name */struct hostent*lwip_gethostbyname(const char *name){  err_t err;  struct ip_addr addr;  /* buffer variables for lwip_gethostbyname() */  HOSTENT_STORAGE struct hostent s_hostent;  HOSTENT_STORAGE char *s_aliases;  HOSTENT_STORAGE struct ip_addr s_hostent_addr;  HOSTENT_STORAGE struct ip_addr *s_phostent_addr;  /* query host IP address */  err = netconn_gethostbyname(name, &addr);  if (err != ERR_OK) {    LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err));    h_errno = HOST_NOT_FOUND;    return NULL;  }  /* fill hostent */  s_hostent_addr = addr;  s_phostent_addr = &s_hostent_addr;  s_hostent.h_name = (char*)name;  s_hostent.h_aliases = &s_aliases;  s_hostent.h_addrtype = AF_INET;  s_hostent.h_length = sizeof(struct ip_addr);  s_hostent.h_addr_list = (char**)&s_phostent_addr;#if DNS_DEBUG  /* dump hostent */  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_name           == %s\n",      s_hostent.h_name));  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases        == 0x%08lX\n",(u32_t)(s_hostent.h_aliases)));  if (s_hostent.h_aliases != NULL) {    u8_t idx;    for ( idx=0; s_hostent.h_aliases[idx]; idx++) {      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases[%i]->   == 0x%08lX\n", idx, s_hostent.h_aliases[idx]));      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases[%i]->   == %s\n",      idx, s_hostent.h_aliases[idx]));    }  }  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addrtype       == %lu\n",    (u32_t)(s_hostent.h_addrtype)));  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_length         == %lu\n",    (u32_t)(s_hostent.h_length)));  LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list      == 0x%08lX\n", s_hostent.h_addr_list));  if (s_hostent.h_addr_list != NULL) {    u8_t idx;    for ( idx=0; s_hostent.h_addr_list[idx]; idx++) {      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]   == 0x%08lX\n", idx, s_hostent.h_addr_list[idx]));      LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]-> == %s\n",      idx, inet_ntoa(*((struct in_addr*)(s_hostent.h_addr_list[idx])))));    }  }#endif /* DNS_DEBUG */#if LWIP_DNS_API_HOSTENT_STORAGE  /* this function should return the "per-thread" hostent after copy from s_hostent */  return sys_thread_hostent(&s_hostent);#else  return &s_hostent;#endif /* LWIP_DNS_API_HOSTENT_STORAGE */}/** * Thread-safe variant of lwip_gethostbyname: instead of using a static * buffer, this function takes buffer and errno pointers as arguments * and uses these for the result. * * @param name the hostname to resolve * @param ret pre-allocated struct where to store the result * @param buf pre-allocated buffer where to store additional data * @param buflen the size of buf * @param result pointer to a hostent pointer that is set to ret on success *               and set to zero on error * @param h_errnop pointer to an int where to store errors (instead of modifying *                 the global h_errno) * @return 0 on success, non-zero on error, additional error information *         is stored in *h_errnop instead of h_errno to be thread-safe */intlwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf,                size_t buflen, struct hostent **result, int *h_errnop){  err_t err;  struct gethostbyname_r_helper *h;  char *hostname;  size_t namelen;  int lh_errno;  if (h_errnop == NULL) {    /* ensure h_errnop is never NULL */    h_errnop = &lh_errno;  }  if (result == NULL) {    /* not all arguments given */    *h_errnop = EINVAL;    return -1;  }  /* first thing to do: set *result to nothing */  *result = NULL;  if ((name == NULL) || (ret == NULL) || (buf == 0)) {    /* not all arguments given */    *h_errnop = EINVAL;    return -1;  }  namelen = strlen(name);  if (buflen < (sizeof(struct gethostbyname_r_helper) + namelen + 1 + (MEM_ALIGNMENT - 1))) {    /* buf can't hold the data needed + a copy of name */    *h_errnop = ERANGE;    return -1;  }  h = (struct gethostbyname_r_helper*)LWIP_MEM_ALIGN(buf);  hostname = ((char*)h) + sizeof(struct gethostbyname_r_helper);  /* query host IP address */  err = netconn_gethostbyname(name, &(h->addr));  if (err != ERR_OK) {    LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err));    *h_errnop = ENSRNOTFOUND;    return -1;  }  /* copy the hostname into buf */  MEMCPY(hostname, name, namelen);  hostname[namelen] = 0;  /* fill hostent */  h->addrs = &(h->addr);  h->aliases = NULL;  ret->h_name = (char*)hostname;  ret->h_aliases = &(h->aliases);  ret->h_addrtype = AF_INET;  ret->h_length = sizeof(struct ip_addr);  ret->h_addr_list = (char**)&(h->addrs);  /* set result != NULL */  *result = ret;  /* return success */  return 0;}/** * Frees one or more addrinfo structures returned by getaddrinfo(), along with * any additional storage associated with those structures. If the ai_next field * of the structure is not null, the entire list of structures is freed. * * @param ai struct addrinfo to free */voidlwip_freeaddrinfo(struct addrinfo *ai){  struct addrinfo *next;  while (ai != NULL) {    if (ai->ai_addr != NULL) {      mem_free(ai->ai_addr);    }    if (ai->ai_canonname != NULL) {      mem_free(ai->ai_canonname);    }    next = ai->ai_next;    mem_free(ai);    ai = next;  }}/** * Translates the name of a service location (for example, a host name) and/or * a service name and returns a set of socket addresses and associated * information to be used in creating a socket with which to address the * specified service. * Memory for the result is allocated internally and must be freed by calling * lwip_freeaddrinfo()! * * Due to a limitation in dns_gethostbyname, only the first address of a * host is returned. * Also, service names are not supported (only port numbers)! * * @param nodename descriptive name or address string of the host *                 (may be NULL -> local address) * @param servname port number as string of NULL  * @param hints structure containing input values that set socktype and protocol * @param res pointer to a pointer where to store the result (set to NULL on failure) * @return 0 on success, non-zero on failure */intlwip_getaddrinfo(const char *nodename, const char *servname,       const struct addrinfo *hints, struct addrinfo **res){  err_t err;  struct ip_addr addr;  struct addrinfo *ai;  struct sockaddr_in *sa = NULL;  int port_nr = 0;  if (res == NULL) {    return EAI_FAIL;  }  *res = NULL;  if ((nodename == NULL) && (servname == NULL)) {    return EAI_NONAME;  }  if (servname != NULL) {    /* service name specified: convert to port number     * @todo?: currently, only ASCII integers (port numbers) are supported! */    port_nr = atoi(servname);    if ((port_nr <= 0) || (port_nr > 0xffff)) {      return EAI_SERVICE;    }  }  if (nodename != NULL) {    /* service location specified, try to resolve */    err = netconn_gethostbyname(nodename, &addr);    if (err != ERR_OK) {      return EAI_FAIL;    }  } else {    /* service location specified, use loopback address */    addr.addr = INADDR_LOOPBACK;  }  ai = mem_malloc(sizeof(struct addrinfo));  if (ai == NULL) {    goto memerr;  }  memset(ai, 0, sizeof(struct addrinfo));  sa = mem_malloc(sizeof(struct sockaddr_in));  if (sa == NULL) {    goto memerr;  }  memset(sa, 0, sizeof(struct sockaddr_in));  /* set up sockaddr */  sa->sin_addr.s_addr = addr.addr;  sa->sin_family = AF_INET;  sa->sin_len = sizeof(struct sockaddr_in);  sa->sin_port = htons(port_nr);  /* set up addrinfo */  ai->ai_family = AF_INET;  if (hints != NULL) {    /* copy socktype & protocol from hints if specified */    ai->ai_socktype = hints->ai_socktype;    ai->ai_protocol = hints->ai_protocol;  }  if (nodename != NULL) {    /* copy nodename to canonname if specified */    size_t namelen = strlen(nodename);    ai->ai_canonname = mem_malloc(namelen + 1);    if (ai->ai_canonname == NULL) {      goto memerr;    }    MEMCPY(ai->ai_canonname, nodename, namelen);    ai->ai_canonname[namelen] = 0;  }  ai->ai_addrlen = sizeof(struct sockaddr_in);  ai->ai_addr = (struct sockaddr*)sa;  *res = ai;  return 0;memerr:  if (ai != NULL) {    mem_free(ai);  }  if (sa != NULL) {    mem_free(sa);  }  return EAI_MEMORY;}#endif /* LWIP_DNS && LWIP_SOCKET */