| /* Hosts file parser in nss_files module. |
| Copyright (C) 1996-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <assert.h> |
| #include <netinet/in.h> |
| #include <arpa/inet.h> |
| #include <arpa/nameser.h> |
| #include <netdb.h> |
| #include <resolv/resolv-internal.h> |
| #include <scratch_buffer.h> |
| #include <alloc_buffer.h> |
| |
| |
| /* Get implementation for some internal functions. */ |
| #include "../resolv/mapv4v6addr.h" |
| #include "../resolv/res_hconf.h" |
| |
| |
| #define ENTNAME hostent |
| #define DATABASE "hosts" |
| #define NEED_H_ERRNO |
| |
| #define EXTRA_ARGS , af, flags |
| #define EXTRA_ARGS_DECL , int af, int flags |
| |
| #define ENTDATA hostent_data |
| struct hostent_data |
| { |
| unsigned char host_addr[16]; /* IPv4 or IPv6 address. */ |
| char *h_addr_ptrs[2]; /* Points to that and null terminator. */ |
| }; |
| |
| #define TRAILING_LIST_MEMBER h_aliases |
| #define TRAILING_LIST_SEPARATOR_P isspace |
| #include "files-parse.c" |
| LINE_PARSER |
| ("#", |
| { |
| char *addr; |
| |
| STRING_FIELD (addr, isspace, 1); |
| |
| /* Parse address. */ |
| if (inet_pton (af == AF_UNSPEC ? AF_INET : af, addr, entdata->host_addr) |
| > 0) |
| af = af == AF_UNSPEC ? AF_INET : af; |
| else |
| { |
| if (af == AF_INET6 && (flags & AI_V4MAPPED) != 0 |
| && inet_pton (AF_INET, addr, entdata->host_addr) > 0) |
| map_v4v6_address ((char *) entdata->host_addr, |
| (char *) entdata->host_addr); |
| else if (af == AF_INET |
| && inet_pton (AF_INET6, addr, entdata->host_addr) > 0) |
| { |
| if (IN6_IS_ADDR_V4MAPPED (entdata->host_addr)) |
| memcpy (entdata->host_addr, entdata->host_addr + 12, INADDRSZ); |
| else if (IN6_IS_ADDR_LOOPBACK (entdata->host_addr)) |
| { |
| in_addr_t localhost = htonl (INADDR_LOOPBACK); |
| memcpy (entdata->host_addr, &localhost, sizeof (localhost)); |
| } |
| else |
| /* Illegal address: ignore line. */ |
| return 0; |
| } |
| else if (af == AF_UNSPEC |
| && inet_pton (AF_INET6, addr, entdata->host_addr) > 0) |
| af = AF_INET6; |
| else |
| /* Illegal address: ignore line. */ |
| return 0; |
| } |
| |
| /* We always return entries of the requested form. */ |
| result->h_addrtype = af; |
| result->h_length = af == AF_INET ? INADDRSZ : IN6ADDRSZ; |
| |
| /* Store a pointer to the address in the expected form. */ |
| entdata->h_addr_ptrs[0] = (char *) entdata->host_addr; |
| entdata->h_addr_ptrs[1] = NULL; |
| result->h_addr_list = entdata->h_addr_ptrs; |
| |
| STRING_FIELD (result->h_name, isspace, 1); |
| }) |
| |
| #define EXTRA_ARGS_VALUE \ |
| , (res_use_inet6 () ? AF_INET6 : AF_INET), \ |
| (res_use_inet6 () ? AI_V4MAPPED : 0) |
| #include "files-XXX.c" |
| #undef EXTRA_ARGS_VALUE |
| |
| /* We only need to consider IPv4 mapped addresses if the input to the |
| gethostbyaddr() function is an IPv6 address. */ |
| #define EXTRA_ARGS_VALUE \ |
| , af, (len == IN6ADDRSZ ? AI_V4MAPPED : 0) |
| DB_LOOKUP (hostbyaddr, ,,, |
| { |
| if (result->h_length == (int) len |
| && ! memcmp (addr, result->h_addr_list[0], len)) |
| break; |
| }, const void *addr, socklen_t len, int af) |
| #undef EXTRA_ARGS_VALUE |
| |
| /* Type of the address and alias arrays. */ |
| #define DYNARRAY_STRUCT array |
| #define DYNARRAY_ELEMENT char * |
| #define DYNARRAY_PREFIX array_ |
| #include <malloc/dynarray-skeleton.c> |
| |
| static enum nss_status |
| gethostbyname3_multi (FILE * stream, const char *name, int af, |
| struct hostent *result, char *buffer, size_t buflen, |
| int *errnop, int *herrnop, int flags) |
| { |
| assert (af == AF_INET || af == AF_INET6); |
| |
| /* We have to get all host entries from the file. */ |
| struct scratch_buffer tmp_buffer; |
| scratch_buffer_init (&tmp_buffer); |
| struct hostent tmp_result_buf; |
| struct array addresses; |
| array_init (&addresses); |
| struct array aliases; |
| array_init (&aliases); |
| enum nss_status status; |
| |
| /* Preserve the addresses and aliases encountered so far. */ |
| for (size_t i = 0; result->h_addr_list[i] != NULL; ++i) |
| array_add (&addresses, result->h_addr_list[i]); |
| for (size_t i = 0; result->h_aliases[i] != NULL; ++i) |
| array_add (&aliases, result->h_aliases[i]); |
| |
| /* The output buffer re-uses now-unused space at the end of the |
| buffer, starting with the aliases array. It comes last in the |
| data produced by internal_getent. (The alias names themselves |
| are still located in the line read in internal_getent, which is |
| stored at the beginning of the buffer.) */ |
| struct alloc_buffer outbuf; |
| { |
| char *bufferend = (char *) result->h_aliases; |
| outbuf = alloc_buffer_create (bufferend, buffer + buflen - bufferend); |
| } |
| |
| while (true) |
| { |
| status = internal_getent (stream, &tmp_result_buf, tmp_buffer.data, |
| tmp_buffer.length, errnop, herrnop, af, |
| flags); |
| /* Enlarge the buffer if necessary. */ |
| if (status == NSS_STATUS_TRYAGAIN && *herrnop == NETDB_INTERNAL |
| && *errnop == ERANGE) |
| { |
| if (!scratch_buffer_grow (&tmp_buffer)) |
| { |
| *errnop = ENOMEM; |
| /* *herrnop and status already have the right value. */ |
| break; |
| } |
| /* Loop around and retry with a larger buffer. */ |
| } |
| else if (status == NSS_STATUS_SUCCESS) |
| { |
| /* A line was read. Check that it matches the search |
| criteria. */ |
| |
| int matches = 1; |
| struct hostent *old_result = result; |
| result = &tmp_result_buf; |
| /* The following piece is a bit clumsy but we want to use |
| the `LOOKUP_NAME_CASE' value. The optimizer should do |
| its job. */ |
| do |
| { |
| LOOKUP_NAME_CASE (h_name, h_aliases) |
| result = old_result; |
| } |
| while ((matches = 0)); |
| |
| /* If the line matches, we need to copy the addresses and |
| aliases, so that we can reuse tmp_buffer for the next |
| line. */ |
| if (matches) |
| { |
| /* Record the addresses. */ |
| for (size_t i = 0; tmp_result_buf.h_addr_list[i] != NULL; ++i) |
| { |
| /* Allocate the target space in the output buffer, |
| depending on the address family. */ |
| void *target; |
| if (af == AF_INET) |
| { |
| assert (tmp_result_buf.h_length == 4); |
| target = alloc_buffer_alloc (&outbuf, struct in_addr); |
| } |
| else if (af == AF_INET6) |
| { |
| assert (tmp_result_buf.h_length == 16); |
| target = alloc_buffer_alloc (&outbuf, struct in6_addr); |
| } |
| else |
| __builtin_unreachable (); |
| |
| if (target == NULL) |
| { |
| /* Request a larger output buffer. */ |
| *errnop = ERANGE; |
| *herrnop = NETDB_INTERNAL; |
| status = NSS_STATUS_TRYAGAIN; |
| break; |
| } |
| memcpy (target, tmp_result_buf.h_addr_list[i], |
| tmp_result_buf.h_length); |
| array_add (&addresses, target); |
| } |
| |
| /* Record the aliases. */ |
| for (size_t i = 0; tmp_result_buf.h_aliases[i] != NULL; ++i) |
| { |
| char *alias = tmp_result_buf.h_aliases[i]; |
| array_add (&aliases, |
| alloc_buffer_copy_string (&outbuf, alias)); |
| } |
| |
| /* If the real name is different add, it also to the |
| aliases. This means that there is a duplication in |
| the alias list but this is really the user's |
| problem. */ |
| { |
| char *new_name = tmp_result_buf.h_name; |
| if (strcmp (old_result->h_name, new_name) != 0) |
| array_add (&aliases, |
| alloc_buffer_copy_string (&outbuf, new_name)); |
| } |
| |
| /* Report memory allocation failures during the |
| expansion of the temporary arrays. */ |
| if (array_has_failed (&addresses) || array_has_failed (&aliases)) |
| { |
| *errnop = ENOMEM; |
| *herrnop = NETDB_INTERNAL; |
| status = NSS_STATUS_UNAVAIL; |
| break; |
| } |
| |
| /* Request a larger output buffer if we ran out of room. */ |
| if (alloc_buffer_has_failed (&outbuf)) |
| { |
| *errnop = ERANGE; |
| *herrnop = NETDB_INTERNAL; |
| status = NSS_STATUS_TRYAGAIN; |
| break; |
| } |
| |
| result = old_result; |
| } /* If match was found. */ |
| |
| /* If no match is found, loop around and fetch another |
| line. */ |
| |
| } /* status == NSS_STATUS_SUCCESS. */ |
| else |
| /* internal_getent returned an error. */ |
| break; |
| } /* while (true) */ |
| |
| /* Propagate the NSS_STATUS_TRYAGAIN error to the caller. It means |
| that we may not have loaded the complete result. |
| NSS_STATUS_NOTFOUND, however, means that we reached the end of |
| the file successfully. */ |
| if (status != NSS_STATUS_TRYAGAIN) |
| status = NSS_STATUS_SUCCESS; |
| |
| if (status == NSS_STATUS_SUCCESS) |
| { |
| /* Copy the address and alias arrays into the output buffer and |
| add NULL terminators. The pointed-to elements were directly |
| written into the output buffer above and do not need to be |
| copied again. */ |
| size_t addresses_count = array_size (&addresses); |
| size_t aliases_count = array_size (&aliases); |
| char **out_addresses = alloc_buffer_alloc_array |
| (&outbuf, char *, addresses_count + 1); |
| char **out_aliases = alloc_buffer_alloc_array |
| (&outbuf, char *, aliases_count + 1); |
| if (out_addresses == NULL || out_aliases == NULL) |
| { |
| /* The output buffer is not large enough. */ |
| *errnop = ERANGE; |
| *herrnop = NETDB_INTERNAL; |
| status = NSS_STATUS_TRYAGAIN; |
| /* Fall through to function exit. */ |
| } |
| else |
| { |
| /* Everything is allocated in place. Make the copies and |
| adjust the array pointers. */ |
| memcpy (out_addresses, array_begin (&addresses), |
| addresses_count * sizeof (char *)); |
| out_addresses[addresses_count] = NULL; |
| memcpy (out_aliases, array_begin (&aliases), |
| aliases_count * sizeof (char *)); |
| out_aliases[aliases_count] = NULL; |
| |
| result->h_addr_list = out_addresses; |
| result->h_aliases = out_aliases; |
| |
| status = NSS_STATUS_SUCCESS; |
| } |
| } |
| |
| scratch_buffer_free (&tmp_buffer); |
| array_free (&addresses); |
| array_free (&aliases); |
| return status; |
| } |
| |
| enum nss_status |
| _nss_files_gethostbyname3_r (const char *name, int af, struct hostent *result, |
| char *buffer, size_t buflen, int *errnop, |
| int *herrnop, int32_t *ttlp, char **canonp) |
| { |
| FILE *stream = NULL; |
| uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct hostent_data); |
| buffer += pad; |
| buflen = buflen > pad ? buflen - pad : 0; |
| |
| /* Open file. */ |
| enum nss_status status = internal_setent (&stream); |
| |
| if (status == NSS_STATUS_SUCCESS) |
| { |
| /* XXX Is using _res to determine whether we want to convert IPv4 |
| addresses to IPv6 addresses really the right thing to do? */ |
| int flags = (res_use_inet6 () ? AI_V4MAPPED : 0); |
| |
| while ((status = internal_getent (stream, result, buffer, buflen, errnop, |
| herrnop, af, flags)) |
| == NSS_STATUS_SUCCESS) |
| { |
| LOOKUP_NAME_CASE (h_name, h_aliases) |
| } |
| |
| if (status == NSS_STATUS_SUCCESS |
| && _res_hconf.flags & HCONF_FLAG_MULTI) |
| status = gethostbyname3_multi |
| (stream, name, af, result, buffer, buflen, errnop, herrnop, flags); |
| |
| internal_endent (&stream); |
| } |
| |
| if (canonp && status == NSS_STATUS_SUCCESS) |
| *canonp = result->h_name; |
| |
| return status; |
| } |
| |
| enum nss_status |
| _nss_files_gethostbyname_r (const char *name, struct hostent *result, |
| char *buffer, size_t buflen, int *errnop, |
| int *herrnop) |
| { |
| int af = (res_use_inet6 () ? AF_INET6 : AF_INET); |
| |
| return _nss_files_gethostbyname3_r (name, af, result, buffer, buflen, |
| errnop, herrnop, NULL, NULL); |
| } |
| |
| enum nss_status |
| _nss_files_gethostbyname2_r (const char *name, int af, struct hostent *result, |
| char *buffer, size_t buflen, int *errnop, |
| int *herrnop) |
| { |
| return _nss_files_gethostbyname3_r (name, af, result, buffer, buflen, |
| errnop, herrnop, NULL, NULL); |
| } |
| |
| enum nss_status |
| _nss_files_gethostbyname4_r (const char *name, struct gaih_addrtuple **pat, |
| char *buffer, size_t buflen, int *errnop, |
| int *herrnop, int32_t *ttlp) |
| { |
| FILE *stream = NULL; |
| |
| /* Open file. */ |
| enum nss_status status = internal_setent (&stream); |
| |
| if (status == NSS_STATUS_SUCCESS) |
| { |
| bool any = false; |
| bool got_canon = false; |
| while (1) |
| { |
| /* Align the buffer for the next record. */ |
| uintptr_t pad = (-(uintptr_t) buffer |
| % __alignof__ (struct hostent_data)); |
| buffer += pad; |
| buflen = buflen > pad ? buflen - pad : 0; |
| |
| struct hostent result; |
| status = internal_getent (stream, &result, buffer, buflen, errnop, |
| herrnop, AF_UNSPEC, 0); |
| if (status != NSS_STATUS_SUCCESS) |
| break; |
| |
| int naliases = 0; |
| if (__strcasecmp (name, result.h_name) != 0) |
| { |
| for (; result.h_aliases[naliases] != NULL; ++naliases) |
| if (! __strcasecmp (name, result.h_aliases[naliases])) |
| break; |
| if (result.h_aliases[naliases] == NULL) |
| continue; |
| |
| /* We know this alias exist. Count it. */ |
| ++naliases; |
| } |
| |
| /* Determine how much memory has been used so far. */ |
| // XXX It is not necessary to preserve the aliases array |
| while (result.h_aliases[naliases] != NULL) |
| ++naliases; |
| char *bufferend = (char *) &result.h_aliases[naliases + 1]; |
| assert (buflen >= bufferend - buffer); |
| buflen -= bufferend - buffer; |
| buffer = bufferend; |
| |
| /* We found something. */ |
| any = true; |
| |
| /* Create the record the caller expects. There is only one |
| address. */ |
| assert (result.h_addr_list[1] == NULL); |
| if (*pat == NULL) |
| { |
| uintptr_t pad = (-(uintptr_t) buffer |
| % __alignof__ (struct gaih_addrtuple)); |
| buffer += pad; |
| buflen = buflen > pad ? buflen - pad : 0; |
| |
| if (__builtin_expect (buflen < sizeof (struct gaih_addrtuple), |
| 0)) |
| { |
| *errnop = ERANGE; |
| *herrnop = NETDB_INTERNAL; |
| status = NSS_STATUS_TRYAGAIN; |
| break; |
| } |
| |
| *pat = (struct gaih_addrtuple *) buffer; |
| buffer += sizeof (struct gaih_addrtuple); |
| buflen -= sizeof (struct gaih_addrtuple); |
| } |
| |
| (*pat)->next = NULL; |
| (*pat)->name = got_canon ? NULL : result.h_name; |
| got_canon = true; |
| (*pat)->family = result.h_addrtype; |
| memcpy ((*pat)->addr, result.h_addr_list[0], result.h_length); |
| (*pat)->scopeid = 0; |
| |
| pat = &((*pat)->next); |
| |
| /* If we only look for the first matching entry we are done. */ |
| if ((_res_hconf.flags & HCONF_FLAG_MULTI) == 0) |
| break; |
| } |
| |
| /* If we have to look for multiple records and found one, this |
| is a success. */ |
| if (status == NSS_STATUS_NOTFOUND && any) |
| { |
| assert ((_res_hconf.flags & HCONF_FLAG_MULTI) != 0); |
| status = NSS_STATUS_SUCCESS; |
| } |
| |
| internal_endent (&stream); |
| } |
| else if (status == NSS_STATUS_TRYAGAIN) |
| { |
| *errnop = errno; |
| *herrnop = TRY_AGAIN; |
| } |
| else |
| { |
| *errnop = errno; |
| *herrnop = NO_DATA; |
| } |
| |
| return status; |
| } |