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 <sys/types.h>
  39 #include <sys/stat.h>
  40 #include <sys/socket.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <stdarg.h>
  44 #include <stdbool.h>
  45 #include <stddef.h>
  46 #include <stdio.h>
  47 #include <stdint.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51 #include <ctype.h>
  52
  53 /*
  54  * Defining _POSIX_PTHREAD_SEMANTICS before including pwd.h and grp.h  gives us
  55  * the posix getpwnam_r(), getpwuid_r(), getgrnam_r and getgrgid_r calls on
  56  * Solaris
  57  */
  58 #ifndef _POSIX_PTHREAD_SEMANTICS
  59 #define _POSIX_PTHREAD_SEMANTICS
  60 #endif
  61
  62 #include <pwd.h>
  63 #include <grp.h>
  64
  65 #include <netdb.h>
  66 #include <arpa/inet.h>
  67 #include <netinet/in.h>
  68
  69 #include <dlfcn.h>
  70
  71 #if defined(HAVE_NSS_H)
  72 /* Linux and BSD */
  73 #include <nss.h>
  74
  75 typedef enum nss_status NSS_STATUS;
  76 #elif defined(HAVE_NSS_COMMON_H)
  77 /* Solaris */
  78 #include <nss_common.h>
  79 #include <nss_dbdefs.h>
  80 #include <nsswitch.h>
  81
  82 typedef nss_status_t NSS_STATUS;
  83
  84 # define NSS_STATUS_SUCCESS     NSS_SUCCESS
  85 # define NSS_STATUS_NOTFOUND    NSS_NOTFOUND
  86 # define NSS_STATUS_UNAVAIL     NSS_UNAVAIL
  87 # define NSS_STATUS_TRYAGAIN    NSS_TRYAGAIN
  88 #else
  89 # error "No nsswitch support detected"
  90 #endif
  91
  92 #ifndef PTR_DIFF
  93 #define PTR_DIFF(p1, p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
  94 #endif
  95
  96 #ifndef _PUBLIC_
  97 #define _PUBLIC_
  98 #endif
  99
 100 #ifndef EAI_NODATA
 101 #define EAI_NODATA EAI_NONAME
 102 #endif
 103
 104 #ifndef EAI_ADDRFAMILY
 105 #define EAI_ADDRFAMILY EAI_FAMILY
 106 #endif
 107
 108 #ifndef __STRING
 109 #define __STRING(x)    #x
 110 #endif
 111
 112 #ifndef __STRINGSTRING
 113 #define __STRINGSTRING(x) __STRING(x)
 114 #endif
 115
 116 #ifndef __LINESTR__
 117 #define __LINESTR__ __STRINGSTRING(__LINE__)
 118 #endif
 119
 120 #ifndef __location__
 121 #define __location__ __FILE__ ":" __LINESTR__
 122 #endif
 123
 124 /* GCC have printf type attribute check. */
 125 #ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
 126 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
 127 #else
 128 #define PRINTF_ATTRIBUTE(a,b)
 129 #endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
 130
 131 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
 132 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
 133 #else
 134 #define DESTRUCTOR_ATTRIBUTE
 135 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
 136
 137 #define ZERO_STRUCTP(x) do { if ((x) != NULL) memset((char *)(x), 0, sizeof(*(x))); } while(0)
 138
 139 enum nwrap_dbglvl_e {
 140         NWRAP_LOG_ERROR = 0,
 141         NWRAP_LOG_WARN,
 142         NWRAP_LOG_DEBUG,
 143         NWRAP_LOG_TRACE
 144 };
 145
 146 #ifdef NDEBUG
 147 # define NWRAP_LOG(...)
 148 #else
 149
 150 static void nwrap_log(enum nwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
 151 # define NWRAP_LOG(dbglvl, ...) nwrap_log((dbglvl), __func__, __VA_ARGS__)
 152
 153 static void nwrap_log(enum nwrap_dbglvl_e dbglvl,
 154                       const char *func,
 155                       const char *format, ...)
 156 {
 157         char buffer[1024];
 158         va_list va;
 159         const char *d;
 160         unsigned int lvl = 0;
 161         int pid = getpid();
 162
 163         d = getenv("NSS_WRAPPER_DEBUGLEVEL");
 164         if (d != NULL) {
 165                 lvl = atoi(d);
 166         }
 167
 168         va_start(va, format);
 169         vsnprintf(buffer, sizeof(buffer), format, va);
 170         va_end(va);
 171
 172         if (lvl >= dbglvl) {
 173                 switch (dbglvl) {
 174                         case NWRAP_LOG_ERROR:
 175                                 fprintf(stderr,
 176                                         "NWRAP_ERROR(%d) - %s: %s\n",
 177                                         pid, func, buffer);
 178                                 break;
 179                         case NWRAP_LOG_WARN:
 180                                 fprintf(stderr,
 181                                         "NWRAP_WARN(%d) - %s: %s\n",
 182                                         pid, func, buffer);
 183                                 break;
 184                         case NWRAP_LOG_DEBUG:
 185                                 fprintf(stderr,
 186                                         "NWRAP_DEBUG(%d) - %s: %s\n",
 187                                         pid, func, buffer);
 188                                 break;
 189                         case NWRAP_LOG_TRACE:
 190                                 fprintf(stderr,
 191                                         "NWRAP_TRACE(%d) - %s: %s\n",
 192                                         pid, func, buffer);
 193                                 break;
 194                 }
 195         }
 196 }
 197 #endif /* NDEBUG NWRAP_LOG */
 198
 199 struct nwrap_libc_fns {
 200         struct passwd *(*_libc_getpwnam)(const char *name);
 201         int (*_libc_getpwnam_r)(const char *name, struct passwd *pwd,
 202                        char *buf, size_t buflen, struct passwd **result);
 203         struct passwd *(*_libc_getpwuid)(uid_t uid);
 204         int (*_libc_getpwuid_r)(uid_t uid, struct passwd *pwd, char *buf, size_t buflen, struct passwd **result);
 205         void (*_libc_setpwent)(void);
 206         struct passwd *(*_libc_getpwent)(void);
 207 #ifdef HAVE_SOLARIS_GETPWENT_R
 208         struct passwd *(*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen);
 209 #else
 210         int (*_libc_getpwent_r)(struct passwd *pwbuf, char *buf, size_t buflen, struct passwd **pwbufp);
 211 #endif
 212         void (*_libc_endpwent)(void);
 213         int (*_libc_initgroups)(const char *user, gid_t gid);
 214         struct group *(*_libc_getgrnam)(const char *name);
 215         int (*_libc_getgrnam_r)(const char *name, struct group *grp, char *buf, size_t buflen, struct group **result);
 216         struct group *(*_libc_getgrgid)(gid_t gid);
 217         int (*_libc_getgrgid_r)(gid_t gid, struct group *grp, char *buf, size_t buflen, struct group **result);
 218         void (*_libc_setgrent)(void);
 219         struct group *(*_libc_getgrent)(void);
 220 #ifdef HAVE_SOLARIS_GETGRENT_R
 221         struct group *(*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen);
 222 #else
 223         int (*_libc_getgrent_r)(struct group *group, char *buf, size_t buflen, struct group **result);
 224 #endif
 225         void (*_libc_endgrent)(void);
 226         int (*_libc_getgrouplist)(const char *user, gid_t group, gid_t *groups, int *ngroups);
 227
 228         void (*_libc_sethostent)(int stayopen);
 229         struct hostent *(*_libc_gethostent)(void);
 230         void (*_libc_endhostent)(void);
 231
 232         struct hostent *(*_libc_gethostbyname)(const char *name);
 233 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
 234         struct hostent *(*_libc_gethostbyname2)(const char *name, int af);
 235 #endif
 236         struct hostent *(*_libc_gethostbyaddr)(const void *addr, socklen_t len, int type);
 237
 238         int (*_libc_getaddrinfo)(const char *node, const char *service,
 239                                  const struct addrinfo *hints,
 240                                  struct addrinfo **res);
 241         int (*_libc_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
 242                                  char *host, size_t hostlen,
 243                                  char *serv, size_t servlen,
 244                                  int flags);
 245         int (*_libc_gethostname)(char *name, size_t len);
 246 #ifdef HAVE_GETHOSTBYNAME_R
 247         int (*_libc_gethostbyname_r)(const char *name,
 248                                      struct hostent *ret,
 249                                      char *buf, size_t buflen,
 250                                      struct hostent **result, int *h_errnop);
 251 #endif
 252 #ifdef HAVE_GETHOSTBYADDR_R
 253         int (*_libc_gethostbyaddr_r)(const void *addr, socklen_t len, int type,
 254                                      struct hostent *ret,
 255                                      char *buf, size_t buflen,
 256                                      struct hostent **result, int *h_errnop);
 257 #endif
 258 };
 259
 260 struct nwrap_module_nss_fns {
 261         NSS_STATUS (*_nss_getpwnam_r)(const char *name, struct passwd *result, char *buffer,
 262                                       size_t buflen, int *errnop);
 263         NSS_STATUS (*_nss_getpwuid_r)(uid_t uid, struct passwd *result, char *buffer,
 264                                       size_t buflen, int *errnop);
 265         NSS_STATUS (*_nss_setpwent)(void);
 266         NSS_STATUS (*_nss_getpwent_r)(struct passwd *result, char *buffer,
 267                                       size_t buflen, int *errnop);
 268         NSS_STATUS (*_nss_endpwent)(void);
 269         NSS_STATUS (*_nss_initgroups)(const char *user, gid_t group, long int *start,
 270                                       long int *size, gid_t **groups, long int limit, int *errnop);
 271         NSS_STATUS (*_nss_getgrnam_r)(const char *name, struct group *result, char *buffer,
 272                                       size_t buflen, int *errnop);
 273         NSS_STATUS (*_nss_getgrgid_r)(gid_t gid, struct group *result, char *buffer,
 274                                       size_t buflen, int *errnop);
 275         NSS_STATUS (*_nss_setgrent)(void);
 276         NSS_STATUS (*_nss_getgrent_r)(struct group *result, char *buffer,
 277                                       size_t buflen, int *errnop);
 278         NSS_STATUS (*_nss_endgrent)(void);
 279 };
 280
 281 struct nwrap_backend {
 282         const char *name;
 283         const char *so_path;
 284         void *so_handle;
 285         struct nwrap_ops *ops;
 286         struct nwrap_module_nss_fns *fns;
 287 };
 288
 289 struct nwrap_ops {
 290         struct passwd * (*nw_getpwnam)(struct nwrap_backend *b,
 291                                        const char *name);
 292         int             (*nw_getpwnam_r)(struct nwrap_backend *b,
 293                                          const char *name, struct passwd *pwdst,
 294                                          char *buf, size_t buflen, struct passwd **pwdstp);
 295         struct passwd * (*nw_getpwuid)(struct nwrap_backend *b,
 296                                        uid_t uid);
 297         int             (*nw_getpwuid_r)(struct nwrap_backend *b,
 298                                          uid_t uid, struct passwd *pwdst,
 299                                          char *buf, size_t buflen, struct passwd **pwdstp);
 300         void            (*nw_setpwent)(struct nwrap_backend *b);
 301         struct passwd * (*nw_getpwent)(struct nwrap_backend *b);
 302         int             (*nw_getpwent_r)(struct nwrap_backend *b,
 303                                          struct passwd *pwdst, char *buf,
 304                                          size_t buflen, struct passwd **pwdstp);
 305         void            (*nw_endpwent)(struct nwrap_backend *b);
 306         int             (*nw_initgroups)(struct nwrap_backend *b,
 307                                          const char *user, gid_t group);
 308         struct group *  (*nw_getgrnam)(struct nwrap_backend *b,
 309                                        const char *name);
 310         int             (*nw_getgrnam_r)(struct nwrap_backend *b,
 311                                          const char *name, struct group *grdst,
 312                                          char *buf, size_t buflen, struct group **grdstp);
 313         struct group *  (*nw_getgrgid)(struct nwrap_backend *b,
 314                                        gid_t gid);
 315         int             (*nw_getgrgid_r)(struct nwrap_backend *b,
 316                                          gid_t gid, struct group *grdst,
 317                                          char *buf, size_t buflen, struct group **grdstp);
 318         void            (*nw_setgrent)(struct nwrap_backend *b);
 319         struct group *  (*nw_getgrent)(struct nwrap_backend *b);
 320         int             (*nw_getgrent_r)(struct nwrap_backend *b,
 321                                          struct group *grdst, char *buf,
 322                                          size_t buflen, struct group **grdstp);
 323         void            (*nw_endgrent)(struct nwrap_backend *b);
 324 };
 325
 326 /* Public prototypes */
 327
 328 bool nss_wrapper_enabled(void);
 329 bool nss_wrapper_hosts_enabled(void);
 330
 331 /* prototypes for files backend */
 332
 333
 334 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
 335                                            const char *name);
 336 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
 337                                   const char *name, struct passwd *pwdst,
 338                                   char *buf, size_t buflen, struct passwd **pwdstp);
 339 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
 340                                            uid_t uid);
 341 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
 342                                   uid_t uid, struct passwd *pwdst,
 343                                   char *buf, size_t buflen, struct passwd **pwdstp);
 344 static void nwrap_files_setpwent(struct nwrap_backend *b);
 345 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b);
 346 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
 347                                   struct passwd *pwdst, char *buf,
 348                                   size_t buflen, struct passwd **pwdstp);
 349 static void nwrap_files_endpwent(struct nwrap_backend *b);
 350 static int nwrap_files_initgroups(struct nwrap_backend *b,
 351                                   const char *user, gid_t group);
 352 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
 353                                           const char *name);
 354 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
 355                                   const char *name, struct group *grdst,
 356                                   char *buf, size_t buflen, struct group **grdstp);
 357 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
 358                                           gid_t gid);
 359 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
 360                                   gid_t gid, struct group *grdst,
 361                                   char *buf, size_t buflen, struct group **grdstp);
 362 static void nwrap_files_setgrent(struct nwrap_backend *b);
 363 static struct group *nwrap_files_getgrent(struct nwrap_backend *b);
 364 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
 365                                   struct group *grdst, char *buf,
 366                                   size_t buflen, struct group **grdstp);
 367 static void nwrap_files_endgrent(struct nwrap_backend *b);
 368
 369 /* prototypes for module backend */
 370
 371 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
 372 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
 373                                    struct passwd *pwdst, char *buf,
 374                                    size_t buflen, struct passwd **pwdstp);
 375 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
 376                                             const char *name);
 377 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
 378                                    const char *name, struct passwd *pwdst,
 379                                    char *buf, size_t buflen, struct passwd **pwdstp);
 380 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
 381                                             uid_t uid);
 382 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
 383                                    uid_t uid, struct passwd *pwdst,
 384                                    char *buf, size_t buflen, struct passwd **pwdstp);
 385 static void nwrap_module_setpwent(struct nwrap_backend *b);
 386 static void nwrap_module_endpwent(struct nwrap_backend *b);
 387 static struct group *nwrap_module_getgrent(struct nwrap_backend *b);
 388 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
 389                                    struct group *grdst, char *buf,
 390                                    size_t buflen, struct group **grdstp);
 391 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
 392                                            const char *name);
 393 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
 394                                    const char *name, struct group *grdst,
 395                                    char *buf, size_t buflen, struct group **grdstp);
 396 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
 397                                            gid_t gid);
 398 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
 399                                    gid_t gid, struct group *grdst,
 400                                    char *buf, size_t buflen, struct group **grdstp);
 401 static void nwrap_module_setgrent(struct nwrap_backend *b);
 402 static void nwrap_module_endgrent(struct nwrap_backend *b);
 403 static int nwrap_module_initgroups(struct nwrap_backend *b,
 404                                    const char *user, gid_t group);
 405
 406 struct nwrap_ops nwrap_files_ops = {
 407         .nw_getpwnam    = nwrap_files_getpwnam,
 408         .nw_getpwnam_r  = nwrap_files_getpwnam_r,
 409         .nw_getpwuid    = nwrap_files_getpwuid,
 410         .nw_getpwuid_r  = nwrap_files_getpwuid_r,
 411         .nw_setpwent    = nwrap_files_setpwent,
 412         .nw_getpwent    = nwrap_files_getpwent,
 413         .nw_getpwent_r  = nwrap_files_getpwent_r,
 414         .nw_endpwent    = nwrap_files_endpwent,
 415         .nw_initgroups  = nwrap_files_initgroups,
 416         .nw_getgrnam    = nwrap_files_getgrnam,
 417         .nw_getgrnam_r  = nwrap_files_getgrnam_r,
 418         .nw_getgrgid    = nwrap_files_getgrgid,
 419         .nw_getgrgid_r  = nwrap_files_getgrgid_r,
 420         .nw_setgrent    = nwrap_files_setgrent,
 421         .nw_getgrent    = nwrap_files_getgrent,
 422         .nw_getgrent_r  = nwrap_files_getgrent_r,
 423         .nw_endgrent    = nwrap_files_endgrent,
 424 };
 425
 426 struct nwrap_ops nwrap_module_ops = {
 427         .nw_getpwnam    = nwrap_module_getpwnam,
 428         .nw_getpwnam_r  = nwrap_module_getpwnam_r,
 429         .nw_getpwuid    = nwrap_module_getpwuid,
 430         .nw_getpwuid_r  = nwrap_module_getpwuid_r,
 431         .nw_setpwent    = nwrap_module_setpwent,
 432         .nw_getpwent    = nwrap_module_getpwent,
 433         .nw_getpwent_r  = nwrap_module_getpwent_r,
 434         .nw_endpwent    = nwrap_module_endpwent,
 435         .nw_initgroups  = nwrap_module_initgroups,
 436         .nw_getgrnam    = nwrap_module_getgrnam,
 437         .nw_getgrnam_r  = nwrap_module_getgrnam_r,
 438         .nw_getgrgid    = nwrap_module_getgrgid,
 439         .nw_getgrgid_r  = nwrap_module_getgrgid_r,
 440         .nw_setgrent    = nwrap_module_setgrent,
 441         .nw_getgrent    = nwrap_module_getgrent,
 442         .nw_getgrent_r  = nwrap_module_getgrent_r,
 443         .nw_endgrent    = nwrap_module_endgrent,
 444 };
 445
 446 struct nwrap_libc {
 447         void *handle;
 448         void *nsl_handle;
 449         void *sock_handle;
 450         struct nwrap_libc_fns *fns;
 451 };
 452
 453 struct nwrap_main {
 454         const char *nwrap_switch;
 455         int num_backends;
 456         struct nwrap_backend *backends;
 457         struct nwrap_libc *libc;
 458 };
 459
 460 struct nwrap_main *nwrap_main_global;
 461 struct nwrap_main __nwrap_main_global;
 462
 463 struct nwrap_cache {
 464         const char *path;
 465         int fd;
 466         struct stat st;
 467         uint8_t *buf;
 468         void *private_data;
 469         bool (*parse_line)(struct nwrap_cache *, char *line);
 470         void (*unload)(struct nwrap_cache *);
 471 };
 472
 473 struct nwrap_pw {
 474         struct nwrap_cache *cache;
 475
 476         struct passwd *list;
 477         int num;
 478         int idx;
 479 };
 480
 481 struct nwrap_cache __nwrap_cache_pw;
 482 struct nwrap_pw nwrap_pw_global;
 483
 484 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line);
 485 static void nwrap_pw_unload(struct nwrap_cache *nwrap);
 486
 487 struct nwrap_gr {
 488         struct nwrap_cache *cache;
 489
 490         struct group *list;
 491         int num;
 492         int idx;
 493 };
 494
 495 struct nwrap_cache __nwrap_cache_gr;
 496 struct nwrap_gr nwrap_gr_global;
 497
 498 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line);
 499 static void nwrap_he_unload(struct nwrap_cache *nwrap);
 500
 501 struct nwrap_addrdata {
 502         unsigned char host_addr[16]; /* IPv4 or IPv6 address */
 503         char *h_addr_ptrs[2]; /* host_addr pointer + NULL */
 504 };
 505
 506 struct nwrap_entdata {
 507         struct nwrap_addrdata *addr;
 508         struct hostent ht;
 509 };
 510
 511 struct nwrap_he {
 512         struct nwrap_cache *cache;
 513
 514         struct nwrap_entdata *list;
 515         int num;
 516         int idx;
 517 };
 518
 519 struct nwrap_cache __nwrap_cache_he;
 520 struct nwrap_he nwrap_he_global;
 521
 522
 523 /*********************************************************
 524  * NWRAP PROTOTYPES
 525  *********************************************************/
 526
 527 static void nwrap_init(void);
 528 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line);
 529 static void nwrap_gr_unload(struct nwrap_cache *nwrap);
 530 void nwrap_destructor(void) DESTRUCTOR_ATTRIBUTE;
 531
 532 /*********************************************************
 533  * NWRAP LIBC LOADER FUNCTIONS
 534  *********************************************************/
 535
 536 enum nwrap_lib {
 537     NWRAP_LIBC,
 538     NWRAP_LIBNSL,
 539     NWRAP_LIBSOCKET,
 540 };
 541
 542 #ifndef NDEBUG
 543 static const char *nwrap_str_lib(enum nwrap_lib lib)
 544 {
 545         switch (lib) {
 546         case NWRAP_LIBC:
 547                 return "libc";
 548         case NWRAP_LIBNSL:
 549                 return "libnsl";
 550         case NWRAP_LIBSOCKET:
 551                 return "libsocket";
 552         }
 553
 554         /* Compiler would warn us about unhandled enum value if we get here */
 555         return "unknown";
 556 }
 557 #endif
 558
 559 static void *nwrap_load_lib_handle(enum nwrap_lib lib)
 560 {
 561         int flags = RTLD_LAZY;
 562         void *handle = NULL;
 563         int i;
 564
 565 #ifdef RTLD_DEEPBIND
 566         flags |= RTLD_DEEPBIND;
 567 #endif
 568
 569         switch (lib) {
 570         case NWRAP_LIBNSL:
 571 #ifdef HAVE_LIBNSL
 572                 handle = nwrap_main_global->libc->nsl_handle;
 573                 if (handle == NULL) {
 574                         for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
 575                                 char soname[256] = {0};
 576
 577                                 snprintf(soname, sizeof(soname), "libnsl.so.%d", i);
 578                                 handle = dlopen(soname, flags);
 579                         }
 580
 581                         nwrap_main_global->libc->nsl_handle = handle;
 582                 }
 583                 break;
 584 #endif
 585                 /* FALL TROUGH */
 586         case NWRAP_LIBSOCKET:
 587 #ifdef HAVE_LIBSOCKET
 588                 handle = nwrap_main_global->libc->sock_handle;
 589                 if (handle == NULL) {
 590                         for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
 591                                 char soname[256] = {0};
 592
 593                                 snprintf(soname, sizeof(soname), "libsocket.so.%d", i);
 594                                 handle = dlopen(soname, flags);
 595                         }
 596
 597                         nwrap_main_global->libc->sock_handle = handle;
 598                 }
 599                 break;
 600 #endif
 601                 /* FALL TROUGH */
 602         case NWRAP_LIBC:
 603                 handle = nwrap_main_global->libc->handle;
 604                 if (handle == NULL) {
 605                         for (handle = NULL, i = 10; handle == NULL && i >= 0; i--) {
 606                                 char soname[256] = {0};
 607
 608                                 snprintf(soname, sizeof(soname), "libc.so.%d", i);
 609                                 handle = dlopen(soname, flags);
 610                         }
 611
 612                         nwrap_main_global->libc->handle = handle;
 613                 }
 614                 break;
 615         }
 616
 617         if (handle == NULL) {
 618 #ifdef RTLD_NEXT
 619                 handle = nwrap_main_global->libc->handle
 620                        = nwrap_main_global->libc->sock_handle
 621                        = nwrap_main_global->libc->nsl_handle
 622                        = RTLD_NEXT;
 623 #else
 624                 NWRAP_LOG(NWRAP_LOG_ERROR,
 625                           "Failed to dlopen library: %s\n",
 626                           dlerror());
 627                 exit(-1);
 628 #endif
 629         }
 630
 631         return handle;
 632 }
 633
 634 static void *_nwrap_load_lib_function(enum nwrap_lib lib, const char *fn_name)
 635 {
 636         void *handle;
 637         void *func;
 638
 639         nwrap_init();
 640
 641         handle = nwrap_load_lib_handle(lib);
 642
 643         func = dlsym(handle, fn_name);
 644         if (func == NULL) {
 645                 NWRAP_LOG(NWRAP_LOG_ERROR,
 646                                 "Failed to find %s: %s\n",
 647                                 fn_name, dlerror());
 648                 exit(-1);
 649         }
 650
 651         NWRAP_LOG(NWRAP_LOG_TRACE,
 652                         "Loaded %s from %s",
 653                         fn_name, nwrap_str_lib(lib));
 654         return func;
 655 }
 656
 657 #define nwrap_load_lib_function(lib, fn_name) \
 658         if (nwrap_main_global->libc->fns->_libc_##fn_name == NULL) { \
 659                 *(void **) (&nwrap_main_global->libc->fns->_libc_##fn_name) = \
 660                         _nwrap_load_lib_function(lib, #fn_name); \
 661         }
 662
 663 /*
 664  * IMPORTANT
 665  *
 666  * Functions expeciall from libc need to be loaded individually, you can't load
 667  * all at once or gdb will segfault at startup. The same applies to valgrind and
 668  * has probably something todo with with the linker.
 669  * So we need load each function at the point it is called the first time.
 670  */
 671 static struct passwd *libc_getpwnam(const char *name)
 672 {
 673         nwrap_load_lib_function(NWRAP_LIBC, getpwnam);
 674
 675         return nwrap_main_global->libc->fns->_libc_getpwnam(name);
 676 }
 677
 678 #ifdef HAVE_GETPWNAM_R
 679 static int libc_getpwnam_r(const char *name,
 680                            struct passwd *pwd,
 681                            char *buf,
 682                            size_t buflen,
 683                            struct passwd **result)
 684 {
 685 #ifdef HAVE___POSIX_GETPWNAM_R
 686         if (nwrap_main_global->libc->fns->_libc_getpwnam_r == NULL) {
 687                 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwnam_r) =
 688                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwnam_r");
 689         }
 690 #else
 691         nwrap_load_lib_function(NWRAP_LIBC, getpwnam_r);
 692 #endif
 693
 694         return nwrap_main_global->libc->fns->_libc_getpwnam_r(name,
 695                                                               pwd,
 696                                                               buf,
 697                                                               buflen,
 698                                                               result);
 699 }
 700 #endif
 701
 702 static struct passwd *libc_getpwuid(uid_t uid)
 703 {
 704         nwrap_load_lib_function(NWRAP_LIBC, getpwuid);
 705
 706         return nwrap_main_global->libc->fns->_libc_getpwuid(uid);
 707 }
 708
 709 #ifdef HAVE_GETPWUID_R
 710 static int libc_getpwuid_r(uid_t uid,
 711                            struct passwd *pwd,
 712                            char *buf,
 713                            size_t buflen,
 714                            struct passwd **result)
 715 {
 716 #ifdef HAVE___POSIX_GETPWUID_R
 717         if (nwrap_main_global->libc->fns->_libc_getpwuid_r == NULL) {
 718                 *(void **) (&nwrap_main_global->libc->fns->_libc_getpwuid_r) =
 719                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getpwuid_r");
 720         }
 721 #else
 722         nwrap_load_lib_function(NWRAP_LIBC, getpwuid_r);
 723 #endif
 724
 725         return nwrap_main_global->libc->fns->_libc_getpwuid_r(uid,
 726                                                               pwd,
 727                                                               buf,
 728                                                               buflen,
 729                                                               result);
 730 }
 731 #endif
 732
 733 static void libc_setpwent(void)
 734 {
 735         nwrap_load_lib_function(NWRAP_LIBC, setpwent);
 736
 737         nwrap_main_global->libc->fns->_libc_setpwent();
 738 }
 739
 740 static struct passwd *libc_getpwent(void)
 741 {
 742         nwrap_load_lib_function(NWRAP_LIBC, getpwent);
 743
 744         return nwrap_main_global->libc->fns->_libc_getpwent();
 745 }
 746
 747 #ifdef HAVE_SOLARIS_GETPWENT_R
 748 static struct passwd *libc_getpwent_r(struct passwd *pwdst,
 749                                       char *buf,
 750                                       int buflen)
 751 {
 752         nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
 753
 754         return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
 755                                                               buf,
 756                                                               buflen);
 757 }
 758 #else /* HAVE_SOLARIS_GETPWENT_R */
 759 static int libc_getpwent_r(struct passwd *pwdst,
 760                            char *buf,
 761                            size_t buflen,
 762                            struct passwd **pwdstp)
 763 {
 764         nwrap_load_lib_function(NWRAP_LIBC, getpwent_r);
 765
 766         return nwrap_main_global->libc->fns->_libc_getpwent_r(pwdst,
 767                                                               buf,
 768                                                               buflen,
 769                                                               pwdstp);
 770 }
 771 #endif /* HAVE_SOLARIS_GETPWENT_R */
 772
 773 static void libc_endpwent(void)
 774 {
 775         nwrap_load_lib_function(NWRAP_LIBC, endpwent);
 776
 777         nwrap_main_global->libc->fns->_libc_endpwent();
 778 }
 779
 780 static int libc_initgroups(const char *user, gid_t gid)
 781 {
 782         nwrap_load_lib_function(NWRAP_LIBC, initgroups);
 783
 784         return nwrap_main_global->libc->fns->_libc_initgroups(user, gid);
 785 }
 786
 787 static struct group *libc_getgrnam(const char *name)
 788 {
 789         nwrap_load_lib_function(NWRAP_LIBC, getgrnam);
 790
 791         return nwrap_main_global->libc->fns->_libc_getgrnam(name);
 792 }
 793
 794 #ifdef HAVE_GETGRNAM_R
 795 static int libc_getgrnam_r(const char *name,
 796                            struct group *grp,
 797                            char *buf,
 798                            size_t buflen,
 799                            struct group **result)
 800 {
 801 #ifdef HAVE___POSIX_GETGRNAM_R
 802         if (nwrap_main_global->libc->fns->_libc_getgrnam_r == NULL) {
 803                 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrnam_r) =
 804                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrnam_r");
 805         }
 806 #else
 807         nwrap_load_lib_function(NWRAP_LIBC, getgrnam_r);
 808 #endif
 809
 810         return nwrap_main_global->libc->fns->_libc_getgrnam_r(name,
 811                                                               grp,
 812                                                               buf,
 813                                                               buflen,
 814                                                               result);
 815 }
 816 #endif
 817
 818 static struct group *libc_getgrgid(gid_t gid)
 819 {
 820         nwrap_load_lib_function(NWRAP_LIBC, getgrgid);
 821
 822         return nwrap_main_global->libc->fns->_libc_getgrgid(gid);
 823 }
 824
 825 #ifdef HAVE_GETGRGID_R
 826 static int libc_getgrgid_r(gid_t gid,
 827                            struct group *grp,
 828                            char *buf,
 829                            size_t buflen,
 830                            struct group **result)
 831 {
 832 #ifdef HAVE___POSIX_GETGRGID_R
 833         if (nwrap_main_global->libc->fns->_libc_getgrgid_r == NULL) {
 834                 *(void **) (&nwrap_main_global->libc->fns->_libc_getgrgid_r) =
 835                         _nwrap_load_lib_function(NWRAP_LIBC, "__posix_getgrgid_r");
 836         }
 837 #else
 838         nwrap_load_lib_function(NWRAP_LIBC, getgrgid_r);
 839 #endif
 840
 841         return nwrap_main_global->libc->fns->_libc_getgrgid_r(gid,
 842                                                               grp,
 843                                                               buf,
 844                                                               buflen,
 845                                                               result);
 846 }
 847 #endif
 848
 849 static void libc_setgrent(void)
 850 {
 851         nwrap_load_lib_function(NWRAP_LIBC, setgrent);
 852
 853         nwrap_main_global->libc->fns->_libc_setgrent();
 854 }
 855
 856 static struct group *libc_getgrent(void)
 857 {
 858         nwrap_load_lib_function(NWRAP_LIBC, getgrent);
 859
 860         return nwrap_main_global->libc->fns->_libc_getgrent();
 861 }
 862
 863 #ifdef HAVE_GETGRENT_R
 864 #ifdef HAVE_SOLARIS_GETGRENT_R
 865 static struct group *libc_getgrent_r(struct group *group,
 866                                      char *buf,
 867                                      size_t buflen)
 868 {
 869         nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
 870
 871         return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
 872                                                               buf,
 873                                                               buflen);
 874 }
 875 #else /* !HAVE_SOLARIS_GETGRENT_R */
 876 static int libc_getgrent_r(struct group *group,
 877                            char *buf,
 878                            size_t buflen,
 879                            struct group **result)
 880 {
 881         nwrap_load_lib_function(NWRAP_LIBC, getgrent_r);
 882
 883         return nwrap_main_global->libc->fns->_libc_getgrent_r(group,
 884                                                               buf,
 885                                                               buflen,
 886                                                               result);
 887 }
 888 #endif /* HAVE_SOLARIS_GETGRENT_R */
 889 #endif /* HAVE_GETGRENT_R */
 890
 891 static void libc_endgrent(void)
 892 {
 893         nwrap_load_lib_function(NWRAP_LIBC, endgrent);
 894
 895         nwrap_main_global->libc->fns->_libc_endgrent();
 896 }
 897
 898 #ifdef HAVE_GETGROUPLIST
 899 static int libc_getgrouplist(const char *user,
 900                              gid_t group,
 901                              gid_t *groups,
 902                              int *ngroups)
 903 {
 904         nwrap_load_lib_function(NWRAP_LIBC, getgrouplist);
 905
 906         return nwrap_main_global->libc->fns->_libc_getgrouplist(user,
 907                                                                 group,
 908                                                                 groups,
 909                                                                 ngroups);
 910 }
 911 #endif
 912
 913 static void libc_sethostent(int stayopen)
 914 {
 915         nwrap_load_lib_function(NWRAP_LIBNSL, sethostent);
 916
 917         nwrap_main_global->libc->fns->_libc_sethostent(stayopen);
 918 }
 919
 920 static struct hostent *libc_gethostent(void)
 921 {
 922         nwrap_load_lib_function(NWRAP_LIBNSL, gethostent);
 923
 924         return nwrap_main_global->libc->fns->_libc_gethostent();
 925 }
 926
 927 static void libc_endhostent(void)
 928 {
 929         nwrap_load_lib_function(NWRAP_LIBNSL, endhostent);
 930
 931         nwrap_main_global->libc->fns->_libc_endhostent();
 932 }
 933
 934 static struct hostent *libc_gethostbyname(const char *name)
 935 {
 936         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname);
 937
 938         return nwrap_main_global->libc->fns->_libc_gethostbyname(name);
 939 }
 940
 941 #ifdef HAVE_GETHOSTBYNAME2 /* GNU extension */
 942 static struct hostent *libc_gethostbyname2(const char *name, int af)
 943 {
 944         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname2);
 945
 946         return nwrap_main_global->libc->fns->_libc_gethostbyname2(name, af);
 947 }
 948 #endif
 949
 950 static struct hostent *libc_gethostbyaddr(const void *addr,
 951                                           socklen_t len,
 952                                           int type)
 953 {
 954         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr);
 955
 956         return nwrap_main_global->libc->fns->_libc_gethostbyaddr(addr,
 957                                                                  len,
 958                                                                  type);
 959 }
 960
 961 static int libc_gethostname(char *name, size_t len)
 962 {
 963         nwrap_load_lib_function(NWRAP_LIBNSL, gethostname);
 964
 965         return nwrap_main_global->libc->fns->_libc_gethostname(name, len);
 966 }
 967
 968 #ifdef HAVE_GETHOSTBYNAME_R
 969 static int libc_gethostbyname_r(const char *name,
 970                                 struct hostent *ret,
 971                                 char *buf,
 972                                 size_t buflen,
 973                                 struct hostent **result,
 974                                 int *h_errnop)
 975 {
 976         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyname_r);
 977
 978         return nwrap_main_global->libc->fns->_libc_gethostbyname_r(name,
 979                                                                    ret,
 980                                                                    buf,
 981                                                                    buflen,
 982                                                                    result,
 983                                                                    h_errnop);
 984 }
 985 #endif
 986
 987 #ifdef HAVE_GETHOSTBYADDR_R
 988 static int libc_gethostbyaddr_r(const void *addr,
 989                                 socklen_t len,
 990                                 int type,
 991                                 struct hostent *ret,
 992                                 char *buf,
 993                                 size_t buflen,
 994                                 struct hostent **result,
 995                                 int *h_errnop)
 996 {
 997         nwrap_load_lib_function(NWRAP_LIBNSL, gethostbyaddr_r);
 998
 999         return nwrap_main_global->libc->fns->_libc_gethostbyaddr_r(addr,
1000                                                                    len,
1001                                                                    type,
1002                                                                    ret,
1003                                                                    buf,
1004                                                                    buflen,
1005                                                                    result,
1006                                                                    h_errnop);
1007 }
1008 #endif
1009
1010 static int libc_getaddrinfo(const char *node,
1011                             const char *service,
1012                             const struct addrinfo *hints,
1013                             struct addrinfo **res)
1014 {
1015         nwrap_load_lib_function(NWRAP_LIBSOCKET, getaddrinfo);
1016
1017         return nwrap_main_global->libc->fns->_libc_getaddrinfo(node,
1018                                                                service,
1019                                                                hints,
1020                                                                res);
1021 }
1022
1023 static int libc_getnameinfo(const struct sockaddr *sa,
1024                             socklen_t salen,
1025                             char *host,
1026                             size_t hostlen,
1027                             char *serv,
1028                             size_t servlen,
1029                             int flags)
1030 {
1031         nwrap_load_lib_function(NWRAP_LIBSOCKET, getnameinfo);
1032
1033         return nwrap_main_global->libc->fns->_libc_getnameinfo(sa,
1034                                                                salen,
1035                                                                host,
1036                                                                hostlen,
1037                                                                serv,
1038                                                                servlen,
1039                                                                flags);
1040 }
1041
1042 /*********************************************************
1043  * NWRAP NSS MODULE LOADER FUNCTIONS
1044  *********************************************************/
1045
1046 static void *nwrap_load_module_fn(struct nwrap_backend *b,
1047                                   const char *fn_name)
1048 {
1049         void *res;
1050         char *s;
1051
1052         if (!b->so_handle) {
1053                 NWRAP_LOG(NWRAP_LOG_ERROR, "No handle");
1054                 return NULL;
1055         }
1056
1057         if (asprintf(&s, "_nss_%s_%s", b->name, fn_name) == -1) {
1058                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1059                 return NULL;
1060         }
1061
1062         res = dlsym(b->so_handle, s);
1063         if (!res) {
1064                 NWRAP_LOG(NWRAP_LOG_ERROR,
1065                           "Cannot find function %s in %s",
1066                           s, b->so_path);
1067         }
1068         free(s);
1069         s = NULL;
1070         return res;
1071 }
1072
1073 static struct nwrap_module_nss_fns *nwrap_load_module_fns(struct nwrap_backend *b)
1074 {
1075         struct nwrap_module_nss_fns *fns;
1076
1077         if (!b->so_handle) {
1078                 return NULL;
1079         }
1080
1081         fns = (struct nwrap_module_nss_fns *)malloc(sizeof(struct nwrap_module_nss_fns));
1082         if (!fns) {
1083                 return NULL;
1084         }
1085
1086         *(void **)(&fns->_nss_getpwnam_r) =
1087                 nwrap_load_module_fn(b, "getpwnam_r");
1088         *(void **)(&fns->_nss_getpwuid_r) =
1089                 nwrap_load_module_fn(b, "getpwuid_r");
1090         *(void **)(&fns->_nss_setpwent) =
1091                 nwrap_load_module_fn(b, "setpwent");
1092         *(void **)(&fns->_nss_getpwent_r) =
1093                 nwrap_load_module_fn(b, "getpwent_r");
1094         *(void **)(&fns->_nss_endpwent) =
1095                 nwrap_load_module_fn(b, "endpwent");
1096         *(void **)(&fns->_nss_initgroups) =
1097                 nwrap_load_module_fn(b, "initgroups_dyn");
1098         *(void **)(&fns->_nss_getgrnam_r) =
1099                 nwrap_load_module_fn(b, "getgrnam_r");
1100         *(void **)(&fns->_nss_getgrgid_r)=
1101                 nwrap_load_module_fn(b, "getgrgid_r");
1102         *(void **)(&fns->_nss_setgrent) =
1103                 nwrap_load_module_fn(b, "setgrent");
1104         *(void **)(&fns->_nss_getgrent_r) =
1105                 nwrap_load_module_fn(b, "getgrent_r");
1106         *(void **)(&fns->_nss_endgrent) =
1107                 nwrap_load_module_fn(b, "endgrent");
1108
1109         return fns;
1110 }
1111
1112 static void *nwrap_load_module(const char *so_path)
1113 {
1114         void *h;
1115
1116         if (!so_path || !strlen(so_path)) {
1117                 return NULL;
1118         }
1119
1120         h = dlopen(so_path, RTLD_LAZY);
1121         if (!h) {
1122                 NWRAP_LOG(NWRAP_LOG_ERROR,
1123                           "Cannot open shared library %s",
1124                           so_path);
1125                 return NULL;
1126         }
1127
1128         return h;
1129 }
1130
1131 static bool nwrap_module_init(const char *name,
1132                               struct nwrap_ops *ops,
1133                               const char *so_path,
1134                               int *num_backends,
1135                               struct nwrap_backend **backends)
1136 {
1137         struct nwrap_backend *b;
1138
1139         *backends = (struct nwrap_backend *)realloc(*backends,
1140                 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
1141         if (!*backends) {
1142                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1143                 return false;
1144         }
1145
1146         b = &((*backends)[*num_backends]);
1147
1148         b->name = name;
1149         b->ops = ops;
1150         b->so_path = so_path;
1151
1152         if (so_path != NULL) {
1153                 b->so_handle = nwrap_load_module(so_path);
1154                 b->fns = nwrap_load_module_fns(b);
1155                 if (b->fns == NULL) {
1156                         return false;
1157                 }
1158         } else {
1159                 b->so_handle = NULL;
1160                 b->fns = NULL;
1161         }
1162
1163         (*num_backends)++;
1164
1165         return true;
1166 }
1167
1168 static void nwrap_libc_init(struct nwrap_main *r)
1169 {
1170         r->libc = malloc(sizeof(struct nwrap_libc));
1171         if (r->libc == NULL) {
1172                 printf("Failed to allocate memory for libc");
1173                 exit(-1);
1174         }
1175         ZERO_STRUCTP(r->libc);
1176
1177         r->libc->fns = malloc(sizeof(struct nwrap_libc_fns));
1178         if (r->libc->fns == NULL) {
1179                 printf("Failed to allocate memory for libc functions");
1180                 exit(-1);
1181         }
1182         ZERO_STRUCTP(r->libc->fns);
1183 }
1184
1185 static void nwrap_backend_init(struct nwrap_main *r)
1186 {
1187         const char *module_so_path = getenv("NSS_WRAPPER_MODULE_SO_PATH");
1188         const char *module_fn_name = getenv("NSS_WRAPPER_MODULE_FN_PREFIX");
1189
1190         r->num_backends = 0;
1191         r->backends = NULL;
1192
1193         if (!nwrap_module_init("files", &nwrap_files_ops, NULL,
1194                                &r->num_backends,
1195                                &r->backends)) {
1196                 NWRAP_LOG(NWRAP_LOG_ERROR,
1197                           "Failed to initialize 'files' backend");
1198                 return;
1199         }
1200
1201         if (module_so_path != NULL &&
1202             module_so_path[0] != '\0' &&
1203             module_fn_name != NULL &&
1204             module_fn_name[0] != '\0') {
1205                 if (!nwrap_module_init(module_fn_name,
1206                                        &nwrap_module_ops,
1207                                        module_so_path,
1208                                        &r->num_backends,
1209                                        &r->backends)) {
1210                         NWRAP_LOG(NWRAP_LOG_ERROR,
1211                                   "Failed to initialize '%s' backend",
1212                                   module_fn_name);
1213                         return;
1214                 }
1215         }
1216 }
1217
1218 static void nwrap_init(void)
1219 {
1220         static bool initialized;
1221
1222         if (initialized) return;
1223         initialized = true;
1224
1225         nwrap_main_global = &__nwrap_main_global;
1226
1227         nwrap_libc_init(nwrap_main_global);
1228
1229         nwrap_backend_init(nwrap_main_global);
1230
1231         nwrap_pw_global.cache = &__nwrap_cache_pw;
1232
1233         nwrap_pw_global.cache->path = getenv("NSS_WRAPPER_PASSWD");
1234         nwrap_pw_global.cache->fd = -1;
1235         nwrap_pw_global.cache->private_data = &nwrap_pw_global;
1236         nwrap_pw_global.cache->parse_line = nwrap_pw_parse_line;
1237         nwrap_pw_global.cache->unload = nwrap_pw_unload;
1238
1239         nwrap_gr_global.cache = &__nwrap_cache_gr;
1240
1241         nwrap_gr_global.cache->path = getenv("NSS_WRAPPER_GROUP");
1242         nwrap_gr_global.cache->fd = -1;
1243         nwrap_gr_global.cache->private_data = &nwrap_gr_global;
1244         nwrap_gr_global.cache->parse_line = nwrap_gr_parse_line;
1245         nwrap_gr_global.cache->unload = nwrap_gr_unload;
1246
1247         nwrap_he_global.cache = &__nwrap_cache_he;
1248
1249         nwrap_he_global.cache->path = getenv("NSS_WRAPPER_HOSTS");
1250         nwrap_he_global.cache->fd = -1;
1251         nwrap_he_global.cache->private_data = &nwrap_he_global;
1252         nwrap_he_global.cache->parse_line = nwrap_he_parse_line;
1253         nwrap_he_global.cache->unload = nwrap_he_unload;
1254 }
1255
1256 bool nss_wrapper_enabled(void)
1257 {
1258         nwrap_init();
1259
1260         if (nwrap_pw_global.cache->path == NULL ||
1261             nwrap_pw_global.cache->path[0] == '\0') {
1262                 return false;
1263         }
1264         if (nwrap_gr_global.cache->path == NULL ||
1265             nwrap_gr_global.cache->path[0] == '\0') {
1266                 return false;
1267         }
1268
1269         return true;
1270 }
1271
1272 bool nss_wrapper_hosts_enabled(void)
1273 {
1274         nwrap_init();
1275
1276         if (nwrap_he_global.cache->path == NULL ||
1277             nwrap_he_global.cache->path[0] == '\0') {
1278                 return false;
1279         }
1280
1281         return true;
1282 }
1283
1284 static bool nwrap_hostname_enabled(void)
1285 {
1286         nwrap_init();
1287
1288         if (getenv("NSS_WRAPPER_HOSTNAME") == NULL) {
1289                 return false;
1290         }
1291
1292         return true;
1293 }
1294
1295 static bool nwrap_parse_file(struct nwrap_cache *nwrap)
1296 {
1297         int ret;
1298         uint8_t *buf = NULL;
1299         char *nline;
1300
1301         if (nwrap->st.st_size == 0) {
1302                 NWRAP_LOG(NWRAP_LOG_DEBUG, "size == 0");
1303                 goto done;
1304         }
1305
1306         if (nwrap->st.st_size > INT32_MAX) {
1307                 NWRAP_LOG(NWRAP_LOG_ERROR,
1308                           "Size[%u] larger than INT32_MAX",
1309                           (unsigned)nwrap->st.st_size);
1310                 goto failed;
1311         }
1312
1313         ret = lseek(nwrap->fd, 0, SEEK_SET);
1314         if (ret != 0) {
1315                 NWRAP_LOG(NWRAP_LOG_ERROR, "lseek - rc=%d\n", ret);
1316                 goto failed;
1317         }
1318
1319         buf = (uint8_t *)malloc(nwrap->st.st_size + 1);
1320         if (!buf) {
1321                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1322                 goto failed;
1323         }
1324
1325         ret = read(nwrap->fd, buf, nwrap->st.st_size);
1326         if (ret != nwrap->st.st_size) {
1327                 NWRAP_LOG(NWRAP_LOG_ERROR,
1328                           "read(%u) rc=%d\n",
1329                           (unsigned)nwrap->st.st_size, ret);
1330                 goto failed;
1331         }
1332
1333         buf[nwrap->st.st_size] = '\0';
1334
1335         nline = (char *)buf;
1336         while (nline != NULL && nline[0] != '\0') {
1337                 char *line;
1338                 char *e;
1339                 bool ok;
1340
1341                 line = nline;
1342                 nline = NULL;
1343
1344                 e = strchr(line, '\n');
1345                 if (e) {
1346                         e[0] = '\0';
1347                         e++;
1348                         if (e[0] == '\r') {
1349                                 e[0] = '\0';
1350                                 e++;
1351                         }
1352                         nline = e;
1353                 }
1354
1355                 if (strlen(line) == 0) {
1356                         continue;
1357                 }
1358
1359                 ok = nwrap->parse_line(nwrap, line);
1360                 if (!ok) {
1361                         goto failed;
1362                 }
1363         }
1364
1365 done:
1366         nwrap->buf = buf;
1367         return true;
1368
1369 failed:
1370         if (buf) free(buf);
1371         return false;
1372 }
1373
1374 static void nwrap_files_cache_unload(struct nwrap_cache *nwrap)
1375 {
1376         nwrap->unload(nwrap);
1377
1378         if (nwrap->buf) free(nwrap->buf);
1379
1380         nwrap->buf = NULL;
1381 }
1382
1383 static void nwrap_files_cache_reload(struct nwrap_cache *nwrap)
1384 {
1385         struct stat st;
1386         int ret;
1387         bool ok;
1388         bool retried = false;
1389
1390 reopen:
1391         if (nwrap->fd < 0) {
1392                 nwrap->fd = open(nwrap->path, O_RDONLY);
1393                 if (nwrap->fd < 0) {
1394                         NWRAP_LOG(NWRAP_LOG_ERROR,
1395                                   "Unable to open '%s' readonly %d:%s",
1396                                   nwrap->path, nwrap->fd,
1397                                   strerror(errno));
1398                         return;
1399                 }
1400                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Open '%s'", nwrap->path);
1401         }
1402
1403         ret = fstat(nwrap->fd, &st);
1404         if (ret != 0) {
1405                 NWRAP_LOG(NWRAP_LOG_ERROR,
1406                           "fstat(%s) - %d:%s",
1407                           nwrap->path,
1408                           ret,
1409                           strerror(errno));
1410                 return;
1411         }
1412
1413         if (retried == false && st.st_nlink == 0) {
1414                 /* maybe someone has replaced the file... */
1415                 NWRAP_LOG(NWRAP_LOG_TRACE,
1416                           "st_nlink == 0, reopen %s",
1417                           nwrap->path);
1418                 retried = true;
1419                 memset(&nwrap->st, 0, sizeof(nwrap->st));
1420                 close(nwrap->fd);
1421                 nwrap->fd = -1;
1422                 goto reopen;
1423         }
1424
1425         if (st.st_mtime == nwrap->st.st_mtime) {
1426                 NWRAP_LOG(NWRAP_LOG_TRACE,
1427                           "st_mtime[%u] hasn't changed, skip reload",
1428                           (unsigned)st.st_mtime);
1429                 return;
1430         }
1431
1432         NWRAP_LOG(NWRAP_LOG_TRACE,
1433                   "st_mtime has changed [%u] => [%u], start reload",
1434                   (unsigned)st.st_mtime,
1435                   (unsigned)nwrap->st.st_mtime);
1436
1437         nwrap->st = st;
1438
1439         nwrap_files_cache_unload(nwrap);
1440
1441         ok = nwrap_parse_file(nwrap);
1442         if (!ok) {
1443                 NWRAP_LOG(NWRAP_LOG_ERROR, "Failed to reload %s", nwrap->path);
1444                 nwrap_files_cache_unload(nwrap);
1445         }
1446
1447         NWRAP_LOG(NWRAP_LOG_TRACE, "Reloaded %s", nwrap->path);
1448 }
1449
1450 /*
1451  * the caller has to call nwrap_unload() on failure
1452  */
1453 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line)
1454 {
1455         struct nwrap_pw *nwrap_pw;
1456         char *c;
1457         char *p;
1458         char *e;
1459         struct passwd *pw;
1460         size_t list_size;
1461
1462         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
1463
1464         list_size = sizeof(*nwrap_pw->list) * (nwrap_pw->num+1);
1465         pw = (struct passwd *)realloc(nwrap_pw->list, list_size);
1466         if (!pw) {
1467                 NWRAP_LOG(NWRAP_LOG_ERROR,
1468                           "realloc(%u) failed",
1469                           (unsigned)list_size);
1470                 return false;
1471         }
1472         nwrap_pw->list = pw;
1473
1474         pw = &nwrap_pw->list[nwrap_pw->num];
1475
1476         c = line;
1477
1478         /* name */
1479         p = strchr(c, ':');
1480         if (!p) {
1481                 NWRAP_LOG(NWRAP_LOG_ERROR,
1482                           "Invalid line[%s]: '%s'",
1483                           line,
1484                           c);
1485                 return false;
1486         }
1487         *p = '\0';
1488         p++;
1489         pw->pw_name = c;
1490         c = p;
1491
1492         NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]\n", pw->pw_name);
1493
1494         /* password */
1495         p = strchr(c, ':');
1496         if (!p) {
1497                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1498                 return false;
1499         }
1500         *p = '\0';
1501         p++;
1502         pw->pw_passwd = c;
1503         c = p;
1504
1505         NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]\n", pw->pw_passwd);
1506
1507         /* uid */
1508         p = strchr(c, ':');
1509         if (!p) {
1510                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1511                 return false;
1512         }
1513         *p = '\0';
1514         p++;
1515         e = NULL;
1516         pw->pw_uid = (uid_t)strtoul(c, &e, 10);
1517         if (c == e) {
1518                 NWRAP_LOG(NWRAP_LOG_ERROR,
1519                           "Invalid line[%s]: '%s' - %s",
1520                           line, c, strerror(errno));
1521                 return false;
1522         }
1523         if (e == NULL) {
1524                 NWRAP_LOG(NWRAP_LOG_ERROR,
1525                           "Invalid line[%s]: '%s' - %s",
1526                           line, c, strerror(errno));
1527                 return false;
1528         }
1529         if (e[0] != '\0') {
1530                 NWRAP_LOG(NWRAP_LOG_ERROR,
1531                           "Invalid line[%s]: '%s' - %s",
1532                           line, c, strerror(errno));
1533                 return false;
1534         }
1535         c = p;
1536
1537         NWRAP_LOG(NWRAP_LOG_TRACE, "uid[%u]", pw->pw_uid);
1538
1539         /* gid */
1540         p = strchr(c, ':');
1541         if (!p) {
1542                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1543                 return false;
1544         }
1545         *p = '\0';
1546         p++;
1547         e = NULL;
1548         pw->pw_gid = (gid_t)strtoul(c, &e, 10);
1549         if (c == e) {
1550                 NWRAP_LOG(NWRAP_LOG_ERROR,
1551                           "Invalid line[%s]: '%s' - %s",
1552                           line, c, strerror(errno));
1553                 return false;
1554         }
1555         if (e == NULL) {
1556                 NWRAP_LOG(NWRAP_LOG_ERROR,
1557                           "Invalid line[%s]: '%s' - %s",
1558                           line, c, strerror(errno));
1559                 return false;
1560         }
1561         if (e[0] != '\0') {
1562                 NWRAP_LOG(NWRAP_LOG_ERROR,
1563                           "Invalid line[%s]: '%s' - %s",
1564                           line, c, strerror(errno));
1565                 return false;
1566         }
1567         c = p;
1568
1569         NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]\n", pw->pw_gid);
1570
1571         /* gecos */
1572         p = strchr(c, ':');
1573         if (!p) {
1574                 NWRAP_LOG(NWRAP_LOG_ERROR, "invalid line[%s]: '%s'", line, c);
1575                 return false;
1576         }
1577         *p = '\0';
1578         p++;
1579         pw->pw_gecos = c;
1580         c = p;
1581
1582         NWRAP_LOG(NWRAP_LOG_TRACE, "gecos[%s]", pw->pw_gecos);
1583
1584         /* dir */
1585         p = strchr(c, ':');
1586         if (!p) {
1587                 NWRAP_LOG(NWRAP_LOG_ERROR, "'%s'", c);
1588                 return false;
1589         }
1590         *p = '\0';
1591         p++;
1592         pw->pw_dir = c;
1593         c = p;
1594
1595         NWRAP_LOG(NWRAP_LOG_TRACE, "dir[%s]", pw->pw_dir);
1596
1597         /* shell */
1598         pw->pw_shell = c;
1599         NWRAP_LOG(NWRAP_LOG_TRACE, "shell[%s]", pw->pw_shell);
1600
1601         NWRAP_LOG(NWRAP_LOG_DEBUG,
1602                   "Added user[%s:%s:%u:%u:%s:%s:%s]",
1603                   pw->pw_name, pw->pw_passwd,
1604                   pw->pw_uid, pw->pw_gid,
1605                   pw->pw_gecos, pw->pw_dir, pw->pw_shell);
1606
1607         nwrap_pw->num++;
1608         return true;
1609 }
1610
1611 static void nwrap_pw_unload(struct nwrap_cache *nwrap)
1612 {
1613         struct nwrap_pw *nwrap_pw;
1614         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
1615
1616         if (nwrap_pw->list) free(nwrap_pw->list);
1617
1618         nwrap_pw->list = NULL;
1619         nwrap_pw->num = 0;
1620         nwrap_pw->idx = 0;
1621 }
1622
1623 static int nwrap_pw_copy_r(const struct passwd *src, struct passwd *dst,
1624                            char *buf, size_t buflen, struct passwd **dstp)
1625 {
1626         char *first;
1627         char *last;
1628         off_t ofs;
1629
1630         first = src->pw_name;
1631
1632         last = src->pw_shell;
1633         while (*last) last++;
1634
1635         ofs = PTR_DIFF(last + 1, first);
1636
1637         if (ofs > (off_t) buflen) {
1638                 return ERANGE;
1639         }
1640
1641         memcpy(buf, first, ofs);
1642
1643         ofs = PTR_DIFF(src->pw_name, first);
1644         dst->pw_name = buf + ofs;
1645         ofs = PTR_DIFF(src->pw_passwd, first);
1646         dst->pw_passwd = buf + ofs;
1647         dst->pw_uid = src->pw_uid;
1648         dst->pw_gid = src->pw_gid;
1649         ofs = PTR_DIFF(src->pw_gecos, first);
1650         dst->pw_gecos = buf + ofs;
1651         ofs = PTR_DIFF(src->pw_dir, first);
1652         dst->pw_dir = buf + ofs;
1653         ofs = PTR_DIFF(src->pw_shell, first);
1654         dst->pw_shell = buf + ofs;
1655
1656         if (dstp) {
1657                 *dstp = dst;
1658         }
1659
1660         return 0;
1661 }
1662
1663 /*
1664  * the caller has to call nwrap_unload() on failure
1665  */
1666 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line)
1667 {
1668         struct nwrap_gr *nwrap_gr;
1669         char *c;
1670         char *p;
1671         char *e;
1672         struct group *gr;
1673         size_t list_size;
1674         unsigned nummem;
1675
1676         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
1677
1678         list_size = sizeof(*nwrap_gr->list) * (nwrap_gr->num+1);
1679         gr = (struct group *)realloc(nwrap_gr->list, list_size);
1680         if (!gr) {
1681                 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc failed");
1682                 return false;
1683         }
1684         nwrap_gr->list = gr;
1685
1686         gr = &nwrap_gr->list[nwrap_gr->num];
1687
1688         c = line;
1689
1690         /* name */
1691         p = strchr(c, ':');
1692         if (!p) {
1693                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1694                 return false;
1695         }
1696         *p = '\0';
1697         p++;
1698         gr->gr_name = c;
1699         c = p;
1700
1701         NWRAP_LOG(NWRAP_LOG_TRACE, "name[%s]", gr->gr_name);
1702
1703         /* password */
1704         p = strchr(c, ':');
1705         if (!p) {
1706                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1707                 return false;
1708         }
1709         *p = '\0';
1710         p++;
1711         gr->gr_passwd = c;
1712         c = p;
1713
1714         NWRAP_LOG(NWRAP_LOG_TRACE, "password[%s]", gr->gr_passwd);
1715
1716         /* gid */
1717         p = strchr(c, ':');
1718         if (!p) {
1719                 NWRAP_LOG(NWRAP_LOG_ERROR, "Invalid line[%s]: '%s'", line, c);
1720                 return false;
1721         }
1722         *p = '\0';
1723         p++;
1724         e = NULL;
1725         gr->gr_gid = (gid_t)strtoul(c, &e, 10);
1726         if (c == e) {
1727                 NWRAP_LOG(NWRAP_LOG_ERROR,
1728                           "Invalid line[%s]: '%s' - %s",
1729                           line, c, strerror(errno));
1730                 return false;
1731         }
1732         if (e == NULL) {
1733                 NWRAP_LOG(NWRAP_LOG_ERROR,
1734                           "Invalid line[%s]: '%s' - %s",
1735                           line, c, strerror(errno));
1736                 return false;
1737         }
1738         if (e[0] != '\0') {
1739                 NWRAP_LOG(NWRAP_LOG_ERROR,
1740                           "Invalid line[%s]: '%s' - %s",
1741                           line, c, strerror(errno));
1742                 return false;
1743         }
1744         c = p;
1745
1746         NWRAP_LOG(NWRAP_LOG_TRACE, "gid[%u]", gr->gr_gid);
1747
1748         /* members */
1749         gr->gr_mem = (char **)malloc(sizeof(char *));
1750         if (!gr->gr_mem) {
1751                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
1752                 return false;
1753         }
1754         gr->gr_mem[0] = NULL;
1755
1756         for(nummem=0; p; nummem++) {
1757                 char **m;
1758                 size_t m_size;
1759                 c = p;
1760                 p = strchr(c, ',');
1761                 if (p) {
1762                         *p = '\0';
1763                         p++;
1764                 }
1765
1766                 if (strlen(c) == 0) {
1767                         break;
1768                 }
1769
1770                 m_size = sizeof(char *) * (nummem+2);
1771                 m = (char **)realloc(gr->gr_mem, m_size);
1772                 if (!m) {
1773                         NWRAP_LOG(NWRAP_LOG_ERROR,
1774                                   "realloc(%zd) failed",
1775                                   m_size);
1776                         return false;
1777                 }
1778                 gr->gr_mem = m;
1779                 gr->gr_mem[nummem] = c;
1780                 gr->gr_mem[nummem+1] = NULL;
1781
1782                 NWRAP_LOG(NWRAP_LOG_TRACE,
1783                           "member[%u]: '%s'",
1784                           nummem, gr->gr_mem[nummem]);
1785         }
1786
1787         NWRAP_LOG(NWRAP_LOG_DEBUG,
1788                   "Added group[%s:%s:%u:] with %u members",
1789                   gr->gr_name, gr->gr_passwd, gr->gr_gid, nummem);
1790
1791         nwrap_gr->num++;
1792         return true;
1793 }
1794
1795 static void nwrap_gr_unload(struct nwrap_cache *nwrap)
1796 {
1797         int i;
1798         struct nwrap_gr *nwrap_gr;
1799         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
1800
1801         if (nwrap_gr->list) {
1802                 for (i=0; i < nwrap_gr->num; i++) {
1803                         if (nwrap_gr->list[i].gr_mem) {
1804                                 free(nwrap_gr->list[i].gr_mem);
1805                         }
1806                 }
1807                 free(nwrap_gr->list);
1808         }
1809
1810         nwrap_gr->list = NULL;
1811         nwrap_gr->num = 0;
1812         nwrap_gr->idx = 0;
1813 }
1814
1815 static int nwrap_gr_copy_r(const struct group *src, struct group *dst,
1816                            char *buf, size_t buflen, struct group **dstp)
1817 {
1818         char *first;
1819         char **lastm;
1820         char *last = NULL;
1821         off_t ofsb;
1822         off_t ofsm;
1823         off_t ofs;
1824         unsigned i;
1825
1826         first = src->gr_name;
1827
1828         lastm = src->gr_mem;
1829         while (*lastm) {
1830                 last = *lastm;
1831                 lastm++;
1832         }
1833
1834         if (last == NULL) {
1835                 last = src->gr_passwd;
1836         }
1837         while (*last) last++;
1838
1839         ofsb = PTR_DIFF(last + 1, first);
1840         ofsm = PTR_DIFF(lastm + 1, src->gr_mem);
1841
1842         if ((ofsb + ofsm) > (off_t) buflen) {
1843                 return ERANGE;
1844         }
1845
1846         memcpy(buf, first, ofsb);
1847         memcpy(buf + ofsb, src->gr_mem, ofsm);
1848
1849         ofs = PTR_DIFF(src->gr_name, first);
1850         dst->gr_name = buf + ofs;
1851         ofs = PTR_DIFF(src->gr_passwd, first);
1852         dst->gr_passwd = buf + ofs;
1853         dst->gr_gid = src->gr_gid;
1854
1855         dst->gr_mem = (char **)(buf + ofsb);
1856         for (i=0; src->gr_mem[i]; i++) {
1857                 ofs = PTR_DIFF(src->gr_mem[i], first);
1858                 dst->gr_mem[i] = buf + ofs;
1859         }
1860
1861         if (dstp) {
1862                 *dstp = dst;
1863         }
1864
1865         return 0;
1866 }
1867
1868 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line)
1869 {
1870         struct nwrap_he *nwrap_he = (struct nwrap_he *)nwrap->private_data;
1871         struct nwrap_entdata *ed;
1872         size_t list_size;
1873         bool do_aliases = true;
1874         int aliases_count = 0;
1875         char *p;
1876         char *i;
1877         char *n;
1878
1879         list_size = sizeof(struct nwrap_entdata) * (nwrap_he->num + 1);
1880
1881         ed = (struct nwrap_entdata *)realloc(nwrap_he->list, list_size);
1882         if (ed == NULL) {
1883                 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc[%zd] failed", list_size);
1884                 return false;
1885         }
1886         nwrap_he->list = ed;
1887
1888         /* set it to the last element */
1889         ed = &(nwrap_he->list[nwrap_he->num]);
1890
1891         ed->addr = malloc(sizeof(struct nwrap_addrdata));
1892         if (ed->addr == NULL) {
1893                 NWRAP_LOG(NWRAP_LOG_ERROR, "realloc[%zd] failed", list_size);
1894                 return false;
1895         }
1896
1897         i = line;
1898
1899         /*
1900          * IP
1901          */
1902
1903         /* Walk to first char */
1904         for (p = i; *p != '.' && *p != ':' && !isxdigit((int) *p); p++) {
1905                 if (*p == '\0') {
1906                         NWRAP_LOG(NWRAP_LOG_ERROR,
1907                                   "Invalid line[%s]: '%s'",
1908                                   line, i);
1909                         return false;
1910                 }
1911         }
1912
1913         for (i = p; !isspace((int)*p); p++) {
1914                 if (*p == '\0') {
1915                         NWRAP_LOG(NWRAP_LOG_ERROR,
1916                                   "Invalid line[%s]: '%s'",
1917                                   line, i);
1918                         return false;
1919                 }
1920         }
1921
1922         *p = '\0';
1923
1924         if (inet_pton(AF_INET, i, ed->addr->host_addr)) {
1925                 ed->ht.h_addrtype = AF_INET;
1926                 ed->ht.h_length = 4;
1927 #ifdef HAVE_IPV6
1928         } else if (inet_pton(AF_INET6, i, ed->addr->host_addr)) {
1929                 ed->ht.h_addrtype = AF_INET6;
1930                 ed->ht.h_length = 16;
1931 #endif
1932         } else {
1933                 NWRAP_LOG(NWRAP_LOG_ERROR,
1934                           "Invalid line[%s]: '%s'",
1935                           line, i);
1936
1937                 return false;
1938         }
1939
1940         ed->addr->h_addr_ptrs[0] = (char *)ed->addr->host_addr;
1941         ed->addr->h_addr_ptrs[1] = NULL;
1942
1943         ed->ht.h_addr_list = ed->addr->h_addr_ptrs;
1944
1945         p++;
1946
1947         /*
1948          * FQDN
1949          */
1950
1951         /* Walk to first char */
1952         for (n = p; *p != '_' && !isalnum((int) *p); p++) {
1953                 if (*p == '\0') {
1954                         NWRAP_LOG(NWRAP_LOG_ERROR,
1955                                   "Invalid line[%s]: '%s'",
1956                                   line, n);
1957
1958                         return false;
1959                 }
1960         }
1961
1962         for (n = p; !isspace((int)*p); p++) {
1963                 if (*p == '\0') {
1964                         do_aliases = false;
1965                         break;
1966                 }
1967         }
1968
1969         *p = '\0';
1970
1971         ed->ht.h_name = n;
1972
1973         /* glib's getent always dereferences he->h_aliases */
1974         ed->ht.h_aliases = malloc(sizeof(char *));
1975         if (ed->ht.h_aliases == NULL) {
1976                 return false;
1977         }
1978         ed->ht.h_aliases[0] = NULL;
1979
1980         /*
1981          * Aliases
1982          */
1983         while (do_aliases) {
1984                 char **aliases;
1985                 char *a;
1986
1987                 p++;
1988
1989                 /* Walk to first char */
1990                 for (a = p; *p != '_' && !isalnum((int) *p); p++) {
1991                         if (*p == '\0') {
1992                                 do_aliases = false;
1993                                 break;
1994                         }
1995                 }
1996                 /* Only trailing spaces are left */
1997                 if (!do_aliases) {
1998                         break;
1999                 }
2000
2001                 for (a = p; !isspace((int)*p); p++) {
2002                         if (*p == '\0') {
2003                                 do_aliases = false;
2004                                 break;
2005                         }
2006                 }
2007
2008                 *p = '\0';
2009
2010                 aliases = realloc(ed->ht.h_aliases, sizeof(char *) * (aliases_count + 2));
2011                 if (aliases == NULL) {
2012                         return false;
2013                 }
2014                 ed->ht.h_aliases = aliases;
2015
2016                 aliases[aliases_count] = a;
2017                 aliases[aliases_count + 1] = NULL;
2018
2019                 aliases_count++;
2020         }
2021
2022         nwrap_he->num++;
2023         return true;
2024 }
2025
2026 static void nwrap_he_unload(struct nwrap_cache *nwrap)
2027 {
2028         struct nwrap_he *nwrap_he =
2029                 (struct nwrap_he *)nwrap->private_data;
2030         int i;
2031
2032         if (nwrap_he->list != NULL) {
2033                 for (i = 0; i < nwrap_he->num; i++) {
2034                         if (nwrap_he->list[i].ht.h_aliases != NULL) {
2035                                 free(nwrap_he->list[i].ht.h_aliases);
2036                         }
2037                         if (nwrap_he->list[i].addr != NULL) {
2038                                 free(nwrap_he->list[i].addr);
2039                         }
2040                 }
2041                 free(nwrap_he->list);
2042         }
2043
2044         nwrap_he->list = NULL;
2045         nwrap_he->num = 0;
2046         nwrap_he->idx = 0;
2047 }
2048
2049
2050 /* user functions */
2051 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
2052                                            const char *name)
2053 {
2054         int i;
2055
2056         (void) b; /* unused */
2057
2058         NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
2059
2060         nwrap_files_cache_reload(nwrap_pw_global.cache);
2061
2062         for (i=0; i<nwrap_pw_global.num; i++) {
2063                 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
2064                         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
2065                         return &nwrap_pw_global.list[i];
2066                 }
2067                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2068                           "user[%s] does not match [%s]",
2069                           name,
2070                           nwrap_pw_global.list[i].pw_name);
2071         }
2072
2073         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
2074
2075         errno = ENOENT;
2076         return NULL;
2077 }
2078
2079 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
2080                                   const char *name, struct passwd *pwdst,
2081                                   char *buf, size_t buflen, struct passwd **pwdstp)
2082 {
2083         struct passwd *pw;
2084
2085         pw = nwrap_files_getpwnam(b, name);
2086         if (!pw) {
2087                 if (errno == 0) {
2088                         return ENOENT;
2089                 }
2090                 return errno;
2091         }
2092
2093         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2094 }
2095
2096 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
2097                                            uid_t uid)
2098 {
2099         int i;
2100
2101         (void) b; /* unused */
2102
2103         nwrap_files_cache_reload(nwrap_pw_global.cache);
2104
2105         for (i=0; i<nwrap_pw_global.num; i++) {
2106                 if (nwrap_pw_global.list[i].pw_uid == uid) {
2107                         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] found", uid);
2108                         return &nwrap_pw_global.list[i];
2109                 }
2110                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2111                           "uid[%u] does not match [%u]",
2112                           uid,
2113                           nwrap_pw_global.list[i].pw_uid);
2114         }
2115
2116         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] not found\n", uid);
2117
2118         errno = ENOENT;
2119         return NULL;
2120 }
2121
2122 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
2123                                   uid_t uid, struct passwd *pwdst,
2124                                   char *buf, size_t buflen, struct passwd **pwdstp)
2125 {
2126         struct passwd *pw;
2127
2128         pw = nwrap_files_getpwuid(b, uid);
2129         if (!pw) {
2130                 if (errno == 0) {
2131                         return ENOENT;
2132                 }
2133                 return errno;
2134         }
2135
2136         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2137 }
2138
2139 /* user enum functions */
2140 static void nwrap_files_setpwent(struct nwrap_backend *b)
2141 {
2142         (void) b; /* unused */
2143
2144         nwrap_pw_global.idx = 0;
2145 }
2146
2147 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
2148 {
2149         struct passwd *pw;
2150
2151         (void) b; /* unused */
2152
2153         if (nwrap_pw_global.idx == 0) {
2154                 nwrap_files_cache_reload(nwrap_pw_global.cache);
2155         }
2156
2157         if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
2158                 errno = ENOENT;
2159                 return NULL;
2160         }
2161
2162         pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
2163
2164         NWRAP_LOG(NWRAP_LOG_DEBUG,
2165                   "return user[%s] uid[%u]",
2166                   pw->pw_name, pw->pw_uid);
2167
2168         return pw;
2169 }
2170
2171 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
2172                                   struct passwd *pwdst, char *buf,
2173                                   size_t buflen, struct passwd **pwdstp)
2174 {
2175         struct passwd *pw;
2176
2177         pw = nwrap_files_getpwent(b);
2178         if (!pw) {
2179                 if (errno == 0) {
2180                         return ENOENT;
2181                 }
2182                 return errno;
2183         }
2184
2185         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2186 }
2187
2188 static void nwrap_files_endpwent(struct nwrap_backend *b)
2189 {
2190         (void) b; /* unused */
2191
2192         nwrap_pw_global.idx = 0;
2193 }
2194
2195 /* misc functions */
2196 static int nwrap_files_initgroups(struct nwrap_backend *b,
2197                                   const char *user, gid_t group)
2198 {
2199         (void) b; /* unused */
2200         (void) user; /* unused */
2201         (void) group; /* used */
2202
2203         /* TODO: maybe we should also fake this... */
2204         return EPERM;
2205 }
2206
2207 /* group functions */
2208 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
2209                                           const char *name)
2210 {
2211         int i;
2212
2213         (void) b; /* unused */
2214
2215         nwrap_files_cache_reload(nwrap_gr_global.cache);
2216
2217         for (i=0; i<nwrap_gr_global.num; i++) {
2218                 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
2219                         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] found", name);
2220                         return &nwrap_gr_global.list[i];
2221                 }
2222                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2223                           "group[%s] does not match [%s]",
2224                           name,
2225                           nwrap_gr_global.list[i].gr_name);
2226         }
2227
2228         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] not found", name);
2229
2230         errno = ENOENT;
2231         return NULL;
2232 }
2233
2234 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
2235                                   const char *name, struct group *grdst,
2236                                   char *buf, size_t buflen, struct group **grdstp)
2237 {
2238         struct group *gr;
2239
2240         gr = nwrap_files_getgrnam(b, name);
2241         if (!gr) {
2242                 if (errno == 0) {
2243                         return ENOENT;
2244                 }
2245                 return errno;
2246         }
2247
2248         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
2249 }
2250
2251 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
2252                                           gid_t gid)
2253 {
2254         int i;
2255
2256         (void) b; /* unused */
2257
2258         nwrap_files_cache_reload(nwrap_gr_global.cache);
2259
2260         for (i=0; i<nwrap_gr_global.num; i++) {
2261                 if (nwrap_gr_global.list[i].gr_gid == gid) {
2262                         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] found", gid);
2263                         return &nwrap_gr_global.list[i];
2264                 }
2265                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2266                           "gid[%u] does not match [%u]",
2267                           gid,
2268                           nwrap_gr_global.list[i].gr_gid);
2269         }
2270
2271         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] not found", gid);
2272
2273         errno = ENOENT;
2274         return NULL;
2275 }
2276
2277 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
2278                                   gid_t gid, struct group *grdst,
2279                                   char *buf, size_t buflen, struct group **grdstp)
2280 {
2281         struct group *gr;
2282
2283         gr = nwrap_files_getgrgid(b, gid);
2284         if (!gr) {
2285                 if (errno == 0) {
2286                         return ENOENT;
2287                 }
2288                 return errno;
2289         }
2290
2291         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
2292 }
2293
2294 /* group enum functions */
2295 static void nwrap_files_setgrent(struct nwrap_backend *b)
2296 {
2297         (void) b; /* unused */
2298
2299         nwrap_gr_global.idx = 0;
2300 }
2301
2302 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
2303 {
2304         struct group *gr;
2305
2306         (void) b; /* unused */
2307
2308         if (nwrap_gr_global.idx == 0) {
2309                 nwrap_files_cache_reload(nwrap_gr_global.cache);
2310         }
2311
2312         if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
2313                 errno = ENOENT;
2314                 return NULL;
2315         }
2316
2317         gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
2318
2319         NWRAP_LOG(NWRAP_LOG_DEBUG,
2320                   "return group[%s] gid[%u]",
2321                   gr->gr_name, gr->gr_gid);
2322
2323         return gr;
2324 }
2325
2326 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
2327                                   struct group *grdst, char *buf,
2328                                   size_t buflen, struct group **grdstp)
2329 {
2330         struct group *gr;
2331
2332         gr = nwrap_files_getgrent(b);
2333         if (!gr) {
2334                 if (errno == 0) {
2335                         return ENOENT;
2336                 }
2337                 return errno;
2338         }
2339
2340         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
2341 }
2342
2343 static void nwrap_files_endgrent(struct nwrap_backend *b)
2344 {
2345         (void) b; /* unused */
2346
2347         nwrap_gr_global.idx = 0;
2348 }
2349
2350 /* hosts functions */
2351 static struct hostent *nwrap_files_gethostbyname(const char *name, int af)
2352 {
2353         struct hostent *he;
2354         int i;
2355
2356         nwrap_files_cache_reload(nwrap_he_global.cache);
2357
2358         for (i = 0; i < nwrap_he_global.num; i++) {
2359                 int j;
2360
2361                 he = &nwrap_he_global.list[i].ht;
2362
2363                 /* Filter by address familiy if provided */
2364                 if (af != AF_UNSPEC && he->h_addrtype != af) {
2365                         continue;
2366                 }
2367
2368                 if (strcasecmp(he->h_name, name) == 0) {
2369                         NWRAP_LOG(NWRAP_LOG_DEBUG, "name[%s] found", name);
2370                         return he;
2371                 }
2372
2373                 if (he->h_aliases == NULL) {
2374                         continue;
2375                 }
2376
2377                 for (j = 0; he->h_aliases[j] != NULL; j++) {
2378                         if (strcasecmp(he->h_aliases[j], name) == 0) {
2379                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2380                                           "name[%s] found",
2381                                           name);
2382                                 return he;
2383                         }
2384                 }
2385         }
2386
2387         errno = ENOENT;
2388         return NULL;
2389 }
2390
2391 #ifdef HAVE_GETHOSTBYNAME_R
2392 static int nwrap_gethostbyname_r(const char *name,
2393                                  struct hostent *ret,
2394                                  char *buf, size_t buflen,
2395                                  struct hostent **result, int *h_errnop)
2396 {
2397         *result = nwrap_files_gethostbyname(name, AF_UNSPEC);
2398         if (*result != NULL) {
2399                 memset(buf, '\0', buflen);
2400                 *ret = **result;
2401                 return 0;
2402         } else {
2403                 *h_errnop = h_errno;
2404                 return -1;
2405         }
2406 }
2407
2408 int gethostbyname_r(const char *name,
2409                     struct hostent *ret,
2410                     char *buf, size_t buflen,
2411                     struct hostent **result, int *h_errnop)
2412 {
2413         if (!nss_wrapper_hosts_enabled()) {
2414                 return libc_gethostbyname_r(name,
2415                                             ret,
2416                                             buf,
2417                                             buflen,
2418                                             result,
2419                                             h_errnop);
2420         }
2421
2422         return nwrap_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
2423 }
2424 #endif
2425
2426 static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
2427                                                  socklen_t len, int type)
2428 {
2429         struct hostent *he;
2430         char ip[INET6_ADDRSTRLEN] = {0};
2431         const char *a;
2432         int i;
2433
2434         (void) len; /* unused */
2435
2436         nwrap_files_cache_reload(nwrap_he_global.cache);
2437
2438         a = inet_ntop(type, addr, ip, sizeof(ip));
2439         if (a == NULL) {
2440                 errno = EINVAL;
2441                 return NULL;
2442         }
2443
2444         for (i = 0; i < nwrap_he_global.num; i++) {
2445                 he = &nwrap_he_global.list[i].ht;
2446
2447                 if (he->h_addrtype != type) {
2448                         continue;
2449                 }
2450
2451                 if (memcmp(addr, he->h_addr_list[0], he->h_length) == 0) {
2452                         return he;
2453                 }
2454         }
2455
2456         errno = ENOENT;
2457         return NULL;
2458 }
2459
2460 #ifdef HAVE_GETHOSTBYADDR_R
2461 static int nwrap_gethostbyaddr_r(const void *addr, socklen_t len, int type,
2462                                  struct hostent *ret,
2463                                  char *buf, size_t buflen,
2464                                  struct hostent **result, int *h_errnop)
2465 {
2466         *result = nwrap_files_gethostbyaddr(addr, len, type);
2467         if (*result != NULL) {
2468                 memset(buf, '\0', buflen);
2469                 *ret = **result;
2470                 return 0;
2471         } else {
2472                 *h_errnop = h_errno;
2473                 return -1;
2474         }
2475 }
2476
2477 int gethostbyaddr_r(const void *addr, socklen_t len, int type,
2478                     struct hostent *ret,
2479                     char *buf, size_t buflen,
2480                     struct hostent **result, int *h_errnop)
2481 {
2482         if (!nss_wrapper_hosts_enabled()) {
2483                 return libc_gethostbyaddr_r(addr,
2484                                             len,
2485                                             type,
2486                                             ret,
2487                                             buf,
2488                                             buflen,
2489                                             result,
2490                                             h_errnop);
2491         }
2492
2493         return nwrap_gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
2494 }
2495 #endif
2496
2497 /* hosts enum functions */
2498 static void nwrap_files_sethostent(void)
2499 {
2500         nwrap_he_global.idx = 0;
2501 }
2502
2503 static struct hostent *nwrap_files_gethostent(void)
2504 {
2505         struct hostent *he;
2506
2507         if (nwrap_he_global.idx == 0) {
2508                 nwrap_files_cache_reload(nwrap_he_global.cache);
2509         }
2510
2511         if (nwrap_he_global.idx >= nwrap_he_global.num) {
2512                 errno = ENOENT;
2513                 return NULL;
2514         }
2515
2516         he = &nwrap_he_global.list[nwrap_he_global.idx++].ht;
2517
2518         NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
2519
2520         return he;
2521 }
2522
2523 static void nwrap_files_endhostent(void)
2524 {
2525         nwrap_he_global.idx = 0;
2526 }
2527
2528 /*
2529  * module backend
2530  */
2531
2532 #ifndef SAFE_FREE
2533 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
2534 #endif
2535
2536 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
2537                                             const char *name)
2538 {
2539         static struct passwd pwd;
2540         static char buf[1000];
2541         NSS_STATUS status;
2542
2543         if (!b->fns->_nss_getpwnam_r) {
2544                 return NULL;
2545         }
2546
2547         status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
2548         if (status == NSS_STATUS_NOTFOUND) {
2549                 return NULL;
2550         }
2551         if (status != NSS_STATUS_SUCCESS) {
2552                 return NULL;
2553         }
2554
2555         return &pwd;
2556 }
2557
2558 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
2559                                    const char *name, struct passwd *pwdst,
2560                                    char *buf, size_t buflen, struct passwd **pwdstp)
2561 {
2562         int ret;
2563
2564         (void) b; /* unused */
2565         (void) pwdst; /* unused */
2566         (void) pwdstp; /* unused */
2567
2568         if (!b->fns->_nss_getpwnam_r) {
2569                 return NSS_STATUS_NOTFOUND;
2570         }
2571
2572         ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
2573         switch (ret) {
2574         case NSS_STATUS_SUCCESS:
2575                 return 0;
2576         case NSS_STATUS_NOTFOUND:
2577                 if (errno != 0) {
2578                         return errno;
2579                 }
2580                 return ENOENT;
2581         case NSS_STATUS_TRYAGAIN:
2582                 if (errno != 0) {
2583                         return errno;
2584                 }
2585                 return ERANGE;
2586         default:
2587                 if (errno != 0) {
2588                         return errno;
2589                 }
2590                 return ret;
2591         }
2592 }
2593
2594 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
2595                                             uid_t uid)
2596 {
2597         static struct passwd pwd;
2598         static char buf[1000];
2599         NSS_STATUS status;
2600
2601         if (!b->fns->_nss_getpwuid_r) {
2602                 return NULL;
2603         }
2604
2605         status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
2606         if (status == NSS_STATUS_NOTFOUND) {
2607                 return NULL;
2608         }
2609         if (status != NSS_STATUS_SUCCESS) {
2610                 return NULL;
2611         }
2612         return &pwd;
2613 }
2614
2615 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
2616                                    uid_t uid, struct passwd *pwdst,
2617                                    char *buf, size_t buflen, struct passwd **pwdstp)
2618 {
2619         int ret;
2620
2621         (void) pwdstp; /* unused */
2622
2623         if (!b->fns->_nss_getpwuid_r) {
2624                 return ENOENT;
2625         }
2626
2627         ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
2628         switch (ret) {
2629         case NSS_STATUS_SUCCESS:
2630                 return 0;
2631         case NSS_STATUS_NOTFOUND:
2632                 if (errno != 0) {
2633                         return errno;
2634                 }
2635                 return ENOENT;
2636         case NSS_STATUS_TRYAGAIN:
2637                 if (errno != 0) {
2638                         return errno;
2639                 }
2640                 return ERANGE;
2641         default:
2642                 if (errno != 0) {
2643                         return errno;
2644                 }
2645                 return ret;
2646         }
2647 }
2648
2649 static void nwrap_module_setpwent(struct nwrap_backend *b)
2650 {
2651         if (!b->fns->_nss_setpwent) {
2652                 return;
2653         }
2654
2655         b->fns->_nss_setpwent();
2656 }
2657
2658 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
2659 {
2660         static struct passwd pwd;
2661         static char buf[1000];
2662         NSS_STATUS status;
2663
2664         if (!b->fns->_nss_getpwent_r) {
2665                 return NULL;
2666         }
2667
2668         status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
2669         if (status == NSS_STATUS_NOTFOUND) {
2670                 return NULL;
2671         }
2672         if (status != NSS_STATUS_SUCCESS) {
2673                 return NULL;
2674         }
2675         return &pwd;
2676 }
2677
2678 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
2679                                    struct passwd *pwdst, char *buf,
2680                                    size_t buflen, struct passwd **pwdstp)
2681 {
2682         int ret;
2683
2684         (void) pwdstp; /* unused */
2685
2686         if (!b->fns->_nss_getpwent_r) {
2687                 return ENOENT;
2688         }
2689
2690         ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
2691         switch (ret) {
2692         case NSS_STATUS_SUCCESS:
2693                 return 0;
2694         case NSS_STATUS_NOTFOUND:
2695                 if (errno != 0) {
2696                         return errno;
2697                 }
2698                 return ENOENT;
2699         case NSS_STATUS_TRYAGAIN:
2700                 if (errno != 0) {
2701                         return errno;
2702                 }
2703                 return ERANGE;
2704         default:
2705                 if (errno != 0) {
2706                         return errno;
2707                 }
2708                 return ret;
2709         }
2710 }
2711
2712 static void nwrap_module_endpwent(struct nwrap_backend *b)
2713 {
2714         if (!b->fns->_nss_endpwent) {
2715                 return;
2716         }
2717
2718         b->fns->_nss_endpwent();
2719 }
2720
2721 static int nwrap_module_initgroups(struct nwrap_backend *b,
2722                                    const char *user, gid_t group)
2723 {
2724         gid_t *groups;
2725         long int start;
2726         long int size;
2727
2728         if (!b->fns->_nss_initgroups) {
2729                 return NSS_STATUS_UNAVAIL;
2730         }
2731
2732         return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
2733 }
2734
2735 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
2736                                            const char *name)
2737 {
2738         static struct group grp;
2739         static char *buf;
2740         static int buflen = 1000;
2741         NSS_STATUS status;
2742
2743         if (!b->fns->_nss_getgrnam_r) {
2744                 return NULL;
2745         }
2746
2747         if (!buf) {
2748                 buf = (char *)malloc(buflen);
2749         }
2750 again:
2751         status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
2752         if (status == NSS_STATUS_TRYAGAIN) {
2753                 buflen *= 2;
2754                 buf = (char *)realloc(buf, buflen);
2755                 if (!buf) {
2756                         return NULL;
2757                 }
2758                 goto again;
2759         }
2760         if (status == NSS_STATUS_NOTFOUND) {
2761                 SAFE_FREE(buf);
2762                 return NULL;
2763         }
2764         if (status != NSS_STATUS_SUCCESS) {
2765                 SAFE_FREE(buf);
2766                 return NULL;
2767         }
2768         return &grp;
2769 }
2770
2771 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
2772                                    const char *name, struct group *grdst,
2773                                    char *buf, size_t buflen, struct group **grdstp)
2774 {
2775         int ret;
2776
2777         (void) grdstp; /* unused */
2778
2779         if (!b->fns->_nss_getgrnam_r) {
2780                 return ENOENT;
2781         }
2782
2783         ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
2784         switch (ret) {
2785         case NSS_STATUS_SUCCESS:
2786                 return 0;
2787         case NSS_STATUS_NOTFOUND:
2788                 if (errno != 0) {
2789                         return errno;
2790                 }
2791                 return ENOENT;
2792         case NSS_STATUS_TRYAGAIN:
2793                 if (errno != 0) {
2794                         return errno;
2795                 }
2796                 return ERANGE;
2797         default:
2798                 if (errno != 0) {
2799                         return errno;
2800                 }
2801                 return ret;
2802         }
2803 }
2804
2805 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
2806                                            gid_t gid)
2807 {
2808         static struct group grp;
2809         static char *buf;
2810         static int buflen = 1000;
2811         NSS_STATUS status;
2812
2813         if (!b->fns->_nss_getgrgid_r) {
2814                 return NULL;
2815         }
2816
2817         if (!buf) {
2818                 buf = (char *)malloc(buflen);
2819         }
2820
2821 again:
2822         status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
2823         if (status == NSS_STATUS_TRYAGAIN) {
2824                 buflen *= 2;
2825                 buf = (char *)realloc(buf, buflen);
2826                 if (!buf) {
2827                         return NULL;
2828                 }
2829                 goto again;
2830         }
2831         if (status == NSS_STATUS_NOTFOUND) {
2832                 SAFE_FREE(buf);
2833                 return NULL;
2834         }
2835         if (status != NSS_STATUS_SUCCESS) {
2836                 SAFE_FREE(buf);
2837                 return NULL;
2838         }
2839         return &grp;
2840 }
2841
2842 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
2843                                    gid_t gid, struct group *grdst,
2844                                    char *buf, size_t buflen, struct group **grdstp)
2845 {
2846         int ret;
2847
2848         (void) grdstp; /* unused */
2849
2850         if (!b->fns->_nss_getgrgid_r) {
2851                 return ENOENT;
2852         }
2853
2854         ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
2855         switch (ret) {
2856         case NSS_STATUS_SUCCESS:
2857                 return 0;
2858         case NSS_STATUS_NOTFOUND:
2859                 if (errno != 0) {
2860                         return errno;
2861                 }
2862                 return ENOENT;
2863         case NSS_STATUS_TRYAGAIN:
2864                 if (errno != 0) {
2865                         return errno;
2866                 }
2867                 return ERANGE;
2868         default:
2869                 if (errno != 0) {
2870                         return errno;
2871                 }
2872                 return ret;
2873         }
2874 }
2875
2876 static void nwrap_module_setgrent(struct nwrap_backend *b)
2877 {
2878         if (!b->fns->_nss_setgrent) {
2879                 return;
2880         }
2881
2882         b->fns->_nss_setgrent();
2883 }
2884
2885 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
2886 {
2887         static struct group grp;
2888         static char *buf;
2889         static int buflen = 1024;
2890         NSS_STATUS status;
2891
2892         if (!b->fns->_nss_getgrent_r) {
2893                 return NULL;
2894         }
2895
2896         if (!buf) {
2897                 buf = (char *)malloc(buflen);
2898         }
2899
2900 again:
2901         status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
2902         if (status == NSS_STATUS_TRYAGAIN) {
2903                 buflen *= 2;
2904                 buf = (char *)realloc(buf, buflen);
2905                 if (!buf) {
2906                         return NULL;
2907                 }
2908                 goto again;
2909         }
2910         if (status == NSS_STATUS_NOTFOUND) {
2911                 SAFE_FREE(buf);
2912                 return NULL;
2913         }
2914         if (status != NSS_STATUS_SUCCESS) {
2915                 SAFE_FREE(buf);
2916                 return NULL;
2917         }
2918         return &grp;
2919 }
2920
2921 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
2922                                    struct group *grdst, char *buf,
2923                                    size_t buflen, struct group **grdstp)
2924 {
2925         int ret;
2926
2927         (void) grdstp; /* unused */
2928
2929         if (!b->fns->_nss_getgrent_r) {
2930                 return ENOENT;
2931         }
2932
2933         ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
2934         switch (ret) {
2935         case NSS_STATUS_SUCCESS:
2936                 return 0;
2937         case NSS_STATUS_NOTFOUND:
2938                 if (errno != 0) {
2939                         return errno;
2940                 }
2941                 return ENOENT;
2942         case NSS_STATUS_TRYAGAIN:
2943                 if (errno != 0) {
2944                         return errno;
2945                 }
2946                 return ERANGE;
2947         default:
2948                 if (errno != 0) {
2949                         return errno;
2950                 }
2951                 return ret;
2952         }
2953 }
2954
2955 static void nwrap_module_endgrent(struct nwrap_backend *b)
2956 {
2957         if (!b->fns->_nss_endgrent) {
2958                 return;
2959         }
2960
2961         b->fns->_nss_endgrent();
2962 }
2963
2964 /****************************************************************************
2965  *   GETPWNAM
2966  ***************************************************************************/
2967
2968 static struct passwd *nwrap_getpwnam(const char *name)
2969 {
2970         int i;
2971         struct passwd *pwd;
2972
2973         for (i=0; i < nwrap_main_global->num_backends; i++) {
2974                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2975                 pwd = b->ops->nw_getpwnam(b, name);
2976                 if (pwd) {
2977                         return pwd;
2978                 }
2979         }
2980
2981         return NULL;
2982 }
2983
2984 struct passwd *getpwnam(const char *name)
2985 {
2986         if (!nss_wrapper_enabled()) {
2987                 return libc_getpwnam(name);
2988         }
2989
2990         return nwrap_getpwnam(name);
2991 }
2992
2993 /****************************************************************************
2994  *   GETPWNAM_R
2995  ***************************************************************************/
2996
2997 static int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
2998                             char *buf, size_t buflen, struct passwd **pwdstp)
2999 {
3000         int i,ret;
3001
3002         for (i=0; i < nwrap_main_global->num_backends; i++) {
3003                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3004                 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
3005                 if (ret == ENOENT) {
3006                         continue;
3007                 }
3008                 return ret;
3009         }
3010
3011         return ENOENT;
3012 }
3013
3014 #ifdef HAVE_GETPWNAM_R
3015 # ifdef HAVE_SOLARIS_GETPWNAM_R
3016 int getpwnam_r(const char *name, struct passwd *pwdst,
3017                char *buf, int buflen, struct passwd **pwdstp)
3018 # else /* HAVE_SOLARIS_GETPWNAM_R */
3019 int getpwnam_r(const char *name, struct passwd *pwdst,
3020                char *buf, size_t buflen, struct passwd **pwdstp)
3021 # endif /* HAVE_SOLARIS_GETPWNAM_R */
3022 {
3023         if (!nss_wrapper_enabled()) {
3024                 return libc_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
3025         }
3026
3027         return nwrap_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
3028 }
3029 #endif
3030
3031 /****************************************************************************
3032  *   GETPWUID
3033  ***************************************************************************/
3034
3035 static struct passwd *nwrap_getpwuid(uid_t uid)
3036 {
3037         int i;
3038         struct passwd *pwd;
3039
3040         for (i=0; i < nwrap_main_global->num_backends; i++) {
3041                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3042                 pwd = b->ops->nw_getpwuid(b, uid);
3043                 if (pwd) {
3044                         return pwd;
3045                 }
3046         }
3047
3048         return NULL;
3049 }
3050
3051 struct passwd *getpwuid(uid_t uid)
3052 {
3053         if (!nss_wrapper_enabled()) {
3054                 return libc_getpwuid(uid);
3055         }
3056
3057         return nwrap_getpwuid(uid);
3058 }
3059
3060 /****************************************************************************
3061  *   GETPWUID_R
3062  ***************************************************************************/
3063
3064 static int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
3065                             char *buf, size_t buflen, struct passwd **pwdstp)
3066 {
3067         int i,ret;
3068
3069         for (i=0; i < nwrap_main_global->num_backends; i++) {
3070                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3071                 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
3072                 if (ret == ENOENT) {
3073                         continue;
3074                 }
3075                 return ret;
3076         }
3077
3078         return ENOENT;
3079 }
3080
3081 #ifdef HAVE_SOLARIS_GETPWUID_R
3082 int getpwuid_r(uid_t uid, struct passwd *pwdst,
3083                char *buf, int buflen, struct passwd **pwdstp)
3084 #else
3085 int getpwuid_r(uid_t uid, struct passwd *pwdst,
3086                char *buf, size_t buflen, struct passwd **pwdstp)
3087 #endif
3088 {
3089         if (!nss_wrapper_enabled()) {
3090                 return libc_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
3091         }
3092
3093         return nwrap_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
3094 }
3095
3096 /****************************************************************************
3097  *   SETPWENT
3098  ***************************************************************************/
3099
3100 static void nwrap_setpwent(void)
3101 {
3102         int i;
3103
3104         for (i=0; i < nwrap_main_global->num_backends; i++) {
3105                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3106                 b->ops->nw_setpwent(b);
3107         }
3108 }
3109
3110 void setpwent(void)
3111 {
3112         if (!nss_wrapper_enabled()) {
3113                 libc_setpwent();
3114                 return;
3115         }
3116
3117         nwrap_setpwent();
3118 }
3119
3120 /****************************************************************************
3121  *   GETPWENT
3122  ***************************************************************************/
3123
3124 static struct passwd *nwrap_getpwent(void)
3125 {
3126         int i;
3127         struct passwd *pwd;
3128
3129         for (i=0; i < nwrap_main_global->num_backends; i++) {
3130                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3131                 pwd = b->ops->nw_getpwent(b);
3132                 if (pwd) {
3133                         return pwd;
3134                 }
3135         }
3136
3137         return NULL;
3138 }
3139
3140 struct passwd *getpwent(void)
3141 {
3142         if (!nss_wrapper_enabled()) {
3143                 return libc_getpwent();
3144         }
3145
3146         return nwrap_getpwent();
3147 }
3148
3149 /****************************************************************************
3150  *   GETPWENT_R
3151  ***************************************************************************/
3152
3153 static int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
3154                             size_t buflen, struct passwd **pwdstp)
3155 {
3156         int i,ret;
3157
3158         for (i=0; i < nwrap_main_global->num_backends; i++) {
3159                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3160                 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
3161                 if (ret == ENOENT) {
3162                         continue;
3163                 }
3164                 return ret;
3165         }
3166
3167         return ENOENT;
3168 }
3169
3170 #ifdef HAVE_SOLARIS_GETPWENT_R
3171 struct passwd *getpwent_r(struct passwd *pwdst, char *buf, int buflen)
3172 {
3173         struct passwd *pwdstp = NULL;
3174         int rc;
3175
3176         if (!nss_wrapper_enabled()) {
3177                 return libc_getpwent_r(pwdst, buf, buflen);
3178         }
3179         rc = nwrap_getpwent_r(pwdst, buf, buflen, &pwdstp);
3180         if (rc < 0) {
3181                 return NULL;
3182         }
3183
3184         return pwdstp;
3185 }
3186 #else /* HAVE_SOLARIS_GETPWENT_R */
3187 int getpwent_r(struct passwd *pwdst, char *buf,
3188                size_t buflen, struct passwd **pwdstp)
3189 {
3190         if (!nss_wrapper_enabled()) {
3191                 return libc_getpwent_r(pwdst, buf, buflen, pwdstp);
3192         }
3193
3194         return nwrap_getpwent_r(pwdst, buf, buflen, pwdstp);
3195 }
3196 #endif /* HAVE_SOLARIS_GETPWENT_R */
3197
3198 /****************************************************************************
3199  *   ENDPWENT
3200  ***************************************************************************/
3201
3202 static void nwrap_endpwent(void)
3203 {
3204         int i;
3205
3206         for (i=0; i < nwrap_main_global->num_backends; i++) {
3207                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3208                 b->ops->nw_endpwent(b);
3209         }
3210 }
3211
3212 void endpwent(void)
3213 {
3214         if (!nss_wrapper_enabled()) {
3215                 libc_endpwent();
3216                 return;
3217         }
3218
3219         nwrap_endpwent();
3220 }
3221
3222 /****************************************************************************
3223  *   INITGROUPS
3224  ***************************************************************************/
3225
3226 static int nwrap_initgroups(const char *user, gid_t group)
3227 {
3228         int i;
3229
3230         for (i=0; i < nwrap_main_global->num_backends; i++) {
3231                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3232                 int rc;
3233
3234                 rc = b->ops->nw_initgroups(b, user, group);
3235                 if (rc == 0) {
3236                         return 0;
3237                 }
3238         }
3239
3240         errno = ENOENT;
3241         return -1;
3242 }
3243
3244 int initgroups(const char *user, gid_t group)
3245 {
3246         if (!nss_wrapper_enabled()) {
3247                 return libc_initgroups(user, group);
3248         }
3249
3250         return nwrap_initgroups(user, group);
3251 }
3252
3253 /****************************************************************************
3254  *   GETGRNAM
3255  ***************************************************************************/
3256
3257 static struct group *nwrap_getgrnam(const char *name)
3258 {
3259         int i;
3260         struct group *grp;
3261
3262         for (i=0; i < nwrap_main_global->num_backends; i++) {
3263                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3264                 grp = b->ops->nw_getgrnam(b, name);
3265                 if (grp) {
3266                         return grp;
3267                 }
3268         }
3269
3270         return NULL;
3271 }
3272
3273 struct group *getgrnam(const char *name)
3274 {
3275         if (!nss_wrapper_enabled()) {
3276                 return libc_getgrnam(name);
3277         }
3278
3279         return nwrap_getgrnam(name);
3280 }
3281
3282 /****************************************************************************
3283  *   GETGRNAM_R
3284  ***************************************************************************/
3285
3286 static int nwrap_getgrnam_r(const char *name, struct group *grdst,
3287                             char *buf, size_t buflen, struct group **grdstp)
3288 {
3289         int i, ret;
3290
3291         for (i=0; i < nwrap_main_global->num_backends; i++) {
3292                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3293                 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
3294                 if (ret == ENOENT) {
3295                         continue;
3296                 }
3297                 return ret;
3298         }
3299
3300         return ENOENT;
3301 }
3302
3303 #ifdef HAVE_GETGRNAM_R
3304 # ifdef HAVE_SOLARIS_GETGRNAM_R
3305 int getgrnam_r(const char *name, struct group *grp,
3306                 char *buf, int buflen, struct group **pgrp)
3307 # else /* HAVE_SOLARIS_GETGRNAM_R */
3308 int getgrnam_r(const char *name, struct group *grp,
3309                char *buf, size_t buflen, struct group **pgrp)
3310 # endif /* HAVE_SOLARIS_GETGRNAM_R */
3311 {
3312         if (!nss_wrapper_enabled()) {
3313                 return libc_getgrnam_r(name,
3314                                        grp,
3315                                        buf,
3316                                        buflen,
3317                                        pgrp);
3318         }
3319
3320         return nwrap_getgrnam_r(name, grp, buf, buflen, pgrp);
3321 }
3322 #endif /* HAVE_GETGRNAM_R */
3323
3324 /****************************************************************************
3325  *   GETGRGID
3326  ***************************************************************************/
3327
3328 static struct group *nwrap_getgrgid(gid_t gid)
3329 {
3330         int i;
3331         struct group *grp;
3332
3333         for (i=0; i < nwrap_main_global->num_backends; i++) {
3334                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3335                 grp = b->ops->nw_getgrgid(b, gid);
3336                 if (grp) {
3337                         return grp;
3338                 }
3339         }
3340
3341         return NULL;
3342 }
3343
3344 struct group *getgrgid(gid_t gid)
3345 {
3346         if (!nss_wrapper_enabled()) {
3347                 return libc_getgrgid(gid);
3348         }
3349
3350         return nwrap_getgrgid(gid);
3351 }
3352
3353 /****************************************************************************
3354  *   GETGRGID_R
3355  ***************************************************************************/
3356
3357 static int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
3358                             char *buf, size_t buflen, struct group **grdstp)
3359 {
3360         int i,ret;
3361
3362         for (i=0; i < nwrap_main_global->num_backends; i++) {
3363                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3364                 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
3365                 if (ret == ENOENT) {
3366                         continue;
3367                 }
3368                 return ret;
3369         }
3370
3371         return ENOENT;
3372 }
3373
3374 #ifdef HAVE_GETGRGID_R
3375 # ifdef HAVE_SOLARIS_GETGRGID_R
3376 int getgrgid_r(gid_t gid, struct group *grdst,
3377                char *buf, int buflen, struct group **grdstp)
3378 # else /* HAVE_SOLARIS_GETGRGID_R */
3379 int getgrgid_r(gid_t gid, struct group *grdst,
3380                char *buf, size_t buflen, struct group **grdstp)
3381 # endif /* HAVE_SOLARIS_GETGRGID_R */
3382 {
3383         if (!nss_wrapper_enabled()) {
3384                 return libc_getgrgid_r(gid, grdst, buf, buflen, grdstp);
3385         }
3386
3387         return nwrap_getgrgid_r(gid, grdst, buf, buflen, grdstp);
3388 }
3389 #endif
3390
3391 /****************************************************************************
3392  *   SETGRENT
3393  ***************************************************************************/
3394
3395 static void nwrap_setgrent(void)
3396 {
3397         int i;
3398
3399         for (i=0; i < nwrap_main_global->num_backends; i++) {
3400                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3401                 b->ops->nw_setgrent(b);
3402         }
3403 }
3404
3405 #ifdef HAVE_BSD_SETGRENT
3406 int setgrent(void)
3407 #else
3408 void setgrent(void)
3409 #endif
3410 {
3411         if (!nss_wrapper_enabled()) {
3412                 libc_setgrent();
3413                 goto out;
3414         }
3415
3416         nwrap_setgrent();
3417
3418 out:
3419 #ifdef HAVE_BSD_SETGRENT
3420         return 0;
3421 #else
3422         return;
3423 #endif
3424 }
3425
3426 /****************************************************************************
3427  *   GETGRENT
3428  ***************************************************************************/
3429
3430 static struct group *nwrap_getgrent(void)
3431 {
3432         int i;
3433         struct group *grp;
3434
3435         for (i=0; i < nwrap_main_global->num_backends; i++) {
3436                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3437                 grp = b->ops->nw_getgrent(b);
3438                 if (grp) {
3439                         return grp;
3440                 }
3441         }
3442
3443         return NULL;
3444 }
3445
3446 struct group *getgrent(void)
3447 {
3448         if (!nss_wrapper_enabled()) {
3449                 return libc_getgrent();
3450         }
3451
3452         return nwrap_getgrent();
3453 }
3454
3455 /****************************************************************************
3456  *   GETGRENT_R
3457  ***************************************************************************/
3458
3459 static int nwrap_getgrent_r(struct group *grdst, char *buf,
3460                             size_t buflen, struct group **grdstp)
3461 {
3462         int i,ret;
3463
3464         for (i=0; i < nwrap_main_global->num_backends; i++) {
3465                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3466                 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
3467                 if (ret == ENOENT) {
3468                         continue;
3469                 }
3470                 return ret;
3471         }
3472
3473         return ENOENT;
3474 }
3475
3476 #ifdef HAVE_SOLARIS_GETGRENT_R
3477 struct group *getgrent_r(struct group *src, char *buf, int buflen)
3478 {
3479         struct group *grdstp = NULL;
3480         int rc;
3481
3482         if (!nss_wrapper_enabled()) {
3483                 return libc_getgrent_r(src, buf, buflen);
3484         }
3485
3486         rc = nwrap_getgrent_r(src, buf, buflen, &grdstp);
3487         if (rc < 0) {
3488                 return NULL;
3489         }
3490
3491         return grdstp;
3492 }
3493 #else /* HAVE_SOLARIS_GETGRENT_R */
3494 int getgrent_r(struct group *src, char *buf,
3495                size_t buflen, struct group **grdstp)
3496 {
3497         if (!nss_wrapper_enabled()) {
3498                 return libc_getgrent_r(src, buf, buflen, grdstp);
3499         }
3500
3501         return nwrap_getgrent_r(src, buf, buflen, grdstp);
3502 }
3503 #endif /* HAVE_SOLARIS_GETGRENT_R */
3504
3505 /****************************************************************************
3506  *   ENDGRENT
3507  ***************************************************************************/
3508
3509 static void nwrap_endgrent(void)
3510 {
3511         int i;
3512
3513         for (i=0; i < nwrap_main_global->num_backends; i++) {
3514                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
3515                 b->ops->nw_endgrent(b);
3516         }
3517 }
3518
3519 void endgrent(void)
3520 {
3521         if (!nss_wrapper_enabled()) {
3522                 libc_endgrent();
3523                 return;
3524         }
3525
3526         nwrap_endgrent();
3527 }
3528
3529 /****************************************************************************
3530  *   GETGROUPLIST
3531  ***************************************************************************/
3532
3533 #ifdef HAVE_GETGROUPLIST
3534 static int nwrap_getgrouplist(const char *user, gid_t group,
3535                               gid_t *groups, int *ngroups)
3536 {
3537         struct group *grp;
3538         gid_t *groups_tmp;
3539         int count = 1;
3540         const char *name_of_group = "";
3541
3542         NWRAP_LOG(NWRAP_LOG_DEBUG, "getgrouplist called for %s", user);
3543
3544         groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
3545         if (!groups_tmp) {
3546                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
3547                 errno = ENOMEM;
3548                 return -1;
3549         }
3550
3551         memcpy(groups_tmp, &group, sizeof(gid_t));
3552
3553         grp = nwrap_getgrgid(group);
3554         if (grp) {
3555                 name_of_group = grp->gr_name;
3556         }
3557
3558         nwrap_setgrent();
3559         while ((grp = nwrap_getgrent()) != NULL) {
3560                 int i = 0;
3561
3562                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3563                           "Inspecting %s for group membership",
3564                           grp->gr_name);
3565
3566                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
3567
3568                         if ((strcmp(user, grp->gr_mem[i]) == 0) &&
3569                             (strcmp(name_of_group, grp->gr_name) != 0)) {
3570
3571                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3572                                           "%s is member of %s",
3573                                           user,
3574                                           grp->gr_name);
3575
3576                                 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
3577                                 if (!groups_tmp) {
3578                                         NWRAP_LOG(NWRAP_LOG_ERROR,
3579                                                   "Out of memory");
3580                                         errno = ENOMEM;
3581                                         return -1;
3582                                 }
3583
3584                                 memcpy(&groups_tmp[count], &grp->gr_gid, sizeof(gid_t));
3585                                 count++;
3586                         }
3587                 }
3588         }
3589
3590         nwrap_endgrent();
3591
3592         NWRAP_LOG(NWRAP_LOG_DEBUG,
3593                   "%s is member of %d groups",
3594                   user, *ngroups);
3595
3596         if (*ngroups < count) {
3597                 *ngroups = count;
3598                 free(groups_tmp);
3599                 return -1;
3600         }
3601
3602         *ngroups = count;
3603         memcpy(groups, groups_tmp, count * sizeof(gid_t));
3604         free(groups_tmp);
3605
3606         return count;
3607 }
3608
3609 int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
3610 {
3611         if (!nss_wrapper_enabled()) {
3612                 return libc_getgrouplist(user, group, groups, ngroups);
3613         }
3614
3615         return nwrap_getgrouplist(user, group, groups, ngroups);
3616 }
3617 #endif
3618
3619 /**********************************************************
3620  * NETDB
3621  **********************************************************/
3622
3623 static void nwrap_sethostent(int stayopen) {
3624         (void) stayopen; /* ignored */
3625
3626         nwrap_files_sethostent();
3627 }
3628
3629 #ifdef HAVE_SOLARIS_SETHOSTENT
3630 int sethostent(int stayopen)
3631 {
3632         if (!nss_wrapper_hosts_enabled()) {
3633                 libc_sethostent(stayopen);
3634                 return 0;
3635         }
3636
3637         nwrap_sethostent(stayopen);
3638
3639         return 0;
3640 }
3641 #else /* HAVE_SOLARIS_SETHOSTENT */
3642 void sethostent(int stayopen)
3643 {
3644         if (!nss_wrapper_hosts_enabled()) {
3645                 libc_sethostent(stayopen);
3646                 return;
3647         }
3648
3649         nwrap_sethostent(stayopen);
3650 }
3651 #endif /* HAVE_SOLARIS_SETHOSTENT */
3652
3653 static struct hostent *nwrap_gethostent(void)
3654 {
3655         return nwrap_files_gethostent();
3656 }
3657
3658 struct hostent *gethostent(void) {
3659         if (!nss_wrapper_hosts_enabled()) {
3660                 return libc_gethostent();
3661         }
3662
3663         return nwrap_gethostent();
3664 }
3665
3666 static void nwrap_endhostent(void) {
3667         nwrap_files_endhostent();
3668 }
3669
3670 #ifdef HAVE_SOLARIS_ENDHOSTENT
3671 int endhostent(void)
3672 {
3673         if (!nss_wrapper_hosts_enabled()) {
3674                 libc_endhostent();
3675                 return 0;
3676         }
3677
3678         nwrap_endhostent();
3679
3680         return 0;
3681 }
3682 #else /* HAVE_SOLARIS_ENDHOSTENT */
3683 void endhostent(void)
3684 {
3685         if (!nss_wrapper_hosts_enabled()) {
3686                 libc_endhostent();
3687                 return;
3688         }
3689
3690         nwrap_endhostent();
3691 }
3692 #endif /* HAVE_SOLARIS_ENDHOSTENT */
3693
3694 static struct hostent *nwrap_gethostbyname(const char *name)
3695 {
3696         return nwrap_files_gethostbyname(name, AF_UNSPEC);
3697 }
3698
3699 struct hostent *gethostbyname(const char *name)
3700 {
3701         if (!nss_wrapper_hosts_enabled()) {
3702                 return libc_gethostbyname(name);
3703         }
3704
3705         return nwrap_gethostbyname(name);
3706 }
3707
3708 /* This is a GNU extension */
3709 #ifdef HAVE_GETHOSTBYNAME2
3710 static struct hostent *nwrap_gethostbyname2(const char *name, int af)
3711 {
3712         return nwrap_files_gethostbyname(name, af);
3713 }
3714
3715 struct hostent *gethostbyname2(const char *name, int af)
3716 {
3717         if (!nss_wrapper_hosts_enabled()) {
3718                 return libc_gethostbyname2(name, af);
3719         }
3720
3721         return nwrap_gethostbyname2(name, af);
3722 }
3723 #endif
3724
3725 static struct hostent *nwrap_gethostbyaddr(const void *addr,
3726                                            socklen_t len, int type)
3727 {
3728         return nwrap_files_gethostbyaddr(addr, len, type);
3729 }
3730
3731 struct hostent *gethostbyaddr(const void *addr,
3732                               socklen_t len, int type)
3733 {
3734         if (!nss_wrapper_hosts_enabled()) {
3735                 return libc_gethostbyaddr(addr, len, type);
3736         }
3737
3738         return nwrap_gethostbyaddr(addr, len, type);
3739 }
3740
3741 static const struct addrinfo default_hints =
3742 {
3743         .ai_flags = AI_ADDRCONFIG|AI_V4MAPPED,
3744         .ai_family = AF_UNSPEC,
3745         .ai_socktype = 0,
3746         .ai_protocol = 0,
3747         .ai_addrlen = 0,
3748         .ai_addr = NULL,
3749         .ai_canonname = NULL,
3750         .ai_next = NULL
3751 };
3752
3753 static int nwrap_convert_he_ai(const struct hostent *he,
3754                                unsigned short port,
3755                                const struct addrinfo *hints,
3756                                struct addrinfo **pai)
3757 {
3758         struct addrinfo *ai;
3759         socklen_t socklen;
3760
3761         switch (he->h_addrtype) {
3762                 case AF_INET:
3763                         socklen = sizeof(struct sockaddr_in);
3764                         break;
3765 #ifdef HAVE_IPV6
3766                 case AF_INET6:
3767                         socklen = sizeof(struct sockaddr_in6);
3768                         break;
3769 #endif
3770                 default:
3771                         return EAI_FAMILY;
3772         }
3773
3774         ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) + socklen);
3775         if (ai == NULL) {
3776                 return EAI_MEMORY;
3777         }
3778
3779         ai->ai_flags = 0;
3780         ai->ai_family = he->h_addrtype;
3781         ai->ai_socktype = hints->ai_socktype;
3782         ai->ai_protocol = hints->ai_protocol;
3783
3784         ai->ai_addrlen = socklen;
3785         ai->ai_addr = (void *)(ai + 1);
3786
3787 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
3788         ai->ai_addr->sa_len = socklen;
3789 #endif
3790         ai->ai_addr->sa_family = he->h_addrtype;
3791
3792         switch (he->h_addrtype) {
3793                 case AF_INET:
3794                 {
3795                         struct sockaddr_in *sinp =
3796                                 (struct sockaddr_in *) ai->ai_addr;
3797
3798                         memset(sinp, 0, sizeof(struct sockaddr_in));
3799
3800                         sinp->sin_port = htons(port);
3801                         sinp->sin_family = AF_INET;
3802
3803                         memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
3804                         memcpy(&sinp->sin_addr, he->h_addr_list[0], he->h_length);
3805
3806                 }
3807                 break;
3808 #ifdef HAVE_IPV6
3809                 case AF_INET6:
3810                 {
3811                         struct sockaddr_in6 *sin6p =
3812                                 (struct sockaddr_in6 *) ai->ai_addr;
3813
3814                         memset(sin6p, 0, sizeof(struct sockaddr_in6));
3815
3816                         sin6p->sin6_port = htons(port);
3817                         sin6p->sin6_family = AF_INET6;
3818
3819                         memcpy(&sin6p->sin6_addr, he->h_addr_list[0], he->h_length);
3820                 }
3821                 break;
3822 #endif
3823         }
3824
3825         ai->ai_next = NULL;
3826
3827         if (he->h_name) {
3828                 ai->ai_canonname = strdup(he->h_name);
3829                 if (ai->ai_canonname == NULL) {
3830                         freeaddrinfo(ai);
3831                         return EAI_MEMORY;
3832                 }
3833         }
3834
3835         *pai = ai;
3836         return 0;
3837 }
3838
3839 static int nwrap_getaddrinfo(const char *node,
3840                              const char *service,
3841                              const struct addrinfo *hints,
3842                              struct addrinfo **res)
3843 {
3844         struct addrinfo *ai = NULL;
3845         struct addrinfo *p = NULL;
3846         unsigned short port = 0;
3847         struct hostent *he;
3848         struct in_addr in;
3849         bool is_addr_ipv4 = false;
3850         bool is_addr_ipv6 = false;
3851         int eai = EAI_SYSTEM;
3852         int ret;
3853         int rc;
3854         int af;
3855
3856         if (node == NULL && service == NULL) {
3857                 return EAI_NONAME;
3858         }
3859
3860         ret = libc_getaddrinfo(node, service, hints, &p);
3861         if (ret == 0) {
3862                 *res = p;
3863         }
3864
3865         /* If no node has been specified, let glibc deal with it */
3866         if (node == NULL) {
3867                 return ret;
3868         }
3869
3870         if (hints == NULL) {
3871                 hints = &default_hints;
3872         }
3873
3874         if ((hints->ai_flags & AI_CANONNAME) && node == NULL) {
3875                 return EAI_BADFLAGS;
3876         }
3877
3878         if (service != NULL && service[0] != '\0') {
3879                 if (isdigit((int)service[0])) {
3880                         port = (unsigned short)atoi(service);
3881                 } else {
3882                         const char *proto = NULL;
3883                         struct servent *s;
3884
3885                         if (hints->ai_protocol != 0) {
3886                                 struct protoent *pent;
3887
3888                                 pent = getprotobynumber(hints->ai_protocol);
3889                                 if (pent != NULL) {
3890                                         proto = pent->p_name;
3891                                 }
3892                         }
3893
3894                         s = getservbyname(service, proto);
3895                         if (s != NULL) {
3896                                 port = ntohs(s->s_port);
3897                         } else {
3898                                 if (p != NULL) {
3899                                         freeaddrinfo(p);
3900                                 }
3901                                 return EAI_SERVICE;
3902                         }
3903                 }
3904         }
3905
3906         af = hints->ai_family;
3907         if (af == AF_UNSPEC) {
3908                 af = AF_INET;
3909         }
3910
3911         rc = inet_pton(af, node, &in);
3912         if (rc == 1) {
3913                 is_addr_ipv4 = true;
3914                 if (af == AF_UNSPEC) {
3915                         af = AF_INET;
3916                 }
3917 #ifdef HAVE_IPV6
3918         } else {
3919                 struct in6_addr in6;
3920
3921                 af = AF_INET6;
3922
3923                 rc = inet_pton(af, node, &in6);
3924                 if (rc == 1) {
3925                         is_addr_ipv6 = true;
3926                 }
3927 #endif
3928         }
3929
3930         if (is_addr_ipv4) {
3931                 he = nwrap_files_gethostbyaddr(&in, sizeof(struct in_addr), af);
3932                 if (he != NULL) {
3933                         rc = nwrap_convert_he_ai(he, port, hints, &ai);
3934                 } else {
3935                         eai = EAI_NODATA;
3936                         rc = -1;
3937                 }
3938 #ifdef HAVE_IPV6
3939         } else if (is_addr_ipv6) {
3940                 struct in6_addr in6;
3941
3942                 rc =  inet_pton(af, node, &in6);
3943                 if (rc <= 0) {
3944                         eai = EAI_ADDRFAMILY;
3945                         return ret == 0 ? 0 : eai;
3946                 }
3947
3948                 he = nwrap_files_gethostbyaddr(&in6,
3949                                                sizeof(struct in6_addr),
3950                                                af);
3951                 if (he != NULL) {
3952                         rc = nwrap_convert_he_ai(he, port, hints, &ai);
3953                         eai = rc;
3954                 } else {
3955                         eai = EAI_NODATA;
3956                         rc = -1;
3957                 }
3958 #endif
3959         } else {
3960                 he = nwrap_files_gethostbyname(node, hints->ai_family);
3961                 if (he != NULL) {
3962                         rc = nwrap_convert_he_ai(he, port, hints, &ai);
3963                         eai = rc;
3964                 } else {
3965                         eai = EAI_NODATA;
3966                         rc = -1;
3967                 }
3968         }
3969
3970         if (rc < 0) {
3971                 return ret == 0 ? 0 : eai;
3972         }
3973
3974         if (ret == 0) {
3975                 freeaddrinfo(p);
3976         }
3977
3978         if (ai->ai_flags == 0) {
3979                 ai->ai_flags = hints->ai_flags;
3980         }
3981         if (ai->ai_socktype == 0) {
3982                 ai->ai_socktype = SOCK_DGRAM;
3983         }
3984         if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_DGRAM) {
3985                 ai->ai_protocol = 17; /* UDP */
3986         } else if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_STREAM) {
3987                 ai->ai_protocol = 6; /* TCP */
3988         }
3989
3990         if (hints->ai_socktype == 0) {
3991                 /* Add second ai */
3992                 rc = nwrap_convert_he_ai(he, port, hints, &ai->ai_next);
3993                 if (rc < 0) {
3994                         freeaddrinfo(ai);
3995                         return rc;
3996                 }
3997
3998                 if (ai->ai_next->ai_flags == 0) {
3999                         ai->ai_next->ai_flags = hints->ai_flags;
4000                 }
4001                 if (ai->ai_socktype == SOCK_DGRAM) {
4002                         ai->ai_next->ai_socktype = SOCK_STREAM;
4003                 } else if (ai->ai_socktype == SOCK_STREAM) {
4004                         ai->ai_next->ai_socktype = SOCK_DGRAM;
4005                 }
4006                 if (ai->ai_next->ai_socktype == SOCK_DGRAM) {
4007                         ai->ai_next->ai_protocol = 17; /* UDP */
4008                 } else if (ai->ai_next->ai_socktype == SOCK_STREAM) {
4009                         ai->ai_next->ai_protocol = 6; /* TCP */
4010                 }
4011         }
4012
4013         *res = ai;
4014
4015         return 0;
4016 }
4017
4018 int getaddrinfo(const char *node, const char *service,
4019                 const struct addrinfo *hints,
4020                 struct addrinfo **res)
4021 {
4022         if (!nss_wrapper_hosts_enabled()) {
4023                 return libc_getaddrinfo(node, service, hints, res);
4024         }
4025
4026         return nwrap_getaddrinfo(node, service, hints, res);
4027 }
4028
4029 static int nwrap_getnameinfo(const struct sockaddr *sa, socklen_t salen,
4030                              char *host, size_t hostlen,
4031                              char *serv, size_t servlen,
4032                              int flags)
4033 {
4034         struct hostent *he;
4035         struct servent *service;
4036         const char *proto;
4037         const void *addr;
4038         socklen_t addrlen;
4039         uint16_t port;
4040         sa_family_t type;
4041
4042         if (sa == NULL || salen < sizeof(sa_family_t)) {
4043                 return EAI_FAMILY;
4044         }
4045
4046         if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL) {
4047                 return EAI_NONAME;
4048         }
4049
4050         type = sa->sa_family;
4051         switch (type) {
4052         case AF_INET:
4053                 if (salen < sizeof(struct sockaddr_in))
4054                         return EAI_FAMILY;
4055                 addr = &((struct sockaddr_in *)sa)->sin_addr;
4056                 addrlen = sizeof(((struct sockaddr_in *)sa)->sin_addr);
4057                 port = ntohs(((struct sockaddr_in *)sa)->sin_port);
4058                 break;
4059 #ifdef HAVE_IPV6
4060         case AF_INET6:
4061                 if (salen < sizeof(struct sockaddr_in6))
4062                         return EAI_FAMILY;
4063                 addr = &((struct sockaddr_in6 *)sa)->sin6_addr;
4064                 addrlen = sizeof(((struct sockaddr_in6 *)sa)->sin6_addr);
4065                 port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
4066                 break;
4067 #endif
4068         default:
4069                 return EAI_FAMILY;
4070         }
4071
4072         if (host != NULL) {
4073                 he = NULL;
4074                 if ((flags & NI_NUMERICHOST) == 0) {
4075                         he = nwrap_files_gethostbyaddr(addr, addrlen, type);
4076                         if ((flags & NI_NAMEREQD) && (he == NULL || he->h_name == NULL))
4077                                 return EAI_NONAME;
4078                 }
4079                 if (he != NULL && he->h_name != NULL) {
4080                         if (strlen(he->h_name) >= hostlen)
4081                                 return EAI_OVERFLOW;
4082                         strcpy(host, he->h_name);
4083                         if (flags & NI_NOFQDN)
4084                                 host[strcspn(host, ".")] = '\0';
4085                 } else {
4086                         if (inet_ntop(type, addr, host, hostlen) == NULL)
4087                                 return (errno == ENOSPC) ? EAI_OVERFLOW : EAI_FAIL;
4088                 }
4089         }
4090
4091         if (serv != NULL) {
4092                 service = NULL;
4093                 if ((flags & NI_NUMERICSERV) == 0) {
4094                         proto = (flags & NI_DGRAM) ? "udp" : "tcp";
4095                         service = getservbyport(htons(port), proto);
4096                 }
4097                 if (service != NULL) {
4098                         if (strlen(service->s_name) >= servlen)
4099                                 return EAI_OVERFLOW;
4100                         strcpy(serv, service->s_name);
4101                 } else {
4102                         if (snprintf(serv, servlen, "%u", port) >= (int) servlen)
4103                                 return EAI_OVERFLOW;
4104                 }
4105         }
4106
4107         return 0;
4108 }
4109
4110 #ifdef HAVE_LINUX_GETNAMEINFO
4111 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
4112                 char *host, socklen_t hostlen,
4113                 char *serv, socklen_t servlen,
4114                 int flags)
4115 #elif defined(HAVE_LINUX_GETNAMEINFO_UNSIGNED)
4116 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
4117                 char *host, socklen_t hostlen,
4118                 char *serv, socklen_t servlen,
4119                 unsigned int flags)
4120 #else
4121 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
4122                 char *host, size_t hostlen,
4123                 char *serv, size_t servlen,
4124                 int flags)
4125 #endif
4126 {
4127         if (!nss_wrapper_hosts_enabled()) {
4128                 return libc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
4129         }
4130
4131         return nwrap_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
4132 }
4133
4134 static int nwrap_gethostname(char *name, size_t len)
4135 {
4136         const char *hostname = getenv("NSS_WRAPPER_HOSTNAME");
4137
4138         if (strlen(hostname) >= len) {
4139                 errno = ENAMETOOLONG;
4140                 return -1;
4141         }
4142         snprintf(name, len, "%s", hostname);
4143
4144         return 0;
4145 }
4146
4147 #ifdef HAVE_SOLARIS_GETHOSTNAME
4148 int gethostname(char *name, int len)
4149 #else /* HAVE_SOLARIS_GETHOSTNAME */
4150 int gethostname(char *name, size_t len)
4151 #endif /* HAVE_SOLARIS_GETHOSTNAME */
4152 {
4153         if (!nwrap_hostname_enabled()) {
4154                 return libc_gethostname(name, len);
4155         }
4156
4157         return nwrap_gethostname(name, len);
4158 }
4159
4160 /****************************
4161  * DESTRUCTOR
4162  ***************************/
4163
4164 /*
4165  * This function is called when the library is unloaded and makes sure that
4166  * sockets get closed and the unix file for the socket are unlinked.
4167  */
4168 void nwrap_destructor(void)
4169 {
4170         int i;
4171
4172         if (nwrap_main_global != NULL) {
4173                 struct nwrap_main *m = nwrap_main_global;
4174
4175                 /* libc */
4176                 SAFE_FREE(m->libc->fns);
4177                 if (m->libc->handle != NULL) {
4178                         dlclose(m->libc->handle);
4179                 }
4180                 if (m->libc->nsl_handle != NULL) {
4181                         dlclose(m->libc->nsl_handle);
4182                 }
4183                 if (m->libc->sock_handle != NULL) {
4184                         dlclose(m->libc->sock_handle);
4185                 }
4186                 SAFE_FREE(m->libc);
4187
4188                 /* backends */
4189                 for (i = 0; i < m->num_backends; i++) {
4190                         struct nwrap_backend *b = &(m->backends[i]);
4191
4192                         if (b->so_handle != NULL) {
4193                                 dlclose(b->so_handle);
4194                         }
4195                         SAFE_FREE(b->fns);
4196                 }
4197                 SAFE_FREE(m->backends);
4198         }
4199
4200         if (nwrap_pw_global.cache != NULL) {
4201                 struct nwrap_cache *c = nwrap_pw_global.cache;
4202
4203                 nwrap_files_cache_unload(c);
4204                 if (c->fd >= 0) {
4205                         close(c->fd);
4206                 }
4207
4208                 SAFE_FREE(nwrap_pw_global.list);
4209                 nwrap_pw_global.num = 0;
4210         }
4211
4212         if (nwrap_gr_global.cache != NULL) {
4213                 struct nwrap_cache *c = nwrap_gr_global.cache;
4214
4215                 nwrap_files_cache_unload(c);
4216                 if (c->fd >= 0) {
4217                         close(c->fd);
4218                 }
4219
4220                 SAFE_FREE(nwrap_gr_global.list);
4221                 nwrap_pw_global.num = 0;
4222         }
4223
4224         if (nwrap_he_global.cache != NULL) {
4225                 struct nwrap_cache *c = nwrap_he_global.cache;
4226
4227                 nwrap_files_cache_unload(c);
4228                 if (c->fd >= 0) {
4229                         close(c->fd);
4230                 }
4231
4232                 SAFE_FREE(nwrap_he_global.list);
4233                 nwrap_he_global.num = 0;
4234         }
4235 }