lib/nss_wrapper/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         /* Maybe it's little bit late ... */
2631         assert(ed != NULL);
2632         assert(h_name != NULL);
2633
2634         e.key = h_name;
2635         e.data = NULL;
2636         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
2637         p = hsearch(e, FIND);
2638         if (p == NULL) {
2639                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name);
2640                 /* Just add alias and don't mess with metadata */
2641                 nwrap_add_hname_add_new(h_name, ed);
2642
2643                 if (ed->ed_tail == NULL) {
2644                         ed->ed_tail = ed;
2645                 }
2646         } else {
2647                 /* Element found. Add them to end of list */
2648                 struct nwrap_entdata *ed_dst = (struct nwrap_entdata *)p->data;
2649
2650                 assert(p->data != NULL);
2651                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name);
2652                 nwrap_add_hname_add_to_existing(ed, ed_dst);
2653         }
2654
2655         /* Return true when list of aliases is empty */
2656         if (ed->ht.h_aliases == NULL) {
2657                 return true;
2658         }
2659
2660         /* Itemize aliases */
2661         for (i = 0; ed->ht.h_aliases[i] != NULL; ++i) {
2662                 char *h_name_alias;
2663
2664                 h_name_alias = ed->ht.h_aliases[i];
2665                 assert(h_name_alias != NULL);
2666
2667                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Add alias: %s", h_name_alias);
2668
2669                 if (!nwrap_add_hname_alias(h_name_alias, ed)) {
2670                         NWRAP_LOG(NWRAP_LOG_DEBUG,
2671                                   "Unable to add alias: %s", h_name_alias);
2672                 }
2673         }
2674
2675         return true;
2676 }
2677
2678 static bool nwrap_he_parse_line(struct nwrap_cache *nwrap, char *line)
2679 {
2680         struct nwrap_he *nwrap_he = (struct nwrap_he *)nwrap->private_data;
2681         bool do_aliases = true;
2682         ssize_t aliases_count = 0;
2683         char *p;
2684         char *i;
2685         char *n;
2686
2687         char *ip;
2688
2689         struct nwrap_entdata *ed = (struct nwrap_entdata *)
2690                                    malloc(sizeof(struct nwrap_entdata));
2691         if (ed == NULL) {
2692                 NWRAP_LOG(NWRAP_LOG_ERROR,
2693                           "Unable to allocate memory for nwrap_entdata");
2694                 return false;
2695         }
2696         ZERO_STRUCTP(ed);
2697
2698         i = line;
2699
2700         /*
2701          * IP
2702          */
2703
2704         /* Walk to first char */
2705         for (p = i; *p != '.' && *p != ':' && !isxdigit((int) *p); p++) {
2706                 if (*p == '\0') {
2707                         NWRAP_LOG(NWRAP_LOG_ERROR,
2708                                   "Invalid line[%s]: '%s'",
2709                                   line, i);
2710                         free(ed);
2711                         return false;
2712                 }
2713         }
2714
2715         for (i = p; !isspace((int)*p); p++) {
2716                 if (*p == '\0') {
2717                         NWRAP_LOG(NWRAP_LOG_ERROR,
2718                                   "Invalid line[%s]: '%s'",
2719                                   line, i);
2720                         free(ed);
2721                         return false;
2722                 }
2723         }
2724
2725         *p = '\0';
2726
2727         if (inet_pton(AF_INET, i, ed->addr.host_addr)) {
2728                 ed->ht.h_addrtype = AF_INET;
2729                 ed->ht.h_length = 4;
2730 #ifdef HAVE_IPV6
2731         } else if (inet_pton(AF_INET6, i, ed->addr.host_addr)) {
2732                 ed->ht.h_addrtype = AF_INET6;
2733                 ed->ht.h_length = 16;
2734 #endif
2735         } else {
2736                 NWRAP_LOG(NWRAP_LOG_ERROR,
2737                           "Invalid line[%s]: '%s'",
2738                           line, i);
2739
2740                 free(ed);
2741                 return false;
2742         }
2743         ip = i;
2744
2745         nwrap_vector_add_item(&(ed->nwrap_addrdata),
2746                               (void *const)ed->addr.host_addr);
2747         ed->ht.h_addr_list = nwrap_vector_head(&ed->nwrap_addrdata);
2748
2749         p++;
2750
2751         /*
2752          * FQDN
2753          */
2754
2755         /* Walk to first char */
2756         for (n = p; *p != '_' && !isalnum((int) *p); p++) {
2757                 if (*p == '\0') {
2758                         NWRAP_LOG(NWRAP_LOG_ERROR,
2759                                   "Invalid line[%s]: '%s'",
2760                                   line, n);
2761
2762                         free(ed);
2763                         return false;
2764                 }
2765         }
2766
2767         for (n = p; !isspace((int)*p); p++) {
2768                 if (*p == '\0') {
2769                         do_aliases = false;
2770                         break;
2771                 }
2772         }
2773
2774         *p = '\0';
2775
2776         /* Convert to lowercase. This operate on same memory region */
2777         str_tolower(n, n);
2778         ed->ht.h_name = n;
2779
2780         /* glib's getent always dereferences he->h_aliases */
2781         ed->ht.h_aliases = malloc(sizeof(char *));
2782         if (ed->ht.h_aliases == NULL) {
2783                 free(ed);
2784                 return false;
2785         }
2786         ed->ht.h_aliases[0] = NULL;
2787
2788         /*
2789          * Aliases
2790          */
2791         while (do_aliases) {
2792                 char **aliases;
2793                 char *a;
2794
2795                 p++;
2796
2797                 /* Walk to first char */
2798                 for (a = p; *p != '_' && !isalnum((int) *p); p++) {
2799                         if (*p == '\0') {
2800                                 do_aliases = false;
2801                                 break;
2802                         }
2803                 }
2804                 /* Only trailing spaces are left */
2805                 if (!do_aliases) {
2806                         break;
2807                 }
2808
2809                 for (a = p; !isspace((int)*p); p++) {
2810                         if (*p == '\0') {
2811                                 do_aliases = false;
2812                                 break;
2813                         }
2814                 }
2815
2816                 *p = '\0';
2817
2818                 aliases = realloc(ed->ht.h_aliases, sizeof(char *) * (aliases_count + 2));
2819                 if (aliases == NULL) {
2820                         free(ed);
2821                         return false;
2822                 }
2823                 ed->ht.h_aliases = aliases;
2824
2825                 str_tolower(a, a);
2826                 aliases[aliases_count] = a;
2827                 aliases[aliases_count + 1] = NULL;
2828
2829                 aliases_count += 1;
2830         }
2831
2832         nwrap_vector_add_item(&(nwrap_he->entdata), (void *const)ed);
2833
2834         ed->aliases_count = aliases_count;
2835         /* Inventarize item */
2836         nwrap_add_hname(ed);
2837         nwrap_add_ai(ip, ed);
2838
2839         nwrap_he->num++;
2840         return true;
2841 }
2842
2843 static void nwrap_he_unload(struct nwrap_cache *nwrap)
2844 {
2845         struct nwrap_he *nwrap_he =
2846                 (struct nwrap_he *)nwrap->private_data;
2847         struct nwrap_entdata *ed;
2848         size_t i;
2849
2850         nwrap_vector_foreach (ed, nwrap_he->entdata, i)
2851         {
2852                 SAFE_FREE(ed->nwrap_addrdata.items);
2853                 SAFE_FREE(ed->ht.h_aliases);
2854                 SAFE_FREE(ed);
2855         }
2856         SAFE_FREE(nwrap_he->entdata.items);
2857         nwrap_he->entdata.count = nwrap_he->entdata.capacity = 0;
2858
2859         nwrap_he->num = 0;
2860         nwrap_he->idx = 0;
2861 }
2862
2863
2864 /* user functions */
2865 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
2866                                            const char *name)
2867 {
2868         int i;
2869
2870         (void) b; /* unused */
2871
2872         NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
2873
2874         nwrap_files_cache_reload(nwrap_pw_global.cache);
2875
2876         for (i=0; i<nwrap_pw_global.num; i++) {
2877                 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
2878                         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
2879                         return &nwrap_pw_global.list[i];
2880                 }
2881                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2882                           "user[%s] does not match [%s]",
2883                           name,
2884                           nwrap_pw_global.list[i].pw_name);
2885         }
2886
2887         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
2888
2889         errno = ENOENT;
2890         return NULL;
2891 }
2892
2893 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
2894                                   const char *name, struct passwd *pwdst,
2895                                   char *buf, size_t buflen, struct passwd **pwdstp)
2896 {
2897         struct passwd *pw;
2898
2899         pw = nwrap_files_getpwnam(b, name);
2900         if (!pw) {
2901                 if (errno == 0) {
2902                         return ENOENT;
2903                 }
2904                 return errno;
2905         }
2906
2907         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2908 }
2909
2910 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
2911                                            uid_t uid)
2912 {
2913         int i;
2914
2915         (void) b; /* unused */
2916
2917         nwrap_files_cache_reload(nwrap_pw_global.cache);
2918
2919         for (i=0; i<nwrap_pw_global.num; i++) {
2920                 if (nwrap_pw_global.list[i].pw_uid == uid) {
2921                         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] found", uid);
2922                         return &nwrap_pw_global.list[i];
2923                 }
2924                 NWRAP_LOG(NWRAP_LOG_DEBUG,
2925                           "uid[%u] does not match [%u]",
2926                           uid,
2927                           nwrap_pw_global.list[i].pw_uid);
2928         }
2929
2930         NWRAP_LOG(NWRAP_LOG_DEBUG, "uid[%u] not found\n", uid);
2931
2932         errno = ENOENT;
2933         return NULL;
2934 }
2935
2936 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
2937                                   uid_t uid, struct passwd *pwdst,
2938                                   char *buf, size_t buflen, struct passwd **pwdstp)
2939 {
2940         struct passwd *pw;
2941
2942         pw = nwrap_files_getpwuid(b, uid);
2943         if (!pw) {
2944                 if (errno == 0) {
2945                         return ENOENT;
2946                 }
2947                 return errno;
2948         }
2949
2950         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
2951 }
2952
2953 /* user enum functions */
2954 static void nwrap_files_setpwent(struct nwrap_backend *b)
2955 {
2956         (void) b; /* unused */
2957
2958         nwrap_pw_global.idx = 0;
2959 }
2960
2961 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
2962 {
2963         struct passwd *pw;
2964
2965         (void) b; /* unused */
2966
2967         if (nwrap_pw_global.idx == 0) {
2968                 nwrap_files_cache_reload(nwrap_pw_global.cache);
2969         }
2970
2971         if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
2972                 errno = ENOENT;
2973                 return NULL;
2974         }
2975
2976         pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
2977
2978         NWRAP_LOG(NWRAP_LOG_DEBUG,
2979                   "return user[%s] uid[%u]",
2980                   pw->pw_name, pw->pw_uid);
2981
2982         return pw;
2983 }
2984
2985 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
2986                                   struct passwd *pwdst, char *buf,
2987                                   size_t buflen, struct passwd **pwdstp)
2988 {
2989         struct passwd *pw;
2990
2991         pw = nwrap_files_getpwent(b);
2992         if (!pw) {
2993                 if (errno == 0) {
2994                         return ENOENT;
2995                 }
2996                 return errno;
2997         }
2998
2999         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
3000 }
3001
3002 static void nwrap_files_endpwent(struct nwrap_backend *b)
3003 {
3004         (void) b; /* unused */
3005
3006         nwrap_pw_global.idx = 0;
3007 }
3008
3009 /* shadow */
3010
3011 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
3012
3013 #ifdef HAVE_SETSPENT
3014 static void nwrap_files_setspent(void)
3015 {
3016         nwrap_sp_global.idx = 0;
3017 }
3018
3019 static struct spwd *nwrap_files_getspent(void)
3020 {
3021         struct spwd *sp;
3022
3023         if (nwrap_sp_global.idx == 0) {
3024                 nwrap_files_cache_reload(nwrap_sp_global.cache);
3025         }
3026
3027         if (nwrap_sp_global.idx >= nwrap_sp_global.num) {
3028                 errno = ENOENT;
3029                 return NULL;
3030         }
3031
3032         sp = &nwrap_sp_global.list[nwrap_sp_global.idx++];
3033
3034         NWRAP_LOG(NWRAP_LOG_DEBUG,
3035                   "return user[%s]",
3036                   sp->sp_namp);
3037
3038         return sp;
3039 }
3040
3041 static void nwrap_files_endspent(void)
3042 {
3043         nwrap_sp_global.idx = 0;
3044 }
3045 #endif /* HAVE_SETSPENT */
3046
3047 static struct spwd *nwrap_files_getspnam(const char *name)
3048 {
3049         int i;
3050
3051         NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
3052
3053         nwrap_files_cache_reload(nwrap_sp_global.cache);
3054
3055         for (i=0; i<nwrap_sp_global.num; i++) {
3056                 if (strcmp(nwrap_sp_global.list[i].sp_namp, name) == 0) {
3057                         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] found", name);
3058                         return &nwrap_sp_global.list[i];
3059                 }
3060                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3061                           "user[%s] does not match [%s]",
3062                           name,
3063                           nwrap_sp_global.list[i].sp_namp);
3064         }
3065
3066         NWRAP_LOG(NWRAP_LOG_DEBUG, "user[%s] not found\n", name);
3067
3068         errno = ENOENT;
3069         return NULL;
3070 }
3071 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
3072
3073 /* misc functions */
3074 static int nwrap_files_initgroups(struct nwrap_backend *b,
3075                                   const char *user,
3076                                   gid_t group)
3077 {
3078         struct group *grp;
3079         gid_t *groups;
3080         int size = 1;
3081         int rc;
3082
3083         groups = (gid_t *)malloc(size * sizeof(gid_t));
3084         if (groups == NULL) {
3085                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
3086                 errno = ENOMEM;
3087                 return -1;
3088         }
3089         groups[0] = group;
3090
3091         nwrap_files_setgrent(b);
3092         while ((grp = nwrap_files_getgrent(b)) != NULL) {
3093                 int i = 0;
3094
3095                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3096                           "Inspecting %s for group membership",
3097                           grp->gr_name);
3098
3099                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
3100                         if (group != grp->gr_gid &&
3101                             (strcmp(user, grp->gr_mem[i]) == 0)) {
3102                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3103                                           "%s is member of %s",
3104                                           user,
3105                                           grp->gr_name);
3106
3107                                 groups = (gid_t *)realloc(groups,
3108                                                           (size + 1) * sizeof(gid_t));
3109                                 if (groups == NULL) {
3110                                         NWRAP_LOG(NWRAP_LOG_ERROR,
3111                                                   "Out of memory");
3112                                         errno = ENOMEM;
3113                                         return -1;
3114                                 }
3115
3116                                 groups[size] = grp->gr_gid;
3117                                 size++;
3118                         }
3119                 }
3120         }
3121
3122         nwrap_files_endgrent(b);
3123
3124         NWRAP_LOG(NWRAP_LOG_DEBUG,
3125                   "%s is member of %d groups",
3126                   user, size);
3127
3128         /* This really only works if uid_wrapper is loaded */
3129         rc = setgroups(size, groups);
3130
3131         free(groups);
3132
3133         return rc;
3134 }
3135
3136 /* group functions */
3137 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
3138                                           const char *name)
3139 {
3140         int i;
3141
3142         (void) b; /* unused */
3143
3144         nwrap_files_cache_reload(nwrap_gr_global.cache);
3145
3146         for (i=0; i<nwrap_gr_global.num; i++) {
3147                 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
3148                         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] found", name);
3149                         return &nwrap_gr_global.list[i];
3150                 }
3151                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3152                           "group[%s] does not match [%s]",
3153                           name,
3154                           nwrap_gr_global.list[i].gr_name);
3155         }
3156
3157         NWRAP_LOG(NWRAP_LOG_DEBUG, "group[%s] not found", name);
3158
3159         errno = ENOENT;
3160         return NULL;
3161 }
3162
3163 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
3164                                   const char *name, struct group *grdst,
3165                                   char *buf, size_t buflen, struct group **grdstp)
3166 {
3167         struct group *gr;
3168
3169         gr = nwrap_files_getgrnam(b, name);
3170         if (!gr) {
3171                 if (errno == 0) {
3172                         return ENOENT;
3173                 }
3174                 return errno;
3175         }
3176
3177         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3178 }
3179
3180 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
3181                                           gid_t gid)
3182 {
3183         int i;
3184
3185         (void) b; /* unused */
3186
3187         nwrap_files_cache_reload(nwrap_gr_global.cache);
3188
3189         for (i=0; i<nwrap_gr_global.num; i++) {
3190                 if (nwrap_gr_global.list[i].gr_gid == gid) {
3191                         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] found", gid);
3192                         return &nwrap_gr_global.list[i];
3193                 }
3194                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3195                           "gid[%u] does not match [%u]",
3196                           gid,
3197                           nwrap_gr_global.list[i].gr_gid);
3198         }
3199
3200         NWRAP_LOG(NWRAP_LOG_DEBUG, "gid[%u] not found", gid);
3201
3202         errno = ENOENT;
3203         return NULL;
3204 }
3205
3206 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
3207                                   gid_t gid, struct group *grdst,
3208                                   char *buf, size_t buflen, struct group **grdstp)
3209 {
3210         struct group *gr;
3211
3212         gr = nwrap_files_getgrgid(b, gid);
3213         if (!gr) {
3214                 if (errno == 0) {
3215                         return ENOENT;
3216                 }
3217                 return errno;
3218         }
3219
3220         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3221 }
3222
3223 /* group enum functions */
3224 static void nwrap_files_setgrent(struct nwrap_backend *b)
3225 {
3226         (void) b; /* unused */
3227
3228         nwrap_gr_global.idx = 0;
3229 }
3230
3231 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
3232 {
3233         struct group *gr;
3234
3235         (void) b; /* unused */
3236
3237         if (nwrap_gr_global.idx == 0) {
3238                 nwrap_files_cache_reload(nwrap_gr_global.cache);
3239         }
3240
3241         if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
3242                 errno = ENOENT;
3243                 return NULL;
3244         }
3245
3246         gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
3247
3248         NWRAP_LOG(NWRAP_LOG_DEBUG,
3249                   "return group[%s] gid[%u]",
3250                   gr->gr_name, gr->gr_gid);
3251
3252         return gr;
3253 }
3254
3255 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
3256                                   struct group *grdst, char *buf,
3257                                   size_t buflen, struct group **grdstp)
3258 {
3259         struct group *gr;
3260
3261         gr = nwrap_files_getgrent(b);
3262         if (!gr) {
3263                 if (errno == 0) {
3264                         return ENOENT;
3265                 }
3266                 return errno;
3267         }
3268
3269         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
3270 }
3271
3272 static void nwrap_files_endgrent(struct nwrap_backend *b)
3273 {
3274         (void) b; /* unused */
3275
3276         nwrap_gr_global.idx = 0;
3277 }
3278
3279 /* hosts functions */
3280 static int nwrap_files_gethostbyname(const char *name, int af,
3281                                      struct hostent *result,
3282                                      struct nwrap_vector *addr_list)
3283 {
3284         struct nwrap_entdata *ed_head;
3285         struct nwrap_entdata *ed_cur;
3286         struct hostent *he;
3287         char *h_name_lower;
3288         ENTRY e;
3289         ENTRY *e_p;
3290         char canon_name[DNS_NAME_MAX] = { 0 };
3291         size_t name_len;
3292         bool he_found = false;
3293
3294         nwrap_files_cache_reload(nwrap_he_global.cache);
3295
3296         name_len = strlen(name);
3297         if (name_len < sizeof(canon_name) && name[name_len - 1] == '.') {
3298                 strncpy(canon_name, name, name_len - 1);
3299                 name = canon_name;
3300         }
3301
3302         if (!str_tolower_copy(&h_name_lower, name)) {
3303                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3304                           "Out of memory while converting to lower case");
3305                 goto no_ent;
3306         }
3307
3308         /* Look at hash table for element */
3309         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3310         e.key = h_name_lower;
3311         e.data = NULL;
3312         e_p = hsearch(e, FIND);
3313         if (e_p == NULL) {
3314                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3315                 SAFE_FREE(h_name_lower);
3316                 goto no_ent;
3317         }
3318         SAFE_FREE(h_name_lower);
3319
3320         /* Always cleanup vector and results */
3321         if (!nwrap_vector_is_initialized(addr_list)) {
3322                 if (!nwrap_vector_init(addr_list)) {
3323                         NWRAP_LOG(NWRAP_LOG_DEBUG,
3324                                   "Unable to initialize memory for addr_list vector");
3325                         goto no_ent;
3326                 }
3327         } else {
3328                 /* When vector is initialized data are valid no more.
3329                  * Quick way how to free vector is: */
3330                 addr_list->count = 0;
3331         }
3332
3333         /* Iterate through results */
3334         ed_head = (struct nwrap_entdata *)e_p->data;
3335         for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
3336                 he = &(ed_cur->ht);
3337
3338                 /* Filter by address familiy if provided */
3339                 if (af != AF_UNSPEC && he->h_addrtype != af) {
3340                         continue;
3341                 }
3342
3343                 /*
3344                  * GLIBC HACK?
3345                  * glibc doesn't return ipv6 addresses when AF_UNSPEC is used
3346                  */
3347                 if (af == AF_UNSPEC && he->h_addrtype != AF_INET) {
3348                         continue;
3349                 }
3350
3351                 if (!he_found) {
3352                         memcpy(result, he, sizeof(struct hostent));
3353                         NWRAP_LOG(NWRAP_LOG_DEBUG,
3354                                   "Name found. Returning record for %s",
3355                                   he->h_name);
3356                         he_found = true;
3357                 }
3358                 nwrap_vector_merge(addr_list, &ed_cur->nwrap_addrdata);
3359                 result->h_addr_list = nwrap_vector_head(addr_list);
3360         }
3361
3362         if (he_found) {
3363                 return 0;
3364         }
3365         NWRAP_LOG(NWRAP_LOG_DEBUG,
3366                   "Name found in database. No records matches type.");
3367
3368 no_ent:
3369         errno = ENOENT;
3370         return -1;
3371 }
3372
3373 #ifdef HAVE_GETHOSTBYNAME_R
3374 static int nwrap_gethostbyname_r(const char *name,
3375                                  struct hostent *ret,
3376                                  char *buf, size_t buflen,
3377                                  struct hostent **result, int *h_errnop)
3378 {
3379         struct nwrap_vector *addr_list = malloc(sizeof(struct nwrap_vector));
3380         int rc;
3381
3382         if (addr_list == NULL) {
3383                 NWRAP_LOG(NWRAP_LOG_ERROR,
3384                           "Unable to allocate memory for address list");
3385                 errno = ENOENT;
3386                 return -1;
3387         }
3388
3389         ZERO_STRUCTP(addr_list);
3390
3391         rc = nwrap_files_gethostbyname(name, AF_UNSPEC, ret, addr_list);
3392         if (rc == -1) {
3393                 *h_errnop = h_errno;
3394                 if (addr_list->items != NULL) {
3395                         free(addr_list->items);
3396                 }
3397                 SAFE_FREE(addr_list);
3398                 errno = ENOENT;
3399                 return -1;
3400         }
3401
3402         if (buflen < (addr_list->count * sizeof(void *))) {
3403                 SAFE_FREE(addr_list->items);
3404                 SAFE_FREE(addr_list);
3405                 return ERANGE;
3406         }
3407
3408         /* Copy all to user provided buffer and change
3409          * pointers in returned structure.
3410          * +1 is for ending NULL pointer. */
3411         memcpy(buf, addr_list->items, (addr_list->count + 1) * sizeof(void *));
3412
3413         free(addr_list->items);
3414         free(addr_list);
3415
3416         ret->h_addr_list = (char **)buf;
3417         *result = ret;
3418         return 0;
3419 }
3420
3421 int gethostbyname_r(const char *name,
3422                     struct hostent *ret,
3423                     char *buf, size_t buflen,
3424                     struct hostent **result, int *h_errnop)
3425 {
3426         if (!nss_wrapper_hosts_enabled()) {
3427                 return libc_gethostbyname_r(name,
3428                                             ret,
3429                                             buf,
3430                                             buflen,
3431                                             result,
3432                                             h_errnop);
3433         }
3434
3435         return nwrap_gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
3436 }
3437 #endif
3438
3439 static struct addrinfo *nwrap_files_getaddrinfo(const char *name,
3440                                                 unsigned short port,
3441                                                 const struct addrinfo *hints,
3442                                                 struct addrinfo **ai_tail)
3443 {
3444         struct nwrap_entdata *ed_head;
3445         struct nwrap_entdata *ed_cur;
3446         struct hostent *he;
3447         struct addrinfo *ai = NULL;
3448         struct addrinfo *ai_head = NULL;
3449         struct addrinfo *ai_prev = NULL;
3450         char *h_name_lower;
3451         size_t name_len;
3452         char canon_name[DNS_NAME_MAX] = { 0 };
3453         bool skip_canonname = false;
3454         ENTRY e = { 0 };
3455         ENTRY *e_p = NULL;
3456
3457         nwrap_files_cache_reload(nwrap_he_global.cache);
3458
3459         name_len = strlen(name);
3460         if (name_len < DNS_NAME_MAX && name[name_len - 1] == '.') {
3461                 strncpy(canon_name, name, name_len - 1);
3462                 name = canon_name;
3463         }
3464
3465         if (!str_tolower_copy(&h_name_lower, name)) {
3466                 NWRAP_LOG(NWRAP_LOG_DEBUG,
3467                           "Out of memory while converting to lower case");
3468                 return NULL;
3469         }
3470
3471         NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
3472         e.key = h_name_lower;
3473         e.data = NULL;
3474         e_p = hsearch(e, FIND);
3475         if (e_p == NULL) {
3476                 NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
3477                 SAFE_FREE(h_name_lower);
3478                 errno = ENOENT;
3479                 return NULL;
3480         }
3481         NWRAP_LOG(NWRAP_LOG_DEBUG, "Name: %s found.", h_name_lower);
3482         SAFE_FREE(h_name_lower);
3483
3484         ed_head = (struct nwrap_entdata *)e_p->data;
3485
3486         for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
3487                 int rc;
3488
3489                 he = &(ed_cur->ht);
3490
3491                 if (hints->ai_family != AF_UNSPEC &&
3492                     he->h_addrtype != hints->ai_family) {
3493                         continue;
3494                 }
3495
3496                 /* Function allocates memory and returns it in ai. */
3497                 rc = nwrap_convert_he_ai(he,
3498                                          port,
3499                                          hints,
3500                                          &ai,
3501                                          skip_canonname);
3502                 if (rc != 0) {
3503                         /* FIXME: Investigate if this is nice to do... */
3504                         NWRAP_LOG(NWRAP_LOG_ERROR,
3505                                   "Error in converting he to ai! Skipping.");
3506                         continue;
3507                 }
3508                 skip_canonname = true;
3509
3510                 if (ai_head == NULL) {
3511                         ai_head = ai;
3512                 }
3513                 if (ai_prev != NULL) {
3514                         ai_prev->ai_next = ai;
3515                 }
3516                 ai_prev = ai;
3517         }
3518
3519         *ai_tail = ai;
3520         return ai_head;
3521 }
3522
3523 static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
3524                                                  socklen_t len, int type)
3525 {
3526         struct hostent *he;
3527         char ip[NWRAP_INET_ADDRSTRLEN] = {0};
3528         struct nwrap_entdata *ed;
3529         const char *a;
3530         size_t i;
3531
3532         (void) len; /* unused */
3533
3534         nwrap_files_cache_reload(nwrap_he_global.cache);
3535
3536         a = inet_ntop(type, addr, ip, sizeof(ip));
3537         if (a == NULL) {
3538                 errno = EINVAL;
3539                 return NULL;
3540         }
3541
3542         nwrap_vector_foreach(ed, nwrap_he_global.entdata, i)
3543         {
3544                 he = &(ed->ht);
3545                 if (he->h_addrtype != type) {
3546                         continue;
3547                 }
3548
3549                 if (memcmp(addr, he->h_addr_list[0], he->h_length) == 0) {
3550                         return he;
3551                 }
3552         }
3553
3554         errno = ENOENT;
3555         return NULL;
3556 }
3557
3558 #ifdef HAVE_GETHOSTBYADDR_R
3559 static int nwrap_gethostbyaddr_r(const void *addr, socklen_t len, int type,
3560                                  struct hostent *ret,
3561                                  char *buf, size_t buflen,
3562                                  struct hostent **result, int *h_errnop)
3563 {
3564         *result = nwrap_files_gethostbyaddr(addr, len, type);
3565         if (*result != NULL) {
3566                 memset(buf, '\0', buflen);
3567                 *ret = **result;
3568                 return 0;
3569         } else {
3570                 *h_errnop = h_errno;
3571                 return -1;
3572         }
3573 }
3574
3575 int gethostbyaddr_r(const void *addr, socklen_t len, int type,
3576                     struct hostent *ret,
3577                     char *buf, size_t buflen,
3578                     struct hostent **result, int *h_errnop)
3579 {
3580         if (!nss_wrapper_hosts_enabled()) {
3581                 return libc_gethostbyaddr_r(addr,
3582                                             len,
3583                                             type,
3584                                             ret,
3585                                             buf,
3586                                             buflen,
3587                                             result,
3588                                             h_errnop);
3589         }
3590
3591         return nwrap_gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
3592 }
3593 #endif
3594
3595 /* hosts enum functions */
3596 static void nwrap_files_sethostent(void)
3597 {
3598         nwrap_he_global.idx = 0;
3599 }
3600
3601 static struct hostent *nwrap_files_gethostent(void)
3602 {
3603         struct hostent *he;
3604
3605         if (nwrap_he_global.idx == 0) {
3606                 nwrap_files_cache_reload(nwrap_he_global.cache);
3607         }
3608
3609         if (nwrap_he_global.idx >= nwrap_he_global.num) {
3610                 errno = ENOENT;
3611                 return NULL;
3612         }
3613
3614         he = &((struct nwrap_entdata *)nwrap_he_global.entdata.items[nwrap_he_global.idx++])->ht;
3615
3616         NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
3617
3618         return he;
3619 }
3620
3621 static void nwrap_files_endhostent(void)
3622 {
3623         nwrap_he_global.idx = 0;
3624 }
3625
3626 /*
3627  * module backend
3628  */
3629
3630
3631 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
3632                                             const char *name)
3633 {
3634         static struct passwd pwd;
3635         static char buf[1000];
3636         NSS_STATUS status;
3637
3638         if (!b->fns->_nss_getpwnam_r) {
3639                 return NULL;
3640         }
3641
3642         status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
3643         if (status == NSS_STATUS_NOTFOUND) {
3644                 return NULL;
3645         }
3646         if (status != NSS_STATUS_SUCCESS) {
3647                 return NULL;
3648         }
3649
3650         return &pwd;
3651 }
3652
3653 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
3654                                    const char *name, struct passwd *pwdst,
3655                                    char *buf, size_t buflen, struct passwd **pwdstp)
3656 {
3657         int ret;
3658
3659         (void) b; /* unused */
3660         (void) pwdst; /* unused */
3661         (void) pwdstp; /* unused */
3662
3663         if (!b->fns->_nss_getpwnam_r) {
3664                 return NSS_STATUS_NOTFOUND;
3665         }
3666
3667         ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
3668         switch (ret) {
3669         case NSS_STATUS_SUCCESS:
3670                 return 0;
3671         case NSS_STATUS_NOTFOUND:
3672                 if (errno != 0) {
3673                         return errno;
3674                 }
3675                 return ENOENT;
3676         case NSS_STATUS_TRYAGAIN:
3677                 if (errno != 0) {
3678                         return errno;
3679                 }
3680                 return ERANGE;
3681         default:
3682                 if (errno != 0) {
3683                         return errno;
3684                 }
3685                 return ret;
3686         }
3687 }
3688
3689 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
3690                                             uid_t uid)
3691 {
3692         static struct passwd pwd;
3693         static char buf[1000];
3694         NSS_STATUS status;
3695
3696         if (!b->fns->_nss_getpwuid_r) {
3697                 return NULL;
3698         }
3699
3700         status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
3701         if (status == NSS_STATUS_NOTFOUND) {
3702                 return NULL;
3703         }
3704         if (status != NSS_STATUS_SUCCESS) {
3705                 return NULL;
3706         }
3707         return &pwd;
3708 }
3709
3710 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
3711                                    uid_t uid, struct passwd *pwdst,
3712                                    char *buf, size_t buflen, struct passwd **pwdstp)
3713 {
3714         int ret;
3715
3716         (void) pwdstp; /* unused */
3717
3718         if (!b->fns->_nss_getpwuid_r) {
3719                 return ENOENT;
3720         }
3721
3722         ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
3723         switch (ret) {
3724         case NSS_STATUS_SUCCESS:
3725                 return 0;
3726         case NSS_STATUS_NOTFOUND:
3727                 if (errno != 0) {
3728                         return errno;
3729                 }
3730                 return ENOENT;
3731         case NSS_STATUS_TRYAGAIN:
3732                 if (errno != 0) {
3733                         return errno;
3734                 }
3735                 return ERANGE;
3736         default:
3737                 if (errno != 0) {
3738                         return errno;
3739                 }
3740                 return ret;
3741         }
3742 }
3743
3744 static void nwrap_module_setpwent(struct nwrap_backend *b)
3745 {
3746         if (!b->fns->_nss_setpwent) {
3747                 return;
3748         }
3749
3750         b->fns->_nss_setpwent();
3751 }
3752
3753 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
3754 {
3755         static struct passwd pwd;
3756         static char buf[1000];
3757         NSS_STATUS status;
3758
3759         if (!b->fns->_nss_getpwent_r) {
3760                 return NULL;
3761         }
3762
3763         status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
3764         if (status == NSS_STATUS_NOTFOUND) {
3765                 return NULL;
3766         }
3767         if (status != NSS_STATUS_SUCCESS) {
3768                 return NULL;
3769         }
3770         return &pwd;
3771 }
3772
3773 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
3774                                    struct passwd *pwdst, char *buf,
3775                                    size_t buflen, struct passwd **pwdstp)
3776 {
3777         int ret;
3778
3779         (void) pwdstp; /* unused */
3780
3781         if (!b->fns->_nss_getpwent_r) {
3782                 return ENOENT;
3783         }
3784
3785         ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
3786         switch (ret) {
3787         case NSS_STATUS_SUCCESS:
3788                 return 0;
3789         case NSS_STATUS_NOTFOUND:
3790                 if (errno != 0) {
3791                         return errno;
3792                 }
3793                 return ENOENT;
3794         case NSS_STATUS_TRYAGAIN:
3795                 if (errno != 0) {
3796                         return errno;
3797                 }
3798                 return ERANGE;
3799         default:
3800                 if (errno != 0) {
3801                         return errno;
3802                 }
3803                 return ret;
3804         }
3805 }
3806
3807 static void nwrap_module_endpwent(struct nwrap_backend *b)
3808 {
3809         if (!b->fns->_nss_endpwent) {
3810                 return;
3811         }
3812
3813         b->fns->_nss_endpwent();
3814 }
3815
3816 static int nwrap_module_initgroups(struct nwrap_backend *b,
3817                                    const char *user, gid_t group)
3818 {
3819         gid_t *groups;
3820         long int start;
3821         long int size;
3822
3823         if (!b->fns->_nss_initgroups) {
3824                 return NSS_STATUS_UNAVAIL;
3825         }
3826
3827         return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
3828 }
3829
3830 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
3831                                            const char *name)
3832 {
3833         static struct group grp;
3834         static char *buf;
3835         static int buflen = 1000;
3836         NSS_STATUS status;
3837
3838         if (!b->fns->_nss_getgrnam_r) {
3839                 return NULL;
3840         }
3841
3842         if (!buf) {
3843                 buf = (char *)malloc(buflen);
3844         }
3845 again:
3846         status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
3847         if (status == NSS_STATUS_TRYAGAIN) {
3848                 buflen *= 2;
3849                 buf = (char *)realloc(buf, buflen);
3850                 if (!buf) {
3851                         return NULL;
3852                 }
3853                 goto again;
3854         }
3855         if (status == NSS_STATUS_NOTFOUND) {
3856                 SAFE_FREE(buf);
3857                 return NULL;
3858         }
3859         if (status != NSS_STATUS_SUCCESS) {
3860                 SAFE_FREE(buf);
3861                 return NULL;
3862         }
3863         return &grp;
3864 }
3865
3866 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
3867                                    const char *name, struct group *grdst,
3868                                    char *buf, size_t buflen, struct group **grdstp)
3869 {
3870         int ret;
3871
3872         (void) grdstp; /* unused */
3873
3874         if (!b->fns->_nss_getgrnam_r) {
3875                 return ENOENT;
3876         }
3877
3878         ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
3879         switch (ret) {
3880         case NSS_STATUS_SUCCESS:
3881                 return 0;
3882         case NSS_STATUS_NOTFOUND:
3883                 if (errno != 0) {
3884                         return errno;
3885                 }
3886                 return ENOENT;
3887         case NSS_STATUS_TRYAGAIN:
3888                 if (errno != 0) {
3889                         return errno;
3890                 }
3891                 return ERANGE;
3892         default:
3893                 if (errno != 0) {
3894                         return errno;
3895                 }
3896                 return ret;
3897         }
3898 }
3899
3900 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
3901                                            gid_t gid)
3902 {
3903         static struct group grp;
3904         static char *buf;
3905         static int buflen = 1000;
3906         NSS_STATUS status;
3907
3908         if (!b->fns->_nss_getgrgid_r) {
3909                 return NULL;
3910         }
3911
3912         if (!buf) {
3913                 buf = (char *)malloc(buflen);
3914         }
3915
3916 again:
3917         status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
3918         if (status == NSS_STATUS_TRYAGAIN) {
3919                 buflen *= 2;
3920                 buf = (char *)realloc(buf, buflen);
3921                 if (!buf) {
3922                         return NULL;
3923                 }
3924                 goto again;
3925         }
3926         if (status == NSS_STATUS_NOTFOUND) {
3927                 SAFE_FREE(buf);
3928                 return NULL;
3929         }
3930         if (status != NSS_STATUS_SUCCESS) {
3931                 SAFE_FREE(buf);
3932                 return NULL;
3933         }
3934         return &grp;
3935 }
3936
3937 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
3938                                    gid_t gid, struct group *grdst,
3939                                    char *buf, size_t buflen, struct group **grdstp)
3940 {
3941         int ret;
3942
3943         (void) grdstp; /* unused */
3944
3945         if (!b->fns->_nss_getgrgid_r) {
3946                 return ENOENT;
3947         }
3948
3949         ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
3950         switch (ret) {
3951         case NSS_STATUS_SUCCESS:
3952                 return 0;
3953         case NSS_STATUS_NOTFOUND:
3954                 if (errno != 0) {
3955                         return errno;
3956                 }
3957                 return ENOENT;
3958         case NSS_STATUS_TRYAGAIN:
3959                 if (errno != 0) {
3960                         return errno;
3961                 }
3962                 return ERANGE;
3963         default:
3964                 if (errno != 0) {
3965                         return errno;
3966                 }
3967                 return ret;
3968         }
3969 }
3970
3971 static void nwrap_module_setgrent(struct nwrap_backend *b)
3972 {
3973         if (!b->fns->_nss_setgrent) {
3974                 return;
3975         }
3976
3977         b->fns->_nss_setgrent();
3978 }
3979
3980 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
3981 {
3982         static struct group grp;
3983         static char *buf;
3984         static int buflen = 1024;
3985         NSS_STATUS status;
3986
3987         if (!b->fns->_nss_getgrent_r) {
3988                 return NULL;
3989         }
3990
3991         if (!buf) {
3992                 buf = (char *)malloc(buflen);
3993         }
3994
3995 again:
3996         status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
3997         if (status == NSS_STATUS_TRYAGAIN) {
3998                 buflen *= 2;
3999                 buf = (char *)realloc(buf, buflen);
4000                 if (!buf) {
4001                         return NULL;
4002                 }
4003                 goto again;
4004         }
4005         if (status == NSS_STATUS_NOTFOUND) {
4006                 SAFE_FREE(buf);
4007                 return NULL;
4008         }
4009         if (status != NSS_STATUS_SUCCESS) {
4010                 SAFE_FREE(buf);
4011                 return NULL;
4012         }
4013         return &grp;
4014 }
4015
4016 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
4017                                    struct group *grdst, char *buf,
4018                                    size_t buflen, struct group **grdstp)
4019 {
4020         int ret;
4021
4022         (void) grdstp; /* unused */
4023
4024         if (!b->fns->_nss_getgrent_r) {
4025                 return ENOENT;
4026         }
4027
4028         ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
4029         switch (ret) {
4030         case NSS_STATUS_SUCCESS:
4031                 return 0;
4032         case NSS_STATUS_NOTFOUND:
4033                 if (errno != 0) {
4034                         return errno;
4035                 }
4036                 return ENOENT;
4037         case NSS_STATUS_TRYAGAIN:
4038                 if (errno != 0) {
4039                         return errno;
4040                 }
4041                 return ERANGE;
4042         default:
4043                 if (errno != 0) {
4044                         return errno;
4045                 }
4046                 return ret;
4047         }
4048 }
4049
4050 static void nwrap_module_endgrent(struct nwrap_backend *b)
4051 {
4052         if (!b->fns->_nss_endgrent) {
4053                 return;
4054         }
4055
4056         b->fns->_nss_endgrent();
4057 }
4058
4059 /****************************************************************************
4060  *   GETPWNAM
4061  ***************************************************************************/
4062
4063 static struct passwd *nwrap_getpwnam(const char *name)
4064 {
4065         int i;
4066         struct passwd *pwd;
4067
4068         for (i=0; i < nwrap_main_global->num_backends; i++) {
4069                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4070                 pwd = b->ops->nw_getpwnam(b, name);
4071                 if (pwd) {
4072                         return pwd;
4073                 }
4074         }
4075
4076         return NULL;
4077 }
4078
4079 struct passwd *getpwnam(const char *name)
4080 {
4081         if (!nss_wrapper_enabled()) {
4082                 return libc_getpwnam(name);
4083         }
4084
4085         return nwrap_getpwnam(name);
4086 }
4087
4088 /****************************************************************************
4089  *   GETPWNAM_R
4090  ***************************************************************************/
4091
4092 static int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
4093                             char *buf, size_t buflen, struct passwd **pwdstp)
4094 {
4095         int i,ret;
4096
4097         for (i=0; i < nwrap_main_global->num_backends; i++) {
4098                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4099                 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
4100                 if (ret == ENOENT) {
4101                         continue;
4102                 }
4103                 return ret;
4104         }
4105
4106         return ENOENT;
4107 }
4108
4109 #ifdef HAVE_GETPWNAM_R
4110 # ifdef HAVE_SOLARIS_GETPWNAM_R
4111 int getpwnam_r(const char *name, struct passwd *pwdst,
4112                char *buf, int buflen, struct passwd **pwdstp)
4113 # else /* HAVE_SOLARIS_GETPWNAM_R */
4114 int getpwnam_r(const char *name, struct passwd *pwdst,
4115                char *buf, size_t buflen, struct passwd **pwdstp)
4116 # endif /* HAVE_SOLARIS_GETPWNAM_R */
4117 {
4118         if (!nss_wrapper_enabled()) {
4119                 return libc_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4120         }
4121
4122         return nwrap_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
4123 }
4124 #endif
4125
4126 /****************************************************************************
4127  *   GETPWUID
4128  ***************************************************************************/
4129
4130 static struct passwd *nwrap_getpwuid(uid_t uid)
4131 {
4132         int i;
4133         struct passwd *pwd;
4134
4135         for (i=0; i < nwrap_main_global->num_backends; i++) {
4136                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4137                 pwd = b->ops->nw_getpwuid(b, uid);
4138                 if (pwd) {
4139                         return pwd;
4140                 }
4141         }
4142
4143         return NULL;
4144 }
4145
4146 struct passwd *getpwuid(uid_t uid)
4147 {
4148         if (!nss_wrapper_enabled()) {
4149                 return libc_getpwuid(uid);
4150         }
4151
4152         return nwrap_getpwuid(uid);
4153 }
4154
4155 /****************************************************************************
4156  *   GETPWUID_R
4157  ***************************************************************************/
4158
4159 static int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
4160                             char *buf, size_t buflen, struct passwd **pwdstp)
4161 {
4162         int i,ret;
4163
4164         for (i=0; i < nwrap_main_global->num_backends; i++) {
4165                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4166                 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
4167                 if (ret == ENOENT) {
4168                         continue;
4169                 }
4170                 return ret;
4171         }
4172
4173         return ENOENT;
4174 }
4175
4176 #ifdef HAVE_SOLARIS_GETPWUID_R
4177 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4178                char *buf, int buflen, struct passwd **pwdstp)
4179 #else
4180 int getpwuid_r(uid_t uid, struct passwd *pwdst,
4181                char *buf, size_t buflen, struct passwd **pwdstp)
4182 #endif
4183 {
4184         if (!nss_wrapper_enabled()) {
4185                 return libc_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4186         }
4187
4188         return nwrap_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
4189 }
4190
4191 /****************************************************************************
4192  *   SETPWENT
4193  ***************************************************************************/
4194
4195 static void nwrap_setpwent(void)
4196 {
4197         int i;
4198
4199         for (i=0; i < nwrap_main_global->num_backends; i++) {
4200                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4201                 b->ops->nw_setpwent(b);
4202         }
4203 }
4204
4205 void setpwent(void)
4206 {
4207         if (!nss_wrapper_enabled()) {
4208                 libc_setpwent();
4209                 return;
4210         }
4211
4212         nwrap_setpwent();
4213 }
4214
4215 /****************************************************************************
4216  *   GETPWENT
4217  ***************************************************************************/
4218
4219 static struct passwd *nwrap_getpwent(void)
4220 {
4221         int i;
4222         struct passwd *pwd;
4223
4224         for (i=0; i < nwrap_main_global->num_backends; i++) {
4225                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4226                 pwd = b->ops->nw_getpwent(b);
4227                 if (pwd) {
4228                         return pwd;
4229                 }
4230         }
4231
4232         return NULL;
4233 }
4234
4235 struct passwd *getpwent(void)
4236 {
4237         if (!nss_wrapper_enabled()) {
4238                 return libc_getpwent();
4239         }
4240
4241         return nwrap_getpwent();
4242 }
4243
4244 /****************************************************************************
4245  *   GETPWENT_R
4246  ***************************************************************************/
4247
4248 static int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
4249                             size_t buflen, struct passwd **pwdstp)
4250 {
4251         int i,ret;
4252
4253         for (i=0; i < nwrap_main_global->num_backends; i++) {
4254                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4255                 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
4256                 if (ret == ENOENT) {
4257                         continue;
4258                 }
4259                 return ret;
4260         }
4261
4262         return ENOENT;
4263 }
4264
4265 #ifdef HAVE_SOLARIS_GETPWENT_R
4266 struct passwd *getpwent_r(struct passwd *pwdst, char *buf, int buflen)
4267 {
4268         struct passwd *pwdstp = NULL;
4269         int rc;
4270
4271         if (!nss_wrapper_enabled()) {
4272                 return libc_getpwent_r(pwdst, buf, buflen);
4273         }
4274         rc = nwrap_getpwent_r(pwdst, buf, buflen, &pwdstp);
4275         if (rc < 0) {
4276                 return NULL;
4277         }
4278
4279         return pwdstp;
4280 }
4281 #else /* HAVE_SOLARIS_GETPWENT_R */
4282 int getpwent_r(struct passwd *pwdst, char *buf,
4283                size_t buflen, struct passwd **pwdstp)
4284 {
4285         if (!nss_wrapper_enabled()) {
4286                 return libc_getpwent_r(pwdst, buf, buflen, pwdstp);
4287         }
4288
4289         return nwrap_getpwent_r(pwdst, buf, buflen, pwdstp);
4290 }
4291 #endif /* HAVE_SOLARIS_GETPWENT_R */
4292
4293 /****************************************************************************
4294  *   ENDPWENT
4295  ***************************************************************************/
4296
4297 static void nwrap_endpwent(void)
4298 {
4299         int i;
4300
4301         for (i=0; i < nwrap_main_global->num_backends; i++) {
4302                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4303                 b->ops->nw_endpwent(b);
4304         }
4305 }
4306
4307 void endpwent(void)
4308 {
4309         if (!nss_wrapper_enabled()) {
4310                 libc_endpwent();
4311                 return;
4312         }
4313
4314         nwrap_endpwent();
4315 }
4316
4317 /****************************************************************************
4318  *   INITGROUPS
4319  ***************************************************************************/
4320
4321 static int nwrap_initgroups(const char *user, gid_t group)
4322 {
4323         int i;
4324
4325         for (i=0; i < nwrap_main_global->num_backends; i++) {
4326                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4327                 int rc;
4328
4329                 rc = b->ops->nw_initgroups(b, user, group);
4330                 if (rc == 0) {
4331                         return 0;
4332                 }
4333         }
4334
4335         errno = ENOENT;
4336         return -1;
4337 }
4338
4339 int initgroups(const char *user, gid_t group)
4340 {
4341         if (!nss_wrapper_enabled()) {
4342                 return libc_initgroups(user, group);
4343         }
4344
4345         return nwrap_initgroups(user, group);
4346 }
4347
4348 /****************************************************************************
4349  *   GETGRNAM
4350  ***************************************************************************/
4351
4352 static struct group *nwrap_getgrnam(const char *name)
4353 {
4354         int i;
4355         struct group *grp;
4356
4357         for (i=0; i < nwrap_main_global->num_backends; i++) {
4358                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4359                 grp = b->ops->nw_getgrnam(b, name);
4360                 if (grp) {
4361                         return grp;
4362                 }
4363         }
4364
4365         return NULL;
4366 }
4367
4368 struct group *getgrnam(const char *name)
4369 {
4370         if (!nss_wrapper_enabled()) {
4371                 return libc_getgrnam(name);
4372         }
4373
4374         return nwrap_getgrnam(name);
4375 }
4376
4377 /****************************************************************************
4378  *   GETGRNAM_R
4379  ***************************************************************************/
4380
4381 static int nwrap_getgrnam_r(const char *name, struct group *grdst,
4382                             char *buf, size_t buflen, struct group **grdstp)
4383 {
4384         int i, ret;
4385
4386         for (i=0; i < nwrap_main_global->num_backends; i++) {
4387                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4388                 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
4389                 if (ret == ENOENT) {
4390                         continue;
4391                 }
4392                 return ret;
4393         }
4394
4395         return ENOENT;
4396 }
4397
4398 #ifdef HAVE_GETGRNAM_R
4399 # ifdef HAVE_SOLARIS_GETGRNAM_R
4400 int getgrnam_r(const char *name, struct group *grp,
4401                 char *buf, int buflen, struct group **pgrp)
4402 # else /* HAVE_SOLARIS_GETGRNAM_R */
4403 int getgrnam_r(const char *name, struct group *grp,
4404                char *buf, size_t buflen, struct group **pgrp)
4405 # endif /* HAVE_SOLARIS_GETGRNAM_R */
4406 {
4407         if (!nss_wrapper_enabled()) {
4408                 return libc_getgrnam_r(name,
4409                                        grp,
4410                                        buf,
4411                                        buflen,
4412                                        pgrp);
4413         }
4414
4415         return nwrap_getgrnam_r(name, grp, buf, buflen, pgrp);
4416 }
4417 #endif /* HAVE_GETGRNAM_R */
4418
4419 /****************************************************************************
4420  *   GETGRGID
4421  ***************************************************************************/
4422
4423 static struct group *nwrap_getgrgid(gid_t gid)
4424 {
4425         int i;
4426         struct group *grp;
4427
4428         for (i=0; i < nwrap_main_global->num_backends; i++) {
4429                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4430                 grp = b->ops->nw_getgrgid(b, gid);
4431                 if (grp) {
4432                         return grp;
4433                 }
4434         }
4435
4436         return NULL;
4437 }
4438
4439 struct group *getgrgid(gid_t gid)
4440 {
4441         if (!nss_wrapper_enabled()) {
4442                 return libc_getgrgid(gid);
4443         }
4444
4445         return nwrap_getgrgid(gid);
4446 }
4447
4448 /****************************************************************************
4449  *   GETGRGID_R
4450  ***************************************************************************/
4451
4452 static int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
4453                             char *buf, size_t buflen, struct group **grdstp)
4454 {
4455         int i,ret;
4456
4457         for (i=0; i < nwrap_main_global->num_backends; i++) {
4458                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4459                 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
4460                 if (ret == ENOENT) {
4461                         continue;
4462                 }
4463                 return ret;
4464         }
4465
4466         return ENOENT;
4467 }
4468
4469 #ifdef HAVE_GETGRGID_R
4470 # ifdef HAVE_SOLARIS_GETGRGID_R
4471 int getgrgid_r(gid_t gid, struct group *grdst,
4472                char *buf, int buflen, struct group **grdstp)
4473 # else /* HAVE_SOLARIS_GETGRGID_R */
4474 int getgrgid_r(gid_t gid, struct group *grdst,
4475                char *buf, size_t buflen, struct group **grdstp)
4476 # endif /* HAVE_SOLARIS_GETGRGID_R */
4477 {
4478         if (!nss_wrapper_enabled()) {
4479                 return libc_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4480         }
4481
4482         return nwrap_getgrgid_r(gid, grdst, buf, buflen, grdstp);
4483 }
4484 #endif
4485
4486 /****************************************************************************
4487  *   SETGRENT
4488  ***************************************************************************/
4489
4490 static void nwrap_setgrent(void)
4491 {
4492         int i;
4493
4494         for (i=0; i < nwrap_main_global->num_backends; i++) {
4495                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4496                 b->ops->nw_setgrent(b);
4497         }
4498 }
4499
4500 #ifdef HAVE_BSD_SETGRENT
4501 int setgrent(void)
4502 #else
4503 void setgrent(void)
4504 #endif
4505 {
4506         if (!nss_wrapper_enabled()) {
4507                 libc_setgrent();
4508                 goto out;
4509         }
4510
4511         nwrap_setgrent();
4512
4513 out:
4514 #ifdef HAVE_BSD_SETGRENT
4515         return 0;
4516 #else
4517         return;
4518 #endif
4519 }
4520
4521 /****************************************************************************
4522  *   GETGRENT
4523  ***************************************************************************/
4524
4525 static struct group *nwrap_getgrent(void)
4526 {
4527         int i;
4528         struct group *grp;
4529
4530         for (i=0; i < nwrap_main_global->num_backends; i++) {
4531                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4532                 grp = b->ops->nw_getgrent(b);
4533                 if (grp) {
4534                         return grp;
4535                 }
4536         }
4537
4538         return NULL;
4539 }
4540
4541 struct group *getgrent(void)
4542 {
4543         if (!nss_wrapper_enabled()) {
4544                 return libc_getgrent();
4545         }
4546
4547         return nwrap_getgrent();
4548 }
4549
4550 /****************************************************************************
4551  *   GETGRENT_R
4552  ***************************************************************************/
4553
4554 static int nwrap_getgrent_r(struct group *grdst, char *buf,
4555                             size_t buflen, struct group **grdstp)
4556 {
4557         int i,ret;
4558
4559         for (i=0; i < nwrap_main_global->num_backends; i++) {
4560                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4561                 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
4562                 if (ret == ENOENT) {
4563                         continue;
4564                 }
4565                 return ret;
4566         }
4567
4568         return ENOENT;
4569 }
4570
4571 #ifdef HAVE_SOLARIS_GETGRENT_R
4572 struct group *getgrent_r(struct group *src, char *buf, int buflen)
4573 {
4574         struct group *grdstp = NULL;
4575         int rc;
4576
4577         if (!nss_wrapper_enabled()) {
4578                 return libc_getgrent_r(src, buf, buflen);
4579         }
4580
4581         rc = nwrap_getgrent_r(src, buf, buflen, &grdstp);
4582         if (rc < 0) {
4583                 return NULL;
4584         }
4585
4586         return grdstp;
4587 }
4588 #else /* HAVE_SOLARIS_GETGRENT_R */
4589 int getgrent_r(struct group *src, char *buf,
4590                size_t buflen, struct group **grdstp)
4591 {
4592         if (!nss_wrapper_enabled()) {
4593                 return libc_getgrent_r(src, buf, buflen, grdstp);
4594         }
4595
4596         return nwrap_getgrent_r(src, buf, buflen, grdstp);
4597 }
4598 #endif /* HAVE_SOLARIS_GETGRENT_R */
4599
4600 /****************************************************************************
4601  *   ENDGRENT
4602  ***************************************************************************/
4603
4604 static void nwrap_endgrent(void)
4605 {
4606         int i;
4607
4608         for (i=0; i < nwrap_main_global->num_backends; i++) {
4609                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
4610                 b->ops->nw_endgrent(b);
4611         }
4612 }
4613
4614 void endgrent(void)
4615 {
4616         if (!nss_wrapper_enabled()) {
4617                 libc_endgrent();
4618                 return;
4619         }
4620
4621         nwrap_endgrent();
4622 }
4623
4624 /****************************************************************************
4625  *   GETGROUPLIST
4626  ***************************************************************************/
4627
4628 #ifdef HAVE_GETGROUPLIST
4629 static int nwrap_getgrouplist(const char *user, gid_t group,
4630                               gid_t *groups, int *ngroups)
4631 {
4632         struct group *grp;
4633         gid_t *groups_tmp;
4634         int count = 1;
4635
4636         NWRAP_LOG(NWRAP_LOG_DEBUG, "getgrouplist called for %s", user);
4637
4638         groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
4639         if (!groups_tmp) {
4640                 NWRAP_LOG(NWRAP_LOG_ERROR, "Out of memory");
4641                 errno = ENOMEM;
4642                 return -1;
4643         }
4644         groups_tmp[0] = group;
4645
4646         nwrap_setgrent();
4647         while ((grp = nwrap_getgrent()) != NULL) {
4648                 int i = 0;
4649
4650                 NWRAP_LOG(NWRAP_LOG_DEBUG,
4651                           "Inspecting %s for group membership",
4652                           grp->gr_name);
4653
4654                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
4655
4656                         if (group != grp->gr_gid &&
4657                             (strcmp(user, grp->gr_mem[i]) == 0)) {
4658
4659                                 NWRAP_LOG(NWRAP_LOG_DEBUG,
4660                                           "%s is member of %s",
4661                                           user,
4662                                           grp->gr_name);
4663
4664                                 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
4665                                 if (!groups_tmp) {
4666                                         NWRAP_LOG(NWRAP_LOG_ERROR,
4667                                                   "Out of memory");
4668                                         errno = ENOMEM;
4669                                         return -1;
4670                                 }
4671                                 groups_tmp[count] = grp->gr_gid;
4672
4673                                 count++;
4674                         }
4675                 }
4676         }
4677
4678         nwrap_endgrent();
4679
4680         NWRAP_LOG(NWRAP_LOG_DEBUG,
4681                   "%s is member of %d groups",
4682                   user, *ngroups);
4683
4684         if (*ngroups < count) {
4685                 *ngroups = count;
4686                 free(groups_tmp);
4687                 return -1;
4688         }
4689
4690         *ngroups = count;
4691         memcpy(groups, groups_tmp, count * sizeof(gid_t));
4692         free(groups_tmp);
4693
4694         return count;
4695 }
4696
4697 int getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
4698 {
4699         if (!nss_wrapper_enabled()) {
4700                 return libc_getgrouplist(user, group, groups, ngroups);
4701         }
4702
4703         return nwrap_getgrouplist(user, group, groups, ngroups);
4704 }
4705 #endif
4706
4707 /**********************************************************
4708  * SHADOW
4709  **********************************************************/
4710
4711 #if defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM)
4712
4713 #ifdef HAVE_SETSPENT
4714 static void nwrap_setspent(void)
4715 {
4716         nwrap_files_setspent();
4717 }
4718
4719 void setspent(void)
4720 {
4721         if (!nss_wrapper_shadow_enabled()) {
4722                 return;
4723         }
4724
4725         nwrap_setspent();
4726 }
4727
4728 static struct spwd *nwrap_getspent(void)
4729 {
4730         return nwrap_files_getspent();
4731 }
4732
4733 struct spwd *getspent(void)
4734 {
4735         if (!nss_wrapper_shadow_enabled()) {
4736                 return NULL;
4737         }
4738
4739         return nwrap_getspent();
4740 }
4741
4742 static void nwrap_endspent(void)
4743 {
4744         nwrap_files_endspent();
4745 }
4746
4747 void endspent(void)
4748 {
4749         if (!nss_wrapper_shadow_enabled()) {
4750                 return;
4751         }
4752
4753         nwrap_endspent();
4754 }
4755 #endif /* HAVE_SETSPENT */
4756
4757 static struct spwd *nwrap_getspnam(const char *name)
4758 {
4759         return nwrap_files_getspnam(name);
4760 }
4761
4762 struct spwd *getspnam(const char *name)
4763 {
4764         if (!nss_wrapper_shadow_enabled()) {
4765                 return NULL;
4766         }
4767
4768         return nwrap_getspnam(name);
4769 }
4770
4771 #endif /* defined(HAVE_SHADOW_H) && defined(HAVE_GETSPNAM) */
4772
4773 /**********************************************************
4774  * NETDB
4775  **********************************************************/
4776
4777 static void nwrap_sethostent(int stayopen) {
4778         (void) stayopen; /* ignored */
4779
4780         nwrap_files_sethostent();
4781 }
4782
4783 #ifdef HAVE_SOLARIS_SETHOSTENT
4784 int sethostent(int stayopen)
4785 {
4786         if (!nss_wrapper_hosts_enabled()) {
4787                 libc_sethostent(stayopen);
4788                 return 0;
4789         }
4790
4791         nwrap_sethostent(stayopen);
4792
4793         return 0;
4794 }
4795 #else /* HAVE_SOLARIS_SETHOSTENT */
4796 void sethostent(int stayopen)
4797 {
4798         if (!nss_wrapper_hosts_enabled()) {
4799                 libc_sethostent(stayopen);
4800                 return;
4801         }
4802
4803         nwrap_sethostent(stayopen);
4804 }
4805 #endif /* HAVE_SOLARIS_SETHOSTENT */
4806
4807 static struct hostent *nwrap_gethostent(void)
4808 {
4809         return nwrap_files_gethostent();
4810 }
4811
4812 struct hostent *gethostent(void) {
4813         if (!nss_wrapper_hosts_enabled()) {
4814                 return libc_gethostent();
4815         }
4816
4817         return nwrap_gethostent();
4818 }
4819
4820 static void nwrap_endhostent(void) {
4821         nwrap_files_endhostent();
4822 }
4823
4824 #ifdef HAVE_SOLARIS_ENDHOSTENT
4825 int endhostent(void)
4826 {
4827         if (!nss_wrapper_hosts_enabled()) {
4828                 libc_endhostent();
4829                 return 0;
4830         }
4831
4832         nwrap_endhostent();
4833
4834         return 0;
4835 }
4836 #else /* HAVE_SOLARIS_ENDHOSTENT */
4837 void endhostent(void)
4838 {
4839         if (!nss_wrapper_hosts_enabled()) {
4840                 libc_endhostent();
4841                 return;
4842         }
4843
4844         nwrap_endhostent();
4845 }
4846 #endif /* HAVE_SOLARIS_ENDHOSTENT */
4847
4848 #ifdef BSD
4849 /* BSD implementation stores data in thread local storage but GLIBC does not */
4850 static __thread struct hostent user_he;
4851 static __thread struct nwrap_vector user_addrlist;
4852 #else
4853 static struct hostent user_he;
4854 static struct nwrap_vector user_addrlist;
4855 #endif /* BSD */
4856 static struct hostent *nwrap_gethostbyname(const char *name)
4857 {
4858         if (nwrap_files_gethostbyname(name, AF_UNSPEC, &user_he, &user_addrlist) == -1) {
4859                 return NULL;
4860         }
4861         return &user_he;
4862 }
4863
4864 struct hostent *gethostbyname(const char *name)
4865 {
4866         if (!nss_wrapper_hosts_enabled()) {
4867                 return libc_gethostbyname(name);
4868         }
4869
4870         return nwrap_gethostbyname(name);
4871 }
4872
4873 /* This is a GNU extension - Also can be found on BSD systems */
4874 #ifdef HAVE_GETHOSTBYNAME2
4875 #ifdef BSD
4876 /* BSD implementation stores data in  thread local storage but GLIBC not */
4877 static __thread struct hostent user_he2;
4878 static __thread struct nwrap_vector user_addrlist2;
4879 #else
4880 static struct hostent user_he2;
4881 static struct nwrap_vector user_addrlist2;
4882 #endif /* BSD */
4883 static struct hostent *nwrap_gethostbyname2(const char *name, int af)
4884 {
4885         if (nwrap_files_gethostbyname(name, af, &user_he2, &user_addrlist2) == -1) {
4886                 return NULL;
4887         }
4888         return &user_he2;
4889 }
4890
4891 struct hostent *gethostbyname2(const char *name, int af)
4892 {
4893         if (!nss_wrapper_hosts_enabled()) {
4894                 return libc_gethostbyname2(name, af);
4895         }
4896
4897         return nwrap_gethostbyname2(name, af);
4898 }
4899 #endif
4900
4901 static struct hostent *nwrap_gethostbyaddr(const void *addr,
4902                                            socklen_t len, int type)
4903 {
4904         return nwrap_files_gethostbyaddr(addr, len, type);
4905 }
4906
4907 struct hostent *gethostbyaddr(const void *addr,
4908                               socklen_t len, int type)
4909 {
4910         if (!nss_wrapper_hosts_enabled()) {
4911                 return libc_gethostbyaddr(addr, len, type);
4912         }
4913
4914         return nwrap_gethostbyaddr(addr, len, type);
4915 }
4916
4917 static const struct addrinfo default_hints =
4918 {
4919         .ai_flags = AI_ADDRCONFIG|AI_V4MAPPED,
4920         .ai_family = AF_UNSPEC,
4921         .ai_socktype = 0,
4922         .ai_protocol = 0,
4923         .ai_addrlen = 0,
4924         .ai_addr = NULL,
4925         .ai_canonname = NULL,
4926         .ai_next = NULL
4927 };
4928
4929 static int nwrap_convert_he_ai(const struct hostent *he,
4930                                unsigned short port,
4931                                const struct addrinfo *hints,
4932                                struct addrinfo **pai,
4933                                bool skip_canonname)
4934 {
4935         struct addrinfo *ai;
4936         socklen_t socklen;
4937
4938         if (he == NULL) {
4939                 return EAI_MEMORY;
4940         }
4941
4942         switch (he->h_addrtype) {
4943                 case AF_INET:
4944                         socklen = sizeof(struct sockaddr_in);
4945                         break;
4946 #ifdef HAVE_IPV6
4947                 case AF_INET6:
4948                         socklen = sizeof(struct sockaddr_in6);
4949                         break;
4950 #endif
4951                 default:
4952                         return EAI_FAMILY;
4953         }
4954
4955         ai = (struct addrinfo *)malloc(sizeof(struct addrinfo) + socklen);
4956         if (ai == NULL) {
4957                 return EAI_MEMORY;
4958         }
4959
4960         ai->ai_flags = 0;
4961         ai->ai_family = he->h_addrtype;
4962         ai->ai_socktype = hints->ai_socktype;
4963         ai->ai_protocol = hints->ai_protocol;
4964         ai->ai_canonname = NULL;
4965
4966         ai->ai_addrlen = socklen;
4967         ai->ai_addr = (void *)(ai + 1);
4968
4969 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
4970         ai->ai_addr->sa_len = socklen;
4971 #endif
4972         ai->ai_addr->sa_family = he->h_addrtype;
4973
4974         switch (he->h_addrtype) {
4975                 case AF_INET:
4976                 {
4977                         struct sockaddr_in *sinp =
4978                                 (struct sockaddr_in *) ai->ai_addr;
4979
4980                         memset(sinp, 0, sizeof(struct sockaddr_in));
4981
4982                         sinp->sin_port = htons(port);
4983                         sinp->sin_family = AF_INET;
4984
4985                         memset (sinp->sin_zero, '\0', sizeof (sinp->sin_zero));
4986                         memcpy(&sinp->sin_addr, he->h_addr_list[0], he->h_length);
4987
4988                 }
4989                 break;
4990 #ifdef HAVE_IPV6
4991                 case AF_INET6:
4992                 {
4993                         struct sockaddr_in6 *sin6p =
4994                                 (struct sockaddr_in6 *) ai->ai_addr;
4995
4996                         memset(sin6p, 0, sizeof(struct sockaddr_in6));
4997
4998                         sin6p->sin6_port = htons(port);
4999                         sin6p->sin6_family = AF_INET6;
5000
5001                         memcpy(&sin6p->sin6_addr,
5002                                he->h_addr_list[0],
5003                                he->h_length);
5004                 }
5005                 break;
5006 #endif
5007         }
5008
5009         ai->ai_next = NULL;
5010
5011         if (he->h_name && !skip_canonname) {
5012                 ai->ai_canonname = strdup(he->h_name);
5013                 if (ai->ai_canonname == NULL) {
5014                         freeaddrinfo(ai);
5015                         return EAI_MEMORY;
5016                 }
5017         }
5018
5019         *pai = ai;
5020         return 0;
5021 }
5022
5023 static int nwrap_getaddrinfo(const char *node,
5024                              const char *service,
5025                              const struct addrinfo *hints,
5026                              struct addrinfo **res)
5027 {
5028         struct addrinfo *ai = NULL;
5029         struct addrinfo *ai_tail;
5030         unsigned short port = 0;
5031         struct {
5032                 int family;
5033                 union {
5034                         struct in_addr v4;
5035 #ifdef HAVE_IPV6
5036                         struct in6_addr v6;
5037                 } in;
5038 #endif
5039         } addr = {
5040                 .family = AF_UNSPEC,
5041         };
5042
5043         if (node == NULL && service == NULL) {
5044                 return EAI_NONAME;
5045         }
5046
5047         if (hints == NULL) {
5048                 hints = &default_hints;
5049         }
5050
5051         /* EAI_BADFLAGS
5052               hints.ai_flags   contains   invalid  flags;  or,  hints.ai_flags
5053               included AI_CANONNAME and name was NULL.
5054         */
5055         if ((hints->ai_flags & AI_CANONNAME) && (node == NULL)) {
5056                 return EAI_BADFLAGS;
5057         }
5058
5059         /* If no node has been specified, let glibc deal with it */
5060         if (node == NULL) {
5061                 int ret;
5062                 struct addrinfo *p = NULL;
5063
5064                 ret = libc_getaddrinfo(node, service, hints, &p);
5065
5066                 if (ret == 0) {
5067                         *res = p;
5068                 }
5069                 return ret;
5070         }
5071
5072         if (service != NULL && service[0] != '\0') {
5073                 const char *proto = NULL;
5074                 struct servent *s;
5075                 char *end_ptr;
5076                 long sl;
5077
5078                 errno = 0;
5079                 sl = strtol(service, &end_ptr, 10);
5080
5081                 if (*end_ptr == '\0') {
5082                         port = sl;
5083                         goto valid_port;
5084                 } else if (hints->ai_flags & AI_NUMERICSERV) {
5085                         return EAI_NONAME;
5086                 }
5087
5088                 if (hints->ai_protocol != 0) {
5089                         struct protoent *pent;
5090
5091                         pent = getprotobynumber(hints->ai_protocol);
5092                         if (pent != NULL) {
5093                                 proto = pent->p_name;
5094                         }
5095                 }
5096
5097                 s = getservbyname(service, proto);
5098                 if (s == NULL) {
5099                         return EAI_NONAME;
5100                 }
5101                 port = ntohs(s->s_port);
5102         }
5103
5104 valid_port:
5105         if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET) {
5106                 int rc = inet_pton(AF_INET, node, &addr.in.v4);
5107                 if (rc == 1) {
5108                         addr.family = AF_INET;
5109                 }
5110         }
5111 #ifdef HAVE_IPV6
5112         if (addr.family == AF_UNSPEC) {
5113                 int rc = inet_pton(AF_INET6, node, &addr.in.v6);
5114                 if (rc == 1) {
5115                         addr.family = AF_INET6;
5116                 }
5117         }
5118 #endif
5119
5120         ai = nwrap_files_getaddrinfo(node, port, hints, &ai_tail);
5121         if (ai == NULL) {
5122                 int ret;
5123                 struct addrinfo *p = NULL;
5124
5125                 ret = libc_getaddrinfo(node, service, hints, &p);
5126
5127                 if (ret == 0) {
5128                         /*
5129                          * nwrap_files_getaddrinfo failed, but libc was
5130                          * successful -- use the result from libc.
5131                          */
5132                         *res = p;
5133                         return 0;
5134                 }
5135
5136                 return EAI_SYSTEM;
5137         }
5138
5139         if (ai->ai_flags == 0) {
5140                 ai->ai_flags = hints->ai_flags;
5141         }
5142         if (ai->ai_socktype == 0) {
5143                 ai->ai_socktype = SOCK_DGRAM;
5144         }
5145         if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_DGRAM) {
5146                 ai->ai_protocol = 17; /* UDP */
5147         } else if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_STREAM) {
5148                 ai->ai_protocol = 6; /* TCP */
5149         }
5150
5151         if (hints->ai_socktype == 0) {
5152                 /* Add second ai */
5153                 struct addrinfo *ai_head = ai;
5154                 struct addrinfo *ai_tmp;
5155                 struct addrinfo *ai_new_tail = ai_tail;
5156
5157                 /* Add at least one more struct */
5158                 do {
5159                         /* CHECKS! */
5160                         ai_tmp = malloc(sizeof(struct addrinfo));
5161                         memcpy(ai_tmp, ai_head, sizeof(struct addrinfo));
5162                         ai_tmp->ai_next = NULL;
5163
5164                         /* We need a deep copy or freeaddrinfo() will blow up */
5165                         if (ai_head->ai_canonname != NULL) {
5166                                 ai_tmp->ai_canonname =
5167                                         strdup(ai_head->ai_canonname);
5168                         }
5169                         /* ai_head should point inside hints. */
5170                         ai_tmp->ai_addr = ai_head->ai_addr;
5171
5172                         if (ai_head->ai_flags == 0) {
5173                                 ai_tmp->ai_flags = hints->ai_flags;
5174                         }
5175                         if (ai_head->ai_socktype == SOCK_DGRAM) {
5176                                 ai_tmp->ai_socktype = SOCK_STREAM;
5177                         } else if (ai_head->ai_socktype == SOCK_STREAM) {
5178                                 ai_tmp->ai_socktype = SOCK_DGRAM;
5179                         }
5180                         if (ai_head->ai_socktype == SOCK_DGRAM) {
5181                                 ai_tmp->ai_protocol = 17; /* UDP */
5182                         } else if (ai_head->ai_socktype == SOCK_STREAM) {
5183                                 ai_tmp->ai_protocol = 6; /* TCP */
5184                         }
5185                         ai_new_tail->ai_next = ai_tmp;
5186                         ai_new_tail = ai_tmp;
5187
5188                         if (ai_head == ai_tail) {
5189                                 break;
5190                         }
5191                         ai_head = ai_head->ai_next;
5192                 } while (1);
5193         }
5194
5195         *res = ai;
5196
5197         return 0;
5198 }
5199
5200 int getaddrinfo(const char *node, const char *service,
5201                 const struct addrinfo *hints,
5202                 struct addrinfo **res)
5203 {
5204         if (!nss_wrapper_hosts_enabled()) {
5205                 return libc_getaddrinfo(node, service, hints, res);
5206         }
5207
5208         return nwrap_getaddrinfo(node, service, hints, res);
5209 }
5210
5211 static int nwrap_getnameinfo(const struct sockaddr *sa, socklen_t salen,
5212                              char *host, size_t hostlen,
5213                              char *serv, size_t servlen,
5214                              int flags)
5215 {
5216         struct hostent *he;
5217         struct servent *service;
5218         const char *proto;
5219         const void *addr;
5220         socklen_t addrlen;
5221         uint16_t port;
5222         sa_family_t type;
5223
5224         if (sa == NULL || salen < sizeof(sa_family_t)) {
5225                 return EAI_FAMILY;
5226         }
5227
5228         if ((flags & NI_NAMEREQD) && host == NULL && serv == NULL) {
5229                 return EAI_NONAME;
5230         }
5231
5232         type = sa->sa_family;
5233         switch (type) {
5234         case AF_INET:
5235                 if (salen < sizeof(struct sockaddr_in))
5236                         return EAI_FAMILY;
5237                 addr = &((const struct sockaddr_in *)sa)->sin_addr;
5238                 addrlen = sizeof(((const struct sockaddr_in *)sa)->sin_addr);
5239                 port = ntohs(((const struct sockaddr_in *)sa)->sin_port);
5240                 break;
5241 #ifdef HAVE_IPV6
5242         case AF_INET6:
5243                 if (salen < sizeof(struct sockaddr_in6))
5244                         return EAI_FAMILY;
5245                 addr = &((const struct sockaddr_in6 *)sa)->sin6_addr;
5246                 addrlen = sizeof(((const struct sockaddr_in6 *)sa)->sin6_addr);
5247                 port = ntohs(((const struct sockaddr_in6 *)sa)->sin6_port);
5248                 break;
5249 #endif
5250         default:
5251                 return EAI_FAMILY;
5252         }
5253
5254         if (host != NULL) {
5255                 he = NULL;
5256                 if ((flags & NI_NUMERICHOST) == 0) {
5257                         he = nwrap_files_gethostbyaddr(addr, addrlen, type);
5258                         if ((flags & NI_NAMEREQD) && (he == NULL || he->h_name == NULL))
5259                                 return EAI_NONAME;
5260                 }
5261                 if (he != NULL && he->h_name != NULL) {
5262                         if (strlen(he->h_name) >= hostlen)
5263                                 return EAI_OVERFLOW;
5264                         strcpy(host, he->h_name);
5265                         if (flags & NI_NOFQDN)
5266                                 host[strcspn(host, ".")] = '\0';
5267                 } else {
5268                         if (inet_ntop(type, addr, host, hostlen) == NULL)
5269                                 return (errno == ENOSPC) ? EAI_OVERFLOW : EAI_FAIL;
5270                 }
5271         }
5272
5273         if (serv != NULL) {
5274                 service = NULL;
5275                 if ((flags & NI_NUMERICSERV) == 0) {
5276                         proto = (flags & NI_DGRAM) ? "udp" : "tcp";
5277                         service = getservbyport(htons(port), proto);
5278                 }
5279                 if (service != NULL) {
5280                         if (strlen(service->s_name) >= servlen)
5281                                 return EAI_OVERFLOW;
5282                         strcpy(serv, service->s_name);
5283                 } else {
5284                         if (snprintf(serv, servlen, "%u", port) >= (int) servlen)
5285                                 return EAI_OVERFLOW;
5286                 }
5287         }
5288
5289         return 0;
5290 }
5291
5292 #ifdef HAVE_LINUX_GETNAMEINFO
5293 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5294                 char *host, socklen_t hostlen,
5295                 char *serv, socklen_t servlen,
5296                 int flags)
5297 #elif defined(HAVE_LINUX_GETNAMEINFO_UNSIGNED)
5298 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5299                 char *host, socklen_t hostlen,
5300                 char *serv, socklen_t servlen,
5301                 unsigned int flags)
5302 #else
5303 int getnameinfo(const struct sockaddr *sa, socklen_t salen,
5304                 char *host, size_t hostlen,
5305                 char *serv, size_t servlen,
5306                 int flags)
5307 #endif
5308 {
5309         if (!nss_wrapper_hosts_enabled()) {
5310                 return libc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5311         }
5312
5313         return nwrap_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
5314 }
5315
5316 static int nwrap_gethostname(char *name, size_t len)
5317 {
5318         const char *hostname = getenv("NSS_WRAPPER_HOSTNAME");
5319
5320         if (strlen(hostname) >= len) {
5321                 errno = ENAMETOOLONG;
5322                 return -1;
5323         }
5324         snprintf(name, len, "%s", hostname);
5325
5326         return 0;
5327 }
5328
5329 #ifdef HAVE_SOLARIS_GETHOSTNAME
5330 int gethostname(char *name, int len)
5331 #else /* HAVE_SOLARIS_GETHOSTNAME */
5332 int gethostname(char *name, size_t len)
5333 #endif /* HAVE_SOLARIS_GETHOSTNAME */
5334 {
5335         if (!nwrap_hostname_enabled()) {
5336                 return libc_gethostname(name, len);
5337         }
5338
5339         return nwrap_gethostname(name, len);
5340 }
5341
5342 /****************************
5343  * DESTRUCTOR
5344  ***************************/
5345
5346 /*
5347  * This function is called when the library is unloaded and makes sure that
5348  * sockets get closed and the unix file for the socket are unlinked.
5349  */
5350 void nwrap_destructor(void)
5351 {
5352         int i;
5353
5354         NWRAP_LOCK_ALL;
5355         if (nwrap_main_global != NULL) {
5356                 struct nwrap_main *m = nwrap_main_global;
5357
5358                 /* libc */
5359                 SAFE_FREE(m->libc->fns);
5360                 if (m->libc->handle != NULL) {
5361                         dlclose(m->libc->handle);
5362                 }
5363                 if (m->libc->nsl_handle != NULL) {
5364                         dlclose(m->libc->nsl_handle);
5365                 }
5366                 if (m->libc->sock_handle != NULL) {
5367                         dlclose(m->libc->sock_handle);
5368                 }
5369                 SAFE_FREE(m->libc);
5370
5371                 /* backends */
5372                 for (i = 0; i < m->num_backends; i++) {
5373                         struct nwrap_backend *b = &(m->backends[i]);
5374
5375                         if (b->so_handle != NULL) {
5376                                 dlclose(b->so_handle);
5377                         }
5378                         SAFE_FREE(b->fns);
5379                 }
5380                 SAFE_FREE(m->backends);
5381         }
5382
5383         if (nwrap_pw_global.cache != NULL) {
5384                 struct nwrap_cache *c = nwrap_pw_global.cache;
5385
5386                 nwrap_files_cache_unload(c);
5387                 if (c->fd >= 0) {
5388                         fclose(c->fp);
5389                         c->fd = -1;
5390                 }
5391
5392                 SAFE_FREE(nwrap_pw_global.list);
5393                 nwrap_pw_global.num = 0;
5394         }
5395
5396         if (nwrap_gr_global.cache != NULL) {
5397                 struct nwrap_cache *c = nwrap_gr_global.cache;
5398
5399                 nwrap_files_cache_unload(c);
5400                 if (c->fd >= 0) {
5401                         fclose(c->fp);
5402                         c->fd = -1;
5403                 }
5404
5405                 SAFE_FREE(nwrap_gr_global.list);
5406                 nwrap_pw_global.num = 0;
5407         }
5408
5409         if (nwrap_he_global.cache != NULL) {
5410                 struct nwrap_cache *c = nwrap_he_global.cache;
5411
5412                 nwrap_files_cache_unload(c);
5413                 if (c->fd >= 0) {
5414                         fclose(c->fp);
5415                         c->fd = -1;
5416                 }
5417
5418                 nwrap_he_global.num = 0;
5419         }
5420
5421         hdestroy();
5422         NWRAP_UNLOCK_ALL;
5423 }