src/nss_wrapper.c

   1 /*
   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>
   5  *
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  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.
  18  *
  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.
  22  *
  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
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include "config.h"
  37
  38 #include <pthread.h>
  39
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <sys/socket.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <stdarg.h>
  46 #include <stdbool.h>
  47 #include <stddef.h>
  48 #include <stdio.h>
  49 #include <stdint.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53 #include <ctype.h>
  54
  55 #include <search.h>
  56 #include <assert.h>
  57
  58 /*
  59  * Defining _POSIX_PTHREAD_SEMANTICS before including pwd.h and grp.h  gives us
  60  * the posix getpwnam_r(), getpwuid_r(), getgrnam_r and getgrgid_r calls on
  61  * Solaris
  62  */
  63 #ifndef _POSIX_PTHREAD_SEMANTICS
  64 #define _POSIX_PTHREAD_SEMANTICS
  65 #endif
  66
  67 #include <pwd.h>
  68 #include <grp.h>
  69 #ifdef HAVE_SHADOW_H
  70 #include <shadow.h>
  71 #endif /* HAVE_SHADOW_H */
  72
  73 #include <netdb.h>
  74 #include <arpa/inet.h>
  75 #include <netinet/in.h>
  76
  77 #include <dlfcn.h>
  78
  79 #if defined(HAVE_NSS_H)
  80 /* Linux and BSD */
  81 #include <nss.h>
  82
  83 typedef enum nss_status NSS_STATUS;
  84 #elif defined(HAVE_NSS_COMMON_H)
  85 /* Solaris */
  86 #include <nss_common.h>
  87 #include <nss_dbdefs.h>
  88 #include <nsswitch.h>
  89
  90 typedef nss_status_t NSS_STATUS;
  91
  92 # define NSS_STATUS_SUCCESS     NSS_SUCCESS
  93 # define NSS_STATUS_NOTFOUND    NSS_NOTFOUND
  94 # define NSS_STATUS_UNAVAIL     NSS_UNAVAIL
  95 # define NSS_STATUS_TRYAGAIN    NSS_TRYAGAIN
  96 #else
  97 # error "No nsswitch support detected"
  98 #endif
  99
 100 #ifndef PTR_DIFF
 101 #define PTR_DIFF(p1, p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
 102 #endif
 103
 104 #ifndef _PUBLIC_
 105 #define _PUBLIC_
 106 #endif
 107
 108 #ifndef EAI_NODATA
 109 #define EAI_NODATA EAI_NONAME
 110 #endif
 111
 112 #ifndef EAI_ADDRFAMILY
 113 #define EAI_ADDRFAMILY EAI_FAMILY
 114 #endif
 115
 116 #ifndef __STRING
 117 #define __STRING(x)    #x
 118 #endif
 119
 120 #ifndef __STRINGSTRING
 121 #define __STRINGSTRING(x) __STRING(x)
 122 #endif
 123
 124 #ifndef __LINESTR__
 125 #define __LINESTR__ __STRINGSTRING(__LINE__)
 126 #endif
 127
 128 #ifndef __location__
 129 #define __location__ __FILE__ ":" __LINESTR__
 130 #endif
 131
 132 #ifndef DNS_NAME_MAX
 133 #define DNS_NAME_MAX 255
 134 #endif
 135
 136 /* GCC have printf type attribute check. */
 137 #ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
 138 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
 139 #else
 140 #define PRINTF_ATTRIBUTE(a,b)
 141 #endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
 142
 143 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
 144 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
 145 #else
 146 #define DESTRUCTOR_ATTRIBUTE
 147 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
 148
 149 #define ZERO_STRUCTP(x) do { if ((x) != NULL) memset((char *)(x), 0, sizeof(*(x))); } while(0)
 150
 151 #ifndef SAFE_FREE
 152 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
 153 #endif
 154
 155 #ifdef HAVE_IPV6
 156 #define NWRAP_INET_ADDRSTRLEN INET6_ADDRSTRLEN
 157 #else
 158 #define NWRAP_INET_ADDRSTRLEN INET_ADDRSTRLEN
 159 #endif
 160
 161 #define NWRAP_LOCK(m) do { \
 162         pthread_mutex_lock(&( m ## _mutex)); \
 163 } while(0)
 164
 165 #define NWRAP_UNLOCK(m) do { \
 166         pthread_mutex_unlock(&( m ## _mutex)); \
 167 } while(0)
 168
 169
 170 static bool nwrap_initialized = false;
 171 static pthread_mutex_t nwrap_initialized_mutex = PTHREAD_MUTEX_INITIALIZER;
 172
 173 /* The mutex or accessing the id */
 174 static pthread_mutex_t nwrap_global_mutex = PTHREAD_MUTEX_INITIALIZER;
 175 static pthread_mutex_t nwrap_gr_global_mutex = PTHREAD_MUTEX_INITIALIZER;
 176 static pthread_mutex_t nwrap_he_global_mutex = PTHREAD_MUTEX_INITIALIZER;
 177 static pthread_mutex_t nwrap_pw_global_mutex = PTHREAD_MUTEX_INITIALIZER;
 178 static pthread_mutex_t nwrap_sp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
 179
 180 /* Add new global locks here please */
 181 /* Also don't forget to add locks to
 182  * nwrap_init() function.
 183  */
 184 # define NWRAP_LOCK_ALL do { \
 185         NWRAP_LOCK(nwrap_initialized); \
 186         NWRAP_LOCK(nwrap_global); \
 187         NWRAP_LOCK(nwrap_gr_global); \
 188         NWRAP_LOCK(nwrap_he_global); \
 189         NWRAP_LOCK(nwrap_pw_global); \
 190         NWRAP_LOCK(nwrap_sp_global); \
 191 } while (0);
 192
 193 # define NWRAP_UNLOCK_ALL do {\
 194         NWRAP_UNLOCK(nwrap_sp_global); \
 195         NWRAP_UNLOCK(nwrap_pw_global); \
 196         NWRAP_UNLOCK(nwrap_he_global); \
 197         NWRAP_UNLOCK(nwrap_gr_global); \
 198         NWRAP_UNLOCK(nwrap_global); \
 199         NWRAP_UNLOCK(nwrap_initialized); \
 200 } while (0);
 201
 202 static void nwrap_thread_prepare(void)
 203 {
 204         NWRAP_LOCK_ALL;
 205 }
 206
 207 static void nwrap_thread_parent(void)
 208 {
 209         NWRAP_UNLOCK_ALL;
 210 }
 211
 212 static void nwrap_thread_child(void)
 213 {
 214         NWRAP_UNLOCK_ALL;
 215 }
 216
 217 enum nwrap_dbglvl_e {
 218         NWRAP_LOG_ERROR = 0,
 219         NWRAP_LOG_WARN,
 220         NWRAP_LOG_DEBUG,
 221         NWRAP_LOG_TRACE
 222 };
 223
 224 #ifdef NDEBUG
 225 # define NWRAP_LOG(...)
 226 #else
 227
 228 static void nwrap_log(enum nwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
 229 # define NWRAP_LOG(dbglvl, ...) nwrap_log((dbglvl), __func__, __VA_ARGS__)
 230
 231 static void nwrap_log(enum nwrap_dbglvl_e dbglvl,
 232                       const char *func,
 233                       const char *format, ...)
 234 {
 235         char buffer[1024];
 236         va_list va;
 237         const char *d;
 238         unsigned int lvl = 0;
 239         int pid = getpid();
 240
 241         d = getenv("NSS_WRAPPER_DEBUGLEVEL");
 242         if (d != NULL) {
 243                 lvl = atoi(d);
 244         }
 245
 246         va_start(va, format);
 247         vsnprintf(buffer, sizeof(buffer), format, va);
 248         va_end(va);
 249
 250         if (lvl >= dbglvl) {
 251                 switch (dbglvl) {
 252                         case NWRAP_LOG_ERROR:
 253                                 fprintf(stderr,
 254                                         "NWRAP_ERROR(%d) - %s: %s\n",
 255                                         pid, func, buffer);
 256                                 break;
 257                         case NWRAP_LOG_WARN:
 258                                 fprintf(stderr,
 259                                         "NWRAP_WARN(%d) - %s: %s\n",
 260                                         pid, func, buffer);
 261                                 break;
 262                         case NWRAP_LOG_DEBUG:
 263                                 fprintf(stderr,
 264                                         "NWRAP_DEBUG(%d) - %s: %s\n",
 265                                         pid, func, buffer);
 266                                 break;
 267                         case NWRAP_LOG_TRACE:
 268                                 fprintf(stderr,
 269                                         "NWRAP_TRACE(%d) - %s: %s\n",
 270                                         pid, func, buffer);
 271                                 break;
 272                 }
 273         }
 274 }
 275 #endif /* NDEBUG NWRAP_LOG */
 276
 277 struct nwrap_libc_fns {
 278         struct passwd *(*_libc_getpwnam)(const char *name);
 279         int (*_libc_getpwnam_r)(const char *name, struct passwd *pwd,
 280                        char *buf, size_t buflen, struct passwd **result);
 281         struct passwd *(*_libc_getpwuid)(uid_t uid);
 282         int (*_libc_getpwuid_r)(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);
 283         void (*_libc_setpwent)(void);
 284         struct passwd *(*_libc_getpwent)(void);
 285 #ifdef HAVE_SOLARIS_GETPWENT_R
 286         struct passwd *(*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen);
 287 #else
 288         int (*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
 289 #endif
 290         void (*_libc_endpwent)(void);
 291         int (*_libc_initgroups)(const char *user, gid_t gid);
 292         struct group *(*_libc_getgrnam)(const char *name);
 293         int (*_libc_getgrnam_r)(const char *name, struct group *grp, char *buf, size_t buflen, struct group **result);
 294         struct group *(*_libc_getgrgid)(gid_t gid);
 295         int (*_libc_getgrgid_r)(gid_t gid, struct group *grp, char *buf, size_t buflen, struct group **result);
 296         void (*_libc_setgrent)(void);
 297         struct group *(*_libc_getgrent)(void);
 298 #ifdef HAVE_SOLARIS_GETGRENT_R
 299         struct group *(*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen);
 300 #else
 301         int (*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen, struct group **result);
 302 #endif
 303         void (*_libc_endgrent)(void);
 304         int (*_libc_getgrouplist)(const char *user, gid_t group, gid_t *groups, int *ngroups);
 305
 306         void (*_libc_sethostent)(int stayopen);
 307         struct hostent *(*_libc_gethostent)(void);
 308         void (*_libc_endhostent)(void);
 309
 310         struct hostent *(*_libc_gethostbyname)(const char *name);
 311 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
 312         struct hostent *(*_libc_gethostbyname2)(const char *name, int af);
 313 #endif
 314         struct hostent *(*_libc_gethostbyaddr)(const void *addr, socklen_t len, int type);
 315
 316         int (*_libc_getaddrinfo)(const char *node, const char *service,
 317                                  const struct addrinfo *hints,
 318                                  struct addrinfo **res);
 319         int (*_libc_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
 320                                  char *host, size_t hostlen,
 321                                  char *serv, size_t servlen,
 322                                  int flags);
 323         int (*_libc_gethostname)(char *name, size_t len);
 324 #ifdef HAVE_GETHOSTBYNAME_R
 325         int (*_libc_gethostbyname_r)(const char *name,
 326                                      struct hostent *ret,
 327                                      char *buf, size_t buflen,
 328                                      struct hostent **result, int *h_errnop);
 329 #endif
 330 #ifdef HAVE_GETHOSTBYADDR_R
 331         int (*_libc_gethostbyaddr_r)(const void *addr, socklen_t len, int type,
 332                                      struct hostent *ret,
 333                                      char *buf, size_t buflen,
 334                                      struct hostent **result, int *h_errnop);
 335 #endif
 336 };
 337
 338 struct nwrap_module_nss_fns {
 339         NSS_STATUS (*_nss_getpwnam_r)(const char *name, struct passwd *result, char *buffer,
 340                                       size_t buflen, int *errnop);
 341         NSS_STATUS (*_nss_getpwuid_r)(uid_t uid, struct passwd *result, char *buffer,
 342                                       size_t buflen, int *errnop);
 343         NSS_STATUS (*_nss_setpwent)(void);
 344         NSS_STATUS (*_nss_getpwent_r)(struct passwd *result, char *buffer,
 345                                       size_t buflen, int *errnop);
 346         NSS_STATUS (*_nss_endpwent)(void);
 347         NSS_STATUS (*_nss_initgroups)(const char *user, gid_t group, long int *start,
 348                                       long int *size, gid_t **groups, long int limit, int *errnop);
 349         NSS_STATUS (*_nss_getgrnam_r)(const char *name, struct group *result, char *buffer,
 350                                       size_t buflen, int *errnop);
 351         NSS_STATUS (*_nss_getgrgid_r)(gid_t gid, struct group *result, char *buffer,
 352                                       size_t buflen, int *errnop);
 353         NSS_STATUS (*_nss_setgrent)(void);
 354         NSS_STATUS (*_nss_getgrent_r)(struct group *result, char *buffer,
 355                                       size_t buflen, int *errnop);
 356         NSS_STATUS (*_nss_endgrent)(void);
 357 };
 358
 359 struct nwrap_backend {
 360         const char *name;
 361         const char *so_path;
 362         void *so_handle;
 363         struct nwrap_ops *ops;
 364         struct nwrap_module_nss_fns *fns;
 365 };
 366
 367 struct nwrap_ops {
 368         struct passwd * (*nw_getpwnam)(struct nwrap_backend *b,
 369                                        const char *name);
 370         int             (*nw_getpwnam_r)(struct nwrap_backend *b,
 371                                          const char *name, struct passwd *pwdst,
 372                                          char *buf, size_t buflen, struct passwd **pwdstp);
 373         struct passwd * (*nw_getpwuid)(struct nwrap_backend *b,
 374                                        uid_t uid);
 375         int             (*nw_getpwuid_r)(struct nwrap_backend *b,
 376                                          uid_t uid, struct passwd *pwdst,
 377                                          char *buf, size_t buflen, struct passwd **pwdstp);
 378         void            (*nw_setpwent)(struct nwrap_backend *b);
 379         struct passwd * (*nw_getpwent)(struct nwrap_backend *b);
 380         int             (*nw_getpwent_r)(struct nwrap_backend *b,
 381                                          struct passwd *pwdst, char *buf,
 382                                          size_t buflen, struct passwd **pwdstp);
 383         void            (*nw_endpwent)(struct nwrap_backend *b);
 384         int             (*nw_initgroups)(struct nwrap_backend *b,
 385                                          const char *user, gid_t group);
 386         struct group *  (*nw_getgrnam)(struct nwrap_backend *b,
 387                                        const char *name);
 388         int             (*nw_getgrnam_r)(struct nwrap_backend *b,
 389                                          const char *name, struct group *grdst,
 390                                          char *buf, size_t buflen, struct group **grdstp);
 391         struct group *  (*nw_getgrgid)(struct nwrap_backend *b,
 392                                        gid_t gid);
 393         int             (*nw_getgrgid_r)(struct nwrap_backend *b,
 394                                          gid_t gid, struct group *grdst,
 395                                          char *buf, size_t buflen, struct group **grdstp);
 396         void            (*nw_setgrent)(struct nwrap_backend *b);
 397         struct group *  (*nw_getgrent)(struct nwrap_backend *b);
 398         int             (*nw_getgrent_r)(struct nwrap_backend *b,
 399                                          struct group *grdst, char *buf,
 400                                          size_t buflen, struct group **grdstp);
 401         void            (*nw_endgrent)(struct nwrap_backend *b);
 402 };
 403
 404 /* Public prototypes */
 405
 406 bool nss_wrapper_enabled(void);
 407 bool nss_wrapper_shadow_enabled(void);
 408 bool nss_wrapper_hosts_enabled(void);
 409
 410 /* prototypes for files backend */
 411
 412
 413 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
 414                                            const char *name);
 415 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
 416                                   const char *name, struct passwd *pwdst,
 417                                   char *buf, size_t buflen, struct passwd **pwdstp);
 418 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
 419                                            uid_t uid);
 420 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
 421                                   uid_t uid, struct passwd *pwdst,
 422                                   char *buf, size_t buflen, struct passwd **pwdstp);
 423 static void nwrap_files_setpwent(struct nwrap_backend *b);
 424 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b);
 425 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
 426                                   struct passwd *pwdst, char *buf,
 427                                   size_t buflen, struct passwd **pwdstp);
 428 static void nwrap_files_endpwent(struct nwrap_backend *b);
 429 static int nwrap_files_initgroups(struct nwrap_backend *b,
 430                                   const char *user, gid_t group);
 431 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
 432                                           const char *name);
 433 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
 434                                   const char *name, struct group *grdst,
 435                                   char *buf, size_t buflen, struct group **grdstp);
 436 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
 437                                           gid_t gid);
 438 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
 439                                   gid_t gid, struct group *grdst,
 440                                   char *buf, size_t buflen, struct group **grdstp);
 441 static void nwrap_files_setgrent(struct nwrap_backend *b);
 442 static struct group *nwrap_files_getgrent(struct nwrap_backend *b);
 443 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
 444                                   struct group *grdst, char *buf,
 445                                   size_t buflen, struct group **grdstp);
 446 static void nwrap_files_endgrent(struct nwrap_backend *b);
 447
 448 /* prototypes for module backend */
 449
 450 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
 451 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
 452                                    struct passwd *pwdst, char *buf,
 453                                    size_t buflen, struct passwd **pwdstp);
 454 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
 455                                             const char *name);
 456 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
 457                                    const char *name, struct passwd *pwdst,
 458                                    char *buf, size_t buflen, struct passwd **pwdstp);
 459 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
 460                                             uid_t uid);
 461 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
 462                                    uid_t uid, struct passwd *pwdst,
 463                                    char *buf, size_t buflen, struct passwd **pwdstp);
 464 static void nwrap_module_setpwent(struct nwrap_backend *b);
 465 static void nwrap_module_endpwent(struct nwrap_backend *b);
 466 static struct group *nwrap_module_getgrent(struct nwrap_backend *b);
 467 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
 468                                    struct group *grdst, char *buf,
 469                                    size_t buflen, struct group **grdstp);
 470 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
 471                                            const char *name);
 472 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
 473                                    const char *name, struct group *grdst,
 474                                    char *buf, size_t buflen, struct group **grdstp);
 475 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
 476                                            gid_t gid);
 477 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
 478                                    gid_t gid, struct group *grdst,
 479                                    char *buf, size_t buflen, struct group **grdstp);
 480 static void nwrap_module_setgrent(struct nwrap_backend *b);
 481 static void nwrap_module_endgrent(struct nwrap_backend *b);
 482 static int nwrap_module_initgroups(struct nwrap_backend *b,
 483                                    const char *user, gid_t group);
 484
 485 struct nwrap_ops nwrap_files_ops = {
 486         .nw_getpwnam    = nwrap_files_getpwnam,
 487         .nw_getpwnam_r  = nwrap_files_getpwnam_r,
 488         .nw_getpwuid    = nwrap_files_getpwuid,
 489         .nw_getpwuid_r  = nwrap_files_getpwuid_r,
 490         .nw_setpwent    = nwrap_files_setpwent,
 491         .nw_getpwent    = nwrap_files_getpwent,
 492         .nw_getpwent_r  = nwrap_files_getpwent_r,
 493         .nw_endpwent    = nwrap_files_endpwent,
 494         .nw_initgroups  = nwrap_files_initgroups,
 495         .nw_getgrnam    = nwrap_files_getgrnam,
 496         .nw_getgrnam_r  = nwrap_files_getgrnam_r,
 497         .nw_getgrgid    = nwrap_files_getgrgid,
 498         .nw_getgrgid_r  = nwrap_files_getgrgid_r,
 499         .nw_setgrent    = nwrap_files_setgrent,
 500         .nw_getgrent    = nwrap_files_getgrent,
 501         .nw_getgrent_r  = nwrap_files_getgrent_r,
 502         .nw_endgrent    = nwrap_files_endgrent,
 503 };
 504
 505 struct nwrap_ops nwrap_module_ops = {
 506         .nw_getpwnam    = nwrap_module_getpwnam,
 507         .nw_getpwnam_r  = nwrap_module_getpwnam_r,
 508         .nw_getpwuid    = nwrap_module_getpwuid,
 509         .nw_getpwuid_r  = nwrap_module_getpwuid_r,
 510         .nw_setpwent    = nwrap_module_setpwent,
 511         .nw_getpwent    = nwrap_module_getpwent,
 512         .nw_getpwent_r  = nwrap_module_getpwent_r,
 513         .nw_endpwent    = nwrap_module_endpwent,
 514         .nw_initgroups  = nwrap_module_initgroups,
 515         .nw_getgrnam    = nwrap_module_getgrnam,
 516         .nw_getgrnam_r  = nwrap_module_getgrnam_r,
 517         .nw_getgrgid    = nwrap_module_getgrgid,
 518         .nw_getgrgid_r  = nwrap_module_getgrgid_r,
 519         .nw_setgrent    = nwrap_module_setgrent,
 520         .nw_getgrent    = nwrap_module_getgrent,
 521         .nw_getgrent_r  = nwrap_module_getgrent_r,
 522         .nw_endgrent    = nwrap_module_endgrent,
 523 };
 524
 525 struct nwrap_libc {
 526         void *handle;
 527         void *nsl_handle;
 528         void *sock_handle;
 529         struct nwrap_libc_fns *fns;
 530 };
 531
 532 struct nwrap_main {
 533         int num_backends;
 534         struct nwrap_backend *backends;
 535         struct nwrap_libc *libc;
 536 };
 537
 538 static struct nwrap_main *nwrap_main_global;
 539 static struct nwrap_main __nwrap_main_global;
 540
 541 /*
 542  * PROTOTYPES
 543  */
 544 static int nwrap_convert_he_ai(const struct hostent *he,
 545                                unsigned short port,
 546                                const struct addrinfo *hints,
 547                                struct addrinfo **pai,
 548                                bool skip_canonname);
 549
 550 /*
 551  * VECTORS
 552  */
 553
 554 #define DEFAULT_VECTOR_CAPACITY 16
 555
 556 struct nwrap_vector {
 557         void **items;
 558         size_t count;
 559         size_t capacity;
 560 };
 561
 562 /* Macro returns pointer to first element of vector->items array.
 563  *
 564  * nwrap_vector is used as a memory backend which take care of
 565  * memory allocations and other stuff like memory growing.
 566  * nwrap_vectors should not be considered as some abstract structures.
 567  * On this level, vectors are more handy than direct realloc/malloc
 568  * calls.
 569  *
 570  * nwrap_vector->items is array inside nwrap_vector which can be
 571  * directly pointed by libc structure assembled by cwrap itself.
 572  *
 573  * EXAMPLE:
 574  *
 575  * 1) struct hostent contains char **h_addr_list element.
 576  * 2) nwrap_vector holds array of pointers to addresses.
 577  *    It's easier to use vector to store results of
 578  *    file parsing etc.
 579  *
 580  * Now, pretend that cwrap assembled struct hostent and
 581  * we need to set h_addr_list to point to nwrap_vector.
 582  * Idea behind is to shield users from internal nwrap_vector
 583  * implementation.
 584  * (Yes, not fully - array terminated by NULL is needed because
 585  * it's result expected by libc function caller.)
 586  *
 587  *
 588  * CODE EXAMPLE:
 589  *
 590  * struct hostent he;
 591  * struct nwrap_vector *vector = malloc(sizeof(struct nwrap_vector));
 592  * ... don't care about failed allocation now ...
 593  *
 594  * ... fill nwrap vector ...
 595  *
 596  * struct hostent he;
 597  * he.h_addr_list = nwrap_vector_head(vector);
 598  *
 599  */
 600 #define nwrap_vector_head(vect) ((void *)((vect)->items))
 601
 602 #define nwrap_vector_foreach(item, vect, iter) \
 603         for (iter = 0, (item) = (vect).items == NULL ? NULL : (vect).items[0]; \
 604              item != NULL; \
 605              (item) = (vect).items[++iter])
 606
 607 #define nwrap_vector_is_initialized(vector) ((vector)->items != NULL)
 608
 609 static inline bool nwrap_vector_init(struct nwrap_vector *const vector)
 610 {
 611         if (vector == NULL) {
 612                 return false;
 613         }
 614
 615         /* count is initialized by ZERO_STRUCTP */
 616         ZERO_STRUCTP(vector);
 617         vector->items = malloc(sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
 618         if (vector->items == NULL) {
 619                 return false;
 620         }
 621         vector->capacity = DEFAULT_VECTOR_CAPACITY;
 622         memset(vector->items, '\0', sizeof(void *) * (DEFAULT_VECTOR_CAPACITY + 1));
 623
 624         return true;
 625 }
 626
 627 static bool nwrap_vector_add_item(struct nwrap_vector *vector, void *const item)
 628 {
 629         assert (vector != NULL);
 630
 631         if (vector->items == NULL) {
 632                 nwrap_vector_init(vector);
 633         }
 634
 635         if (vector->count == vector->capacity) {
 636                 /* Items array _MUST_ be NULL terminated because it's passed
 637                  * as result to caller which expect NULL terminated array from libc.
 638                  */
 639                 void **items = realloc(vector->items, sizeof(void *) * ((vector->capacity * 2) + 1));
 640                 if (items == NULL) {
 641                         return false;
 642                 }
 643                 vector->items = items;
 644
 645                 /* Don't count ending NULL to capacity */
 646                 vector->capacity *= 2;
 647         }
 648
 649         vector->items[vector->count] = item;
 650
 651         vector->count += 1;
 652         vector->items[vector->count] = NULL;
 653
 654         return true;
 655 }
 656
 657 static bool nwrap_vector_merge(struct nwrap_vector *dst,
 658                                struct nwrap_vector *src)
 659 {
 660         void **dst_items = NULL;
 661         size_t count;
 662
 663         if (src->count == 0) {
 664                 return true;
 665         }
 666
 667         count = dst->count + src->count;
 668
 669         /* We don't need reallocation if we have enough capacity. */
 670         if (src->count > (dst->capacity - dst->count)) {
 671                 dst_items = (void **)realloc(dst->items, (count + 1) * sizeof(void *));
 672                 if (dst_items == NULL) {
 673                         return false;
 674                 }
 675                 dst->items = dst_items;
 676                 dst->capacity = count;
 677         }
 678
 679         memcpy((void *)(((long *)dst->items) + dst->count),
 680                src->items,
 681                src->count * sizeof(void *));
 682         dst->count = count;
 683
 684         return true;
 685 }
 686
 687 struct nwrap_cache {
 688         const char *path;
 689         int fd;
 690         FILE *fp;
 691         struct stat st;
 692         void *private_data;
 693
 694         struct nwrap_vector lines;
 695
 696         bool (*parse_line)(struct nwrap_cache *, char *line);
 697         void (*unload)(struct nwrap_cache *);
 698 };
 699
 700 /* passwd */
 701 struct nwrap_pw {
 702         struct nwrap_cache *cache;
 703
 704         struct passwd *list;
 705         int num;
 706         int idx;
 707 };
 708
 709 struct nwrap_cache __nwrap_cache_pw;
 710 struct nwrap_pw nwrap_pw_global;
 711
 712 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line);
 713 static void nwrap_pw_unload(struct nwrap_cache *nwrap);
 714
 715 /* shadow */
 716 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
 717 struct nwrap_sp {
 718         struct nwrap_cache *cache;
 719
 720         struct spwd *list;
 721         int num;
 722         int idx;
 723 };
 724
 725 struct nwrap_cache __nwrap_cache_sp;
 726 struct nwrap_sp nwrap_sp_global;
 727
 728 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line);
 729 static void nwrap_sp_unload(struct nwrap_cache *nwrap);
 730 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
 731
 732 /* group */
 733 struct nwrap_gr {
 734         struct nwrap_cache *cache;
 735
 736         struct group *list;
 737         int num;
 738         int idx;
 739 };
 740
 741 struct nwrap_cache __nwrap_cache_gr;
 742 struct nwrap_gr nwrap_gr_global;
 743
 744 /* hosts */
 745 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line);
 746 static void nwrap_he_unload(struct nwrap_cache *nwrap);
 747
 748 struct nwrap_addrdata {
 749         unsigned char host_addr[16]; /* IPv4 or IPv6 address */
 750 };
 751
 752 static size_t max_hostents = 100;
 753
 754 struct nwrap_entdata {
 755         struct nwrap_addrdata addr;
 756         struct hostent ht;
 757
 758         struct nwrap_vector nwrap_addrdata;
 759
 760         ssize_t aliases_count;
 761
 762         struct nwrap_entdata *ed_next;
 763         struct nwrap_entdata *ed_tail;
 764 };
 765
 766 struct nwrap_he {
 767         struct nwrap_cache *cache;
 768
 769         struct nwrap_entdata *list;
 770         struct nwrap_vector entdata;
 771
 772         int num;
 773         int idx;
 774 };
 775
 776 static struct nwrap_cache __nwrap_cache_he;
 777 static struct nwrap_he nwrap_he_global;
 778
 779
 780 /*********************************************************
 781  * NWRAP PROTOTYPES
 782  *********************************************************/
 783
 784 static void nwrap_init(void);
 785 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line);
 786 static void nwrap_gr_unload(struct nwrap_cache *nwrap);
 787 void nwrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
 788
 789 /*********************************************************
 790  * NWRAP LIBC LOADER FUNCTIONS
 791  *********************************************************/
 792
 793 enum nwrap_lib {
 794     NWRAP_LIBC,
 795     NWRAP_LIBNSL,
 796     NWRAP_LIBSOCKET,
 797 };
 798
 799 #ifndef NDEBUG
 800 static const char *nwrap_str_lib(enum nwrap_lib lib)
 801 {
 802         switch (lib) {
 803         case NWRAP_LIBC:
 804                 return "libc";
 805         case NWRAP_LIBNSL:
 806                 return "libnsl";
 807         case NWRAP_LIBSOCKET:
 808                 return "libsocket";
 809         }
 810
 811         /* Compiler would warn us about unhandled enum value if we get here */
 812         return "unknown";
 813 }
 814 #endif
 815
 816 static void *nwrap_load_lib_handle(enum nwrap_lib lib)
 817 {
 818         int flags = RTLD_LAZY;
 819         void *handle = NULL;
 820         int i;
 821
 822 #ifdef RTLD_DEEPBIND
 823         flags |= RTLD_DEEPBIND;
 824 #endif
 825
 826         switch (lib) {
 827         case NWRAP_LIBNSL:
 828 #ifdef HAVE_LIBNSL
 829                 handle = nwrap_main_global->libc->nsl_handle;
 830                 if (handle == NULL) {
 831                         for (i = 10; i >= 0; i--) {
 832                                 char soname[256] = {0};
 833
 834                                 snprintf(soname, sizeof(soname), "libnsl.so.%d", i);
 835                                 handle = dlopen(soname, flags);
 836                                 if (handle != NULL) {
 837                                         break;
 838                                 }
 839                         }
 840
 841                         nwrap_main_global->libc->nsl_handle = handle;
 842                 }
 843                 break;
 844 #endif
 845                 /* FALL TROUGH */
 846         case NWRAP_LIBSOCKET:
 847 #ifdef HAVE_LIBSOCKET
 848                 handle = nwrap_main_global->libc->sock_handle;
 849                 if (handle == NULL) {
 850                         for (i = 10; i >= 0; i--) {
 851                                 char soname[256] = {0};
 852
 853                                 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
 854                                 handle = dlopen(soname, flags);
 855                                 if (handle != NULL) {
 856                                         break;
 857                                 }
 858                         }
 859
 860                         nwrap_main_global->libc->sock_handle = handle;
 861                 }
 862                 break;
 863 #endif
 864                 /* FALL TROUGH */
 865         case NWRAP_LIBC:
 866                 handle = nwrap_main_global->libc->handle;
 867                 if (handle == NULL) {
 868                         for (i = 10; i >= 0; i--) {
 869                                 char soname[256] = {0};
 870
 871                                 snprintf(soname, sizeof(soname), "libc.so.%d", i);
 872                                 handle = dlopen(soname, flags);
 873                                 if (handle != NULL) {
 874                                         break;
 875                                 }
 876                         }
 877
 878                         nwrap_main_global->libc->handle = handle;
 879                 }
 880                 break;
 881         }
 882
 883         if (handle == NULL) {
 884 #ifdef RTLD_NEXT
 885                 handle = nwrap_main_global->libc->handle
 886                        = nwrap_main_global->libc->sock_handle
 887                        = nwrap_main_global->libc->nsl_handle
 888                        = RTLD_NEXT;
 889 #else
 890                 NWRAP_LOG(NWRAP_LOG_ERROR,
 891                           "Failed to dlopen library: %s\n",
 892                           dlerror());
 893                 exit(-1);
 894 #endif
 895         }
 896
 897         return handle;
 898 }
 899
 900 static void *_nwrap_load_lib_function(enum nwrap_lib lib, const char *fn_name)
 901 {
 902         void *handle;
 903         void *func;
 904
 905         nwrap_init();
 906
 907         handle = nwrap_load_lib_handle(lib);
 908
 909         func = dlsym(handle, fn_name);
 910         if (func == NULL) {
 911                 NWRAP_LOG(NWRAP_LOG_ERROR,
 912                                 "Failed to find %s: %s\n",
 913                                 fn_name, dlerror());
 914                 exit(-1);
 915         }
 916
 917         NWRAP_LOG(NWRAP_LOG_TRACE,
 918                         "Loaded %s from %s",
 919                         fn_name, nwrap_str_lib(lib));
 920         return func;
 921 }
 922
 923 #define nwrap_load_lib_function(lib, fn_name) \
 924         if (nwrap_main_global->libc->fns->_libc_##fn_name == NULL) { \
 925                 *(void **) (&nwrap_main_global->libc->fns->_libc_##fn_name) = \
 926                         _nwrap_load_lib_function(lib, #fn_name); \
 927         }
 928
 929 /* INTERNAL HELPER FUNCTIONS */
 930 static void nwrap_lines_unload(struct nwrap_cache *const nwrap)
 931 {
 932         size_t p;
 933         void *item;
 934         nwrap_vector_foreach(item, nwrap->lines, p) {
 935                 /* Maybe some vectors were merged ... */
 936                 SAFE_FREE(item);
 937         }
 938         SAFE_FREE(nwrap->lines.items);
 939         ZERO_STRUCTP(&nwrap->lines);
 940 }
 941
 942 /*
 943  * IMPORTANT
 944  *
 945  * Functions expeciall from libc need to be loaded individually, you can't load
 946  * all at once or gdb will segfault at startup. The same applies to valgrind and
 947  * has probably something todo with with the linker.
 948  * So we need load each function at the point it is called the first time.
 949  */
 950 static struct passwd *libc_getpwnam(const char *name)
 951 {
 952         nwrap_load_lib_function(NWRAP_LIBC, getpwnam);
 953
 954         return nwrap_main_global->libc->fns->_libc_getpwnam(name);
 955 }
 956
 957 #ifdef HAVE_GETPWNAM_R
 958 static int libc_getpwnam_r(const char *name,
 959                            struct passwd *pwd,
 960                            char *buf,
 961                            size_t buflen,
 962                            struct passwd **result)
 963 {
 964 #ifdef HAVE___POSIX_GETPWNAM_R
 965         if (nwrap_main_global->libc->fns->_libc_getpwnam_r == NULL) {
 966                 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwnam_r) =
 967                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwnam_r");
 968         }
 969 #else
 970         nwrap_load_lib_function(NWRAP_LIBC, getpwnam_r);
 971 #endif
 972
 973         return nwrap_main_global->libc->fns->_libc_getpwnam_r(name,
 974                                                               pwd,
 975                                                               buf,
 976                                                               buflen,
 977                                                               result);
 978 }
 979 #endif
 980
 981 static struct passwd *libc_getpwuid(uid_t uid)
 982 {
 983         nwrap_load_lib_function(NWRAP_LIBC, getpwuid);
 984
 985         return nwrap_main_global->libc->fns->_libc_getpwuid(uid);
 986 }
 987
 988 #ifdef HAVE_GETPWUID_R
 989 static int libc_getpwuid_r(uid_t uid,
 990                            struct passwd *pwd,
 991                            char *buf,
 992                            size_t buflen,
 993                            struct passwd **result)
 994 {
 995 #ifdef HAVE___POSIX_GETPWUID_R
 996         if (nwrap_main_global->libc->fns->_libc_getpwuid_r == NULL) {
 997                 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwuid_r) =
 998                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwuid_r");
 999         }
1000 #else
1001         nwrap_load_lib_function(NWRAP_LIBC, getpwuid_r);
1002 #endif
1003
1004         return nwrap_main_global->libc->fns->_libc_getpwuid_r(uid,
1005                                                               pwd,
1006                                                               buf,
1007                                                               buflen,
1008                                                               result);
1009 }
1010 #endif
1011
1012 static inline void str_tolower(char *dst, char *src)
1013 {
1014         register char *src_tmp = src;
1015         register char *dst_tmp = dst;
1016
1017         while (*src_tmp != '\0') {
1018                 *dst_tmp = tolower(*src_tmp);
1019                 ++src_tmp;
1020                 ++dst_tmp;
1021         }
1022 }
1023
1024 static bool str_tolower_copy(char **dst_name, const char *const src_name)
1025 {
1026         char *h_name_lower;
1027
1028         if ((dst_name == NULL) || (src_name == NULL)) {
1029                 return false;
1030         }
1031
1032         h_name_lower = strdup(src_name);
1033         if (h_name_lower == NULL) {
1034                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Out of memory while strdup");
1035                 return false;
1036         }
1037
1038         str_tolower(h_name_lower, h_name_lower);
1039         *dst_name = h_name_lower;
1040         return true;
1041 }
1042
1043 static void libc_setpwent(void)
1044 {
1045         nwrap_load_lib_function(NWRAP_LIBC, setpwent);
1046
1047         nwrap_main_global->libc->fns->_libc_setpwent();
1048 }
1049
1050 static struct passwd *libc_getpwent(void)
1051 {
1052         nwrap_load_lib_function(NWRAP_LIBC, getpwent);
1053
1054         return nwrap_main_global->libc->fns->_libc_getpwent();
1055 }
1056
1057 #ifdef HAVE_SOLARIS_GETPWENT_R
1058 static struct passwd *libc_getpwent_r(struct passwd *pwdst,
1059                                       char *buf,
1060                                       int buflen)
1061 {
1062         nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1063
1064         return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1065                                                               buf,
1066                                                               buflen);
1067 }
1068 #else /* HAVE_SOLARIS_GETPWENT_R */
1069 static int libc_getpwent_r(struct passwd *pwdst,
1070                            char *buf,
1071                            size_t buflen,
1072                            struct passwd **pwdstp)
1073 {
1074         nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
1075
1076         return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
1077                                                               buf,
1078                                                               buflen,
1079                                                               pwdstp);
1080 }
1081 #endif /* HAVE_SOLARIS_GETPWENT_R */
1082
1083 static void libc_endpwent(void)
1084 {
1085         nwrap_load_lib_function(NWRAP_LIBC, endpwent);
1086
1087         nwrap_main_global->libc->fns->_libc_endpwent();
1088 }
1089
1090 static int libc_initgroups(const char *user, gid_t gid)
1091 {
1092         nwrap_load_lib_function(NWRAP_LIBC, initgroups);
1093
1094         return nwrap_main_global->libc->fns->_libc_initgroups(user, gid);
1095 }
1096
1097 static struct group *libc_getgrnam(const char *name)
1098 {
1099         nwrap_load_lib_function(NWRAP_LIBC, getgrnam);
1100
1101         return nwrap_main_global->libc->fns->_libc_getgrnam(name);
1102 }
1103
1104 #ifdef HAVE_GETGRNAM_R
1105 static int libc_getgrnam_r(const char *name,
1106                            struct group *grp,
1107                            char *buf,
1108                            size_t buflen,
1109                            struct group **result)
1110 {
1111 #ifdef HAVE___POSIX_GETGRNAM_R
1112         if (nwrap_main_global->libc->fns->_libc_getgrnam_r == NULL) {
1113                 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrnam_r) =
1114                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrnam_r");
1115         }
1116 #else
1117         nwrap_load_lib_function(NWRAP_LIBC, getgrnam_r);
1118 #endif
1119
1120         return nwrap_main_global->libc->fns->_libc_getgrnam_r(name,
1121                                                               grp,
1122                                                               buf,
1123                                                               buflen,
1124                                                               result);
1125 }
1126 #endif
1127
1128 static struct group *libc_getgrgid(gid_t gid)
1129 {
1130         nwrap_load_lib_function(NWRAP_LIBC, getgrgid);
1131
1132         return nwrap_main_global->libc->fns->_libc_getgrgid(gid);
1133 }
1134
1135 #ifdef HAVE_GETGRGID_R
1136 static int libc_getgrgid_r(gid_t gid,
1137                            struct group *grp,
1138                            char *buf,
1139                            size_t buflen,
1140                            struct group **result)
1141 {
1142 #ifdef HAVE___POSIX_GETGRGID_R
1143         if (nwrap_main_global->libc->fns->_libc_getgrgid_r == NULL) {
1144                 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrgid_r) =
1145                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrgid_r");
1146         }
1147 #else
1148         nwrap_load_lib_function(NWRAP_LIBC, getgrgid_r);
1149 #endif
1150
1151         return nwrap_main_global->libc->fns->_libc_getgrgid_r(gid,
1152                                                               grp,
1153                                                               buf,
1154                                                               buflen,
1155                                                               result);
1156 }
1157 #endif
1158
1159 static void libc_setgrent(void)
1160 {
1161         nwrap_load_lib_function(NWRAP_LIBC, setgrent);
1162
1163         nwrap_main_global->libc->fns->_libc_setgrent();
1164 }
1165
1166 static struct group *libc_getgrent(void)
1167 {
1168         nwrap_load_lib_function(NWRAP_LIBC, getgrent);
1169
1170         return nwrap_main_global->libc->fns->_libc_getgrent();
1171 }
1172
1173 #ifdef HAVE_GETGRENT_R
1174 #ifdef HAVE_SOLARIS_GETGRENT_R
1175 static struct group *libc_getgrent_r(struct group *group,
1176                                      char *buf,
1177                                      size_t buflen)
1178 {
1179         nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1180
1181         return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1182                                                               buf,
1183                                                               buflen);
1184 }
1185 #else /* !HAVE_SOLARIS_GETGRENT_R */
1186 static int libc_getgrent_r(struct group *group,
1187                            char *buf,
1188                            size_t buflen,
1189                            struct group **result)
1190 {
1191         nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
1192
1193         return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
1194                                                               buf,
1195                                                               buflen,
1196                                                               result);
1197 }
1198 #endif /* HAVE_SOLARIS_GETGRENT_R */
1199 #endif /* HAVE_GETGRENT_R */
1200
1201 static void libc_endgrent(void)
1202 {
1203         nwrap_load_lib_function(NWRAP_LIBC, endgrent);
1204
1205         nwrap_main_global->libc->fns->_libc_endgrent();
1206 }
1207
1208 #ifdef HAVE_GETGROUPLIST
1209 static int libc_getgrouplist(const char *user,
1210                              gid_t group,
1211                              gid_t *groups,
1212                              int *ngroups)
1213 {
1214         nwrap_load_lib_function(NWRAP_LIBC, getgrouplist);
1215
1216         return nwrap_main_global->libc->fns->_libc_getgrouplist(user,
1217                                                                 group,
1218                                                                 groups,
1219                                                                 ngroups);
1220 }
1221 #endif
1222
1223 static void libc_sethostent(int stayopen)
1224 {
1225         nwrap_load_lib_function(NWRAP_LIBNSL, sethostent);
1226
1227         nwrap_main_global->libc->fns->_libc_sethostent(stayopen);
1228 }
1229
1230 static struct hostent *libc_gethostent(void)
1231 {
1232         nwrap_load_lib_function(NWRAP_LIBNSL, gethostent);
1233
1234         return nwrap_main_global->libc->fns->_libc_gethostent();
1235 }
1236
1237 static void libc_endhostent(void)
1238 {
1239         nwrap_load_lib_function(NWRAP_LIBNSL, endhostent);
1240
1241         nwrap_main_global->libc->fns->_libc_endhostent();
1242 }
1243
1244 static struct hostent *libc_gethostbyname(const char *name)
1245 {
1246         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname);
1247
1248         return nwrap_main_global->libc->fns->_libc_gethostbyname(name);
1249 }
1250
1251 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
1252 static struct hostent *libc_gethostbyname2(const char *name, int af)
1253 {
1254         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname2);
1255
1256         return nwrap_main_global->libc->fns->_libc_gethostbyname2(name, af);
1257 }
1258 #endif
1259
1260 static struct hostent *libc_gethostbyaddr(const void *addr,
1261                                           socklen_t len,
1262                                           int type)
1263 {
1264         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr);
1265
1266         return nwrap_main_global->libc->fns->_libc_gethostbyaddr(addr,
1267                                                                  len,
1268                                                                  type);
1269 }
1270
1271 static int libc_gethostname(char *name, size_t len)
1272 {
1273         nwrap_load_lib_function(NWRAP_LIBNSL, gethostname);
1274
1275         return nwrap_main_global->libc->fns->_libc_gethostname(name, len);
1276 }
1277
1278 #ifdef HAVE_GETHOSTBYNAME_R
1279 static int libc_gethostbyname_r(const char *name,
1280                                 struct hostent *ret,
1281                                 char *buf,
1282                                 size_t buflen,
1283                                 struct hostent **result,
1284                                 int *h_errnop)
1285 {
1286         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname_r);
1287
1288         return nwrap_main_global->libc->fns->_libc_gethostbyname_r(name,
1289                                                                    ret,
1290                                                                    buf,
1291                                                                    buflen,
1292                                                                    result,
1293                                                                    h_errnop);
1294 }
1295 #endif
1296
1297 #ifdef HAVE_GETHOSTBYADDR_R
1298 static int libc_gethostbyaddr_r(const void *addr,
1299                                 socklen_t len,
1300                                 int type,
1301                                 struct hostent *ret,
1302                                 char *buf,
1303                                 size_t buflen,
1304                                 struct hostent **result,
1305                                 int *h_errnop)
1306 {
1307         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr_r);
1308
1309         return nwrap_main_global->libc->fns->_libc_gethostbyaddr_r(addr,
1310                                                                    len,
1311                                                                    type,
1312                                                                    ret,
1313                                                                    buf,
1314                                                                    buflen,
1315                                                                    result,
1316                                                                    h_errnop);
1317 }
1318 #endif
1319
1320 static int libc_getaddrinfo(const char *node,
1321                             const char *service,
1322                             const struct addrinfo *hints,
1323                             struct addrinfo **res)
1324 {
1325         nwrap_load_lib_function(NWRAP_LIBSOCKET, getaddrinfo);
1326
1327         return nwrap_main_global->libc->fns->_libc_getaddrinfo(node,
1328                                                                service,
1329                                                                hints,
1330                                                                res);
1331 }
1332
1333 static int libc_getnameinfo(const struct sockaddr *sa,
1334                             socklen_t salen,
1335                             char *host,
1336                             size_t hostlen,
1337                             char *serv,
1338                             size_t servlen,
1339                             int flags)
1340 {
1341         nwrap_load_lib_function(NWRAP_LIBSOCKET, getnameinfo);
1342
1343         return nwrap_main_global->libc->fns->_libc_getnameinfo(sa,
1344                                                                salen,
1345                                                                host,
1346                                                                hostlen,
1347                                                                serv,
1348                                                                servlen,
1349                                                                flags);
1350 }
1351
1352 /*********************************************************
1353  * NWRAP NSS MODULE LOADER FUNCTIONS
1354  *********************************************************/
1355
1356 static void *nwrap_load_module_fn(struct nwrap_backend *b,
1357                                   const char *fn_name)
1358 {
1359         void *res;
1360         char *s;
1361
1362         if (!b->so_handle) {
1363                 NWRAP_LOG(NWRAP_LOG_ERROR, "No handle");
1364                 return NULL;
1365         }
1366
1367         if (asprintf(&s, "_nss_%s_%s", b->name, fn_name) == -1) {
1368                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1369                 return NULL;
1370         }
1371
1372         res = dlsym(b->so_handle, s);
1373         if (!res) {
1374                 NWRAP_LOG(NWRAP_LOG_ERROR,
1375                           "Cannot find function %s in %s",
1376                           s, b->so_path);
1377         }
1378         SAFE_FREE(s);
1379         return res;
1380 }
1381
1382 static struct nwrap_module_nss_fns *nwrap_load_module_fns(struct nwrap_backend *b)
1383 {
1384         struct nwrap_module_nss_fns *fns;
1385
1386         if (!b->so_handle) {
1387                 return NULL;
1388         }
1389
1390         fns = (struct nwrap_module_nss_fns *)malloc(sizeof(struct nwrap_module_nss_fns));
1391         if (!fns) {
1392                 return NULL;
1393         }
1394
1395         *(void **)(&fns->_nss_getpwnam_r) =
1396                 nwrap_load_module_fn(b, "getpwnam_r");
1397         *(void **)(&fns->_nss_getpwuid_r) =
1398                 nwrap_load_module_fn(b, "getpwuid_r");
1399         *(void **)(&fns->_nss_setpwent) =
1400                 nwrap_load_module_fn(b, "setpwent");
1401         *(void **)(&fns->_nss_getpwent_r) =
1402                 nwrap_load_module_fn(b, "getpwent_r");
1403         *(void **)(&fns->_nss_endpwent) =
1404                 nwrap_load_module_fn(b, "endpwent");
1405         *(void **)(&fns->_nss_initgroups) =
1406                 nwrap_load_module_fn(b, "initgroups_dyn");
1407         *(void **)(&fns->_nss_getgrnam_r) =
1408                 nwrap_load_module_fn(b, "getgrnam_r");
1409         *(void **)(&fns->_nss_getgrgid_r)=
1410                 nwrap_load_module_fn(b, "getgrgid_r");
1411         *(void **)(&fns->_nss_setgrent) =
1412                 nwrap_load_module_fn(b, "setgrent");
1413         *(void **)(&fns->_nss_getgrent_r) =
1414                 nwrap_load_module_fn(b, "getgrent_r");
1415         *(void **)(&fns->_nss_endgrent) =
1416                 nwrap_load_module_fn(b, "endgrent");
1417
1418         return fns;
1419 }
1420
1421 static void *nwrap_load_module(const char *so_path)
1422 {
1423         void *h;
1424
1425         if (!so_path || !strlen(so_path)) {
1426                 return NULL;
1427         }
1428
1429         h = dlopen(so_path, RTLD_LAZY);
1430         if (!h) {
1431                 NWRAP_LOG(NWRAP_LOG_ERROR,
1432                           "Cannot open shared library %s",
1433                           so_path);
1434                 return NULL;
1435         }
1436
1437         return h;
1438 }
1439
1440 static bool nwrap_module_init(const char *name,
1441                               struct nwrap_ops *ops,
1442                               const char *so_path,
1443                               int *num_backends,
1444                               struct nwrap_backend **backends)
1445 {
1446         struct nwrap_backend *b;
1447
1448         *backends = (struct nwrap_backend *)realloc(*backends,
1449                 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
1450         if (!*backends) {
1451                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1452                 return false;
1453         }
1454
1455         b = &((*backends)[*num_backends]);
1456
1457         b->name = name;
1458         b->ops = ops;
1459         b->so_path = so_path;
1460
1461         if (so_path != NULL) {
1462                 b->so_handle = nwrap_load_module(so_path);
1463                 b->fns = nwrap_load_module_fns(b);
1464                 if (b->fns == NULL) {
1465                         return false;
1466                 }
1467         } else {
1468                 b->so_handle = NULL;
1469                 b->fns = NULL;
1470         }
1471
1472         (*num_backends)++;
1473
1474         return true;
1475 }
1476
1477 static void nwrap_libc_init(struct nwrap_main *r)
1478 {
1479         r->libc = malloc(sizeof(struct nwrap_libc));
1480         if (r->libc == NULL) {
1481                 printf("Failed to allocate memory for libc");
1482                 exit(-1);
1483         }
1484         ZERO_STRUCTP(r->libc);
1485
1486         r->libc->fns = malloc(sizeof(struct nwrap_libc_fns));
1487         if (r->libc->fns == NULL) {
1488                 printf("Failed to allocate memory for libc functions");
1489                 exit(-1);
1490         }
1491         ZERO_STRUCTP(r->libc->fns);
1492 }
1493
1494 static void nwrap_backend_init(struct nwrap_main *r)
1495 {
1496         const char *module_so_path = getenv("NSS_WRAPPER_MODULE_SO_PATH");
1497         const char *module_fn_name = getenv("NSS_WRAPPER_MODULE_FN_PREFIX");
1498
1499         r->num_backends = 0;
1500         r->backends = NULL;
1501
1502         if (!nwrap_module_init("files", &nwrap_files_ops, NULL,
1503                                &r->num_backends,
1504                                &r->backends)) {
1505                 NWRAP_LOG(NWRAP_LOG_ERROR,
1506                           "Failed to initialize 'files' backend");
1507                 return;
1508         }
1509
1510         if (module_so_path != NULL &&
1511             module_so_path[0] != '\0' &&
1512             module_fn_name != NULL &&
1513             module_fn_name[0] != '\0') {
1514                 if (!nwrap_module_init(module_fn_name,
1515                                        &nwrap_module_ops,
1516                                        module_so_path,
1517                                        &r->num_backends,
1518                                        &r->backends)) {
1519                         NWRAP_LOG(NWRAP_LOG_ERROR,
1520                                   "Failed to initialize '%s' backend",
1521                                   module_fn_name);
1522                         return;
1523                 }
1524         }
1525 }
1526
1527 static void nwrap_init(void)
1528 {
1529         const char *env;
1530         char *endptr;
1531         size_t max_hostents_tmp;
1532
1533         NWRAP_LOCK(nwrap_initialized);
1534         if (nwrap_initialized) {
1535                 NWRAP_UNLOCK(nwrap_initialized);
1536                 return;
1537         }
1538
1539         /*
1540          * Still holding nwrap_initialized lock here.
1541          * We don't use NWRAP_(UN)LOCK_ALL macros here because we
1542          * want to avoid overhead when other threads do their job.
1543          */
1544         NWRAP_LOCK(nwrap_global);
1545         NWRAP_LOCK(nwrap_gr_global);
1546         NWRAP_LOCK(nwrap_he_global);
1547         NWRAP_LOCK(nwrap_pw_global);
1548         NWRAP_LOCK(nwrap_sp_global);
1549
1550         nwrap_initialized = true;
1551
1552         /* Initialize pthread_atfork handlers */
1553         pthread_atfork(&nwrap_thread_prepare, &nwrap_thread_parent,
1554                        &nwrap_thread_child);
1555
1556         env = getenv("NSS_WRAPPER_MAX_HOSTENTS");
1557         if (env != NULL) {
1558                 max_hostents_tmp = (size_t)strtol(env, &endptr, 10);
1559                 if (((env != '\0') && (endptr == '\0')) ||
1560                     (max_hostents_tmp == 0)) {
1561                         NWRAP_LOG(NWRAP_LOG_DEBUG,
1562                                   "Error parsing NSS_WRAPPER_MAX_HOSTENTS "
1563                                   "value or value is too small. "
1564                                   "Using default value: %lu.",
1565                                   max_hostents);
1566                 } else {
1567                         max_hostents = max_hostents_tmp;
1568                 }
1569         }
1570         /* Initialize hash table */
1571         NWRAP_LOG(NWRAP_LOG_DEBUG,
1572                   "Initializing hash table of size %lu items.", max_hostents);
1573         if (hcreate(max_hostents) == 0) {
1574                 NWRAP_LOG(NWRAP_LOG_ERROR,
1575                           "Failed to initialize hash table");
1576                 goto done;
1577         }
1578
1579         nwrap_main_global = &__nwrap_main_global;
1580
1581         nwrap_libc_init(nwrap_main_global);
1582
1583         nwrap_backend_init(nwrap_main_global);
1584
1585         /* passwd */
1586         nwrap_pw_global.cache = &__nwrap_cache_pw;
1587
1588         nwrap_pw_global.cache->path = getenv("NSS_WRAPPER_PASSWD");
1589         nwrap_pw_global.cache->fp = NULL;
1590         nwrap_pw_global.cache->fd = -1;
1591         nwrap_pw_global.cache->private_data = &nwrap_pw_global;
1592         nwrap_pw_global.cache->parse_line = nwrap_pw_parse_line;
1593         nwrap_pw_global.cache->unload = nwrap_pw_unload;
1594
1595         /* shadow */
1596 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1597         nwrap_sp_global.cache = &__nwrap_cache_sp;
1598
1599         nwrap_sp_global.cache->path = getenv("NSS_WRAPPER_SHADOW");
1600         nwrap_sp_global.cache->fp = NULL;
1601         nwrap_sp_global.cache->fd = -1;
1602         nwrap_sp_global.cache->private_data = &nwrap_sp_global;
1603         nwrap_sp_global.cache->parse_line = nwrap_sp_parse_line;
1604         nwrap_sp_global.cache->unload = nwrap_sp_unload;
1605 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1606
1607         /* group */
1608         nwrap_gr_global.cache = &__nwrap_cache_gr;
1609
1610         nwrap_gr_global.cache->path = getenv("NSS_WRAPPER_GROUP");
1611         nwrap_gr_global.cache->fp = NULL;
1612         nwrap_gr_global.cache->fd = -1;
1613         nwrap_gr_global.cache->private_data = &nwrap_gr_global;
1614         nwrap_gr_global.cache->parse_line = nwrap_gr_parse_line;
1615         nwrap_gr_global.cache->unload = nwrap_gr_unload;
1616
1617         /* hosts */
1618         nwrap_he_global.cache = &__nwrap_cache_he;
1619
1620         nwrap_he_global.cache->path = getenv("NSS_WRAPPER_HOSTS");
1621         nwrap_he_global.cache->fp = NULL;
1622         nwrap_he_global.cache->fd = -1;
1623         nwrap_he_global.cache->private_data = &nwrap_he_global;
1624         nwrap_he_global.cache->parse_line = nwrap_he_parse_line;
1625         nwrap_he_global.cache->unload = nwrap_he_unload;
1626
1627 done:
1628         /* We hold all locks here so we can use NWRAP_UNLOCK_ALL. */
1629         NWRAP_UNLOCK_ALL;
1630 }
1631
1632 bool nss_wrapper_enabled(void)
1633 {
1634         nwrap_init();
1635
1636         if (nwrap_pw_global.cache->path == NULL ||
1637             nwrap_pw_global.cache->path[0] == '\0') {
1638                 return false;
1639         }
1640         if (nwrap_gr_global.cache->path == NULL ||
1641             nwrap_gr_global.cache->path[0] == '\0') {
1642                 return false;
1643         }
1644
1645         return true;
1646 }
1647
1648 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
1649 bool nss_wrapper_shadow_enabled(void)
1650 {
1651         nwrap_init();
1652
1653         if (nwrap_sp_global.cache->path == NULL ||
1654             nwrap_sp_global.cache->path[0] == '\0') {
1655                 return false;
1656         }
1657
1658         return true;
1659 }
1660 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
1661
1662 bool nss_wrapper_hosts_enabled(void)
1663 {
1664         nwrap_init();
1665
1666         if (nwrap_he_global.cache->path == NULL ||
1667             nwrap_he_global.cache->path[0] == '\0') {
1668                 return false;
1669         }
1670
1671         return true;
1672 }
1673
1674 static bool nwrap_hostname_enabled(void)
1675 {
1676         nwrap_init();
1677
1678         if (getenv("NSS_WRAPPER_HOSTNAME") == NULL) {
1679                 return false;
1680         }
1681
1682         return true;
1683 }
1684
1685 static bool nwrap_parse_file(struct nwrap_cache *nwrap)
1686 {
1687         char *line = NULL;
1688         ssize_t n;
1689         /* Unused but getline needs it */
1690         size_t len;
1691         bool ok;
1692
1693         if (nwrap->st.st_size == 0) {
1694                 NWRAP_LOG(NWRAP_LOG_DEBUG, "size == 0");
1695                 return true;
1696         }
1697
1698         /* Support for 32-bit system I guess */
1699         if (nwrap->st.st_size > INT32_MAX) {
1700                 NWRAP_LOG(NWRAP_LOG_ERROR,
1701                           "Size[%u] larger than INT32_MAX",
1702                           (unsigned)nwrap->st.st_size);
1703                 return false;
1704         }
1705
1706         rewind(nwrap->fp);
1707
1708         do {
1709                 n = getline(&line, &len, nwrap->fp);
1710                 if (n < 0) {
1711                         SAFE_FREE(line);
1712                         if (feof(nwrap->fp)) {
1713                                 break;
1714                         }
1715
1716                         NWRAP_LOG(NWRAP_LOG_ERROR,
1717                                   "Unable to read line from file: %s",
1718                                   nwrap->path);
1719                         return false;
1720                 }
1721
1722                 if (line[n - 1] == '\n') {
1723                         line[n - 1] = '\0';
1724                 }
1725
1726                 if (line[0] == '\0') {
1727                         SAFE_FREE(line);
1728                         continue;
1729                 }
1730
1731                 ok = nwrap->parse_line(nwrap, line);
1732                 if (!ok) {
1733                         NWRAP_LOG(NWRAP_LOG_ERROR,
1734                                   "Unable to parse line file: %s",
1735                                   line);
1736                         SAFE_FREE(line);
1737                         return false;
1738                 }
1739
1740                 /* Line is parsed without issues so add it to list */
1741                 ok = nwrap_vector_add_item(&(nwrap->lines), (void *const) line);
1742                 if (!ok) {
1743                         NWRAP_LOG(NWRAP_LOG_ERROR,
1744                                   "Unable to add line to vector");
1745                         return false;
1746                 }
1747
1748                 /* This forces getline to allocate new memory for line. */
1749                 line = NULL;
1750         } while (!feof(nwrap->fp));
1751
1752         return true;
1753 }
1754
1755 static void nwrap_files_cache_unload(struct nwrap_cache *nwrap)
1756 {
1757         nwrap->unload(nwrap);
1758
1759         nwrap_lines_unload(nwrap);
1760 }
1761
1762 static void nwrap_files_cache_reload(struct nwrap_cache *nwrap)
1763 {
1764         struct stat st;
1765         int ret;
1766         bool ok;
1767         bool retried = false;
1768
1769         assert(nwrap != NULL);
1770
1771 reopen:
1772         if (nwrap->fd < 0) {
1773                 nwrap->fp = fopen(nwrap->path, "re");
1774                 if (nwrap->fp == NULL) {
1775                         nwrap->fd = -1;
1776                         NWRAP_LOG(NWRAP_LOG_ERROR,
1777                                   "Unable to open '%s' readonly %d:%s",
1778                                   nwrap->path, nwrap->fd,
1779                                   strerror(errno));
1780                         return;
1781
1782                 }
1783                 nwrap->fd = fileno(nwrap->fp);
1784                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Open '%s'", nwrap->path);
1785         }
1786
1787         ret = fstat(nwrap->fd, &st);
1788         if (ret != 0) {
1789                 NWRAP_LOG(NWRAP_LOG_ERROR,
1790                           "fstat(%s) - %d:%s",
1791                           nwrap->path,
1792                           ret,
1793                           strerror(errno));
1794                 fclose(nwrap->fp);
1795                 nwrap->fp = NULL;
1796                 nwrap->fd = -1;
1797                 return;
1798         }
1799
1800         if (retried == false && st.st_nlink == 0) {
1801                 /* maybe someone has replaced the file... */
1802                 NWRAP_LOG(NWRAP_LOG_TRACE,
1803                           "st_nlink == 0, reopen %s",
1804                           nwrap->path);
1805                 retried = true;
1806                 memset(&nwrap->st, 0, sizeof(nwrap->st));
1807                 fclose(nwrap->fp);
1808                 nwrap->fp = NULL;
1809                 nwrap->fd = -1;
1810                 goto reopen;
1811         }
1812
1813         if (st.st_mtime == nwrap->st.st_mtime) {
1814                 NWRAP_LOG(NWRAP_LOG_TRACE,
1815                           "st_mtime[%u] hasn't changed, skip reload",
1816                           (unsigned)st.st_mtime);
1817                 return;
1818         }
1819
1820         NWRAP_LOG(NWRAP_LOG_TRACE,
1821                   "st_mtime has changed [%u] => [%u], start reload",
1822                   (unsigned)st.st_mtime,
1823                   (unsigned)nwrap->st.st_mtime);
1824
1825         nwrap->st = st;
1826
1827         nwrap_files_cache_unload(nwrap);
1828
1829         ok = nwrap_parse_file(nwrap);
1830         if (!ok) {
1831                 NWRAP_LOG(NWRAP_LOG_ERROR, "Failed to reload %s", nwrap->path);
1832                 nwrap_files_cache_unload(nwrap);
1833         }
1834
1835         NWRAP_LOG(NWRAP_LOG_TRACE, "Reloaded %s", nwrap->path);
1836 }
1837
1838 /*
1839  * the caller has to call nwrap_unload() on failure
1840  */
1841 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line)
1842 {
1843         struct nwrap_pw *nwrap_pw;
1844         char *c;
1845         char *p;
1846         char *e;
1847         struct passwd *pw;
1848         size_t list_size;
1849
1850         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
1851
1852         list_size = sizeof(*nwrap_pw->list) * (nwrap_pw->num+1);
1853         pw = (struct passwd *)realloc(nwrap_pw->list, list_size);
1854         if (!pw) {
1855                 NWRAP_LOG(NWRAP_LOG_ERROR,
1856                           "realloc(%u) failed",
1857                           (unsigned)list_size);
1858                 return false;
1859         }
1860         nwrap_pw->list = pw;
1861
1862         pw = &nwrap_pw->list[nwrap_pw->num];
1863
1864         c = line;
1865
1866         /* name */
1867         p = strchr(c, ':');
1868         if (!p) {
1869                 NWRAP_LOG(NWRAP_LOG_ERROR,
1870                           "Invalid line[%s]: '%s'",
1871                           line,
1872                           c);
1873                 return false;
1874         }
1875         *p = '\0';
1876         p++;
1877         pw->pw_name = c;
1878         c = p;
1879
1880         NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", pw->pw_name);
1881
1882         /* password */
1883         p = strchr(c, ':');
1884         if (!p) {
1885                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1886                 return false;
1887         }
1888         *p = '\0';
1889         p++;
1890         pw->pw_passwd = c;
1891         c = p;
1892
1893         NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]\n", pw->pw_passwd);
1894
1895         /* uid */
1896         p = strchr(c, ':');
1897         if (!p) {
1898                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1899                 return false;
1900         }
1901         *p = '\0';
1902         p++;
1903         e = NULL;
1904         pw->pw_uid = (uid_t)strtoul(c, &e, 10);
1905         if (c == e) {
1906                 NWRAP_LOG(NWRAP_LOG_ERROR,
1907                           "Invalid line[%s]: '%s' - %s",
1908                           line, c, strerror(errno));
1909                 return false;
1910         }
1911         if (e == NULL) {
1912                 NWRAP_LOG(NWRAP_LOG_ERROR,
1913                           "Invalid line[%s]: '%s' - %s",
1914                           line, c, strerror(errno));
1915                 return false;
1916         }
1917         if (e[0] != '\0') {
1918                 NWRAP_LOG(NWRAP_LOG_ERROR,
1919                           "Invalid line[%s]: '%s' - %s",
1920                           line, c, strerror(errno));
1921                 return false;
1922         }
1923         c = p;
1924
1925         NWRAP_LOG(NWRAP_LOG_TRACE, "uid[%u]", pw->pw_uid);
1926
1927         /* gid */
1928         p = strchr(c, ':');
1929         if (!p) {
1930                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1931                 return false;
1932         }
1933         *p = '\0';
1934         p++;
1935         e = NULL;
1936         pw->pw_gid = (gid_t)strtoul(c, &e, 10);
1937         if (c == e) {
1938                 NWRAP_LOG(NWRAP_LOG_ERROR,
1939                           "Invalid line[%s]: '%s' - %s",
1940                           line, c, strerror(errno));
1941                 return false;
1942         }
1943         if (e == NULL) {
1944                 NWRAP_LOG(NWRAP_LOG_ERROR,
1945                           "Invalid line[%s]: '%s' - %s",
1946                           line, c, strerror(errno));
1947                 return false;
1948         }
1949         if (e[0] != '\0') {
1950                 NWRAP_LOG(NWRAP_LOG_ERROR,
1951                           "Invalid line[%s]: '%s' - %s",
1952                           line, c, strerror(errno));
1953                 return false;
1954         }
1955         c = p;
1956
1957         NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]\n", pw->pw_gid);
1958
1959         /* gecos */
1960         p = strchr(c, ':');
1961         if (!p) {
1962                 NWRAP_LOG(NWRAP_LOG_ERROR, "invalid line[%s]: '%s'", line, c);
1963                 return false;
1964         }
1965         *p = '\0';
1966         p++;
1967         pw->pw_gecos = c;
1968         c = p;
1969
1970         NWRAP_LOG(NWRAP_LOG_TRACE, "gecos[%s]", pw->pw_gecos);
1971
1972         /* dir */
1973         p = strchr(c, ':');
1974         if (!p) {
1975                 NWRAP_LOG(NWRAP_LOG_ERROR, "'%s'", c);
1976                 return false;
1977         }
1978         *p = '\0';
1979         p++;
1980         pw->pw_dir = c;
1981         c = p;
1982
1983         NWRAP_LOG(NWRAP_LOG_TRACE, "dir[%s]", pw->pw_dir);
1984
1985         /* shell */
1986         pw->pw_shell = c;
1987         NWRAP_LOG(NWRAP_LOG_TRACE, "shell[%s]", pw->pw_shell);
1988
1989         NWRAP_LOG(NWRAP_LOG_DEBUG,
1990                   "Added user[%s:%s:%u:%u:%s:%s:%s]",
1991                   pw->pw_name, pw->pw_passwd,
1992                   pw->pw_uid, pw->pw_gid,
1993                   pw->pw_gecos, pw->pw_dir, pw->pw_shell);
1994
1995         nwrap_pw->num++;
1996         return true;
1997 }
1998
1999 static void nwrap_pw_unload(struct nwrap_cache *nwrap)
2000 {
2001         struct nwrap_pw *nwrap_pw;
2002         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
2003
2004         SAFE_FREE(nwrap_pw->list);
2005         nwrap_pw->num = 0;
2006         nwrap_pw->idx = 0;
2007 }
2008
2009 static int nwrap_pw_copy_r(const struct passwd *src, struct passwd *dst,
2010                            char *buf, size_t buflen, struct passwd **dstp)
2011 {
2012         char *first;
2013         char *last;
2014         off_t ofs;
2015
2016         first = src->pw_name;
2017
2018         last = src->pw_shell;
2019         while (*last) last++;
2020
2021         ofs = PTR_DIFF(last + 1, first);
2022
2023         if (ofs > (off_t) buflen) {
2024                 return ERANGE;
2025         }
2026
2027         memcpy(buf, first, ofs);
2028
2029         ofs = PTR_DIFF(src->pw_name, first);
2030         dst->pw_name = buf + ofs;
2031         ofs = PTR_DIFF(src->pw_passwd, first);
2032         dst->pw_passwd = buf + ofs;
2033         dst->pw_uid = src->pw_uid;
2034         dst->pw_gid = src->pw_gid;
2035         ofs = PTR_DIFF(src->pw_gecos, first);
2036         dst->pw_gecos = buf + ofs;
2037         ofs = PTR_DIFF(src->pw_dir, first);
2038         dst->pw_dir = buf + ofs;
2039         ofs = PTR_DIFF(src->pw_shell, first);
2040         dst->pw_shell = buf + ofs;
2041
2042         if (dstp) {
2043                 *dstp = dst;
2044         }
2045
2046         return 0;
2047 }
2048
2049 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
2050 static bool nwrap_sp_parse_line(struct nwrap_cache *nwrap, char *line)
2051 {
2052         struct nwrap_sp *nwrap_sp;
2053         struct spwd *sp;
2054         size_t list_size;
2055         char *c;
2056         char *e;
2057         char *p;
2058
2059         nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2060
2061         list_size = sizeof(*nwrap_sp->list) * (nwrap_sp->num+1);
2062         sp = (struct spwd *)realloc(nwrap_sp->list, list_size);
2063         if (sp == NULL) {
2064                 NWRAP_LOG(NWRAP_LOG_ERROR,
2065                           "realloc(%u) failed",
2066                           (unsigned)list_size);
2067                 return false;
2068         }
2069         nwrap_sp->list = sp;
2070
2071         sp = &nwrap_sp->list[nwrap_sp->num];
2072
2073         c = line;
2074
2075         /* name */
2076         p = strchr(c, ':');
2077         if (p == NULL) {
2078                 NWRAP_LOG(NWRAP_LOG_ERROR,
2079                           "name -- Invalid line[%s]: '%s'",
2080                           line,
2081                           c);
2082                 return false;
2083         }
2084         *p = '\0';
2085         p++;
2086         sp->sp_namp = c;
2087         c = p;
2088
2089         NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", sp->sp_namp);
2090
2091         /* pwd */
2092         p = strchr(c, ':');
2093         if (p == NULL) {
2094                 NWRAP_LOG(NWRAP_LOG_ERROR,
2095                           "pwd -- Invalid line[%s]: '%s'",
2096                           line,
2097                           c);
2098                 return false;
2099         }
2100         *p = '\0';
2101         p++;
2102         sp->sp_pwdp = c;
2103         c = p;
2104
2105         /* lstchg (long) */
2106         if (c[0] == ':') {
2107                 sp->sp_lstchg = -1;
2108                 p++;
2109         } else {
2110                 p = strchr(c, ':');
2111                 if (p == NULL) {
2112                         NWRAP_LOG(NWRAP_LOG_ERROR,
2113                                   "lstchg -- Invalid line[%s]: '%s'",
2114                                   line,
2115                                   c);
2116                         return false;
2117                 }
2118                 *p = '\0';
2119                 p++;
2120                 sp->sp_lstchg = strtol(c, &e, 10);
2121                 if (c == e) {
2122                         NWRAP_LOG(NWRAP_LOG_ERROR,
2123                                   "lstchg -- Invalid line[%s]: '%s' - %s",
2124                                   line, c, strerror(errno));
2125                         return false;
2126                 }
2127                 if (e == NULL) {
2128                         NWRAP_LOG(NWRAP_LOG_ERROR,
2129                                   "lstchg -- Invalid line[%s]: '%s' - %s",
2130                                   line, c, strerror(errno));
2131                         return false;
2132                 }
2133                 if (e[0] != '\0') {
2134                         NWRAP_LOG(NWRAP_LOG_ERROR,
2135                                   "lstchg -- Invalid line[%s]: '%s' - %s",
2136                                   line, c, strerror(errno));
2137                         return false;
2138                 }
2139         }
2140         c = p;
2141
2142         /* min (long) */
2143         if (c[0] == ':') {
2144                 sp->sp_min = -1;
2145                 p++;
2146         } else {
2147                 p = strchr(c, ':');
2148                 if (p == NULL) {
2149                         NWRAP_LOG(NWRAP_LOG_ERROR,
2150                                   "min -- Invalid line[%s]: '%s'",
2151                                   line,
2152                                   c);
2153                         return false;
2154                 }
2155                 *p = '\0';
2156                 p++;
2157                 sp->sp_min = strtol(c, &e, 10);
2158                 if (c == e) {
2159                         NWRAP_LOG(NWRAP_LOG_ERROR,
2160                                   "min -- Invalid line[%s]: '%s' - %s",
2161                                   line, c, strerror(errno));
2162                         return false;
2163                 }
2164                 if (e == NULL) {
2165                         NWRAP_LOG(NWRAP_LOG_ERROR,
2166                                   "min -- Invalid line[%s]: '%s' - %s",
2167                                   line, c, strerror(errno));
2168                         return false;
2169                 }
2170                 if (e[0] != '\0') {
2171                         NWRAP_LOG(NWRAP_LOG_ERROR,
2172                                   "min -- Invalid line[%s]: '%s' - %s",
2173                                   line, c, strerror(errno));
2174                         return false;
2175                 }
2176         }
2177         c = p;
2178
2179         /* max (long) */
2180         if (c[0] == ':') {
2181                 sp->sp_max = -1;
2182                 p++;
2183         } else {
2184                 p = strchr(c, ':');
2185                 if (p == NULL) {
2186                         NWRAP_LOG(NWRAP_LOG_ERROR,
2187                                   "max -- Invalid line[%s]: '%s'",
2188                                   line,
2189                                   c);
2190                         return false;
2191                 }
2192                 *p = '\0';
2193                 p++;
2194                 sp->sp_max = strtol(c, &e, 10);
2195                 if (c == e) {
2196                         NWRAP_LOG(NWRAP_LOG_ERROR,
2197                                   "max -- Invalid line[%s]: '%s' - %s",
2198                                   line, c, strerror(errno));
2199                         return false;
2200                 }
2201                 if (e == NULL) {
2202                         NWRAP_LOG(NWRAP_LOG_ERROR,
2203                                   "max -- Invalid line[%s]: '%s' - %s",
2204                                   line, c, strerror(errno));
2205                         return false;
2206                 }
2207                 if (e[0] != '\0') {
2208                         NWRAP_LOG(NWRAP_LOG_ERROR,
2209                                   "max -- Invalid line[%s]: '%s' - %s",
2210                                   line, c, strerror(errno));
2211                         return false;
2212                 }
2213         }
2214         c = p;
2215
2216         /* warn (long) */
2217         if (c[0] == ':') {
2218                 sp->sp_warn = -1;
2219                 p++;
2220         } else {
2221                 p = strchr(c, ':');
2222                 if (p == NULL) {
2223                         NWRAP_LOG(NWRAP_LOG_ERROR,
2224                                   "warn -- Invalid line[%s]: '%s'",
2225                                   line,
2226                                   c);
2227                         return false;
2228                 }
2229                 *p = '\0';
2230                 p++;
2231                 sp->sp_warn = strtol(c, &e, 10);
2232                 if (c == e) {
2233                         NWRAP_LOG(NWRAP_LOG_ERROR,
2234                                   "warn -- Invalid line[%s]: '%s' - %s",
2235                                   line, c, strerror(errno));
2236                         return false;
2237                 }
2238                 if (e == NULL) {
2239                         NWRAP_LOG(NWRAP_LOG_ERROR,
2240                                   "warn -- Invalid line[%s]: '%s' - %s",
2241                                   line, c, strerror(errno));
2242                         return false;
2243                 }
2244                 if (e[0] != '\0') {
2245                         NWRAP_LOG(NWRAP_LOG_ERROR,
2246                                   "warn -- Invalid line[%s]: '%s' - %s",
2247                                   line, c, strerror(errno));
2248                         return false;
2249                 }
2250         }
2251         c = p;
2252
2253         /* inact (long) */
2254         if (c[0] == ':') {
2255                 sp->sp_inact = -1;
2256                 p++;
2257         } else {
2258                 p = strchr(c, ':');
2259                 if (p == NULL) {
2260                         NWRAP_LOG(NWRAP_LOG_ERROR,
2261                                   "inact -- Invalid line[%s]: '%s'",
2262                                   line,
2263                                   c);
2264                         return false;
2265                 }
2266                 *p = '\0';
2267                 p++;
2268                 sp->sp_inact = strtol(c, &e, 10);
2269                 if (c == e) {
2270                         NWRAP_LOG(NWRAP_LOG_ERROR,
2271                                   "inact -- Invalid line[%s]: '%s' - %s",
2272                                   line, c, strerror(errno));
2273                         return false;
2274                 }
2275                 if (e == NULL) {
2276                         NWRAP_LOG(NWRAP_LOG_ERROR,
2277                                   "inact -- Invalid line[%s]: '%s' - %s",
2278                                   line, c, strerror(errno));
2279                         return false;
2280                 }
2281                 if (e[0] != '\0') {
2282                         NWRAP_LOG(NWRAP_LOG_ERROR,
2283                                   "inact -- Invalid line[%s]: '%s' - %s",
2284                                   line, c, strerror(errno));
2285                         return false;
2286                 }
2287         }
2288         c = p;
2289
2290         /* expire (long) */
2291         if (c[0] == ':') {
2292                 sp->sp_expire = -1;
2293                 p++;
2294         } else {
2295                 p = strchr(c, ':');
2296                 if (p == NULL) {
2297                         NWRAP_LOG(NWRAP_LOG_ERROR,
2298                                   "expire -- Invalid line[%s]: '%s'",
2299                                   line,
2300                                   c);
2301                         return false;
2302                 }
2303                 *p = '\0';
2304                 p++;
2305                 sp->sp_expire = strtol(c, &e, 10);
2306                 if (c == e) {
2307                         NWRAP_LOG(NWRAP_LOG_ERROR,
2308                                   "expire -- Invalid line[%s]: '%s' - %s",
2309                                   line, c, strerror(errno));
2310                         return false;
2311                 }
2312                 if (e == NULL) {
2313                         NWRAP_LOG(NWRAP_LOG_ERROR,
2314                                   "expire -- Invalid line[%s]: '%s' - %s",
2315                                   line, c, strerror(errno));
2316                         return false;
2317                 }
2318                 if (e[0] != '\0') {
2319                         NWRAP_LOG(NWRAP_LOG_ERROR,
2320                                   "expire -- Invalid line[%s]: '%s' - %s",
2321                                   line, c, strerror(errno));
2322                         return false;
2323                 }
2324         }
2325         c = p;
2326
2327         nwrap_sp->num++;
2328         return true;
2329 }
2330
2331 static void nwrap_sp_unload(struct nwrap_cache *nwrap)
2332 {
2333         struct nwrap_sp *nwrap_sp;
2334         nwrap_sp = (struct nwrap_sp *)nwrap->private_data;
2335
2336         SAFE_FREE(nwrap_sp->list);
2337         nwrap_sp->num = 0;
2338         nwrap_sp->idx = 0;
2339 }
2340 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
2341
2342 /*
2343  * the caller has to call nwrap_unload() on failure
2344  */
2345 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line)
2346 {
2347         struct nwrap_gr *nwrap_gr;
2348         char *c;
2349         char *p;
2350         char *e;
2351         struct group *gr;
2352         size_t list_size;
2353         unsigned nummem;
2354
2355         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2356
2357         list_size = sizeof(*nwrap_gr->list) * (nwrap_gr->num+1);
2358         gr = (struct group *)realloc(nwrap_gr->list, list_size);
2359         if (!gr) {
2360                 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc failed");
2361                 return false;
2362         }
2363         nwrap_gr->list = gr;
2364
2365         gr = &nwrap_gr->list[nwrap_gr->num];
2366
2367         c = line;
2368
2369         /* name */
2370         p = strchr(c, ':');
2371         if (!p) {
2372                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2373                 return false;
2374         }
2375         *p = '\0';
2376         p++;
2377         gr->gr_name = c;
2378         c = p;
2379
2380         NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]", gr->gr_name);
2381
2382         /* password */
2383         p = strchr(c, ':');
2384         if (!p) {
2385                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2386                 return false;
2387         }
2388         *p = '\0';
2389         p++;
2390         gr->gr_passwd = c;
2391         c = p;
2392
2393         NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]", gr->gr_passwd);
2394
2395         /* gid */
2396         p = strchr(c, ':');
2397         if (!p) {
2398                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
2399                 return false;
2400         }
2401         *p = '\0';
2402         p++;
2403         e = NULL;
2404         gr->gr_gid = (gid_t)strtoul(c, &e, 10);
2405         if (c == e) {
2406                 NWRAP_LOG(NWRAP_LOG_ERROR,
2407                           "Invalid line[%s]: '%s' - %s",
2408                           line, c, strerror(errno));
2409                 return false;
2410         }
2411         if (e == NULL) {
2412                 NWRAP_LOG(NWRAP_LOG_ERROR,
2413                           "Invalid line[%s]: '%s' - %s",
2414                           line, c, strerror(errno));
2415                 return false;
2416         }
2417         if (e[0] != '\0') {
2418                 NWRAP_LOG(NWRAP_LOG_ERROR,
2419                           "Invalid line[%s]: '%s' - %s",
2420                           line, c, strerror(errno));
2421                 return false;
2422         }
2423         c = p;
2424
2425         NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]", gr->gr_gid);
2426
2427         /* members */
2428         gr->gr_mem = (char **)malloc(sizeof(char *));
2429         if (!gr->gr_mem) {
2430                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
2431                 return false;
2432         }
2433         gr->gr_mem[0] = NULL;
2434
2435         for(nummem=0; p; nummem++) {
2436                 char **m;
2437                 size_t m_size;
2438                 c = p;
2439                 p = strchr(c, ',');
2440                 if (p) {
2441                         *p = '\0';
2442                         p++;
2443                 }
2444
2445                 if (strlen(c) == 0) {
2446                         break;
2447                 }
2448
2449                 m_size = sizeof(char *) * (nummem+2);
2450                 m = (char **)realloc(gr->gr_mem, m_size);
2451                 if (!m) {
2452                         NWRAP_LOG(NWRAP_LOG_ERROR,
2453                                   "realloc(%zd) failed",
2454                                   m_size);
2455                         return false;
2456                 }
2457                 gr->gr_mem = m;
2458                 gr->gr_mem[nummem] = c;
2459                 gr->gr_mem[nummem+1] = NULL;
2460
2461                 NWRAP_LOG(NWRAP_LOG_TRACE,
2462                           "member[%u]: '%s'",
2463                           nummem, gr->gr_mem[nummem]);
2464         }
2465
2466         NWRAP_LOG(NWRAP_LOG_DEBUG,
2467                   "Added group[%s:%s:%u:] with %u members",
2468                   gr->gr_name, gr->gr_passwd, gr->gr_gid, nummem);
2469
2470         nwrap_gr->num++;
2471         return true;
2472 }
2473
2474 static void nwrap_gr_unload(struct nwrap_cache *nwrap)
2475 {
2476         int i;
2477         struct nwrap_gr *nwrap_gr;
2478         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
2479
2480         if (nwrap_gr->list) {
2481                 for (i=0; i < nwrap_gr->num; i++) {
2482                         SAFE_FREE(nwrap_gr->list[i].gr_mem);
2483                 }
2484                 SAFE_FREE(nwrap_gr->list);
2485         }
2486
2487         nwrap_gr->num = 0;
2488         nwrap_gr->idx = 0;
2489 }
2490
2491 static int nwrap_gr_copy_r(const struct group *src, struct group *dst,
2492                            char *buf, size_t buflen, struct group **dstp)
2493 {
2494         char *first;
2495         char **lastm;
2496         char *last = NULL;
2497         off_t ofsb;
2498         off_t ofsm;
2499         off_t ofs;
2500         unsigned i;
2501
2502         first = src->gr_name;
2503
2504         lastm = src->gr_mem;
2505         while (*lastm) {
2506                 last = *lastm;
2507                 lastm++;
2508         }
2509
2510         if (last == NULL) {
2511                 last = src->gr_passwd;
2512         }
2513         while (*last) last++;
2514
2515         ofsb = PTR_DIFF(last + 1, first);
2516         ofsm = PTR_DIFF(lastm + 1, src->gr_mem);
2517
2518         if ((ofsb + ofsm) > (off_t) buflen) {
2519                 return ERANGE;
2520         }
2521
2522         memcpy(buf, first, ofsb);
2523         memcpy(buf + ofsb, src->gr_mem, ofsm);
2524
2525         ofs = PTR_DIFF(src->gr_name, first);
2526         dst->gr_name = buf + ofs;
2527         ofs = PTR_DIFF(src->gr_passwd, first);
2528         dst->gr_passwd = buf + ofs;
2529         dst->gr_gid = src->gr_gid;
2530
2531         dst->gr_mem = (char **)(buf + ofsb);
2532         for (i=0; src->gr_mem[i]; i++) {
2533                 ofs = PTR_DIFF(src->gr_mem[i], first);
2534                 dst->gr_mem[i] = buf + ofs;
2535         }
2536
2537         if (dstp) {
2538                 *dstp = dst;
2539         }
2540
2541         return 0;
2542 }
2543
2544 static bool nwrap_add_ai(char *const ip_addr, struct nwrap_entdata *const ed)
2545 {
2546         ENTRY e = {
2547                 .key = ip_addr,
2548                 .data = (void *)ed,
2549         };
2550         ENTRY *p;
2551
2552         p = hsearch(e, ENTER);
2553         if (p == NULL) {
2554                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Hash table is full");
2555                 return false;
2556         }
2557
2558         return true;
2559 }
2560
2561
2562 static bool nwrap_add_hname_add_new(char *const h_name,
2563                                     struct nwrap_entdata *const ed)
2564 {
2565         /* No element found.. inventarize new item */
2566         ENTRY e;
2567         ENTRY *p;
2568
2569         e.key = h_name;
2570         e.data = (void *)ed;
2571         ed->ed_tail = NULL;
2572         ed->ed_next = NULL;
2573
2574         p = hsearch(e, ENTER);
2575         if (p == NULL) {
2576                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Hash table is full!");
2577                 return false;
2578         }
2579
2580         return true;
2581 }
2582
2583 static void nwrap_add_hname_add_to_existing(struct nwrap_entdata *const ed,
2584                                             struct nwrap_entdata *const ed_dst)
2585 {
2586         if (ed_dst->ed_tail != NULL) {
2587                 ed_dst->ed_tail->ed_next = ed;
2588                 if (ed_dst->ed_tail != ed) {
2589                         ed_dst->ed_tail = ed;
2590                         ed->ed_next = NULL;
2591                 }
2592         } else {
2593                 ed_dst->ed_tail = ed;
2594         }
2595 }
2596
2597 static bool nwrap_add_hname_alias(char *const h_name_a,
2598                                   struct nwrap_entdata *const ed)
2599 {
2600         ENTRY e;
2601         ENTRY *p;
2602
2603         /* Maybe it's little bit late ... */
2604         assert(ed != NULL);
2605         assert(h_name_a != NULL);
2606
2607         e.key = h_name_a;
2608         e.data = NULL;
2609         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2610         p = hsearch(e, FIND);
2611         if (p == NULL) {
2612                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name_a);
2613                 /* Just add alias and don't mess with metadata */
2614                 nwrap_add_hname_add_new(h_name_a, ed);
2615         } else {
2616                 /* Element found. Add them to end of list */
2617                 struct nwrap_entdata *ed_dst = (struct nwrap_entdata *)p->data;
2618
2619                 assert(p->data != NULL);
2620                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name_a);
2621                 nwrap_add_hname_add_to_existing(ed, ed_dst);
2622         }
2623
2624         return true;
2625 }
2626
2627 static bool nwrap_add_hname(struct nwrap_entdata *const ed)
2628 {
2629         char *const h_name = (char *const)(ed->ht.h_name);
2630         ENTRY e;
2631         ENTRY *p;
2632         char *h_name_alias;
2633         unsigned i;
2634
2635         /* Maybe it's little bit late ... */
2636         assert(ed != NULL);
2637         assert(h_name != NULL);
2638
2639         e.key = h_name;
2640         e.data = NULL;
2641         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2642         p = hsearch(e, FIND);
2643         if (p == NULL) {
2644                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name);
2645                 /* Just add alias and don't mess with metadata */
2646                 nwrap_add_hname_add_new(h_name, ed);
2647
2648                 if (ed->ed_tail == NULL) {
2649                         ed->ed_tail = ed;
2650                 }
2651         } else {
2652                 /* Element found. Add them to end of list */
2653                 struct nwrap_entdata *ed_dst = (struct nwrap_entdata *)p->data;
2654
2655                 assert(p->data != NULL);
2656                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name);
2657                 nwrap_add_hname_add_to_existing(ed, ed_dst);
2658         }
2659
2660         /* Return true when list of aliases is empty */
2661         if (ed->ht.h_aliases == NULL) {
2662                 return true;
2663         }
2664
2665         /* Itemize aliases */
2666         for (i = 0; ed->ht.h_aliases[i] != NULL; ++i) {
2667                 h_name_alias = ed->ht.h_aliases[i];
2668                 assert(h_name_alias != NULL);
2669
2670                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Add alias: %s", h_name_alias);
2671
2672                 if (!nwrap_add_hname_alias(h_name_alias, ed)) {
2673                         NWRAP_LOG(NWRAP_LOG_DEBUG,
2674                                   "Unable to add alias: %s", h_name_alias);
2675                 }
2676         }
2677
2678         return true;
2679 }
2680
2681 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line)
2682 {
2683         struct nwrap_he *nwrap_he = (struct nwrap_he *)nwrap->private_data;
2684         bool do_aliases = true;
2685         ssize_t aliases_count = 0;
2686         char *p;
2687         char *i;
2688         char *n;
2689
2690         char *ip;
2691
2692         struct nwrap_entdata *ed = (struct nwrap_entdata *)
2693                                    malloc(sizeof(struct nwrap_entdata));
2694         if (ed == NULL) {
2695                 NWRAP_LOG(NWRAP_LOG_ERROR,
2696                           "Unable to allocate memory for nwrap_entdata");
2697                 return false;
2698         }
2699         ZERO_STRUCTP(ed);
2700
2701         i = line;
2702
2703         /*
2704          * IP
2705          */
2706
2707         /* Walk to first char */
2708         for (p = i; *p != '.' && *p != ':' && !isxdigit((int) *p); p++) {
2709                 if (*p == '\0') {
2710                         NWRAP_LOG(NWRAP_LOG_ERROR,
2711                                   "Invalid line[%s]: '%s'",
2712                                   line, i);
2713                         free(ed);
2714                         return false;
2715                 }
2716         }
2717
2718         for (i = p; !isspace((int)*p); p++) {
2719                 if (*p == '\0') {
2720                         NWRAP_LOG(NWRAP_LOG_ERROR,
2721                                   "Invalid line[%s]: '%s'",
2722                                   line, i);
2723                         free(ed);
2724                         return false;
2725                 }
2726         }
2727
2728         *p = '\0';
2729
2730         if (inet_pton(AF_INET, i, ed->addr.host_addr)) {
2731                 ed->ht.h_addrtype = AF_INET;
2732                 ed->ht.h_length = 4;
2733 #ifdef HAVE_IPV6
2734         } else if (inet_pton(AF_INET6, i, ed->addr.host_addr)) {
2735                 ed->ht.h_addrtype = AF_INET6;
2736                 ed->ht.h_length = 16;
2737 #endif
2738         } else {
2739                 NWRAP_LOG(NWRAP_LOG_ERROR,
2740                           "Invalid line[%s]: '%s'",
2741                           line, i);
2742
2743                 free(ed);
2744                 return false;
2745         }
2746         ip = i;
2747
2748         nwrap_vector_add_item(&(ed->nwrap_addrdata),
2749                               (void *const)ed->addr.host_addr);
2750         ed->ht.h_addr_list = nwrap_vector_head(&ed->nwrap_addrdata);
2751
2752         p++;
2753
2754         /*
2755          * FQDN
2756          */
2757
2758         /* Walk to first char */
2759         for (n = p; *p != '_' && !isalnum((int) *p); p++) {
2760                 if (*p == '\0') {
2761                         NWRAP_LOG(NWRAP_LOG_ERROR,
2762                                   "Invalid line[%s]: '%s'",
2763                                   line, n);
2764
2765                         free(ed);
2766                         return false;
2767                 }
2768         }
2769
2770         for (n = p; !isspace((int)*p); p++) {
2771                 if (*p == '\0') {
2772                         do_aliases = false;
2773                         break;
2774                 }
2775         }
2776
2777         *p = '\0';
2778
2779         /* Convert to lowercase. This operate on same memory region */
2780         str_tolower(n, n);
2781         ed->ht.h_name = n;
2782
2783         /* glib's getent always dereferences he->h_aliases */
2784         ed->ht.h_aliases = malloc(sizeof(char *));
2785         if (ed->ht.h_aliases == NULL) {
2786                 free(ed);
2787                 return false;
2788         }
2789         ed->ht.h_aliases[0] = NULL;
2790
2791         /*
2792          * Aliases
2793          */
2794         while (do_aliases) {
2795                 char **aliases;
2796                 char *a;
2797
2798                 p++;
2799
2800                 /* Walk to first char */
2801                 for (a = p; *p != '_' && !isalnum((int) *p); p++) {
2802                         if (*p == '\0') {
2803                                 do_aliases = false;
2804                                 break;
2805                         }
2806                 }
2807                 /* Only trailing spaces are left */
2808                 if (!do_aliases) {
2809                         break;
2810                 }
2811
2812                 for (a = p; !isspace((int)*p); p++) {
2813                         if (*p == '\0') {
2814                                 do_aliases = false;
2815                                 break;
2816                         }
2817                 }
2818
2819                 *p = '\0';
2820
2821                 aliases = realloc(ed->ht.h_aliases, sizeof(char *) * (aliases_count + 2));
2822                 if (aliases == NULL) {
2823                         free(ed);
2824                         return false;
2825                 }
2826                 ed->ht.h_aliases = aliases;
2827
2828                 str_tolower(a, a);
2829                 aliases[aliases_count] = a;
2830                 aliases[aliases_count + 1] = NULL;
2831
2832                 aliases_count += 1;
2833         }
2834
2835         nwrap_vector_add_item(&(nwrap_he->entdata), (void *const)ed);
2836
2837         ed->aliases_count = aliases_count;
2838         /* Inventarize item */
2839         nwrap_add_hname(ed);
2840         nwrap_add_ai(ip, ed);
2841
2842         nwrap_he->num++;
2843         return true;
2844 }
2845
2846 static void nwrap_he_unload(struct nwrap_cache *nwrap)
2847 {
2848         struct nwrap_he *nwrap_he =
2849                 (struct nwrap_he *)nwrap->private_data;
2850         struct nwrap_entdata *ed;
2851         size_t i;
2852
2853         nwrap_vector_foreach (ed, nwrap_he->entdata, i)
2854         {
2855                 SAFE_FREE(ed->nwrap_addrdata.items);
2856                 SAFE_FREE(ed->ht.h_aliases);
2857                 SAFE_FREE(ed);
2858         }
2859         SAFE_FREE(nwrap_he->entdata.items);
2860         nwrap_he->entdata.count = nwrap_he->entdata.capacity = 0;
2861
2862         nwrap_he->num = 0;
2863         nwrap_he->idx = 0;
2864 }
2865
2866
2867 /* user functions */
2868 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
2869                                            const char *name)
2870 {
2871         int i;
2872
2873         (void) b; /* unused */
2874
2875         NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
2876
2877         nwrap_files_cache_reload(nwrap_pw_global.cache);
2878
2879         for (i=0; i<nwrap_pw_global.num; i++) {
2880                 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
2881                         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
2882                         return &nwrap_pw_global.list[i];
2883                 }
2884                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2885                           "user[%s] does not match [%s]",
2886                           name,
2887                           nwrap_pw_global.list[i].pw_name);
2888         }
2889
2890         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
2891
2892         errno = ENOENT;
2893         return NULL;
2894 }
2895
2896 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
2897                                   const char *name, struct passwd *pwdst,
2898                                   char *buf, size_t buflen, struct passwd **pwdstp)
2899 {
2900         struct passwd *pw;
2901
2902         pw = nwrap_files_getpwnam(b, name);
2903         if (!pw) {
2904                 if (errno == 0) {
2905                         return ENOENT;
2906                 }
2907                 return errno;
2908         }
2909
2910         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2911 }
2912
2913 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
2914                                            uid_t uid)
2915 {
2916         int i;
2917
2918         (void) b; /* unused */
2919
2920         nwrap_files_cache_reload(nwrap_pw_global.cache);
2921
2922         for (i=0; i<nwrap_pw_global.num; i++) {
2923                 if (nwrap_pw_global.list[i].pw_uid == uid) {
2924                         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] found", uid);
2925                         return &nwrap_pw_global.list[i];
2926                 }
2927                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2928                           "uid[%u] does not match [%u]",
2929                           uid,
2930                           nwrap_pw_global.list[i].pw_uid);
2931         }
2932
2933         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] not found\n", uid);
2934
2935         errno = ENOENT;
2936         return NULL;
2937 }
2938
2939 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
2940                                   uid_t uid, struct passwd *pwdst,
2941                                   char *buf, size_t buflen, struct passwd **pwdstp)
2942 {
2943         struct passwd *pw;
2944
2945         pw = nwrap_files_getpwuid(b, uid);
2946         if (!pw) {
2947                 if (errno == 0) {
2948                         return ENOENT;
2949                 }
2950                 return errno;
2951         }
2952
2953         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2954 }
2955
2956 /* user enum functions */
2957 static void nwrap_files_setpwent(struct nwrap_backend *b)
2958 {
2959         (void) b; /* unused */
2960
2961         nwrap_pw_global.idx = 0;
2962 }
2963
2964 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
2965 {
2966         struct passwd *pw;
2967
2968         (void) b; /* unused */
2969
2970         if (nwrap_pw_global.idx == 0) {
2971                 nwrap_files_cache_reload(nwrap_pw_global.cache);
2972         }
2973
2974         if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
2975                 errno = ENOENT;
2976                 return NULL;
2977         }
2978
2979         pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
2980
2981         NWRAP_LOG(NWRAP_LOG_DEBUG,
2982                   "return user[%s] uid[%u]",
2983                   pw->pw_name, pw->pw_uid);
2984
2985         return pw;
2986 }
2987
2988 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
2989                                   struct passwd *pwdst, char *buf,
2990                                   size_t buflen, struct passwd **pwdstp)
2991 {
2992         struct passwd *pw;
2993
2994         pw = nwrap_files_getpwent(b);
2995         if (!pw) {
2996                 if (errno == 0) {
2997                         return ENOENT;
2998                 }
2999                 return errno;
3000         }
3001
3002         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3003 }
3004
3005 static void nwrap_files_endpwent(struct nwrap_backend *b)
3006 {
3007         (void) b; /* unused */
3008
3009         nwrap_pw_global.idx = 0;
3010 }
3011
3012 /* shadow */
3013
3014 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
3015
3016 #ifdef HAVE_SETSPENT
3017 static void nwrap_files_setspent(void)
3018 {
3019         nwrap_sp_global.idx = 0;
3020 }
3021
3022 static struct spwd *nwrap_files_getspent(void)
3023 {
3024         struct spwd *sp;
3025
3026         if (nwrap_sp_global.idx == 0) {
3027                 nwrap_files_cache_reload(nwrap_sp_global.cache);
3028         }
3029
3030         if (nwrap_sp_global.idx >= nwrap_sp_global.num) {
3031                 errno = ENOENT;
3032                 return NULL;
3033         }
3034
3035         sp = &nwrap_sp_global.list[nwrap_sp_global.idx++];
3036
3037         NWRAP_LOG(NWRAP_LOG_DEBUG,
3038                   "return user[%s]",
3039                   sp->sp_namp);
3040
3041         return sp;
3042 }
3043
3044 static void nwrap_files_endspent(void)
3045 {
3046         nwrap_sp_global.idx = 0;
3047 }
3048 #endif /* HAVE_SETSPENT */
3049
3050 static struct spwd *nwrap_files_getspnam(const char *name)
3051 {
3052         int i;
3053
3054         NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
3055
3056         nwrap_files_cache_reload(nwrap_sp_global.cache);
3057
3058         for (i=0; i<nwrap_sp_global.num; i++) {
3059                 if (strcmp(nwrap_sp_global.list[i].sp_namp, name) == 0) {
3060                         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
3061                         return &nwrap_sp_global.list[i];
3062                 }
3063                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3064                           "user[%s] does not match [%s]",
3065                           name,
3066                           nwrap_sp_global.list[i].sp_namp);
3067         }
3068
3069         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
3070
3071         errno = ENOENT;
3072         return NULL;
3073 }
3074 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
3075
3076 /* misc functions */
3077 static int nwrap_files_initgroups(struct nwrap_backend *b,
3078                                   const char *user,
3079                                   gid_t group)
3080 {
3081         struct group *grp;
3082         gid_t *groups;
3083         int size = 1;
3084         int rc;
3085
3086         groups = (gid_t *)malloc(size * sizeof(gid_t));
3087         if (groups == NULL) {
3088                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
3089                 errno = ENOMEM;
3090                 return -1;
3091         }
3092         groups[0] = group;
3093
3094         nwrap_files_setgrent(b);
3095         while ((grp = nwrap_files_getgrent(b)) != NULL) {
3096                 int i = 0;
3097
3098                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3099                           "Inspecting %s for group membership",
3100                           grp->gr_name);
3101
3102                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
3103                         if (group != grp->gr_gid &&
3104                             (strcmp(user, grp->gr_mem[i]) == 0)) {
3105                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3106                                           "%s is member of %s",
3107                                           user,
3108                                           grp->gr_name);
3109
3110                                 groups = (gid_t *)realloc(groups,
3111                                                           (size + 1) * sizeof(gid_t));
3112                                 if (groups == NULL) {
3113                                         NWRAP_LOG(NWRAP_LOG_ERROR,
3114                                                   "Out of memory");
3115                                         errno = ENOMEM;
3116                                         return -1;
3117                                 }
3118
3119                                 groups[size] = grp->gr_gid;
3120                                 size++;
3121                         }
3122                 }
3123         }
3124
3125         nwrap_files_endgrent(b);
3126
3127         NWRAP_LOG(NWRAP_LOG_DEBUG,
3128                   "%s is member of %d groups",
3129                   user, size);
3130
3131         /* This really only works if uid_wrapper is loaded */
3132         rc = setgroups(size, groups);
3133
3134         free(groups);
3135
3136         return rc;
3137 }
3138
3139 /* group functions */
3140 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
3141                                           const char *name)
3142 {
3143         int i;
3144
3145         (void) b; /* unused */
3146
3147         nwrap_files_cache_reload(nwrap_gr_global.cache);
3148
3149         for (i=0; i<nwrap_gr_global.num; i++) {
3150                 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
3151                         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] found", name);
3152                         return &nwrap_gr_global.list[i];
3153                 }
3154                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3155                           "group[%s] does not match [%s]",
3156                           name,
3157                           nwrap_gr_global.list[i].gr_name);
3158         }
3159
3160         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] not found", name);
3161
3162         errno = ENOENT;
3163         return NULL;
3164 }
3165
3166 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
3167                                   const char *name, struct group *grdst,
3168                                   char *buf, size_t buflen, struct group **grdstp)
3169 {
3170         struct group *gr;
3171
3172         gr = nwrap_files_getgrnam(b, name);
3173         if (!gr) {
3174                 if (errno == 0) {
3175                         return ENOENT;
3176                 }
3177                 return errno;
3178         }
3179
3180         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3181 }
3182
3183 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
3184                                           gid_t gid)
3185 {
3186         int i;
3187
3188         (void) b; /* unused */
3189
3190         nwrap_files_cache_reload(nwrap_gr_global.cache);
3191
3192         for (i=0; i<nwrap_gr_global.num; i++) {
3193                 if (nwrap_gr_global.list[i].gr_gid == gid) {
3194                         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] found", gid);
3195                         return &nwrap_gr_global.list[i];
3196                 }
3197                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3198                           "gid[%u] does not match [%u]",
3199                           gid,
3200                           nwrap_gr_global.list[i].gr_gid);
3201         }
3202
3203         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] not found", gid);
3204
3205         errno = ENOENT;
3206         return NULL;
3207 }
3208
3209 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
3210                                   gid_t gid, struct group *grdst,
3211                                   char *buf, size_t buflen, struct group **grdstp)
3212 {
3213         struct group *gr;
3214
3215         gr = nwrap_files_getgrgid(b, gid);
3216         if (!gr) {
3217                 if (errno == 0) {
3218                         return ENOENT;
3219                 }
3220                 return errno;
3221         }
3222
3223         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3224 }
3225
3226 /* group enum functions */
3227 static void nwrap_files_setgrent(struct nwrap_backend *b)
3228 {
3229         (void) b; /* unused */
3230
3231         nwrap_gr_global.idx = 0;
3232 }
3233
3234 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
3235 {
3236         struct group *gr;
3237
3238         (void) b; /* unused */
3239
3240         if (nwrap_gr_global.idx == 0) {
3241                 nwrap_files_cache_reload(nwrap_gr_global.cache);
3242         }
3243
3244         if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
3245                 errno = ENOENT;
3246                 return NULL;
3247         }
3248
3249         gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
3250
3251         NWRAP_LOG(NWRAP_LOG_DEBUG,
3252                   "return group[%s] gid[%u]",
3253                   gr->gr_name, gr->gr_gid);
3254
3255         return gr;
3256 }
3257
3258 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
3259                                   struct group *grdst, char *buf,
3260                                   size_t buflen, struct group **grdstp)
3261 {
3262         struct group *gr;
3263
3264         gr = nwrap_files_getgrent(b);
3265         if (!gr) {
3266                 if (errno == 0) {
3267                         return ENOENT;
3268                 }
3269                 return errno;
3270         }
3271
3272         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3273 }
3274
3275 static void nwrap_files_endgrent(struct nwrap_backend *b)
3276 {
3277         (void) b; /* unused */
3278
3279         nwrap_gr_global.idx = 0;
3280 }
3281
3282 /* hosts functions */
3283 static int nwrap_files_gethostbyname(const char *name, int af,
3284                                      struct hostent *result,
3285                                      struct nwrap_vector *addr_list)
3286 {
3287         struct nwrap_entdata *ed_head;
3288         struct nwrap_entdata *ed_cur;
3289         struct hostent *he;
3290         char *h_name_lower;
3291         ENTRY e;
3292         ENTRY *e_p;
3293         char canon_name[DNS_NAME_MAX] = { 0 };
3294         size_t name_len;
3295         bool he_found = false;
3296
3297         nwrap_files_cache_reload(nwrap_he_global.cache);
3298
3299         name_len = strlen(name);
3300         if (name_len < sizeof(canon_name) && name[name_len - 1] == '.') {
3301                 strncpy(canon_name, name, name_len - 1);
3302                 name = canon_name;
3303         }
3304
3305         if (!str_tolower_copy(&h_name_lower, name)) {
3306                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3307                           "Out of memory while converting to lower case");
3308                 goto no_ent;
3309         }
3310
3311         /* Look at hash table for element */
3312         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3313         e.key = h_name_lower;
3314         e.data = NULL;
3315         e_p = hsearch(e, FIND);
3316         if (e_p == NULL) {
3317                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3318                 SAFE_FREE(h_name_lower);
3319                 goto no_ent;
3320         }
3321         SAFE_FREE(h_name_lower);
3322
3323         /* Always cleanup vector and results */
3324         if (!nwrap_vector_is_initialized(addr_list)) {
3325                 if (!nwrap_vector_init(addr_list)) {
3326                         NWRAP_LOG(NWRAP_LOG_DEBUG,
3327                                   "Unable to initialize memory for addr_list vector");
3328                         goto no_ent;
3329                 }
3330         } else {
3331                 /* When vector is initialized data are valid no more.
3332                  * Quick way how to free vector is: */
3333                 addr_list->count = 0;
3334         }
3335
3336         /* Iterate through results */
3337         ed_head = (struct nwrap_entdata *)e_p->data;
3338         for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
3339                 he = &(ed_cur->ht);
3340
3341                 /* Filter by address familiy if provided */
3342                 if (af != AF_UNSPEC && he->h_addrtype != af) {
3343                         continue;
3344                 }
3345
3346                 /*
3347                  * GLIBC HACK?
3348                  * glibc doesn't return ipv6 addresses when AF_UNSPEC is used
3349                  */
3350                 if (af == AF_UNSPEC && he->h_addrtype != AF_INET) {
3351                         continue;
3352                 }
3353
3354                 if (!he_found) {
3355                         memcpy(result, he, sizeof(struct hostent));
3356                         NWRAP_LOG(NWRAP_LOG_DEBUG,
3357                                   "Name found. Returning record for %s",
3358                                   he->h_name);
3359                         he_found = true;
3360                 }
3361                 nwrap_vector_merge(addr_list, &ed_cur->nwrap_addrdata);
3362                 result->h_addr_list = nwrap_vector_head(addr_list);
3363         }
3364
3365         if (he_found) {
3366                 return 0;
3367         }
3368         NWRAP_LOG(NWRAP_LOG_DEBUG,
3369                   "Name found in database. No records matches type.");
3370
3371 no_ent:
3372         errno = ENOENT;
3373         return -1;
3374 }
3375
3376 #ifdef HAVE_GETHOSTBYNAME_R
3377 static int nwrap_gethostbyname_r(const char *name,
3378                                  struct hostent *ret,
3379                                  char *buf, size_t buflen,
3380                                  struct hostent **result, int *h_errnop)
3381 {
3382         struct nwrap_vector *addr_list = malloc(sizeof(struct nwrap_vector));
3383         int rc;
3384
3385         if (addr_list == NULL) {
3386                 NWRAP_LOG(NWRAP_LOG_ERROR,
3387                           "Unable to allocate memory for address list");
3388                 errno = ENOENT;
3389                 return -1;
3390         }
3391
3392         ZERO_STRUCTP(addr_list);
3393
3394         rc = nwrap_files_gethostbyname(name, AF_UNSPEC, ret, addr_list);
3395         if (rc == -1) {
3396                 *h_errnop = h_errno;
3397                 if (addr_list->items != NULL) {
3398                         free(addr_list->items);
3399                 }
3400                 SAFE_FREE(addr_list);
3401                 errno = ENOENT;
3402                 return -1;
3403         }
3404
3405         if (buflen < (addr_list->count * sizeof(void *))) {
3406                 SAFE_FREE(addr_list->items);
3407                 SAFE_FREE(addr_list);
3408                 return ERANGE;
3409         }
3410
3411         /* Copy all to user provided buffer and change
3412          * pointers in returned structure.
3413          * +1 is for ending NULL pointer. */
3414         memcpy(buf, addr_list->items, (addr_list->count + 1) * sizeof(void *));
3415
3416         free(addr_list->items);
3417         free(addr_list);
3418
3419         ret->h_addr_list = (char **)buf;
3420         *result = ret;
3421         return 0;
3422 }
3423
3424 int gethostbyname_r(const char *name,
3425                     struct hostent *ret,
3426                     char *buf, size_t buflen,
3427                     struct hostent **result, int *h_errnop)
3428 {
3429         if (!nss_wrapper_hosts_enabled()) {
3430                 return libc_gethostbyname_r(name,
3431                                             ret,
3432                                             buf,
3433                                             buflen,
3434                                             result,
3435                                             h_errnop);
3436         }
3437
3438         return nwrap_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
3439 }
3440 #endif
3441
3442 static struct addrinfo *nwrap_files_getaddrinfo(const char *name,
3443                                                 unsigned short port,
3444                                                 const struct addrinfo *hints,
3445                                                 struct addrinfo **ai_tail)
3446 {
3447         struct nwrap_entdata *ed_head;
3448         struct nwrap_entdata *ed_cur;
3449         struct hostent *he;
3450         struct addrinfo *ai = NULL;
3451         struct addrinfo *ai_head = NULL;
3452         struct addrinfo *ai_prev = NULL;
3453         char *h_name_lower;
3454         size_t name_len;
3455         char canon_name[DNS_NAME_MAX] = { 0 };
3456         bool skip_canonname = false;
3457         ENTRY e = { 0 };
3458         ENTRY *e_p = NULL;
3459
3460         nwrap_files_cache_reload(nwrap_he_global.cache);
3461
3462         name_len = strlen(name);
3463         if (name_len < DNS_NAME_MAX && name[name_len - 1] == '.') {
3464                 strncpy(canon_name, name, name_len - 1);
3465                 name = canon_name;
3466         }
3467
3468         if (!str_tolower_copy(&h_name_lower, name)) {
3469                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3470                           "Out of memory while converting to lower case");
3471                 return NULL;
3472         }
3473
3474         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3475         e.key = h_name_lower;
3476         e.data = NULL;
3477         e_p = hsearch(e, FIND);
3478         if (e_p == NULL) {
3479                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3480                 SAFE_FREE(h_name_lower);
3481                 errno = ENOENT;
3482                 return NULL;
3483         }
3484         NWRAP_LOG(NWRAP_LOG_DEBUG, "Name: %s found.", h_name_lower);
3485         SAFE_FREE(h_name_lower);
3486
3487         ed_head = (struct nwrap_entdata *)e_p->data;
3488
3489         for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
3490                 int rc;
3491
3492                 he = &(ed_cur->ht);
3493
3494                 if (hints->ai_family != AF_UNSPEC &&
3495                     he->h_addrtype != hints->ai_family) {
3496                         continue;
3497                 }
3498
3499                 /* Function allocates memory and returns it in ai. */
3500                 rc = nwrap_convert_he_ai(he,
3501                                          port,
3502                                          hints,
3503                                          &ai,
3504                                          skip_canonname);
3505                 if (rc != 0) {
3506                         /* FIXME: Investigate if this is nice to do... */
3507                         NWRAP_LOG(NWRAP_LOG_ERROR,
3508                                   "Error in converting he to ai! Skipping.");
3509                         continue;
3510                 }
3511                 skip_canonname = true;
3512
3513                 if (ai_head == NULL) {
3514                         ai_head = ai;
3515                 }
3516                 if (ai_prev != NULL) {
3517                         ai_prev->ai_next = ai;
3518                 }
3519                 ai_prev = ai;
3520         }
3521
3522         *ai_tail = ai;
3523         return ai_head;
3524 }
3525
3526 static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
3527                                                  socklen_t len, int type)
3528 {
3529         struct hostent *he;
3530         char ip[NWRAP_INET_ADDRSTRLEN] = {0};
3531         struct nwrap_entdata *ed;
3532         const char *a;
3533         size_t i;
3534
3535         (void) len; /* unused */
3536
3537         nwrap_files_cache_reload(nwrap_he_global.cache);
3538
3539         a = inet_ntop(type, addr, ip, sizeof(ip));
3540         if (a == NULL) {
3541                 errno = EINVAL;
3542                 return NULL;
3543         }
3544
3545         nwrap_vector_foreach(ed, nwrap_he_global.entdata, i)
3546         {
3547                 he = &(ed->ht);
3548                 if (he->h_addrtype != type) {
3549                         continue;
3550                 }
3551
3552                 if (memcmp(addr, he->h_addr_list[0], he->h_length) == 0) {
3553                         return he;
3554                 }
3555         }
3556
3557         errno = ENOENT;
3558         return NULL;
3559 }
3560
3561 #ifdef HAVE_GETHOSTBYADDR_R
3562 static int nwrap_gethostbyaddr_r(const void *addr, socklen_t len, int type,
3563                                  struct hostent *ret,
3564                                  char *buf, size_t buflen,
3565                                  struct hostent **result, int *h_errnop)
3566 {
3567         *result = nwrap_files_gethostbyaddr(addr, len, type);
3568         if (*result != NULL) {
3569                 memset(buf, '\0', buflen);
3570                 *ret = **result;
3571                 return 0;
3572         } else {
3573                 *h_errnop = h_errno;
3574                 return -1;
3575         }
3576 }
3577
3578 int gethostbyaddr_r(const void *addr, socklen_t len, int type,
3579                     struct hostent *ret,
3580                     char *buf, size_t buflen,
3581                     struct hostent **result, int *h_errnop)
3582 {
3583         if (!nss_wrapper_hosts_enabled()) {
3584                 return libc_gethostbyaddr_r(addr,
3585                                             len,
3586                                             type,
3587                                             ret,
3588                                             buf,
3589                                             buflen,
3590                                             result,
3591                                             h_errnop);
3592         }
3593
3594         return nwrap_gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
3595 }
3596 #endif
3597
3598 /* hosts enum functions */
3599 static void nwrap_files_sethostent(void)
3600 {
3601         nwrap_he_global.idx = 0;
3602 }
3603
3604 static struct hostent *nwrap_files_gethostent(void)
3605 {
3606         struct hostent *he;
3607
3608         if (nwrap_he_global.idx == 0) {
3609                 nwrap_files_cache_reload(nwrap_he_global.cache);
3610         }
3611
3612         if (nwrap_he_global.idx >= nwrap_he_global.num) {
3613                 errno = ENOENT;
3614                 return NULL;
3615         }
3616
3617         he = &((struct nwrap_entdata *)nwrap_he_global.entdata.items[nwrap_he_global.idx++])->ht;
3618
3619         NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
3620
3621         return he;
3622 }
3623
3624 static void nwrap_files_endhostent(void)
3625 {
3626         nwrap_he_global.idx = 0;
3627 }
3628
3629 /*
3630  * module backend
3631  */
3632
3633
3634 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
3635                                             const char *name)
3636 {
3637         static struct passwd pwd;
3638         static char buf[1000];
3639         NSS_STATUS status;
3640
3641         if (!b->fns->_nss_getpwnam_r) {
3642                 return NULL;
3643         }
3644
3645         status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
3646         if (status == NSS_STATUS_NOTFOUND) {
3647                 return NULL;
3648         }
3649         if (status != NSS_STATUS_SUCCESS) {
3650                 return NULL;
3651         }
3652
3653         return &pwd;
3654 }
3655
3656 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
3657                                    const char *name, struct passwd *pwdst,
3658                                    char *buf, size_t buflen, struct passwd **pwdstp)
3659 {
3660         int ret;
3661
3662         (void) b; /* unused */
3663         (void) pwdst; /* unused */
3664         (void) pwdstp; /* unused */
3665
3666         if (!b->fns->_nss_getpwnam_r) {
3667                 return NSS_STATUS_NOTFOUND;
3668         }
3669
3670         ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
3671         switch (ret) {
3672         case NSS_STATUS_SUCCESS:
3673                 return 0;
3674         case NSS_STATUS_NOTFOUND:
3675                 if (errno != 0) {
3676                         return errno;
3677                 }
3678                 return ENOENT;
3679         case NSS_STATUS_TRYAGAIN:
3680                 if (errno != 0) {
3681                         return errno;
3682                 }
3683                 return ERANGE;
3684         default:
3685                 if (errno != 0) {
3686                         return errno;
3687                 }
3688                 return ret;
3689         }
3690 }
3691
3692 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
3693                                             uid_t uid)
3694 {
3695         static struct passwd pwd;
3696         static char buf[1000];
3697         NSS_STATUS status;
3698
3699         if (!b->fns->_nss_getpwuid_r) {
3700                 return NULL;
3701         }
3702
3703         status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
3704         if (status == NSS_STATUS_NOTFOUND) {
3705                 return NULL;
3706         }
3707         if (status != NSS_STATUS_SUCCESS) {
3708                 return NULL;
3709         }
3710         return &pwd;
3711 }
3712
3713 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
3714                                    uid_t uid, struct passwd *pwdst,
3715                                    char *buf, size_t buflen, struct passwd **pwdstp)
3716 {
3717         int ret;
3718
3719         (void) pwdstp; /* unused */
3720
3721         if (!b->fns->_nss_getpwuid_r) {
3722                 return ENOENT;
3723         }
3724
3725         ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
3726         switch (ret) {
3727         case NSS_STATUS_SUCCESS:
3728                 return 0;
3729         case NSS_STATUS_NOTFOUND:
3730                 if (errno != 0) {
3731                         return errno;
3732                 }
3733                 return ENOENT;
3734         case NSS_STATUS_TRYAGAIN:
3735                 if (errno != 0) {
3736                         return errno;
3737                 }
3738                 return ERANGE;
3739         default:
3740                 if (errno != 0) {
3741                         return errno;
3742                 }
3743                 return ret;
3744         }
3745 }
3746
3747 static void nwrap_module_setpwent(struct nwrap_backend *b)
3748 {
3749         if (!b->fns->_nss_setpwent) {
3750                 return;
3751         }
3752
3753         b->fns->_nss_setpwent();
3754 }
3755
3756 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
3757 {
3758         static struct passwd pwd;
3759         static char buf[1000];
3760         NSS_STATUS status;
3761
3762         if (!b->fns->_nss_getpwent_r) {
3763                 return NULL;
3764         }
3765
3766         status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
3767         if (status == NSS_STATUS_NOTFOUND) {
3768                 return NULL;
3769         }
3770         if (status != NSS_STATUS_SUCCESS) {
3771                 return NULL;
3772         }
3773         return &pwd;
3774 }
3775
3776 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
3777                                    struct passwd *pwdst, char *buf,
3778                                    size_t buflen, struct passwd **pwdstp)
3779 {
3780         int ret;
3781
3782         (void) pwdstp; /* unused */
3783
3784         if (!b->fns->_nss_getpwent_r) {
3785                 return ENOENT;
3786         }
3787
3788         ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
3789         switch (ret) {
3790         case NSS_STATUS_SUCCESS:
3791                 return 0;
3792         case NSS_STATUS_NOTFOUND:
3793                 if (errno != 0) {
3794                         return errno;
3795                 }
3796                 return ENOENT;
3797         case NSS_STATUS_TRYAGAIN:
3798                 if (errno != 0) {
3799                         return errno;
3800                 }
3801                 return ERANGE;
3802         default:
3803                 if (errno != 0) {
3804                         return errno;
3805                 }
3806                 return ret;
3807         }
3808 }
3809
3810 static void nwrap_module_endpwent(struct nwrap_backend *b)
3811 {
3812         if (!b->fns->_nss_endpwent) {
3813                 return;
3814         }
3815
3816         b->fns->_nss_endpwent();
3817 }
3818
3819 static int nwrap_module_initgroups(struct nwrap_backend *b,
3820                                    const char *user, gid_t group)
3821 {
3822         gid_t *groups;
3823         long int start;
3824         long int size;
3825
3826         if (!b->fns->_nss_initgroups) {
3827                 return NSS_STATUS_UNAVAIL;
3828         }
3829
3830         return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
3831 }
3832
3833 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
3834                                            const char *name)
3835 {
3836         static struct group grp;
3837         static char *buf;
3838         static int buflen = 1000;
3839         NSS_STATUS status;
3840
3841         if (!b->fns->_nss_getgrnam_r) {
3842                 return NULL;
3843         }
3844
3845         if (!buf) {
3846                 buf = (char *)malloc(buflen);
3847         }
3848 again:
3849         status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
3850         if (status == NSS_STATUS_TRYAGAIN) {
3851                 buflen *= 2;
3852                 buf = (char *)realloc(buf, buflen);
3853                 if (!buf) {
3854                         return NULL;
3855                 }
3856                 goto again;
3857         }
3858         if (status == NSS_STATUS_NOTFOUND) {
3859                 SAFE_FREE(buf);
3860                 return NULL;
3861         }
3862         if (status != NSS_STATUS_SUCCESS) {
3863                 SAFE_FREE(buf);
3864                 return NULL;
3865         }
3866         return &grp;
3867 }
3868
3869 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
3870                                    const char *name, struct group *grdst,
3871                                    char *buf, size_t buflen, struct group **grdstp)
3872 {
3873         int ret;
3874
3875         (void) grdstp; /* unused */
3876
3877         if (!b->fns->_nss_getgrnam_r) {
3878                 return ENOENT;
3879         }
3880
3881         ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
3882         switch (ret) {
3883         case NSS_STATUS_SUCCESS:
3884                 return 0;
3885         case NSS_STATUS_NOTFOUND:
3886                 if (errno != 0) {
3887                         return errno;
3888                 }
3889                 return ENOENT;
3890         case NSS_STATUS_TRYAGAIN:
3891                 if (errno != 0) {
3892                         return errno;
3893                 }
3894                 return ERANGE;
3895         default:
3896                 if (errno != 0) {
3897                         return errno;
3898                 }
3899                 return ret;
3900         }
3901 }
3902
3903 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
3904                                            gid_t gid)
3905 {
3906         static struct group grp;
3907         static char *buf;
3908         static int buflen = 1000;
3909         NSS_STATUS status;
3910
3911         if (!b->fns->_nss_getgrgid_r) {
3912                 return NULL;
3913         }
3914
3915         if (!buf) {
3916                 buf = (char *)malloc(buflen);
3917         }
3918
3919 again:
3920         status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
3921         if (status == NSS_STATUS_TRYAGAIN) {
3922                 buflen *= 2;
3923                 buf = (char *)realloc(buf, buflen);
3924                 if (!buf) {
3925                         return NULL;
3926                 }
3927                 goto again;
3928         }
3929         if (status == NSS_STATUS_NOTFOUND) {
3930                 SAFE_FREE(buf);
3931                 return NULL;
3932         }
3933         if (status != NSS_STATUS_SUCCESS) {
3934                 SAFE_FREE(buf);
3935                 return NULL;
3936         }
3937         return &grp;
3938 }
3939
3940 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
3941                                    gid_t gid, struct group *grdst,
3942                                    char *buf, size_t buflen, struct group **grdstp)
3943 {
3944         int ret;
3945
3946         (void) grdstp; /* unused */
3947
3948         if (!b->fns->_nss_getgrgid_r) {
3949                 return ENOENT;
3950         }
3951
3952         ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
3953         switch (ret) {
3954         case NSS_STATUS_SUCCESS:
3955                 return 0;
3956         case NSS_STATUS_NOTFOUND:
3957                 if (errno != 0) {
3958                         return errno;
3959                 }
3960                 return ENOENT;
3961         case NSS_STATUS_TRYAGAIN:
3962                 if (errno != 0) {
3963                         return errno;
3964                 }
3965                 return ERANGE;
3966         default:
3967                 if (errno != 0) {
3968                         return errno;
3969                 }
3970                 return ret;
3971         }
3972 }
3973
3974 static void nwrap_module_setgrent(struct nwrap_backend *b)
3975 {
3976         if (!b->fns->_nss_setgrent) {
3977                 return;
3978         }
3979
3980         b->fns->_nss_setgrent();
3981 }
3982
3983 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
3984 {
3985         static struct group grp;
3986         static char *buf;
3987         static int buflen = 1024;
3988         NSS_STATUS status;
3989
3990         if (!b->fns->_nss_getgrent_r) {
3991                 return NULL;
3992         }
3993
3994         if (!buf) {
3995                 buf = (char *)malloc(buflen);
3996         }
3997
3998 again:
3999         status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
4000         if (status == NSS_STATUS_TRYAGAIN) {
4001                 buflen *= 2;
4002                 buf = (char *)realloc(buf, buflen);
4003                 if (!buf) {
4004                         return NULL;
4005                 }
4006                 goto again;
4007         }
4008         if (status == NSS_STATUS_NOTFOUND) {
4009                 SAFE_FREE(buf);
4010                 return NULL;
4011         }
4012         if (status != NSS_STATUS_SUCCESS) {
4013                 SAFE_FREE(buf);
4014                 return NULL;
4015         }
4016         return &grp;
4017 }
4018
4019 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
4020                                    struct group *grdst, char *buf,
4021                                    size_t buflen, struct group **grdstp)
4022 {
4023         int ret;
4024
4025         (void) grdstp; /* unused */
4026
4027         if (!b->fns->_nss_getgrent_r) {
4028                 return ENOENT;
4029         }
4030
4031         ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
4032         switch (ret) {
4033         case NSS_STATUS_SUCCESS:
4034                 return 0;
4035         case NSS_STATUS_NOTFOUND:
4036                 if (errno != 0) {
4037                         return errno;
4038                 }
4039                 return ENOENT;
4040         case NSS_STATUS_TRYAGAIN:
4041                 if (errno != 0) {
4042                         return errno;
4043                 }
4044                 return ERANGE;
4045         default:
4046                 if (errno != 0) {
4047                         return errno;
4048                 }
4049                 return ret;
4050         }
4051 }
4052
4053 static void nwrap_module_endgrent(struct nwrap_backend *b)
4054 {
4055         if (!b->fns->_nss_endgrent) {
4056                 return;
4057         }
4058
4059         b->fns->_nss_endgrent();
4060 }
4061
4062 /****************************************************************************
4063  *   GETPWNAM
4064  ***************************************************************************/
4065
4066 static struct passwd *nwrap_getpwnam(const char *name)
4067 {
4068         int i;
4069         struct passwd *pwd;
4070
4071         for (i=0; i < nwrap_main_global->num_backends; i++) {
4072                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4073                 pwd = b->ops->nw_getpwnam(b, name);
4074                 if (pwd) {
4075                         return pwd;
4076                 }
4077         }
4078
4079         return NULL;
4080 }
4081
4082 struct passwd *getpwnam(const char *name)
4083 {
4084         if (!nss_wrapper_enabled()) {
4085                 return libc_getpwnam(name);
4086         }
4087
4088         return nwrap_getpwnam(name);
4089 }
4090
4091 /****************************************************************************
4092  *   GETPWNAM_R
4093  ***************************************************************************/
4094
4095 static int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
4096                             char *buf, size_t buflen, struct passwd **pwdstp)
4097 {
4098         int i,ret;
4099
4100         for (i=0; i < nwrap_main_global->num_backends; i++) {
4101                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4102                 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
4103                 if (ret == ENOENT) {
4104                         continue;
4105                 }
4106                 return ret;
4107         }
4108
4109         return ENOENT;
4110 }
4111
4112 #ifdef HAVE_GETPWNAM_R
4113 # ifdef HAVE_SOLARIS_GETPWNAM_R
4114 int getpwnam_r(const char *name, struct passwd *pwdst,
4115                char *buf, int buflen, struct passwd **pwdstp)
4116 # else /* HAVE_SOLARIS_GETPWNAM_R */
4117 int getpwnam_r(const char *name, struct passwd *pwdst,
4118                char *buf, size_t buflen, struct passwd **pwdstp)
4119 # endif /* HAVE_SOLARIS_GETPWNAM_R */
4120 {
4121         if (!nss_wrapper_enabled()) {
4122                 return libc_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4123         }
4124
4125         return nwrap_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4126 }
4127 #endif
4128
4129 /****************************************************************************
4130  *   GETPWUID
4131  ***************************************************************************/
4132
4133 static struct passwd *nwrap_getpwuid(uid_t uid)
4134 {
4135         int i;
4136         struct passwd *pwd;
4137
4138         for (i=0; i < nwrap_main_global->num_backends; i++) {
4139                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4140                 pwd = b->ops->nw_getpwuid(b, uid);
4141                 if (pwd) {
4142                         return pwd;
4143                 }
4144         }
4145
4146         return NULL;
4147 }
4148
4149 struct passwd *getpwuid(uid_t uid)
4150 {
4151         if (!nss_wrapper_enabled()) {
4152                 return libc_getpwuid(uid);
4153         }
4154
4155         return nwrap_getpwuid(uid);
4156 }
4157
4158 /****************************************************************************
4159  *   GETPWUID_R
4160  ***************************************************************************/
4161
4162 static int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
4163                             char *buf, size_t buflen, struct passwd **pwdstp)
4164 {
4165         int i,ret;
4166
4167         for (i=0; i < nwrap_main_global->num_backends; i++) {
4168                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4169                 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
4170                 if (ret == ENOENT) {
4171                         continue;
4172                 }
4173                 return ret;
4174         }
4175
4176         return ENOENT;
4177 }
4178
4179 #ifdef HAVE_SOLARIS_GETPWUID_R
4180 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4181                char *buf, int buflen, struct passwd **pwdstp)
4182 #else
4183 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4184                char *buf, size_t buflen, struct passwd **pwdstp)
4185 #endif
4186 {
4187         if (!nss_wrapper_enabled()) {
4188                 return libc_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4189         }
4190
4191         return nwrap_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4192 }
4193
4194 /****************************************************************************
4195  *   SETPWENT
4196  ***************************************************************************/
4197
4198 static void nwrap_setpwent(void)
4199 {
4200         int i;
4201
4202         for (i=0; i < nwrap_main_global->num_backends; i++) {
4203                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4204                 b->ops->nw_setpwent(b);
4205         }
4206 }
4207
4208 void setpwent(void)
4209 {
4210         if (!nss_wrapper_enabled()) {
4211                 libc_setpwent();
4212                 return;
4213         }
4214
4215         nwrap_setpwent();
4216 }
4217
4218 /****************************************************************************
4219  *   GETPWENT
4220  ***************************************************************************/
4221
4222 static struct passwd *nwrap_getpwent(void)
4223 {
4224         int i;
4225         struct passwd *pwd;
4226
4227         for (i=0; i < nwrap_main_global->num_backends; i++) {
4228                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4229                 pwd = b->ops->nw_getpwent(b);
4230                 if (pwd) {
4231                         return pwd;
4232                 }
4233         }
4234
4235         return NULL;
4236 }
4237
4238 struct passwd *getpwent(void)
4239 {
4240         if (!nss_wrapper_enabled()) {
4241                 return libc_getpwent();
4242         }
4243
4244         return nwrap_getpwent();
4245 }
4246
4247 /****************************************************************************
4248  *   GETPWENT_R
4249  ***************************************************************************/
4250
4251 static int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
4252                             size_t buflen, struct passwd **pwdstp)
4253 {
4254         int i,ret;
4255
4256         for (i=0; i < nwrap_main_global->num_backends; i++) {
4257                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4258                 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
4259                 if (ret == ENOENT) {
4260                         continue;
4261                 }
4262                 return ret;
4263         }
4264
4265         return ENOENT;
4266 }
4267
4268 #ifdef HAVE_SOLARIS_GETPWENT_R
4269 struct passwd *getpwent_r(struct passwd *pwdst, char *buf, int buflen)
4270 {
4271         struct passwd *pwdstp = NULL;
4272         int rc;
4273
4274         if (!nss_wrapper_enabled()) {
4275                 return libc_getpwent_r(pwdst, buf, buflen);
4276         }
4277         rc = nwrap_getpwent_r(pwdst, buf, buflen, &pwdstp);
4278         if (rc < 0) {
4279                 return NULL;
4280         }
4281
4282         return pwdstp;
4283 }
4284 #else /* HAVE_SOLARIS_GETPWENT_R */
4285 int getpwent_r(struct passwd *pwdst, char *buf,
4286                size_t buflen, struct passwd **pwdstp)
4287 {
4288         if (!nss_wrapper_enabled()) {
4289                 return libc_getpwent_r(pwdst, buf, buflen, pwdstp);
4290         }
4291
4292         return nwrap_getpwent_r(pwdst, buf, buflen, pwdstp);
4293 }
4294 #endif /* HAVE_SOLARIS_GETPWENT_R */
4295
4296 /****************************************************************************
4297  *   ENDPWENT
4298  ***************************************************************************/
4299
4300 static void nwrap_endpwent(void)
4301 {
4302         int i;
4303
4304         for (i=0; i < nwrap_main_global->num_backends; i++) {
4305                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4306                 b->ops->nw_endpwent(b);
4307         }
4308 }
4309
4310 void endpwent(void)
4311 {
4312         if (!nss_wrapper_enabled()) {
4313                 libc_endpwent();
4314                 return;
4315         }
4316
4317         nwrap_endpwent();
4318 }
4319
4320 /****************************************************************************
4321  *   INITGROUPS
4322  ***************************************************************************/
4323
4324 static int nwrap_initgroups(const char *user, gid_t group)
4325 {
4326         int i;
4327
4328         for (i=0; i < nwrap_main_global->num_backends; i++) {
4329                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4330                 int rc;
4331
4332                 rc = b->ops->nw_initgroups(b, user, group);
4333                 if (rc == 0) {
4334                         return 0;
4335                 }
4336         }
4337
4338         errno = ENOENT;
4339         return -1;
4340 }
4341
4342 int initgroups(const char *user, gid_t group)
4343 {
4344         if (!nss_wrapper_enabled()) {
4345                 return libc_initgroups(user, group);
4346         }
4347
4348         return nwrap_initgroups(user, group);
4349 }
4350
4351 /****************************************************************************
4352  *   GETGRNAM
4353  ***************************************************************************/
4354
4355 static struct group *nwrap_getgrnam(const char *name)
4356 {
4357         int i;
4358         struct group *grp;
4359
4360         for (i=0; i < nwrap_main_global->num_backends; i++) {
4361                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4362                 grp = b->ops->nw_getgrnam(b, name);
4363                 if (grp) {
4364                         return grp;
4365                 }
4366         }
4367
4368         return NULL;
4369 }
4370
4371 struct group *getgrnam(const char *name)
4372 {
4373         if (!nss_wrapper_enabled()) {
4374                 return libc_getgrnam(name);
4375         }
4376
4377         return nwrap_getgrnam(name);
4378 }
4379
4380 /****************************************************************************
4381  *   GETGRNAM_R
4382  ***************************************************************************/
4383
4384 static int nwrap_getgrnam_r(const char *name, struct group *grdst,
4385                             char *buf, size_t buflen, struct group **grdstp)
4386 {
4387         int i, ret;
4388
4389         for (i=0; i < nwrap_main_global->num_backends; i++) {
4390                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4391                 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
4392                 if (ret == ENOENT) {
4393                         continue;
4394                 }
4395                 return ret;
4396         }
4397
4398         return ENOENT;
4399 }
4400
4401 #ifdef HAVE_GETGRNAM_R
4402 # ifdef HAVE_SOLARIS_GETGRNAM_R
4403 int getgrnam_r(const char *name, struct group *grp,
4404                 char *buf, int buflen, struct group **pgrp)
4405 # else /* HAVE_SOLARIS_GETGRNAM_R */
4406 int getgrnam_r(const char *name, struct group *grp,
4407                char *buf, size_t buflen, struct group **pgrp)
4408 # endif /* HAVE_SOLARIS_GETGRNAM_R */
4409 {
4410         if (!nss_wrapper_enabled()) {
4411                 return libc_getgrnam_r(name,
4412                                        grp,
4413                                        buf,
4414                                        buflen,
4415                                        pgrp);
4416         }
4417
4418         return nwrap_getgrnam_r(name, grp, buf, buflen, pgrp);
4419 }
4420 #endif /* HAVE_GETGRNAM_R */
4421
4422 /****************************************************************************
4423  *   GETGRGID
4424  ***************************************************************************/
4425
4426 static struct group *nwrap_getgrgid(gid_t gid)
4427 {
4428         int i;
4429         struct group *grp;
4430
4431         for (i=0; i < nwrap_main_global->num_backends; i++) {
4432                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4433                 grp = b->ops->nw_getgrgid(b, gid);
4434                 if (grp) {
4435                         return grp;
4436                 }
4437         }
4438
4439         return NULL;
4440 }
4441
4442 struct group *getgrgid(gid_t gid)
4443 {
4444         if (!nss_wrapper_enabled()) {
4445                 return libc_getgrgid(gid);
4446         }
4447
4448         return nwrap_getgrgid(gid);
4449 }
4450
4451 /****************************************************************************
4452  *   GETGRGID_R
4453  ***************************************************************************/
4454
4455 static int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
4456                             char *buf, size_t buflen, struct group **grdstp)
4457 {
4458         int i,ret;
4459
4460         for (i=0; i < nwrap_main_global->num_backends; i++) {
4461                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4462                 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
4463                 if (ret == ENOENT) {
4464                         continue;
4465                 }
4466                 return ret;
4467         }
4468
4469         return ENOENT;
4470 }
4471
4472 #ifdef HAVE_GETGRGID_R
4473 # ifdef HAVE_SOLARIS_GETGRGID_R
4474 int getgrgid_r(gid_t gid, struct group *grdst,
4475                char *buf, int buflen, struct group **grdstp)
4476 # else /* HAVE_SOLARIS_GETGRGID_R */
4477 int getgrgid_r(gid_t gid, struct group *grdst,
4478                char *buf, size_t buflen, struct group **grdstp)
4479 # endif /* HAVE_SOLARIS_GETGRGID_R */
4480 {
4481         if (!nss_wrapper_enabled()) {
4482                 return libc_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4483         }
4484
4485         return nwrap_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4486 }
4487 #endif
4488
4489 /****************************************************************************
4490  *   SETGRENT
4491  ***************************************************************************/
4492
4493 static void nwrap_setgrent(void)
4494 {
4495         int i;
4496
4497         for (i=0; i < nwrap_main_global->num_backends; i++) {
4498                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4499                 b->ops->nw_setgrent(b);
4500         }
4501 }
4502
4503 #ifdef HAVE_BSD_SETGRENT
4504 int setgrent(void)
4505 #else
4506 void setgrent(void)
4507 #endif
4508 {
4509         if (!nss_wrapper_enabled()) {
4510                 libc_setgrent();
4511                 goto out;
4512         }
4513
4514         nwrap_setgrent();
4515
4516 out:
4517 #ifdef HAVE_BSD_SETGRENT
4518         return 0;
4519 #else
4520         return;
4521 #endif
4522 }
4523
4524 /****************************************************************************
4525  *   GETGRENT
4526  ***************************************************************************/
4527
4528 static struct group *nwrap_getgrent(void)
4529 {
4530         int i;
4531         struct group *grp;
4532
4533         for (i=0; i < nwrap_main_global->num_backends; i++) {
4534                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4535                 grp = b->ops->nw_getgrent(b);
4536                 if (grp) {
4537                         return grp;
4538                 }
4539         }
4540
4541         return NULL;
4542 }
4543
4544 struct group *getgrent(void)
4545 {
4546         if (!nss_wrapper_enabled()) {
4547                 return libc_getgrent();
4548         }
4549
4550         return nwrap_getgrent();
4551 }
4552
4553 /****************************************************************************
4554  *   GETGRENT_R
4555  ***************************************************************************/
4556
4557 static int nwrap_getgrent_r(struct group *grdst, char *buf,
4558                             size_t buflen, struct group **grdstp)
4559 {
4560         int i,ret;
4561
4562         for (i=0; i < nwrap_main_global->num_backends; i++) {
4563                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4564                 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
4565                 if (ret == ENOENT) {
4566                         continue;
4567                 }
4568                 return ret;
4569         }
4570
4571         return ENOENT;
4572 }
4573
4574 #ifdef HAVE_SOLARIS_GETGRENT_R
4575 struct group *getgrent_r(struct group *src, char *buf, int buflen)
4576 {
4577         struct group *grdstp = NULL;
4578         int rc;
4579
4580         if (!nss_wrapper_enabled()) {
4581                 return libc_getgrent_r(src, buf, buflen);
4582         }
4583
4584         rc = nwrap_getgrent_r(src, buf, buflen, &grdstp);
4585         if (rc < 0) {
4586                 return NULL;
4587         }
4588
4589         return grdstp;
4590 }
4591 #else /* HAVE_SOLARIS_GETGRENT_R */
4592 int getgrent_r(struct group *src, char *buf,
4593                size_t buflen, struct group **grdstp)
4594 {
4595         if (!nss_wrapper_enabled()) {
4596                 return libc_getgrent_r(src, buf, buflen, grdstp);
4597         }
4598
4599         return nwrap_getgrent_r(src, buf, buflen, grdstp);
4600 }
4601 #endif /* HAVE_SOLARIS_GETGRENT_R */
4602
4603 /****************************************************************************
4604  *   ENDGRENT
4605  ***************************************************************************/
4606
4607 static void nwrap_endgrent(void)
4608 {
4609         int i;
4610
4611         for (i=0; i < nwrap_main_global->num_backends; i++) {
4612                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4613                 b->ops->nw_endgrent(b);
4614         }
4615 }
4616
4617 void endgrent(void)
4618 {
4619         if (!nss_wrapper_enabled()) {
4620                 libc_endgrent();
4621                 return;
4622         }
4623
4624         nwrap_endgrent();
4625 }
4626
4627 /****************************************************************************
4628  *   GETGROUPLIST
4629  ***************************************************************************/
4630
4631 #ifdef HAVE_GETGROUPLIST
4632 static int nwrap_getgrouplist(const char *user, gid_t group,
4633                               gid_t *groups, int *ngroups)
4634 {
4635         struct group *grp;
4636         gid_t *groups_tmp;
4637         int count = 1;
4638
4639         NWRAP_LOG(NWRAP_LOG_DEBUG, "getgrouplist called for %s", user);
4640
4641         groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
4642         if (!groups_tmp) {
4643                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
4644                 errno = ENOMEM;
4645                 return -1;
4646         }
4647         groups_tmp[0] = group;
4648
4649         nwrap_setgrent();
4650         while ((grp = nwrap_getgrent()) != NULL) {
4651                 int i = 0;
4652
4653                 NWRAP_LOG(NWRAP_LOG_DEBUG,
4654                           "Inspecting %s for group membership",
4655                           grp->gr_name);
4656
4657                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
4658
4659                         if (group != grp->gr_gid &&
4660                             (strcmp(user, grp->gr_mem[i]) == 0)) {
4661
4662                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
4663                                           "%s is member of %s",
4664                                           user,
4665                                           grp->gr_name);
4666
4667                                 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
4668                                 if (!groups_tmp) {
4669                                         NWRAP_LOG(NWRAP_LOG_ERROR,
4670                                                   "Out of memory");
4671                                         errno = ENOMEM;
4672                                         return -1;
4673                                 }
4674                                 groups_tmp[count] = grp->gr_gid;
4675
4676                                 count++;
4677                         }
4678                 }
4679         }
4680
4681         nwrap_endgrent();
4682
4683         NWRAP_LOG(NWRAP_LOG_DEBUG,
4684                   "%s is member of %d groups",
4685                   user, *ngroups);
4686
4687         if (*ngroups < count) {
4688                 *ngroups = count;
4689                 free(groups_tmp);
4690                 return -1;
4691         }
4692
4693         *ngroups = count;
4694         memcpy(groups, groups_tmp, count * sizeof(gid_t));
4695         free(groups_tmp);
4696
4697         return count;
4698 }
4699
4700 int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
4701 {
4702         if (!nss_wrapper_enabled()) {
4703                 return libc_getgrouplist(user, group, groups, ngroups);
4704         }
4705
4706         return nwrap_getgrouplist(user, group, groups, ngroups);
4707 }
4708 #endif
4709
4710 /**********************************************************
4711  * SHADOW
4712  **********************************************************/
4713
4714 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
4715
4716 #ifdef HAVE_SETSPENT
4717 static void nwrap_setspent(void)
4718 {
4719         nwrap_files_setspent();
4720 }
4721
4722 void setspent(void)
4723 {
4724         if (!nss_wrapper_shadow_enabled()) {
4725                 return;
4726         }
4727
4728         nwrap_setspent();
4729 }
4730
4731 static struct spwd *nwrap_getspent(void)
4732 {
4733         return nwrap_files_getspent();
4734 }
4735
4736 struct spwd *getspent(void)
4737 {
4738         if (!nss_wrapper_shadow_enabled()) {
4739                 return NULL;
4740         }
4741
4742         return nwrap_getspent();
4743 }
4744
4745 static void nwrap_endspent(void)
4746 {
4747         nwrap_files_endspent();
4748 }
4749
4750 void endspent(void)
4751 {
4752         if (!nss_wrapper_shadow_enabled()) {
4753                 return;
4754         }
4755
4756         nwrap_endspent();
4757 }
4758 #endif /* HAVE_SETSPENT */
4759
4760 static struct spwd *nwrap_getspnam(const char *name)
4761 {
4762         return nwrap_files_getspnam(name);
4763 }
4764
4765 struct spwd *getspnam(const char *name)
4766 {
4767         if (!nss_wrapper_shadow_enabled()) {
4768                 return NULL;
4769         }
4770
4771         return nwrap_getspnam(name);
4772 }
4773
4774 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
4775
4776 /**********************************************************
4777  * NETDB
4778  **********************************************************/
4779
4780 static void nwrap_sethostent(int stayopen) {
4781         (void) stayopen; /* ignored */
4782
4783         nwrap_files_sethostent();
4784 }
4785
4786 #ifdef HAVE_SOLARIS_SETHOSTENT
4787 int sethostent(int stayopen)
4788 {
4789         if (!nss_wrapper_hosts_enabled()) {
4790                 libc_sethostent(stayopen);
4791                 return 0;
4792         }
4793
4794         nwrap_sethostent(stayopen);
4795
4796         return 0;
4797 }
4798 #else /* HAVE_SOLARIS_SETHOSTENT */
4799 void sethostent(int stayopen)
4800 {
4801         if (!nss_wrapper_hosts_enabled()) {
4802                 libc_sethostent(stayopen);
4803                 return;
4804         }
4805
4806         nwrap_sethostent(stayopen);
4807 }
4808 #endif /* HAVE_SOLARIS_SETHOSTENT */
4809
4810 static struct hostent *nwrap_gethostent(void)
4811 {
4812         return nwrap_files_gethostent();
4813 }
4814
4815 struct hostent *gethostent(void) {
4816         if (!nss_wrapper_hosts_enabled()) {
4817                 return libc_gethostent();
4818         }
4819
4820         return nwrap_gethostent();
4821 }
4822
4823 static void nwrap_endhostent(void) {
4824         nwrap_files_endhostent();
4825 }
4826
4827 #ifdef HAVE_SOLARIS_ENDHOSTENT
4828 int endhostent(void)
4829 {
4830         if (!nss_wrapper_hosts_enabled()) {
4831                 libc_endhostent();
4832                 return 0;
4833         }
4834
4835         nwrap_endhostent();
4836
4837         return 0;
4838 }
4839 #else /* HAVE_SOLARIS_ENDHOSTENT */
4840 void endhostent(void)
4841 {
4842         if (!nss_wrapper_hosts_enabled()) {
4843                 libc_endhostent();
4844                 return;
4845         }
4846
4847         nwrap_endhostent();
4848 }
4849 #endif /* HAVE_SOLARIS_ENDHOSTENT */
4850
4851 #ifdef BSD
4852 /* BSD implementation stores data in thread local storage but GLIBC does not */
4853 static __thread struct hostent user_he;
4854 static __thread struct nwrap_vector user_addrlist;
4855 #else
4856 static struct hostent user_he;
4857 static struct nwrap_vector user_addrlist;
4858 #endif /* BSD */
4859 static struct hostent *nwrap_gethostbyname(const char *name)
4860 {
4861         if (nwrap_files_gethostbyname(name, AF_UNSPEC, &user_he, &user_addrlist) == -1) {
4862                 return NULL;
4863         }
4864         return &user_he;
4865 }
4866
4867 struct hostent *gethostbyname(const char *name)
4868 {
4869         if (!nss_wrapper_hosts_enabled()) {
4870                 return libc_gethostbyname(name);
4871         }
4872
4873         return nwrap_gethostbyname(name);
4874 }
4875
4876 /* This is a GNU extension - Also can be found on BSD systems */
4877 #ifdef HAVE_GETHOSTBYNAME2
4878 #ifdef BSD
4879 /* BSD implementation stores data in  thread local storage but GLIBC not */
4880 static __thread struct hostent user_he2;
4881 static __thread struct nwrap_vector user_addrlist2;
4882 #else
4883 static struct hostent user_he2;
4884 static struct nwrap_vector user_addrlist2;
4885 #endif /* BSD */
4886 static struct hostent *nwrap_gethostbyname2(const char *name, int af)
4887 {
4888         if (nwrap_files_gethostbyname(name, af, &user_he2, &user_addrlist2) == -1) {
4889                 return NULL;
4890         }
4891         return &user_he2;
4892 }
4893
4894 struct hostent *gethostbyname2(const char *name, int af)
4895 {
4896         if (!nss_wrapper_hosts_enabled()) {
4897                 return libc_gethostbyname2(name, af);
4898         }
4899
4900         return nwrap_gethostbyname2(name, af);
4901 }
4902 #endif
4903
4904 static struct hostent *nwrap_gethostbyaddr(const void *addr,
4905                                            socklen_t len, int type)
4906 {
4907         return nwrap_files_gethostbyaddr(addr, len, type);
4908 }
4909
4910 struct hostent *gethostbyaddr(const void *addr,
4911                               socklen_t len, int type)
4912 {
4913         if (!nss_wrapper_hosts_enabled()) {
4914                 return libc_gethostbyaddr(addr, len, type);
4915         }
4916
4917         return nwrap_gethostbyaddr(addr, len, type);
4918 }
4919
4920 static const struct addrinfo default_hints =
4921 {
4922         .ai_flags = AI_ADDRCONFIG|AI_V4MAPPED,
4923         .ai_family = AF_UNSPEC,
4924         .ai_socktype = 0,
4925         .ai_protocol = 0,
4926         .ai_addrlen = 0,
4927         .ai_addr = NULL,
4928         .ai_canonname = NULL,
4929         .ai_next = NULL
4930 };
4931
4932 static int nwrap_convert_he_ai(const struct hostent *he,
4933                                unsigned short port,
4934                                const struct addrinfo *hints,
4935                                struct addrinfo **pai,
4936                                bool skip_canonname)
4937 {
4938         struct addrinfo *ai;
4939         socklen_t socklen;
4940
4941         if (he == NULL) {
4942                 return EAI_MEMORY;
4943         }
4944
4945         switch (he->h_addrtype) {
4946                 case AF_INET:
4947                         socklen = sizeof(struct sockaddr_in);
4948                         break;
4949 #ifdef HAVE_IPV6
4950                 case AF_INET6:
4951                         socklen = sizeof(struct sockaddr_in6);
4952                         break;
4953 #endif
4954                 default:
4955                         return EAI_FAMILY;
4956         }
4957
4958         ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) + socklen);
4959         if (ai == NULL) {
4960                 return EAI_MEMORY;
4961         }
4962
4963         ai->ai_flags = 0;
4964         ai->ai_family = he->h_addrtype;
4965         ai->ai_socktype = hints->ai_socktype;
4966         ai->ai_protocol = hints->ai_protocol;
4967         ai->ai_canonname = NULL;
4968
4969         ai->ai_addrlen = socklen;
4970         ai->ai_addr = (void *)(ai + 1);
4971
4972 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
4973         ai->ai_addr->sa_len = socklen;
4974 #endif
4975         ai->ai_addr->sa_family = he->h_addrtype;
4976
4977         switch (he->h_addrtype) {
4978                 case AF_INET:
4979                 {
4980                         struct sockaddr_in *sinp =
4981                                 (struct sockaddr_in *) ai->ai_addr;
4982
4983                         memset(sinp, 0, sizeof(struct sockaddr_in));
4984
4985                         sinp->sin_port = htons(port);
4986                         sinp->sin_family = AF_INET;
4987
4988                         memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
4989                         memcpy(&sinp->sin_addr, he->h_addr_list[0], he->h_length);
4990
4991                 }
4992                 break;
4993 #ifdef HAVE_IPV6
4994                 case AF_INET6:
4995                 {
4996                         struct sockaddr_in6 *sin6p =
4997                                 (struct sockaddr_in6 *) ai->ai_addr;
4998
4999                         memset(sin6p, 0, sizeof(struct sockaddr_in6));
5000
5001                         sin6p->sin6_port = htons(port);
5002                         sin6p->sin6_family = AF_INET6;
5003
5004                         memcpy(&sin6p->sin6_addr,
5005                                he->h_addr_list[0],
5006                                he->h_length);
5007                 }
5008                 break;
5009 #endif
5010         }
5011
5012         ai->ai_next = NULL;
5013
5014         if (he->h_name && !skip_canonname) {
5015                 ai->ai_canonname = strdup(he->h_name);
5016                 if (ai->ai_canonname == NULL) {
5017                         freeaddrinfo(ai);
5018                         return EAI_MEMORY;
5019                 }
5020         }
5021
5022         *pai = ai;
5023         return 0;
5024 }
5025
5026 static int nwrap_getaddrinfo(const char *node,
5027                              const char *service,
5028                              const struct addrinfo *hints,
5029                              struct addrinfo **res)
5030 {
5031         struct addrinfo *ai = NULL;
5032         struct addrinfo *ai_tail;
5033         unsigned short port = 0;
5034         struct {
5035                 int family;
5036                 union {
5037                         struct in_addr v4;
5038 #ifdef HAVE_IPV6
5039                         struct in6_addr v6;
5040                 } in;
5041 #endif
5042         } addr = {
5043                 .family = AF_UNSPEC,
5044         };
5045
5046         if (node == NULL && service == NULL) {
5047                 return EAI_NONAME;
5048         }
5049
5050         if (hints == NULL) {
5051                 hints = &default_hints;
5052         }
5053
5054         /* EAI_BADFLAGS
5055               hints.ai_flags   contains   invalid  flags;  or,  hints.ai_flags
5056               included AI_CANONNAME and name was NULL.
5057         */
5058         if ((hints->ai_flags & AI_CANONNAME) && (node == NULL)) {
5059                 return EAI_BADFLAGS;
5060         }
5061
5062         /* If no node has been specified, let glibc deal with it */
5063         if (node == NULL) {
5064                 int ret;
5065                 struct addrinfo *p = NULL;
5066
5067                 ret = libc_getaddrinfo(node, service, hints, &p);
5068
5069                 if (ret == 0) {
5070                         *res = p;
5071                 }
5072                 return ret;
5073         }
5074
5075         if (service != NULL && service[0] != '\0') {
5076                 const char *proto = NULL;
5077                 struct servent *s;
5078                 char *end_ptr;
5079                 long sl;
5080
5081                 errno = 0;
5082                 sl = strtol(service, &end_ptr, 10);
5083
5084                 if (*end_ptr == '\0') {
5085                         port = sl;
5086                         goto valid_port;
5087                 } else if (hints->ai_flags & AI_NUMERICSERV) {
5088                         return EAI_NONAME;
5089                 }
5090
5091                 if (hints->ai_protocol != 0) {
5092                         struct protoent *pent;
5093
5094                         pent = getprotobynumber(hints->ai_protocol);
5095                         if (pent != NULL) {
5096                                 proto = pent->p_name;
5097                         }
5098                 }
5099
5100                 s = getservbyname(service, proto);
5101                 if (s == NULL) {
5102                         return EAI_NONAME;
5103                 }
5104                 port = ntohs(s->s_port);
5105         }
5106
5107 valid_port:
5108         if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET) {
5109                 int rc = inet_pton(AF_INET, node, &addr.in.v4);
5110                 if (rc == 1) {
5111                         addr.family = AF_INET;
5112                 }
5113         }
5114 #ifdef HAVE_IPV6
5115         if (addr.family == AF_UNSPEC) {
5116                 int rc = inet_pton(AF_INET6, node, &addr.in.v6);
5117                 if (rc == 1) {
5118                         addr.family = AF_INET6;
5119                 }
5120         }
5121 #endif
5122
5123         ai = nwrap_files_getaddrinfo(node, port, hints, &ai_tail);
5124         if (ai == NULL) {
5125                 int ret;
5126                 struct addrinfo *p = NULL;
5127
5128                 ret = libc_getaddrinfo(node, service, hints, &p);
5129
5130                 if (ret == 0) {
5131                         /*
5132                          * nwrap_files_getaddrinfo failed, but libc was
5133                          * successful -- use the result from libc.
5134                          */
5135                         *res = p;
5136                         return 0;
5137                 }
5138
5139                 return EAI_SYSTEM;
5140         }
5141
5142         if (ai->ai_flags == 0) {
5143                 ai->ai_flags = hints->ai_flags;
5144         }
5145         if (ai->ai_socktype == 0) {
5146                 ai->ai_socktype = SOCK_DGRAM;
5147         }
5148         if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_DGRAM) {
5149                 ai->ai_protocol = 17; /* UDP */
5150         } else if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_STREAM) {
5151                 ai->ai_protocol = 6; /* TCP */
5152         }
5153
5154         if (hints->ai_socktype == 0) {
5155                 /* Add second ai */
5156                 struct addrinfo *ai_head = ai;
5157                 struct addrinfo *ai_tmp;
5158                 struct addrinfo *ai_new_tail = ai_tail;
5159
5160                 /* Add at least one more struct */
5161                 do {
5162                         /* CHECKS! */
5163                         ai_tmp = malloc(sizeof(struct addrinfo));
5164                         memcpy(ai_tmp, ai_head, sizeof(struct addrinfo));
5165                         ai_tmp->ai_next = NULL;
5166
5167                         /* We need a deep copy or freeaddrinfo() will blow up */
5168                         if (ai_head->ai_canonname != NULL) {
5169                                 ai_tmp->ai_canonname =
5170                                         strdup(ai_head->ai_canonname);
5171                         }
5172                         /* ai_head should point inside hints. */
5173                         ai_tmp->ai_addr = ai_head->ai_addr;
5174
5175                         if (ai_head->ai_flags == 0) {
5176                                 ai_tmp->ai_flags = hints->ai_flags;
5177                         }
5178                         if (ai_head->ai_socktype == SOCK_DGRAM) {
5179                                 ai_tmp->ai_socktype = SOCK_STREAM;
5180                         } else if (ai_head->ai_socktype == SOCK_STREAM) {
5181                                 ai_tmp->ai_socktype = SOCK_DGRAM;
5182                         }
5183                         if (ai_head->ai_socktype == SOCK_DGRAM) {
5184                                 ai_tmp->ai_protocol = 17; /* UDP */
5185                         } else if (ai_head->ai_socktype == SOCK_STREAM) {
5186                                 ai_tmp->ai_protocol = 6; /* TCP */
5187                         }
5188                         ai_new_tail->ai_next = ai_tmp;
5189                         ai_new_tail = ai_tmp;
5190
5191                         if (ai_head == ai_tail) {
5192                                 break;
5193                         }
5194                         ai_head = ai_head->ai_next;
5195                 } while (1);
5196         }
5197
5198         *res = ai;
5199
5200         return 0;
5201 }
5202
5203 int getaddrinfo(const char *node, const char *service,
5204                 const struct addrinfo *hints,
5205                 struct addrinfo **res)
5206 {
5207         if (!nss_wrapper_hosts_enabled()) {
5208                 return libc_getaddrinfo(node, service, hints, res);
5209         }
5210
5211         return nwrap_getaddrinfo(node, service, hints, res);
5212 }
5213
5214 static int nwrap_getnameinfo(const struct sockaddr *sa, socklen_t salen,
5215                              char *host, size_t hostlen,
5216                              char *serv, size_t servlen,
5217                              int flags)
5218 {
5219         struct hostent *he;
5220         struct servent *service;
5221         const char *proto;
5222         const void *addr;
5223         socklen_t addrlen;
5224         uint16_t port;
5225         sa_family_t type;
5226
5227         if (sa == NULL || salen < sizeof(sa_family_t)) {
5228                 return EAI_FAMILY;
5229         }
5230
5231         if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL) {
5232                 return EAI_NONAME;
5233         }
5234
5235         type = sa->sa_family;
5236         switch (type) {
5237         case AF_INET:
5238                 if (salen < sizeof(struct sockaddr_in))
5239                         return EAI_FAMILY;
5240                 addr = &((const struct sockaddr_in *)sa)->sin_addr;
5241                 addrlen = sizeof(((const struct sockaddr_in *)sa)->sin_addr);
5242                 port = ntohs(((const struct sockaddr_in *)sa)->sin_port);
5243                 break;
5244 #ifdef HAVE_IPV6
5245         case AF_INET6:
5246                 if (salen < sizeof(struct sockaddr_in6))
5247                         return EAI_FAMILY;
5248                 addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
5249                 addrlen = sizeof(((const struct sockaddr_in6 *)sa)->sin6_addr);
5250                 port = ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
5251                 break;
5252 #endif
5253         default:
5254                 return EAI_FAMILY;
5255         }
5256
5257         if (host != NULL) {
5258                 he = NULL;
5259                 if ((flags & NI_NUMERICHOST) == 0) {
5260                         he = nwrap_files_gethostbyaddr(addr, addrlen, type);
5261                         if ((flags & NI_NAMEREQD) && (he == NULL || he->h_name == NULL))
5262                                 return EAI_NONAME;
5263                 }
5264                 if (he != NULL && he->h_name != NULL) {
5265                         if (strlen(he->h_name) >= hostlen)
5266                                 return EAI_OVERFLOW;
5267                         strcpy(host, he->h_name);
5268                         if (flags & NI_NOFQDN)
5269                                 host[strcspn(host, ".")] = '\0';
5270                 } else {
5271                         if (inet_ntop(type, addr, host, hostlen) == NULL)
5272                                 return (errno == ENOSPC) ? EAI_OVERFLOW : EAI_FAIL;
5273                 }
5274         }
5275
5276         if (serv != NULL) {
5277                 service = NULL;
5278                 if ((flags & NI_NUMERICSERV) == 0) {
5279                         proto = (flags & NI_DGRAM) ? "udp" : "tcp";
5280                         service = getservbyport(htons(port), proto);
5281                 }
5282                 if (service != NULL) {
5283                         if (strlen(service->s_name) >= servlen)
5284                                 return EAI_OVERFLOW;
5285                         strcpy(serv, service->s_name);
5286                 } else {
5287                         if (snprintf(serv, servlen, "%u", port) >= (int) servlen)
5288                                 return EAI_OVERFLOW;
5289                 }
5290         }
5291
5292         return 0;
5293 }
5294
5295 #ifdef HAVE_LINUX_GETNAMEINFO
5296 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5297                 char *host, socklen_t hostlen,
5298                 char *serv, socklen_t servlen,
5299                 int flags)
5300 #elif defined(HAVE_LINUX_GETNAMEINFO_UNSIGNED)
5301 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5302                 char *host, socklen_t hostlen,
5303                 char *serv, socklen_t servlen,
5304                 unsigned int flags)
5305 #else
5306 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5307                 char *host, size_t hostlen,
5308                 char *serv, size_t servlen,
5309                 int flags)
5310 #endif
5311 {
5312         if (!nss_wrapper_hosts_enabled()) {
5313                 return libc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5314         }
5315
5316         return nwrap_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5317 }
5318
5319 static int nwrap_gethostname(char *name, size_t len)
5320 {
5321         const char *hostname = getenv("NSS_WRAPPER_HOSTNAME");
5322
5323         if (strlen(hostname) >= len) {
5324                 errno = ENAMETOOLONG;
5325                 return -1;
5326         }
5327         snprintf(name, len, "%s", hostname);
5328
5329         return 0;
5330 }
5331
5332 #ifdef HAVE_SOLARIS_GETHOSTNAME
5333 int gethostname(char *name, int len)
5334 #else /* HAVE_SOLARIS_GETHOSTNAME */
5335 int gethostname(char *name, size_t len)
5336 #endif /* HAVE_SOLARIS_GETHOSTNAME */
5337 {
5338         if (!nwrap_hostname_enabled()) {
5339                 return libc_gethostname(name, len);
5340         }
5341
5342         return nwrap_gethostname(name, len);
5343 }
5344
5345 /****************************
5346  * DESTRUCTOR
5347  ***************************/
5348
5349 /*
5350  * This function is called when the library is unloaded and makes sure that
5351  * sockets get closed and the unix file for the socket are unlinked.
5352  */
5353 void nwrap_destructor(void)
5354 {
5355         int i;
5356
5357         NWRAP_LOCK_ALL;
5358         if (nwrap_main_global != NULL) {
5359                 struct nwrap_main *m = nwrap_main_global;
5360
5361                 /* libc */
5362                 SAFE_FREE(m->libc->fns);
5363                 if (m->libc->handle != NULL) {
5364                         dlclose(m->libc->handle);
5365                 }
5366                 if (m->libc->nsl_handle != NULL) {
5367                         dlclose(m->libc->nsl_handle);
5368                 }
5369                 if (m->libc->sock_handle != NULL) {
5370                         dlclose(m->libc->sock_handle);
5371                 }
5372                 SAFE_FREE(m->libc);
5373
5374                 /* backends */
5375                 for (i = 0; i < m->num_backends; i++) {
5376                         struct nwrap_backend *b = &(m->backends[i]);
5377
5378                         if (b->so_handle != NULL) {
5379                                 dlclose(b->so_handle);
5380                         }
5381                         SAFE_FREE(b->fns);
5382                 }
5383                 SAFE_FREE(m->backends);
5384         }
5385
5386         if (nwrap_pw_global.cache != NULL) {
5387                 struct nwrap_cache *c = nwrap_pw_global.cache;
5388
5389                 nwrap_files_cache_unload(c);
5390                 if (c->fd >= 0) {
5391                         fclose(c->fp);
5392                         c->fd = -1;
5393                 }
5394
5395                 SAFE_FREE(nwrap_pw_global.list);
5396                 nwrap_pw_global.num = 0;
5397         }
5398
5399         if (nwrap_gr_global.cache != NULL) {
5400                 struct nwrap_cache *c = nwrap_gr_global.cache;
5401
5402                 nwrap_files_cache_unload(c);
5403                 if (c->fd >= 0) {
5404                         fclose(c->fp);
5405                         c->fd = -1;
5406                 }
5407
5408                 SAFE_FREE(nwrap_gr_global.list);
5409                 nwrap_pw_global.num = 0;
5410         }
5411
5412         if (nwrap_he_global.cache != NULL) {
5413                 struct nwrap_cache *c = nwrap_he_global.cache;
5414
5415                 nwrap_files_cache_unload(c);
5416                 if (c->fd >= 0) {
5417                         fclose(c->fp);
5418                         c->fd = -1;
5419                 }
5420
5421                 nwrap_he_global.num = 0;
5422         }
5423
5424         hdestroy();
5425         NWRAP_UNLOCK_ALL;
5426 }