1 /* Copyright (C) 1996-2014 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 <http://www.gnu.org/licenses/>. */
22 /* The following is an ugly trick to avoid a prototype declaration for
24 #define _nss_nis_endhostent _nss_nis_endhostent_XXX
26 #undef _nss_nis_endhostent
28 #include <netinet/in.h>
29 #include <arpa/inet.h>
31 #include <bits/libc-lock.h>
32 #include <rpcsvc/yp.h>
33 #include <rpcsvc/ypclnt.h>
37 /* Get implementation for some internal functions. */
38 #include <resolv/mapv4v6addr.h>
40 #define ENTNAME hostent
41 #define DATABASE "hosts"
44 #define EXTRA_ARGS , af, flags
45 #define EXTRA_ARGS_DECL , int af, int flags
47 #define ENTDATA hostent_data
50 unsigned char host_addr
[16]; /* IPv4 or IPv6 address. */
51 char *h_addr_ptrs
[2]; /* Points to that and null terminator. */
54 #define TRAILING_LIST_MEMBER h_aliases
55 #define TRAILING_LIST_SEPARATOR_P isspace
56 #include <nss/nss_files/files-parse.c>
62 STRING_FIELD (addr
, isspace
, 1);
64 assert (af
== AF_INET
|| af
== AF_INET6
|| af
== AF_UNSPEC
);
67 if (af
!= AF_INET6
&& inet_pton (AF_INET
, addr
, entdata
->host_addr
) > 0)
69 assert ((flags
& AI_V4MAPPED
) == 0 || af
!= AF_UNSPEC
);
70 if (flags
& AI_V4MAPPED
)
72 map_v4v6_address ((char *) entdata
->host_addr
,
73 (char *) entdata
->host_addr
);
74 result
->h_addrtype
= AF_INET6
;
75 result
->h_length
= IN6ADDRSZ
;
79 result
->h_addrtype
= AF_INET
;
80 result
->h_length
= INADDRSZ
;
83 else if (af
!= AF_INET
84 && inet_pton (AF_INET6
, addr
, entdata
->host_addr
) > 0)
86 result
->h_addrtype
= AF_INET6
;
87 result
->h_length
= IN6ADDRSZ
;
90 /* Illegal address: ignore line. */
93 /* Store a pointer to the address in the expected form. */
94 entdata
->h_addr_ptrs
[0] = (char *) entdata
->host_addr
;
95 entdata
->h_addr_ptrs
[1] = NULL
;
96 result
->h_addr_list
= entdata
->h_addr_ptrs
;
98 STRING_FIELD (result
->h_name
, isspace
, 1);
102 __libc_lock_define_initialized (static, lock
)
104 static bool_t new_start
= 1;
105 static char *oldkey
= NULL
;
106 static int oldkeylen
= 0;
110 _nss_nis_sethostent (int stayopen
)
112 __libc_lock_lock (lock
);
122 __libc_lock_unlock (lock
);
124 return NSS_STATUS_SUCCESS
;
126 /* Make _nss_nis_endhostent an alias of _nss_nis_sethostent. We do this
127 even though the prototypes don't match. The argument of sethostent
128 is used so this makes no difference. */
129 strong_alias (_nss_nis_sethostent
, _nss_nis_endhostent
)
132 /* The calling function always need to get a lock first. */
133 static enum nss_status
134 internal_nis_gethostent_r (struct hostent
*host
, char *buffer
,
135 size_t buflen
, int *errnop
, int *h_errnop
,
139 if (__glibc_unlikely (yp_get_default_domain (&domain
)))
140 return NSS_STATUS_UNAVAIL
;
142 uintptr_t pad
= -(uintptr_t) buffer
% __alignof__ (struct parser_data
);
145 struct parser_data
*data
= (void *) buffer
;
146 if (__glibc_unlikely (buflen
< sizeof *data
+ 1 + pad
))
149 *h_errnop
= NETDB_INTERNAL
;
150 return NSS_STATUS_TRYAGAIN
;
154 /* Get the next entry until we found a correct one. */
155 const size_t linebuflen
= buffer
+ buflen
- data
->linebuffer
;
165 yperr
= yp_first (domain
, "hosts.byname", &outkey
, &keylen
, &result
,
168 yperr
= yp_next (domain
, "hosts.byname", oldkey
, oldkeylen
, &outkey
,
169 &keylen
, &result
, &len
);
171 if (__glibc_unlikely (yperr
!= YPERR_SUCCESS
))
173 enum nss_status retval
= yperr2nss (yperr
);
177 case NSS_STATUS_TRYAGAIN
:
179 *h_errnop
= TRY_AGAIN
;
181 case NSS_STATUS_NOTFOUND
:
182 *h_errnop
= HOST_NOT_FOUND
;
185 *h_errnop
= NO_RECOVERY
;
191 if (__glibc_unlikely ((size_t) (len
+ 1) > linebuflen
))
194 *h_errnop
= NETDB_INTERNAL
;
196 return NSS_STATUS_TRYAGAIN
;
199 char *p
= strncpy (data
->linebuffer
, result
, len
);
200 data
->linebuffer
[len
] = '\0';
205 parse_res
= parse_line (p
, host
, data
, buflen
, errnop
, af
, flags
);
206 if (__glibc_unlikely (parse_res
== -1))
209 *h_errnop
= NETDB_INTERNAL
;
211 return NSS_STATUS_TRYAGAIN
;
220 *h_errnop
= NETDB_SUCCESS
;
221 return NSS_STATUS_SUCCESS
;
226 _nss_nis_gethostent_r (struct hostent
*host
, char *buffer
, size_t buflen
,
227 int *errnop
, int *h_errnop
)
229 enum nss_status status
;
231 __libc_lock_lock (lock
);
233 status
= internal_nis_gethostent_r (host
, buffer
, buflen
, errnop
, h_errnop
,
234 ((_res
.options
& RES_USE_INET6
) ? AF_INET6
: AF_INET
),
235 ((_res
.options
& RES_USE_INET6
) ? AI_V4MAPPED
: 0 ));
237 __libc_lock_unlock (lock
);
243 static enum nss_status
244 internal_gethostbyname2_r (const char *name
, int af
, struct hostent
*host
,
245 char *buffer
, size_t buflen
, int *errnop
,
246 int *h_errnop
, int flags
)
248 uintptr_t pad
= -(uintptr_t) buffer
% __alignof__ (struct parser_data
);
251 struct parser_data
*data
= (void *) buffer
;
256 return NSS_STATUS_UNAVAIL
;
260 if (yp_get_default_domain (&domain
))
261 return NSS_STATUS_UNAVAIL
;
263 if (buflen
< sizeof *data
+ 1 + pad
)
265 *h_errnop
= NETDB_INTERNAL
;
267 return NSS_STATUS_TRYAGAIN
;
271 /* Convert name to lowercase. */
272 size_t namlen
= strlen (name
);
273 char name2
[namlen
+ 1];
276 for (i
= 0; i
< namlen
; ++i
)
277 name2
[i
] = tolower (name
[i
]);
282 int yperr
= yp_match (domain
, "hosts.byname", name2
, namlen
, &result
, &len
);
284 if (__glibc_unlikely (yperr
!= YPERR_SUCCESS
))
286 enum nss_status retval
= yperr2nss (yperr
);
288 if (retval
== NSS_STATUS_TRYAGAIN
)
290 *h_errnop
= TRY_AGAIN
;
293 if (retval
== NSS_STATUS_NOTFOUND
)
294 *h_errnop
= HOST_NOT_FOUND
;
298 const size_t linebuflen
= buffer
+ buflen
- data
->linebuffer
;
299 if (__glibc_unlikely ((size_t) (len
+ 1) > linebuflen
))
302 *h_errnop
= NETDB_INTERNAL
;
304 return NSS_STATUS_TRYAGAIN
;
307 char *p
= strncpy (data
->linebuffer
, result
, len
);
308 data
->linebuffer
[len
] = '\0';
313 int parse_res
= parse_line (p
, host
, data
, buflen
, errnop
, af
, flags
);
315 if (__glibc_unlikely (parse_res
< 1 || host
->h_addrtype
!= af
))
319 *h_errnop
= NETDB_INTERNAL
;
320 return NSS_STATUS_TRYAGAIN
;
324 *h_errnop
= HOST_NOT_FOUND
;
325 return NSS_STATUS_NOTFOUND
;
329 *h_errnop
= NETDB_SUCCESS
;
330 return NSS_STATUS_SUCCESS
;
335 _nss_nis_gethostbyname2_r (const char *name
, int af
, struct hostent
*host
,
336 char *buffer
, size_t buflen
, int *errnop
,
339 if (af
!= AF_INET
&& af
!= AF_INET6
)
341 *h_errnop
= HOST_NOT_FOUND
;
342 return NSS_STATUS_NOTFOUND
;
345 return internal_gethostbyname2_r (name
, af
, host
, buffer
, buflen
, errnop
,
347 ((_res
.options
& RES_USE_INET6
) ? AI_V4MAPPED
: 0));
352 _nss_nis_gethostbyname_r (const char *name
, struct hostent
*host
, char *buffer
,
353 size_t buflen
, int *errnop
, int *h_errnop
)
355 if (_res
.options
& RES_USE_INET6
)
357 enum nss_status status
;
359 status
= internal_gethostbyname2_r (name
, AF_INET6
, host
, buffer
, buflen
,
360 errnop
, h_errnop
, AI_V4MAPPED
);
361 if (status
== NSS_STATUS_SUCCESS
)
365 return internal_gethostbyname2_r (name
, AF_INET
, host
, buffer
, buflen
,
366 errnop
, h_errnop
, 0);
371 _nss_nis_gethostbyaddr_r (const void *addr
, socklen_t addrlen
, int af
,
372 struct hostent
*host
, char *buffer
, size_t buflen
,
373 int *errnop
, int *h_errnop
)
376 if (__glibc_unlikely (yp_get_default_domain (&domain
)))
377 return NSS_STATUS_UNAVAIL
;
379 uintptr_t pad
= -(uintptr_t) buffer
% __alignof__ (struct parser_data
);
382 struct parser_data
*data
= (void *) buffer
;
383 if (__glibc_unlikely (buflen
< sizeof *data
+ 1 + pad
))
386 *h_errnop
= NETDB_INTERNAL
;
387 return NSS_STATUS_TRYAGAIN
;
391 char *buf
= inet_ntoa (*(const struct in_addr
*) addr
);
395 int yperr
= yp_match (domain
, "hosts.byaddr", buf
, strlen (buf
), &result
,
398 if (__glibc_unlikely (yperr
!= YPERR_SUCCESS
))
400 enum nss_status retval
= yperr2nss (yperr
);
402 if (retval
== NSS_STATUS_TRYAGAIN
)
404 *h_errnop
= TRY_AGAIN
;
407 else if (retval
== NSS_STATUS_NOTFOUND
)
408 *h_errnop
= HOST_NOT_FOUND
;
413 const size_t linebuflen
= buffer
+ buflen
- data
->linebuffer
;
414 if (__glibc_unlikely ((size_t) (len
+ 1) > linebuflen
))
418 *h_errnop
= NETDB_INTERNAL
;
419 return NSS_STATUS_TRYAGAIN
;
422 char *p
= strncpy (data
->linebuffer
, result
, len
);
423 data
->linebuffer
[len
] = '\0';
428 int parse_res
= parse_line (p
, host
, data
, buflen
, errnop
, af
,
429 ((_res
.options
& RES_USE_INET6
)
431 if (__glibc_unlikely (parse_res
< 1))
435 *h_errnop
= NETDB_INTERNAL
;
436 return NSS_STATUS_TRYAGAIN
;
440 *h_errnop
= HOST_NOT_FOUND
;
441 return NSS_STATUS_NOTFOUND
;
445 *h_errnop
= NETDB_SUCCESS
;
446 return NSS_STATUS_SUCCESS
;
451 _nss_nis_gethostbyname4_r (const char *name
, struct gaih_addrtuple
**pat
,
452 char *buffer
, size_t buflen
, int *errnop
,
453 int *herrnop
, int32_t *ttlp
)
456 if (yp_get_default_domain (&domain
))
459 return NSS_STATUS_UNAVAIL
;
462 /* Convert name to lowercase. */
463 size_t namlen
= strlen (name
);
464 char name2
[namlen
+ 1];
467 for (i
= 0; i
< namlen
; ++i
)
468 name2
[i
] = tolower (name
[i
]);
473 int yperr
= yp_match (domain
, "hosts.byname", name2
, namlen
, &result
, &len
);
475 if (__glibc_unlikely (yperr
!= YPERR_SUCCESS
))
477 enum nss_status retval
= yperr2nss (yperr
);
479 if (retval
== NSS_STATUS_TRYAGAIN
)
481 *herrnop
= TRY_AGAIN
;
484 if (retval
== NSS_STATUS_NOTFOUND
)
485 *herrnop
= HOST_NOT_FOUND
;
491 uintptr_t pad
= (-(uintptr_t) buffer
492 % __alignof__ (struct gaih_addrtuple
));
494 buflen
= buflen
> pad
? buflen
- pad
: 0;
496 if (__glibc_unlikely (buflen
< sizeof (struct gaih_addrtuple
)))
501 *herrnop
= NETDB_INTERNAL
;
502 return NSS_STATUS_TRYAGAIN
;
505 *pat
= (struct gaih_addrtuple
*) buffer
;
506 buffer
+= sizeof (struct gaih_addrtuple
);
507 buflen
-= sizeof (struct gaih_addrtuple
);
510 uintptr_t pad
= -(uintptr_t) buffer
% __alignof__ (struct parser_data
);
513 struct parser_data
*data
= (void *) buffer
;
515 if (__glibc_unlikely (buflen
< sizeof *data
+ 1 + pad
))
520 int parse_res
= parse_line (result
, &host
, data
, buflen
, errnop
, AF_UNSPEC
,
522 if (__glibc_unlikely (parse_res
< 1))
526 *herrnop
= NETDB_INTERNAL
;
527 return NSS_STATUS_TRYAGAIN
;
531 *herrnop
= HOST_NOT_FOUND
;
532 return NSS_STATUS_NOTFOUND
;
537 (*pat
)->family
= host
.h_addrtype
;
538 memcpy ((*pat
)->addr
, host
.h_addr_list
[0], host
.h_length
);
540 assert (host
.h_addr_list
[1] == NULL
);
542 /* Undo the alignment for parser_data. */
546 size_t h_name_len
= strlen (host
.h_name
) + 1;
547 if (h_name_len
>= buflen
)
549 (*pat
)->name
= memcpy (buffer
, host
.h_name
, h_name_len
);
553 return NSS_STATUS_SUCCESS
;