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  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of the author nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #ifdef _SAMBA_BUILD_
  36
  37 /* defining this gives us the posix getpwnam_r() calls on solaris
  38    Thanks to heimdal for this */
  39 #define _POSIX_PTHREAD_SEMANTICS
  40
  41 #define NSS_WRAPPER_NOT_REPLACE
  42 #include "../replace/replace.h"
  43 #include "system/passwd.h"
  44 #include "system/filesys.h"
  45 #include "../nsswitch/nsstest.h"
  46
  47 #else /* _SAMBA_BUILD_ */
  48
  49 #error nss_wrapper_only_supported_in_samba_yet
  50
  51 #endif
  52
  53 #ifndef _PUBLIC_
  54 #define _PUBLIC_
  55 #endif
  56
  57 /* not all systems have _r functions... */
  58 #ifndef HAVE_GETPWNAM_R
  59 #define getpwnam_r(name, pwdst, buf, buflen, pwdstp)    ENOSYS
  60 #endif
  61 #ifndef HAVE_GETPWUID_R
  62 #define getpwuid_r(uid, pwdst, buf, buflen, pwdstp)     ENOSYS
  63 #endif
  64 #ifndef HAVE_GETPWENT_R
  65 #define getpwent_r(pwdst, buf, buflen, pwdstp)          ENOSYS
  66 #endif
  67 #ifndef HAVE_GETGRNAM_R
  68 #define getgrnam_r(name, grdst, buf, buflen, grdstp)    ENOSYS
  69 #endif
  70 #ifndef HAVE_GETGRGID_R
  71 #define getgrgid_r(gid, grdst, buf, buflen, grdstp)     ENOSYS
  72 #endif
  73 #ifndef HAVE_GETGRENT_R
  74 #define getgrent_r(grdst, buf, buflen, grdstp)          ENOSYS
  75 #endif
  76
  77 /* not all systems have getgrouplist */
  78 #ifndef HAVE_GETGROUPLIST
  79 #define getgrouplist(user, group, groups, ngroups)      0
  80 #endif
  81
  82 /* LD_PRELOAD doesn't work yet, so REWRITE_CALLS is all we support
  83  * for now */
  84 #define REWRITE_CALLS
  85
  86 #ifdef REWRITE_CALLS
  87
  88 #define real_getpwnam           getpwnam
  89 #define real_getpwnam_r         getpwnam_r
  90 #define real_getpwuid           getpwuid
  91 #define real_getpwuid_r         getpwuid_r
  92
  93 #define real_setpwent           setpwent
  94 #define real_getpwent           getpwent
  95 #define real_getpwent_r         getpwent_r
  96 #define real_endpwent           endpwent
  97
  98 /*
  99 #define real_getgrlst           getgrlst
 100 #define real_getgrlst_r         getgrlst_r
 101 #define real_initgroups_dyn     initgroups_dyn
 102 */
 103 #define real_initgroups         initgroups
 104 #define real_getgrouplist       getgrouplist
 105
 106 #define real_getgrnam           getgrnam
 107 #define real_getgrnam_r         getgrnam_r
 108 #define real_getgrgid           getgrgid
 109 #define real_getgrgid_r         getgrgid_r
 110
 111 #define real_setgrent           setgrent
 112 #define real_getgrent           getgrent
 113 #define real_getgrent_r         getgrent_r
 114 #define real_endgrent           endgrent
 115
 116 #endif
 117
 118 #if 0
 119 # ifdef DEBUG
 120 # define NWRAP_ERROR(args)      DEBUG(0, args)
 121 # else
 122 # define NWRAP_ERROR(args)      printf args
 123 # endif
 124 #else
 125 #define NWRAP_ERROR(args)
 126 #endif
 127
 128 #if 0
 129 # ifdef DEBUG
 130 # define NWRAP_DEBUG(args)      DEBUG(0, args)
 131 # else
 132 # define NWRAP_DEBUG(args)      printf args
 133 # endif
 134 #else
 135 #define NWRAP_DEBUG(args)
 136 #endif
 137
 138 #if 0
 139 # ifdef DEBUG
 140 # define NWRAP_VERBOSE(args)    DEBUG(0, args)
 141 # else
 142 # define NWRAP_VERBOSE(args)    printf args
 143 # endif
 144 #else
 145 #define NWRAP_VERBOSE(args)
 146 #endif
 147
 148 struct nwrap_module_nss_fns {
 149         NSS_STATUS (*_nss_getpwnam_r)(const char *name, struct passwd *result, char *buffer,
 150                                       size_t buflen, int *errnop);
 151         NSS_STATUS (*_nss_getpwuid_r)(uid_t uid, struct passwd *result, char *buffer,
 152                                       size_t buflen, int *errnop);
 153         NSS_STATUS (*_nss_setpwent)(void);
 154         NSS_STATUS (*_nss_getpwent_r)(struct passwd *result, char *buffer,
 155                                       size_t buflen, int *errnop);
 156         NSS_STATUS (*_nss_endpwent)(void);
 157         NSS_STATUS (*_nss_initgroups)(const char *user, gid_t group, long int *start,
 158                                       long int *size, gid_t **groups, long int limit, int *errnop);
 159         NSS_STATUS (*_nss_getgrnam_r)(const char *name, struct group *result, char *buffer,
 160                                       size_t buflen, int *errnop);
 161         NSS_STATUS (*_nss_getgrgid_r)(gid_t gid, struct group *result, char *buffer,
 162                                       size_t buflen, int *errnop);
 163         NSS_STATUS (*_nss_setgrent)(void);
 164         NSS_STATUS (*_nss_getgrent_r)(struct group *result, char *buffer,
 165                                       size_t buflen, int *errnop);
 166         NSS_STATUS (*_nss_endgrent)(void);
 167 };
 168
 169 struct nwrap_backend {
 170         const char *name;
 171         const char *so_path;
 172         void *so_handle;
 173         struct nwrap_ops *ops;
 174         struct nwrap_module_nss_fns *fns;
 175 };
 176
 177 struct nwrap_ops {
 178         struct passwd * (*nw_getpwnam)(struct nwrap_backend *b,
 179                                        const char *name);
 180         int             (*nw_getpwnam_r)(struct nwrap_backend *b,
 181                                          const char *name, struct passwd *pwdst,
 182                                          char *buf, size_t buflen, struct passwd **pwdstp);
 183         struct passwd * (*nw_getpwuid)(struct nwrap_backend *b,
 184                                        uid_t uid);
 185         int             (*nw_getpwuid_r)(struct nwrap_backend *b,
 186                                          uid_t uid, struct passwd *pwdst,
 187                                          char *buf, size_t buflen, struct passwd **pwdstp);
 188         void            (*nw_setpwent)(struct nwrap_backend *b);
 189         struct passwd * (*nw_getpwent)(struct nwrap_backend *b);
 190         int             (*nw_getpwent_r)(struct nwrap_backend *b,
 191                                          struct passwd *pwdst, char *buf,
 192                                          size_t buflen, struct passwd **pwdstp);
 193         void            (*nw_endpwent)(struct nwrap_backend *b);
 194         int             (*nw_initgroups)(struct nwrap_backend *b,
 195                                          const char *user, gid_t group);
 196         struct group *  (*nw_getgrnam)(struct nwrap_backend *b,
 197                                        const char *name);
 198         int             (*nw_getgrnam_r)(struct nwrap_backend *b,
 199                                          const char *name, struct group *grdst,
 200                                          char *buf, size_t buflen, struct group **grdstp);
 201         struct group *  (*nw_getgrgid)(struct nwrap_backend *b,
 202                                        gid_t gid);
 203         int             (*nw_getgrgid_r)(struct nwrap_backend *b,
 204                                          gid_t gid, struct group *grdst,
 205                                          char *buf, size_t buflen, struct group **grdstp);
 206         void            (*nw_setgrent)(struct nwrap_backend *b);
 207         struct group *  (*nw_getgrent)(struct nwrap_backend *b);
 208         int             (*nw_getgrent_r)(struct nwrap_backend *b,
 209                                          struct group *grdst, char *buf,
 210                                          size_t buflen, struct group **grdstp);
 211         void            (*nw_endgrent)(struct nwrap_backend *b);
 212 };
 213
 214 /* prototypes for files backend */
 215
 216
 217 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
 218                                            const char *name);
 219 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
 220                                   const char *name, struct passwd *pwdst,
 221                                   char *buf, size_t buflen, struct passwd **pwdstp);
 222 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
 223                                            uid_t uid);
 224 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
 225                                   uid_t uid, struct passwd *pwdst,
 226                                   char *buf, size_t buflen, struct passwd **pwdstp);
 227 static void nwrap_files_setpwent(struct nwrap_backend *b);
 228 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b);
 229 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
 230                                   struct passwd *pwdst, char *buf,
 231                                   size_t buflen, struct passwd **pwdstp);
 232 static void nwrap_files_endpwent(struct nwrap_backend *b);
 233 static int nwrap_files_initgroups(struct nwrap_backend *b,
 234                                   const char *user, gid_t group);
 235 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
 236                                           const char *name);
 237 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
 238                                   const char *name, struct group *grdst,
 239                                   char *buf, size_t buflen, struct group **grdstp);
 240 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
 241                                           gid_t gid);
 242 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
 243                                   gid_t gid, struct group *grdst,
 244                                   char *buf, size_t buflen, struct group **grdstp);
 245 static void nwrap_files_setgrent(struct nwrap_backend *b);
 246 static struct group *nwrap_files_getgrent(struct nwrap_backend *b);
 247 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
 248                                   struct group *grdst, char *buf,
 249                                   size_t buflen, struct group **grdstp);
 250 static void nwrap_files_endgrent(struct nwrap_backend *b);
 251
 252 /* prototypes for module backend */
 253
 254 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
 255 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
 256                                    struct passwd *pwdst, char *buf,
 257                                    size_t buflen, struct passwd **pwdstp);
 258 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
 259                                             const char *name);
 260 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
 261                                    const char *name, struct passwd *pwdst,
 262                                    char *buf, size_t buflen, struct passwd **pwdstp);
 263 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
 264                                             uid_t uid);
 265 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
 266                                    uid_t uid, struct passwd *pwdst,
 267                                    char *buf, size_t buflen, struct passwd **pwdstp);
 268 static void nwrap_module_setpwent(struct nwrap_backend *b);
 269 static void nwrap_module_endpwent(struct nwrap_backend *b);
 270 static struct group *nwrap_module_getgrent(struct nwrap_backend *b);
 271 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
 272                                    struct group *grdst, char *buf,
 273                                    size_t buflen, struct group **grdstp);
 274 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
 275                                            const char *name);
 276 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
 277                                    const char *name, struct group *grdst,
 278                                    char *buf, size_t buflen, struct group **grdstp);
 279 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
 280                                            gid_t gid);
 281 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
 282                                    gid_t gid, struct group *grdst,
 283                                    char *buf, size_t buflen, struct group **grdstp);
 284 static void nwrap_module_setgrent(struct nwrap_backend *b);
 285 static void nwrap_module_endgrent(struct nwrap_backend *b);
 286 static int nwrap_module_initgroups(struct nwrap_backend *b,
 287                                    const char *user, gid_t group);
 288
 289 struct nwrap_ops nwrap_files_ops = {
 290         .nw_getpwnam    = nwrap_files_getpwnam,
 291         .nw_getpwnam_r  = nwrap_files_getpwnam_r,
 292         .nw_getpwuid    = nwrap_files_getpwuid,
 293         .nw_getpwuid_r  = nwrap_files_getpwuid_r,
 294         .nw_setpwent    = nwrap_files_setpwent,
 295         .nw_getpwent    = nwrap_files_getpwent,
 296         .nw_getpwent_r  = nwrap_files_getpwent_r,
 297         .nw_endpwent    = nwrap_files_endpwent,
 298         .nw_initgroups  = nwrap_files_initgroups,
 299         .nw_getgrnam    = nwrap_files_getgrnam,
 300         .nw_getgrnam_r  = nwrap_files_getgrnam_r,
 301         .nw_getgrgid    = nwrap_files_getgrgid,
 302         .nw_getgrgid_r  = nwrap_files_getgrgid_r,
 303         .nw_setgrent    = nwrap_files_setgrent,
 304         .nw_getgrent    = nwrap_files_getgrent,
 305         .nw_getgrent_r  = nwrap_files_getgrent_r,
 306         .nw_endgrent    = nwrap_files_endgrent,
 307 };
 308
 309 struct nwrap_ops nwrap_module_ops = {
 310         .nw_getpwnam    = nwrap_module_getpwnam,
 311         .nw_getpwnam_r  = nwrap_module_getpwnam_r,
 312         .nw_getpwuid    = nwrap_module_getpwuid,
 313         .nw_getpwuid_r  = nwrap_module_getpwuid_r,
 314         .nw_setpwent    = nwrap_module_setpwent,
 315         .nw_getpwent    = nwrap_module_getpwent,
 316         .nw_getpwent_r  = nwrap_module_getpwent_r,
 317         .nw_endpwent    = nwrap_module_endpwent,
 318         .nw_initgroups  = nwrap_module_initgroups,
 319         .nw_getgrnam    = nwrap_module_getgrnam,
 320         .nw_getgrnam_r  = nwrap_module_getgrnam_r,
 321         .nw_getgrgid    = nwrap_module_getgrgid,
 322         .nw_getgrgid_r  = nwrap_module_getgrgid_r,
 323         .nw_setgrent    = nwrap_module_setgrent,
 324         .nw_getgrent    = nwrap_module_getgrent,
 325         .nw_getgrent_r  = nwrap_module_getgrent_r,
 326         .nw_endgrent    = nwrap_module_endgrent,
 327 };
 328
 329 struct nwrap_main {
 330         const char *nwrap_switch;
 331         int num_backends;
 332         struct nwrap_backend *backends;
 333 };
 334
 335 struct nwrap_main *nwrap_main_global;
 336 struct nwrap_main __nwrap_main_global;
 337
 338 struct nwrap_cache {
 339         const char *path;
 340         int fd;
 341         struct stat st;
 342         uint8_t *buf;
 343         void *private_data;
 344         bool (*parse_line)(struct nwrap_cache *, char *line);
 345         void (*unload)(struct nwrap_cache *);
 346 };
 347
 348 struct nwrap_pw {
 349         struct nwrap_cache *cache;
 350
 351         struct passwd *list;
 352         int num;
 353         int idx;
 354 };
 355
 356 struct nwrap_cache __nwrap_cache_pw;
 357 struct nwrap_pw nwrap_pw_global;
 358
 359 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line);
 360 static void nwrap_pw_unload(struct nwrap_cache *nwrap);
 361
 362 struct nwrap_gr {
 363         struct nwrap_cache *cache;
 364
 365         struct group *list;
 366         int num;
 367         int idx;
 368 };
 369
 370 struct nwrap_cache __nwrap_cache_gr;
 371 struct nwrap_gr nwrap_gr_global;
 372
 373 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line);
 374 static void nwrap_gr_unload(struct nwrap_cache *nwrap);
 375
 376 static void *nwrap_load_module_fn(struct nwrap_backend *b,
 377                                   const char *fn_name)
 378 {
 379         void *res;
 380         char *s;
 381
 382         if (!b->so_handle) {
 383                 NWRAP_ERROR(("%s: no handle\n",
 384                              __location__));
 385                 return NULL;
 386         }
 387
 388         if (asprintf(&s, "_nss_%s_%s", b->name, fn_name) == -1) {
 389                 NWRAP_ERROR(("%s: out of memory\n",
 390                              __location__));
 391                 return NULL;
 392         }
 393
 394         res = dlsym(b->so_handle, s);
 395         if (!res) {
 396                 NWRAP_ERROR(("%s: cannot find function %s in %s\n",
 397                              __location__, s, b->so_path));
 398         }
 399         free(s);
 400         s = NULL;
 401         return res;
 402 }
 403
 404 static struct nwrap_module_nss_fns *nwrap_load_module_fns(struct nwrap_backend *b)
 405 {
 406         struct nwrap_module_nss_fns *fns;
 407
 408         if (!b->so_handle) {
 409                 return NULL;
 410         }
 411
 412         fns = (struct nwrap_module_nss_fns *)malloc(sizeof(struct nwrap_module_nss_fns));
 413         if (!fns) {
 414                 return NULL;
 415         }
 416
 417         fns->_nss_getpwnam_r    = (NSS_STATUS (*)(const char *, struct passwd *, char *, size_t, int *))
 418                                   nwrap_load_module_fn(b, "getpwnam_r");
 419         fns->_nss_getpwuid_r    = (NSS_STATUS (*)(uid_t, struct passwd *, char *, size_t, int *))
 420                                   nwrap_load_module_fn(b, "getpwuid_r");
 421         fns->_nss_setpwent      = (NSS_STATUS(*)(void))
 422                                   nwrap_load_module_fn(b, "setpwent");
 423         fns->_nss_getpwent_r    = (NSS_STATUS (*)(struct passwd *, char *, size_t, int *))
 424                                   nwrap_load_module_fn(b, "getpwent_r");
 425         fns->_nss_endpwent      = (NSS_STATUS(*)(void))
 426                                   nwrap_load_module_fn(b, "endpwent");
 427         fns->_nss_initgroups    = (NSS_STATUS (*)(const char *, gid_t, long int *, long int *, gid_t **, long int, int *))
 428                                   nwrap_load_module_fn(b, "initgroups_dyn");
 429         fns->_nss_getgrnam_r    = (NSS_STATUS (*)(const char *, struct group *, char *, size_t, int *))
 430                                   nwrap_load_module_fn(b, "getgrnam_r");
 431         fns->_nss_getgrgid_r    = (NSS_STATUS (*)(gid_t, struct group *, char *, size_t, int *))
 432                                   nwrap_load_module_fn(b, "getgrgid_r");
 433         fns->_nss_setgrent      = (NSS_STATUS(*)(void))
 434                                   nwrap_load_module_fn(b, "setgrent");
 435         fns->_nss_getgrent_r    = (NSS_STATUS (*)(struct group *, char *, size_t, int *))
 436                                   nwrap_load_module_fn(b, "getgrent_r");
 437         fns->_nss_endgrent      = (NSS_STATUS(*)(void))
 438                                   nwrap_load_module_fn(b, "endgrent");
 439
 440         return fns;
 441 }
 442
 443 static void *nwrap_load_module(const char *so_path)
 444 {
 445         void *h;
 446
 447         if (!so_path || !strlen(so_path)) {
 448                 return NULL;
 449         }
 450
 451         h = dlopen(so_path, RTLD_LAZY);
 452         if (!h) {
 453                 NWRAP_ERROR(("%s: cannot open shared library %s\n",
 454                              __location__, so_path));
 455                 return NULL;
 456         }
 457
 458         return h;
 459 }
 460
 461 static bool nwrap_module_init(const char *name,
 462                               struct nwrap_ops *ops,
 463                               const char *so_path,
 464                               int *num_backends,
 465                               struct nwrap_backend **backends)
 466 {
 467         *backends = (struct nwrap_backend *)realloc(*backends,
 468                 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
 469         if (!*backends) {
 470                 NWRAP_ERROR(("%s: out of memory\n",
 471                              __location__));
 472                 return false;
 473         }
 474
 475         (*backends)[*num_backends].name = name;
 476         (*backends)[*num_backends].ops = ops;
 477         (*backends)[*num_backends].so_path = so_path;
 478         (*backends)[*num_backends].so_handle = nwrap_load_module(so_path);
 479         (*backends)[*num_backends].fns = nwrap_load_module_fns(&((*backends)[*num_backends]));
 480
 481         (*num_backends)++;
 482
 483         return true;
 484 }
 485
 486 static void nwrap_backend_init(struct nwrap_main *r)
 487 {
 488         const char *winbind_so_path = getenv("NSS_WRAPPER_WINBIND_SO_PATH");
 489
 490         r->num_backends = 0;
 491         r->backends = NULL;
 492
 493         if (!nwrap_module_init("files", &nwrap_files_ops, NULL,
 494                                &r->num_backends,
 495                                &r->backends)) {
 496                 NWRAP_ERROR(("%s: failed to initialize 'files' backend\n",
 497                              __location__));
 498                 return;
 499         }
 500
 501         if (winbind_so_path && strlen(winbind_so_path)) {
 502                 if (!nwrap_module_init("winbind", &nwrap_module_ops, winbind_so_path,
 503                                        &r->num_backends,
 504                                        &r->backends)) {
 505                         NWRAP_ERROR(("%s: failed to initialize 'winbind' backend\n",
 506                                      __location__));
 507                         return;
 508                 }
 509         }
 510 }
 511
 512 static void nwrap_init(void)
 513 {
 514         static bool initialized;
 515
 516         if (initialized) return;
 517         initialized = true;
 518
 519         nwrap_main_global = &__nwrap_main_global;
 520
 521         nwrap_backend_init(nwrap_main_global);
 522
 523         nwrap_pw_global.cache = &__nwrap_cache_pw;
 524
 525         nwrap_pw_global.cache->path = getenv("NSS_WRAPPER_PASSWD");
 526         nwrap_pw_global.cache->fd = -1;
 527         nwrap_pw_global.cache->private_data = &nwrap_pw_global;
 528         nwrap_pw_global.cache->parse_line = nwrap_pw_parse_line;
 529         nwrap_pw_global.cache->unload = nwrap_pw_unload;
 530
 531         nwrap_gr_global.cache = &__nwrap_cache_gr;
 532
 533         nwrap_gr_global.cache->path = getenv("NSS_WRAPPER_GROUP");
 534         nwrap_gr_global.cache->fd = -1;
 535         nwrap_gr_global.cache->private_data = &nwrap_gr_global;
 536         nwrap_gr_global.cache->parse_line = nwrap_gr_parse_line;
 537         nwrap_gr_global.cache->unload = nwrap_gr_unload;
 538 }
 539
 540 static bool nwrap_enabled(void)
 541 {
 542         nwrap_init();
 543
 544         if (!nwrap_pw_global.cache->path) {
 545                 return false;
 546         }
 547         if (nwrap_pw_global.cache->path[0] == '\0') {
 548                 return false;
 549         }
 550         if (!nwrap_gr_global.cache->path) {
 551                 return false;
 552         }
 553         if (nwrap_gr_global.cache->path[0] == '\0') {
 554                 return false;
 555         }
 556
 557         return true;
 558 }
 559
 560 static bool nwrap_parse_file(struct nwrap_cache *nwrap)
 561 {
 562         int ret;
 563         uint8_t *buf = NULL;
 564         char *nline;
 565
 566         if (nwrap->st.st_size == 0) {
 567                 NWRAP_DEBUG(("%s: size == 0\n",
 568                              __location__));
 569                 goto done;
 570         }
 571
 572         if (nwrap->st.st_size > INT32_MAX) {
 573                 NWRAP_ERROR(("%s: size[%u] larger than INT32_MAX\n",
 574                              __location__, (unsigned)nwrap->st.st_size));
 575                 goto failed;
 576         }
 577
 578         ret = lseek(nwrap->fd, 0, SEEK_SET);
 579         if (ret != 0) {
 580                 NWRAP_ERROR(("%s: lseek - %d\n",__location__,ret));
 581                 goto failed;
 582         }
 583
 584         buf = (uint8_t *)malloc(nwrap->st.st_size + 1);
 585         if (!buf) {
 586                 NWRAP_ERROR(("%s: malloc failed\n",__location__));
 587                 goto failed;
 588         }
 589
 590         ret = read(nwrap->fd, buf, nwrap->st.st_size);
 591         if (ret != nwrap->st.st_size) {
 592                 NWRAP_ERROR(("%s: read(%u) gave %d\n",
 593                              __location__, (unsigned)nwrap->st.st_size, ret));
 594                 goto failed;
 595         }
 596
 597         buf[nwrap->st.st_size] = '\0';
 598
 599         nline = (char *)buf;
 600         while (nline && nline[0]) {
 601                 char *line;
 602                 char *e;
 603                 bool ok;
 604
 605                 line = nline;
 606                 nline = NULL;
 607
 608                 e = strchr(line, '\n');
 609                 if (e) {
 610                         e[0] = '\0';
 611                         e++;
 612                         if (e[0] == '\r') {
 613                                 e[0] = '\0';
 614                                 e++;
 615                         }
 616                         nline = e;
 617                 }
 618
 619                 NWRAP_VERBOSE(("%s:'%s'\n",__location__, line));
 620
 621                 if (strlen(line) == 0) {
 622                         continue;
 623                 }
 624
 625                 ok = nwrap->parse_line(nwrap, line);
 626                 if (!ok) {
 627                         goto failed;
 628                 }
 629         }
 630
 631 done:
 632         nwrap->buf = buf;
 633         return true;
 634
 635 failed:
 636         if (buf) free(buf);
 637         return false;
 638 }
 639
 640 static void nwrap_files_cache_unload(struct nwrap_cache *nwrap)
 641 {
 642         nwrap->unload(nwrap);
 643
 644         if (nwrap->buf) free(nwrap->buf);
 645
 646         nwrap->buf = NULL;
 647 }
 648
 649 static void nwrap_files_cache_reload(struct nwrap_cache *nwrap)
 650 {
 651         struct stat st;
 652         int ret;
 653         bool ok;
 654         bool retried = false;
 655
 656 reopen:
 657         if (nwrap->fd < 0) {
 658                 nwrap->fd = open(nwrap->path, O_RDONLY);
 659                 if (nwrap->fd < 0) {
 660                         NWRAP_ERROR(("%s: unable to open '%s' readonly %d:%s\n",
 661                                      __location__,
 662                                      nwrap->path, nwrap->fd,
 663                                      strerror(errno)));
 664                         return;
 665                 }
 666                 NWRAP_VERBOSE(("%s: open '%s'\n", __location__, nwrap->path));
 667         }
 668
 669         ret = fstat(nwrap->fd, &st);
 670         if (ret != 0) {
 671                 NWRAP_ERROR(("%s: fstat(%s) - %d:%s\n",
 672                              __location__,
 673                              nwrap->path,
 674                              ret, strerror(errno)));
 675                 return;
 676         }
 677
 678         if (retried == false && st.st_nlink == 0) {
 679                 /* maybe someone has replaced the file... */
 680                 NWRAP_DEBUG(("%s: st_nlink == 0, reopen %s\n",
 681                              __location__, nwrap->path));
 682                 retried = true;
 683                 memset(&nwrap->st, 0, sizeof(nwrap->st));
 684                 close(nwrap->fd);
 685                 nwrap->fd = -1;
 686                 goto reopen;
 687         }
 688
 689         if (st.st_mtime == nwrap->st.st_mtime) {
 690                 NWRAP_VERBOSE(("%s: st_mtime[%u] hasn't changed, skip reload\n",
 691                                __location__, (unsigned)st.st_mtime));
 692                 return;
 693         }
 694         NWRAP_DEBUG(("%s: st_mtime has changed [%u] => [%u], start reload\n",
 695                      __location__, (unsigned)st.st_mtime,
 696                      (unsigned)nwrap->st.st_mtime));
 697
 698         nwrap->st = st;
 699
 700         nwrap_files_cache_unload(nwrap);
 701
 702         ok = nwrap_parse_file(nwrap);
 703         if (!ok) {
 704                 NWRAP_ERROR(("%s: failed to reload %s\n",
 705                              __location__, nwrap->path));
 706                 nwrap_files_cache_unload(nwrap);
 707         }
 708         NWRAP_DEBUG(("%s: reloaded %s\n",
 709                      __location__, nwrap->path));
 710 }
 711
 712 /*
 713  * the caller has to call nwrap_unload() on failure
 714  */
 715 static bool nwrap_pw_parse_line(struct nwrap_cache *nwrap, char *line)
 716 {
 717         struct nwrap_pw *nwrap_pw;
 718         char *c;
 719         char *p;
 720         char *e;
 721         struct passwd *pw;
 722         size_t list_size;
 723
 724         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
 725
 726         list_size = sizeof(*nwrap_pw->list) * (nwrap_pw->num+1);
 727         pw = (struct passwd *)realloc(nwrap_pw->list, list_size);
 728         if (!pw) {
 729                 NWRAP_ERROR(("%s:realloc(%u) failed\n",
 730                              __location__, list_size));
 731                 return false;
 732         }
 733         nwrap_pw->list = pw;
 734
 735         pw = &nwrap_pw->list[nwrap_pw->num];
 736
 737         c = line;
 738
 739         /* name */
 740         p = strchr(c, ':');
 741         if (!p) {
 742                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 743                              __location__, line, c));
 744                 return false;
 745         }
 746         *p = '\0';
 747         p++;
 748         pw->pw_name = c;
 749         c = p;
 750
 751         NWRAP_VERBOSE(("name[%s]\n", pw->pw_name));
 752
 753         /* password */
 754         p = strchr(c, ':');
 755         if (!p) {
 756                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 757                              __location__, line, c));
 758                 return false;
 759         }
 760         *p = '\0';
 761         p++;
 762         pw->pw_passwd = c;
 763         c = p;
 764
 765         NWRAP_VERBOSE(("password[%s]\n", pw->pw_passwd));
 766
 767         /* uid */
 768         p = strchr(c, ':');
 769         if (!p) {
 770                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 771                              __location__, line, c));
 772                 return false;
 773         }
 774         *p = '\0';
 775         p++;
 776         e = NULL;
 777         pw->pw_uid = (uid_t)strtoul(c, &e, 10);
 778         if (c == e) {
 779                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 780                              __location__, line, c, strerror(errno)));
 781                 return false;
 782         }
 783         if (e == NULL) {
 784                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 785                              __location__, line, c, strerror(errno)));
 786                 return false;
 787         }
 788         if (e[0] != '\0') {
 789                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 790                              __location__, line, c, strerror(errno)));
 791                 return false;
 792         }
 793         c = p;
 794
 795         NWRAP_VERBOSE(("uid[%u]\n", pw->pw_uid));
 796
 797         /* gid */
 798         p = strchr(c, ':');
 799         if (!p) {
 800                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 801                              __location__, line, c));
 802                 return false;
 803         }
 804         *p = '\0';
 805         p++;
 806         e = NULL;
 807         pw->pw_gid = (gid_t)strtoul(c, &e, 10);
 808         if (c == e) {
 809                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 810                              __location__, line, c, strerror(errno)));
 811                 return false;
 812         }
 813         if (e == NULL) {
 814                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 815                              __location__, line, c, strerror(errno)));
 816                 return false;
 817         }
 818         if (e[0] != '\0') {
 819                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 820                              __location__, line, c, strerror(errno)));
 821                 return false;
 822         }
 823         c = p;
 824
 825         NWRAP_VERBOSE(("gid[%u]\n", pw->pw_gid));
 826
 827         /* gecos */
 828         p = strchr(c, ':');
 829         if (!p) {
 830                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 831                              __location__, line, c));
 832                 return false;
 833         }
 834         *p = '\0';
 835         p++;
 836         pw->pw_gecos = c;
 837         c = p;
 838
 839         NWRAP_VERBOSE(("gecos[%s]\n", pw->pw_gecos));
 840
 841         /* dir */
 842         p = strchr(c, ':');
 843         if (!p) {
 844                 NWRAP_ERROR(("%s:'%s'\n",__location__,c));
 845                 return false;
 846         }
 847         *p = '\0';
 848         p++;
 849         pw->pw_dir = c;
 850         c = p;
 851
 852         NWRAP_VERBOSE(("dir[%s]\n", pw->pw_dir));
 853
 854         /* shell */
 855         pw->pw_shell = c;
 856         NWRAP_VERBOSE(("shell[%s]\n", pw->pw_shell));
 857
 858         NWRAP_DEBUG(("add user[%s:%s:%u:%u:%s:%s:%s]\n",
 859                      pw->pw_name, pw->pw_passwd,
 860                      pw->pw_uid, pw->pw_gid,
 861                      pw->pw_gecos, pw->pw_dir, pw->pw_shell));
 862
 863         nwrap_pw->num++;
 864         return true;
 865 }
 866
 867 static void nwrap_pw_unload(struct nwrap_cache *nwrap)
 868 {
 869         struct nwrap_pw *nwrap_pw;
 870         nwrap_pw = (struct nwrap_pw *)nwrap->private_data;
 871
 872         if (nwrap_pw->list) free(nwrap_pw->list);
 873
 874         nwrap_pw->list = NULL;
 875         nwrap_pw->num = 0;
 876         nwrap_pw->idx = 0;
 877 }
 878
 879 static int nwrap_pw_copy_r(const struct passwd *src, struct passwd *dst,
 880                            char *buf, size_t buflen, struct passwd **dstp)
 881 {
 882         char *first;
 883         char *last;
 884         off_t ofs;
 885
 886         first = src->pw_name;
 887
 888         last = src->pw_shell;
 889         while (*last) last++;
 890
 891         ofs = PTR_DIFF(last + 1, first);
 892
 893         if (ofs > buflen) {
 894                 return ERANGE;
 895         }
 896
 897         memcpy(buf, first, ofs);
 898
 899         ofs = PTR_DIFF(src->pw_name, first);
 900         dst->pw_name = buf + ofs;
 901         ofs = PTR_DIFF(src->pw_passwd, first);
 902         dst->pw_passwd = buf + ofs;
 903         dst->pw_uid = src->pw_uid;
 904         dst->pw_gid = src->pw_gid;
 905         ofs = PTR_DIFF(src->pw_gecos, first);
 906         dst->pw_gecos = buf + ofs;
 907         ofs = PTR_DIFF(src->pw_dir, first);
 908         dst->pw_dir = buf + ofs;
 909         ofs = PTR_DIFF(src->pw_shell, first);
 910         dst->pw_shell = buf + ofs;
 911
 912         if (dstp) {
 913                 *dstp = dst;
 914         }
 915
 916         return 0;
 917 }
 918
 919 /*
 920  * the caller has to call nwrap_unload() on failure
 921  */
 922 static bool nwrap_gr_parse_line(struct nwrap_cache *nwrap, char *line)
 923 {
 924         struct nwrap_gr *nwrap_gr;
 925         char *c;
 926         char *p;
 927         char *e;
 928         struct group *gr;
 929         size_t list_size;
 930         unsigned nummem;
 931
 932         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
 933
 934         list_size = sizeof(*nwrap_gr->list) * (nwrap_gr->num+1);
 935         gr = (struct group *)realloc(nwrap_gr->list, list_size);
 936         if (!gr) {
 937                 NWRAP_ERROR(("%s:realloc failed\n",__location__));
 938                 return false;
 939         }
 940         nwrap_gr->list = gr;
 941
 942         gr = &nwrap_gr->list[nwrap_gr->num];
 943
 944         c = line;
 945
 946         /* name */
 947         p = strchr(c, ':');
 948         if (!p) {
 949                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 950                              __location__, line, c));
 951                 return false;
 952         }
 953         *p = '\0';
 954         p++;
 955         gr->gr_name = c;
 956         c = p;
 957
 958         NWRAP_VERBOSE(("name[%s]\n", gr->gr_name));
 959
 960         /* password */
 961         p = strchr(c, ':');
 962         if (!p) {
 963                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 964                              __location__, line, c));
 965                 return false;
 966         }
 967         *p = '\0';
 968         p++;
 969         gr->gr_passwd = c;
 970         c = p;
 971
 972         NWRAP_VERBOSE(("password[%s]\n", gr->gr_passwd));
 973
 974         /* gid */
 975         p = strchr(c, ':');
 976         if (!p) {
 977                 NWRAP_ERROR(("%s:invalid line[%s]: '%s'\n",
 978                              __location__, line, c));
 979                 return false;
 980         }
 981         *p = '\0';
 982         p++;
 983         e = NULL;
 984         gr->gr_gid = (gid_t)strtoul(c, &e, 10);
 985         if (c == e) {
 986                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 987                              __location__, line, c, strerror(errno)));
 988                 return false;
 989         }
 990         if (e == NULL) {
 991                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 992                              __location__, line, c, strerror(errno)));
 993                 return false;
 994         }
 995         if (e[0] != '\0') {
 996                 NWRAP_ERROR(("%s:invalid line[%s]: '%s' - %s\n",
 997                              __location__, line, c, strerror(errno)));
 998                 return false;
 999         }
1000         c = p;
1001
1002         NWRAP_VERBOSE(("gid[%u]\n", gr->gr_gid));
1003
1004         /* members */
1005         gr->gr_mem = (char **)malloc(sizeof(char *));
1006         if (!gr->gr_mem) {
1007                 NWRAP_ERROR(("%s:calloc failed\n",__location__));
1008                 return false;
1009         }
1010         gr->gr_mem[0] = NULL;
1011
1012         for(nummem=0; p; nummem++) {
1013                 char **m;
1014                 size_t m_size;
1015                 c = p;
1016                 p = strchr(c, ',');
1017                 if (p) {
1018                         *p = '\0';
1019                         p++;
1020                 }
1021
1022                 if (strlen(c) == 0) {
1023                         break;
1024                 }
1025
1026                 m_size = sizeof(char *) * (nummem+2);
1027                 m = (char **)realloc(gr->gr_mem, m_size);
1028                 if (!m) {
1029                         NWRAP_ERROR(("%s:realloc(%u) failed\n",
1030                                       __location__, m_size));
1031                         return false;
1032                 }
1033                 gr->gr_mem = m;
1034                 gr->gr_mem[nummem] = c;
1035                 gr->gr_mem[nummem+1] = NULL;
1036
1037                 NWRAP_VERBOSE(("member[%u]: '%s'\n", nummem, gr->gr_mem[nummem]));
1038         }
1039
1040         NWRAP_DEBUG(("add group[%s:%s:%u:] with %u members\n",
1041                      gr->gr_name, gr->gr_passwd, gr->gr_gid, nummem));
1042
1043         nwrap_gr->num++;
1044         return true;
1045 }
1046
1047 static void nwrap_gr_unload(struct nwrap_cache *nwrap)
1048 {
1049         int i;
1050         struct nwrap_gr *nwrap_gr;
1051         nwrap_gr = (struct nwrap_gr *)nwrap->private_data;
1052
1053         if (nwrap_gr->list) {
1054                 for (i=0; i < nwrap_gr->num; i++) {
1055                         if (nwrap_gr->list[i].gr_mem) {
1056                                 free(nwrap_gr->list[i].gr_mem);
1057                         }
1058                 }
1059                 free(nwrap_gr->list);
1060         }
1061
1062         nwrap_gr->list = NULL;
1063         nwrap_gr->num = 0;
1064         nwrap_gr->idx = 0;
1065 }
1066
1067 static int nwrap_gr_copy_r(const struct group *src, struct group *dst,
1068                            char *buf, size_t buflen, struct group **dstp)
1069 {
1070         char *first;
1071         char **lastm;
1072         char *last = NULL;
1073         off_t ofsb;
1074         off_t ofsm;
1075         off_t ofs;
1076         unsigned i;
1077
1078         first = src->gr_name;
1079
1080         lastm = src->gr_mem;
1081         while (*lastm) {
1082                 last = *lastm;
1083                 lastm++;
1084         }
1085
1086         if (last == NULL) {
1087                 last = src->gr_passwd;
1088         }
1089         while (*last) last++;
1090
1091         ofsb = PTR_DIFF(last + 1, first);
1092         ofsm = PTR_DIFF(lastm + 1, src->gr_mem);
1093
1094         if ((ofsb + ofsm) > buflen) {
1095                 return ERANGE;
1096         }
1097
1098         memcpy(buf, first, ofsb);
1099         memcpy(buf + ofsb, src->gr_mem, ofsm);
1100
1101         ofs = PTR_DIFF(src->gr_name, first);
1102         dst->gr_name = buf + ofs;
1103         ofs = PTR_DIFF(src->gr_passwd, first);
1104         dst->gr_passwd = buf + ofs;
1105         dst->gr_gid = src->gr_gid;
1106
1107         dst->gr_mem = (char **)(buf + ofsb);
1108         for (i=0; src->gr_mem[i]; i++) {
1109                 ofs = PTR_DIFF(src->gr_mem[i], first);
1110                 dst->gr_mem[i] = buf + ofs;
1111         }
1112
1113         if (dstp) {
1114                 *dstp = dst;
1115         }
1116
1117         return 0;
1118 }
1119
1120 /* user functions */
1121 static struct passwd *nwrap_files_getpwnam(struct nwrap_backend *b,
1122                                            const char *name)
1123 {
1124         int i;
1125
1126         nwrap_files_cache_reload(nwrap_pw_global.cache);
1127
1128         for (i=0; i<nwrap_pw_global.num; i++) {
1129                 if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
1130                         NWRAP_DEBUG(("%s: user[%s] found\n",
1131                                      __location__, name));
1132                         return &nwrap_pw_global.list[i];
1133                 }
1134                 NWRAP_VERBOSE(("%s: user[%s] does not match [%s]\n",
1135                                __location__, name,
1136                                nwrap_pw_global.list[i].pw_name));
1137         }
1138
1139         NWRAP_DEBUG(("%s: user[%s] not found\n", __location__, name));
1140
1141         errno = ENOENT;
1142         return NULL;
1143 }
1144
1145 static int nwrap_files_getpwnam_r(struct nwrap_backend *b,
1146                                   const char *name, struct passwd *pwdst,
1147                                   char *buf, size_t buflen, struct passwd **pwdstp)
1148 {
1149         struct passwd *pw;
1150
1151         pw = nwrap_files_getpwnam(b, name);
1152         if (!pw) {
1153                 if (errno == 0) {
1154                         return ENOENT;
1155                 }
1156                 return errno;
1157         }
1158
1159         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
1160 }
1161
1162 static struct passwd *nwrap_files_getpwuid(struct nwrap_backend *b,
1163                                            uid_t uid)
1164 {
1165         int i;
1166
1167         nwrap_files_cache_reload(nwrap_pw_global.cache);
1168
1169         for (i=0; i<nwrap_pw_global.num; i++) {
1170                 if (nwrap_pw_global.list[i].pw_uid == uid) {
1171                         NWRAP_DEBUG(("%s: uid[%u] found\n",
1172                                      __location__, uid));
1173                         return &nwrap_pw_global.list[i];
1174                 }
1175                 NWRAP_VERBOSE(("%s: uid[%u] does not match [%u]\n",
1176                                __location__, uid,
1177                                nwrap_pw_global.list[i].pw_uid));
1178         }
1179
1180         NWRAP_DEBUG(("%s: uid[%u] not found\n", __location__, uid));
1181
1182         errno = ENOENT;
1183         return NULL;
1184 }
1185
1186 static int nwrap_files_getpwuid_r(struct nwrap_backend *b,
1187                                   uid_t uid, struct passwd *pwdst,
1188                                   char *buf, size_t buflen, struct passwd **pwdstp)
1189 {
1190         struct passwd *pw;
1191
1192         pw = nwrap_files_getpwuid(b, uid);
1193         if (!pw) {
1194                 if (errno == 0) {
1195                         return ENOENT;
1196                 }
1197                 return errno;
1198         }
1199
1200         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
1201 }
1202
1203 /* user enum functions */
1204 static void nwrap_files_setpwent(struct nwrap_backend *b)
1205 {
1206         nwrap_pw_global.idx = 0;
1207 }
1208
1209 static struct passwd *nwrap_files_getpwent(struct nwrap_backend *b)
1210 {
1211         struct passwd *pw;
1212
1213         if (nwrap_pw_global.idx == 0) {
1214                 nwrap_files_cache_reload(nwrap_pw_global.cache);
1215         }
1216
1217         if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
1218                 errno = ENOENT;
1219                 return NULL;
1220         }
1221
1222         pw = &nwrap_pw_global.list[nwrap_pw_global.idx++];
1223
1224         NWRAP_VERBOSE(("%s: return user[%s] uid[%u]\n",
1225                        __location__, pw->pw_name, pw->pw_uid));
1226
1227         return pw;
1228 }
1229
1230 static int nwrap_files_getpwent_r(struct nwrap_backend *b,
1231                                   struct passwd *pwdst, char *buf,
1232                                   size_t buflen, struct passwd **pwdstp)
1233 {
1234         struct passwd *pw;
1235
1236         pw = nwrap_files_getpwent(b);
1237         if (!pw) {
1238                 if (errno == 0) {
1239                         return ENOENT;
1240                 }
1241                 return errno;
1242         }
1243
1244         return nwrap_pw_copy_r(pw, pwdst, buf, buflen, pwdstp);
1245 }
1246
1247 static void nwrap_files_endpwent(struct nwrap_backend *b)
1248 {
1249         nwrap_pw_global.idx = 0;
1250 }
1251
1252 /* misc functions */
1253 static int nwrap_files_initgroups(struct nwrap_backend *b,
1254                                   const char *user, gid_t group)
1255 {
1256         /* TODO: maybe we should also fake this... */
1257         return EPERM;
1258 }
1259
1260 /* group functions */
1261 static struct group *nwrap_files_getgrnam(struct nwrap_backend *b,
1262                                           const char *name)
1263 {
1264         int i;
1265
1266         nwrap_files_cache_reload(nwrap_gr_global.cache);
1267
1268         for (i=0; i<nwrap_gr_global.num; i++) {
1269                 if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
1270                         NWRAP_DEBUG(("%s: group[%s] found\n",
1271                                      __location__, name));
1272                         return &nwrap_gr_global.list[i];
1273                 }
1274                 NWRAP_VERBOSE(("%s: group[%s] does not match [%s]\n",
1275                                __location__, name,
1276                                nwrap_gr_global.list[i].gr_name));
1277         }
1278
1279         NWRAP_DEBUG(("%s: group[%s] not found\n", __location__, name));
1280
1281         errno = ENOENT;
1282         return NULL;
1283 }
1284
1285 static int nwrap_files_getgrnam_r(struct nwrap_backend *b,
1286                                   const char *name, struct group *grdst,
1287                                   char *buf, size_t buflen, struct group **grdstp)
1288 {
1289         struct group *gr;
1290
1291         gr = nwrap_files_getgrnam(b, name);
1292         if (!gr) {
1293                 if (errno == 0) {
1294                         return ENOENT;
1295                 }
1296                 return errno;
1297         }
1298
1299         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
1300 }
1301
1302 static struct group *nwrap_files_getgrgid(struct nwrap_backend *b,
1303                                           gid_t gid)
1304 {
1305         int i;
1306
1307         nwrap_files_cache_reload(nwrap_gr_global.cache);
1308
1309         for (i=0; i<nwrap_gr_global.num; i++) {
1310                 if (nwrap_gr_global.list[i].gr_gid == gid) {
1311                         NWRAP_DEBUG(("%s: gid[%u] found\n",
1312                                      __location__, gid));
1313                         return &nwrap_gr_global.list[i];
1314                 }
1315                 NWRAP_VERBOSE(("%s: gid[%u] does not match [%u]\n",
1316                                __location__, gid,
1317                                nwrap_gr_global.list[i].gr_gid));
1318         }
1319
1320         NWRAP_DEBUG(("%s: gid[%u] not found\n", __location__, gid));
1321
1322         errno = ENOENT;
1323         return NULL;
1324 }
1325
1326 static int nwrap_files_getgrgid_r(struct nwrap_backend *b,
1327                                   gid_t gid, struct group *grdst,
1328                                   char *buf, size_t buflen, struct group **grdstp)
1329 {
1330         struct group *gr;
1331
1332         gr = nwrap_files_getgrgid(b, gid);
1333         if (!gr) {
1334                 if (errno == 0) {
1335                         return ENOENT;
1336                 }
1337                 return errno;
1338         }
1339
1340         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
1341 }
1342
1343 /* group enum functions */
1344 static void nwrap_files_setgrent(struct nwrap_backend *b)
1345 {
1346         nwrap_gr_global.idx = 0;
1347 }
1348
1349 static struct group *nwrap_files_getgrent(struct nwrap_backend *b)
1350 {
1351         struct group *gr;
1352
1353         if (nwrap_gr_global.idx == 0) {
1354                 nwrap_files_cache_reload(nwrap_gr_global.cache);
1355         }
1356
1357         if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
1358                 errno = ENOENT;
1359                 return NULL;
1360         }
1361
1362         gr = &nwrap_gr_global.list[nwrap_gr_global.idx++];
1363
1364         NWRAP_VERBOSE(("%s: return group[%s] gid[%u]\n",
1365                        __location__, gr->gr_name, gr->gr_gid));
1366
1367         return gr;
1368 }
1369
1370 static int nwrap_files_getgrent_r(struct nwrap_backend *b,
1371                                   struct group *grdst, char *buf,
1372                                   size_t buflen, struct group **grdstp)
1373 {
1374         struct group *gr;
1375
1376         gr = nwrap_files_getgrent(b);
1377         if (!gr) {
1378                 if (errno == 0) {
1379                         return ENOENT;
1380                 }
1381                 return errno;
1382         }
1383
1384         return nwrap_gr_copy_r(gr, grdst, buf, buflen, grdstp);
1385 }
1386
1387 static void nwrap_files_endgrent(struct nwrap_backend *b)
1388 {
1389         nwrap_gr_global.idx = 0;
1390 }
1391
1392 /*
1393  * module backend
1394  */
1395
1396 #ifndef SAFE_FREE
1397 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
1398 #endif
1399
1400 static struct passwd *nwrap_module_getpwnam(struct nwrap_backend *b,
1401                                             const char *name)
1402 {
1403         static struct passwd pwd;
1404         static char buf[1000];
1405         NSS_STATUS status;
1406
1407         if (!b->fns->_nss_getpwnam_r) {
1408                 return NULL;
1409         }
1410
1411         status = b->fns->_nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &errno);
1412         if (status == NSS_STATUS_NOTFOUND) {
1413                 return NULL;
1414         }
1415         if (status != NSS_STATUS_SUCCESS) {
1416                 return NULL;
1417         }
1418         return &pwd;
1419 }
1420
1421 static int nwrap_module_getpwnam_r(struct nwrap_backend *b,
1422                                    const char *name, struct passwd *pwdst,
1423                                    char *buf, size_t buflen, struct passwd **pwdstp)
1424 {
1425         int ret;
1426
1427         if (!b->fns->_nss_getpwnam_r) {
1428                 return NSS_STATUS_NOTFOUND;
1429         }
1430
1431         ret = b->fns->_nss_getpwnam_r(name, pwdst, buf, buflen, &errno);
1432         switch (ret) {
1433         case NSS_STATUS_SUCCESS:
1434                 return 0;
1435         case NSS_STATUS_NOTFOUND:
1436                 if (errno != 0) {
1437                         return errno;
1438                 }
1439                 return ENOENT;
1440         case NSS_STATUS_TRYAGAIN:
1441                 if (errno != 0) {
1442                         return errno;
1443                 }
1444                 return ERANGE;
1445         default:
1446                 if (errno != 0) {
1447                         return errno;
1448                 }
1449                 return ret;
1450         }
1451 }
1452
1453 static struct passwd *nwrap_module_getpwuid(struct nwrap_backend *b,
1454                                             uid_t uid)
1455 {
1456         static struct passwd pwd;
1457         static char buf[1000];
1458         NSS_STATUS status;
1459
1460         if (!b->fns->_nss_getpwuid_r) {
1461                 return NULL;
1462         }
1463
1464         status = b->fns->_nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &errno);
1465         if (status == NSS_STATUS_NOTFOUND) {
1466                 return NULL;
1467         }
1468         if (status != NSS_STATUS_SUCCESS) {
1469                 return NULL;
1470         }
1471         return &pwd;
1472 }
1473
1474 static int nwrap_module_getpwuid_r(struct nwrap_backend *b,
1475                                    uid_t uid, struct passwd *pwdst,
1476                                    char *buf, size_t buflen, struct passwd **pwdstp)
1477 {
1478         int ret;
1479
1480         if (!b->fns->_nss_getpwuid_r) {
1481                 return ENOENT;
1482         }
1483
1484         ret = b->fns->_nss_getpwuid_r(uid, pwdst, buf, buflen, &errno);
1485         switch (ret) {
1486         case NSS_STATUS_SUCCESS:
1487                 return 0;
1488         case NSS_STATUS_NOTFOUND:
1489                 if (errno != 0) {
1490                         return errno;
1491                 }
1492                 return ENOENT;
1493         case NSS_STATUS_TRYAGAIN:
1494                 if (errno != 0) {
1495                         return errno;
1496                 }
1497                 return ERANGE;
1498         default:
1499                 if (errno != 0) {
1500                         return errno;
1501                 }
1502                 return ret;
1503         }
1504 }
1505
1506 static void nwrap_module_setpwent(struct nwrap_backend *b)
1507 {
1508         if (!b->fns->_nss_setpwent) {
1509                 return;
1510         }
1511
1512         b->fns->_nss_setpwent();
1513 }
1514
1515 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b)
1516 {
1517         static struct passwd pwd;
1518         static char buf[1000];
1519         NSS_STATUS status;
1520
1521         if (!b->fns->_nss_getpwent_r) {
1522                 return NULL;
1523         }
1524
1525         status = b->fns->_nss_getpwent_r(&pwd, buf, sizeof(buf), &errno);
1526         if (status == NSS_STATUS_NOTFOUND) {
1527                 return NULL;
1528         }
1529         if (status != NSS_STATUS_SUCCESS) {
1530                 return NULL;
1531         }
1532         return &pwd;
1533 }
1534
1535 static int nwrap_module_getpwent_r(struct nwrap_backend *b,
1536                                    struct passwd *pwdst, char *buf,
1537                                    size_t buflen, struct passwd **pwdstp)
1538 {
1539         int ret;
1540
1541         if (!b->fns->_nss_getpwent_r) {
1542                 return ENOENT;
1543         }
1544
1545         ret = b->fns->_nss_getpwent_r(pwdst, buf, buflen, &errno);
1546         switch (ret) {
1547         case NSS_STATUS_SUCCESS:
1548                 return 0;
1549         case NSS_STATUS_NOTFOUND:
1550                 if (errno != 0) {
1551                         return errno;
1552                 }
1553                 return ENOENT;
1554         case NSS_STATUS_TRYAGAIN:
1555                 if (errno != 0) {
1556                         return errno;
1557                 }
1558                 return ERANGE;
1559         default:
1560                 if (errno != 0) {
1561                         return errno;
1562                 }
1563                 return ret;
1564         }
1565 }
1566
1567 static void nwrap_module_endpwent(struct nwrap_backend *b)
1568 {
1569         if (!b->fns->_nss_endpwent) {
1570                 return;
1571         }
1572
1573         b->fns->_nss_endpwent();
1574 }
1575
1576 static int nwrap_module_initgroups(struct nwrap_backend *b,
1577                                    const char *user, gid_t group)
1578 {
1579         gid_t *groups;
1580         long int start;
1581         long int size;
1582
1583         if (!b->fns->_nss_initgroups) {
1584                 return NSS_STATUS_UNAVAIL;
1585         }
1586
1587         return b->fns->_nss_initgroups(user, group, &start, &size, &groups, 0, &errno);
1588 }
1589
1590 static struct group *nwrap_module_getgrnam(struct nwrap_backend *b,
1591                                            const char *name)
1592 {
1593         static struct group grp;
1594         static char *buf;
1595         static int buflen = 1000;
1596         NSS_STATUS status;
1597
1598         if (!b->fns->_nss_getgrnam_r) {
1599                 return NULL;
1600         }
1601
1602         if (!buf) {
1603                 buf = (char *)malloc(buflen);
1604         }
1605 again:
1606         status = b->fns->_nss_getgrnam_r(name, &grp, buf, buflen, &errno);
1607         if (status == NSS_STATUS_TRYAGAIN) {
1608                 buflen *= 2;
1609                 buf = (char *)realloc(buf, buflen);
1610                 if (!buf) {
1611                         return NULL;
1612                 }
1613                 goto again;
1614         }
1615         if (status == NSS_STATUS_NOTFOUND) {
1616                 SAFE_FREE(buf);
1617                 return NULL;
1618         }
1619         if (status != NSS_STATUS_SUCCESS) {
1620                 SAFE_FREE(buf);
1621                 return NULL;
1622         }
1623         return &grp;
1624 }
1625
1626 static int nwrap_module_getgrnam_r(struct nwrap_backend *b,
1627                                    const char *name, struct group *grdst,
1628                                    char *buf, size_t buflen, struct group **grdstp)
1629 {
1630         int ret;
1631
1632         if (!b->fns->_nss_getgrnam_r) {
1633                 return ENOENT;
1634         }
1635
1636         ret = b->fns->_nss_getgrnam_r(name, grdst, buf, buflen, &errno);
1637         switch (ret) {
1638         case NSS_STATUS_SUCCESS:
1639                 return 0;
1640         case NSS_STATUS_NOTFOUND:
1641                 if (errno != 0) {
1642                         return errno;
1643                 }
1644                 return ENOENT;
1645         case NSS_STATUS_TRYAGAIN:
1646                 if (errno != 0) {
1647                         return errno;
1648                 }
1649                 return ERANGE;
1650         default:
1651                 if (errno != 0) {
1652                         return errno;
1653                 }
1654                 return ret;
1655         }
1656 }
1657
1658 static struct group *nwrap_module_getgrgid(struct nwrap_backend *b,
1659                                            gid_t gid)
1660 {
1661         static struct group grp;
1662         static char *buf;
1663         static int buflen = 1000;
1664         NSS_STATUS status;
1665
1666         if (!b->fns->_nss_getgrgid_r) {
1667                 return NULL;
1668         }
1669
1670         if (!buf) {
1671                 buf = (char *)malloc(buflen);
1672         }
1673
1674 again:
1675         status = b->fns->_nss_getgrgid_r(gid, &grp, buf, buflen, &errno);
1676         if (status == NSS_STATUS_TRYAGAIN) {
1677                 buflen *= 2;
1678                 buf = (char *)realloc(buf, buflen);
1679                 if (!buf) {
1680                         return NULL;
1681                 }
1682                 goto again;
1683         }
1684         if (status == NSS_STATUS_NOTFOUND) {
1685                 SAFE_FREE(buf);
1686                 return NULL;
1687         }
1688         if (status != NSS_STATUS_SUCCESS) {
1689                 SAFE_FREE(buf);
1690                 return NULL;
1691         }
1692         return &grp;
1693 }
1694
1695 static int nwrap_module_getgrgid_r(struct nwrap_backend *b,
1696                                    gid_t gid, struct group *grdst,
1697                                    char *buf, size_t buflen, struct group **grdstp)
1698 {
1699         int ret;
1700
1701         if (!b->fns->_nss_getgrgid_r) {
1702                 return ENOENT;
1703         }
1704
1705         ret = b->fns->_nss_getgrgid_r(gid, grdst, buf, buflen, &errno);
1706         switch (ret) {
1707         case NSS_STATUS_SUCCESS:
1708                 return 0;
1709         case NSS_STATUS_NOTFOUND:
1710                 if (errno != 0) {
1711                         return errno;
1712                 }
1713                 return ENOENT;
1714         case NSS_STATUS_TRYAGAIN:
1715                 if (errno != 0) {
1716                         return errno;
1717                 }
1718                 return ERANGE;
1719         default:
1720                 if (errno != 0) {
1721                         return errno;
1722                 }
1723                 return ret;
1724         }
1725 }
1726
1727 static void nwrap_module_setgrent(struct nwrap_backend *b)
1728 {
1729         if (!b->fns->_nss_setgrent) {
1730                 return;
1731         }
1732
1733         b->fns->_nss_setgrent();
1734 }
1735
1736 static struct group *nwrap_module_getgrent(struct nwrap_backend *b)
1737 {
1738         static struct group grp;
1739         static char *buf;
1740         static int buflen = 1024;
1741         NSS_STATUS status;
1742
1743         if (!b->fns->_nss_getgrent_r) {
1744                 return NULL;
1745         }
1746
1747         if (!buf) {
1748                 buf = (char *)malloc(buflen);
1749         }
1750
1751 again:
1752         status = b->fns->_nss_getgrent_r(&grp, buf, buflen, &errno);
1753         if (status == NSS_STATUS_TRYAGAIN) {
1754                 buflen *= 2;
1755                 buf = (char *)realloc(buf, buflen);
1756                 if (!buf) {
1757                         return NULL;
1758                 }
1759                 goto again;
1760         }
1761         if (status == NSS_STATUS_NOTFOUND) {
1762                 SAFE_FREE(buf);
1763                 return NULL;
1764         }
1765         if (status != NSS_STATUS_SUCCESS) {
1766                 SAFE_FREE(buf);
1767                 return NULL;
1768         }
1769         return &grp;
1770 }
1771
1772 static int nwrap_module_getgrent_r(struct nwrap_backend *b,
1773                                    struct group *grdst, char *buf,
1774                                    size_t buflen, struct group **grdstp)
1775 {
1776         int ret;
1777
1778         if (!b->fns->_nss_getgrent_r) {
1779                 return ENOENT;
1780         }
1781
1782         ret = b->fns->_nss_getgrent_r(grdst, buf, buflen, &errno);
1783         switch (ret) {
1784         case NSS_STATUS_SUCCESS:
1785                 return 0;
1786         case NSS_STATUS_NOTFOUND:
1787                 if (errno != 0) {
1788                         return errno;
1789                 }
1790                 return ENOENT;
1791         case NSS_STATUS_TRYAGAIN:
1792                 if (errno != 0) {
1793                         return errno;
1794                 }
1795                 return ERANGE;
1796         default:
1797                 if (errno != 0) {
1798                         return errno;
1799                 }
1800                 return ret;
1801         }
1802 }
1803
1804 static void nwrap_module_endgrent(struct nwrap_backend *b)
1805 {
1806         if (!b->fns->_nss_endgrent) {
1807                 return;
1808         }
1809
1810         b->fns->_nss_endgrent();
1811 }
1812
1813 /*
1814  * PUBLIC interface
1815  */
1816
1817 _PUBLIC_ struct passwd *nwrap_getpwnam(const char *name)
1818 {
1819         int i;
1820         struct passwd *pwd;
1821
1822         if (!nwrap_enabled()) {
1823                 return real_getpwnam(name);
1824         }
1825
1826         for (i=0; i < nwrap_main_global->num_backends; i++) {
1827                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1828                 pwd = b->ops->nw_getpwnam(b, name);
1829                 if (pwd) {
1830                         return pwd;
1831                 }
1832         }
1833
1834         return NULL;
1835 }
1836
1837 _PUBLIC_ int nwrap_getpwnam_r(const char *name, struct passwd *pwdst,
1838                               char *buf, size_t buflen, struct passwd **pwdstp)
1839 {
1840         int i,ret;
1841
1842         if (!nwrap_enabled()) {
1843                 return real_getpwnam_r(name, pwdst, buf, buflen, pwdstp);
1844         }
1845
1846         for (i=0; i < nwrap_main_global->num_backends; i++) {
1847                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1848                 ret = b->ops->nw_getpwnam_r(b, name, pwdst, buf, buflen, pwdstp);
1849                 if (ret == ENOENT) {
1850                         continue;
1851                 }
1852                 return ret;
1853         }
1854
1855         return ENOENT;
1856 }
1857
1858 _PUBLIC_ struct passwd *nwrap_getpwuid(uid_t uid)
1859 {
1860         int i;
1861         struct passwd *pwd;
1862
1863         if (!nwrap_enabled()) {
1864                 return real_getpwuid(uid);
1865         }
1866
1867         for (i=0; i < nwrap_main_global->num_backends; i++) {
1868                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1869                 pwd = b->ops->nw_getpwuid(b, uid);
1870                 if (pwd) {
1871                         return pwd;
1872                 }
1873         }
1874
1875         return NULL;
1876 }
1877
1878 _PUBLIC_ int nwrap_getpwuid_r(uid_t uid, struct passwd *pwdst,
1879                               char *buf, size_t buflen, struct passwd **pwdstp)
1880 {
1881         int i,ret;
1882
1883         if (!nwrap_enabled()) {
1884                 return real_getpwuid_r(uid, pwdst, buf, buflen, pwdstp);
1885         }
1886
1887         for (i=0; i < nwrap_main_global->num_backends; i++) {
1888                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1889                 ret = b->ops->nw_getpwuid_r(b, uid, pwdst, buf, buflen, pwdstp);
1890                 if (ret == ENOENT) {
1891                         continue;
1892                 }
1893                 return ret;
1894         }
1895
1896         return ENOENT;
1897 }
1898
1899 _PUBLIC_ void nwrap_setpwent(void)
1900 {
1901         int i;
1902
1903         if (!nwrap_enabled()) {
1904                 real_setpwent();
1905                 return;
1906         }
1907
1908         for (i=0; i < nwrap_main_global->num_backends; i++) {
1909                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1910                 b->ops->nw_setpwent(b);
1911         }
1912 }
1913
1914 _PUBLIC_ struct passwd *nwrap_getpwent(void)
1915 {
1916         int i;
1917         struct passwd *pwd;
1918
1919         if (!nwrap_enabled()) {
1920                 return real_getpwent();
1921         }
1922
1923         for (i=0; i < nwrap_main_global->num_backends; i++) {
1924                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1925                 pwd = b->ops->nw_getpwent(b);
1926                 if (pwd) {
1927                         return pwd;
1928                 }
1929         }
1930
1931         return NULL;
1932 }
1933
1934 _PUBLIC_ int nwrap_getpwent_r(struct passwd *pwdst, char *buf,
1935                               size_t buflen, struct passwd **pwdstp)
1936 {
1937         int i,ret;
1938
1939         if (!nwrap_enabled()) {
1940 #ifdef SOLARIS_GETPWENT_R
1941                 struct passwd *pw;
1942                 pw = real_getpwent_r(pwdst, buf, buflen);
1943                 if (!pw) {
1944                         if (errno == 0) {
1945                                 return ENOENT;
1946                         }
1947                         return errno;
1948                 }
1949                 if (pwdstp) {
1950                         *pwdstp = pw;
1951                 }
1952                 return 0;
1953 #else
1954                 return real_getpwent_r(pwdst, buf, buflen, pwdstp);
1955 #endif
1956         }
1957
1958         for (i=0; i < nwrap_main_global->num_backends; i++) {
1959                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1960                 ret = b->ops->nw_getpwent_r(b, pwdst, buf, buflen, pwdstp);
1961                 if (ret == ENOENT) {
1962                         continue;
1963                 }
1964                 return ret;
1965         }
1966
1967         return ENOENT;
1968 }
1969
1970 _PUBLIC_ void nwrap_endpwent(void)
1971 {
1972         int i;
1973
1974         if (!nwrap_enabled()) {
1975                 real_endpwent();
1976                 return;
1977         }
1978
1979         for (i=0; i < nwrap_main_global->num_backends; i++) {
1980                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1981                 b->ops->nw_endpwent(b);
1982         }
1983 }
1984
1985 _PUBLIC_ int nwrap_initgroups(const char *user, gid_t group)
1986 {
1987         int i;
1988
1989         if (!nwrap_enabled()) {
1990                 return real_initgroups(user, group);
1991         }
1992
1993         for (i=0; i < nwrap_main_global->num_backends; i++) {
1994                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
1995                 return b->ops->nw_initgroups(b, user, group);
1996         }
1997
1998         errno = ENOENT;
1999         return -1;
2000 }
2001
2002 _PUBLIC_ struct group *nwrap_getgrnam(const char *name)
2003 {
2004         int i;
2005         struct group *grp;
2006
2007         if (!nwrap_enabled()) {
2008                 return real_getgrnam(name);
2009         }
2010
2011         for (i=0; i < nwrap_main_global->num_backends; i++) {
2012                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2013                 grp = b->ops->nw_getgrnam(b, name);
2014                 if (grp) {
2015                         return grp;
2016                 }
2017         }
2018
2019         return NULL;
2020 }
2021
2022 _PUBLIC_ int nwrap_getgrnam_r(const char *name, struct group *grdst,
2023                               char *buf, size_t buflen, struct group **grdstp)
2024 {
2025         int i,ret;
2026
2027         if (!nwrap_enabled()) {
2028                 return real_getgrnam_r(name, grdst, buf, buflen, grdstp);
2029         }
2030
2031         for (i=0; i < nwrap_main_global->num_backends; i++) {
2032                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2033                 ret = b->ops->nw_getgrnam_r(b, name, grdst, buf, buflen, grdstp);
2034                 if (ret == ENOENT) {
2035                         continue;
2036                 }
2037                 return ret;
2038         }
2039
2040         return ENOENT;
2041 }
2042
2043 _PUBLIC_ struct group *nwrap_getgrgid(gid_t gid)
2044 {
2045         int i;
2046         struct group *grp;
2047
2048         if (!nwrap_enabled()) {
2049                 return real_getgrgid(gid);
2050         }
2051
2052         for (i=0; i < nwrap_main_global->num_backends; i++) {
2053                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2054                 grp = b->ops->nw_getgrgid(b, gid);
2055                 if (grp) {
2056                         return grp;
2057                 }
2058         }
2059
2060         return NULL;
2061 }
2062
2063 _PUBLIC_ int nwrap_getgrgid_r(gid_t gid, struct group *grdst,
2064                               char *buf, size_t buflen, struct group **grdstp)
2065 {
2066         int i,ret;
2067
2068         if (!nwrap_enabled()) {
2069                 return real_getgrgid_r(gid, grdst, buf, buflen, grdstp);
2070         }
2071
2072         for (i=0; i < nwrap_main_global->num_backends; i++) {
2073                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2074                 ret = b->ops->nw_getgrgid_r(b, gid, grdst, buf, buflen, grdstp);
2075                 if (ret == ENOENT) {
2076                         continue;
2077                 }
2078                 return ret;
2079         }
2080
2081         return ENOENT;
2082 }
2083
2084 _PUBLIC_ void nwrap_setgrent(void)
2085 {
2086         int i;
2087
2088         if (!nwrap_enabled()) {
2089                 real_setgrent();
2090                 return;
2091         }
2092
2093         for (i=0; i < nwrap_main_global->num_backends; i++) {
2094                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2095                 b->ops->nw_setgrent(b);
2096         }
2097 }
2098
2099 _PUBLIC_ struct group *nwrap_getgrent(void)
2100 {
2101         int i;
2102         struct group *grp;
2103
2104         if (!nwrap_enabled()) {
2105                 return real_getgrent();
2106         }
2107
2108         for (i=0; i < nwrap_main_global->num_backends; i++) {
2109                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2110                 grp = b->ops->nw_getgrent(b);
2111                 if (grp) {
2112                         return grp;
2113                 }
2114         }
2115
2116         return NULL;
2117 }
2118
2119 _PUBLIC_ int nwrap_getgrent_r(struct group *grdst, char *buf,
2120                               size_t buflen, struct group **grdstp)
2121 {
2122         int i,ret;
2123
2124         if (!nwrap_enabled()) {
2125 #ifdef SOLARIS_GETGRENT_R
2126                 struct group *gr;
2127                 gr = real_getgrent_r(grdst, buf, buflen);
2128                 if (!gr) {
2129                         if (errno == 0) {
2130                                 return ENOENT;
2131                         }
2132                         return errno;
2133                 }
2134                 if (grdstp) {
2135                         *grdstp = gr;
2136                 }
2137                 return 0;
2138 #else
2139                 return real_getgrent_r(grdst, buf, buflen, grdstp);
2140 #endif
2141         }
2142
2143         for (i=0; i < nwrap_main_global->num_backends; i++) {
2144                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2145                 ret = b->ops->nw_getgrent_r(b, grdst, buf, buflen, grdstp);
2146                 if (ret == ENOENT) {
2147                         continue;
2148                 }
2149                 return ret;
2150         }
2151
2152         return ENOENT;
2153 }
2154
2155 _PUBLIC_ void nwrap_endgrent(void)
2156 {
2157         int i;
2158
2159         if (!nwrap_enabled()) {
2160                 real_endgrent();
2161                 return;
2162         }
2163
2164         for (i=0; i < nwrap_main_global->num_backends; i++) {
2165                 struct nwrap_backend *b = &nwrap_main_global->backends[i];
2166                 b->ops->nw_endgrent(b);
2167         }
2168 }
2169
2170 _PUBLIC_ int nwrap_getgrouplist(const char *user, gid_t group, gid_t *groups, int *ngroups)
2171 {
2172         struct group *grp;
2173         gid_t *groups_tmp;
2174         int count = 1;
2175         const char *name_of_group = NULL;
2176
2177         if (!nwrap_enabled()) {
2178                 return real_getgrouplist(user, group, groups, ngroups);
2179         }
2180
2181         NWRAP_DEBUG(("%s: getgrouplist called for %s\n", __location__, user));
2182
2183         groups_tmp = (gid_t *)malloc(count * sizeof(gid_t));
2184         if (!groups_tmp) {
2185                 NWRAP_ERROR(("%s:calloc failed\n",__location__));
2186                 errno = ENOMEM;
2187                 return -1;
2188         }
2189
2190         memcpy(groups_tmp, &group, sizeof(gid_t));
2191
2192         grp = nwrap_getgrgid(group);
2193         if (grp) {
2194                 name_of_group = grp->gr_name;
2195         }
2196
2197         nwrap_setgrent();
2198         while ((grp = nwrap_getgrent()) != NULL) {
2199                 int i = 0;
2200
2201                 NWRAP_VERBOSE(("%s: inspecting %s for group membership\n",
2202                                __location__, grp->gr_name));
2203
2204                 for (i=0; grp->gr_mem && grp->gr_mem[i] != NULL; i++) {
2205
2206                         if ((strcmp(user, grp->gr_mem[i]) == 0) &&
2207                             (strcmp(name_of_group, grp->gr_name) != 0)) {
2208
2209                                 NWRAP_DEBUG(("%s: %s is member of %s\n",
2210                                         __location__, user, grp->gr_name));
2211
2212                                 groups_tmp = (gid_t *)realloc(groups_tmp, (count + 1) * sizeof(gid_t));
2213                                 if (!groups_tmp) {
2214                                         NWRAP_ERROR(("%s:calloc failed\n",__location__));
2215                                         errno = ENOMEM;
2216                                         return -1;
2217                                 }
2218
2219                                 memcpy(&groups_tmp[count], &grp->gr_gid, sizeof(gid_t));
2220                                 count++;
2221                         }
2222                 }
2223         }
2224
2225         nwrap_endgrent();
2226
2227         NWRAP_VERBOSE(("%s: %s is member of %d groups: %d\n",
2228                        __location__, user, *ngroups));
2229
2230         if (*ngroups < count) {
2231                 *ngroups = count;
2232                 free(groups_tmp);
2233                 return -1;
2234         }
2235
2236         *ngroups = count;
2237         memcpy(groups, groups_tmp, count * sizeof(gid_t));
2238         free(groups_tmp);
2239
2240         return count;
2241 }