2 * Copyright (C) Stefan Metzmacher 2007 <metze@samba.org>
3 * Copyright (C) Guenther Deschner 2009 <gd@samba.org>
4 * Copyright (C) Andreas Schneider 2013 <asn@samba.org>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the author nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 #include <sys/types.h>
42 #include <sys/socket.h>
59 * Defining _POSIX_PTHREAD_SEMANTICS before including pwd.h and grp.h gives us
60 * the posix getpwnam_r(), getpwuid_r(), getgrnam_r and getgrgid_r calls on
63 #ifndef _POSIX_PTHREAD_SEMANTICS
64 #define _POSIX_PTHREAD_SEMANTICS
71 #endif /* HAVE_SHADOW_H */
74 #include <arpa/inet.h>
75 #include <netinet/in.h>
79 #if defined(HAVE_NSS_H)
83 typedef enum nss_status NSS_STATUS;
84 #elif defined(HAVE_NSS_COMMON_H)
86 #include <nss_common.h>
87 #include <nss_dbdefs.h>
90 typedef nss_status_t NSS_STATUS;
92 # define NSS_STATUS_SUCCESS NSS_SUCCESS
93 # define NSS_STATUS_NOTFOUND NSS_NOTFOUND
94 # define NSS_STATUS_UNAVAIL NSS_UNAVAIL
95 # define NSS_STATUS_TRYAGAIN NSS_TRYAGAIN
97 # error "No nsswitch support detected"
101 #define PTR_DIFF(p1, p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
109 #define EAI_NODATA EAI_NONAME
112 #ifndef EAI_ADDRFAMILY
113 #define EAI_ADDRFAMILY EAI_FAMILY
117 #define __STRING(x) #x
120 #ifndef __STRINGSTRING
121 #define __STRINGSTRING(x) __STRING(x)
125 #define __LINESTR__ __STRINGSTRING(__LINE__)
129 #define __location__ __FILE__ ":" __LINESTR__
133 #define DNS_NAME_MAX 255
136 /* GCC have printf type attribute check. */
137 #ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
138 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
140 #define PRINTF_ATTRIBUTE(a,b)
141 #endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
143 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
144 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
146 #define DESTRUCTOR_ATTRIBUTE
147 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
149 #define ZERO_STRUCTP(x) do { if ((x) != NULL) memset((char *)(x), 0, sizeof(*(x))); } while(0)
152 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
156 #define NWRAP_INET_ADDRSTRLEN INET6_ADDRSTRLEN
158 #define NWRAP_INET_ADDRSTRLEN INET_ADDRSTRLEN
161 #define NWRAP_LOCK(m) do { \
162 pthread_mutex_lock(&( m ## _mutex)); \
165 #define NWRAP_UNLOCK(m) do { \
166 pthread_mutex_unlock(&( m ## _mutex)); \
170 static bool nwrap_initialized = false;
171 static pthread_mutex_t nwrap_initialized_mutex = PTHREAD_MUTEX_INITIALIZER;
173 /* The mutex or accessing the id */
174 static pthread_mutex_t nwrap_global_mutex = PTHREAD_MUTEX_INITIALIZER;
175 static pthread_mutex_t nwrap_gr_global_mutex = PTHREAD_MUTEX_INITIALIZER;
176 static pthread_mutex_t nwrap_he_global_mutex = PTHREAD_MUTEX_INITIALIZER;
177 static pthread_mutex_t nwrap_pw_global_mutex = PTHREAD_MUTEX_INITIALIZER;
178 static pthread_mutex_t nwrap_sp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
180 /* Add new global locks here please */
181 /* Also don't forget to add locks to
182 * nwrap_init() function.
184 # define NWRAP_LOCK_ALL do { \
185 NWRAP_LOCK(nwrap_initialized); \
186 NWRAP_LOCK(nwrap_global); \
187 NWRAP_LOCK(nwrap_gr_global); \
188 NWRAP_LOCK(nwrap_he_global); \
189 NWRAP_LOCK(nwrap_pw_global); \
190 NWRAP_LOCK(nwrap_sp_global); \
193 # define NWRAP_UNLOCK_ALL do {\
194 NWRAP_UNLOCK(nwrap_sp_global); \
195 NWRAP_UNLOCK(nwrap_pw_global); \
196 NWRAP_UNLOCK(nwrap_he_global); \
197 NWRAP_UNLOCK(nwrap_gr_global); \
198 NWRAP_UNLOCK(nwrap_global); \
199 NWRAP_UNLOCK(nwrap_initialized); \
202 static void nwrap_thread_prepare(void)
207 static void nwrap_thread_parent(void)
212 static void nwrap_thread_child(void)
217 enum nwrap_dbglvl_e {
225 # define NWRAP_LOG(...)
228 static void nwrap_log(enum nwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
229 # define NWRAP_LOG(dbglvl, ...) nwrap_log((dbglvl), __func__, __VA_ARGS__)
231 static void nwrap_log(enum nwrap_dbglvl_e dbglvl,
233 const char *format, ...)
238 unsigned int lvl = 0;
241 d = getenv("NSS_WRAPPER_DEBUGLEVEL");
246 va_start(va, format);
247 vsnprintf(buffer, sizeof(buffer), format, va);
252 case NWRAP_LOG_ERROR:
254 "NWRAP_ERROR(%d) - %s: %s\n",
259 "NWRAP_WARN(%d) - %s: %s\n",
262 case NWRAP_LOG_DEBUG:
264 "NWRAP_DEBUG(%d) - %s: %s\n",
267 case NWRAP_LOG_TRACE:
269 "NWRAP_TRACE(%d) - %s: %s\n",
275 #endif /* NDEBUG NWRAP_LOG */
277 struct nwrap_libc_fns {
278 struct passwd *(*_libc_getpwnam)(const char *name);
279 int (*_libc_getpwnam_r)(const char *name, struct passwd *pwd,
280 char *buf, size_t buflen, struct passwd **result);
281 struct passwd *(*_libc_getpwuid)(uid_t uid);
282 int (*_libc_getpwuid_r)(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);
283 void (*_libc_setpwent)(void);
284 struct passwd *(*_libc_getpwent)(void);
285 #ifdef HAVE_SOLARIS_GETPWENT_R
286 struct passwd *(*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen);
288 int (*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
290 void (*_libc_endpwent)(void);
291 int (*_libc_initgroups)(const char *user, gid_t gid);
292 struct group *(*_libc_getgrnam)(const char *name);
293 int (*_libc_getgrnam_r)(const char *name, struct group *grp, char *buf, size_t buflen, struct group **result);
294 struct group *(*_libc_getgrgid)(gid_t gid);
295 int (*_libc_getgrgid_r)(gid_t gid, struct group *grp, char *buf, size_t buflen, struct group **result);
296 void (*_libc_setgrent)(void);
297 struct group *(*_libc_getgrent)(void);
298 #ifdef HAVE_SOLARIS_GETGRENT_R
299 struct group *(*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen);
301 int (*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen, struct group **result);
303 void (*_libc_endgrent)(void);
304 int (*_libc_getgrouplist)(const char *user, gid_t group, gid_t *groups, int *ngroups);
306 void (*_libc_sethostent)(int stayopen);
307 struct hostent *(*_libc_gethostent)(void);
308 void (*_libc_endhostent)(void);
310 struct hostent *(*_libc_gethostbyname)(const char *name);
311 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
312 struct hostent *(*_libc_gethostbyname2)(const char *name, int af);
314 struct hostent *(*_libc_gethostbyaddr)(const void *addr, socklen_t len, int type);
316 int (*_libc_getaddrinfo)(const char *node, const char *service,
317 const struct addrinfo *hints,
318 struct addrinfo **res);
319 int (*_libc_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
320 char *host, size_t hostlen,
321 char *serv, size_t servlen,
323 int (*_libc_gethostname)(char *name, size_t len);
324 #ifdef HAVE_GETHOSTBYNAME_R
325 int (*_libc_gethostbyname_r)(const char *name,
327 char *buf, size_t buflen,
328 struct hostent **result, int *h_errnop);
330 #ifdef HAVE_GETHOSTBYADDR_R
331 int (*_libc_gethostbyaddr_r)(const void *addr, socklen_t len, int type,
333 char *buf, size_t buflen,
334 struct hostent **result, int *h_errnop);
338 struct nwrap_module_nss_fns {
339 NSS_STATUS (*_nss_getpwnam_r)(const char *name, struct passwd *result, char *buffer,
340 size_t buflen, int *errnop);
341 NSS_STATUS (*_nss_getpwuid_r)(uid_t uid, struct passwd *result, char *buffer,
342 size_t buflen, int *errnop);
343 NSS_STATUS (*_nss_setpwent)(void);
344 NSS_STATUS (*_nss_getpwent_r)(struct passwd *result, char *buffer,
345 size_t buflen, int *errnop);
346 NSS_STATUS (*_nss_endpwent)(void);
347 NSS_STATUS (*_nss_initgroups)(const char *user, gid_t group, long int *start,
348 long int *size, gid_t **groups, long int limit, int *errnop);
349 NSS_STATUS (*_nss_getgrnam_r)(const char *name, struct group *result, char *buffer,
350 size_t buflen, int *errnop);
351 NSS_STATUS (*_nss_getgrgid_r)(gid_t gid, struct group *result, char *buffer,
352 size_t buflen, int *errnop);
353 NSS_STATUS (*_nss_setgrent)(void);
354 NSS_STATUS (*_nss_getgrent_r)(struct group *result, char *buffer,
355 size_t buflen, int *errnop);
356 NSS_STATUS (*_nss_endgrent)(void);
359 struct nwrap_backend {
363 struct nwrap_ops *ops;
364 struct nwrap_module_nss_fns *fns;
368 struct passwd * (*nw_getpwnam)(struct nwrap_backend *b,
370 int (*nw_getpwnam_r)(struct nwrap_backend *b,
371 const char *name, struct passwd *pwdst,
372 char *buf, size_t buflen, struct passwd **pwdstp);
373 struct passwd * (*nw_getpwuid)(struct nwrap_backend *b,
375 int (*nw_getpwuid_r)(struct nwrap_backend *b,
376 uid_t uid, struct passwd *pwdst,
377 char *buf, size_t buflen, struct passwd **pwdstp);
378 void (*nw_setpwent)(struct nwrap_backend *b);
379 struct passwd * (*nw_getpwent)(struct nwrap_backend *b);
380 int (*nw_getpwent_r)(struct nwrap_backend *b,
381 struct passwd *pwdst, char *buf,
382 size_t buflen, struct passwd **pwdstp);
383 void (*nw_endpwent)(struct nwrap_backend *b);
384 int (*nw_initgroups)(struct nwrap_backend *b,
385 const char *user, gid_t group);
386 struct group * (*nw_getgrnam)(struct nwrap_backend *b,
388 int (*nw_getgrnam_r)(struct nwrap_backend *b,
389 const char *name, struct group *grdst,
390 char *buf, size_t buflen, struct group **grdstp);
391 struct group * (*nw_getgrgid)(struct nwrap_backend *b,
393 int (*nw_getgrgid_r)(struct nwrap_backend *b,
394 gid_t gid, struct group *grdst,
395 char *buf, size_t buflen, struct group **grdstp);
396 void (*nw_setgrent)(struct nwrap_backend *b);
397 struct group * (*nw_getgrent)(struct nwrap_backend *b);
398 int (*nw_getgrent_r)(struct nwrap_backend *b,
399 struct group *grdst, char *buf,
400 size_t buflen, struct group **grdstp);
401 void (*nw_endgrent)(struct nwrap_backend *b);
404 /* Public prototypes */
406 bool nss_wrapper_enabled(void);
407 bool nss_wrapper_shadow_enabled(void);
408 bool nss_wrapper_hosts_enabled(void);
410 /* prototypes for files backend */
413 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
415 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
416 const char *name, struct passwd *pwdst,
417 char *buf, size_t buflen, struct passwd **pwdstp);
418 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
420 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
421 uid_t uid, struct passwd *pwdst,
422 char *buf, size_t buflen, struct passwd **pwdstp);
423 static void nwrap_files_setpwent(struct nwrap_backend *b);
424 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b);
425 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
426 struct passwd *pwdst, char *buf,
427 size_t buflen, struct passwd **pwdstp);
428 static void nwrap_files_endpwent(struct nwrap_backend *b);
429 static int nwrap_files_initgroups(struct nwrap_backend *b,
430 const char *user, gid_t group);
431 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
433 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
434 const char *name, struct group *grdst,
435 char *buf, size_t buflen, struct group **grdstp);
436 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
438 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
439 gid_t gid, struct group *grdst,
440 char *buf, size_t buflen, struct group **grdstp);
441 static void nwrap_files_setgrent(struct nwrap_backend *b);
442 static struct group *nwrap_files_getgrent(struct nwrap_backend *b);
443 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
444 struct group *grdst, char *buf,
445 size_t buflen, struct group **grdstp);
446 static void nwrap_files_endgrent(struct nwrap_backend *b);
448 /* prototypes for module backend */
450 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
451 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
452 struct passwd *pwdst, char *buf,
453 size_t buflen, struct passwd **pwdstp);
454 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
456 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
457 const char *name, struct passwd *pwdst,
458 char *buf, size_t buflen, struct passwd **pwdstp);
459 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
461 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
462 uid_t uid, struct passwd *pwdst,
463 char *buf, size_t buflen, struct passwd **pwdstp);
464 static void nwrap_module_setpwent(struct nwrap_backend *b);
465 static void nwrap_module_endpwent(struct nwrap_backend *b);
466 static struct group *nwrap_module_getgrent(struct nwrap_backend *b);
467 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
468 struct group *grdst, char *buf,
469 size_t buflen, struct group **grdstp);
470 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
472 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
473 const char *name, struct group *grdst,
474 char *buf, size_t buflen, struct group **grdstp);
475 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
477 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
478 gid_t gid, struct group *grdst,
479 char *buf, size_t buflen, struct group **grdstp);
480 static void nwrap_module_setgrent(struct nwrap_backend *b);
481 static void nwrap_module_endgrent(struct nwrap_backend *b);
482 static int nwrap_module_initgroups(struct nwrap_backend *b,
483 const char *user, gid_t group);
485 struct nwrap_ops nwrap_files_ops = {
486 .nw_getpwnam = nwrap_files_getpwnam,
487 .nw_getpwnam_r = nwrap_files_getpwnam_r,
488 .nw_getpwuid = nwrap_files_getpwuid,
489 .nw_getpwuid_r = nwrap_files_getpwuid_r,
490 .nw_setpwent = nwrap_files_setpwent,
491 .nw_getpwent = nwrap_files_getpwent,
492 .nw_getpwent_r = nwrap_files_getpwent_r,
493 .nw_endpwent = nwrap_files_endpwent,
494 .nw_initgroups = nwrap_files_initgroups,
495 .nw_getgrnam = nwrap_files_getgrnam,
496 .nw_getgrnam_r = nwrap_files_getgrnam_r,
497 .nw_getgrgid = nwrap_files_getgrgid,
498 .nw_getgrgid_r = nwrap_files_getgrgid_r,
499 .nw_setgrent = nwrap_files_setgrent,
500 .nw_getgrent = nwrap_files_getgrent,
501 .nw_getgrent_r = nwrap_files_getgrent_r,
502 .nw_endgrent = nwrap_files_endgrent,
505 struct nwrap_ops nwrap_module_ops = {
506 .nw_getpwnam = nwrap_module_getpwnam,
507 .nw_getpwnam_r = nwrap_module_getpwnam_r,
508 .nw_getpwuid = nwrap_module_getpwuid,
509 .nw_getpwuid_r = nwrap_module_getpwuid_r,
510 .nw_setpwent = nwrap_module_setpwent,
511 .nw_getpwent = nwrap_module_getpwent,
512 .nw_getpwent_r = nwrap_module_getpwent_r,
513 .nw_endpwent = nwrap_module_endpwent,
514 .nw_initgroups = nwrap_module_initgroups,
515 .nw_getgrnam = nwrap_module_getgrnam,
516 .nw_getgrnam_r = nwrap_module_getgrnam_r,
517 .nw_getgrgid = nwrap_module_getgrgid,
518 .nw_getgrgid_r = nwrap_module_getgrgid_r,
519 .nw_setgrent = nwrap_module_setgrent,
520 .nw_getgrent = nwrap_module_getgrent,
521 .nw_getgrent_r = nwrap_module_getgrent_r,
522 .nw_endgrent = nwrap_module_endgrent,
529 struct nwrap_libc_fns *fns;
534 struct nwrap_backend *backends;
535 struct nwrap_libc *libc;
538 static struct nwrap_main *nwrap_main_global;
539 static struct nwrap_main __nwrap_main_global;
544 static int nwrap_convert_he_ai(const struct hostent *he,
546 const struct addrinfo *hints,
547 struct addrinfo **pai,
548 bool skip_canonname);
554 #define DEFAULT_VECTOR_CAPACITY 16
556 struct nwrap_vector {
562 /* Macro returns pointer to first element of vector->items array.
564 * nwrap_vector is used as a memory backend which take care of
565 * memory allocations and other stuff like memory growing.
566 * nwrap_vectors should not be considered as some abstract structures.
567 * On this level, vectors are more handy than direct realloc/malloc
570 * nwrap_vector->items is array inside nwrap_vector which can be
571 * directly pointed by libc structure assembled by cwrap itself.
575 * 1) struct hostent contains char **h_addr_list element.
576 * 2) nwrap_vector holds array of pointers to addresses.
577 * It's easier to use vector to store results of
580 * Now, pretend that cwrap assembled struct hostent and
581 * we need to set h_addr_list to point to nwrap_vector.
582 * Idea behind is to shield users from internal nwrap_vector
584 * (Yes, not fully - array terminated by NULL is needed because
585 * it's result expected by libc function caller.)
591 * struct nwrap_vector *vector = malloc(sizeof(struct nwrap_vector));
592 * ... don't care about failed allocation now ...
594 * ... fill nwrap vector ...
597 * he.h_addr_list = nwrap_vector_head(vector);
600 #define nwrap_vector_head(vect) ((void *)((vect)->items))
602 #define nwrap_vector_foreach(item, vect, iter) \
603 for (iter = 0, (item) = (vect).items == NULL ? NULL : (vect).items[0]; \
605 (item) = (vect).items[++iter])
607 #define nwrap_vector_is_initialized(vector) ((vector)->items != NULL)
609 static inline bool nwrap_vector_init(struct nwrap_vector *const vector)
611 if (vector == NULL) {
615 /* count is initialized by ZERO_STRUCTP */
616 ZERO_STRUCTP(vector);
617 vector->items = malloc(sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
618 if (vector->items == NULL) {
621 vector->capacity = DEFAULT_VECTOR_CAPACITY;
622 memset(vector->items, '\0', sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
627 static bool nwrap_vector_add_item(struct nwrap_vector *vector, void *const item)
629 assert (vector != NULL);
631 if (vector->items == NULL) {
632 nwrap_vector_init(vector);
635 if (vector->count == vector->capacity) {
636 /* Items array _MUST_ be NULL terminated because it's passed
637 * as result to caller which expect NULL terminated array from libc.
639 void **items = realloc(vector->items, sizeof(void *) * ((vector->capacity * 2) + 1));
643 vector->items = items;
645 /* Don't count ending NULL to capacity */
646 vector->capacity *= 2;
649 vector->items[vector->count] = item;
652 vector->items[vector->count] = NULL;
657 static bool nwrap_vector_merge(struct nwrap_vector *dst,
658 struct nwrap_vector *src)
660 void **dst_items = NULL;
663 if (src->count == 0) {
667 count = dst->count + src->count;
669 /* We don't need reallocation if we have enough capacity. */
670 if (src->count > (dst->capacity - dst->count)) {
671 dst_items = (void **)realloc(dst->items, (count + 1) * sizeof(void *));
672 if (dst_items == NULL) {
675 dst->items = dst_items;
676 dst->capacity = count;
679 memcpy((void *)(((long *)dst->items) + dst->count),
681 src->count * sizeof(void *));
694 struct nwrap_vector lines;
696 bool (*parse_line)(struct nwrap_cache *, char *line);
697 void (*unload)(struct nwrap_cache *);
702 struct nwrap_cache *cache;
709 struct nwrap_cache __nwrap_cache_pw;
710 struct nwrap_pw nwrap_pw_global;
712 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line);
713 static void nwrap_pw_unload(struct nwrap_cache *nwrap);
716 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
718 struct nwrap_cache *cache;
725 struct nwrap_cache __nwrap_cache_sp;
726 struct nwrap_sp nwrap_sp_global;
728 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line);
729 static void nwrap_sp_unload(struct nwrap_cache *nwrap);
730 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
734 struct nwrap_cache *cache;
741 struct nwrap_cache __nwrap_cache_gr;
742 struct nwrap_gr nwrap_gr_global;
745 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line);
746 static void nwrap_he_unload(struct nwrap_cache *nwrap);
748 struct nwrap_addrdata {
749 unsigned char host_addr[16]; /* IPv4 or IPv6 address */
752 static size_t max_hostents = 100;
754 struct nwrap_entdata {
755 struct nwrap_addrdata addr;
758 struct nwrap_vector nwrap_addrdata;
760 ssize_t aliases_count;
763 struct nwrap_entlist {
764 struct nwrap_entlist *next;
765 struct nwrap_entdata *ed;
769 struct nwrap_cache *cache;
771 struct nwrap_entdata *list;
772 struct nwrap_vector entdata;
778 static struct nwrap_cache __nwrap_cache_he;
779 static struct nwrap_he nwrap_he_global;
782 /*********************************************************
784 *********************************************************/
786 static void nwrap_init(void);
787 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line);
788 static void nwrap_gr_unload(struct nwrap_cache *nwrap);
789 void nwrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
791 /*********************************************************
792 * NWRAP LIBC LOADER FUNCTIONS
793 *********************************************************/
802 static const char *nwrap_str_lib(enum nwrap_lib lib)
809 case NWRAP_LIBSOCKET:
813 /* Compiler would warn us about unhandled enum value if we get here */
818 static void *nwrap_load_lib_handle(enum nwrap_lib lib)
820 int flags = RTLD_LAZY;
825 flags |= RTLD_DEEPBIND;
831 handle = nwrap_main_global->libc->nsl_handle;
832 if (handle == NULL) {
833 for (i = 10; i >= 0; i--) {
834 char soname[256] = {0};
836 snprintf(soname, sizeof(soname), "libnsl.so.%d", i);
837 handle = dlopen(soname, flags);
838 if (handle != NULL) {
843 nwrap_main_global->libc->nsl_handle = handle;
848 case NWRAP_LIBSOCKET:
849 #ifdef HAVE_LIBSOCKET
850 handle = nwrap_main_global->libc->sock_handle;
851 if (handle == NULL) {
852 for (i = 10; i >= 0; i--) {
853 char soname[256] = {0};
855 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
856 handle = dlopen(soname, flags);
857 if (handle != NULL) {
862 nwrap_main_global->libc->sock_handle = handle;
868 handle = nwrap_main_global->libc->handle;
869 if (handle == NULL) {
870 for (i = 10; i >= 0; i--) {
871 char soname[256] = {0};
873 snprintf(soname, sizeof(soname), "libc.so.%d", i);
874 handle = dlopen(soname, flags);
875 if (handle != NULL) {
880 nwrap_main_global->libc->handle = handle;
885 if (handle == NULL) {
887 handle = nwrap_main_global->libc->handle
888 = nwrap_main_global->libc->sock_handle
889 = nwrap_main_global->libc->nsl_handle
892 NWRAP_LOG(NWRAP_LOG_ERROR,
893 "Failed to dlopen library: %s\n",
902 static void *_nwrap_load_lib_function(enum nwrap_lib lib, const char *fn_name)
909 handle = nwrap_load_lib_handle(lib);
911 func = dlsym(handle, fn_name);
913 NWRAP_LOG(NWRAP_LOG_ERROR,
914 "Failed to find %s: %s\n",
919 NWRAP_LOG(NWRAP_LOG_TRACE,
921 fn_name, nwrap_str_lib(lib));
925 #define nwrap_load_lib_function(lib, fn_name) \
926 if (nwrap_main_global->libc->fns->_libc_##fn_name == NULL) { \
927 *(void **) (&nwrap_main_global->libc->fns->_libc_##fn_name) = \
928 _nwrap_load_lib_function(lib, #fn_name); \
931 /* INTERNAL HELPER FUNCTIONS */
932 static void nwrap_lines_unload(struct nwrap_cache *const nwrap)
936 nwrap_vector_foreach(item, nwrap->lines, p) {
937 /* Maybe some vectors were merged ... */
940 SAFE_FREE(nwrap->lines.items);
941 ZERO_STRUCTP(&nwrap->lines);
947 * Functions expeciall from libc need to be loaded individually, you can't load
948 * all at once or gdb will segfault at startup. The same applies to valgrind and
949 * has probably something todo with with the linker.
950 * So we need load each function at the point it is called the first time.
952 static struct passwd *libc_getpwnam(const char *name)
954 nwrap_load_lib_function(NWRAP_LIBC, getpwnam);
956 return nwrap_main_global->libc->fns->_libc_getpwnam(name);
959 #ifdef HAVE_GETPWNAM_R
960 static int libc_getpwnam_r(const char *name,
964 struct passwd **result)
966 #ifdef HAVE___POSIX_GETPWNAM_R
967 if (nwrap_main_global->libc->fns->_libc_getpwnam_r == NULL) {
968 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwnam_r) =
969 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwnam_r");
972 nwrap_load_lib_function(NWRAP_LIBC, getpwnam_r);
975 return nwrap_main_global->libc->fns->_libc_getpwnam_r(name,
983 static struct passwd *libc_getpwuid(uid_t uid)
985 nwrap_load_lib_function(NWRAP_LIBC, getpwuid);
987 return nwrap_main_global->libc->fns->_libc_getpwuid(uid);
990 #ifdef HAVE_GETPWUID_R
991 static int libc_getpwuid_r(uid_t uid,
995 struct passwd **result)
997 #ifdef HAVE___POSIX_GETPWUID_R
998 if (nwrap_main_global->libc->fns->_libc_getpwuid_r == NULL) {
999 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwuid_r) =
1000 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwuid_r");
1003 nwrap_load_lib_function(NWRAP_LIBC, getpwuid_r);
1006 return nwrap_main_global->libc->fns->_libc_getpwuid_r(uid,
1014 static inline void str_tolower(char *dst, char *src)
1016 register char *src_tmp = src;
1017 register char *dst_tmp = dst;
1019 while (*src_tmp != '\0') {
1020 *dst_tmp = tolower(*src_tmp);
1026 static bool str_tolower_copy(char **dst_name, const char *const src_name)
1030 if ((dst_name == NULL) || (src_name == NULL)) {
1034 h_name_lower = strdup(src_name);
1035 if (h_name_lower == NULL) {
1036 NWRAP_LOG(NWRAP_LOG_DEBUG, "Out of memory while strdup");
1040 str_tolower(h_name_lower, h_name_lower);
1041 *dst_name = h_name_lower;
1045 static void libc_setpwent(void)
1047 nwrap_load_lib_function(NWRAP_LIBC, setpwent);
1049 nwrap_main_global->libc->fns->_libc_setpwent();
1052 static struct passwd *libc_getpwent(void)
1054 nwrap_load_lib_function(NWRAP_LIBC, getpwent);
1056 return nwrap_main_global->libc->fns->_libc_getpwent();
1059 #ifdef HAVE_SOLARIS_GETPWENT_R
1060 static struct passwd *libc_getpwent_r(struct passwd *pwdst,
1064 nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1066 return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1070 #else /* HAVE_SOLARIS_GETPWENT_R */
1071 static int libc_getpwent_r(struct passwd *pwdst,
1074 struct passwd **pwdstp)
1076 nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1078 return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1083 #endif /* HAVE_SOLARIS_GETPWENT_R */
1085 static void libc_endpwent(void)
1087 nwrap_load_lib_function(NWRAP_LIBC, endpwent);
1089 nwrap_main_global->libc->fns->_libc_endpwent();
1092 static int libc_initgroups(const char *user, gid_t gid)
1094 nwrap_load_lib_function(NWRAP_LIBC, initgroups);
1096 return nwrap_main_global->libc->fns->_libc_initgroups(user, gid);
1099 static struct group *libc_getgrnam(const char *name)
1101 nwrap_load_lib_function(NWRAP_LIBC, getgrnam);
1103 return nwrap_main_global->libc->fns->_libc_getgrnam(name);
1106 #ifdef HAVE_GETGRNAM_R
1107 static int libc_getgrnam_r(const char *name,
1111 struct group **result)
1113 #ifdef HAVE___POSIX_GETGRNAM_R
1114 if (nwrap_main_global->libc->fns->_libc_getgrnam_r == NULL) {
1115 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrnam_r) =
1116 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrnam_r");
1119 nwrap_load_lib_function(NWRAP_LIBC, getgrnam_r);
1122 return nwrap_main_global->libc->fns->_libc_getgrnam_r(name,
1130 static struct group *libc_getgrgid(gid_t gid)
1132 nwrap_load_lib_function(NWRAP_LIBC, getgrgid);
1134 return nwrap_main_global->libc->fns->_libc_getgrgid(gid);
1137 #ifdef HAVE_GETGRGID_R
1138 static int libc_getgrgid_r(gid_t gid,
1142 struct group **result)
1144 #ifdef HAVE___POSIX_GETGRGID_R
1145 if (nwrap_main_global->libc->fns->_libc_getgrgid_r == NULL) {
1146 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrgid_r) =
1147 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrgid_r");
1150 nwrap_load_lib_function(NWRAP_LIBC, getgrgid_r);
1153 return nwrap_main_global->libc->fns->_libc_getgrgid_r(gid,
1161 static void libc_setgrent(void)
1163 nwrap_load_lib_function(NWRAP_LIBC, setgrent);
1165 nwrap_main_global->libc->fns->_libc_setgrent();
1168 static struct group *libc_getgrent(void)
1170 nwrap_load_lib_function(NWRAP_LIBC, getgrent);
1172 return nwrap_main_global->libc->fns->_libc_getgrent();
1175 #ifdef HAVE_GETGRENT_R
1176 #ifdef HAVE_SOLARIS_GETGRENT_R
1177 static struct group *libc_getgrent_r(struct group *group,
1181 nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1183 return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1187 #else /* !HAVE_SOLARIS_GETGRENT_R */
1188 static int libc_getgrent_r(struct group *group,
1191 struct group **result)
1193 nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1195 return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1200 #endif /* HAVE_SOLARIS_GETGRENT_R */
1201 #endif /* HAVE_GETGRENT_R */
1203 static void libc_endgrent(void)
1205 nwrap_load_lib_function(NWRAP_LIBC, endgrent);
1207 nwrap_main_global->libc->fns->_libc_endgrent();
1210 #ifdef HAVE_GETGROUPLIST
1211 static int libc_getgrouplist(const char *user,
1216 nwrap_load_lib_function(NWRAP_LIBC, getgrouplist);
1218 return nwrap_main_global->libc->fns->_libc_getgrouplist(user,
1225 static void libc_sethostent(int stayopen)
1227 nwrap_load_lib_function(NWRAP_LIBNSL, sethostent);
1229 nwrap_main_global->libc->fns->_libc_sethostent(stayopen);
1232 static struct hostent *libc_gethostent(void)
1234 nwrap_load_lib_function(NWRAP_LIBNSL, gethostent);
1236 return nwrap_main_global->libc->fns->_libc_gethostent();
1239 static void libc_endhostent(void)
1241 nwrap_load_lib_function(NWRAP_LIBNSL, endhostent);
1243 nwrap_main_global->libc->fns->_libc_endhostent();
1246 static struct hostent *libc_gethostbyname(const char *name)
1248 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname);
1250 return nwrap_main_global->libc->fns->_libc_gethostbyname(name);
1253 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
1254 static struct hostent *libc_gethostbyname2(const char *name, int af)
1256 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname2);
1258 return nwrap_main_global->libc->fns->_libc_gethostbyname2(name, af);
1262 static struct hostent *libc_gethostbyaddr(const void *addr,
1266 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr);
1268 return nwrap_main_global->libc->fns->_libc_gethostbyaddr(addr,
1273 static int libc_gethostname(char *name, size_t len)
1275 nwrap_load_lib_function(NWRAP_LIBNSL, gethostname);
1277 return nwrap_main_global->libc->fns->_libc_gethostname(name, len);
1280 #ifdef HAVE_GETHOSTBYNAME_R
1281 static int libc_gethostbyname_r(const char *name,
1282 struct hostent *ret,
1285 struct hostent **result,
1288 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname_r);
1290 return nwrap_main_global->libc->fns->_libc_gethostbyname_r(name,
1299 #ifdef HAVE_GETHOSTBYADDR_R
1300 static int libc_gethostbyaddr_r(const void *addr,
1303 struct hostent *ret,
1306 struct hostent **result,
1309 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr_r);
1311 return nwrap_main_global->libc->fns->_libc_gethostbyaddr_r(addr,
1322 static int libc_getaddrinfo(const char *node,
1323 const char *service,
1324 const struct addrinfo *hints,
1325 struct addrinfo **res)
1327 nwrap_load_lib_function(NWRAP_LIBSOCKET, getaddrinfo);
1329 return nwrap_main_global->libc->fns->_libc_getaddrinfo(node,
1335 static int libc_getnameinfo(const struct sockaddr *sa,
1343 nwrap_load_lib_function(NWRAP_LIBSOCKET, getnameinfo);
1345 return nwrap_main_global->libc->fns->_libc_getnameinfo(sa,
1354 /*********************************************************
1355 * NWRAP NSS MODULE LOADER FUNCTIONS
1356 *********************************************************/
1358 static void *nwrap_load_module_fn(struct nwrap_backend *b,
1359 const char *fn_name)
1364 if (!b->so_handle) {
1365 NWRAP_LOG(NWRAP_LOG_ERROR, "No handle");
1369 if (asprintf(&s, "_nss_%s_%s", b->name, fn_name) == -1) {
1370 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1374 res = dlsym(b->so_handle, s);
1376 NWRAP_LOG(NWRAP_LOG_ERROR,
1377 "Cannot find function %s in %s",
1384 static struct nwrap_module_nss_fns *nwrap_load_module_fns(struct nwrap_backend *b)
1386 struct nwrap_module_nss_fns *fns;
1388 if (!b->so_handle) {
1392 fns = (struct nwrap_module_nss_fns *)malloc(sizeof(struct nwrap_module_nss_fns));
1397 *(void **)(&fns->_nss_getpwnam_r) =
1398 nwrap_load_module_fn(b, "getpwnam_r");
1399 *(void **)(&fns->_nss_getpwuid_r) =
1400 nwrap_load_module_fn(b, "getpwuid_r");
1401 *(void **)(&fns->_nss_setpwent) =
1402 nwrap_load_module_fn(b, "setpwent");
1403 *(void **)(&fns->_nss_getpwent_r) =
1404 nwrap_load_module_fn(b, "getpwent_r");
1405 *(void **)(&fns->_nss_endpwent) =
1406 nwrap_load_module_fn(b, "endpwent");
1407 *(void **)(&fns->_nss_initgroups) =
1408 nwrap_load_module_fn(b, "initgroups_dyn");
1409 *(void **)(&fns->_nss_getgrnam_r) =
1410 nwrap_load_module_fn(b, "getgrnam_r");
1411 *(void **)(&fns->_nss_getgrgid_r)=
1412 nwrap_load_module_fn(b, "getgrgid_r");
1413 *(void **)(&fns->_nss_setgrent) =
1414 nwrap_load_module_fn(b, "setgrent");
1415 *(void **)(&fns->_nss_getgrent_r) =
1416 nwrap_load_module_fn(b, "getgrent_r");
1417 *(void **)(&fns->_nss_endgrent) =
1418 nwrap_load_module_fn(b, "endgrent");
1423 static void *nwrap_load_module(const char *so_path)
1427 if (!so_path || !strlen(so_path)) {
1431 h = dlopen(so_path, RTLD_LAZY);
1433 NWRAP_LOG(NWRAP_LOG_ERROR,
1434 "Cannot open shared library %s",
1442 static bool nwrap_module_init(const char *name,
1443 struct nwrap_ops *ops,
1444 const char *so_path,
1446 struct nwrap_backend **backends)
1448 struct nwrap_backend *b;
1450 *backends = (struct nwrap_backend *)realloc(*backends,
1451 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
1453 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1457 b = &((*backends)[*num_backends]);
1461 b->so_path = so_path;
1463 if (so_path != NULL) {
1464 b->so_handle = nwrap_load_module(so_path);
1465 b->fns = nwrap_load_module_fns(b);
1466 if (b->fns == NULL) {
1470 b->so_handle = NULL;
1479 static void nwrap_libc_init(struct nwrap_main *r)
1481 r->libc = malloc(sizeof(struct nwrap_libc));
1482 if (r->libc == NULL) {
1483 printf("Failed to allocate memory for libc");
1486 ZERO_STRUCTP(r->libc);
1488 r->libc->fns = malloc(sizeof(struct nwrap_libc_fns));
1489 if (r->libc->fns == NULL) {
1490 printf("Failed to allocate memory for libc functions");
1493 ZERO_STRUCTP(r->libc->fns);
1496 static void nwrap_backend_init(struct nwrap_main *r)
1498 const char *module_so_path = getenv("NSS_WRAPPER_MODULE_SO_PATH");
1499 const char *module_fn_name = getenv("NSS_WRAPPER_MODULE_FN_PREFIX");
1501 r->num_backends = 0;
1504 if (!nwrap_module_init("files", &nwrap_files_ops, NULL,
1507 NWRAP_LOG(NWRAP_LOG_ERROR,
1508 "Failed to initialize 'files' backend");
1512 if (module_so_path != NULL &&
1513 module_so_path[0] != '\0' &&
1514 module_fn_name != NULL &&
1515 module_fn_name[0] != '\0') {
1516 if (!nwrap_module_init(module_fn_name,
1521 NWRAP_LOG(NWRAP_LOG_ERROR,
1522 "Failed to initialize '%s' backend",
1529 static void nwrap_init(void)
1533 size_t max_hostents_tmp;
1535 NWRAP_LOCK(nwrap_initialized);
1536 if (nwrap_initialized) {
1537 NWRAP_UNLOCK(nwrap_initialized);
1542 * Still holding nwrap_initialized lock here.
1543 * We don't use NWRAP_(UN)LOCK_ALL macros here because we
1544 * want to avoid overhead when other threads do their job.
1546 NWRAP_LOCK(nwrap_global);
1547 NWRAP_LOCK(nwrap_gr_global);
1548 NWRAP_LOCK(nwrap_he_global);
1549 NWRAP_LOCK(nwrap_pw_global);
1550 NWRAP_LOCK(nwrap_sp_global);
1552 nwrap_initialized = true;
1554 /* Initialize pthread_atfork handlers */
1555 pthread_atfork(&nwrap_thread_prepare, &nwrap_thread_parent,
1556 &nwrap_thread_child);
1558 env = getenv("NSS_WRAPPER_MAX_HOSTENTS");
1560 max_hostents_tmp = (size_t)strtol(env, &endptr, 10);
1561 if (((env != '\0') && (endptr == '\0')) ||
1562 (max_hostents_tmp == 0)) {
1563 NWRAP_LOG(NWRAP_LOG_DEBUG,
1564 "Error parsing NSS_WRAPPER_MAX_HOSTENTS "
1565 "value or value is too small. "
1566 "Using default value: %lu.",
1569 max_hostents = max_hostents_tmp;
1572 /* Initialize hash table */
1573 NWRAP_LOG(NWRAP_LOG_DEBUG,
1574 "Initializing hash table of size %lu items.", max_hostents);
1575 if (hcreate(max_hostents) == 0) {
1576 NWRAP_LOG(NWRAP_LOG_ERROR,
1577 "Failed to initialize hash table");
1581 nwrap_main_global = &__nwrap_main_global;
1583 nwrap_libc_init(nwrap_main_global);
1585 nwrap_backend_init(nwrap_main_global);
1588 nwrap_pw_global.cache = &__nwrap_cache_pw;
1590 nwrap_pw_global.cache->path = getenv("NSS_WRAPPER_PASSWD");
1591 nwrap_pw_global.cache->fp = NULL;
1592 nwrap_pw_global.cache->fd = -1;
1593 nwrap_pw_global.cache->private_data = &nwrap_pw_global;
1594 nwrap_pw_global.cache->parse_line = nwrap_pw_parse_line;
1595 nwrap_pw_global.cache->unload = nwrap_pw_unload;
1598 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1599 nwrap_sp_global.cache = &__nwrap_cache_sp;
1601 nwrap_sp_global.cache->path = getenv("NSS_WRAPPER_SHADOW");
1602 nwrap_sp_global.cache->fp = NULL;
1603 nwrap_sp_global.cache->fd = -1;
1604 nwrap_sp_global.cache->private_data = &nwrap_sp_global;
1605 nwrap_sp_global.cache->parse_line = nwrap_sp_parse_line;
1606 nwrap_sp_global.cache->unload = nwrap_sp_unload;
1607 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1610 nwrap_gr_global.cache = &__nwrap_cache_gr;
1612 nwrap_gr_global.cache->path = getenv("NSS_WRAPPER_GROUP");
1613 nwrap_gr_global.cache->fp = NULL;
1614 nwrap_gr_global.cache->fd = -1;
1615 nwrap_gr_global.cache->private_data = &nwrap_gr_global;
1616 nwrap_gr_global.cache->parse_line = nwrap_gr_parse_line;
1617 nwrap_gr_global.cache->unload = nwrap_gr_unload;
1620 nwrap_he_global.cache = &__nwrap_cache_he;
1622 nwrap_he_global.cache->path = getenv("NSS_WRAPPER_HOSTS");
1623 nwrap_he_global.cache->fp = NULL;
1624 nwrap_he_global.cache->fd = -1;
1625 nwrap_he_global.cache->private_data = &nwrap_he_global;
1626 nwrap_he_global.cache->parse_line = nwrap_he_parse_line;
1627 nwrap_he_global.cache->unload = nwrap_he_unload;
1630 /* We hold all locks here so we can use NWRAP_UNLOCK_ALL. */
1634 bool nss_wrapper_enabled(void)
1638 if (nwrap_pw_global.cache->path == NULL ||
1639 nwrap_pw_global.cache->path[0] == '\0') {
1642 if (nwrap_gr_global.cache->path == NULL ||
1643 nwrap_gr_global.cache->path[0] == '\0') {
1650 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1651 bool nss_wrapper_shadow_enabled(void)
1655 if (nwrap_sp_global.cache->path == NULL ||
1656 nwrap_sp_global.cache->path[0] == '\0') {
1662 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1664 bool nss_wrapper_hosts_enabled(void)
1668 if (nwrap_he_global.cache->path == NULL ||
1669 nwrap_he_global.cache->path[0] == '\0') {
1676 static bool nwrap_hostname_enabled(void)
1680 if (getenv("NSS_WRAPPER_HOSTNAME") == NULL) {
1687 static bool nwrap_parse_file(struct nwrap_cache *nwrap)
1691 /* Unused but getline needs it */
1695 if (nwrap->st.st_size == 0) {
1696 NWRAP_LOG(NWRAP_LOG_DEBUG, "size == 0");
1700 /* Support for 32-bit system I guess */
1701 if (nwrap->st.st_size > INT32_MAX) {
1702 NWRAP_LOG(NWRAP_LOG_ERROR,
1703 "Size[%u] larger than INT32_MAX",
1704 (unsigned)nwrap->st.st_size);
1711 n = getline(&line, &len, nwrap->fp);
1714 if (feof(nwrap->fp)) {
1718 NWRAP_LOG(NWRAP_LOG_ERROR,
1719 "Unable to read line from file: %s",
1724 if (line[n - 1] == '\n') {
1728 if (line[0] == '\0') {
1733 ok = nwrap->parse_line(nwrap, line);
1735 NWRAP_LOG(NWRAP_LOG_ERROR,
1736 "Unable to parse line file: %s",
1742 /* Line is parsed without issues so add it to list */
1743 ok = nwrap_vector_add_item(&(nwrap->lines), (void *const) line);
1745 NWRAP_LOG(NWRAP_LOG_ERROR,
1746 "Unable to add line to vector");
1750 /* This forces getline to allocate new memory for line. */
1752 } while (!feof(nwrap->fp));
1757 static void nwrap_files_cache_unload(struct nwrap_cache *nwrap)
1759 nwrap->unload(nwrap);
1761 nwrap_lines_unload(nwrap);
1764 static bool nwrap_files_cache_reload(struct nwrap_cache *nwrap)
1769 bool retried = false;
1771 assert(nwrap != NULL);
1774 if (nwrap->fd < 0) {
1775 nwrap->fp = fopen(nwrap->path, "re");
1776 if (nwrap->fp == NULL) {
1778 NWRAP_LOG(NWRAP_LOG_ERROR,
1779 "Unable to open '%s' readonly %d:%s",
1780 nwrap->path, nwrap->fd,
1785 nwrap->fd = fileno(nwrap->fp);
1786 NWRAP_LOG(NWRAP_LOG_DEBUG, "Open '%s'", nwrap->path);
1789 ret = fstat(nwrap->fd, &st);
1791 NWRAP_LOG(NWRAP_LOG_ERROR,
1792 "fstat(%s) - %d:%s",
1802 if (retried == false && st.st_nlink == 0) {
1803 /* maybe someone has replaced the file... */
1804 NWRAP_LOG(NWRAP_LOG_TRACE,
1805 "st_nlink == 0, reopen %s",
1808 memset(&nwrap->st, 0, sizeof(nwrap->st));
1815 if (st.st_mtime == nwrap->st.st_mtime) {
1816 NWRAP_LOG(NWRAP_LOG_TRACE,
1817 "st_mtime[%u] hasn't changed, skip reload",
1818 (unsigned)st.st_mtime);
1822 NWRAP_LOG(NWRAP_LOG_TRACE,
1823 "st_mtime has changed [%u] => [%u], start reload",
1824 (unsigned)st.st_mtime,
1825 (unsigned)nwrap->st.st_mtime);
1829 nwrap_files_cache_unload(nwrap);
1831 ok = nwrap_parse_file(nwrap);
1833 NWRAP_LOG(NWRAP_LOG_ERROR, "Failed to reload %s", nwrap->path);
1834 nwrap_files_cache_unload(nwrap);
1838 NWRAP_LOG(NWRAP_LOG_TRACE, "Reloaded %s", nwrap->path);
1843 * the caller has to call nwrap_unload() on failure
1845 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line)
1847 struct nwrap_pw *nwrap_pw;
1854 nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
1856 list_size = sizeof(*nwrap_pw->list) * (nwrap_pw->num+1);
1857 pw = (struct passwd *)realloc(nwrap_pw->list, list_size);
1859 NWRAP_LOG(NWRAP_LOG_ERROR,
1860 "realloc(%u) failed",
1861 (unsigned)list_size);
1864 nwrap_pw->list = pw;
1866 pw = &nwrap_pw->list[nwrap_pw->num];
1873 NWRAP_LOG(NWRAP_LOG_ERROR,
1874 "Invalid line[%s]: '%s'",
1884 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", pw->pw_name);
1889 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1897 NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]\n", pw->pw_passwd);
1902 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1908 pw->pw_uid = (uid_t)strtoul(c, &e, 10);
1910 NWRAP_LOG(NWRAP_LOG_ERROR,
1911 "Invalid line[%s]: '%s' - %s",
1912 line, c, strerror(errno));
1916 NWRAP_LOG(NWRAP_LOG_ERROR,
1917 "Invalid line[%s]: '%s' - %s",
1918 line, c, strerror(errno));
1922 NWRAP_LOG(NWRAP_LOG_ERROR,
1923 "Invalid line[%s]: '%s' - %s",
1924 line, c, strerror(errno));
1929 NWRAP_LOG(NWRAP_LOG_TRACE, "uid[%u]", pw->pw_uid);
1934 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1940 pw->pw_gid = (gid_t)strtoul(c, &e, 10);
1942 NWRAP_LOG(NWRAP_LOG_ERROR,
1943 "Invalid line[%s]: '%s' - %s",
1944 line, c, strerror(errno));
1948 NWRAP_LOG(NWRAP_LOG_ERROR,
1949 "Invalid line[%s]: '%s' - %s",
1950 line, c, strerror(errno));
1954 NWRAP_LOG(NWRAP_LOG_ERROR,
1955 "Invalid line[%s]: '%s' - %s",
1956 line, c, strerror(errno));
1961 NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]\n", pw->pw_gid);
1966 NWRAP_LOG(NWRAP_LOG_ERROR, "invalid line[%s]: '%s'", line, c);
1974 NWRAP_LOG(NWRAP_LOG_TRACE, "gecos[%s]", pw->pw_gecos);
1979 NWRAP_LOG(NWRAP_LOG_ERROR, "'%s'", c);
1987 NWRAP_LOG(NWRAP_LOG_TRACE, "dir[%s]", pw->pw_dir);
1991 NWRAP_LOG(NWRAP_LOG_TRACE, "shell[%s]", pw->pw_shell);
1993 NWRAP_LOG(NWRAP_LOG_DEBUG,
1994 "Added user[%s:%s:%u:%u:%s:%s:%s]",
1995 pw->pw_name, pw->pw_passwd,
1996 pw->pw_uid, pw->pw_gid,
1997 pw->pw_gecos, pw->pw_dir, pw->pw_shell);
2003 static void nwrap_pw_unload(struct nwrap_cache *nwrap)
2005 struct nwrap_pw *nwrap_pw;
2006 nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
2008 SAFE_FREE(nwrap_pw->list);
2013 static int nwrap_pw_copy_r(const struct passwd *src, struct passwd *dst,
2014 char *buf, size_t buflen, struct passwd **dstp)
2020 first = src->pw_name;
2022 last = src->pw_shell;
2023 while (*last) last++;
2025 ofs = PTR_DIFF(last + 1, first);
2027 if (ofs > (off_t) buflen) {
2031 memcpy(buf, first, ofs);
2033 ofs = PTR_DIFF(src->pw_name, first);
2034 dst->pw_name = buf + ofs;
2035 ofs = PTR_DIFF(src->pw_passwd, first);
2036 dst->pw_passwd = buf + ofs;
2037 dst->pw_uid = src->pw_uid;
2038 dst->pw_gid = src->pw_gid;
2039 ofs = PTR_DIFF(src->pw_gecos, first);
2040 dst->pw_gecos = buf + ofs;
2041 ofs = PTR_DIFF(src->pw_dir, first);
2042 dst->pw_dir = buf + ofs;
2043 ofs = PTR_DIFF(src->pw_shell, first);
2044 dst->pw_shell = buf + ofs;
2053 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
2054 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line)
2056 struct nwrap_sp *nwrap_sp;
2063 nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2065 list_size = sizeof(*nwrap_sp->list) * (nwrap_sp->num+1);
2066 sp = (struct spwd *)realloc(nwrap_sp->list, list_size);
2068 NWRAP_LOG(NWRAP_LOG_ERROR,
2069 "realloc(%u) failed",
2070 (unsigned)list_size);
2073 nwrap_sp->list = sp;
2075 sp = &nwrap_sp->list[nwrap_sp->num];
2082 NWRAP_LOG(NWRAP_LOG_ERROR,
2083 "name -- Invalid line[%s]: '%s'",
2093 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", sp->sp_namp);
2098 NWRAP_LOG(NWRAP_LOG_ERROR,
2099 "pwd -- Invalid line[%s]: '%s'",
2116 NWRAP_LOG(NWRAP_LOG_ERROR,
2117 "lstchg -- Invalid line[%s]: '%s'",
2124 sp->sp_lstchg = strtol(c, &e, 10);
2126 NWRAP_LOG(NWRAP_LOG_ERROR,
2127 "lstchg -- Invalid line[%s]: '%s' - %s",
2128 line, c, strerror(errno));
2132 NWRAP_LOG(NWRAP_LOG_ERROR,
2133 "lstchg -- Invalid line[%s]: '%s' - %s",
2134 line, c, strerror(errno));
2138 NWRAP_LOG(NWRAP_LOG_ERROR,
2139 "lstchg -- Invalid line[%s]: '%s' - %s",
2140 line, c, strerror(errno));
2153 NWRAP_LOG(NWRAP_LOG_ERROR,
2154 "min -- Invalid line[%s]: '%s'",
2161 sp->sp_min = strtol(c, &e, 10);
2163 NWRAP_LOG(NWRAP_LOG_ERROR,
2164 "min -- Invalid line[%s]: '%s' - %s",
2165 line, c, strerror(errno));
2169 NWRAP_LOG(NWRAP_LOG_ERROR,
2170 "min -- Invalid line[%s]: '%s' - %s",
2171 line, c, strerror(errno));
2175 NWRAP_LOG(NWRAP_LOG_ERROR,
2176 "min -- Invalid line[%s]: '%s' - %s",
2177 line, c, strerror(errno));
2190 NWRAP_LOG(NWRAP_LOG_ERROR,
2191 "max -- Invalid line[%s]: '%s'",
2198 sp->sp_max = strtol(c, &e, 10);
2200 NWRAP_LOG(NWRAP_LOG_ERROR,
2201 "max -- Invalid line[%s]: '%s' - %s",
2202 line, c, strerror(errno));
2206 NWRAP_LOG(NWRAP_LOG_ERROR,
2207 "max -- Invalid line[%s]: '%s' - %s",
2208 line, c, strerror(errno));
2212 NWRAP_LOG(NWRAP_LOG_ERROR,
2213 "max -- Invalid line[%s]: '%s' - %s",
2214 line, c, strerror(errno));
2227 NWRAP_LOG(NWRAP_LOG_ERROR,
2228 "warn -- Invalid line[%s]: '%s'",
2235 sp->sp_warn = strtol(c, &e, 10);
2237 NWRAP_LOG(NWRAP_LOG_ERROR,
2238 "warn -- Invalid line[%s]: '%s' - %s",
2239 line, c, strerror(errno));
2243 NWRAP_LOG(NWRAP_LOG_ERROR,
2244 "warn -- Invalid line[%s]: '%s' - %s",
2245 line, c, strerror(errno));
2249 NWRAP_LOG(NWRAP_LOG_ERROR,
2250 "warn -- Invalid line[%s]: '%s' - %s",
2251 line, c, strerror(errno));
2264 NWRAP_LOG(NWRAP_LOG_ERROR,
2265 "inact -- Invalid line[%s]: '%s'",
2272 sp->sp_inact = strtol(c, &e, 10);
2274 NWRAP_LOG(NWRAP_LOG_ERROR,
2275 "inact -- Invalid line[%s]: '%s' - %s",
2276 line, c, strerror(errno));
2280 NWRAP_LOG(NWRAP_LOG_ERROR,
2281 "inact -- Invalid line[%s]: '%s' - %s",
2282 line, c, strerror(errno));
2286 NWRAP_LOG(NWRAP_LOG_ERROR,
2287 "inact -- Invalid line[%s]: '%s' - %s",
2288 line, c, strerror(errno));
2301 NWRAP_LOG(NWRAP_LOG_ERROR,
2302 "expire -- Invalid line[%s]: '%s'",
2309 sp->sp_expire = strtol(c, &e, 10);
2311 NWRAP_LOG(NWRAP_LOG_ERROR,
2312 "expire -- Invalid line[%s]: '%s' - %s",
2313 line, c, strerror(errno));
2317 NWRAP_LOG(NWRAP_LOG_ERROR,
2318 "expire -- Invalid line[%s]: '%s' - %s",
2319 line, c, strerror(errno));
2323 NWRAP_LOG(NWRAP_LOG_ERROR,
2324 "expire -- Invalid line[%s]: '%s' - %s",
2325 line, c, strerror(errno));
2335 static void nwrap_sp_unload(struct nwrap_cache *nwrap)
2337 struct nwrap_sp *nwrap_sp;
2338 nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2340 SAFE_FREE(nwrap_sp->list);
2344 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
2347 * the caller has to call nwrap_unload() on failure
2349 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line)
2351 struct nwrap_gr *nwrap_gr;
2359 nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2361 list_size = sizeof(*nwrap_gr->list) * (nwrap_gr->num+1);
2362 gr = (struct group *)realloc(nwrap_gr->list, list_size);
2364 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc failed");
2367 nwrap_gr->list = gr;
2369 gr = &nwrap_gr->list[nwrap_gr->num];
2376 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2384 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]", gr->gr_name);
2389 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2397 NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]", gr->gr_passwd);
2402 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2408 gr->gr_gid = (gid_t)strtoul(c, &e, 10);
2410 NWRAP_LOG(NWRAP_LOG_ERROR,
2411 "Invalid line[%s]: '%s' - %s",
2412 line, c, strerror(errno));
2416 NWRAP_LOG(NWRAP_LOG_ERROR,
2417 "Invalid line[%s]: '%s' - %s",
2418 line, c, strerror(errno));
2422 NWRAP_LOG(NWRAP_LOG_ERROR,
2423 "Invalid line[%s]: '%s' - %s",
2424 line, c, strerror(errno));
2429 NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]", gr->gr_gid);
2432 gr->gr_mem = (char **)malloc(sizeof(char *));
2434 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
2437 gr->gr_mem[0] = NULL;
2439 for(nummem=0; p; nummem++) {
2449 if (strlen(c) == 0) {
2453 m_size = sizeof(char *) * (nummem+2);
2454 m = (char **)realloc(gr->gr_mem, m_size);
2456 NWRAP_LOG(NWRAP_LOG_ERROR,
2457 "realloc(%zd) failed",
2462 gr->gr_mem[nummem] = c;
2463 gr->gr_mem[nummem+1] = NULL;
2465 NWRAP_LOG(NWRAP_LOG_TRACE,
2467 nummem, gr->gr_mem[nummem]);
2470 NWRAP_LOG(NWRAP_LOG_DEBUG,
2471 "Added group[%s:%s:%u:] with %u members",
2472 gr->gr_name, gr->gr_passwd, gr->gr_gid, nummem);
2478 static void nwrap_gr_unload(struct nwrap_cache *nwrap)
2481 struct nwrap_gr *nwrap_gr;
2482 nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2484 if (nwrap_gr->list) {
2485 for (i=0; i < nwrap_gr->num; i++) {
2486 SAFE_FREE(nwrap_gr->list[i].gr_mem);
2488 SAFE_FREE(nwrap_gr->list);
2495 static int nwrap_gr_copy_r(const struct group *src, struct group *dst,
2496 char *buf, size_t buflen, struct group **dstp)
2506 first = src->gr_name;
2508 lastm = src->gr_mem;
2515 last = src->gr_passwd;
2517 while (*last) last++;
2519 ofsb = PTR_DIFF(last + 1, first);
2520 ofsm = PTR_DIFF(lastm + 1, src->gr_mem);
2522 if ((ofsb + ofsm) > (off_t) buflen) {
2526 memcpy(buf, first, ofsb);
2527 memcpy(buf + ofsb, src->gr_mem, ofsm);
2529 ofs = PTR_DIFF(src->gr_name, first);
2530 dst->gr_name = buf + ofs;
2531 ofs = PTR_DIFF(src->gr_passwd, first);
2532 dst->gr_passwd = buf + ofs;
2533 dst->gr_gid = src->gr_gid;
2535 dst->gr_mem = (char **)(buf + ofsb);
2536 for (i=0; src->gr_mem[i]; i++) {
2537 ofs = PTR_DIFF(src->gr_mem[i], first);
2538 dst->gr_mem[i] = buf + ofs;
2548 static struct nwrap_entlist *nwrap_entlist_init(struct nwrap_entdata *ed)
2550 struct nwrap_entlist *el;
2553 NWRAP_LOG(NWRAP_LOG_ERROR,
2554 "entry is NULL, can't create list item");
2558 el = (struct nwrap_entlist *)malloc(sizeof(struct nwrap_entlist));
2560 NWRAP_LOG(NWRAP_LOG_ERROR, "malloc failed");
2570 static bool nwrap_add_ai(char *const ip_addr, struct nwrap_entdata *const ed)
2574 struct nwrap_entlist *el;
2576 if (ip_addr == NULL) {
2577 NWRAP_LOG(NWRAP_LOG_ERROR, "ip_addr NULL - can't add");
2581 el = nwrap_entlist_init(ed);
2589 p = hsearch(e, ENTER);
2591 NWRAP_LOG(NWRAP_LOG_ERROR, "Hash table is full");
2599 static bool nwrap_add_hname_add_new(char *const h_name,
2600 struct nwrap_entdata *const ed)
2604 struct nwrap_entlist *el;
2606 if (h_name == NULL) {
2607 NWRAP_LOG(NWRAP_LOG_ERROR, "h_name NULL - can't add");
2611 el = nwrap_entlist_init(ed);
2617 e.data = (void *)el;
2619 p = hsearch(e, ENTER);
2621 NWRAP_LOG(NWRAP_LOG_ERROR, "Hash table is full!");
2628 static bool nwrap_add_hname_add_to_existing(struct nwrap_entdata *const ed,
2629 struct nwrap_entlist *const el)
2631 struct nwrap_entlist *cursor;
2632 struct nwrap_entlist *el_new;
2635 NWRAP_LOG(NWRAP_LOG_ERROR, "list is NULL, can not add");
2639 el_new = nwrap_entlist_init(ed);
2640 if (el_new == NULL) {
2644 for (cursor = el; cursor->next != NULL; cursor = cursor->next)
2646 if (cursor->ed == ed) {
2652 if (cursor->ed == ed) {
2657 cursor->next = el_new;
2661 static bool nwrap_add_hname_alias(char *const h_name_a,
2662 struct nwrap_entdata *const ed)
2670 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2671 p = hsearch(e, FIND);
2673 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name_a);
2674 ok = nwrap_add_hname_add_new(h_name_a, ed);
2676 struct nwrap_entlist *el = (struct nwrap_entlist *)p->data;
2678 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name_a);
2679 ok = nwrap_add_hname_add_to_existing(ed, el);
2685 static bool nwrap_add_hname(struct nwrap_entdata *const ed)
2687 char *const h_name = (char *const)(ed->ht.h_name);
2695 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2696 p = hsearch(e, FIND);
2698 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name);
2699 ok = nwrap_add_hname_add_new(h_name, ed);
2701 struct nwrap_entlist *el = (struct nwrap_entlist *)p->data;
2703 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name);
2704 ok = nwrap_add_hname_add_to_existing(ed, el);
2711 if (ed->ht.h_aliases == NULL) {
2715 /* Itemize aliases */
2716 for (i = 0; ed->ht.h_aliases[i] != NULL; ++i) {
2719 h_name_alias = ed->ht.h_aliases[i];
2721 NWRAP_LOG(NWRAP_LOG_DEBUG, "Add alias: %s", h_name_alias);
2723 if (!nwrap_add_hname_alias(h_name_alias, ed)) {
2724 NWRAP_LOG(NWRAP_LOG_ERROR,
2725 "Unable to add alias: %s", h_name_alias);
2733 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line)
2735 struct nwrap_he *nwrap_he = (struct nwrap_he *)nwrap->private_data;
2736 bool do_aliases = true;
2737 ssize_t aliases_count = 0;
2745 struct nwrap_entdata *ed = (struct nwrap_entdata *)
2746 malloc(sizeof(struct nwrap_entdata));
2748 NWRAP_LOG(NWRAP_LOG_ERROR,
2749 "Unable to allocate memory for nwrap_entdata");
2760 /* Walk to first char */
2761 for (p = i; *p != '.' && *p != ':' && !isxdigit((int) *p); p++) {
2763 NWRAP_LOG(NWRAP_LOG_ERROR,
2764 "Invalid line[%s]: '%s'",
2771 for (i = p; !isspace((int)*p); p++) {
2773 NWRAP_LOG(NWRAP_LOG_ERROR,
2774 "Invalid line[%s]: '%s'",
2783 if (inet_pton(AF_INET, i, ed->addr.host_addr)) {
2784 ed->ht.h_addrtype = AF_INET;
2785 ed->ht.h_length = 4;
2787 } else if (inet_pton(AF_INET6, i, ed->addr.host_addr)) {
2788 ed->ht.h_addrtype = AF_INET6;
2789 ed->ht.h_length = 16;
2792 NWRAP_LOG(NWRAP_LOG_ERROR,
2793 "Invalid line[%s]: '%s'",
2801 nwrap_vector_add_item(&(ed->nwrap_addrdata),
2802 (void *const)ed->addr.host_addr);
2803 ed->ht.h_addr_list = nwrap_vector_head(&ed->nwrap_addrdata);
2811 /* Walk to first char */
2812 for (n = p; *p != '_' && !isalnum((int) *p); p++) {
2814 NWRAP_LOG(NWRAP_LOG_ERROR,
2815 "Invalid line[%s]: '%s'",
2823 for (n = p; !isspace((int)*p); p++) {
2832 /* Convert to lowercase. This operate on same memory region */
2836 /* glib's getent always dereferences he->h_aliases */
2837 ed->ht.h_aliases = malloc(sizeof(char *));
2838 if (ed->ht.h_aliases == NULL) {
2842 ed->ht.h_aliases[0] = NULL;
2847 while (do_aliases) {
2853 /* Walk to first char */
2854 for (a = p; *p != '_' && !isalnum((int) *p); p++) {
2860 /* Only trailing spaces are left */
2865 for (a = p; !isspace((int)*p); p++) {
2874 aliases = realloc(ed->ht.h_aliases, sizeof(char *) * (aliases_count + 2));
2875 if (aliases == NULL) {
2879 ed->ht.h_aliases = aliases;
2882 aliases[aliases_count] = a;
2883 aliases[aliases_count + 1] = NULL;
2888 nwrap_vector_add_item(&(nwrap_he->entdata), (void *const)ed);
2890 ed->aliases_count = aliases_count;
2891 /* Inventarize item */
2892 ok = nwrap_add_hname(ed);
2897 ok = nwrap_add_ai(ip, ed);
2906 static void nwrap_he_unload(struct nwrap_cache *nwrap)
2908 struct nwrap_he *nwrap_he =
2909 (struct nwrap_he *)nwrap->private_data;
2910 struct nwrap_entdata *ed;
2913 nwrap_vector_foreach (ed, nwrap_he->entdata, i)
2915 SAFE_FREE(ed->nwrap_addrdata.items);
2916 SAFE_FREE(ed->ht.h_aliases);
2919 SAFE_FREE(nwrap_he->entdata.items);
2920 nwrap_he->entdata.count = nwrap_he->entdata.capacity = 0;
2927 /* user functions */
2928 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
2934 (void) b; /* unused */
2936 NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
2938 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
2940 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
2944 for (i=0; i<nwrap_pw_global.num; i++) {
2945 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
2946 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
2947 return &nwrap_pw_global.list[i];
2949 NWRAP_LOG(NWRAP_LOG_DEBUG,
2950 "user[%s] does not match [%s]",
2952 nwrap_pw_global.list[i].pw_name);
2955 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
2961 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
2962 const char *name, struct passwd *pwdst,
2963 char *buf, size_t buflen, struct passwd **pwdstp)
2967 pw = nwrap_files_getpwnam(b, name);
2975 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2978 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
2984 (void) b; /* unused */
2986 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
2988 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
2992 for (i=0; i<nwrap_pw_global.num; i++) {
2993 if (nwrap_pw_global.list[i].pw_uid == uid) {
2994 NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] found", uid);
2995 return &nwrap_pw_global.list[i];
2997 NWRAP_LOG(NWRAP_LOG_DEBUG,
2998 "uid[%u] does not match [%u]",
3000 nwrap_pw_global.list[i].pw_uid);
3003 NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] not found\n", uid);
3009 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
3010 uid_t uid, struct passwd *pwdst,
3011 char *buf, size_t buflen, struct passwd **pwdstp)
3015 pw = nwrap_files_getpwuid(b, uid);
3023 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3026 /* user enum functions */
3027 static void nwrap_files_setpwent(struct nwrap_backend *b)
3029 (void) b; /* unused */
3031 nwrap_pw_global.idx = 0;
3034 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
3038 (void) b; /* unused */
3040 if (nwrap_pw_global.idx == 0) {
3042 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
3044 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
3049 if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
3054 pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
3056 NWRAP_LOG(NWRAP_LOG_DEBUG,
3057 "return user[%s] uid[%u]",
3058 pw->pw_name, pw->pw_uid);
3063 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
3064 struct passwd *pwdst, char *buf,
3065 size_t buflen, struct passwd **pwdstp)
3069 pw = nwrap_files_getpwent(b);
3077 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3080 static void nwrap_files_endpwent(struct nwrap_backend *b)
3082 (void) b; /* unused */
3084 nwrap_pw_global.idx = 0;
3089 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
3091 #ifdef HAVE_SETSPENT
3092 static void nwrap_files_setspent(void)
3094 nwrap_sp_global.idx = 0;
3097 static struct spwd *nwrap_files_getspent(void)
3101 if (nwrap_sp_global.idx == 0) {
3104 ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
3106 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
3111 if (nwrap_sp_global.idx >= nwrap_sp_global.num) {
3116 sp = &nwrap_sp_global.list[nwrap_sp_global.idx++];
3118 NWRAP_LOG(NWRAP_LOG_DEBUG,
3125 static void nwrap_files_endspent(void)
3127 nwrap_sp_global.idx = 0;
3129 #endif /* HAVE_SETSPENT */
3131 static struct spwd *nwrap_files_getspnam(const char *name)
3136 NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
3138 ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
3140 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
3144 for (i=0; i<nwrap_sp_global.num; i++) {
3145 if (strcmp(nwrap_sp_global.list[i].sp_namp, name) == 0) {
3146 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
3147 return &nwrap_sp_global.list[i];
3149 NWRAP_LOG(NWRAP_LOG_DEBUG,
3150 "user[%s] does not match [%s]",
3152 nwrap_sp_global.list[i].sp_namp);
3155 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
3160 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
3162 /* misc functions */
3163 static int nwrap_files_initgroups(struct nwrap_backend *b,
3172 groups = (gid_t *)malloc(size * sizeof(gid_t));
3173 if (groups == NULL) {
3174 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
3180 nwrap_files_setgrent(b);
3181 while ((grp = nwrap_files_getgrent(b)) != NULL) {
3184 NWRAP_LOG(NWRAP_LOG_DEBUG,
3185 "Inspecting %s for group membership",
3188 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
3189 if (group != grp->gr_gid &&
3190 (strcmp(user, grp->gr_mem[i]) == 0)) {
3191 NWRAP_LOG(NWRAP_LOG_DEBUG,
3192 "%s is member of %s",
3196 groups = (gid_t *)realloc(groups,
3197 (size + 1) * sizeof(gid_t));
3198 if (groups == NULL) {
3199 NWRAP_LOG(NWRAP_LOG_ERROR,
3205 groups[size] = grp->gr_gid;
3211 nwrap_files_endgrent(b);
3213 NWRAP_LOG(NWRAP_LOG_DEBUG,
3214 "%s is member of %d groups",
3217 /* This really only works if uid_wrapper is loaded */
3218 rc = setgroups(size, groups);
3225 /* group functions */
3226 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
3232 (void) b; /* unused */
3234 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3236 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3240 for (i=0; i<nwrap_gr_global.num; i++) {
3241 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
3242 NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] found", name);
3243 return &nwrap_gr_global.list[i];
3245 NWRAP_LOG(NWRAP_LOG_DEBUG,
3246 "group[%s] does not match [%s]",
3248 nwrap_gr_global.list[i].gr_name);
3251 NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] not found", name);
3257 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
3258 const char *name, struct group *grdst,
3259 char *buf, size_t buflen, struct group **grdstp)
3263 gr = nwrap_files_getgrnam(b, name);
3271 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3274 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
3280 (void) b; /* unused */
3282 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3284 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3288 for (i=0; i<nwrap_gr_global.num; i++) {
3289 if (nwrap_gr_global.list[i].gr_gid == gid) {
3290 NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] found", gid);
3291 return &nwrap_gr_global.list[i];
3293 NWRAP_LOG(NWRAP_LOG_DEBUG,
3294 "gid[%u] does not match [%u]",
3296 nwrap_gr_global.list[i].gr_gid);
3299 NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] not found", gid);
3305 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
3306 gid_t gid, struct group *grdst,
3307 char *buf, size_t buflen, struct group **grdstp)
3311 gr = nwrap_files_getgrgid(b, gid);
3319 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3322 /* group enum functions */
3323 static void nwrap_files_setgrent(struct nwrap_backend *b)
3325 (void) b; /* unused */
3327 nwrap_gr_global.idx = 0;
3330 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
3334 (void) b; /* unused */
3336 if (nwrap_gr_global.idx == 0) {
3339 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3341 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3346 if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
3351 gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
3353 NWRAP_LOG(NWRAP_LOG_DEBUG,
3354 "return group[%s] gid[%u]",
3355 gr->gr_name, gr->gr_gid);
3360 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
3361 struct group *grdst, char *buf,
3362 size_t buflen, struct group **grdstp)
3366 gr = nwrap_files_getgrent(b);
3374 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3377 static void nwrap_files_endgrent(struct nwrap_backend *b)
3379 (void) b; /* unused */
3381 nwrap_gr_global.idx = 0;
3384 /* hosts functions */
3385 static int nwrap_files_gethostbyname(const char *name, int af,
3386 struct hostent *result,
3387 struct nwrap_vector *addr_list)
3389 struct nwrap_entlist *el;
3394 char canon_name[DNS_NAME_MAX] = { 0 };
3396 bool he_found = false;
3399 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3401 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3405 name_len = strlen(name);
3406 if (name_len < sizeof(canon_name) && name[name_len - 1] == '.') {
3407 strncpy(canon_name, name, name_len - 1);
3411 if (!str_tolower_copy(&h_name_lower, name)) {
3412 NWRAP_LOG(NWRAP_LOG_DEBUG,
3413 "Out of memory while converting to lower case");
3417 /* Look at hash table for element */
3418 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3419 e.key = h_name_lower;
3421 e_p = hsearch(e, FIND);
3423 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3424 SAFE_FREE(h_name_lower);
3427 SAFE_FREE(h_name_lower);
3429 /* Always cleanup vector and results */
3430 if (!nwrap_vector_is_initialized(addr_list)) {
3431 if (!nwrap_vector_init(addr_list)) {
3432 NWRAP_LOG(NWRAP_LOG_DEBUG,
3433 "Unable to initialize memory for addr_list vector");
3437 /* When vector is initialized data are valid no more.
3438 * Quick way how to free vector is: */
3439 addr_list->count = 0;
3442 /* Iterate through results */
3443 for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
3447 /* Filter by address familiy if provided */
3448 if (af != AF_UNSPEC && he->h_addrtype != af) {
3454 * glibc doesn't return ipv6 addresses when AF_UNSPEC is used
3456 if (af == AF_UNSPEC && he->h_addrtype != AF_INET) {
3461 memcpy(result, he, sizeof(struct hostent));
3462 NWRAP_LOG(NWRAP_LOG_DEBUG,
3463 "Name found. Returning record for %s",
3467 nwrap_vector_merge(addr_list, &el->ed->nwrap_addrdata);
3468 result->h_addr_list = nwrap_vector_head(addr_list);
3474 NWRAP_LOG(NWRAP_LOG_DEBUG,
3475 "Name found in database. No records matches type.");
3482 #ifdef HAVE_GETHOSTBYNAME_R
3483 static int nwrap_gethostbyname_r(const char *name,
3484 struct hostent *ret,
3485 char *buf, size_t buflen,
3486 struct hostent **result, int *h_errnop)
3488 struct nwrap_vector *addr_list = malloc(sizeof(struct nwrap_vector));
3491 if (addr_list == NULL) {
3492 NWRAP_LOG(NWRAP_LOG_ERROR,
3493 "Unable to allocate memory for address list");
3498 ZERO_STRUCTP(addr_list);
3500 rc = nwrap_files_gethostbyname(name, AF_UNSPEC, ret, addr_list);
3502 *h_errnop = h_errno;
3503 if (addr_list->items != NULL) {
3504 free(addr_list->items);
3506 SAFE_FREE(addr_list);
3511 if (buflen < (addr_list->count * sizeof(void *))) {
3512 SAFE_FREE(addr_list->items);
3513 SAFE_FREE(addr_list);
3517 /* Copy all to user provided buffer and change
3518 * pointers in returned structure.
3519 * +1 is for ending NULL pointer. */
3520 memcpy(buf, addr_list->items, (addr_list->count + 1) * sizeof(void *));
3522 free(addr_list->items);
3525 ret->h_addr_list = (char **)buf;
3530 int gethostbyname_r(const char *name,
3531 struct hostent *ret,
3532 char *buf, size_t buflen,
3533 struct hostent **result, int *h_errnop)
3535 if (!nss_wrapper_hosts_enabled()) {
3536 return libc_gethostbyname_r(name,
3544 return nwrap_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
3548 static int nwrap_files_getaddrinfo(const char *name,
3549 unsigned short port,
3550 const struct addrinfo *hints,
3551 struct addrinfo **ai,
3552 struct addrinfo **ai_tail)
3554 struct nwrap_entlist *el;
3556 struct addrinfo *_ai = NULL;
3557 struct addrinfo *ai_head = NULL;
3558 struct addrinfo *ai_prev = NULL;
3561 char canon_name[DNS_NAME_MAX] = { 0 };
3562 bool skip_canonname = false;
3568 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3570 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3574 name_len = strlen(name);
3575 if (name_len < DNS_NAME_MAX && name[name_len - 1] == '.') {
3576 strncpy(canon_name, name, name_len - 1);
3580 if (!str_tolower_copy(&h_name_lower, name)) {
3581 NWRAP_LOG(NWRAP_LOG_DEBUG,
3582 "Out of memory while converting to lower case");
3586 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3587 e.key = h_name_lower;
3589 e_p = hsearch(e, FIND);
3591 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3592 SAFE_FREE(h_name_lower);
3596 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name: %s found.", h_name_lower);
3597 SAFE_FREE(h_name_lower);
3600 for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
3606 if (hints->ai_family != AF_UNSPEC &&
3607 he->h_addrtype != hints->ai_family)
3609 NWRAP_LOG(NWRAP_LOG_DEBUG,
3610 "Entry found but with wrong AF - "
3611 "remembering EAI_ADDRINFO.");
3612 rc = EAI_ADDRFAMILY;
3616 /* Function allocates memory and returns it in ai. */
3617 rc2 = nwrap_convert_he_ai(he,
3623 NWRAP_LOG(NWRAP_LOG_ERROR, "Error converting he to ai");
3626 skip_canonname = true;
3628 if (ai_head == NULL) {
3631 if (ai_prev != NULL) {
3632 ai_prev->ai_next = _ai;
3637 if (ai_head != NULL) {
3647 static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
3648 socklen_t len, int type)
3651 char ip[NWRAP_INET_ADDRSTRLEN] = {0};
3652 struct nwrap_entdata *ed;
3657 (void) len; /* unused */
3659 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3661 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3665 a = inet_ntop(type, addr, ip, sizeof(ip));
3671 nwrap_vector_foreach(ed, nwrap_he_global.entdata, i)
3674 if (he->h_addrtype != type) {
3678 if (memcmp(addr, he->h_addr_list[0], he->h_length) == 0) {
3687 #ifdef HAVE_GETHOSTBYADDR_R
3688 static int nwrap_gethostbyaddr_r(const void *addr, socklen_t len, int type,
3689 struct hostent *ret,
3690 char *buf, size_t buflen,
3691 struct hostent **result, int *h_errnop)
3693 *result = nwrap_files_gethostbyaddr(addr, len, type);
3694 if (*result != NULL) {
3695 memset(buf, '\0', buflen);
3699 *h_errnop = h_errno;
3704 int gethostbyaddr_r(const void *addr, socklen_t len, int type,
3705 struct hostent *ret,
3706 char *buf, size_t buflen,
3707 struct hostent **result, int *h_errnop)
3709 if (!nss_wrapper_hosts_enabled()) {
3710 return libc_gethostbyaddr_r(addr,
3720 return nwrap_gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
3724 /* hosts enum functions */
3725 static void nwrap_files_sethostent(void)
3727 nwrap_he_global.idx = 0;
3730 static struct hostent *nwrap_files_gethostent(void)
3734 if (nwrap_he_global.idx == 0) {
3737 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3739 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading hosts file");
3744 if (nwrap_he_global.idx >= nwrap_he_global.num) {
3749 he = &((struct nwrap_entdata *)nwrap_he_global.entdata.items[nwrap_he_global.idx++])->ht;
3751 NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
3756 static void nwrap_files_endhostent(void)
3758 nwrap_he_global.idx = 0;
3766 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
3769 static struct passwd pwd;
3770 static char buf[1000];
3773 if (!b->fns->_nss_getpwnam_r) {
3777 status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
3778 if (status == NSS_STATUS_NOTFOUND) {
3781 if (status != NSS_STATUS_SUCCESS) {
3788 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
3789 const char *name, struct passwd *pwdst,
3790 char *buf, size_t buflen, struct passwd **pwdstp)
3794 (void) b; /* unused */
3795 (void) pwdst; /* unused */
3796 (void) pwdstp; /* unused */
3798 if (!b->fns->_nss_getpwnam_r) {
3799 return NSS_STATUS_NOTFOUND;
3802 ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
3804 case NSS_STATUS_SUCCESS:
3806 case NSS_STATUS_NOTFOUND:
3811 case NSS_STATUS_TRYAGAIN:
3824 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
3827 static struct passwd pwd;
3828 static char buf[1000];
3831 if (!b->fns->_nss_getpwuid_r) {
3835 status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
3836 if (status == NSS_STATUS_NOTFOUND) {
3839 if (status != NSS_STATUS_SUCCESS) {
3845 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
3846 uid_t uid, struct passwd *pwdst,
3847 char *buf, size_t buflen, struct passwd **pwdstp)
3851 (void) pwdstp; /* unused */
3853 if (!b->fns->_nss_getpwuid_r) {
3857 ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
3859 case NSS_STATUS_SUCCESS:
3861 case NSS_STATUS_NOTFOUND:
3866 case NSS_STATUS_TRYAGAIN:
3879 static void nwrap_module_setpwent(struct nwrap_backend *b)
3881 if (!b->fns->_nss_setpwent) {
3885 b->fns->_nss_setpwent();
3888 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
3890 static struct passwd pwd;
3891 static char buf[1000];
3894 if (!b->fns->_nss_getpwent_r) {
3898 status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
3899 if (status == NSS_STATUS_NOTFOUND) {
3902 if (status != NSS_STATUS_SUCCESS) {
3908 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
3909 struct passwd *pwdst, char *buf,
3910 size_t buflen, struct passwd **pwdstp)
3914 (void) pwdstp; /* unused */
3916 if (!b->fns->_nss_getpwent_r) {
3920 ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
3922 case NSS_STATUS_SUCCESS:
3924 case NSS_STATUS_NOTFOUND:
3929 case NSS_STATUS_TRYAGAIN:
3942 static void nwrap_module_endpwent(struct nwrap_backend *b)
3944 if (!b->fns->_nss_endpwent) {
3948 b->fns->_nss_endpwent();
3951 static int nwrap_module_initgroups(struct nwrap_backend *b,
3952 const char *user, gid_t group)
3958 if (!b->fns->_nss_initgroups) {
3959 return NSS_STATUS_UNAVAIL;
3962 return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
3965 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
3968 static struct group grp;
3970 static int buflen = 1000;
3973 if (!b->fns->_nss_getgrnam_r) {
3978 buf = (char *)malloc(buflen);
3981 status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
3982 if (status == NSS_STATUS_TRYAGAIN) {
3984 buf = (char *)realloc(buf, buflen);
3990 if (status == NSS_STATUS_NOTFOUND) {
3994 if (status != NSS_STATUS_SUCCESS) {
4001 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
4002 const char *name, struct group *grdst,
4003 char *buf, size_t buflen, struct group **grdstp)
4007 (void) grdstp; /* unused */
4009 if (!b->fns->_nss_getgrnam_r) {
4013 ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
4015 case NSS_STATUS_SUCCESS:
4017 case NSS_STATUS_NOTFOUND:
4022 case NSS_STATUS_TRYAGAIN:
4035 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
4038 static struct group grp;
4040 static int buflen = 1000;
4043 if (!b->fns->_nss_getgrgid_r) {
4048 buf = (char *)malloc(buflen);
4052 status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
4053 if (status == NSS_STATUS_TRYAGAIN) {
4055 buf = (char *)realloc(buf, buflen);
4061 if (status == NSS_STATUS_NOTFOUND) {
4065 if (status != NSS_STATUS_SUCCESS) {
4072 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
4073 gid_t gid, struct group *grdst,
4074 char *buf, size_t buflen, struct group **grdstp)
4078 (void) grdstp; /* unused */
4080 if (!b->fns->_nss_getgrgid_r) {
4084 ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
4086 case NSS_STATUS_SUCCESS:
4088 case NSS_STATUS_NOTFOUND:
4093 case NSS_STATUS_TRYAGAIN:
4106 static void nwrap_module_setgrent(struct nwrap_backend *b)
4108 if (!b->fns->_nss_setgrent) {
4112 b->fns->_nss_setgrent();
4115 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
4117 static struct group grp;
4119 static int buflen = 1024;
4122 if (!b->fns->_nss_getgrent_r) {
4127 buf = (char *)malloc(buflen);
4131 status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
4132 if (status == NSS_STATUS_TRYAGAIN) {
4134 buf = (char *)realloc(buf, buflen);
4140 if (status == NSS_STATUS_NOTFOUND) {
4144 if (status != NSS_STATUS_SUCCESS) {
4151 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
4152 struct group *grdst, char *buf,
4153 size_t buflen, struct group **grdstp)
4157 (void) grdstp; /* unused */
4159 if (!b->fns->_nss_getgrent_r) {
4163 ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
4165 case NSS_STATUS_SUCCESS:
4167 case NSS_STATUS_NOTFOUND:
4172 case NSS_STATUS_TRYAGAIN:
4185 static void nwrap_module_endgrent(struct nwrap_backend *b)
4187 if (!b->fns->_nss_endgrent) {
4191 b->fns->_nss_endgrent();
4194 /****************************************************************************
4196 ***************************************************************************/
4198 static struct passwd *nwrap_getpwnam(const char *name)
4203 for (i=0; i < nwrap_main_global->num_backends; i++) {
4204 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4205 pwd = b->ops->nw_getpwnam(b, name);
4214 struct passwd *getpwnam(const char *name)
4216 if (!nss_wrapper_enabled()) {
4217 return libc_getpwnam(name);
4220 return nwrap_getpwnam(name);
4223 /****************************************************************************
4225 ***************************************************************************/
4227 static int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
4228 char *buf, size_t buflen, struct passwd **pwdstp)
4232 for (i=0; i < nwrap_main_global->num_backends; i++) {
4233 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4234 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
4235 if (ret == ENOENT) {
4244 #ifdef HAVE_GETPWNAM_R
4245 # ifdef HAVE_SOLARIS_GETPWNAM_R
4246 int getpwnam_r(const char *name, struct passwd *pwdst,
4247 char *buf, int buflen, struct passwd **pwdstp)
4248 # else /* HAVE_SOLARIS_GETPWNAM_R */
4249 int getpwnam_r(const char *name, struct passwd *pwdst,
4250 char *buf, size_t buflen, struct passwd **pwdstp)
4251 # endif /* HAVE_SOLARIS_GETPWNAM_R */
4253 if (!nss_wrapper_enabled()) {
4254 return libc_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4257 return nwrap_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4261 /****************************************************************************
4263 ***************************************************************************/
4265 static struct passwd *nwrap_getpwuid(uid_t uid)
4270 for (i=0; i < nwrap_main_global->num_backends; i++) {
4271 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4272 pwd = b->ops->nw_getpwuid(b, uid);
4281 struct passwd *getpwuid(uid_t uid)
4283 if (!nss_wrapper_enabled()) {
4284 return libc_getpwuid(uid);
4287 return nwrap_getpwuid(uid);
4290 /****************************************************************************
4292 ***************************************************************************/
4294 static int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
4295 char *buf, size_t buflen, struct passwd **pwdstp)
4299 for (i=0; i < nwrap_main_global->num_backends; i++) {
4300 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4301 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
4302 if (ret == ENOENT) {
4311 #ifdef HAVE_SOLARIS_GETPWUID_R
4312 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4313 char *buf, int buflen, struct passwd **pwdstp)
4315 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4316 char *buf, size_t buflen, struct passwd **pwdstp)
4319 if (!nss_wrapper_enabled()) {
4320 return libc_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4323 return nwrap_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4326 /****************************************************************************
4328 ***************************************************************************/
4330 static void nwrap_setpwent(void)
4334 for (i=0; i < nwrap_main_global->num_backends; i++) {
4335 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4336 b->ops->nw_setpwent(b);
4342 if (!nss_wrapper_enabled()) {
4350 /****************************************************************************
4352 ***************************************************************************/
4354 static struct passwd *nwrap_getpwent(void)
4359 for (i=0; i < nwrap_main_global->num_backends; i++) {
4360 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4361 pwd = b->ops->nw_getpwent(b);
4370 struct passwd *getpwent(void)
4372 if (!nss_wrapper_enabled()) {
4373 return libc_getpwent();
4376 return nwrap_getpwent();
4379 /****************************************************************************
4381 ***************************************************************************/
4383 static int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
4384 size_t buflen, struct passwd **pwdstp)
4388 for (i=0; i < nwrap_main_global->num_backends; i++) {
4389 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4390 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
4391 if (ret == ENOENT) {
4400 #ifdef HAVE_SOLARIS_GETPWENT_R
4401 struct passwd *getpwent_r(struct passwd *pwdst, char *buf, int buflen)
4403 struct passwd *pwdstp = NULL;
4406 if (!nss_wrapper_enabled()) {
4407 return libc_getpwent_r(pwdst, buf, buflen);
4409 rc = nwrap_getpwent_r(pwdst, buf, buflen, &pwdstp);
4416 #else /* HAVE_SOLARIS_GETPWENT_R */
4417 int getpwent_r(struct passwd *pwdst, char *buf,
4418 size_t buflen, struct passwd **pwdstp)
4420 if (!nss_wrapper_enabled()) {
4421 return libc_getpwent_r(pwdst, buf, buflen, pwdstp);
4424 return nwrap_getpwent_r(pwdst, buf, buflen, pwdstp);
4426 #endif /* HAVE_SOLARIS_GETPWENT_R */
4428 /****************************************************************************
4430 ***************************************************************************/
4432 static void nwrap_endpwent(void)
4436 for (i=0; i < nwrap_main_global->num_backends; i++) {
4437 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4438 b->ops->nw_endpwent(b);
4444 if (!nss_wrapper_enabled()) {
4452 /****************************************************************************
4454 ***************************************************************************/
4456 static int nwrap_initgroups(const char *user, gid_t group)
4460 for (i=0; i < nwrap_main_global->num_backends; i++) {
4461 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4464 rc = b->ops->nw_initgroups(b, user, group);
4474 int initgroups(const char *user, gid_t group)
4476 if (!nss_wrapper_enabled()) {
4477 return libc_initgroups(user, group);
4480 return nwrap_initgroups(user, group);
4483 /****************************************************************************
4485 ***************************************************************************/
4487 static struct group *nwrap_getgrnam(const char *name)
4492 for (i=0; i < nwrap_main_global->num_backends; i++) {
4493 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4494 grp = b->ops->nw_getgrnam(b, name);
4503 struct group *getgrnam(const char *name)
4505 if (!nss_wrapper_enabled()) {
4506 return libc_getgrnam(name);
4509 return nwrap_getgrnam(name);
4512 /****************************************************************************
4514 ***************************************************************************/
4516 static int nwrap_getgrnam_r(const char *name, struct group *grdst,
4517 char *buf, size_t buflen, struct group **grdstp)
4521 for (i=0; i < nwrap_main_global->num_backends; i++) {
4522 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4523 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
4524 if (ret == ENOENT) {
4533 #ifdef HAVE_GETGRNAM_R
4534 # ifdef HAVE_SOLARIS_GETGRNAM_R
4535 int getgrnam_r(const char *name, struct group *grp,
4536 char *buf, int buflen, struct group **pgrp)
4537 # else /* HAVE_SOLARIS_GETGRNAM_R */
4538 int getgrnam_r(const char *name, struct group *grp,
4539 char *buf, size_t buflen, struct group **pgrp)
4540 # endif /* HAVE_SOLARIS_GETGRNAM_R */
4542 if (!nss_wrapper_enabled()) {
4543 return libc_getgrnam_r(name,
4550 return nwrap_getgrnam_r(name, grp, buf, buflen, pgrp);
4552 #endif /* HAVE_GETGRNAM_R */
4554 /****************************************************************************
4556 ***************************************************************************/
4558 static struct group *nwrap_getgrgid(gid_t gid)
4563 for (i=0; i < nwrap_main_global->num_backends; i++) {
4564 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4565 grp = b->ops->nw_getgrgid(b, gid);
4574 struct group *getgrgid(gid_t gid)
4576 if (!nss_wrapper_enabled()) {
4577 return libc_getgrgid(gid);
4580 return nwrap_getgrgid(gid);
4583 /****************************************************************************
4585 ***************************************************************************/
4587 static int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
4588 char *buf, size_t buflen, struct group **grdstp)
4592 for (i=0; i < nwrap_main_global->num_backends; i++) {
4593 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4594 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
4595 if (ret == ENOENT) {
4604 #ifdef HAVE_GETGRGID_R
4605 # ifdef HAVE_SOLARIS_GETGRGID_R
4606 int getgrgid_r(gid_t gid, struct group *grdst,
4607 char *buf, int buflen, struct group **grdstp)
4608 # else /* HAVE_SOLARIS_GETGRGID_R */
4609 int getgrgid_r(gid_t gid, struct group *grdst,
4610 char *buf, size_t buflen, struct group **grdstp)
4611 # endif /* HAVE_SOLARIS_GETGRGID_R */
4613 if (!nss_wrapper_enabled()) {
4614 return libc_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4617 return nwrap_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4621 /****************************************************************************
4623 ***************************************************************************/
4625 static void nwrap_setgrent(void)
4629 for (i=0; i < nwrap_main_global->num_backends; i++) {
4630 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4631 b->ops->nw_setgrent(b);
4635 #ifdef HAVE_BSD_SETGRENT
4641 if (!nss_wrapper_enabled()) {
4649 #ifdef HAVE_BSD_SETGRENT
4656 /****************************************************************************
4658 ***************************************************************************/
4660 static struct group *nwrap_getgrent(void)
4665 for (i=0; i < nwrap_main_global->num_backends; i++) {
4666 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4667 grp = b->ops->nw_getgrent(b);
4676 struct group *getgrent(void)
4678 if (!nss_wrapper_enabled()) {
4679 return libc_getgrent();
4682 return nwrap_getgrent();
4685 /****************************************************************************
4687 ***************************************************************************/
4689 static int nwrap_getgrent_r(struct group *grdst, char *buf,
4690 size_t buflen, struct group **grdstp)
4694 for (i=0; i < nwrap_main_global->num_backends; i++) {
4695 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4696 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
4697 if (ret == ENOENT) {
4706 #ifdef HAVE_SOLARIS_GETGRENT_R
4707 struct group *getgrent_r(struct group *src, char *buf, int buflen)
4709 struct group *grdstp = NULL;
4712 if (!nss_wrapper_enabled()) {
4713 return libc_getgrent_r(src, buf, buflen);
4716 rc = nwrap_getgrent_r(src, buf, buflen, &grdstp);
4723 #else /* HAVE_SOLARIS_GETGRENT_R */
4724 int getgrent_r(struct group *src, char *buf,
4725 size_t buflen, struct group **grdstp)
4727 if (!nss_wrapper_enabled()) {
4728 return libc_getgrent_r(src, buf, buflen, grdstp);
4731 return nwrap_getgrent_r(src, buf, buflen, grdstp);
4733 #endif /* HAVE_SOLARIS_GETGRENT_R */
4735 /****************************************************************************
4737 ***************************************************************************/
4739 static void nwrap_endgrent(void)
4743 for (i=0; i < nwrap_main_global->num_backends; i++) {
4744 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4745 b->ops->nw_endgrent(b);
4751 if (!nss_wrapper_enabled()) {
4759 /****************************************************************************
4761 ***************************************************************************/
4763 #ifdef HAVE_GETGROUPLIST
4764 static int nwrap_getgrouplist(const char *user, gid_t group,
4765 gid_t *groups, int *ngroups)
4771 NWRAP_LOG(NWRAP_LOG_DEBUG, "getgrouplist called for %s", user);
4773 groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
4775 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
4779 groups_tmp[0] = group;
4782 while ((grp = nwrap_getgrent()) != NULL) {
4785 NWRAP_LOG(NWRAP_LOG_DEBUG,
4786 "Inspecting %s for group membership",
4789 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
4791 if (group != grp->gr_gid &&
4792 (strcmp(user, grp->gr_mem[i]) == 0)) {
4794 NWRAP_LOG(NWRAP_LOG_DEBUG,
4795 "%s is member of %s",
4799 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
4801 NWRAP_LOG(NWRAP_LOG_ERROR,
4806 groups_tmp[count] = grp->gr_gid;
4815 NWRAP_LOG(NWRAP_LOG_DEBUG,
4816 "%s is member of %d groups",
4819 if (*ngroups < count) {
4826 memcpy(groups, groups_tmp, count * sizeof(gid_t));
4832 int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
4834 if (!nss_wrapper_enabled()) {
4835 return libc_getgrouplist(user, group, groups, ngroups);
4838 return nwrap_getgrouplist(user, group, groups, ngroups);
4842 /**********************************************************
4844 **********************************************************/
4846 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
4848 #ifdef HAVE_SETSPENT
4849 static void nwrap_setspent(void)
4851 nwrap_files_setspent();
4856 if (!nss_wrapper_shadow_enabled()) {
4863 static struct spwd *nwrap_getspent(void)
4865 return nwrap_files_getspent();
4868 struct spwd *getspent(void)
4870 if (!nss_wrapper_shadow_enabled()) {
4874 return nwrap_getspent();
4877 static void nwrap_endspent(void)
4879 nwrap_files_endspent();
4884 if (!nss_wrapper_shadow_enabled()) {
4890 #endif /* HAVE_SETSPENT */
4892 static struct spwd *nwrap_getspnam(const char *name)
4894 return nwrap_files_getspnam(name);
4897 struct spwd *getspnam(const char *name)
4899 if (!nss_wrapper_shadow_enabled()) {
4903 return nwrap_getspnam(name);
4906 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
4908 /**********************************************************
4910 **********************************************************/
4912 static void nwrap_sethostent(int stayopen) {
4913 (void) stayopen; /* ignored */
4915 nwrap_files_sethostent();
4918 #ifdef HAVE_SOLARIS_SETHOSTENT
4919 int sethostent(int stayopen)
4921 if (!nss_wrapper_hosts_enabled()) {
4922 libc_sethostent(stayopen);
4926 nwrap_sethostent(stayopen);
4930 #else /* HAVE_SOLARIS_SETHOSTENT */
4931 void sethostent(int stayopen)
4933 if (!nss_wrapper_hosts_enabled()) {
4934 libc_sethostent(stayopen);
4938 nwrap_sethostent(stayopen);
4940 #endif /* HAVE_SOLARIS_SETHOSTENT */
4942 static struct hostent *nwrap_gethostent(void)
4944 return nwrap_files_gethostent();
4947 struct hostent *gethostent(void) {
4948 if (!nss_wrapper_hosts_enabled()) {
4949 return libc_gethostent();
4952 return nwrap_gethostent();
4955 static void nwrap_endhostent(void) {
4956 nwrap_files_endhostent();
4959 #ifdef HAVE_SOLARIS_ENDHOSTENT
4960 int endhostent(void)
4962 if (!nss_wrapper_hosts_enabled()) {
4971 #else /* HAVE_SOLARIS_ENDHOSTENT */
4972 void endhostent(void)
4974 if (!nss_wrapper_hosts_enabled()) {
4981 #endif /* HAVE_SOLARIS_ENDHOSTENT */
4984 /* BSD implementation stores data in thread local storage but GLIBC does not */
4985 static __thread struct hostent user_he;
4986 static __thread struct nwrap_vector user_addrlist;
4988 static struct hostent user_he;
4989 static struct nwrap_vector user_addrlist;
4991 static struct hostent *nwrap_gethostbyname(const char *name)
4993 if (nwrap_files_gethostbyname(name, AF_UNSPEC, &user_he, &user_addrlist) == -1) {
4999 struct hostent *gethostbyname(const char *name)
5001 if (!nss_wrapper_hosts_enabled()) {
5002 return libc_gethostbyname(name);
5005 return nwrap_gethostbyname(name);
5008 /* This is a GNU extension - Also can be found on BSD systems */
5009 #ifdef HAVE_GETHOSTBYNAME2
5011 /* BSD implementation stores data in thread local storage but GLIBC not */
5012 static __thread struct hostent user_he2;
5013 static __thread struct nwrap_vector user_addrlist2;
5015 static struct hostent user_he2;
5016 static struct nwrap_vector user_addrlist2;
5018 static struct hostent *nwrap_gethostbyname2(const char *name, int af)
5020 if (nwrap_files_gethostbyname(name, af, &user_he2, &user_addrlist2) == -1) {
5026 struct hostent *gethostbyname2(const char *name, int af)
5028 if (!nss_wrapper_hosts_enabled()) {
5029 return libc_gethostbyname2(name, af);
5032 return nwrap_gethostbyname2(name, af);
5036 static struct hostent *nwrap_gethostbyaddr(const void *addr,
5037 socklen_t len, int type)
5039 return nwrap_files_gethostbyaddr(addr, len, type);
5042 struct hostent *gethostbyaddr(const void *addr,
5043 socklen_t len, int type)
5045 if (!nss_wrapper_hosts_enabled()) {
5046 return libc_gethostbyaddr(addr, len, type);
5049 return nwrap_gethostbyaddr(addr, len, type);
5052 static const struct addrinfo default_hints =
5054 .ai_flags = AI_ADDRCONFIG|AI_V4MAPPED,
5055 .ai_family = AF_UNSPEC,
5060 .ai_canonname = NULL,
5064 static int nwrap_convert_he_ai(const struct hostent *he,
5065 unsigned short port,
5066 const struct addrinfo *hints,
5067 struct addrinfo **pai,
5068 bool skip_canonname)
5070 struct addrinfo *ai;
5077 switch (he->h_addrtype) {
5079 socklen = sizeof(struct sockaddr_in);
5083 socklen = sizeof(struct sockaddr_in6);
5090 ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) + socklen);
5096 ai->ai_family = he->h_addrtype;
5097 ai->ai_socktype = hints->ai_socktype;
5098 ai->ai_protocol = hints->ai_protocol;
5099 ai->ai_canonname = NULL;
5101 ai->ai_addrlen = socklen;
5102 ai->ai_addr = (void *)(ai + 1);
5104 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
5105 ai->ai_addr->sa_len = socklen;
5107 ai->ai_addr->sa_family = he->h_addrtype;
5109 switch (he->h_addrtype) {
5112 struct sockaddr_in *sinp =
5113 (struct sockaddr_in *) ai->ai_addr;
5115 memset(sinp, 0, sizeof(struct sockaddr_in));
5117 sinp->sin_port = htons(port);
5118 sinp->sin_family = AF_INET;
5120 memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
5121 memcpy(&sinp->sin_addr, he->h_addr_list[0], he->h_length);
5128 struct sockaddr_in6 *sin6p =
5129 (struct sockaddr_in6 *) ai->ai_addr;
5131 memset(sin6p, 0, sizeof(struct sockaddr_in6));
5133 sin6p->sin6_port = htons(port);
5134 sin6p->sin6_family = AF_INET6;
5136 memcpy(&sin6p->sin6_addr,
5146 if (he->h_name && !skip_canonname) {
5147 ai->ai_canonname = strdup(he->h_name);
5148 if (ai->ai_canonname == NULL) {
5158 static int nwrap_getaddrinfo(const char *node,
5159 const char *service,
5160 const struct addrinfo *hints,
5161 struct addrinfo **res)
5163 struct addrinfo *ai = NULL;
5164 struct addrinfo *ai_tail;
5165 unsigned short port = 0;
5175 .family = AF_UNSPEC,
5179 if (node == NULL && service == NULL) {
5183 if (hints == NULL) {
5184 hints = &default_hints;
5188 hints.ai_flags contains invalid flags; or, hints.ai_flags
5189 included AI_CANONNAME and name was NULL.
5191 if ((hints->ai_flags & AI_CANONNAME) && (node == NULL)) {
5192 return EAI_BADFLAGS;
5195 /* If no node has been specified, let glibc deal with it */
5198 struct addrinfo *p = NULL;
5200 ret = libc_getaddrinfo(node, service, hints, &p);
5208 if (service != NULL && service[0] != '\0') {
5209 const char *proto = NULL;
5215 sl = strtol(service, &end_ptr, 10);
5217 if (*end_ptr == '\0') {
5220 } else if (hints->ai_flags & AI_NUMERICSERV) {
5224 if (hints->ai_protocol != 0) {
5225 struct protoent *pent;
5227 pent = getprotobynumber(hints->ai_protocol);
5229 proto = pent->p_name;
5233 s = getservbyname(service, proto);
5237 port = ntohs(s->s_port);
5241 if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET) {
5242 rc = inet_pton(AF_INET, node, &addr.in.v4);
5244 addr.family = AF_INET;
5248 if (addr.family == AF_UNSPEC) {
5249 rc = inet_pton(AF_INET6, node, &addr.in.v6);
5251 addr.family = AF_INET6;
5256 rc = nwrap_files_getaddrinfo(node, port, hints, &ai, &ai_tail);
5259 struct addrinfo *p = NULL;
5261 ret = libc_getaddrinfo(node, service, hints, &p);
5265 * nwrap_files_getaddrinfo failed, but libc was
5266 * successful -- use the result from libc.
5275 if (ai->ai_flags == 0) {
5276 ai->ai_flags = hints->ai_flags;
5278 if (ai->ai_socktype == 0) {
5279 ai->ai_socktype = SOCK_DGRAM;
5281 if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_DGRAM) {
5282 ai->ai_protocol = 17; /* UDP */
5283 } else if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_STREAM) {
5284 ai->ai_protocol = 6; /* TCP */
5287 if (hints->ai_socktype == 0) {
5289 struct addrinfo *ai_head = ai;
5290 struct addrinfo *ai_tmp;
5291 struct addrinfo *ai_new_tail = ai_tail;
5293 /* Add at least one more struct */
5296 ai_tmp = malloc(sizeof(struct addrinfo));
5297 memcpy(ai_tmp, ai_head, sizeof(struct addrinfo));
5298 ai_tmp->ai_next = NULL;
5300 /* We need a deep copy or freeaddrinfo() will blow up */
5301 if (ai_head->ai_canonname != NULL) {
5302 ai_tmp->ai_canonname =
5303 strdup(ai_head->ai_canonname);
5305 /* ai_head should point inside hints. */
5306 ai_tmp->ai_addr = ai_head->ai_addr;
5308 if (ai_head->ai_flags == 0) {
5309 ai_tmp->ai_flags = hints->ai_flags;
5311 if (ai_head->ai_socktype == SOCK_DGRAM) {
5312 ai_tmp->ai_socktype = SOCK_STREAM;
5313 } else if (ai_head->ai_socktype == SOCK_STREAM) {
5314 ai_tmp->ai_socktype = SOCK_DGRAM;
5316 if (ai_head->ai_socktype == SOCK_DGRAM) {
5317 ai_tmp->ai_protocol = 17; /* UDP */
5318 } else if (ai_head->ai_socktype == SOCK_STREAM) {
5319 ai_tmp->ai_protocol = 6; /* TCP */
5321 ai_new_tail->ai_next = ai_tmp;
5322 ai_new_tail = ai_tmp;
5324 if (ai_head == ai_tail) {
5327 ai_head = ai_head->ai_next;
5336 int getaddrinfo(const char *node, const char *service,
5337 const struct addrinfo *hints,
5338 struct addrinfo **res)
5340 if (!nss_wrapper_hosts_enabled()) {
5341 return libc_getaddrinfo(node, service, hints, res);
5344 return nwrap_getaddrinfo(node, service, hints, res);
5347 static int nwrap_getnameinfo(const struct sockaddr *sa, socklen_t salen,
5348 char *host, size_t hostlen,
5349 char *serv, size_t servlen,
5353 struct servent *service;
5360 if (sa == NULL || salen < sizeof(sa_family_t)) {
5364 if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL) {
5368 type = sa->sa_family;
5371 if (salen < sizeof(struct sockaddr_in))
5373 addr = &((const struct sockaddr_in *)sa)->sin_addr;
5374 addrlen = sizeof(((const struct sockaddr_in *)sa)->sin_addr);
5375 port = ntohs(((const struct sockaddr_in *)sa)->sin_port);
5379 if (salen < sizeof(struct sockaddr_in6))
5381 addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
5382 addrlen = sizeof(((const struct sockaddr_in6 *)sa)->sin6_addr);
5383 port = ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
5392 if ((flags & NI_NUMERICHOST) == 0) {
5393 he = nwrap_files_gethostbyaddr(addr, addrlen, type);
5394 if ((flags & NI_NAMEREQD) && (he == NULL || he->h_name == NULL))
5397 if (he != NULL && he->h_name != NULL) {
5398 if (strlen(he->h_name) >= hostlen)
5399 return EAI_OVERFLOW;
5400 strcpy(host, he->h_name);
5401 if (flags & NI_NOFQDN)
5402 host[strcspn(host, ".")] = '\0';
5404 if (inet_ntop(type, addr, host, hostlen) == NULL)
5405 return (errno == ENOSPC) ? EAI_OVERFLOW : EAI_FAIL;
5411 if ((flags & NI_NUMERICSERV) == 0) {
5412 proto = (flags & NI_DGRAM) ? "udp" : "tcp";
5413 service = getservbyport(htons(port), proto);
5415 if (service != NULL) {
5416 if (strlen(service->s_name) >= servlen)
5417 return EAI_OVERFLOW;
5418 strcpy(serv, service->s_name);
5420 if (snprintf(serv, servlen, "%u", port) >= (int) servlen)
5421 return EAI_OVERFLOW;
5428 #ifdef HAVE_LINUX_GETNAMEINFO
5429 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5430 char *host, socklen_t hostlen,
5431 char *serv, socklen_t servlen,
5433 #elif defined(HAVE_LINUX_GETNAMEINFO_UNSIGNED)
5434 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5435 char *host, socklen_t hostlen,
5436 char *serv, socklen_t servlen,
5439 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5440 char *host, size_t hostlen,
5441 char *serv, size_t servlen,
5445 if (!nss_wrapper_hosts_enabled()) {
5446 return libc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5449 return nwrap_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5452 static int nwrap_gethostname(char *name, size_t len)
5454 const char *hostname = getenv("NSS_WRAPPER_HOSTNAME");
5456 if (strlen(hostname) >= len) {
5457 errno = ENAMETOOLONG;
5460 snprintf(name, len, "%s", hostname);
5465 #ifdef HAVE_SOLARIS_GETHOSTNAME
5466 int gethostname(char *name, int len)
5467 #else /* HAVE_SOLARIS_GETHOSTNAME */
5468 int gethostname(char *name, size_t len)
5469 #endif /* HAVE_SOLARIS_GETHOSTNAME */
5471 if (!nwrap_hostname_enabled()) {
5472 return libc_gethostname(name, len);
5475 return nwrap_gethostname(name, len);
5478 /****************************
5480 ***************************/
5483 * This function is called when the library is unloaded and makes sure that
5484 * sockets get closed and the unix file for the socket are unlinked.
5486 void nwrap_destructor(void)
5491 if (nwrap_main_global != NULL) {
5492 struct nwrap_main *m = nwrap_main_global;
5495 SAFE_FREE(m->libc->fns);
5496 if (m->libc->handle != NULL) {
5497 dlclose(m->libc->handle);
5499 if (m->libc->nsl_handle != NULL) {
5500 dlclose(m->libc->nsl_handle);
5502 if (m->libc->sock_handle != NULL) {
5503 dlclose(m->libc->sock_handle);
5508 for (i = 0; i < m->num_backends; i++) {
5509 struct nwrap_backend *b = &(m->backends[i]);
5511 if (b->so_handle != NULL) {
5512 dlclose(b->so_handle);
5516 SAFE_FREE(m->backends);
5519 if (nwrap_pw_global.cache != NULL) {
5520 struct nwrap_cache *c = nwrap_pw_global.cache;
5522 nwrap_files_cache_unload(c);
5528 SAFE_FREE(nwrap_pw_global.list);
5529 nwrap_pw_global.num = 0;
5532 if (nwrap_gr_global.cache != NULL) {
5533 struct nwrap_cache *c = nwrap_gr_global.cache;
5535 nwrap_files_cache_unload(c);
5541 SAFE_FREE(nwrap_gr_global.list);
5542 nwrap_pw_global.num = 0;
5545 if (nwrap_he_global.cache != NULL) {
5546 struct nwrap_cache *c = nwrap_he_global.cache;
5548 nwrap_files_cache_unload(c);
5554 nwrap_he_global.num = 0;