• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /**
2  * @file
3  * API functions for name resolving
4  *
5  */
6 
7 /*
8  * Redistribution and use in source and binary forms, with or without modification,
9  * are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright notice,
12  *    this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright notice,
14  *    this list of conditions and the following disclaimer in the documentation
15  *    and/or other materials provided with the distribution.
16  * 3. The name of the author may not be used to endorse or promote products
17  *    derived from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
20  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
22  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
24  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
28  * OF SUCH DAMAGE.
29  *
30  * This file is part of the lwIP TCP/IP stack.
31  *
32  * Author: Simon Goldschmidt
33  *
34  */
35 
36 #include "lwip/netdb.h"
37 
38 #if LWIP_DNS && LWIP_SOCKET
39 
40 #include "lwip/err.h"
41 #include "lwip/mem.h"
42 #include "lwip/memp.h"
43 #include "lwip/ip_addr.h"
44 #include "lwip/api.h"
45 #include "lwip/dns.h"
46 
47 #include <string.h>
48 #include <stdlib.h>
49 
50 /** helper struct for gethostbyname_r to access the char* buffer */
51 struct gethostbyname_r_helper {
52   ip_addr_t *addrs;
53   ip_addr_t addr;
54   char *aliases;
55 };
56 
57 /** h_errno is exported in netdb.h for access by applications. */
58 #if LWIP_DNS_API_DECLARE_H_ERRNO
59 int h_errno;
60 #endif /* LWIP_DNS_API_DECLARE_H_ERRNO */
61 
62 /** define "hostent" variables storage: 0 if we use a static (but unprotected)
63  * set of variables for lwip_gethostbyname, 1 if we use a local storage */
64 #ifndef LWIP_DNS_API_HOSTENT_STORAGE
65 #define LWIP_DNS_API_HOSTENT_STORAGE 0
66 #endif
67 
68 /** define "hostent" variables storage */
69 #if LWIP_DNS_API_HOSTENT_STORAGE
70 #define HOSTENT_STORAGE
71 #else
72 #define HOSTENT_STORAGE static
73 #endif /* LWIP_DNS_API_STATIC_HOSTENT */
74 
75 /**
76  * Returns an entry containing addresses of address family AF_INET
77  * for the host with name name.
78  * Due to dns_gethostbyname limitations, only one address is returned.
79  *
80  * @param name the hostname to resolve
81  * @return an entry containing addresses of address family AF_INET
82  *         for the host with name name
83  */
84 struct hostent*
lwip_gethostbyname(const char * name)85 lwip_gethostbyname(const char *name)
86 {
87   err_t err;
88   ip_addr_t addr;
89 
90   /* buffer variables for lwip_gethostbyname() */
91   HOSTENT_STORAGE struct hostent s_hostent;
92   HOSTENT_STORAGE char *s_aliases;
93   HOSTENT_STORAGE ip_addr_t s_hostent_addr;
94   HOSTENT_STORAGE ip_addr_t *s_phostent_addr[2];
95 
96   /* query host IP address */
97   err = netconn_gethostbyname(name, &addr);
98   if (err != ERR_OK) {
99     LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err));
100     h_errno = HOST_NOT_FOUND;
101     return NULL;
102   }
103 
104   /* fill hostent */
105   s_hostent_addr = addr;
106   s_phostent_addr[0] = &s_hostent_addr;
107   s_phostent_addr[1] = NULL;
108   s_hostent.h_name = (char*)name;
109   s_hostent.h_aliases = &s_aliases;
110   s_hostent.h_addrtype = AF_INET;
111   s_hostent.h_length = sizeof(ip_addr_t);
112   s_hostent.h_addr_list = (char**)&s_phostent_addr;
113 
114 #if DNS_DEBUG
115   /* dump hostent */
116   LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_name           == %s\n", s_hostent.h_name));
117   LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases        == %p\n", s_hostent.h_aliases));
118   if (s_hostent.h_aliases != NULL) {
119     u8_t idx;
120     for ( idx=0; s_hostent.h_aliases[idx]; idx++) {
121       LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases[%i]->   == %p\n", idx, s_hostent.h_aliases[idx]));
122       LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases[%i]->   == %s\n", idx, s_hostent.h_aliases[idx]));
123     }
124   }
125   LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addrtype       == %d\n", s_hostent.h_addrtype));
126   LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_length         == %d\n", s_hostent.h_length));
127   LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list      == %p\n", s_hostent.h_addr_list));
128   if (s_hostent.h_addr_list != NULL) {
129     u8_t idx;
130     for ( idx=0; s_hostent.h_addr_list[idx]; idx++) {
131       LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]   == %p\n", idx, s_hostent.h_addr_list[idx]));
132       LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]-> == %s\n", idx, ip_ntoa((ip_addr_t*)s_hostent.h_addr_list[idx])));
133     }
134   }
135 #endif /* DNS_DEBUG */
136 
137 #if LWIP_DNS_API_HOSTENT_STORAGE
138   /* this function should return the "per-thread" hostent after copy from s_hostent */
139   return sys_thread_hostent(&s_hostent);
140 #else
141   return &s_hostent;
142 #endif /* LWIP_DNS_API_HOSTENT_STORAGE */
143 }
144 
145 /**
146  * Thread-safe variant of lwip_gethostbyname: instead of using a static
147  * buffer, this function takes buffer and errno pointers as arguments
148  * and uses these for the result.
149  *
150  * @param name the hostname to resolve
151  * @param ret pre-allocated struct where to store the result
152  * @param buf pre-allocated buffer where to store additional data
153  * @param buflen the size of buf
154  * @param result pointer to a hostent pointer that is set to ret on success
155  *               and set to zero on error
156  * @param h_errnop pointer to an int where to store errors (instead of modifying
157  *                 the global h_errno)
158  * @return 0 on success, non-zero on error, additional error information
159  *         is stored in *h_errnop instead of h_errno to be thread-safe
160  */
161 int
lwip_gethostbyname_r(const char * name,struct hostent * ret,char * buf,size_t buflen,struct hostent ** result,int * h_errnop)162 lwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf,
163                 size_t buflen, struct hostent **result, int *h_errnop)
164 {
165   err_t err;
166   struct gethostbyname_r_helper *h;
167   char *hostname;
168   size_t namelen;
169   int lh_errno;
170 
171   if (h_errnop == NULL) {
172     /* ensure h_errnop is never NULL */
173     h_errnop = &lh_errno;
174   }
175 
176   if (result == NULL) {
177     /* not all arguments given */
178     *h_errnop = EINVAL;
179     return -1;
180   }
181   /* first thing to do: set *result to nothing */
182   *result = NULL;
183   if ((name == NULL) || (ret == NULL) || (buf == 0)) {
184     /* not all arguments given */
185     *h_errnop = EINVAL;
186     return -1;
187   }
188 
189   namelen = strlen(name);
190   if (buflen < (sizeof(struct gethostbyname_r_helper) + namelen + 1 + (MEM_ALIGNMENT - 1))) {
191     /* buf can't hold the data needed + a copy of name */
192     *h_errnop = ERANGE;
193     return -1;
194   }
195 
196   h = (struct gethostbyname_r_helper*)LWIP_MEM_ALIGN(buf);
197   hostname = ((char*)h) + sizeof(struct gethostbyname_r_helper);
198 
199   /* query host IP address */
200   err = netconn_gethostbyname(name, &(h->addr));
201   if (err != ERR_OK) {
202     LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err));
203     *h_errnop = ENSRNOTFOUND;
204     return -1;
205   }
206 
207   /* copy the hostname into buf */
208   MEMCPY(hostname, name, namelen);
209   hostname[namelen] = 0;
210 
211   /* fill hostent */
212   h->addrs = &(h->addr);
213   h->aliases = NULL;
214   ret->h_name = (char*)hostname;
215   ret->h_aliases = &(h->aliases);
216   ret->h_addrtype = AF_INET;
217   ret->h_length = sizeof(ip_addr_t);
218   ret->h_addr_list = (char**)&(h->addrs);
219 
220   /* set result != NULL */
221   *result = ret;
222 
223   /* return success */
224   return 0;
225 }
226 
227 /**
228  * Frees one or more addrinfo structures returned by getaddrinfo(), along with
229  * any additional storage associated with those structures. If the ai_next field
230  * of the structure is not null, the entire list of structures is freed.
231  *
232  * @param ai struct addrinfo to free
233  */
234 void
lwip_freeaddrinfo(struct addrinfo * ai)235 lwip_freeaddrinfo(struct addrinfo *ai)
236 {
237   struct addrinfo *next;
238 
239   while (ai != NULL) {
240     next = ai->ai_next;
241     memp_free(MEMP_NETDB, ai);
242     ai = next;
243   }
244 }
245 
246 /**
247  * Translates the name of a service location (for example, a host name) and/or
248  * a service name and returns a set of socket addresses and associated
249  * information to be used in creating a socket with which to address the
250  * specified service.
251  * Memory for the result is allocated internally and must be freed by calling
252  * lwip_freeaddrinfo()!
253  *
254  * Due to a limitation in dns_gethostbyname, only the first address of a
255  * host is returned.
256  * Also, service names are not supported (only port numbers)!
257  *
258  * @param nodename descriptive name or address string of the host
259  *                 (may be NULL -> local address)
260  * @param servname port number as string of NULL
261  * @param hints structure containing input values that set socktype and protocol
262  * @param res pointer to a pointer where to store the result (set to NULL on failure)
263  * @return 0 on success, non-zero on failure
264  */
265 int
lwip_getaddrinfo(const char * nodename,const char * servname,const struct addrinfo * hints,struct addrinfo ** res)266 lwip_getaddrinfo(const char *nodename, const char *servname,
267        const struct addrinfo *hints, struct addrinfo **res)
268 {
269   err_t err;
270   ip_addr_t addr;
271   struct addrinfo *ai;
272   struct sockaddr_in *sa = NULL;
273   int port_nr = 0;
274   size_t total_size;
275   size_t namelen = 0;
276 
277   if (res == NULL) {
278     return EAI_FAIL;
279   }
280   *res = NULL;
281   if ((nodename == NULL) && (servname == NULL)) {
282     return EAI_NONAME;
283   }
284 
285   if (servname != NULL) {
286     /* service name specified: convert to port number
287      * @todo?: currently, only ASCII integers (port numbers) are supported! */
288     port_nr = atoi(servname);
289     if ((port_nr <= 0) || (port_nr > 0xffff)) {
290       return EAI_SERVICE;
291     }
292   }
293 
294   if (nodename != NULL) {
295     /* service location specified, try to resolve */
296     err = netconn_gethostbyname(nodename, &addr);
297     if (err != ERR_OK) {
298       return EAI_FAIL;
299     }
300   } else {
301     /* service location specified, use loopback address */
302     ip_addr_set_loopback(&addr);
303   }
304 
305   total_size = sizeof(struct addrinfo) + sizeof(struct sockaddr_in);
306   if (nodename != NULL) {
307     namelen = strlen(nodename);
308     LWIP_ASSERT("namelen is too long", (namelen + 1) <= (mem_size_t)-1);
309     total_size += namelen + 1;
310   }
311   /* If this fails, please report to lwip-devel! :-) */
312   LWIP_ASSERT("total_size <= NETDB_ELEM_SIZE: please report this!",
313     total_size <= NETDB_ELEM_SIZE);
314   ai = (struct addrinfo *)memp_malloc(MEMP_NETDB);
315   if (ai == NULL) {
316     goto memerr;
317   }
318   memset(ai, 0, total_size);
319   sa = (struct sockaddr_in*)((u8_t*)ai + sizeof(struct addrinfo));
320   /* set up sockaddr */
321   inet_addr_from_ipaddr(&sa->sin_addr, &addr);
322   sa->sin_family = AF_INET;
323   sa->sin_len = sizeof(struct sockaddr_in);
324   sa->sin_port = htons((u16_t)port_nr);
325 
326   /* set up addrinfo */
327   ai->ai_family = AF_INET;
328   if (hints != NULL) {
329     /* copy socktype & protocol from hints if specified */
330     ai->ai_socktype = hints->ai_socktype;
331     ai->ai_protocol = hints->ai_protocol;
332   }
333   if (nodename != NULL) {
334     /* copy nodename to canonname if specified */
335     ai->ai_canonname = ((char*)ai + sizeof(struct addrinfo) + sizeof(struct sockaddr_in));
336     MEMCPY(ai->ai_canonname, nodename, namelen);
337     ai->ai_canonname[namelen] = 0;
338   }
339   ai->ai_addrlen = sizeof(struct sockaddr_in);
340   ai->ai_addr = (struct sockaddr*)sa;
341 
342   *res = ai;
343 
344   return 0;
345 memerr:
346   if (ai != NULL) {
347     memp_free(MEMP_NETDB, ai);
348   }
349   return EAI_MEMORY;
350 }
351 
352 #endif /* LWIP_DNS && LWIP_SOCKET */
353