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