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