libc: Add missing #include "un-namespace.h" in a few files.
[dragonfly.git] / lib / libc / gen / pwcache.c
1 /*      @(#)cache.c     8.1 (Berkeley) 5/31/93 */
2 /*      $NetBSD: pwcache.c,v 1.31 2010/03/23 20:28:59 drochner Exp $    */
3
4 /*-
5  * Copyright (c) 1992 Keith Muller.
6  * Copyright (c) 1992, 1993
7  *      The Regents of the University of California.  All rights reserved.
8  *
9  * This code is derived from software contributed to Berkeley by
10  * Keith Muller of the University of California, San Diego.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 3. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  */
36
37 /*-
38  * Copyright (c) 2002 The NetBSD Foundation, Inc.
39  * All rights reserved.
40  *
41  * Redistribution and use in source and binary forms, with or without
42  * modification, are permitted provided that the following conditions
43  * are met:
44  * 1. Redistributions of source code must retain the above copyright
45  *    notice, this list of conditions and the following disclaimer.
46  * 2. Redistributions in binary form must reproduce the above copyright
47  *    notice, this list of conditions and the following disclaimer in the
48  *    documentation and/or other materials provided with the distribution.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
51  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
52  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
53  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
54  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
55  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
56  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
57  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
58  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
59  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
60  * POSSIBILITY OF SUCH DAMAGE.
61  */
62
63 #if HAVE_NBTOOL_CONFIG_H
64 #include "nbtool_config.h"
65 /*
66  * XXX Undefine the renames of these functions so that we don't
67  * XXX rename the versions found in the host's <pwd.h> by mistake!
68  */
69 #undef group_from_gid
70 #undef user_from_uid
71 #endif
72
73 #include "namespace.h"
74
75 #include <sys/types.h>
76 #include <sys/param.h>
77
78 #include <assert.h>
79 #include <grp.h>
80 #include <pwd.h>
81 #include <stdio.h>
82 #include <stdlib.h>
83 #include <string.h>
84 #include <unistd.h>
85 #include "un-namespace.h"
86
87 #if HAVE_NBTOOL_CONFIG_H
88 /* XXX Now, re-apply the renaming that we undid above. */
89 #define group_from_gid  __nbcompat_group_from_gid
90 #define user_from_uid   __nbcompat_user_from_uid
91 #endif
92
93 #ifdef __weak_alias
94 __weak_alias(user_from_uid,_user_from_uid)
95 __weak_alias(group_from_gid,_group_from_gid)
96 __weak_alias(pwcache_groupdb,_pwcache_groupdb)
97 #endif
98
99 #if !HAVE_PWCACHE_USERDB || HAVE_NBTOOL_CONFIG_H
100 #include "pwcache.h"
101
102 /*
103  * routines that control user, group, uid and gid caches (for the archive
104  * member print routine).
105  * IMPORTANT:
106  * these routines cache BOTH hits and misses, a major performance improvement
107  */
108
109 /*
110  * function pointers to various name lookup routines.
111  * these may be changed as necessary.
112  */
113 static  int             (*_pwcache_setgroupent)(int)            = setgroupent;
114 static  void            (*_pwcache_endgrent)(void)              = endgrent;
115 static  struct group *  (*_pwcache_getgrnam)(const char *)      = getgrnam;
116 static  struct group *  (*_pwcache_getgrgid)(gid_t)             = getgrgid;
117 static  int             (*_pwcache_setpassent)(int)             = setpassent;
118 static  void            (*_pwcache_endpwent)(void)              = endpwent;
119 static  struct passwd * (*_pwcache_getpwnam)(const char *)      = getpwnam;
120 static  struct passwd * (*_pwcache_getpwuid)(uid_t)             = getpwuid;
121
122 /*
123  * internal state
124  */
125 static  int     pwopn;          /* is password file open */
126 static  int     gropn;          /* is group file open */
127 static  UIDC    **uidtb;        /* uid to name cache */
128 static  GIDC    **gidtb;        /* gid to name cache */
129 static  UIDC    **usrtb;        /* user name to uid cache */
130 static  GIDC    **grptb;        /* group name to gid cache */
131
132 static  int     uidtb_fail;     /* uidtb_start() failed ? */
133 static  int     gidtb_fail;     /* gidtb_start() failed ? */
134 static  int     usrtb_fail;     /* usrtb_start() failed ? */
135 static  int     grptb_fail;     /* grptb_start() failed ? */
136
137
138 static  u_int   st_hash(const char *, size_t, int);
139 static  int     uidtb_start(void);
140 static  int     gidtb_start(void);
141 static  int     usrtb_start(void);
142 static  int     grptb_start(void);
143
144
145 static u_int
146 st_hash(const char *name, size_t len, int tabsz)
147 {
148         u_int key = 0;
149
150         _DIAGASSERT(name != NULL);
151
152         while (len--) {
153                 key += *name++;
154                 key = (key << 8) | (key >> 24);
155         }
156
157         return (key % tabsz);
158 }
159
160 /*
161  * uidtb_start
162  *      creates an an empty uidtb
163  * Return:
164  *      0 if ok, -1 otherwise
165  */
166 static int
167 uidtb_start(void)
168 {
169
170         if (uidtb != NULL)
171                 return (0);
172         if (uidtb_fail)
173                 return (-1);
174         if ((uidtb = (UIDC **)calloc(UID_SZ, sizeof(UIDC *))) == NULL) {
175                 ++uidtb_fail;
176                 return (-1);
177         }
178         return (0);
179 }
180
181 /*
182  * gidtb_start
183  *      creates an an empty gidtb
184  * Return:
185  *      0 if ok, -1 otherwise
186  */
187 static int
188 gidtb_start(void)
189 {
190
191         if (gidtb != NULL)
192                 return (0);
193         if (gidtb_fail)
194                 return (-1);
195         if ((gidtb = (GIDC **)calloc(GID_SZ, sizeof(GIDC *))) == NULL) {
196                 ++gidtb_fail;
197                 return (-1);
198         }
199         return (0);
200 }
201
202 /*
203  * usrtb_start
204  *      creates an an empty usrtb
205  * Return:
206  *      0 if ok, -1 otherwise
207  */
208 static int
209 usrtb_start(void)
210 {
211
212         if (usrtb != NULL)
213                 return (0);
214         if (usrtb_fail)
215                 return (-1);
216         if ((usrtb = (UIDC **)calloc(UNM_SZ, sizeof(UIDC *))) == NULL) {
217                 ++usrtb_fail;
218                 return (-1);
219         }
220         return (0);
221 }
222
223 /*
224  * grptb_start
225  *      creates an an empty grptb
226  * Return:
227  *      0 if ok, -1 otherwise
228  */
229 static int
230 grptb_start(void)
231 {
232
233         if (grptb != NULL)
234                 return (0);
235         if (grptb_fail)
236                 return (-1);
237         if ((grptb = (GIDC **)calloc(GNM_SZ, sizeof(GIDC *))) == NULL) {
238                 ++grptb_fail;
239                 return (-1);
240         }
241         return (0);
242 }
243
244 /*
245  * user_from_uid()
246  *      caches the name (if any) for the uid. If noname clear, we always
247  *      return the stored name (if valid or invalid match).
248  *      We use a simple hash table.
249  * Return
250  *      Pointer to stored name (or a empty string)
251  */
252 const char *
253 user_from_uid(uid_t uid, int noname)
254 {
255         struct passwd *pw;
256         UIDC *ptr, **pptr;
257
258         if ((uidtb == NULL) && (uidtb_start() < 0))
259                 return (NULL);
260
261         /*
262          * see if we have this uid cached
263          */
264         pptr = uidtb + (uid % UID_SZ);
265         ptr = *pptr;
266
267         if ((ptr != NULL) && (ptr->valid > 0) && (ptr->uid == uid)) {
268                 /*
269                  * have an entry for this uid
270                  */
271                 if (!noname || (ptr->valid == VALID))
272                         return (ptr->name);
273                 return (NULL);
274         }
275
276         /*
277          * No entry for this uid, we will add it
278          */
279         if (!pwopn) {
280                 if (_pwcache_setpassent != NULL)
281                         (*_pwcache_setpassent)(1);
282                 ++pwopn;
283         }
284
285         if (ptr == NULL)
286                 *pptr = ptr = (UIDC *)malloc(sizeof(UIDC));
287
288         if ((pw = (*_pwcache_getpwuid)(uid)) == NULL) {
289                 /*
290                  * no match for this uid in the local password file
291                  * a string that is the uid in numeric format
292                  */
293                 if (ptr == NULL)
294                         return (NULL);
295                 ptr->uid = uid;
296                 snprintf(ptr->name, UNMLEN, "%lu", (long) uid);
297                 ptr->valid = INVALID;
298                 if (noname)
299                         return (NULL);
300         } else {
301                 /*
302                  * there is an entry for this uid in the password file
303                  */
304                 if (ptr == NULL)
305                         return (pw->pw_name);
306                 ptr->uid = uid;
307                 strlcpy(ptr->name, pw->pw_name, UNMLEN);
308                 ptr->valid = VALID;
309         }
310         return (ptr->name);
311 }
312
313 /*
314  * group_from_gid()
315  *      caches the name (if any) for the gid. If noname clear, we always
316  *      return the stored name (if valid or invalid match).
317  *      We use a simple hash table.
318  * Return
319  *      Pointer to stored name (or a empty string)
320  */
321 const char *
322 group_from_gid(gid_t gid, int noname)
323 {
324         struct group *gr;
325         GIDC *ptr, **pptr;
326
327         if ((gidtb == NULL) && (gidtb_start() < 0))
328                 return (NULL);
329
330         /*
331          * see if we have this gid cached
332          */
333         pptr = gidtb + (gid % GID_SZ);
334         ptr = *pptr;
335
336         if ((ptr != NULL) && (ptr->valid > 0) && (ptr->gid == gid)) {
337                 /*
338                  * have an entry for this gid
339                  */
340                 if (!noname || (ptr->valid == VALID))
341                         return (ptr->name);
342                 return (NULL);
343         }
344
345         /*
346          * No entry for this gid, we will add it
347          */
348         if (!gropn) {
349                 if (_pwcache_setgroupent != NULL)
350                         (*_pwcache_setgroupent)(1);
351                 ++gropn;
352         }
353
354         if (ptr == NULL)
355                 *pptr = ptr = (GIDC *)malloc(sizeof(GIDC));
356
357         if ((gr = (*_pwcache_getgrgid)(gid)) == NULL) {
358                 /*
359                  * no match for this gid in the local group file, put in
360                  * a string that is the gid in numberic format
361                  */
362                 if (ptr == NULL)
363                         return (NULL);
364                 ptr->gid = gid;
365                 snprintf(ptr->name, GNMLEN, "%lu", (long) gid);
366                 ptr->valid = INVALID;
367                 if (noname)
368                         return (NULL);
369         } else {
370                 /*
371                  * there is an entry for this group in the group file
372                  */
373                 if (ptr == NULL)
374                         return (gr->gr_name);
375                 ptr->gid = gid;
376                 strlcpy(ptr->name, gr->gr_name, GNMLEN);
377                 ptr->valid = VALID;
378         }
379         return (ptr->name);
380 }
381
382 /*
383  * uid_from_user()
384  *      caches the uid for a given user name. We use a simple hash table.
385  * Return
386  *      the uid (if any) for a user name, or a -1 if no match can be found
387  */
388 int
389 uid_from_user(const char *name, uid_t *uid)
390 {
391         struct passwd *pw;
392         UIDC *ptr, **pptr;
393         size_t namelen;
394
395         /*
396          * return -1 for mangled names
397          */
398         if (name == NULL || ((namelen = strlen(name)) == 0))
399                 return (-1);
400         if ((usrtb == NULL) && (usrtb_start() < 0))
401                 return (-1);
402
403         /*
404          * look up in hash table, if found and valid return the uid,
405          * if found and invalid, return a -1
406          */
407         pptr = usrtb + st_hash(name, namelen, UNM_SZ);
408         ptr = *pptr;
409
410         if ((ptr != NULL) && (ptr->valid > 0) && !strcmp(name, ptr->name)) {
411                 if (ptr->valid == INVALID)
412                         return (-1);
413                 *uid = ptr->uid;
414                 return (0);
415         }
416
417         if (!pwopn) {
418                 if (_pwcache_setpassent != NULL)
419                         (*_pwcache_setpassent)(1);
420                 ++pwopn;
421         }
422
423         if (ptr == NULL)
424                 *pptr = ptr = (UIDC *)malloc(sizeof(UIDC));
425
426         /*
427          * no match, look it up, if no match store it as an invalid entry,
428          * or store the matching uid
429          */
430         if (ptr == NULL) {
431                 if ((pw = (*_pwcache_getpwnam)(name)) == NULL)
432                         return (-1);
433                 *uid = pw->pw_uid;
434                 return (0);
435         }
436         strlcpy(ptr->name, name, UNMLEN);
437         if ((pw = (*_pwcache_getpwnam)(name)) == NULL) {
438                 ptr->valid = INVALID;
439                 return (-1);
440         }
441         ptr->valid = VALID;
442         *uid = ptr->uid = pw->pw_uid;
443         return (0);
444 }
445
446 /*
447  * gid_from_group()
448  *      caches the gid for a given group name. We use a simple hash table.
449  * Return
450  *      the gid (if any) for a group name, or a -1 if no match can be found
451  */
452 int
453 gid_from_group(const char *name, gid_t *gid)
454 {
455         struct group *gr;
456         GIDC *ptr, **pptr;
457         size_t namelen;
458
459         /*
460          * return -1 for mangled names
461          */
462         if (name == NULL || ((namelen = strlen(name)) == 0))
463                 return (-1);
464         if ((grptb == NULL) && (grptb_start() < 0))
465                 return (-1);
466
467         /*
468          * look up in hash table, if found and valid return the uid,
469          * if found and invalid, return a -1
470          */
471         pptr = grptb + st_hash(name, namelen, GID_SZ);
472         ptr = *pptr;
473
474         if ((ptr != NULL) && (ptr->valid > 0) && !strcmp(name, ptr->name)) {
475                 if (ptr->valid == INVALID)
476                         return (-1);
477                 *gid = ptr->gid;
478                 return (0);
479         }
480
481         if (!gropn) {
482                 if (_pwcache_setgroupent != NULL)
483                         (*_pwcache_setgroupent)(1);
484                 ++gropn;
485         }
486
487         if (ptr == NULL)
488                 *pptr = ptr = (GIDC *)malloc(sizeof(GIDC));
489
490         /*
491          * no match, look it up, if no match store it as an invalid entry,
492          * or store the matching gid
493          */
494         if (ptr == NULL) {
495                 if ((gr = (*_pwcache_getgrnam)(name)) == NULL)
496                         return (-1);
497                 *gid = gr->gr_gid;
498                 return (0);
499         }
500
501         strlcpy(ptr->name, name, GNMLEN);
502         if ((gr = (*_pwcache_getgrnam)(name)) == NULL) {
503                 ptr->valid = INVALID;
504                 return (-1);
505         }
506         ptr->valid = VALID;
507         *gid = ptr->gid = gr->gr_gid;
508         return (0);
509 }
510
511 #define FLUSHTB(arr, len, fail)                         \
512         do {                                            \
513                 if (arr != NULL) {                      \
514                         for (i = 0; i < len; i++)       \
515                                 if (arr[i] != NULL)     \
516                                         free(arr[i]);   \
517                         arr = NULL;                     \
518                 }                                       \
519                 fail = 0;                               \
520         } while (/* CONSTCOND */0);
521
522 int
523 pwcache_userdb(
524         int             (*a_setpassent)(int),
525         void            (*a_endpwent)(void),
526         struct passwd * (*a_getpwnam)(const char *),
527         struct passwd * (*a_getpwuid)(uid_t))
528 {
529         int i;
530
531                 /* a_setpassent and a_endpwent may be NULL */
532         if (a_getpwnam == NULL || a_getpwuid == NULL)
533                 return (-1);
534
535         if (_pwcache_endpwent != NULL)
536                 (*_pwcache_endpwent)();
537         FLUSHTB(uidtb, UID_SZ, uidtb_fail);
538         FLUSHTB(usrtb, UNM_SZ, usrtb_fail);
539         pwopn = 0;
540         _pwcache_setpassent = a_setpassent;
541         _pwcache_endpwent = a_endpwent;
542         _pwcache_getpwnam = a_getpwnam;
543         _pwcache_getpwuid = a_getpwuid;
544
545         return (0);
546 }
547
548 int
549 pwcache_groupdb(
550         int             (*a_setgroupent)(int),
551         void            (*a_endgrent)(void),
552         struct group *  (*a_getgrnam)(const char *),
553         struct group *  (*a_getgrgid)(gid_t))
554 {
555         int i;
556
557                 /* a_setgroupent and a_endgrent may be NULL */
558         if (a_getgrnam == NULL || a_getgrgid == NULL)
559                 return (-1);
560
561         if (_pwcache_endgrent != NULL)
562                 (*_pwcache_endgrent)();
563         FLUSHTB(gidtb, GID_SZ, gidtb_fail);
564         FLUSHTB(grptb, GNM_SZ, grptb_fail);
565         gropn = 0;
566         _pwcache_setgroupent = a_setgroupent;
567         _pwcache_endgrent = a_endgrent;
568         _pwcache_getgrnam = a_getgrnam;
569         _pwcache_getgrgid = a_getgrgid;
570
571         return (0);
572 }
573
574
575 #ifdef TEST_PWCACHE
576
577 struct passwd *
578 test_getpwnam(const char *name)
579 {
580         static struct passwd foo;
581
582         memset(&foo, 0, sizeof(foo));
583         if (strcmp(name, "toor") == 0) {
584                 foo.pw_uid = 666;
585                 return &foo;
586         }
587         return (getpwnam(name));
588 }
589
590 int
591 main(int argc, char *argv[])
592 {
593         uid_t   u;
594         int     r, i;
595
596         printf("pass 1 (default userdb)\n");
597         for (i = 1; i < argc; i++) {
598                 printf("i: %d, pwopn %d usrtb_fail %d usrtb %p\n",
599                     i, pwopn, usrtb_fail, usrtb);
600                 r = uid_from_user(argv[i], &u);
601                 if (r == -1)
602                         printf("  uid_from_user %s: failed\n", argv[i]);
603                 else
604                         printf("  uid_from_user %s: %d\n", argv[i], u);
605         }
606         printf("pass 1 finish: pwopn %d usrtb_fail %d usrtb %p\n",
607                     pwopn, usrtb_fail, usrtb);
608
609         puts("");
610         printf("pass 2 (replacement userdb)\n");
611         printf("pwcache_userdb returned %d\n",
612             pwcache_userdb(setpassent, test_getpwnam, getpwuid));
613         printf("pwopn %d usrtb_fail %d usrtb %p\n", pwopn, usrtb_fail, usrtb);
614
615         for (i = 1; i < argc; i++) {
616                 printf("i: %d, pwopn %d usrtb_fail %d usrtb %p\n",
617                     i, pwopn, usrtb_fail, usrtb);
618                 u = -1;
619                 r = uid_from_user(argv[i], &u);
620                 if (r == -1)
621                         printf("  uid_from_user %s: failed\n", argv[i]);
622                 else
623                         printf("  uid_from_user %s: %d\n", argv[i], u);
624         }
625         printf("pass 2 finish: pwopn %d usrtb_fail %d usrtb %p\n",
626                     pwopn, usrtb_fail, usrtb);
627
628         puts("");
629         printf("pass 3 (null pointers)\n");
630         printf("pwcache_userdb returned %d\n",
631             pwcache_userdb(NULL, NULL, NULL));
632
633         return (0);
634 }
635 #endif  /* TEST_PWCACHE */
636 #endif  /* !HAVE_PWCACHE_USERDB */