(__nscd_getgr_r): Deal with missing UIO_MAXIOV.
[kopensolaris-gnu/glibc.git] / nscd / grpcache.c
1 /* Copyright (c) 1998 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1998.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA. */
19
20 #include <errno.h>
21 #include <grp.h>
22 #include <pthread.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <unistd.h>
26 #include <rpcsvc/nis.h>
27 #include <sys/types.h>
28
29 #include "dbg_log.h"
30 #include "nscd.h"
31
32 static unsigned long modulo = 211;
33 static unsigned long postimeout = 3600;
34 static unsigned long negtimeout = 60;
35
36 static unsigned long poshit = 0;
37 static unsigned long posmiss = 0;
38 static unsigned long neghit = 0;
39 static unsigned long negmiss = 0;
40
41 struct grphash
42 {
43   time_t create;
44   struct grphash *next;
45   struct group *grp;
46 };
47 typedef struct grphash grphash;
48
49 struct gidhash
50 {
51   struct gidhash *next;
52   struct group *grptr;
53 };
54 typedef struct gidhash gidhash;
55
56 struct neghash
57 {
58   time_t create;
59   struct neghash *next;
60   char *key;
61 };
62 typedef struct neghash neghash;
63
64 static grphash *grptbl;
65 static gidhash *gidtbl;
66 static neghash *negtbl;
67
68 static pthread_rwlock_t grplock = PTHREAD_RWLOCK_INITIALIZER;
69 static pthread_rwlock_t neglock = PTHREAD_RWLOCK_INITIALIZER;
70
71 static void *grptable_update (void *);
72 static void *negtable_update (void *);
73
74 void
75 get_gr_stat (stat_response_header *stat)
76 {
77   stat->gr_poshit = poshit;
78   stat->gr_posmiss = posmiss;
79   stat->gr_neghit = neghit;
80   stat->gr_negmiss = negmiss;
81   stat->gr_size = modulo;
82   stat->gr_posttl = postimeout;
83   stat->gr_negttl = negtimeout;
84 }
85
86 void
87 set_grp_modulo (unsigned long mod)
88 {
89   modulo = mod;
90 }
91
92 void
93 set_pos_grp_ttl (unsigned long ttl)
94 {
95   postimeout = ttl;
96 }
97
98 void
99 set_neg_grp_ttl (unsigned long ttl)
100 {
101   negtimeout = ttl;
102 }
103
104 int
105 cache_grpinit ()
106 {
107   pthread_attr_t attr;
108   pthread_t thread;
109
110   grptbl = calloc (modulo, sizeof (grphash));
111   if (grptbl == NULL)
112     return -1;
113   gidtbl = calloc (modulo, sizeof (grphash));
114   if (gidtbl == NULL)
115     return -1;
116   negtbl = calloc (modulo, sizeof (neghash));
117   if (negtbl == NULL)
118     return -1;
119
120   pthread_attr_init (&attr);
121   pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
122
123   pthread_create (&thread, NULL, grptable_update, &attr);
124   pthread_create (&thread, NULL, negtable_update, &attr);
125
126   pthread_attr_destroy (&attr);
127
128   return 0;
129 }
130
131 static struct group *
132 save_grp (struct group *src)
133 {
134   struct group *dest;
135   unsigned long int l;
136
137   dest = calloc (1, sizeof (struct group));
138   dest->gr_name = strdup (src->gr_name);
139   dest->gr_passwd = strdup (src->gr_passwd);
140   dest->gr_gid = src->gr_gid;
141
142   /* How many members does this group have?  */
143   l = 0;
144   while (src->gr_mem[l])
145     ++l;
146
147   dest->gr_mem = calloc (1, sizeof (char *) * (l+1));
148   l = 0;
149   while (src->gr_mem[l])
150     {
151       dest->gr_mem[l] = strdup (src->gr_mem[l]);
152       ++l;
153     }
154
155   return dest;
156 }
157
158 static void
159 free_grp (struct group *src)
160 {
161   unsigned long int l;
162
163   free (src->gr_name);
164   free (src->gr_passwd);
165
166   l = 0;
167   while (src->gr_mem[l])
168     {
169       free (src->gr_mem[l]);
170       ++l;
171     }
172   free (src->gr_mem);
173   free (src);
174 }
175
176 static int
177 add_cache (struct group *grp)
178 {
179   grphash *work;
180   gidhash *gidwork;
181   unsigned long int hash = __nis_hash (grp->gr_name,
182                                        strlen (grp->gr_name)) % modulo;
183
184   if (debug_flag)
185     dbg_log (_("grp_add_cache (%s)"), grp->gr_name);
186
187   work = &grptbl[hash];
188
189   if (grptbl[hash].grp == NULL)
190     grptbl[hash].grp = save_grp (grp);
191   else
192     {
193       while (work->next != NULL)
194         work = work->next;
195
196       work->next = calloc (1, sizeof (grphash));
197       work->next->grp = save_grp (grp);
198       work = work->next;
199     }
200
201   time (&work->create);
202   gidwork = &gidtbl[grp->gr_gid % modulo];
203   if (gidwork->grptr == NULL)
204     gidwork->grptr = work->grp;
205   else
206     {
207       while (gidwork->next != NULL)
208         gidwork = gidwork->next;
209
210       gidwork->next = calloc (1, sizeof (gidhash));
211       gidwork->next->grptr = work->grp;
212     }
213
214   return 0;
215 }
216
217 static struct group *
218 cache_search_name (const char *name)
219 {
220   grphash *work;
221   unsigned long int hash = __nis_hash (name, strlen(name)) % modulo;
222
223   work = &grptbl[hash];
224
225   while (work->grp != NULL)
226     {
227       if (strcmp (work->grp->gr_name, name) == 0)
228         return work->grp;
229       if (work->next != NULL)
230         work = work->next;
231       else
232         return NULL;
233     }
234   return NULL;
235 }
236
237 static struct group *
238 cache_search_gid (gid_t gid)
239 {
240   gidhash *work;
241
242   work = &gidtbl[gid % modulo];
243
244   while (work->grptr != NULL)
245     {
246       if (work->grptr->gr_gid == gid)
247         return work->grptr;
248       if (work->next != NULL)
249         work = work->next;
250       else
251         return NULL;
252     }
253   return NULL;
254 }
255
256 static int
257 add_negcache (char *key)
258 {
259   neghash *work;
260   unsigned long int hash = __nis_hash (key, strlen (key)) % modulo;
261
262   if (debug_flag)
263     dbg_log (_("grp_add_netgache (%s|%ld)"), key, hash);
264
265   work = &negtbl[hash];
266
267   if (negtbl[hash].key == NULL)
268     {
269       negtbl[hash].key = strdup (key);
270       negtbl[hash].next = NULL;
271     }
272   else
273     {
274       while (work->next != NULL)
275         work = work->next;
276
277       work->next = calloc (1, sizeof (neghash));
278       work->next->key = strdup (key);
279       work = work->next;
280     }
281
282   time (&work->create);
283   return 0;
284 }
285
286 static int
287 cache_search_neg (const char *key)
288 {
289   neghash *work;
290   unsigned long int hash = __nis_hash (key, strlen (key)) % modulo;
291
292   if (debug_flag)
293     dbg_log (_("grp_cache_search_neg (%s|%ld)"), key, hash);
294
295   work = &negtbl[hash];
296
297   while (work->key != NULL)
298     {
299       if (strcmp (work->key, key) == 0)
300         return 1;
301       if (work->next != NULL)
302         work = work->next;
303       else
304         return 0;
305     }
306   return 0;
307 }
308
309 void *
310 cache_getgrnam (void *v_param)
311 {
312   param_t *param = (param_t *)v_param;
313   struct group *grp;
314
315   pthread_rwlock_rdlock (&grplock);
316   grp = cache_search_name (param->key);
317
318   /* I don't like it to hold the read only lock longer, but it is
319      necessary to avoid to much malloc/free/strcpy.  */
320
321   if (grp != NULL)
322     {
323       if (debug_flag)
324         dbg_log (_("Found \"%s\" in cache !"), param->key);
325
326       ++poshit;
327       gr_send_answer (param->conn, grp);
328       close_socket (param->conn);
329
330       pthread_rwlock_unlock (&grplock);
331     }
332   else
333     {
334       int status;
335       int buflen = 1024;
336       char *buffer = calloc (1, buflen);
337       struct group resultbuf;
338
339       if (debug_flag)
340         dbg_log (_("Doesn't found \"%s\" in cache !"), param->key);
341
342       pthread_rwlock_unlock (&grplock);
343
344       pthread_rwlock_rdlock (&neglock);
345       status = cache_search_neg (param->key);
346       pthread_rwlock_unlock (&neglock);
347
348       if (status == 0)
349         {
350           while (buffer != NULL
351                  && (getgrnam_r (param->key, &resultbuf, buffer, buflen, &grp)
352                      != 0)
353                  && errno == ERANGE)
354             {
355               errno = 0;
356               buflen += 1024;
357               buffer = realloc (buffer, buflen);
358             }
359
360           if (buffer != NULL && grp != NULL)
361             {
362               struct group *tmp;
363
364               ++poshit;
365               pthread_rwlock_wrlock (&grplock);
366               /* While we are waiting on the lock, somebody else could
367                  add this entry.  */
368               tmp = cache_search_name (param->key);
369               if (tmp == NULL)
370                 add_cache (grp);
371               pthread_rwlock_unlock (&grplock);
372             }
373           else
374             {
375               pthread_rwlock_wrlock (&neglock);
376               add_negcache (param->key);
377               ++negmiss;
378               pthread_rwlock_unlock (&neglock);
379             }
380         }
381       else
382         ++neghit;
383
384       gr_send_answer (param->conn, grp);
385       close_socket (param->conn);
386       if (buffer != NULL)
387         free (buffer);
388     }
389   free (param->key);
390   free (param);
391   return NULL;
392 }
393
394 void *
395 cache_gr_disabled (void *v_param)
396 {
397   param_t *param = (param_t *)v_param;
398
399   if (debug_flag)
400     dbg_log (_("\tgroup cache is disabled\n"));
401
402   gr_send_disabled (param->conn);
403   return NULL;
404 }
405
406 void *
407 cache_getgrgid (void *v_param)
408 {
409   param_t *param = (param_t *)v_param;
410   struct group *grp, resultbuf;
411   gid_t gid = strtol (param->key, NULL, 10);
412
413   pthread_rwlock_rdlock (&grplock);
414   grp = cache_search_gid (gid);
415
416   /* I don't like it to hold the read only lock longer, but it is
417      necessary to avoid to much malloc/free/strcpy.  */
418
419   if (grp != NULL)
420     {
421       if (debug_flag)
422         dbg_log (_("Found \"%d\" in cache !"), gid);
423
424       ++poshit;
425       gr_send_answer (param->conn, grp);
426       close_socket (param->conn);
427
428       pthread_rwlock_unlock (&grplock);
429     }
430   else
431     {
432       int buflen = 1024;
433       char *buffer = malloc (buflen);
434       int status;
435
436       if (debug_flag)
437         dbg_log (_("Doesn't found \"%d\" in cache !"), gid);
438
439       pthread_rwlock_unlock (&grplock);
440
441       pthread_rwlock_rdlock (&neglock);
442       status = cache_search_neg (param->key);
443       pthread_rwlock_unlock (&neglock);
444
445       if (status == 0)
446         {
447           while (buffer != NULL
448                  && (getgrgid_r (gid, &resultbuf, buffer, buflen, &grp) != 0)
449                  && errno == ERANGE)
450             {
451               errno = 0;
452               buflen += 1024;
453               buffer = realloc (buffer, buflen);
454             }
455
456           if (buffer != NULL && grp != NULL)
457             {
458               struct group *tmp;
459
460               ++posmiss;
461               pthread_rwlock_wrlock (&grplock);
462               /* While we are waiting on the lock, somebody else could
463                  add this entry.  */
464               tmp = cache_search_gid (gid);
465               if (tmp == NULL)
466                 add_cache (grp);
467               pthread_rwlock_unlock (&grplock);
468             }
469           else
470             {
471               ++negmiss;
472               pthread_rwlock_wrlock (&neglock);
473               add_negcache (param->key);
474               pthread_rwlock_unlock (&neglock);
475             }
476         }
477       else
478         ++neghit;
479
480       gr_send_answer (param->conn, grp);
481       close_socket (param->conn);
482       if (buffer != NULL)
483         free (buffer);
484     }
485   free (param->key);
486   free (param);
487   return NULL;
488 }
489
490 static void *
491 grptable_update (void *v)
492 {
493   time_t now;
494   int i;
495
496   sleep (20);
497
498   while (!do_shutdown)
499     {
500       if (debug_flag > 2)
501         dbg_log (_("(grptable_update) Wait for write lock!"));
502
503       pthread_rwlock_wrlock (&grplock);
504
505       if (debug_flag > 2)
506         dbg_log (_("(grptable_update) Have write lock"));
507
508       time (&now);
509       for (i = 0; i < modulo; ++i)
510         {
511           grphash *work = &grptbl[i];
512
513           while (work && work->grp)
514             {
515               if ((now - work->create) >= postimeout)
516                 {
517                   gidhash *uh = &gidtbl[work->grp->gr_gid % modulo];
518
519                   if (debug_flag)
520                     dbg_log (_("Give \"%s\" free"), work->grp->gr_name);
521
522                   while (uh && uh->grptr)
523                     {
524                       if (uh->grptr->gr_gid == work->grp->gr_gid)
525                         {
526                           if (debug_flag > 3)
527                             dbg_log (_("Give gid for \"%s\" free"),
528                                      work->grp->gr_name);
529                           if (uh->next != NULL)
530                             {
531                               gidhash *tmp = uh->next;
532                               uh->grptr = tmp->grptr;
533                               uh->next = tmp->next;
534                               free (tmp);
535                             }
536                           else
537                             uh->grptr = NULL;
538                         }
539                       uh = uh->next;
540                     }
541
542                   free_grp (work->grp);
543                   if (work->next != NULL)
544                     {
545                       grphash *tmp = work->next;
546                       work->create = tmp->create;
547                       work->next = tmp->next;
548                       work->grp = tmp->grp;
549                       free (tmp);
550                     }
551                   else
552                     work->grp = NULL;
553                 }
554               work = work->next;
555             }
556         }
557       if (debug_flag > 2)
558         dbg_log (_("(grptable_update) Release wait lock"));
559       pthread_rwlock_unlock (&grplock);
560       sleep (20);
561     }
562   return NULL;
563 }
564
565 static void *
566 negtable_update (void *v)
567 {
568   time_t now;
569   int i;
570
571   sleep (30);
572
573   while (!do_shutdown)
574     {
575       if (debug_flag > 2)
576         dbg_log (_("(neggrptable_update) Wait for write lock!"));
577
578       pthread_rwlock_wrlock (&neglock);
579
580       if (debug_flag > 2)
581         dbg_log (_("(neggrptable_update) Have write lock"));
582
583       time (&now);
584       for (i = 0; i < modulo; ++i)
585         {
586           neghash *work = &negtbl[i];
587
588           while (work && work->key)
589             {
590               if ((now - work->create) >= negtimeout)
591                 {
592                   if (debug_flag)
593                     dbg_log (_("Give \"%s\" free"), work->key);
594
595                   free (work->key);
596
597                   if (work->next != NULL)
598                     {
599                       neghash *tmp = work->next;
600                       work->create = tmp->create;
601                       work->next = tmp->next;
602                       work->key = tmp->key;
603                       free (tmp);
604                     }
605                   else
606                     work->key = NULL;
607                 }
608               work = work->next;
609             }
610         }
611       if (debug_flag > 2)
612         dbg_log (_("(neggrptable_update) Release wait lock"));
613       pthread_rwlock_unlock (&neglock);
614       sleep (10);
615     }
616   return NULL;
617 }