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>
55 #include <netinet/in.h>
61 * Defining _POSIX_PTHREAD_SEMANTICS before including pwd.h and grp.h gives us
62 * the posix getpwnam_r(), getpwuid_r(), getgrnam_r and getgrgid_r calls on
65 #ifndef _POSIX_PTHREAD_SEMANTICS
66 #define _POSIX_PTHREAD_SEMANTICS
73 #endif /* HAVE_SHADOW_H */
76 #include <arpa/inet.h>
77 #include <netinet/in.h>
81 #if defined(HAVE_NSS_H)
85 typedef enum nss_status NSS_STATUS;
86 #elif defined(HAVE_NSS_COMMON_H)
88 #include <nss_common.h>
89 #include <nss_dbdefs.h>
92 typedef nss_status_t NSS_STATUS;
94 # define NSS_STATUS_SUCCESS NSS_SUCCESS
95 # define NSS_STATUS_NOTFOUND NSS_NOTFOUND
96 # define NSS_STATUS_UNAVAIL NSS_UNAVAIL
97 # define NSS_STATUS_TRYAGAIN NSS_TRYAGAIN
99 # error "No nsswitch support detected"
103 #define PTR_DIFF(p1, p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
111 #define EAI_NODATA EAI_NONAME
114 #ifndef EAI_ADDRFAMILY
115 #define EAI_ADDRFAMILY EAI_FAMILY
119 #define __STRING(x) #x
122 #ifndef __STRINGSTRING
123 #define __STRINGSTRING(x) __STRING(x)
127 #define __LINESTR__ __STRINGSTRING(__LINE__)
131 #define __location__ __FILE__ ":" __LINESTR__
135 #define DNS_NAME_MAX 255
138 /* GCC have printf type attribute check. */
139 #ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
140 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
142 #define PRINTF_ATTRIBUTE(a,b)
143 #endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
145 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
146 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
148 #define DESTRUCTOR_ATTRIBUTE
149 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
151 #define ZERO_STRUCTP(x) do { if ((x) != NULL) memset((char *)(x), 0, sizeof(*(x))); } while(0)
154 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
158 #define NWRAP_INET_ADDRSTRLEN INET6_ADDRSTRLEN
160 #define NWRAP_INET_ADDRSTRLEN INET_ADDRSTRLEN
163 #define NWRAP_LOCK(m) do { \
164 pthread_mutex_lock(&( m ## _mutex)); \
167 #define NWRAP_UNLOCK(m) do { \
168 pthread_mutex_unlock(&( m ## _mutex)); \
172 static bool nwrap_initialized = false;
173 static pthread_mutex_t nwrap_initialized_mutex = PTHREAD_MUTEX_INITIALIZER;
175 /* The mutex or accessing the id */
176 static pthread_mutex_t nwrap_global_mutex = PTHREAD_MUTEX_INITIALIZER;
177 static pthread_mutex_t nwrap_gr_global_mutex = PTHREAD_MUTEX_INITIALIZER;
178 static pthread_mutex_t nwrap_he_global_mutex = PTHREAD_MUTEX_INITIALIZER;
179 static pthread_mutex_t nwrap_pw_global_mutex = PTHREAD_MUTEX_INITIALIZER;
180 static pthread_mutex_t nwrap_sp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
182 /* Add new global locks here please */
183 /* Also don't forget to add locks to
184 * nwrap_init() function.
186 # define NWRAP_LOCK_ALL do { \
187 NWRAP_LOCK(nwrap_initialized); \
188 NWRAP_LOCK(nwrap_global); \
189 NWRAP_LOCK(nwrap_gr_global); \
190 NWRAP_LOCK(nwrap_he_global); \
191 NWRAP_LOCK(nwrap_pw_global); \
192 NWRAP_LOCK(nwrap_sp_global); \
195 # define NWRAP_UNLOCK_ALL do {\
196 NWRAP_UNLOCK(nwrap_sp_global); \
197 NWRAP_UNLOCK(nwrap_pw_global); \
198 NWRAP_UNLOCK(nwrap_he_global); \
199 NWRAP_UNLOCK(nwrap_gr_global); \
200 NWRAP_UNLOCK(nwrap_global); \
201 NWRAP_UNLOCK(nwrap_initialized); \
204 static void nwrap_thread_prepare(void)
209 static void nwrap_thread_parent(void)
214 static void nwrap_thread_child(void)
219 enum nwrap_dbglvl_e {
227 # define NWRAP_LOG(...)
230 static void nwrap_log(enum nwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
231 # define NWRAP_LOG(dbglvl, ...) nwrap_log((dbglvl), __func__, __VA_ARGS__)
233 static void nwrap_log(enum nwrap_dbglvl_e dbglvl,
235 const char *format, ...)
240 unsigned int lvl = 0;
243 d = getenv("NSS_WRAPPER_DEBUGLEVEL");
248 va_start(va, format);
249 vsnprintf(buffer, sizeof(buffer), format, va);
254 case NWRAP_LOG_ERROR:
256 "NWRAP_ERROR(%d) - %s: %s\n",
261 "NWRAP_WARN(%d) - %s: %s\n",
264 case NWRAP_LOG_DEBUG:
266 "NWRAP_DEBUG(%d) - %s: %s\n",
269 case NWRAP_LOG_TRACE:
271 "NWRAP_TRACE(%d) - %s: %s\n",
277 #endif /* NDEBUG NWRAP_LOG */
279 struct nwrap_libc_fns {
280 struct passwd *(*_libc_getpwnam)(const char *name);
281 int (*_libc_getpwnam_r)(const char *name, struct passwd *pwd,
282 char *buf, size_t buflen, struct passwd **result);
283 struct passwd *(*_libc_getpwuid)(uid_t uid);
284 int (*_libc_getpwuid_r)(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);
285 void (*_libc_setpwent)(void);
286 struct passwd *(*_libc_getpwent)(void);
287 #ifdef HAVE_SOLARIS_GETPWENT_R
288 struct passwd *(*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen);
290 int (*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
292 void (*_libc_endpwent)(void);
293 int (*_libc_initgroups)(const char *user, gid_t gid);
294 struct group *(*_libc_getgrnam)(const char *name);
295 int (*_libc_getgrnam_r)(const char *name, struct group *grp, char *buf, size_t buflen, struct group **result);
296 struct group *(*_libc_getgrgid)(gid_t gid);
297 int (*_libc_getgrgid_r)(gid_t gid, struct group *grp, char *buf, size_t buflen, struct group **result);
298 void (*_libc_setgrent)(void);
299 struct group *(*_libc_getgrent)(void);
300 #ifdef HAVE_SOLARIS_GETGRENT_R
301 struct group *(*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen);
303 int (*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen, struct group **result);
305 void (*_libc_endgrent)(void);
306 int (*_libc_getgrouplist)(const char *user, gid_t group, gid_t *groups, int *ngroups);
308 void (*_libc_sethostent)(int stayopen);
309 struct hostent *(*_libc_gethostent)(void);
310 void (*_libc_endhostent)(void);
312 struct hostent *(*_libc_gethostbyname)(const char *name);
313 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
314 struct hostent *(*_libc_gethostbyname2)(const char *name, int af);
316 struct hostent *(*_libc_gethostbyaddr)(const void *addr, socklen_t len, int type);
318 int (*_libc_getaddrinfo)(const char *node, const char *service,
319 const struct addrinfo *hints,
320 struct addrinfo **res);
321 int (*_libc_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
322 char *host, size_t hostlen,
323 char *serv, size_t servlen,
325 int (*_libc_gethostname)(char *name, size_t len);
326 #ifdef HAVE_GETHOSTBYNAME_R
327 int (*_libc_gethostbyname_r)(const char *name,
329 char *buf, size_t buflen,
330 struct hostent **result, int *h_errnop);
332 #ifdef HAVE_GETHOSTBYADDR_R
333 int (*_libc_gethostbyaddr_r)(const void *addr, socklen_t len, int type,
335 char *buf, size_t buflen,
336 struct hostent **result, int *h_errnop);
340 struct nwrap_module_nss_fns {
341 NSS_STATUS (*_nss_getpwnam_r)(const char *name, struct passwd *result, char *buffer,
342 size_t buflen, int *errnop);
343 NSS_STATUS (*_nss_getpwuid_r)(uid_t uid, struct passwd *result, char *buffer,
344 size_t buflen, int *errnop);
345 NSS_STATUS (*_nss_setpwent)(void);
346 NSS_STATUS (*_nss_getpwent_r)(struct passwd *result, char *buffer,
347 size_t buflen, int *errnop);
348 NSS_STATUS (*_nss_endpwent)(void);
349 NSS_STATUS (*_nss_initgroups)(const char *user, gid_t group, long int *start,
350 long int *size, gid_t **groups, long int limit, int *errnop);
351 NSS_STATUS (*_nss_getgrnam_r)(const char *name, struct group *result, char *buffer,
352 size_t buflen, int *errnop);
353 NSS_STATUS (*_nss_getgrgid_r)(gid_t gid, struct group *result, char *buffer,
354 size_t buflen, int *errnop);
355 NSS_STATUS (*_nss_setgrent)(void);
356 NSS_STATUS (*_nss_getgrent_r)(struct group *result, char *buffer,
357 size_t buflen, int *errnop);
358 NSS_STATUS (*_nss_endgrent)(void);
361 struct nwrap_backend {
365 struct nwrap_ops *ops;
366 struct nwrap_module_nss_fns *fns;
370 struct passwd * (*nw_getpwnam)(struct nwrap_backend *b,
372 int (*nw_getpwnam_r)(struct nwrap_backend *b,
373 const char *name, struct passwd *pwdst,
374 char *buf, size_t buflen, struct passwd **pwdstp);
375 struct passwd * (*nw_getpwuid)(struct nwrap_backend *b,
377 int (*nw_getpwuid_r)(struct nwrap_backend *b,
378 uid_t uid, struct passwd *pwdst,
379 char *buf, size_t buflen, struct passwd **pwdstp);
380 void (*nw_setpwent)(struct nwrap_backend *b);
381 struct passwd * (*nw_getpwent)(struct nwrap_backend *b);
382 int (*nw_getpwent_r)(struct nwrap_backend *b,
383 struct passwd *pwdst, char *buf,
384 size_t buflen, struct passwd **pwdstp);
385 void (*nw_endpwent)(struct nwrap_backend *b);
386 int (*nw_initgroups)(struct nwrap_backend *b,
387 const char *user, gid_t group);
388 struct group * (*nw_getgrnam)(struct nwrap_backend *b,
390 int (*nw_getgrnam_r)(struct nwrap_backend *b,
391 const char *name, struct group *grdst,
392 char *buf, size_t buflen, struct group **grdstp);
393 struct group * (*nw_getgrgid)(struct nwrap_backend *b,
395 int (*nw_getgrgid_r)(struct nwrap_backend *b,
396 gid_t gid, struct group *grdst,
397 char *buf, size_t buflen, struct group **grdstp);
398 void (*nw_setgrent)(struct nwrap_backend *b);
399 struct group * (*nw_getgrent)(struct nwrap_backend *b);
400 int (*nw_getgrent_r)(struct nwrap_backend *b,
401 struct group *grdst, char *buf,
402 size_t buflen, struct group **grdstp);
403 void (*nw_endgrent)(struct nwrap_backend *b);
406 /* Public prototypes */
408 bool nss_wrapper_enabled(void);
409 bool nss_wrapper_shadow_enabled(void);
410 bool nss_wrapper_hosts_enabled(void);
412 /* prototypes for files backend */
415 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
417 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
418 const char *name, struct passwd *pwdst,
419 char *buf, size_t buflen, struct passwd **pwdstp);
420 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
422 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
423 uid_t uid, struct passwd *pwdst,
424 char *buf, size_t buflen, struct passwd **pwdstp);
425 static void nwrap_files_setpwent(struct nwrap_backend *b);
426 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b);
427 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
428 struct passwd *pwdst, char *buf,
429 size_t buflen, struct passwd **pwdstp);
430 static void nwrap_files_endpwent(struct nwrap_backend *b);
431 static int nwrap_files_initgroups(struct nwrap_backend *b,
432 const char *user, gid_t group);
433 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
435 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
436 const char *name, struct group *grdst,
437 char *buf, size_t buflen, struct group **grdstp);
438 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
440 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
441 gid_t gid, struct group *grdst,
442 char *buf, size_t buflen, struct group **grdstp);
443 static void nwrap_files_setgrent(struct nwrap_backend *b);
444 static struct group *nwrap_files_getgrent(struct nwrap_backend *b);
445 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
446 struct group *grdst, char *buf,
447 size_t buflen, struct group **grdstp);
448 static void nwrap_files_endgrent(struct nwrap_backend *b);
450 /* prototypes for module backend */
452 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
453 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
454 struct passwd *pwdst, char *buf,
455 size_t buflen, struct passwd **pwdstp);
456 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
458 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
459 const char *name, struct passwd *pwdst,
460 char *buf, size_t buflen, struct passwd **pwdstp);
461 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
463 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
464 uid_t uid, struct passwd *pwdst,
465 char *buf, size_t buflen, struct passwd **pwdstp);
466 static void nwrap_module_setpwent(struct nwrap_backend *b);
467 static void nwrap_module_endpwent(struct nwrap_backend *b);
468 static struct group *nwrap_module_getgrent(struct nwrap_backend *b);
469 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
470 struct group *grdst, char *buf,
471 size_t buflen, struct group **grdstp);
472 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
474 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
475 const char *name, struct group *grdst,
476 char *buf, size_t buflen, struct group **grdstp);
477 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
479 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
480 gid_t gid, struct group *grdst,
481 char *buf, size_t buflen, struct group **grdstp);
482 static void nwrap_module_setgrent(struct nwrap_backend *b);
483 static void nwrap_module_endgrent(struct nwrap_backend *b);
484 static int nwrap_module_initgroups(struct nwrap_backend *b,
485 const char *user, gid_t group);
487 struct nwrap_ops nwrap_files_ops = {
488 .nw_getpwnam = nwrap_files_getpwnam,
489 .nw_getpwnam_r = nwrap_files_getpwnam_r,
490 .nw_getpwuid = nwrap_files_getpwuid,
491 .nw_getpwuid_r = nwrap_files_getpwuid_r,
492 .nw_setpwent = nwrap_files_setpwent,
493 .nw_getpwent = nwrap_files_getpwent,
494 .nw_getpwent_r = nwrap_files_getpwent_r,
495 .nw_endpwent = nwrap_files_endpwent,
496 .nw_initgroups = nwrap_files_initgroups,
497 .nw_getgrnam = nwrap_files_getgrnam,
498 .nw_getgrnam_r = nwrap_files_getgrnam_r,
499 .nw_getgrgid = nwrap_files_getgrgid,
500 .nw_getgrgid_r = nwrap_files_getgrgid_r,
501 .nw_setgrent = nwrap_files_setgrent,
502 .nw_getgrent = nwrap_files_getgrent,
503 .nw_getgrent_r = nwrap_files_getgrent_r,
504 .nw_endgrent = nwrap_files_endgrent,
507 struct nwrap_ops nwrap_module_ops = {
508 .nw_getpwnam = nwrap_module_getpwnam,
509 .nw_getpwnam_r = nwrap_module_getpwnam_r,
510 .nw_getpwuid = nwrap_module_getpwuid,
511 .nw_getpwuid_r = nwrap_module_getpwuid_r,
512 .nw_setpwent = nwrap_module_setpwent,
513 .nw_getpwent = nwrap_module_getpwent,
514 .nw_getpwent_r = nwrap_module_getpwent_r,
515 .nw_endpwent = nwrap_module_endpwent,
516 .nw_initgroups = nwrap_module_initgroups,
517 .nw_getgrnam = nwrap_module_getgrnam,
518 .nw_getgrnam_r = nwrap_module_getgrnam_r,
519 .nw_getgrgid = nwrap_module_getgrgid,
520 .nw_getgrgid_r = nwrap_module_getgrgid_r,
521 .nw_setgrent = nwrap_module_setgrent,
522 .nw_getgrent = nwrap_module_getgrent,
523 .nw_getgrent_r = nwrap_module_getgrent_r,
524 .nw_endgrent = nwrap_module_endgrent,
531 struct nwrap_libc_fns *fns;
536 struct nwrap_backend *backends;
537 struct nwrap_libc *libc;
540 static struct nwrap_main *nwrap_main_global;
541 static struct nwrap_main __nwrap_main_global;
546 static int nwrap_convert_he_ai(const struct hostent *he,
548 const struct addrinfo *hints,
549 struct addrinfo **pai,
550 bool skip_canonname);
556 #define DEFAULT_VECTOR_CAPACITY 16
558 struct nwrap_vector {
564 /* Macro returns pointer to first element of vector->items array.
566 * nwrap_vector is used as a memory backend which take care of
567 * memory allocations and other stuff like memory growing.
568 * nwrap_vectors should not be considered as some abstract structures.
569 * On this level, vectors are more handy than direct realloc/malloc
572 * nwrap_vector->items is array inside nwrap_vector which can be
573 * directly pointed by libc structure assembled by cwrap itself.
577 * 1) struct hostent contains char **h_addr_list element.
578 * 2) nwrap_vector holds array of pointers to addresses.
579 * It's easier to use vector to store results of
582 * Now, pretend that cwrap assembled struct hostent and
583 * we need to set h_addr_list to point to nwrap_vector.
584 * Idea behind is to shield users from internal nwrap_vector
586 * (Yes, not fully - array terminated by NULL is needed because
587 * it's result expected by libc function caller.)
593 * struct nwrap_vector *vector = malloc(sizeof(struct nwrap_vector));
594 * ... don't care about failed allocation now ...
596 * ... fill nwrap vector ...
599 * he.h_addr_list = nwrap_vector_head(vector);
602 #define nwrap_vector_head(vect) ((void *)((vect)->items))
604 #define nwrap_vector_foreach(item, vect, iter) \
605 for (iter = 0, (item) = (vect).items == NULL ? NULL : (vect).items[0]; \
607 (item) = (vect).items[++iter])
609 #define nwrap_vector_is_initialized(vector) ((vector)->items != NULL)
611 static inline bool nwrap_vector_init(struct nwrap_vector *const vector)
613 if (vector == NULL) {
617 /* count is initialized by ZERO_STRUCTP */
618 ZERO_STRUCTP(vector);
619 vector->items = malloc(sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
620 if (vector->items == NULL) {
623 vector->capacity = DEFAULT_VECTOR_CAPACITY;
624 memset(vector->items, '\0', sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
629 static bool nwrap_vector_add_item(struct nwrap_vector *vector, void *const item)
631 assert (vector != NULL);
633 if (vector->items == NULL) {
634 nwrap_vector_init(vector);
637 if (vector->count == vector->capacity) {
638 /* Items array _MUST_ be NULL terminated because it's passed
639 * as result to caller which expect NULL terminated array from libc.
641 void **items = realloc(vector->items, sizeof(void *) * ((vector->capacity * 2) + 1));
645 vector->items = items;
647 /* Don't count ending NULL to capacity */
648 vector->capacity *= 2;
651 vector->items[vector->count] = item;
654 vector->items[vector->count] = NULL;
659 static bool nwrap_vector_merge(struct nwrap_vector *dst,
660 struct nwrap_vector *src)
662 void **dst_items = NULL;
665 if (src->count == 0) {
669 count = dst->count + src->count;
671 /* We don't need reallocation if we have enough capacity. */
672 if (src->count > (dst->capacity - dst->count)) {
673 dst_items = (void **)realloc(dst->items, (count + 1) * sizeof(void *));
674 if (dst_items == NULL) {
677 dst->items = dst_items;
678 dst->capacity = count;
681 memcpy((void *)(((long *)dst->items) + dst->count),
683 src->count * sizeof(void *));
696 struct nwrap_vector lines;
698 bool (*parse_line)(struct nwrap_cache *, char *line);
699 void (*unload)(struct nwrap_cache *);
704 struct nwrap_cache *cache;
711 struct nwrap_cache __nwrap_cache_pw;
712 struct nwrap_pw nwrap_pw_global;
714 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line);
715 static void nwrap_pw_unload(struct nwrap_cache *nwrap);
718 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
720 struct nwrap_cache *cache;
727 struct nwrap_cache __nwrap_cache_sp;
728 struct nwrap_sp nwrap_sp_global;
730 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line);
731 static void nwrap_sp_unload(struct nwrap_cache *nwrap);
732 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
736 struct nwrap_cache *cache;
743 struct nwrap_cache __nwrap_cache_gr;
744 struct nwrap_gr nwrap_gr_global;
747 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line);
748 static void nwrap_he_unload(struct nwrap_cache *nwrap);
750 struct nwrap_addrdata {
751 unsigned char host_addr[16]; /* IPv4 or IPv6 address */
754 static size_t max_hostents = 100;
756 struct nwrap_entdata {
757 struct nwrap_addrdata addr;
760 struct nwrap_vector nwrap_addrdata;
762 ssize_t aliases_count;
765 struct nwrap_entlist {
766 struct nwrap_entlist *next;
767 struct nwrap_entdata *ed;
771 struct nwrap_cache *cache;
773 struct nwrap_vector entries;
774 struct nwrap_vector lists;
780 static struct nwrap_cache __nwrap_cache_he;
781 static struct nwrap_he nwrap_he_global;
784 /*********************************************************
786 *********************************************************/
788 static void nwrap_init(void);
789 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line);
790 static void nwrap_gr_unload(struct nwrap_cache *nwrap);
791 void nwrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
793 /*********************************************************
794 * NWRAP LIBC LOADER FUNCTIONS
795 *********************************************************/
804 static const char *nwrap_str_lib(enum nwrap_lib lib)
811 case NWRAP_LIBSOCKET:
815 /* Compiler would warn us about unhandled enum value if we get here */
820 static void *nwrap_load_lib_handle(enum nwrap_lib lib)
822 int flags = RTLD_LAZY;
827 flags |= RTLD_DEEPBIND;
833 handle = nwrap_main_global->libc->nsl_handle;
834 if (handle == NULL) {
835 for (i = 10; i >= 0; i--) {
836 char soname[256] = {0};
838 snprintf(soname, sizeof(soname), "libnsl.so.%d", i);
839 handle = dlopen(soname, flags);
840 if (handle != NULL) {
845 nwrap_main_global->libc->nsl_handle = handle;
850 case NWRAP_LIBSOCKET:
851 #ifdef HAVE_LIBSOCKET
852 handle = nwrap_main_global->libc->sock_handle;
853 if (handle == NULL) {
854 for (i = 10; i >= 0; i--) {
855 char soname[256] = {0};
857 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
858 handle = dlopen(soname, flags);
859 if (handle != NULL) {
864 nwrap_main_global->libc->sock_handle = handle;
870 handle = nwrap_main_global->libc->handle;
871 if (handle == NULL) {
872 for (i = 10; i >= 0; i--) {
873 char soname[256] = {0};
875 snprintf(soname, sizeof(soname), "libc.so.%d", i);
876 handle = dlopen(soname, flags);
877 if (handle != NULL) {
882 nwrap_main_global->libc->handle = handle;
887 if (handle == NULL) {
889 handle = nwrap_main_global->libc->handle
890 = nwrap_main_global->libc->sock_handle
891 = nwrap_main_global->libc->nsl_handle
894 NWRAP_LOG(NWRAP_LOG_ERROR,
895 "Failed to dlopen library: %s\n",
904 static void *_nwrap_load_lib_function(enum nwrap_lib lib, const char *fn_name)
911 handle = nwrap_load_lib_handle(lib);
913 func = dlsym(handle, fn_name);
915 NWRAP_LOG(NWRAP_LOG_ERROR,
916 "Failed to find %s: %s\n",
921 NWRAP_LOG(NWRAP_LOG_TRACE,
923 fn_name, nwrap_str_lib(lib));
927 #define nwrap_load_lib_function(lib, fn_name) \
928 if (nwrap_main_global->libc->fns->_libc_##fn_name == NULL) { \
929 *(void **) (&nwrap_main_global->libc->fns->_libc_##fn_name) = \
930 _nwrap_load_lib_function(lib, #fn_name); \
933 /* INTERNAL HELPER FUNCTIONS */
934 static void nwrap_lines_unload(struct nwrap_cache *const nwrap)
938 nwrap_vector_foreach(item, nwrap->lines, p) {
939 /* Maybe some vectors were merged ... */
942 SAFE_FREE(nwrap->lines.items);
943 ZERO_STRUCTP(&nwrap->lines);
949 * Functions expeciall from libc need to be loaded individually, you can't load
950 * all at once or gdb will segfault at startup. The same applies to valgrind and
951 * has probably something todo with with the linker.
952 * So we need load each function at the point it is called the first time.
954 static struct passwd *libc_getpwnam(const char *name)
956 nwrap_load_lib_function(NWRAP_LIBC, getpwnam);
958 return nwrap_main_global->libc->fns->_libc_getpwnam(name);
961 #ifdef HAVE_GETPWNAM_R
962 static int libc_getpwnam_r(const char *name,
966 struct passwd **result)
968 #ifdef HAVE___POSIX_GETPWNAM_R
969 if (nwrap_main_global->libc->fns->_libc_getpwnam_r == NULL) {
970 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwnam_r) =
971 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwnam_r");
974 nwrap_load_lib_function(NWRAP_LIBC, getpwnam_r);
977 return nwrap_main_global->libc->fns->_libc_getpwnam_r(name,
985 static struct passwd *libc_getpwuid(uid_t uid)
987 nwrap_load_lib_function(NWRAP_LIBC, getpwuid);
989 return nwrap_main_global->libc->fns->_libc_getpwuid(uid);
992 #ifdef HAVE_GETPWUID_R
993 static int libc_getpwuid_r(uid_t uid,
997 struct passwd **result)
999 #ifdef HAVE___POSIX_GETPWUID_R
1000 if (nwrap_main_global->libc->fns->_libc_getpwuid_r == NULL) {
1001 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwuid_r) =
1002 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwuid_r");
1005 nwrap_load_lib_function(NWRAP_LIBC, getpwuid_r);
1008 return nwrap_main_global->libc->fns->_libc_getpwuid_r(uid,
1016 static inline void str_tolower(char *dst, char *src)
1018 register char *src_tmp = src;
1019 register char *dst_tmp = dst;
1021 while (*src_tmp != '\0') {
1022 *dst_tmp = tolower(*src_tmp);
1028 static bool str_tolower_copy(char **dst_name, const char *const src_name)
1032 if ((dst_name == NULL) || (src_name == NULL)) {
1036 h_name_lower = strdup(src_name);
1037 if (h_name_lower == NULL) {
1038 NWRAP_LOG(NWRAP_LOG_DEBUG, "Out of memory while strdup");
1042 str_tolower(h_name_lower, h_name_lower);
1043 *dst_name = h_name_lower;
1047 static void libc_setpwent(void)
1049 nwrap_load_lib_function(NWRAP_LIBC, setpwent);
1051 nwrap_main_global->libc->fns->_libc_setpwent();
1054 static struct passwd *libc_getpwent(void)
1056 nwrap_load_lib_function(NWRAP_LIBC, getpwent);
1058 return nwrap_main_global->libc->fns->_libc_getpwent();
1061 #ifdef HAVE_SOLARIS_GETPWENT_R
1062 static struct passwd *libc_getpwent_r(struct passwd *pwdst,
1066 nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1068 return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1072 #else /* HAVE_SOLARIS_GETPWENT_R */
1073 static int libc_getpwent_r(struct passwd *pwdst,
1076 struct passwd **pwdstp)
1078 nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1080 return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1085 #endif /* HAVE_SOLARIS_GETPWENT_R */
1087 static void libc_endpwent(void)
1089 nwrap_load_lib_function(NWRAP_LIBC, endpwent);
1091 nwrap_main_global->libc->fns->_libc_endpwent();
1094 static int libc_initgroups(const char *user, gid_t gid)
1096 nwrap_load_lib_function(NWRAP_LIBC, initgroups);
1098 return nwrap_main_global->libc->fns->_libc_initgroups(user, gid);
1101 static struct group *libc_getgrnam(const char *name)
1103 nwrap_load_lib_function(NWRAP_LIBC, getgrnam);
1105 return nwrap_main_global->libc->fns->_libc_getgrnam(name);
1108 #ifdef HAVE_GETGRNAM_R
1109 static int libc_getgrnam_r(const char *name,
1113 struct group **result)
1115 #ifdef HAVE___POSIX_GETGRNAM_R
1116 if (nwrap_main_global->libc->fns->_libc_getgrnam_r == NULL) {
1117 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrnam_r) =
1118 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrnam_r");
1121 nwrap_load_lib_function(NWRAP_LIBC, getgrnam_r);
1124 return nwrap_main_global->libc->fns->_libc_getgrnam_r(name,
1132 static struct group *libc_getgrgid(gid_t gid)
1134 nwrap_load_lib_function(NWRAP_LIBC, getgrgid);
1136 return nwrap_main_global->libc->fns->_libc_getgrgid(gid);
1139 #ifdef HAVE_GETGRGID_R
1140 static int libc_getgrgid_r(gid_t gid,
1144 struct group **result)
1146 #ifdef HAVE___POSIX_GETGRGID_R
1147 if (nwrap_main_global->libc->fns->_libc_getgrgid_r == NULL) {
1148 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrgid_r) =
1149 _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrgid_r");
1152 nwrap_load_lib_function(NWRAP_LIBC, getgrgid_r);
1155 return nwrap_main_global->libc->fns->_libc_getgrgid_r(gid,
1163 static void libc_setgrent(void)
1165 nwrap_load_lib_function(NWRAP_LIBC, setgrent);
1167 nwrap_main_global->libc->fns->_libc_setgrent();
1170 static struct group *libc_getgrent(void)
1172 nwrap_load_lib_function(NWRAP_LIBC, getgrent);
1174 return nwrap_main_global->libc->fns->_libc_getgrent();
1177 #ifdef HAVE_GETGRENT_R
1178 #ifdef HAVE_SOLARIS_GETGRENT_R
1179 static struct group *libc_getgrent_r(struct group *group,
1183 nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1185 return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1189 #else /* !HAVE_SOLARIS_GETGRENT_R */
1190 static int libc_getgrent_r(struct group *group,
1193 struct group **result)
1195 nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1197 return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1202 #endif /* HAVE_SOLARIS_GETGRENT_R */
1203 #endif /* HAVE_GETGRENT_R */
1205 static void libc_endgrent(void)
1207 nwrap_load_lib_function(NWRAP_LIBC, endgrent);
1209 nwrap_main_global->libc->fns->_libc_endgrent();
1212 #ifdef HAVE_GETGROUPLIST
1213 static int libc_getgrouplist(const char *user,
1218 nwrap_load_lib_function(NWRAP_LIBC, getgrouplist);
1220 return nwrap_main_global->libc->fns->_libc_getgrouplist(user,
1227 static void libc_sethostent(int stayopen)
1229 nwrap_load_lib_function(NWRAP_LIBNSL, sethostent);
1231 nwrap_main_global->libc->fns->_libc_sethostent(stayopen);
1234 static struct hostent *libc_gethostent(void)
1236 nwrap_load_lib_function(NWRAP_LIBNSL, gethostent);
1238 return nwrap_main_global->libc->fns->_libc_gethostent();
1241 static void libc_endhostent(void)
1243 nwrap_load_lib_function(NWRAP_LIBNSL, endhostent);
1245 nwrap_main_global->libc->fns->_libc_endhostent();
1248 static struct hostent *libc_gethostbyname(const char *name)
1250 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname);
1252 return nwrap_main_global->libc->fns->_libc_gethostbyname(name);
1255 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
1256 static struct hostent *libc_gethostbyname2(const char *name, int af)
1258 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname2);
1260 return nwrap_main_global->libc->fns->_libc_gethostbyname2(name, af);
1264 static struct hostent *libc_gethostbyaddr(const void *addr,
1268 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr);
1270 return nwrap_main_global->libc->fns->_libc_gethostbyaddr(addr,
1275 static int libc_gethostname(char *name, size_t len)
1277 nwrap_load_lib_function(NWRAP_LIBNSL, gethostname);
1279 return nwrap_main_global->libc->fns->_libc_gethostname(name, len);
1282 #ifdef HAVE_GETHOSTBYNAME_R
1283 static int libc_gethostbyname_r(const char *name,
1284 struct hostent *ret,
1287 struct hostent **result,
1290 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname_r);
1292 return nwrap_main_global->libc->fns->_libc_gethostbyname_r(name,
1301 #ifdef HAVE_GETHOSTBYADDR_R
1302 static int libc_gethostbyaddr_r(const void *addr,
1305 struct hostent *ret,
1308 struct hostent **result,
1311 nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr_r);
1313 return nwrap_main_global->libc->fns->_libc_gethostbyaddr_r(addr,
1324 static int libc_getaddrinfo(const char *node,
1325 const char *service,
1326 const struct addrinfo *hints,
1327 struct addrinfo **res)
1329 nwrap_load_lib_function(NWRAP_LIBSOCKET, getaddrinfo);
1331 return nwrap_main_global->libc->fns->_libc_getaddrinfo(node,
1337 static int libc_getnameinfo(const struct sockaddr *sa,
1345 nwrap_load_lib_function(NWRAP_LIBSOCKET, getnameinfo);
1347 return nwrap_main_global->libc->fns->_libc_getnameinfo(sa,
1356 /*********************************************************
1357 * NWRAP NSS MODULE LOADER FUNCTIONS
1358 *********************************************************/
1360 static void *nwrap_load_module_fn(struct nwrap_backend *b,
1361 const char *fn_name)
1366 if (!b->so_handle) {
1367 NWRAP_LOG(NWRAP_LOG_ERROR, "No handle");
1371 if (asprintf(&s, "_nss_%s_%s", b->name, fn_name) == -1) {
1372 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1376 res = dlsym(b->so_handle, s);
1378 NWRAP_LOG(NWRAP_LOG_ERROR,
1379 "Cannot find function %s in %s",
1386 static struct nwrap_module_nss_fns *nwrap_load_module_fns(struct nwrap_backend *b)
1388 struct nwrap_module_nss_fns *fns;
1390 if (!b->so_handle) {
1394 fns = (struct nwrap_module_nss_fns *)malloc(sizeof(struct nwrap_module_nss_fns));
1399 *(void **)(&fns->_nss_getpwnam_r) =
1400 nwrap_load_module_fn(b, "getpwnam_r");
1401 *(void **)(&fns->_nss_getpwuid_r) =
1402 nwrap_load_module_fn(b, "getpwuid_r");
1403 *(void **)(&fns->_nss_setpwent) =
1404 nwrap_load_module_fn(b, "setpwent");
1405 *(void **)(&fns->_nss_getpwent_r) =
1406 nwrap_load_module_fn(b, "getpwent_r");
1407 *(void **)(&fns->_nss_endpwent) =
1408 nwrap_load_module_fn(b, "endpwent");
1409 *(void **)(&fns->_nss_initgroups) =
1410 nwrap_load_module_fn(b, "initgroups_dyn");
1411 *(void **)(&fns->_nss_getgrnam_r) =
1412 nwrap_load_module_fn(b, "getgrnam_r");
1413 *(void **)(&fns->_nss_getgrgid_r)=
1414 nwrap_load_module_fn(b, "getgrgid_r");
1415 *(void **)(&fns->_nss_setgrent) =
1416 nwrap_load_module_fn(b, "setgrent");
1417 *(void **)(&fns->_nss_getgrent_r) =
1418 nwrap_load_module_fn(b, "getgrent_r");
1419 *(void **)(&fns->_nss_endgrent) =
1420 nwrap_load_module_fn(b, "endgrent");
1425 static void *nwrap_load_module(const char *so_path)
1429 if (!so_path || !strlen(so_path)) {
1433 h = dlopen(so_path, RTLD_LAZY);
1435 NWRAP_LOG(NWRAP_LOG_ERROR,
1436 "Cannot open shared library %s",
1444 static bool nwrap_module_init(const char *name,
1445 struct nwrap_ops *ops,
1446 const char *so_path,
1448 struct nwrap_backend **backends)
1450 struct nwrap_backend *b;
1452 *backends = (struct nwrap_backend *)realloc(*backends,
1453 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
1455 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1459 b = &((*backends)[*num_backends]);
1463 b->so_path = so_path;
1465 if (so_path != NULL) {
1466 b->so_handle = nwrap_load_module(so_path);
1467 b->fns = nwrap_load_module_fns(b);
1468 if (b->fns == NULL) {
1472 b->so_handle = NULL;
1481 static void nwrap_libc_init(struct nwrap_main *r)
1483 r->libc = malloc(sizeof(struct nwrap_libc));
1484 if (r->libc == NULL) {
1485 printf("Failed to allocate memory for libc");
1488 ZERO_STRUCTP(r->libc);
1490 r->libc->fns = malloc(sizeof(struct nwrap_libc_fns));
1491 if (r->libc->fns == NULL) {
1492 printf("Failed to allocate memory for libc functions");
1495 ZERO_STRUCTP(r->libc->fns);
1498 static void nwrap_backend_init(struct nwrap_main *r)
1500 const char *module_so_path = getenv("NSS_WRAPPER_MODULE_SO_PATH");
1501 const char *module_fn_name = getenv("NSS_WRAPPER_MODULE_FN_PREFIX");
1503 r->num_backends = 0;
1506 if (!nwrap_module_init("files", &nwrap_files_ops, NULL,
1509 NWRAP_LOG(NWRAP_LOG_ERROR,
1510 "Failed to initialize 'files' backend");
1514 if (module_so_path != NULL &&
1515 module_so_path[0] != '\0' &&
1516 module_fn_name != NULL &&
1517 module_fn_name[0] != '\0') {
1518 if (!nwrap_module_init(module_fn_name,
1523 NWRAP_LOG(NWRAP_LOG_ERROR,
1524 "Failed to initialize '%s' backend",
1531 static void nwrap_init(void)
1535 size_t max_hostents_tmp;
1537 NWRAP_LOCK(nwrap_initialized);
1538 if (nwrap_initialized) {
1539 NWRAP_UNLOCK(nwrap_initialized);
1544 * Still holding nwrap_initialized lock here.
1545 * We don't use NWRAP_(UN)LOCK_ALL macros here because we
1546 * want to avoid overhead when other threads do their job.
1548 NWRAP_LOCK(nwrap_global);
1549 NWRAP_LOCK(nwrap_gr_global);
1550 NWRAP_LOCK(nwrap_he_global);
1551 NWRAP_LOCK(nwrap_pw_global);
1552 NWRAP_LOCK(nwrap_sp_global);
1554 nwrap_initialized = true;
1556 /* Initialize pthread_atfork handlers */
1557 pthread_atfork(&nwrap_thread_prepare, &nwrap_thread_parent,
1558 &nwrap_thread_child);
1560 env = getenv("NSS_WRAPPER_MAX_HOSTENTS");
1562 max_hostents_tmp = (size_t)strtol(env, &endptr, 10);
1563 if (((env != '\0') && (endptr == '\0')) ||
1564 (max_hostents_tmp == 0)) {
1565 NWRAP_LOG(NWRAP_LOG_DEBUG,
1566 "Error parsing NSS_WRAPPER_MAX_HOSTENTS "
1567 "value or value is too small. "
1568 "Using default value: %lu.",
1569 (unsigned long)max_hostents);
1571 max_hostents = max_hostents_tmp;
1574 /* Initialize hash table */
1575 NWRAP_LOG(NWRAP_LOG_DEBUG,
1576 "Initializing hash table of size %lu items.",
1577 (unsigned long)max_hostents);
1578 if (hcreate(max_hostents) == 0) {
1579 NWRAP_LOG(NWRAP_LOG_ERROR,
1580 "Failed to initialize hash table");
1584 nwrap_main_global = &__nwrap_main_global;
1586 nwrap_libc_init(nwrap_main_global);
1588 nwrap_backend_init(nwrap_main_global);
1591 nwrap_pw_global.cache = &__nwrap_cache_pw;
1593 nwrap_pw_global.cache->path = getenv("NSS_WRAPPER_PASSWD");
1594 nwrap_pw_global.cache->fp = NULL;
1595 nwrap_pw_global.cache->fd = -1;
1596 nwrap_pw_global.cache->private_data = &nwrap_pw_global;
1597 nwrap_pw_global.cache->parse_line = nwrap_pw_parse_line;
1598 nwrap_pw_global.cache->unload = nwrap_pw_unload;
1601 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1602 nwrap_sp_global.cache = &__nwrap_cache_sp;
1604 nwrap_sp_global.cache->path = getenv("NSS_WRAPPER_SHADOW");
1605 nwrap_sp_global.cache->fp = NULL;
1606 nwrap_sp_global.cache->fd = -1;
1607 nwrap_sp_global.cache->private_data = &nwrap_sp_global;
1608 nwrap_sp_global.cache->parse_line = nwrap_sp_parse_line;
1609 nwrap_sp_global.cache->unload = nwrap_sp_unload;
1610 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1613 nwrap_gr_global.cache = &__nwrap_cache_gr;
1615 nwrap_gr_global.cache->path = getenv("NSS_WRAPPER_GROUP");
1616 nwrap_gr_global.cache->fp = NULL;
1617 nwrap_gr_global.cache->fd = -1;
1618 nwrap_gr_global.cache->private_data = &nwrap_gr_global;
1619 nwrap_gr_global.cache->parse_line = nwrap_gr_parse_line;
1620 nwrap_gr_global.cache->unload = nwrap_gr_unload;
1623 nwrap_he_global.cache = &__nwrap_cache_he;
1625 nwrap_he_global.cache->path = getenv("NSS_WRAPPER_HOSTS");
1626 nwrap_he_global.cache->fp = NULL;
1627 nwrap_he_global.cache->fd = -1;
1628 nwrap_he_global.cache->private_data = &nwrap_he_global;
1629 nwrap_he_global.cache->parse_line = nwrap_he_parse_line;
1630 nwrap_he_global.cache->unload = nwrap_he_unload;
1633 /* We hold all locks here so we can use NWRAP_UNLOCK_ALL. */
1637 bool nss_wrapper_enabled(void)
1641 if (nwrap_pw_global.cache->path == NULL ||
1642 nwrap_pw_global.cache->path[0] == '\0') {
1645 if (nwrap_gr_global.cache->path == NULL ||
1646 nwrap_gr_global.cache->path[0] == '\0') {
1653 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1654 bool nss_wrapper_shadow_enabled(void)
1658 if (nwrap_sp_global.cache->path == NULL ||
1659 nwrap_sp_global.cache->path[0] == '\0') {
1665 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1667 bool nss_wrapper_hosts_enabled(void)
1671 if (nwrap_he_global.cache->path == NULL ||
1672 nwrap_he_global.cache->path[0] == '\0') {
1679 static bool nwrap_hostname_enabled(void)
1683 if (getenv("NSS_WRAPPER_HOSTNAME") == NULL) {
1690 static bool nwrap_parse_file(struct nwrap_cache *nwrap)
1694 /* Unused but getline needs it */
1698 if (nwrap->st.st_size == 0) {
1699 NWRAP_LOG(NWRAP_LOG_DEBUG, "size == 0");
1703 /* Support for 32-bit system I guess */
1704 if (nwrap->st.st_size > INT32_MAX) {
1705 NWRAP_LOG(NWRAP_LOG_ERROR,
1706 "Size[%u] larger than INT32_MAX",
1707 (unsigned)nwrap->st.st_size);
1714 n = getline(&line, &len, nwrap->fp);
1717 if (feof(nwrap->fp)) {
1721 NWRAP_LOG(NWRAP_LOG_ERROR,
1722 "Unable to read line from file: %s",
1727 if (line[n - 1] == '\n') {
1731 if (line[0] == '\0') {
1736 ok = nwrap->parse_line(nwrap, line);
1738 NWRAP_LOG(NWRAP_LOG_ERROR,
1739 "Unable to parse line file: %s",
1745 /* Line is parsed without issues so add it to list */
1746 ok = nwrap_vector_add_item(&(nwrap->lines), (void *const) line);
1748 NWRAP_LOG(NWRAP_LOG_ERROR,
1749 "Unable to add line to vector");
1753 /* This forces getline to allocate new memory for line. */
1755 } while (!feof(nwrap->fp));
1760 static void nwrap_files_cache_unload(struct nwrap_cache *nwrap)
1762 nwrap->unload(nwrap);
1764 nwrap_lines_unload(nwrap);
1767 static bool nwrap_files_cache_reload(struct nwrap_cache *nwrap)
1772 bool retried = false;
1774 assert(nwrap != NULL);
1777 if (nwrap->fd < 0) {
1778 nwrap->fp = fopen(nwrap->path, "re");
1779 if (nwrap->fp == NULL) {
1781 NWRAP_LOG(NWRAP_LOG_ERROR,
1782 "Unable to open '%s' readonly %d:%s",
1783 nwrap->path, nwrap->fd,
1788 nwrap->fd = fileno(nwrap->fp);
1789 NWRAP_LOG(NWRAP_LOG_DEBUG, "Open '%s'", nwrap->path);
1792 ret = fstat(nwrap->fd, &st);
1794 NWRAP_LOG(NWRAP_LOG_ERROR,
1795 "fstat(%s) - %d:%s",
1805 if (retried == false && st.st_nlink == 0) {
1806 /* maybe someone has replaced the file... */
1807 NWRAP_LOG(NWRAP_LOG_TRACE,
1808 "st_nlink == 0, reopen %s",
1811 memset(&nwrap->st, 0, sizeof(nwrap->st));
1818 if (st.st_mtime == nwrap->st.st_mtime) {
1819 NWRAP_LOG(NWRAP_LOG_TRACE,
1820 "st_mtime[%u] hasn't changed, skip reload",
1821 (unsigned)st.st_mtime);
1825 NWRAP_LOG(NWRAP_LOG_TRACE,
1826 "st_mtime has changed [%u] => [%u], start reload",
1827 (unsigned)st.st_mtime,
1828 (unsigned)nwrap->st.st_mtime);
1832 nwrap_files_cache_unload(nwrap);
1834 ok = nwrap_parse_file(nwrap);
1836 NWRAP_LOG(NWRAP_LOG_ERROR, "Failed to reload %s", nwrap->path);
1837 nwrap_files_cache_unload(nwrap);
1841 NWRAP_LOG(NWRAP_LOG_TRACE, "Reloaded %s", nwrap->path);
1846 * the caller has to call nwrap_unload() on failure
1848 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line)
1850 struct nwrap_pw *nwrap_pw;
1857 nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
1859 list_size = sizeof(*nwrap_pw->list) * (nwrap_pw->num+1);
1860 pw = (struct passwd *)realloc(nwrap_pw->list, list_size);
1862 NWRAP_LOG(NWRAP_LOG_ERROR,
1863 "realloc(%u) failed",
1864 (unsigned)list_size);
1867 nwrap_pw->list = pw;
1869 pw = &nwrap_pw->list[nwrap_pw->num];
1876 NWRAP_LOG(NWRAP_LOG_ERROR,
1877 "Invalid line[%s]: '%s'",
1887 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", pw->pw_name);
1892 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1900 NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]\n", pw->pw_passwd);
1905 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1911 pw->pw_uid = (uid_t)strtoul(c, &e, 10);
1913 NWRAP_LOG(NWRAP_LOG_ERROR,
1914 "Invalid line[%s]: '%s' - %s",
1915 line, c, strerror(errno));
1919 NWRAP_LOG(NWRAP_LOG_ERROR,
1920 "Invalid line[%s]: '%s' - %s",
1921 line, c, strerror(errno));
1925 NWRAP_LOG(NWRAP_LOG_ERROR,
1926 "Invalid line[%s]: '%s' - %s",
1927 line, c, strerror(errno));
1932 NWRAP_LOG(NWRAP_LOG_TRACE, "uid[%u]", pw->pw_uid);
1937 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1943 pw->pw_gid = (gid_t)strtoul(c, &e, 10);
1945 NWRAP_LOG(NWRAP_LOG_ERROR,
1946 "Invalid line[%s]: '%s' - %s",
1947 line, c, strerror(errno));
1951 NWRAP_LOG(NWRAP_LOG_ERROR,
1952 "Invalid line[%s]: '%s' - %s",
1953 line, c, strerror(errno));
1957 NWRAP_LOG(NWRAP_LOG_ERROR,
1958 "Invalid line[%s]: '%s' - %s",
1959 line, c, strerror(errno));
1964 NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]\n", pw->pw_gid);
1969 NWRAP_LOG(NWRAP_LOG_ERROR, "invalid line[%s]: '%s'", line, c);
1977 NWRAP_LOG(NWRAP_LOG_TRACE, "gecos[%s]", pw->pw_gecos);
1982 NWRAP_LOG(NWRAP_LOG_ERROR, "'%s'", c);
1990 NWRAP_LOG(NWRAP_LOG_TRACE, "dir[%s]", pw->pw_dir);
1994 NWRAP_LOG(NWRAP_LOG_TRACE, "shell[%s]", pw->pw_shell);
1996 NWRAP_LOG(NWRAP_LOG_DEBUG,
1997 "Added user[%s:%s:%u:%u:%s:%s:%s]",
1998 pw->pw_name, pw->pw_passwd,
1999 pw->pw_uid, pw->pw_gid,
2000 pw->pw_gecos, pw->pw_dir, pw->pw_shell);
2006 static void nwrap_pw_unload(struct nwrap_cache *nwrap)
2008 struct nwrap_pw *nwrap_pw;
2009 nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
2011 SAFE_FREE(nwrap_pw->list);
2016 static int nwrap_pw_copy_r(const struct passwd *src, struct passwd *dst,
2017 char *buf, size_t buflen, struct passwd **dstp)
2023 first = src->pw_name;
2025 last = src->pw_shell;
2026 while (*last) last++;
2028 ofs = PTR_DIFF(last + 1, first);
2030 if (ofs > (off_t) buflen) {
2034 memcpy(buf, first, ofs);
2036 ofs = PTR_DIFF(src->pw_name, first);
2037 dst->pw_name = buf + ofs;
2038 ofs = PTR_DIFF(src->pw_passwd, first);
2039 dst->pw_passwd = buf + ofs;
2040 dst->pw_uid = src->pw_uid;
2041 dst->pw_gid = src->pw_gid;
2042 ofs = PTR_DIFF(src->pw_gecos, first);
2043 dst->pw_gecos = buf + ofs;
2044 ofs = PTR_DIFF(src->pw_dir, first);
2045 dst->pw_dir = buf + ofs;
2046 ofs = PTR_DIFF(src->pw_shell, first);
2047 dst->pw_shell = buf + ofs;
2056 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
2057 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line)
2059 struct nwrap_sp *nwrap_sp;
2066 nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2068 list_size = sizeof(*nwrap_sp->list) * (nwrap_sp->num+1);
2069 sp = (struct spwd *)realloc(nwrap_sp->list, list_size);
2071 NWRAP_LOG(NWRAP_LOG_ERROR,
2072 "realloc(%u) failed",
2073 (unsigned)list_size);
2076 nwrap_sp->list = sp;
2078 sp = &nwrap_sp->list[nwrap_sp->num];
2085 NWRAP_LOG(NWRAP_LOG_ERROR,
2086 "name -- Invalid line[%s]: '%s'",
2096 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", sp->sp_namp);
2101 NWRAP_LOG(NWRAP_LOG_ERROR,
2102 "pwd -- Invalid line[%s]: '%s'",
2119 NWRAP_LOG(NWRAP_LOG_ERROR,
2120 "lstchg -- Invalid line[%s]: '%s'",
2127 sp->sp_lstchg = strtol(c, &e, 10);
2129 NWRAP_LOG(NWRAP_LOG_ERROR,
2130 "lstchg -- Invalid line[%s]: '%s' - %s",
2131 line, c, strerror(errno));
2135 NWRAP_LOG(NWRAP_LOG_ERROR,
2136 "lstchg -- Invalid line[%s]: '%s' - %s",
2137 line, c, strerror(errno));
2141 NWRAP_LOG(NWRAP_LOG_ERROR,
2142 "lstchg -- Invalid line[%s]: '%s' - %s",
2143 line, c, strerror(errno));
2156 NWRAP_LOG(NWRAP_LOG_ERROR,
2157 "min -- Invalid line[%s]: '%s'",
2164 sp->sp_min = strtol(c, &e, 10);
2166 NWRAP_LOG(NWRAP_LOG_ERROR,
2167 "min -- Invalid line[%s]: '%s' - %s",
2168 line, c, strerror(errno));
2172 NWRAP_LOG(NWRAP_LOG_ERROR,
2173 "min -- Invalid line[%s]: '%s' - %s",
2174 line, c, strerror(errno));
2178 NWRAP_LOG(NWRAP_LOG_ERROR,
2179 "min -- Invalid line[%s]: '%s' - %s",
2180 line, c, strerror(errno));
2193 NWRAP_LOG(NWRAP_LOG_ERROR,
2194 "max -- Invalid line[%s]: '%s'",
2201 sp->sp_max = strtol(c, &e, 10);
2203 NWRAP_LOG(NWRAP_LOG_ERROR,
2204 "max -- Invalid line[%s]: '%s' - %s",
2205 line, c, strerror(errno));
2209 NWRAP_LOG(NWRAP_LOG_ERROR,
2210 "max -- Invalid line[%s]: '%s' - %s",
2211 line, c, strerror(errno));
2215 NWRAP_LOG(NWRAP_LOG_ERROR,
2216 "max -- Invalid line[%s]: '%s' - %s",
2217 line, c, strerror(errno));
2230 NWRAP_LOG(NWRAP_LOG_ERROR,
2231 "warn -- Invalid line[%s]: '%s'",
2238 sp->sp_warn = strtol(c, &e, 10);
2240 NWRAP_LOG(NWRAP_LOG_ERROR,
2241 "warn -- Invalid line[%s]: '%s' - %s",
2242 line, c, strerror(errno));
2246 NWRAP_LOG(NWRAP_LOG_ERROR,
2247 "warn -- Invalid line[%s]: '%s' - %s",
2248 line, c, strerror(errno));
2252 NWRAP_LOG(NWRAP_LOG_ERROR,
2253 "warn -- Invalid line[%s]: '%s' - %s",
2254 line, c, strerror(errno));
2267 NWRAP_LOG(NWRAP_LOG_ERROR,
2268 "inact -- Invalid line[%s]: '%s'",
2275 sp->sp_inact = strtol(c, &e, 10);
2277 NWRAP_LOG(NWRAP_LOG_ERROR,
2278 "inact -- Invalid line[%s]: '%s' - %s",
2279 line, c, strerror(errno));
2283 NWRAP_LOG(NWRAP_LOG_ERROR,
2284 "inact -- Invalid line[%s]: '%s' - %s",
2285 line, c, strerror(errno));
2289 NWRAP_LOG(NWRAP_LOG_ERROR,
2290 "inact -- Invalid line[%s]: '%s' - %s",
2291 line, c, strerror(errno));
2304 NWRAP_LOG(NWRAP_LOG_ERROR,
2305 "expire -- Invalid line[%s]: '%s'",
2312 sp->sp_expire = strtol(c, &e, 10);
2314 NWRAP_LOG(NWRAP_LOG_ERROR,
2315 "expire -- Invalid line[%s]: '%s' - %s",
2316 line, c, strerror(errno));
2320 NWRAP_LOG(NWRAP_LOG_ERROR,
2321 "expire -- Invalid line[%s]: '%s' - %s",
2322 line, c, strerror(errno));
2326 NWRAP_LOG(NWRAP_LOG_ERROR,
2327 "expire -- Invalid line[%s]: '%s' - %s",
2328 line, c, strerror(errno));
2338 static void nwrap_sp_unload(struct nwrap_cache *nwrap)
2340 struct nwrap_sp *nwrap_sp;
2341 nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2343 SAFE_FREE(nwrap_sp->list);
2347 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
2350 * the caller has to call nwrap_unload() on failure
2352 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line)
2354 struct nwrap_gr *nwrap_gr;
2362 nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2364 list_size = sizeof(*nwrap_gr->list) * (nwrap_gr->num+1);
2365 gr = (struct group *)realloc(nwrap_gr->list, list_size);
2367 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc failed");
2370 nwrap_gr->list = gr;
2372 gr = &nwrap_gr->list[nwrap_gr->num];
2379 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2387 NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]", gr->gr_name);
2392 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2400 NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]", gr->gr_passwd);
2405 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2411 gr->gr_gid = (gid_t)strtoul(c, &e, 10);
2413 NWRAP_LOG(NWRAP_LOG_ERROR,
2414 "Invalid line[%s]: '%s' - %s",
2415 line, c, strerror(errno));
2419 NWRAP_LOG(NWRAP_LOG_ERROR,
2420 "Invalid line[%s]: '%s' - %s",
2421 line, c, strerror(errno));
2425 NWRAP_LOG(NWRAP_LOG_ERROR,
2426 "Invalid line[%s]: '%s' - %s",
2427 line, c, strerror(errno));
2432 NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]", gr->gr_gid);
2435 gr->gr_mem = (char **)malloc(sizeof(char *));
2437 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
2440 gr->gr_mem[0] = NULL;
2442 for(nummem=0; p; nummem++) {
2452 if (strlen(c) == 0) {
2456 m_size = sizeof(char *) * (nummem+2);
2457 m = (char **)realloc(gr->gr_mem, m_size);
2459 NWRAP_LOG(NWRAP_LOG_ERROR,
2460 "realloc(%zd) failed",
2465 gr->gr_mem[nummem] = c;
2466 gr->gr_mem[nummem+1] = NULL;
2468 NWRAP_LOG(NWRAP_LOG_TRACE,
2470 nummem, gr->gr_mem[nummem]);
2473 NWRAP_LOG(NWRAP_LOG_DEBUG,
2474 "Added group[%s:%s:%u:] with %u members",
2475 gr->gr_name, gr->gr_passwd, gr->gr_gid, nummem);
2481 static void nwrap_gr_unload(struct nwrap_cache *nwrap)
2484 struct nwrap_gr *nwrap_gr;
2485 nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2487 if (nwrap_gr->list) {
2488 for (i=0; i < nwrap_gr->num; i++) {
2489 SAFE_FREE(nwrap_gr->list[i].gr_mem);
2491 SAFE_FREE(nwrap_gr->list);
2498 static int nwrap_gr_copy_r(const struct group *src, struct group *dst,
2499 char *buf, size_t buflen, struct group **dstp)
2509 first = src->gr_name;
2511 lastm = src->gr_mem;
2518 last = src->gr_passwd;
2520 while (*last) last++;
2522 ofsb = PTR_DIFF(last + 1, first);
2523 ofsm = PTR_DIFF(lastm + 1, src->gr_mem);
2525 if ((ofsb + ofsm) > (off_t) buflen) {
2529 memcpy(buf, first, ofsb);
2530 memcpy(buf + ofsb, src->gr_mem, ofsm);
2532 ofs = PTR_DIFF(src->gr_name, first);
2533 dst->gr_name = buf + ofs;
2534 ofs = PTR_DIFF(src->gr_passwd, first);
2535 dst->gr_passwd = buf + ofs;
2536 dst->gr_gid = src->gr_gid;
2538 dst->gr_mem = (char **)(buf + ofsb);
2539 for (i=0; src->gr_mem[i]; i++) {
2540 ofs = PTR_DIFF(src->gr_mem[i], first);
2541 dst->gr_mem[i] = buf + ofs;
2551 static struct nwrap_entlist *nwrap_entlist_init(struct nwrap_entdata *ed)
2553 struct nwrap_entlist *el;
2556 NWRAP_LOG(NWRAP_LOG_ERROR,
2557 "entry is NULL, can't create list item");
2561 el = (struct nwrap_entlist *)malloc(sizeof(struct nwrap_entlist));
2563 NWRAP_LOG(NWRAP_LOG_ERROR, "malloc failed");
2573 static bool nwrap_ed_inventarize_add_new(char *const h_name,
2574 struct nwrap_entdata *const ed)
2578 struct nwrap_entlist *el;
2581 if (h_name == NULL) {
2582 NWRAP_LOG(NWRAP_LOG_ERROR, "h_name NULL - can't add");
2586 el = nwrap_entlist_init(ed);
2592 e.data = (void *)el;
2594 p = hsearch(e, ENTER);
2596 NWRAP_LOG(NWRAP_LOG_ERROR, "Hash table is full!");
2600 ok = nwrap_vector_add_item(&(nwrap_he_global.lists), (void *)el);
2602 NWRAP_LOG(NWRAP_LOG_ERROR,
2603 "Failed to add list entry to vector.");
2610 static bool nwrap_ed_inventarize_add_to_existing(struct nwrap_entdata *const ed,
2611 struct nwrap_entlist *const el)
2613 struct nwrap_entlist *cursor;
2614 struct nwrap_entlist *el_new;
2617 NWRAP_LOG(NWRAP_LOG_ERROR, "list is NULL, can not add");
2622 for (cursor = el; cursor->next != NULL; cursor = cursor->next)
2624 if (cursor->ed == ed) {
2625 /* The entry already exists in this list. */
2630 if (cursor->ed == ed) {
2631 /* The entry already exists in this list. */
2635 el_new = nwrap_entlist_init(ed);
2636 if (el_new == NULL) {
2640 cursor->next = el_new;
2644 static bool nwrap_ed_inventarize(char *const name,
2645 struct nwrap_entdata *const ed)
2654 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2656 p = hsearch(e, FIND);
2658 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", name);
2659 ok = nwrap_ed_inventarize_add_new(name, ed);
2661 struct nwrap_entlist *el = (struct nwrap_entlist *)p->data;
2663 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", name);
2664 ok = nwrap_ed_inventarize_add_to_existing(ed, el);
2670 static bool nwrap_add_hname(struct nwrap_entdata *const ed)
2672 char *const h_name = (char *const)(ed->ht.h_name);
2676 ok = nwrap_ed_inventarize(h_name, ed);
2681 if (ed->ht.h_aliases == NULL) {
2685 /* Itemize aliases */
2686 for (i = 0; ed->ht.h_aliases[i] != NULL; ++i) {
2689 h_name_alias = ed->ht.h_aliases[i];
2691 NWRAP_LOG(NWRAP_LOG_DEBUG, "Add alias: %s", h_name_alias);
2693 if (!nwrap_ed_inventarize(h_name_alias, ed)) {
2694 NWRAP_LOG(NWRAP_LOG_ERROR,
2695 "Unable to add alias: %s", h_name_alias);
2703 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line)
2705 struct nwrap_he *nwrap_he = (struct nwrap_he *)nwrap->private_data;
2706 bool do_aliases = true;
2707 ssize_t aliases_count = 0;
2715 struct nwrap_entdata *ed = (struct nwrap_entdata *)
2716 malloc(sizeof(struct nwrap_entdata));
2718 NWRAP_LOG(NWRAP_LOG_ERROR,
2719 "Unable to allocate memory for nwrap_entdata");
2730 /* Walk to first char */
2731 for (p = i; *p != '.' && *p != ':' && !isxdigit((int) *p); p++) {
2733 NWRAP_LOG(NWRAP_LOG_ERROR,
2734 "Invalid line[%s]: '%s'",
2741 for (i = p; !isspace((int)*p); p++) {
2743 NWRAP_LOG(NWRAP_LOG_ERROR,
2744 "Invalid line[%s]: '%s'",
2753 if (inet_pton(AF_INET, i, ed->addr.host_addr)) {
2754 ed->ht.h_addrtype = AF_INET;
2755 ed->ht.h_length = 4;
2757 } else if (inet_pton(AF_INET6, i, ed->addr.host_addr)) {
2758 ed->ht.h_addrtype = AF_INET6;
2759 ed->ht.h_length = 16;
2762 NWRAP_LOG(NWRAP_LOG_ERROR,
2763 "Invalid line[%s]: '%s'",
2771 ok = nwrap_vector_add_item(&(ed->nwrap_addrdata),
2772 (void *const)ed->addr.host_addr);
2774 NWRAP_LOG(NWRAP_LOG_ERROR, "Unable to add addrdata to vector");
2778 ed->ht.h_addr_list = nwrap_vector_head(&ed->nwrap_addrdata);
2786 /* Walk to first char */
2787 for (n = p; *p != '_' && !isalnum((int) *p); p++) {
2789 NWRAP_LOG(NWRAP_LOG_ERROR,
2790 "Invalid line[%s]: '%s'",
2798 for (n = p; !isspace((int)*p); p++) {
2807 /* Convert to lowercase. This operate on same memory region */
2811 /* glib's getent always dereferences he->h_aliases */
2812 ed->ht.h_aliases = malloc(sizeof(char *));
2813 if (ed->ht.h_aliases == NULL) {
2817 ed->ht.h_aliases[0] = NULL;
2822 while (do_aliases) {
2828 /* Walk to first char */
2829 for (a = p; *p != '_' && !isalnum((int) *p); p++) {
2835 /* Only trailing spaces are left */
2840 for (a = p; !isspace((int)*p); p++) {
2849 aliases = realloc(ed->ht.h_aliases, sizeof(char *) * (aliases_count + 2));
2850 if (aliases == NULL) {
2854 ed->ht.h_aliases = aliases;
2857 aliases[aliases_count] = a;
2858 aliases[aliases_count + 1] = NULL;
2863 ok = nwrap_vector_add_item(&(nwrap_he->entries), (void *const)ed);
2865 NWRAP_LOG(NWRAP_LOG_ERROR, "Unable to add entry to vector");
2870 ed->aliases_count = aliases_count;
2871 /* Inventarize item */
2872 ok = nwrap_add_hname(ed);
2877 ok = nwrap_ed_inventarize(ip, ed);
2886 static void nwrap_he_unload(struct nwrap_cache *nwrap)
2888 struct nwrap_he *nwrap_he =
2889 (struct nwrap_he *)nwrap->private_data;
2890 struct nwrap_entdata *ed;
2891 struct nwrap_entlist *el;
2894 nwrap_vector_foreach (ed, nwrap_he->entries, i)
2896 SAFE_FREE(ed->nwrap_addrdata.items);
2897 SAFE_FREE(ed->ht.h_aliases);
2900 SAFE_FREE(nwrap_he->entries.items);
2901 nwrap_he->entries.count = nwrap_he->entries.capacity = 0;
2903 nwrap_vector_foreach(el, nwrap_he->lists, i)
2905 while (el != NULL) {
2906 struct nwrap_entlist *el_next;
2913 SAFE_FREE(nwrap_he->lists.items);
2914 nwrap_he->lists.count = nwrap_he->lists.capacity = 0;
2921 /* user functions */
2922 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
2928 (void) b; /* unused */
2930 NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
2932 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
2934 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
2938 for (i=0; i<nwrap_pw_global.num; i++) {
2939 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
2940 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
2941 return &nwrap_pw_global.list[i];
2943 NWRAP_LOG(NWRAP_LOG_DEBUG,
2944 "user[%s] does not match [%s]",
2946 nwrap_pw_global.list[i].pw_name);
2949 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
2955 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
2956 const char *name, struct passwd *pwdst,
2957 char *buf, size_t buflen, struct passwd **pwdstp)
2961 pw = nwrap_files_getpwnam(b, name);
2969 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2972 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
2978 (void) b; /* unused */
2980 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
2982 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
2986 for (i=0; i<nwrap_pw_global.num; i++) {
2987 if (nwrap_pw_global.list[i].pw_uid == uid) {
2988 NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] found", uid);
2989 return &nwrap_pw_global.list[i];
2991 NWRAP_LOG(NWRAP_LOG_DEBUG,
2992 "uid[%u] does not match [%u]",
2994 nwrap_pw_global.list[i].pw_uid);
2997 NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] not found\n", uid);
3003 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
3004 uid_t uid, struct passwd *pwdst,
3005 char *buf, size_t buflen, struct passwd **pwdstp)
3009 pw = nwrap_files_getpwuid(b, uid);
3017 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3020 /* user enum functions */
3021 static void nwrap_files_setpwent(struct nwrap_backend *b)
3023 (void) b; /* unused */
3025 nwrap_pw_global.idx = 0;
3028 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
3032 (void) b; /* unused */
3034 if (nwrap_pw_global.idx == 0) {
3036 ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
3038 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
3043 if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
3048 pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
3050 NWRAP_LOG(NWRAP_LOG_DEBUG,
3051 "return user[%s] uid[%u]",
3052 pw->pw_name, pw->pw_uid);
3057 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
3058 struct passwd *pwdst, char *buf,
3059 size_t buflen, struct passwd **pwdstp)
3063 pw = nwrap_files_getpwent(b);
3071 return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3074 static void nwrap_files_endpwent(struct nwrap_backend *b)
3076 (void) b; /* unused */
3078 nwrap_pw_global.idx = 0;
3083 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
3085 #ifdef HAVE_SETSPENT
3086 static void nwrap_files_setspent(void)
3088 nwrap_sp_global.idx = 0;
3091 static struct spwd *nwrap_files_getspent(void)
3095 if (nwrap_sp_global.idx == 0) {
3098 ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
3100 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
3105 if (nwrap_sp_global.idx >= nwrap_sp_global.num) {
3110 sp = &nwrap_sp_global.list[nwrap_sp_global.idx++];
3112 NWRAP_LOG(NWRAP_LOG_DEBUG,
3119 static void nwrap_files_endspent(void)
3121 nwrap_sp_global.idx = 0;
3123 #endif /* HAVE_SETSPENT */
3125 static struct spwd *nwrap_files_getspnam(const char *name)
3130 NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
3132 ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
3134 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
3138 for (i=0; i<nwrap_sp_global.num; i++) {
3139 if (strcmp(nwrap_sp_global.list[i].sp_namp, name) == 0) {
3140 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
3141 return &nwrap_sp_global.list[i];
3143 NWRAP_LOG(NWRAP_LOG_DEBUG,
3144 "user[%s] does not match [%s]",
3146 nwrap_sp_global.list[i].sp_namp);
3149 NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
3154 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
3156 /* misc functions */
3157 static int nwrap_files_initgroups(struct nwrap_backend *b,
3166 groups = (gid_t *)malloc(size * sizeof(gid_t));
3167 if (groups == NULL) {
3168 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
3174 nwrap_files_setgrent(b);
3175 while ((grp = nwrap_files_getgrent(b)) != NULL) {
3178 NWRAP_LOG(NWRAP_LOG_DEBUG,
3179 "Inspecting %s for group membership",
3182 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
3183 if (group != grp->gr_gid &&
3184 (strcmp(user, grp->gr_mem[i]) == 0)) {
3185 NWRAP_LOG(NWRAP_LOG_DEBUG,
3186 "%s is member of %s",
3190 groups = (gid_t *)realloc(groups,
3191 (size + 1) * sizeof(gid_t));
3192 if (groups == NULL) {
3193 NWRAP_LOG(NWRAP_LOG_ERROR,
3199 groups[size] = grp->gr_gid;
3205 nwrap_files_endgrent(b);
3207 NWRAP_LOG(NWRAP_LOG_DEBUG,
3208 "%s is member of %d groups",
3211 /* This really only works if uid_wrapper is loaded */
3212 rc = setgroups(size, groups);
3219 /* group functions */
3220 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
3226 (void) b; /* unused */
3228 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3230 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3234 for (i=0; i<nwrap_gr_global.num; i++) {
3235 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
3236 NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] found", name);
3237 return &nwrap_gr_global.list[i];
3239 NWRAP_LOG(NWRAP_LOG_DEBUG,
3240 "group[%s] does not match [%s]",
3242 nwrap_gr_global.list[i].gr_name);
3245 NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] not found", name);
3251 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
3252 const char *name, struct group *grdst,
3253 char *buf, size_t buflen, struct group **grdstp)
3257 gr = nwrap_files_getgrnam(b, name);
3265 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3268 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
3274 (void) b; /* unused */
3276 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3278 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3282 for (i=0; i<nwrap_gr_global.num; i++) {
3283 if (nwrap_gr_global.list[i].gr_gid == gid) {
3284 NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] found", gid);
3285 return &nwrap_gr_global.list[i];
3287 NWRAP_LOG(NWRAP_LOG_DEBUG,
3288 "gid[%u] does not match [%u]",
3290 nwrap_gr_global.list[i].gr_gid);
3293 NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] not found", gid);
3299 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
3300 gid_t gid, struct group *grdst,
3301 char *buf, size_t buflen, struct group **grdstp)
3305 gr = nwrap_files_getgrgid(b, gid);
3313 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3316 /* group enum functions */
3317 static void nwrap_files_setgrent(struct nwrap_backend *b)
3319 (void) b; /* unused */
3321 nwrap_gr_global.idx = 0;
3324 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
3328 (void) b; /* unused */
3330 if (nwrap_gr_global.idx == 0) {
3333 ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
3335 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
3340 if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
3345 gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
3347 NWRAP_LOG(NWRAP_LOG_DEBUG,
3348 "return group[%s] gid[%u]",
3349 gr->gr_name, gr->gr_gid);
3354 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
3355 struct group *grdst, char *buf,
3356 size_t buflen, struct group **grdstp)
3360 gr = nwrap_files_getgrent(b);
3368 return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3371 static void nwrap_files_endgrent(struct nwrap_backend *b)
3373 (void) b; /* unused */
3375 nwrap_gr_global.idx = 0;
3378 /* hosts functions */
3379 static int nwrap_files_gethostbyname(const char *name, int af,
3380 struct hostent *result,
3381 struct nwrap_vector *addr_list)
3383 struct nwrap_entlist *el;
3388 char canon_name[DNS_NAME_MAX] = { 0 };
3390 bool he_found = false;
3393 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3395 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3399 name_len = strlen(name);
3400 if (name_len < sizeof(canon_name) && name[name_len - 1] == '.') {
3401 strncpy(canon_name, name, name_len - 1);
3405 if (!str_tolower_copy(&h_name_lower, name)) {
3406 NWRAP_LOG(NWRAP_LOG_DEBUG,
3407 "Out of memory while converting to lower case");
3411 /* Look at hash table for element */
3412 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3413 e.key = h_name_lower;
3415 e_p = hsearch(e, FIND);
3417 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3418 SAFE_FREE(h_name_lower);
3421 SAFE_FREE(h_name_lower);
3423 /* Always cleanup vector and results */
3424 if (!nwrap_vector_is_initialized(addr_list)) {
3425 if (!nwrap_vector_init(addr_list)) {
3426 NWRAP_LOG(NWRAP_LOG_DEBUG,
3427 "Unable to initialize memory for addr_list vector");
3431 /* When vector is initialized data are valid no more.
3432 * Quick way how to free vector is: */
3433 addr_list->count = 0;
3436 /* Iterate through results */
3437 for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
3441 /* Filter by address familiy if provided */
3442 if (af != AF_UNSPEC && he->h_addrtype != af) {
3448 * glibc doesn't return ipv6 addresses when AF_UNSPEC is used
3450 if (af == AF_UNSPEC && he->h_addrtype != AF_INET) {
3455 memcpy(result, he, sizeof(struct hostent));
3456 NWRAP_LOG(NWRAP_LOG_DEBUG,
3457 "Name found. Returning record for %s",
3461 nwrap_vector_merge(addr_list, &el->ed->nwrap_addrdata);
3462 result->h_addr_list = nwrap_vector_head(addr_list);
3468 NWRAP_LOG(NWRAP_LOG_DEBUG,
3469 "Name found in database. No records matches type.");
3476 #ifdef HAVE_GETHOSTBYNAME_R
3477 static int nwrap_gethostbyname_r(const char *name,
3478 struct hostent *ret,
3479 char *buf, size_t buflen,
3480 struct hostent **result, int *h_errnop)
3482 struct nwrap_vector *addr_list = malloc(sizeof(struct nwrap_vector));
3485 if (addr_list == NULL) {
3486 NWRAP_LOG(NWRAP_LOG_ERROR,
3487 "Unable to allocate memory for address list");
3492 ZERO_STRUCTP(addr_list);
3494 rc = nwrap_files_gethostbyname(name, AF_UNSPEC, ret, addr_list);
3496 *h_errnop = h_errno;
3497 if (addr_list->items != NULL) {
3498 free(addr_list->items);
3500 SAFE_FREE(addr_list);
3505 if (buflen < (addr_list->count * sizeof(void *))) {
3506 SAFE_FREE(addr_list->items);
3507 SAFE_FREE(addr_list);
3511 /* Copy all to user provided buffer and change
3512 * pointers in returned structure.
3513 * +1 is for ending NULL pointer. */
3514 memcpy(buf, addr_list->items, (addr_list->count + 1) * sizeof(void *));
3516 free(addr_list->items);
3519 ret->h_addr_list = (char **)buf;
3524 int gethostbyname_r(const char *name,
3525 struct hostent *ret,
3526 char *buf, size_t buflen,
3527 struct hostent **result, int *h_errnop)
3529 if (!nss_wrapper_hosts_enabled()) {
3530 return libc_gethostbyname_r(name,
3538 return nwrap_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
3542 static int nwrap_files_getaddrinfo(const char *name,
3543 unsigned short port,
3544 const struct addrinfo *hints,
3545 struct addrinfo **ai)
3547 struct nwrap_entlist *el;
3549 struct addrinfo *ai_head = NULL;
3550 struct addrinfo *ai_cur = NULL;
3553 char canon_name[DNS_NAME_MAX] = { 0 };
3554 bool skip_canonname = false;
3562 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3564 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3568 name_len = strlen(name);
3569 if (name_len < DNS_NAME_MAX && name[name_len - 1] == '.') {
3570 strncpy(canon_name, name, name_len - 1);
3574 if (!str_tolower_copy(&h_name_lower, name)) {
3575 NWRAP_LOG(NWRAP_LOG_DEBUG,
3576 "Out of memory while converting to lower case");
3580 NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3581 e.key = h_name_lower;
3583 e_p = hsearch(e, FIND);
3585 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3586 SAFE_FREE(h_name_lower);
3590 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name: %s found.", h_name_lower);
3591 SAFE_FREE(h_name_lower);
3594 for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
3597 struct addrinfo *ai_new = NULL;
3601 if (hints->ai_family != AF_UNSPEC &&
3602 he->h_addrtype != hints->ai_family)
3604 NWRAP_LOG(NWRAP_LOG_DEBUG,
3605 "Entry found but with wrong AF - "
3606 "remembering EAI_ADDRINFO.");
3607 rc = EAI_ADDRFAMILY;
3611 /* Function allocates memory and returns it in ai. */
3612 rc2 = nwrap_convert_he_ai(he,
3618 NWRAP_LOG(NWRAP_LOG_ERROR, "Error converting he to ai");
3619 if (ai_head != NULL) {
3620 freeaddrinfo(ai_head);
3624 skip_canonname = true;
3626 if (ai_head == NULL) {
3629 if (ai_cur != NULL) {
3630 ai_cur->ai_next = ai_new;
3635 if (ai_head != NULL) {
3644 static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
3645 socklen_t len, int type)
3648 char ip[NWRAP_INET_ADDRSTRLEN] = {0};
3649 struct nwrap_entdata *ed;
3654 (void) len; /* unused */
3656 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3658 NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
3662 a = inet_ntop(type, addr, ip, sizeof(ip));
3668 nwrap_vector_foreach(ed, nwrap_he_global.entries, i)
3671 if (he->h_addrtype != type) {
3675 if (memcmp(addr, he->h_addr_list[0], he->h_length) == 0) {
3684 #ifdef HAVE_GETHOSTBYADDR_R
3685 static int nwrap_gethostbyaddr_r(const void *addr, socklen_t len, int type,
3686 struct hostent *ret,
3687 char *buf, size_t buflen,
3688 struct hostent **result, int *h_errnop)
3690 *result = nwrap_files_gethostbyaddr(addr, len, type);
3691 if (*result != NULL) {
3692 memset(buf, '\0', buflen);
3696 *h_errnop = h_errno;
3701 int gethostbyaddr_r(const void *addr, socklen_t len, int type,
3702 struct hostent *ret,
3703 char *buf, size_t buflen,
3704 struct hostent **result, int *h_errnop)
3706 if (!nss_wrapper_hosts_enabled()) {
3707 return libc_gethostbyaddr_r(addr,
3717 return nwrap_gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
3721 /* hosts enum functions */
3722 static void nwrap_files_sethostent(void)
3724 nwrap_he_global.idx = 0;
3727 static struct hostent *nwrap_files_gethostent(void)
3731 if (nwrap_he_global.idx == 0) {
3734 ok = nwrap_files_cache_reload(nwrap_he_global.cache);
3736 NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading hosts file");
3741 if (nwrap_he_global.idx >= nwrap_he_global.num) {
3746 he = &((struct nwrap_entdata *)nwrap_he_global.entries.items[nwrap_he_global.idx++])->ht;
3748 NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
3753 static void nwrap_files_endhostent(void)
3755 nwrap_he_global.idx = 0;
3763 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
3766 static struct passwd pwd;
3767 static char buf[1000];
3770 if (!b->fns->_nss_getpwnam_r) {
3774 status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
3775 if (status == NSS_STATUS_NOTFOUND) {
3778 if (status != NSS_STATUS_SUCCESS) {
3785 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
3786 const char *name, struct passwd *pwdst,
3787 char *buf, size_t buflen, struct passwd **pwdstp)
3791 (void) b; /* unused */
3792 (void) pwdst; /* unused */
3793 (void) pwdstp; /* unused */
3795 if (!b->fns->_nss_getpwnam_r) {
3796 return NSS_STATUS_NOTFOUND;
3799 ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
3801 case NSS_STATUS_SUCCESS:
3803 case NSS_STATUS_NOTFOUND:
3808 case NSS_STATUS_TRYAGAIN:
3821 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
3824 static struct passwd pwd;
3825 static char buf[1000];
3828 if (!b->fns->_nss_getpwuid_r) {
3832 status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
3833 if (status == NSS_STATUS_NOTFOUND) {
3836 if (status != NSS_STATUS_SUCCESS) {
3842 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
3843 uid_t uid, struct passwd *pwdst,
3844 char *buf, size_t buflen, struct passwd **pwdstp)
3848 (void) pwdstp; /* unused */
3850 if (!b->fns->_nss_getpwuid_r) {
3854 ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
3856 case NSS_STATUS_SUCCESS:
3858 case NSS_STATUS_NOTFOUND:
3863 case NSS_STATUS_TRYAGAIN:
3876 static void nwrap_module_setpwent(struct nwrap_backend *b)
3878 if (!b->fns->_nss_setpwent) {
3882 b->fns->_nss_setpwent();
3885 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
3887 static struct passwd pwd;
3888 static char buf[1000];
3891 if (!b->fns->_nss_getpwent_r) {
3895 status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
3896 if (status == NSS_STATUS_NOTFOUND) {
3899 if (status != NSS_STATUS_SUCCESS) {
3905 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
3906 struct passwd *pwdst, char *buf,
3907 size_t buflen, struct passwd **pwdstp)
3911 (void) pwdstp; /* unused */
3913 if (!b->fns->_nss_getpwent_r) {
3917 ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
3919 case NSS_STATUS_SUCCESS:
3921 case NSS_STATUS_NOTFOUND:
3926 case NSS_STATUS_TRYAGAIN:
3939 static void nwrap_module_endpwent(struct nwrap_backend *b)
3941 if (!b->fns->_nss_endpwent) {
3945 b->fns->_nss_endpwent();
3948 static int nwrap_module_initgroups(struct nwrap_backend *b,
3949 const char *user, gid_t group)
3955 if (!b->fns->_nss_initgroups) {
3956 return NSS_STATUS_UNAVAIL;
3959 return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
3962 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
3965 static struct group grp;
3967 static int buflen = 1000;
3970 if (!b->fns->_nss_getgrnam_r) {
3975 buf = (char *)malloc(buflen);
3978 status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
3979 if (status == NSS_STATUS_TRYAGAIN) {
3981 buf = (char *)realloc(buf, buflen);
3987 if (status == NSS_STATUS_NOTFOUND) {
3991 if (status != NSS_STATUS_SUCCESS) {
3998 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
3999 const char *name, struct group *grdst,
4000 char *buf, size_t buflen, struct group **grdstp)
4004 (void) grdstp; /* unused */
4006 if (!b->fns->_nss_getgrnam_r) {
4010 ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
4012 case NSS_STATUS_SUCCESS:
4014 case NSS_STATUS_NOTFOUND:
4019 case NSS_STATUS_TRYAGAIN:
4032 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
4035 static struct group grp;
4037 static int buflen = 1000;
4040 if (!b->fns->_nss_getgrgid_r) {
4045 buf = (char *)malloc(buflen);
4049 status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
4050 if (status == NSS_STATUS_TRYAGAIN) {
4052 buf = (char *)realloc(buf, buflen);
4058 if (status == NSS_STATUS_NOTFOUND) {
4062 if (status != NSS_STATUS_SUCCESS) {
4069 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
4070 gid_t gid, struct group *grdst,
4071 char *buf, size_t buflen, struct group **grdstp)
4075 (void) grdstp; /* unused */
4077 if (!b->fns->_nss_getgrgid_r) {
4081 ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
4083 case NSS_STATUS_SUCCESS:
4085 case NSS_STATUS_NOTFOUND:
4090 case NSS_STATUS_TRYAGAIN:
4103 static void nwrap_module_setgrent(struct nwrap_backend *b)
4105 if (!b->fns->_nss_setgrent) {
4109 b->fns->_nss_setgrent();
4112 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
4114 static struct group grp;
4116 static int buflen = 1024;
4119 if (!b->fns->_nss_getgrent_r) {
4124 buf = (char *)malloc(buflen);
4128 status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
4129 if (status == NSS_STATUS_TRYAGAIN) {
4131 buf = (char *)realloc(buf, buflen);
4137 if (status == NSS_STATUS_NOTFOUND) {
4141 if (status != NSS_STATUS_SUCCESS) {
4148 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
4149 struct group *grdst, char *buf,
4150 size_t buflen, struct group **grdstp)
4154 (void) grdstp; /* unused */
4156 if (!b->fns->_nss_getgrent_r) {
4160 ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
4162 case NSS_STATUS_SUCCESS:
4164 case NSS_STATUS_NOTFOUND:
4169 case NSS_STATUS_TRYAGAIN:
4182 static void nwrap_module_endgrent(struct nwrap_backend *b)
4184 if (!b->fns->_nss_endgrent) {
4188 b->fns->_nss_endgrent();
4191 /****************************************************************************
4193 ***************************************************************************/
4195 static struct passwd *nwrap_getpwnam(const char *name)
4200 for (i=0; i < nwrap_main_global->num_backends; i++) {
4201 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4202 pwd = b->ops->nw_getpwnam(b, name);
4211 struct passwd *getpwnam(const char *name)
4213 if (!nss_wrapper_enabled()) {
4214 return libc_getpwnam(name);
4217 return nwrap_getpwnam(name);
4220 /****************************************************************************
4222 ***************************************************************************/
4224 static int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
4225 char *buf, size_t buflen, struct passwd **pwdstp)
4229 for (i=0; i < nwrap_main_global->num_backends; i++) {
4230 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4231 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
4232 if (ret == ENOENT) {
4241 #ifdef HAVE_GETPWNAM_R
4242 # ifdef HAVE_SOLARIS_GETPWNAM_R
4243 int getpwnam_r(const char *name, struct passwd *pwdst,
4244 char *buf, int buflen, struct passwd **pwdstp)
4245 # else /* HAVE_SOLARIS_GETPWNAM_R */
4246 int getpwnam_r(const char *name, struct passwd *pwdst,
4247 char *buf, size_t buflen, struct passwd **pwdstp)
4248 # endif /* HAVE_SOLARIS_GETPWNAM_R */
4250 if (!nss_wrapper_enabled()) {
4251 return libc_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4254 return nwrap_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4258 /****************************************************************************
4260 ***************************************************************************/
4262 static struct passwd *nwrap_getpwuid(uid_t uid)
4267 for (i=0; i < nwrap_main_global->num_backends; i++) {
4268 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4269 pwd = b->ops->nw_getpwuid(b, uid);
4278 struct passwd *getpwuid(uid_t uid)
4280 if (!nss_wrapper_enabled()) {
4281 return libc_getpwuid(uid);
4284 return nwrap_getpwuid(uid);
4287 /****************************************************************************
4289 ***************************************************************************/
4291 static int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
4292 char *buf, size_t buflen, struct passwd **pwdstp)
4296 for (i=0; i < nwrap_main_global->num_backends; i++) {
4297 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4298 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
4299 if (ret == ENOENT) {
4308 #ifdef HAVE_SOLARIS_GETPWUID_R
4309 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4310 char *buf, int buflen, struct passwd **pwdstp)
4312 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4313 char *buf, size_t buflen, struct passwd **pwdstp)
4316 if (!nss_wrapper_enabled()) {
4317 return libc_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4320 return nwrap_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4323 /****************************************************************************
4325 ***************************************************************************/
4327 static void nwrap_setpwent(void)
4331 for (i=0; i < nwrap_main_global->num_backends; i++) {
4332 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4333 b->ops->nw_setpwent(b);
4339 if (!nss_wrapper_enabled()) {
4347 /****************************************************************************
4349 ***************************************************************************/
4351 static struct passwd *nwrap_getpwent(void)
4356 for (i=0; i < nwrap_main_global->num_backends; i++) {
4357 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4358 pwd = b->ops->nw_getpwent(b);
4367 struct passwd *getpwent(void)
4369 if (!nss_wrapper_enabled()) {
4370 return libc_getpwent();
4373 return nwrap_getpwent();
4376 /****************************************************************************
4378 ***************************************************************************/
4380 static int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
4381 size_t buflen, struct passwd **pwdstp)
4385 for (i=0; i < nwrap_main_global->num_backends; i++) {
4386 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4387 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
4388 if (ret == ENOENT) {
4397 #ifdef HAVE_SOLARIS_GETPWENT_R
4398 struct passwd *getpwent_r(struct passwd *pwdst, char *buf, int buflen)
4400 struct passwd *pwdstp = NULL;
4403 if (!nss_wrapper_enabled()) {
4404 return libc_getpwent_r(pwdst, buf, buflen);
4406 rc = nwrap_getpwent_r(pwdst, buf, buflen, &pwdstp);
4413 #else /* HAVE_SOLARIS_GETPWENT_R */
4414 int getpwent_r(struct passwd *pwdst, char *buf,
4415 size_t buflen, struct passwd **pwdstp)
4417 if (!nss_wrapper_enabled()) {
4418 return libc_getpwent_r(pwdst, buf, buflen, pwdstp);
4421 return nwrap_getpwent_r(pwdst, buf, buflen, pwdstp);
4423 #endif /* HAVE_SOLARIS_GETPWENT_R */
4425 /****************************************************************************
4427 ***************************************************************************/
4429 static void nwrap_endpwent(void)
4433 for (i=0; i < nwrap_main_global->num_backends; i++) {
4434 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4435 b->ops->nw_endpwent(b);
4441 if (!nss_wrapper_enabled()) {
4449 /****************************************************************************
4451 ***************************************************************************/
4453 static int nwrap_initgroups(const char *user, gid_t group)
4457 for (i=0; i < nwrap_main_global->num_backends; i++) {
4458 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4461 rc = b->ops->nw_initgroups(b, user, group);
4471 int initgroups(const char *user, gid_t group)
4473 if (!nss_wrapper_enabled()) {
4474 return libc_initgroups(user, group);
4477 return nwrap_initgroups(user, group);
4480 /****************************************************************************
4482 ***************************************************************************/
4484 static struct group *nwrap_getgrnam(const char *name)
4489 for (i=0; i < nwrap_main_global->num_backends; i++) {
4490 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4491 grp = b->ops->nw_getgrnam(b, name);
4500 struct group *getgrnam(const char *name)
4502 if (!nss_wrapper_enabled()) {
4503 return libc_getgrnam(name);
4506 return nwrap_getgrnam(name);
4509 /****************************************************************************
4511 ***************************************************************************/
4513 static int nwrap_getgrnam_r(const char *name, struct group *grdst,
4514 char *buf, size_t buflen, struct group **grdstp)
4518 for (i=0; i < nwrap_main_global->num_backends; i++) {
4519 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4520 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
4521 if (ret == ENOENT) {
4530 #ifdef HAVE_GETGRNAM_R
4531 # ifdef HAVE_SOLARIS_GETGRNAM_R
4532 int getgrnam_r(const char *name, struct group *grp,
4533 char *buf, int buflen, struct group **pgrp)
4534 # else /* HAVE_SOLARIS_GETGRNAM_R */
4535 int getgrnam_r(const char *name, struct group *grp,
4536 char *buf, size_t buflen, struct group **pgrp)
4537 # endif /* HAVE_SOLARIS_GETGRNAM_R */
4539 if (!nss_wrapper_enabled()) {
4540 return libc_getgrnam_r(name,
4547 return nwrap_getgrnam_r(name, grp, buf, buflen, pgrp);
4549 #endif /* HAVE_GETGRNAM_R */
4551 /****************************************************************************
4553 ***************************************************************************/
4555 static struct group *nwrap_getgrgid(gid_t gid)
4560 for (i=0; i < nwrap_main_global->num_backends; i++) {
4561 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4562 grp = b->ops->nw_getgrgid(b, gid);
4571 struct group *getgrgid(gid_t gid)
4573 if (!nss_wrapper_enabled()) {
4574 return libc_getgrgid(gid);
4577 return nwrap_getgrgid(gid);
4580 /****************************************************************************
4582 ***************************************************************************/
4584 static int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
4585 char *buf, size_t buflen, struct group **grdstp)
4589 for (i=0; i < nwrap_main_global->num_backends; i++) {
4590 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4591 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
4592 if (ret == ENOENT) {
4601 #ifdef HAVE_GETGRGID_R
4602 # ifdef HAVE_SOLARIS_GETGRGID_R
4603 int getgrgid_r(gid_t gid, struct group *grdst,
4604 char *buf, int buflen, struct group **grdstp)
4605 # else /* HAVE_SOLARIS_GETGRGID_R */
4606 int getgrgid_r(gid_t gid, struct group *grdst,
4607 char *buf, size_t buflen, struct group **grdstp)
4608 # endif /* HAVE_SOLARIS_GETGRGID_R */
4610 if (!nss_wrapper_enabled()) {
4611 return libc_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4614 return nwrap_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4618 /****************************************************************************
4620 ***************************************************************************/
4622 static void nwrap_setgrent(void)
4626 for (i=0; i < nwrap_main_global->num_backends; i++) {
4627 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4628 b->ops->nw_setgrent(b);
4632 #ifdef HAVE_BSD_SETGRENT
4638 if (!nss_wrapper_enabled()) {
4646 #ifdef HAVE_BSD_SETGRENT
4653 /****************************************************************************
4655 ***************************************************************************/
4657 static struct group *nwrap_getgrent(void)
4662 for (i=0; i < nwrap_main_global->num_backends; i++) {
4663 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4664 grp = b->ops->nw_getgrent(b);
4673 struct group *getgrent(void)
4675 if (!nss_wrapper_enabled()) {
4676 return libc_getgrent();
4679 return nwrap_getgrent();
4682 /****************************************************************************
4684 ***************************************************************************/
4686 static int nwrap_getgrent_r(struct group *grdst, char *buf,
4687 size_t buflen, struct group **grdstp)
4691 for (i=0; i < nwrap_main_global->num_backends; i++) {
4692 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4693 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
4694 if (ret == ENOENT) {
4703 #ifdef HAVE_SOLARIS_GETGRENT_R
4704 struct group *getgrent_r(struct group *src, char *buf, int buflen)
4706 struct group *grdstp = NULL;
4709 if (!nss_wrapper_enabled()) {
4710 return libc_getgrent_r(src, buf, buflen);
4713 rc = nwrap_getgrent_r(src, buf, buflen, &grdstp);
4720 #else /* HAVE_SOLARIS_GETGRENT_R */
4721 int getgrent_r(struct group *src, char *buf,
4722 size_t buflen, struct group **grdstp)
4724 if (!nss_wrapper_enabled()) {
4725 return libc_getgrent_r(src, buf, buflen, grdstp);
4728 return nwrap_getgrent_r(src, buf, buflen, grdstp);
4730 #endif /* HAVE_SOLARIS_GETGRENT_R */
4732 /****************************************************************************
4734 ***************************************************************************/
4736 static void nwrap_endgrent(void)
4740 for (i=0; i < nwrap_main_global->num_backends; i++) {
4741 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4742 b->ops->nw_endgrent(b);
4748 if (!nss_wrapper_enabled()) {
4756 /****************************************************************************
4758 ***************************************************************************/
4760 #ifdef HAVE_GETGROUPLIST
4761 static int nwrap_getgrouplist(const char *user, gid_t group,
4762 gid_t *groups, int *ngroups)
4768 NWRAP_LOG(NWRAP_LOG_DEBUG, "getgrouplist called for %s", user);
4770 groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
4772 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
4776 groups_tmp[0] = group;
4779 while ((grp = nwrap_getgrent()) != NULL) {
4782 NWRAP_LOG(NWRAP_LOG_DEBUG,
4783 "Inspecting %s for group membership",
4786 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
4788 if (group != grp->gr_gid &&
4789 (strcmp(user, grp->gr_mem[i]) == 0)) {
4791 NWRAP_LOG(NWRAP_LOG_DEBUG,
4792 "%s is member of %s",
4796 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
4798 NWRAP_LOG(NWRAP_LOG_ERROR,
4803 groups_tmp[count] = grp->gr_gid;
4812 NWRAP_LOG(NWRAP_LOG_DEBUG,
4813 "%s is member of %d groups",
4816 if (*ngroups < count) {
4823 memcpy(groups, groups_tmp, count * sizeof(gid_t));
4829 int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
4831 if (!nss_wrapper_enabled()) {
4832 return libc_getgrouplist(user, group, groups, ngroups);
4835 return nwrap_getgrouplist(user, group, groups, ngroups);
4839 /**********************************************************
4841 **********************************************************/
4843 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
4845 #ifdef HAVE_SETSPENT
4846 static void nwrap_setspent(void)
4848 nwrap_files_setspent();
4853 if (!nss_wrapper_shadow_enabled()) {
4860 static struct spwd *nwrap_getspent(void)
4862 return nwrap_files_getspent();
4865 struct spwd *getspent(void)
4867 if (!nss_wrapper_shadow_enabled()) {
4871 return nwrap_getspent();
4874 static void nwrap_endspent(void)
4876 nwrap_files_endspent();
4881 if (!nss_wrapper_shadow_enabled()) {
4887 #endif /* HAVE_SETSPENT */
4889 static struct spwd *nwrap_getspnam(const char *name)
4891 return nwrap_files_getspnam(name);
4894 struct spwd *getspnam(const char *name)
4896 if (!nss_wrapper_shadow_enabled()) {
4900 return nwrap_getspnam(name);
4903 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
4905 /**********************************************************
4907 **********************************************************/
4909 static void nwrap_sethostent(int stayopen) {
4910 (void) stayopen; /* ignored */
4912 nwrap_files_sethostent();
4915 #ifdef HAVE_SOLARIS_SETHOSTENT
4916 int sethostent(int stayopen)
4918 if (!nss_wrapper_hosts_enabled()) {
4919 libc_sethostent(stayopen);
4923 nwrap_sethostent(stayopen);
4927 #else /* HAVE_SOLARIS_SETHOSTENT */
4928 void sethostent(int stayopen)
4930 if (!nss_wrapper_hosts_enabled()) {
4931 libc_sethostent(stayopen);
4935 nwrap_sethostent(stayopen);
4937 #endif /* HAVE_SOLARIS_SETHOSTENT */
4939 static struct hostent *nwrap_gethostent(void)
4941 return nwrap_files_gethostent();
4944 struct hostent *gethostent(void) {
4945 if (!nss_wrapper_hosts_enabled()) {
4946 return libc_gethostent();
4949 return nwrap_gethostent();
4952 static void nwrap_endhostent(void) {
4953 nwrap_files_endhostent();
4956 #ifdef HAVE_SOLARIS_ENDHOSTENT
4957 int endhostent(void)
4959 if (!nss_wrapper_hosts_enabled()) {
4968 #else /* HAVE_SOLARIS_ENDHOSTENT */
4969 void endhostent(void)
4971 if (!nss_wrapper_hosts_enabled()) {
4978 #endif /* HAVE_SOLARIS_ENDHOSTENT */
4981 /* BSD implementation stores data in thread local storage but GLIBC does not */
4982 static __thread struct hostent user_he;
4983 static __thread struct nwrap_vector user_addrlist;
4985 static struct hostent user_he;
4986 static struct nwrap_vector user_addrlist;
4988 static struct hostent *nwrap_gethostbyname(const char *name)
4990 if (nwrap_files_gethostbyname(name, AF_UNSPEC, &user_he, &user_addrlist) == -1) {
4996 struct hostent *gethostbyname(const char *name)
4998 if (!nss_wrapper_hosts_enabled()) {
4999 return libc_gethostbyname(name);
5002 return nwrap_gethostbyname(name);
5005 /* This is a GNU extension - Also can be found on BSD systems */
5006 #ifdef HAVE_GETHOSTBYNAME2
5008 /* BSD implementation stores data in thread local storage but GLIBC not */
5009 static __thread struct hostent user_he2;
5010 static __thread struct nwrap_vector user_addrlist2;
5012 static struct hostent user_he2;
5013 static struct nwrap_vector user_addrlist2;
5015 static struct hostent *nwrap_gethostbyname2(const char *name, int af)
5017 if (nwrap_files_gethostbyname(name, af, &user_he2, &user_addrlist2) == -1) {
5023 struct hostent *gethostbyname2(const char *name, int af)
5025 if (!nss_wrapper_hosts_enabled()) {
5026 return libc_gethostbyname2(name, af);
5029 return nwrap_gethostbyname2(name, af);
5033 static struct hostent *nwrap_gethostbyaddr(const void *addr,
5034 socklen_t len, int type)
5036 return nwrap_files_gethostbyaddr(addr, len, type);
5039 struct hostent *gethostbyaddr(const void *addr,
5040 socklen_t len, int type)
5042 if (!nss_wrapper_hosts_enabled()) {
5043 return libc_gethostbyaddr(addr, len, type);
5046 return nwrap_gethostbyaddr(addr, len, type);
5049 static const struct addrinfo default_hints =
5051 .ai_flags = AI_ADDRCONFIG|AI_V4MAPPED,
5052 .ai_family = AF_UNSPEC,
5057 .ai_canonname = NULL,
5061 static int nwrap_convert_he_ai(const struct hostent *he,
5062 unsigned short port,
5063 const struct addrinfo *hints,
5064 struct addrinfo **pai,
5065 bool skip_canonname)
5067 struct addrinfo *ai;
5074 switch (he->h_addrtype) {
5076 socklen = sizeof(struct sockaddr_in);
5080 socklen = sizeof(struct sockaddr_in6);
5087 ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) + socklen);
5092 ai->ai_flags = hints->ai_flags;
5093 ai->ai_family = he->h_addrtype;
5094 ai->ai_socktype = hints->ai_socktype;
5095 ai->ai_protocol = hints->ai_protocol;
5096 ai->ai_canonname = NULL;
5098 if (ai->ai_socktype == 0) {
5099 ai->ai_socktype = SOCK_DGRAM;
5101 if (ai->ai_protocol == 0) {
5102 if (ai->ai_socktype == SOCK_DGRAM) {
5103 ai->ai_protocol = IPPROTO_UDP;
5104 } else if (ai->ai_socktype == SOCK_STREAM) {
5105 ai->ai_protocol = IPPROTO_TCP;
5109 ai->ai_addrlen = socklen;
5110 ai->ai_addr = (void *)(ai + 1);
5112 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
5113 ai->ai_addr->sa_len = socklen;
5115 ai->ai_addr->sa_family = he->h_addrtype;
5117 switch (he->h_addrtype) {
5120 struct sockaddr_in *sinp =
5121 (struct sockaddr_in *) ai->ai_addr;
5123 memset(sinp, 0, sizeof(struct sockaddr_in));
5125 sinp->sin_port = htons(port);
5126 sinp->sin_family = AF_INET;
5128 memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
5129 memcpy(&sinp->sin_addr, he->h_addr_list[0], he->h_length);
5136 struct sockaddr_in6 *sin6p =
5137 (struct sockaddr_in6 *) ai->ai_addr;
5139 memset(sin6p, 0, sizeof(struct sockaddr_in6));
5141 sin6p->sin6_port = htons(port);
5142 sin6p->sin6_family = AF_INET6;
5144 memcpy(&sin6p->sin6_addr,
5154 if (he->h_name && !skip_canonname) {
5155 ai->ai_canonname = strdup(he->h_name);
5156 if (ai->ai_canonname == NULL) {
5166 static int nwrap_getaddrinfo(const char *node,
5167 const char *service,
5168 const struct addrinfo *hints,
5169 struct addrinfo **res)
5171 struct addrinfo *ai = NULL;
5172 unsigned short port = 0;
5182 .family = AF_UNSPEC,
5186 if (node == NULL && service == NULL) {
5190 if (hints == NULL) {
5191 hints = &default_hints;
5195 hints.ai_flags contains invalid flags; or, hints.ai_flags
5196 included AI_CANONNAME and name was NULL.
5198 if ((hints->ai_flags & AI_CANONNAME) && (node == NULL)) {
5199 return EAI_BADFLAGS;
5202 /* If no node has been specified, let glibc deal with it */
5205 struct addrinfo *p = NULL;
5207 ret = libc_getaddrinfo(node, service, hints, &p);
5215 if (service != NULL && service[0] != '\0') {
5216 const char *proto = NULL;
5222 sl = strtol(service, &end_ptr, 10);
5224 if (*end_ptr == '\0') {
5227 } else if (hints->ai_flags & AI_NUMERICSERV) {
5231 if (hints->ai_protocol != 0) {
5232 struct protoent *pent;
5234 pent = getprotobynumber(hints->ai_protocol);
5236 proto = pent->p_name;
5240 s = getservbyname(service, proto);
5244 port = ntohs(s->s_port);
5249 rc = inet_pton(AF_INET, node, &addr.in.v4);
5251 addr.family = AF_INET;
5254 if (addr.family == AF_UNSPEC) {
5255 rc = inet_pton(AF_INET6, node, &addr.in.v6);
5257 addr.family = AF_INET6;
5262 if (addr.family == AF_UNSPEC) {
5263 if (hints->ai_flags & AI_NUMERICHOST) {
5266 } else if ((hints->ai_family != AF_UNSPEC) &&
5267 (hints->ai_family != addr.family))
5269 return EAI_ADDRFAMILY;
5272 rc = nwrap_files_getaddrinfo(node, port, hints, &ai);
5275 struct addrinfo *p = NULL;
5277 ret = libc_getaddrinfo(node, service, hints, &p);
5281 * nwrap_files_getaddrinfo failed, but libc was
5282 * successful -- use the result from libc.
5292 * If the socktype was not specified, duplicate
5293 * each ai returned, so that we have variants for
5296 if (hints->ai_socktype == 0) {
5297 struct addrinfo *ai_cur;
5299 /* freeaddrinfo() frees ai_canonname and ai so allocate them */
5300 for (ai_cur = ai; ai_cur != NULL; ai_cur = ai_cur->ai_next) {
5301 struct addrinfo *ai_new;
5303 /* duplicate the current entry */
5305 ai_new = malloc(sizeof(struct addrinfo));
5306 if (ai_new == NULL) {
5311 memcpy(ai_new, ai_cur, sizeof(struct addrinfo));
5312 ai_new->ai_next = NULL;
5314 /* We need a deep copy or freeaddrinfo() will blow up */
5315 if (ai_cur->ai_canonname != NULL) {
5316 ai_new->ai_canonname =
5317 strdup(ai_cur->ai_canonname);
5320 if (ai_cur->ai_socktype == SOCK_DGRAM) {
5321 ai_new->ai_socktype = SOCK_STREAM;
5322 } else if (ai_cur->ai_socktype == SOCK_STREAM) {
5323 ai_new->ai_socktype = SOCK_DGRAM;
5325 if (ai_cur->ai_protocol == IPPROTO_TCP) {
5326 ai_new->ai_protocol = IPPROTO_UDP;
5327 } else if (ai_cur->ai_protocol == IPPROTO_UDP) {
5328 ai_new->ai_protocol = IPPROTO_TCP;
5331 /* now insert the new entry */
5333 ai_new->ai_next = ai_cur->ai_next;
5334 ai_cur->ai_next = ai_new;
5336 /* and move on (don't duplicate the new entry) */
5347 int getaddrinfo(const char *node, const char *service,
5348 const struct addrinfo *hints,
5349 struct addrinfo **res)
5351 if (!nss_wrapper_hosts_enabled()) {
5352 return libc_getaddrinfo(node, service, hints, res);
5355 return nwrap_getaddrinfo(node, service, hints, res);
5358 static int nwrap_getnameinfo(const struct sockaddr *sa, socklen_t salen,
5359 char *host, size_t hostlen,
5360 char *serv, size_t servlen,
5364 struct servent *service;
5371 if (sa == NULL || salen < sizeof(sa_family_t)) {
5375 if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL) {
5379 type = sa->sa_family;
5382 if (salen < sizeof(struct sockaddr_in))
5384 addr = &((const struct sockaddr_in *)sa)->sin_addr;
5385 addrlen = sizeof(((const struct sockaddr_in *)sa)->sin_addr);
5386 port = ntohs(((const struct sockaddr_in *)sa)->sin_port);
5390 if (salen < sizeof(struct sockaddr_in6))
5392 addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
5393 addrlen = sizeof(((const struct sockaddr_in6 *)sa)->sin6_addr);
5394 port = ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
5403 if ((flags & NI_NUMERICHOST) == 0) {
5404 he = nwrap_files_gethostbyaddr(addr, addrlen, type);
5405 if ((flags & NI_NAMEREQD) && (he == NULL || he->h_name == NULL))
5408 if (he != NULL && he->h_name != NULL) {
5409 if (strlen(he->h_name) >= hostlen)
5410 return EAI_OVERFLOW;
5411 strcpy(host, he->h_name);
5412 if (flags & NI_NOFQDN)
5413 host[strcspn(host, ".")] = '\0';
5415 if (inet_ntop(type, addr, host, hostlen) == NULL)
5416 return (errno == ENOSPC) ? EAI_OVERFLOW : EAI_FAIL;
5422 if ((flags & NI_NUMERICSERV) == 0) {
5423 proto = (flags & NI_DGRAM) ? "udp" : "tcp";
5424 service = getservbyport(htons(port), proto);
5426 if (service != NULL) {
5427 if (strlen(service->s_name) >= servlen)
5428 return EAI_OVERFLOW;
5429 strcpy(serv, service->s_name);
5431 if (snprintf(serv, servlen, "%u", port) >= (int) servlen)
5432 return EAI_OVERFLOW;
5439 #ifdef HAVE_LINUX_GETNAMEINFO
5440 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5441 char *host, socklen_t hostlen,
5442 char *serv, socklen_t servlen,
5444 #elif defined(HAVE_LINUX_GETNAMEINFO_UNSIGNED)
5445 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5446 char *host, socklen_t hostlen,
5447 char *serv, socklen_t servlen,
5450 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5451 char *host, size_t hostlen,
5452 char *serv, size_t servlen,
5456 if (!nss_wrapper_hosts_enabled()) {
5457 return libc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5460 return nwrap_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5463 static int nwrap_gethostname(char *name, size_t len)
5465 const char *hostname = getenv("NSS_WRAPPER_HOSTNAME");
5467 if (strlen(hostname) >= len) {
5468 errno = ENAMETOOLONG;
5471 snprintf(name, len, "%s", hostname);
5476 #ifdef HAVE_SOLARIS_GETHOSTNAME
5477 int gethostname(char *name, int len)
5478 #else /* HAVE_SOLARIS_GETHOSTNAME */
5479 int gethostname(char *name, size_t len)
5480 #endif /* HAVE_SOLARIS_GETHOSTNAME */
5482 if (!nwrap_hostname_enabled()) {
5483 return libc_gethostname(name, len);
5486 return nwrap_gethostname(name, len);
5489 /****************************
5491 ***************************/
5494 * This function is called when the library is unloaded and makes sure that
5495 * sockets get closed and the unix file for the socket are unlinked.
5497 void nwrap_destructor(void)
5502 if (nwrap_main_global != NULL) {
5503 struct nwrap_main *m = nwrap_main_global;
5506 SAFE_FREE(m->libc->fns);
5507 if (m->libc->handle != NULL) {
5508 dlclose(m->libc->handle);
5510 if (m->libc->nsl_handle != NULL) {
5511 dlclose(m->libc->nsl_handle);
5513 if (m->libc->sock_handle != NULL) {
5514 dlclose(m->libc->sock_handle);
5519 for (i = 0; i < m->num_backends; i++) {
5520 struct nwrap_backend *b = &(m->backends[i]);
5522 if (b->so_handle != NULL) {
5523 dlclose(b->so_handle);
5527 SAFE_FREE(m->backends);
5530 if (nwrap_pw_global.cache != NULL) {
5531 struct nwrap_cache *c = nwrap_pw_global.cache;
5533 nwrap_files_cache_unload(c);
5539 SAFE_FREE(nwrap_pw_global.list);
5540 nwrap_pw_global.num = 0;
5543 if (nwrap_gr_global.cache != NULL) {
5544 struct nwrap_cache *c = nwrap_gr_global.cache;
5546 nwrap_files_cache_unload(c);
5552 SAFE_FREE(nwrap_gr_global.list);
5553 nwrap_pw_global.num = 0;
5556 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
5557 if (nwrap_sp_global.cache != NULL) {
5558 struct nwrap_cache *c = nwrap_sp_global.cache;
5560 nwrap_files_cache_unload(c);
5566 nwrap_sp_global.num = 0;
5568 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
5570 if (nwrap_he_global.cache != NULL) {
5571 struct nwrap_cache *c = nwrap_he_global.cache;
5573 nwrap_files_cache_unload(c);
5579 nwrap_he_global.num = 0;
5582 free(user_addrlist.items);
5583 #ifdef HAVE_GETHOSTBYNAME2
5584 free(user_addrlist2.items);