1 /* Copyright (C) 1996-2020 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@suse.de>, 1996.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
26 #include <libc-lock.h>
27 #include <rpcsvc/yp.h>
28 #include <rpcsvc/ypclnt.h>
32 #define ENTNAME hostent
33 #define DATABASE "hosts"
36 #define EXTRA_ARGS , af
37 #define EXTRA_ARGS_DECL , int af
39 #define ENTDATA hostent_data
42 unsigned char host_addr[16]; /* IPv4 or IPv6 address. */
43 char *h_addr_ptrs[2]; /* Points to that and null terminator. */
46 #define TRAILING_LIST_MEMBER h_aliases
47 #define TRAILING_LIST_SEPARATOR_P isspace
48 #include <nss/nss_files/files-parse.c>
54 STRING_FIELD (addr, isspace, 1);
56 assert (af == AF_INET || af == AF_INET6 || af == AF_UNSPEC);
59 if (af != AF_INET6 && inet_pton (AF_INET, addr, entdata->host_addr) > 0)
61 result->h_addrtype = AF_INET;
62 result->h_length = INADDRSZ;
64 else if (af != AF_INET
65 && inet_pton (AF_INET6, addr, entdata->host_addr) > 0)
67 result->h_addrtype = AF_INET6;
68 result->h_length = IN6ADDRSZ;
71 /* Illegal address: ignore line. */
74 /* Store a pointer to the address in the expected form. */
75 entdata->h_addr_ptrs[0] = (char *) entdata->host_addr;
76 entdata->h_addr_ptrs[1] = NULL;
77 result->h_addr_list = entdata->h_addr_ptrs;
79 STRING_FIELD (result->h_name, isspace, 1);
83 __libc_lock_define_initialized (static, lock)
85 static bool_t new_start = 1;
86 static char *oldkey = NULL;
87 static int oldkeylen = 0;
90 _nss_nis_sethostent (int stayopen)
92 return _nss_nis_endhostent ();
96 _nss_nis_endhostent (void)
98 __libc_lock_lock (lock);
108 __libc_lock_unlock (lock);
110 return NSS_STATUS_SUCCESS;
112 libnss_nis_hidden_def (_nss_nis_endhostent)
114 /* The calling function always need to get a lock first. */
115 static enum nss_status
116 internal_nis_gethostent_r (struct hostent *host, char *buffer,
117 size_t buflen, int *errnop, int *h_errnop,
121 if (__glibc_unlikely (yp_get_default_domain (&domain)))
122 return NSS_STATUS_UNAVAIL;
124 uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
127 struct parser_data *data = (void *) buffer;
128 if (__glibc_unlikely (buflen < sizeof *data + 1 + pad))
131 *h_errnop = NETDB_INTERNAL;
132 return NSS_STATUS_TRYAGAIN;
136 /* Get the next entry until we found a correct one. */
137 const size_t linebuflen = buffer + buflen - data->linebuffer;
147 yperr = yp_first (domain, "hosts.byname", &outkey, &keylen, &result,
150 yperr = yp_next (domain, "hosts.byname", oldkey, oldkeylen, &outkey,
151 &keylen, &result, &len);
153 if (__glibc_unlikely (yperr != YPERR_SUCCESS))
155 enum nss_status retval = yperr2nss (yperr);
159 case NSS_STATUS_TRYAGAIN:
161 *h_errnop = TRY_AGAIN;
163 case NSS_STATUS_NOTFOUND:
164 *h_errnop = HOST_NOT_FOUND;
167 *h_errnop = NO_RECOVERY;
173 if (__glibc_unlikely ((size_t) (len + 1) > linebuflen))
176 *h_errnop = NETDB_INTERNAL;
178 return NSS_STATUS_TRYAGAIN;
181 char *p = strncpy (data->linebuffer, result, len);
182 data->linebuffer[len] = '\0';
187 parse_res = parse_line (p, host, data, buflen, errnop, af);
188 if (__glibc_unlikely (parse_res == -1))
191 *h_errnop = NETDB_INTERNAL;
193 return NSS_STATUS_TRYAGAIN;
202 *h_errnop = NETDB_SUCCESS;
203 return NSS_STATUS_SUCCESS;
208 _nss_nis_gethostent_r (struct hostent *host, char *buffer, size_t buflen,
209 int *errnop, int *h_errnop)
211 enum nss_status status;
213 __libc_lock_lock (lock);
215 status = internal_nis_gethostent_r (host, buffer, buflen, errnop, h_errnop,
218 __libc_lock_unlock (lock);
224 static enum nss_status
225 internal_gethostbyname2_r (const char *name, int af, struct hostent *host,
226 char *buffer, size_t buflen, int *errnop,
229 uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
232 struct parser_data *data = (void *) buffer;
237 return NSS_STATUS_UNAVAIL;
241 if (yp_get_default_domain (&domain))
242 return NSS_STATUS_UNAVAIL;
244 if (buflen < sizeof *data + 1 + pad)
246 *h_errnop = NETDB_INTERNAL;
248 return NSS_STATUS_TRYAGAIN;
252 /* Convert name to lowercase. */
253 size_t namlen = strlen (name);
254 /* Limit name length to the maximum size of an RPC packet. */
255 if (namlen > UDPMSGSIZE)
258 return NSS_STATUS_UNAVAIL;
261 char name2[namlen + 1];
264 for (i = 0; i < namlen; ++i)
265 name2[i] = tolower (name[i]);
270 int yperr = yp_match (domain, "hosts.byname", name2, namlen, &result, &len);
272 if (__glibc_unlikely (yperr != YPERR_SUCCESS))
274 enum nss_status retval = yperr2nss (yperr);
276 if (retval == NSS_STATUS_TRYAGAIN)
278 *h_errnop = TRY_AGAIN;
281 if (retval == NSS_STATUS_NOTFOUND)
282 *h_errnop = HOST_NOT_FOUND;
286 const size_t linebuflen = buffer + buflen - data->linebuffer;
287 if (__glibc_unlikely ((size_t) (len + 1) > linebuflen))
290 *h_errnop = NETDB_INTERNAL;
292 return NSS_STATUS_TRYAGAIN;
295 char *p = strncpy (data->linebuffer, result, len);
296 data->linebuffer[len] = '\0';
301 int parse_res = parse_line (p, host, data, buflen, errnop, af);
303 if (__glibc_unlikely (parse_res < 1 || host->h_addrtype != af))
307 *h_errnop = NETDB_INTERNAL;
308 return NSS_STATUS_TRYAGAIN;
312 *h_errnop = HOST_NOT_FOUND;
313 return NSS_STATUS_NOTFOUND;
317 *h_errnop = NETDB_SUCCESS;
318 return NSS_STATUS_SUCCESS;
323 _nss_nis_gethostbyname2_r (const char *name, int af, struct hostent *host,
324 char *buffer, size_t buflen, int *errnop,
327 if (af != AF_INET && af != AF_INET6)
329 *h_errnop = HOST_NOT_FOUND;
330 return NSS_STATUS_NOTFOUND;
333 return internal_gethostbyname2_r (name, af, host, buffer, buflen, errnop,
339 _nss_nis_gethostbyname_r (const char *name, struct hostent *host, char *buffer,
340 size_t buflen, int *errnop, int *h_errnop)
342 return internal_gethostbyname2_r (name, AF_INET, host, buffer, buflen,
348 _nss_nis_gethostbyaddr_r (const void *addr, socklen_t addrlen, int af,
349 struct hostent *host, char *buffer, size_t buflen,
350 int *errnop, int *h_errnop)
353 if (__glibc_unlikely (yp_get_default_domain (&domain)))
354 return NSS_STATUS_UNAVAIL;
356 uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
359 struct parser_data *data = (void *) buffer;
360 if (__glibc_unlikely (buflen < sizeof *data + 1 + pad))
363 *h_errnop = NETDB_INTERNAL;
364 return NSS_STATUS_TRYAGAIN;
368 char *buf = inet_ntoa (*(const struct in_addr *) addr);
372 int yperr = yp_match (domain, "hosts.byaddr", buf, strlen (buf), &result,
375 if (__glibc_unlikely (yperr != YPERR_SUCCESS))
377 enum nss_status retval = yperr2nss (yperr);
379 if (retval == NSS_STATUS_TRYAGAIN)
381 *h_errnop = TRY_AGAIN;
384 else if (retval == NSS_STATUS_NOTFOUND)
385 *h_errnop = HOST_NOT_FOUND;
390 const size_t linebuflen = buffer + buflen - data->linebuffer;
391 if (__glibc_unlikely ((size_t) (len + 1) > linebuflen))
395 *h_errnop = NETDB_INTERNAL;
396 return NSS_STATUS_TRYAGAIN;
399 char *p = strncpy (data->linebuffer, result, len);
400 data->linebuffer[len] = '\0';
405 int parse_res = parse_line (p, host, data, buflen, errnop, af);
406 if (__glibc_unlikely (parse_res < 1))
410 *h_errnop = NETDB_INTERNAL;
411 return NSS_STATUS_TRYAGAIN;
415 *h_errnop = HOST_NOT_FOUND;
416 return NSS_STATUS_NOTFOUND;
420 *h_errnop = NETDB_SUCCESS;
421 return NSS_STATUS_SUCCESS;
426 _nss_nis_gethostbyname4_r (const char *name, struct gaih_addrtuple **pat,
427 char *buffer, size_t buflen, int *errnop,
428 int *herrnop, int32_t *ttlp)
431 if (yp_get_default_domain (&domain))
434 return NSS_STATUS_UNAVAIL;
437 /* Convert name to lowercase. */
438 size_t namlen = strlen (name);
439 /* Limit name length to the maximum size of an RPC packet. */
440 if (namlen > UDPMSGSIZE)
443 return NSS_STATUS_UNAVAIL;
446 char name2[namlen + 1];
449 for (i = 0; i < namlen; ++i)
450 name2[i] = tolower (name[i]);
455 int yperr = yp_match (domain, "hosts.byname", name2, namlen, &result, &len);
457 if (__glibc_unlikely (yperr != YPERR_SUCCESS))
459 enum nss_status retval = yperr2nss (yperr);
461 if (retval == NSS_STATUS_TRYAGAIN)
463 *herrnop = TRY_AGAIN;
466 if (retval == NSS_STATUS_NOTFOUND)
467 *herrnop = HOST_NOT_FOUND;
473 uintptr_t pad = (-(uintptr_t) buffer
474 % __alignof__ (struct gaih_addrtuple));
476 buflen = buflen > pad ? buflen - pad : 0;
478 if (__glibc_unlikely (buflen < sizeof (struct gaih_addrtuple)))
483 *herrnop = NETDB_INTERNAL;
484 return NSS_STATUS_TRYAGAIN;
487 *pat = (struct gaih_addrtuple *) buffer;
488 buffer += sizeof (struct gaih_addrtuple);
489 buflen -= sizeof (struct gaih_addrtuple);
492 uintptr_t pad = -(uintptr_t) buffer % __alignof__ (struct parser_data);
495 struct parser_data *data = (void *) buffer;
497 if (__glibc_unlikely (buflen < sizeof *data + 1 + pad))
502 int parse_res = parse_line (result, &host, data, buflen, errnop, AF_UNSPEC);
503 if (__glibc_unlikely (parse_res < 1))
507 *herrnop = NETDB_INTERNAL;
508 return NSS_STATUS_TRYAGAIN;
512 *herrnop = HOST_NOT_FOUND;
513 return NSS_STATUS_NOTFOUND;
518 (*pat)->family = host.h_addrtype;
519 memcpy ((*pat)->addr, host.h_addr_list[0], host.h_length);
521 assert (host.h_addr_list[1] == NULL);
523 /* Undo the alignment for parser_data. */
527 size_t h_name_len = strlen (host.h_name) + 1;
528 if (h_name_len >= buflen)
530 (*pat)->name = memcpy (buffer, host.h_name, h_name_len);
534 return NSS_STATUS_SUCCESS;