src/nss_wrapper.c

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