caafeb69b0caa7837c4a5e0d71107afd49d735b7
[kopensolaris-gnu/glibc.git] / nscd / connections.c
1 /* Inner loops of cache daemon.
2    Copyright (C) 1998-2003, 2004, 2005 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License version 2 as
8    published by the Free Software Foundation.
9
10    This program 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
13    GNU General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software Foundation,
17    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
18
19 #include <alloca.h>
20 #include <assert.h>
21 #include <atomic.h>
22 #include <error.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <grp.h>
26 #include <libintl.h>
27 #include <pthread.h>
28 #include <pwd.h>
29 #include <resolv.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <unistd.h>
33 #include <arpa/inet.h>
34 #ifdef HAVE_EPOLL
35 # include <sys/epoll.h>
36 #endif
37 #include <sys/mman.h>
38 #include <sys/param.h>
39 #include <sys/poll.h>
40 #ifdef HAVE_SENDFILE
41 # include <sys/sendfile.h>
42 #endif
43 #include <sys/socket.h>
44 #include <sys/stat.h>
45 #include <sys/un.h>
46
47 #include "nscd.h"
48 #include "dbg_log.h"
49 #include "selinux.h"
50 #ifdef HAVE_SENDFILE
51 # include <kernel-features.h>
52 #endif
53
54
55 /* Wrapper functions with error checking for standard functions.  */
56 extern void *xmalloc (size_t n);
57 extern void *xcalloc (size_t n, size_t s);
58 extern void *xrealloc (void *o, size_t n);
59
60 /* Support to run nscd as an unprivileged user */
61 const char *server_user;
62 static uid_t server_uid;
63 static gid_t server_gid;
64 const char *stat_user;
65 uid_t stat_uid;
66 static gid_t *server_groups;
67 #ifndef NGROUPS
68 # define NGROUPS 32
69 #endif
70 static int server_ngroups;
71
72 static pthread_attr_t attr;
73
74 static void begin_drop_privileges (void);
75 static void finish_drop_privileges (void);
76
77 /* Map request type to a string.  */
78 const char *serv2str[LASTREQ] =
79 {
80   [GETPWBYNAME] = "GETPWBYNAME",
81   [GETPWBYUID] = "GETPWBYUID",
82   [GETGRBYNAME] = "GETGRBYNAME",
83   [GETGRBYGID] = "GETGRBYGID",
84   [GETHOSTBYNAME] = "GETHOSTBYNAME",
85   [GETHOSTBYNAMEv6] = "GETHOSTBYNAMEv6",
86   [GETHOSTBYADDR] = "GETHOSTBYADDR",
87   [GETHOSTBYADDRv6] = "GETHOSTBYADDRv6",
88   [SHUTDOWN] = "SHUTDOWN",
89   [GETSTAT] = "GETSTAT",
90   [INVALIDATE] = "INVALIDATE",
91   [GETFDPW] = "GETFDPW",
92   [GETFDGR] = "GETFDGR",
93   [GETFDHST] = "GETFDHST",
94   [GETAI] = "GETAI",
95   [INITGROUPS] = "INITGROUPS"
96 };
97
98 /* The control data structures for the services.  */
99 struct database_dyn dbs[lastdb] =
100 {
101   [pwddb] = {
102     .lock = PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP,
103     .enabled = 0,
104     .check_file = 1,
105     .persistent = 0,
106     .shared = 0,
107     .max_db_size = DEFAULT_MAX_DB_SIZE,
108     .filename = "/etc/passwd",
109     .db_filename = _PATH_NSCD_PASSWD_DB,
110     .disabled_iov = &pwd_iov_disabled,
111     .postimeout = 3600,
112     .negtimeout = 20,
113     .wr_fd = -1,
114     .ro_fd = -1,
115     .mmap_used = false
116   },
117   [grpdb] = {
118     .lock = PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP,
119     .enabled = 0,
120     .check_file = 1,
121     .persistent = 0,
122     .shared = 0,
123     .max_db_size = DEFAULT_MAX_DB_SIZE,
124     .filename = "/etc/group",
125     .db_filename = _PATH_NSCD_GROUP_DB,
126     .disabled_iov = &grp_iov_disabled,
127     .postimeout = 3600,
128     .negtimeout = 60,
129     .wr_fd = -1,
130     .ro_fd = -1,
131     .mmap_used = false
132   },
133   [hstdb] = {
134     .lock = PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP,
135     .enabled = 0,
136     .check_file = 1,
137     .persistent = 0,
138     .shared = 0,
139     .max_db_size = DEFAULT_MAX_DB_SIZE,
140     .filename = "/etc/hosts",
141     .db_filename = _PATH_NSCD_HOSTS_DB,
142     .disabled_iov = &hst_iov_disabled,
143     .postimeout = 3600,
144     .negtimeout = 20,
145     .wr_fd = -1,
146     .ro_fd = -1,
147     .mmap_used = false
148   }
149 };
150
151
152 /* Mapping of request type to database.  */
153 static struct database_dyn *const serv2db[LASTREQ] =
154 {
155   [GETPWBYNAME] = &dbs[pwddb],
156   [GETPWBYUID] = &dbs[pwddb],
157   [GETGRBYNAME] = &dbs[grpdb],
158   [GETGRBYGID] = &dbs[grpdb],
159   [GETHOSTBYNAME] = &dbs[hstdb],
160   [GETHOSTBYNAMEv6] = &dbs[hstdb],
161   [GETHOSTBYADDR] = &dbs[hstdb],
162   [GETHOSTBYADDRv6] = &dbs[hstdb],
163   [GETFDPW] = &dbs[pwddb],
164   [GETFDGR] = &dbs[grpdb],
165   [GETFDHST] = &dbs[hstdb],
166   [GETAI] = &dbs[hstdb],
167   [INITGROUPS] = &dbs[grpdb]
168 };
169
170
171 /* Number of seconds between two cache pruning runs.  */
172 #define CACHE_PRUNE_INTERVAL    15
173
174
175 /* Initial number of threads to use.  */
176 int nthreads = -1;
177 /* Maximum number of threads to use.  */
178 int max_nthreads = 32;
179
180 /* Socket for incoming connections.  */
181 static int sock;
182
183 /* Number of times clients had to wait.  */
184 unsigned long int client_queued;
185
186
187 ssize_t
188 writeall (int fd, const void *buf, size_t len)
189 {
190   size_t n = len;
191   ssize_t ret;
192   do
193     {
194       ret = TEMP_FAILURE_RETRY (send (fd, buf, n, MSG_NOSIGNAL));
195       if (ret <= 0)
196         break;
197       buf = (const char *) buf + ret;
198       n -= ret;
199     }
200   while (n > 0);
201   return ret < 0 ? ret : len - n;
202 }
203
204
205 #ifdef HAVE_SENDFILE
206 ssize_t
207 sendfileall (int tofd, int fromfd, off_t off, size_t len)
208 {
209   ssize_t n = len;
210   ssize_t ret;
211
212   do
213     {
214       ret = TEMP_FAILURE_RETRY (sendfile (tofd, fromfd, &off, n));
215       if (ret <= 0)
216         break;
217       n -= ret;
218     }
219   while (n > 0);
220   return ret < 0 ? ret : len - n;
221 }
222 #endif
223
224
225 enum usekey
226   {
227     use_not = 0,
228     /* The following three are not really used, they are symbolic constants.  */
229     use_first = 16,
230     use_begin = 32,
231     use_end = 64,
232
233     use_he = 1,
234     use_he_begin = use_he | use_begin,
235     use_he_end = use_he | use_end,
236 #if SEPARATE_KEY
237     use_key = 2,
238     use_key_begin = use_key | use_begin,
239     use_key_end = use_key | use_end,
240     use_key_first = use_key_begin | use_first,
241 #endif
242     use_data = 3,
243     use_data_begin = use_data | use_begin,
244     use_data_end = use_data | use_end,
245     use_data_first = use_data_begin | use_first
246   };
247
248
249 static int
250 check_use (const char *data, nscd_ssize_t first_free, uint8_t *usemap,
251            enum usekey use, ref_t start, size_t len)
252 {
253   assert (len >= 2);
254
255   if (start > first_free || start + len > first_free
256       || (start & BLOCK_ALIGN_M1))
257     return 0;
258
259   if (usemap[start] == use_not)
260     {
261       /* Add the start marker.  */
262       usemap[start] = use | use_begin;
263       use &= ~use_first;
264
265       while (--len > 0)
266         if (usemap[++start] != use_not)
267           return 0;
268         else
269           usemap[start] = use;
270
271       /* Add the end marker.  */
272       usemap[start] = use | use_end;
273     }
274   else if ((usemap[start] & ~use_first) == ((use | use_begin) & ~use_first))
275     {
276       /* Hash entries can't be shared.  */
277       if (use == use_he)
278         return 0;
279
280       usemap[start] |= (use & use_first);
281       use &= ~use_first;
282
283       while (--len > 1)
284         if (usemap[++start] != use)
285           return 0;
286
287       if (usemap[++start] != (use | use_end))
288         return 0;
289     }
290   else
291     /* Points to a wrong object or somewhere in the middle.  */
292     return 0;
293
294   return 1;
295 }
296
297
298 /* Verify data in persistent database.  */
299 static int
300 verify_persistent_db (void *mem, struct database_pers_head *readhead, int dbnr)
301 {
302   assert (dbnr == pwddb || dbnr == grpdb || dbnr == hstdb);
303
304   time_t now = time (NULL);
305
306   struct database_pers_head *head = mem;
307   struct database_pers_head head_copy = *head;
308
309   /* Check that the header that was read matches the head in the database.  */
310   if (readhead != NULL && memcmp (head, readhead, sizeof (*head)) != 0)
311     return 0;
312
313   /* First some easy tests: make sure the database header is sane.  */
314   if (head->version != DB_VERSION
315       || head->header_size != sizeof (*head)
316       /* We allow a timestamp to be one hour ahead of the current time.
317          This should cover daylight saving time changes.  */
318       || head->timestamp > now + 60 * 60 + 60
319       || (head->gc_cycle & 1)
320       || (size_t) head->module > INT32_MAX / sizeof (ref_t)
321       || (size_t) head->data_size > INT32_MAX - head->module * sizeof (ref_t)
322       || head->first_free < 0
323       || head->first_free > head->data_size
324       || (head->first_free & BLOCK_ALIGN_M1) != 0
325       || head->maxnentries < 0
326       || head->maxnsearched < 0)
327     return 0;
328
329   uint8_t *usemap = calloc (head->first_free, 1);
330   if (usemap == NULL)
331     return 0;
332
333   const char *data = (char *) &head->array[roundup (head->module,
334                                                     ALIGN / sizeof (ref_t))];
335
336   nscd_ssize_t he_cnt = 0;
337   for (nscd_ssize_t cnt = 0; cnt < head->module; ++cnt)
338     {
339       ref_t work = head->array[cnt];
340
341       while (work != ENDREF)
342         {
343           if (! check_use (data, head->first_free, usemap, use_he, work,
344                            sizeof (struct hashentry)))
345             goto fail;
346
347           /* Now we know we can dereference the record.  */
348           struct hashentry *here = (struct hashentry *) (data + work);
349
350           ++he_cnt;
351
352           /* Make sure the record is for this type of service.  */
353           if (here->type >= LASTREQ
354               || serv2db[here->type] != &dbs[dbnr])
355             goto fail;
356
357           /* Validate boolean field value.  */
358           if (here->first != false && here->first != true)
359             goto fail;
360
361           if (here->len < 0)
362             goto fail;
363
364           /* Now the data.  */
365           if (here->packet < 0
366               || here->packet > head->first_free
367               || here->packet + sizeof (struct datahead) > head->first_free)
368             goto fail;
369
370           struct datahead *dh = (struct datahead *) (data + here->packet);
371
372           if (! check_use (data, head->first_free, usemap,
373                            use_data | (here->first ? use_first : 0),
374                            here->packet, dh->allocsize))
375             goto fail;
376
377           if (dh->allocsize < sizeof (struct datahead)
378               || dh->recsize > dh->allocsize
379               || (dh->notfound != false && dh->notfound != true)
380               || (dh->usable != false && dh->usable != true))
381             goto fail;
382
383           if (here->key < here->packet + sizeof (struct datahead)
384               || here->key > here->packet + dh->allocsize
385               || here->key + here->len > here->packet + dh->allocsize)
386             {
387 #if SEPARATE_KEY
388               /* If keys can appear outside of data, this should be done
389                  instead.  But gc doesn't mark the data in that case.  */
390               if (! check_use (data, head->first_free, usemap,
391                                use_key | (here->first ? use_first : 0),
392                                here->key, here->len))
393 #endif
394                 goto fail;
395             }
396
397           work = here->next;
398         }
399     }
400
401   if (he_cnt != head->nentries)
402     goto fail;
403
404   /* See if all data and keys had at least one reference from
405      he->first == true hashentry.  */
406   for (ref_t idx = 0; idx < head->first_free; ++idx)
407     {
408 #if SEPARATE_KEY
409       if (usemap[idx] == use_key_begin)
410         goto fail;
411 #endif
412       if (usemap[idx] == use_data_begin)
413         goto fail;
414     }
415
416   /* Finally, make sure the database hasn't changed since the first test.  */
417   if (memcmp (mem, &head_copy, sizeof (*head)) != 0)
418     goto fail;
419
420   free (usemap);
421   return 1;
422
423 fail:
424   free (usemap);
425   return 0;
426 }
427
428
429 /* Initialize database information structures.  */
430 void
431 nscd_init (void)
432 {
433   /* Secure mode and unprivileged mode are incompatible */
434   if (server_user != NULL)
435     {
436       dbg_log (_("Cannot run nscd in secure mode as unprivileged user"));
437       exit (4);
438     }
439
440   /* Look up unprivileged uid/gid/groups before we start listening on the
441      socket  */
442   if (server_user != NULL)
443     begin_drop_privileges ();
444
445   if (nthreads == -1)
446     /* No configuration for this value, assume a default.  */
447     nthreads = 2 * lastdb;
448
449   for (size_t cnt = 0; cnt < lastdb; ++cnt)
450     if (dbs[cnt].enabled)
451       {
452         pthread_rwlock_init (&dbs[cnt].lock, NULL);
453         pthread_mutex_init (&dbs[cnt].memlock, NULL);
454
455         if (dbs[cnt].persistent)
456           {
457             /* Try to open the appropriate file on disk.  */
458             int fd = open (dbs[cnt].db_filename, O_RDWR);
459             if (fd != -1)
460               {
461                 struct stat64 st;
462                 void *mem;
463                 size_t total;
464                 struct database_pers_head head;
465                 ssize_t n = TEMP_FAILURE_RETRY (read (fd, &head,
466                                                       sizeof (head)));
467                 if (n != sizeof (head) || fstat64 (fd, &st) != 0)
468                   {
469                   fail_db:
470                     dbg_log (_("invalid persistent database file \"%s\": %s"),
471                              dbs[cnt].db_filename, strerror (errno));
472                     unlink (dbs[cnt].db_filename);
473                   }
474                 else if (head.module == 0 && head.data_size == 0)
475                   {
476                     /* The file has been created, but the head has not been
477                        initialized yet.  Remove the old file.  */
478                     unlink (dbs[cnt].db_filename);
479                   }
480                 else if (head.header_size != (int) sizeof (head))
481                   {
482                     dbg_log (_("invalid persistent database file \"%s\": %s"),
483                              dbs[cnt].db_filename,
484                              _("header size does not match"));
485                     unlink (dbs[cnt].db_filename);
486                   }
487                 else if ((total = (sizeof (head)
488                                    + roundup (head.module * sizeof (ref_t),
489                                               ALIGN)
490                                    + head.data_size))
491                          > st.st_size
492                          || total < sizeof (head))
493                   {
494                     dbg_log (_("invalid persistent database file \"%s\": %s"),
495                              dbs[cnt].db_filename,
496                              _("file size does not match"));
497                     unlink (dbs[cnt].db_filename);
498                   }
499                 /* Note we map with the maximum size allowed for the
500                    database.  This is likely much larger than the
501                    actual file size.  This is OK on most OSes since
502                    extensions of the underlying file will
503                    automatically translate more pages available for
504                    memory access.  */
505                 else if ((mem = mmap (NULL, dbs[cnt].max_db_size,
506                                       PROT_READ | PROT_WRITE,
507                                       MAP_SHARED, fd, 0))
508                          == MAP_FAILED)
509                   goto fail_db;
510                 else if (!verify_persistent_db (mem, &head, cnt))
511                   {
512                     munmap (mem, total);
513                     dbg_log (_("invalid persistent database file \"%s\": %s"),
514                              dbs[cnt].db_filename,
515                              _("verification failed"));
516                     unlink (dbs[cnt].db_filename);
517                   }
518                 else
519                   {
520                     /* Success.  We have the database.  */
521                     dbs[cnt].head = mem;
522                     dbs[cnt].memsize = total;
523                     dbs[cnt].data = (char *)
524                       &dbs[cnt].head->array[roundup (dbs[cnt].head->module,
525                                                      ALIGN / sizeof (ref_t))];
526                     dbs[cnt].mmap_used = true;
527
528                     if (dbs[cnt].suggested_module > head.module)
529                       dbg_log (_("suggested size of table for database %s larger than the persistent database's table"),
530                                dbnames[cnt]);
531
532                     dbs[cnt].wr_fd = fd;
533                     fd = -1;
534                     /* We also need a read-only descriptor.  */
535                     if (dbs[cnt].shared)
536                       {
537                         dbs[cnt].ro_fd = open (dbs[cnt].db_filename, O_RDONLY);
538                         if (dbs[cnt].ro_fd == -1)
539                           dbg_log (_("\
540 cannot create read-only descriptor for \"%s\"; no mmap"),
541                                    dbs[cnt].db_filename);
542                       }
543
544                     // XXX Shall we test whether the descriptors actually
545                     // XXX point to the same file?
546                   }
547
548                 /* Close the file descriptors in case something went
549                    wrong in which case the variable have not been
550                    assigned -1.  */
551                 if (fd != -1)
552                   close (fd);
553               }
554           }
555
556         if (dbs[cnt].head == NULL)
557           {
558             /* No database loaded.  Allocate the data structure,
559                possibly on disk.  */
560             struct database_pers_head head;
561             size_t total = (sizeof (head)
562                             + roundup (dbs[cnt].suggested_module
563                                        * sizeof (ref_t), ALIGN)
564                             + (dbs[cnt].suggested_module
565                                * DEFAULT_DATASIZE_PER_BUCKET));
566
567             /* Try to create the database.  If we do not need a
568                persistent database create a temporary file.  */
569             int fd;
570             int ro_fd = -1;
571             if (dbs[cnt].persistent)
572               {
573                 fd = open (dbs[cnt].db_filename,
574                            O_RDWR | O_CREAT | O_EXCL | O_TRUNC,
575                            S_IRUSR | S_IWUSR);
576                 if (fd != -1 && dbs[cnt].shared)
577                   ro_fd = open (dbs[cnt].db_filename, O_RDONLY);
578               }
579             else
580               {
581                 char fname[] = _PATH_NSCD_XYZ_DB_TMP;
582                 fd = mkstemp (fname);
583
584                 /* We do not need the file name anymore after we
585                    opened another file descriptor in read-only mode.  */
586                 if (fd != -1)
587                   {
588                     if (dbs[cnt].shared)
589                       ro_fd = open (fname, O_RDONLY);
590
591                     unlink (fname);
592                   }
593               }
594
595             if (fd == -1)
596               {
597                 if (errno == EEXIST)
598                   {
599                     dbg_log (_("database for %s corrupted or simultaneously used; remove %s manually if necessary and restart"),
600                              dbnames[cnt], dbs[cnt].db_filename);
601                     // XXX Correct way to terminate?
602                     exit (1);
603                   }
604
605                 if  (dbs[cnt].persistent)
606                   dbg_log (_("cannot create %s; no persistent database used"),
607                            dbs[cnt].db_filename);
608                 else
609                   dbg_log (_("cannot create %s; no sharing possible"),
610                            dbs[cnt].db_filename);
611
612                 dbs[cnt].persistent = 0;
613                 // XXX remember: no mmap
614               }
615             else
616               {
617                 /* Tell the user if we could not create the read-only
618                    descriptor.  */
619                 if (ro_fd == -1 && dbs[cnt].shared)
620                   dbg_log (_("\
621 cannot create read-only descriptor for \"%s\"; no mmap"),
622                            dbs[cnt].db_filename);
623
624                 /* Before we create the header, initialiye the hash
625                    table.  So that if we get interrupted if writing
626                    the header we can recognize a partially initialized
627                    database.  */
628                 size_t ps = sysconf (_SC_PAGESIZE);
629                 char tmpbuf[ps];
630                 assert (~ENDREF == 0);
631                 memset (tmpbuf, '\xff', ps);
632
633                 size_t remaining = dbs[cnt].suggested_module * sizeof (ref_t);
634                 off_t offset = sizeof (head);
635
636                 size_t towrite;
637                 if (offset % ps != 0)
638                   {
639                     towrite = MIN (remaining, ps - (offset % ps));
640                     if (pwrite (fd, tmpbuf, towrite, offset) != towrite)
641                       goto write_fail;
642                     offset += towrite;
643                     remaining -= towrite;
644                   }
645
646                 while (remaining > ps)
647                   {
648                     if (pwrite (fd, tmpbuf, ps, offset) == -1)
649                       goto write_fail;
650                     offset += ps;
651                     remaining -= ps;
652                   }
653
654                 if (remaining > 0
655                     && pwrite (fd, tmpbuf, remaining, offset) != remaining)
656                   goto write_fail;
657
658                 /* Create the header of the file.  */
659                 struct database_pers_head head =
660                   {
661                     .version = DB_VERSION,
662                     .header_size = sizeof (head),
663                     .module = dbs[cnt].suggested_module,
664                     .data_size = (dbs[cnt].suggested_module
665                                   * DEFAULT_DATASIZE_PER_BUCKET),
666                     .first_free = 0
667                   };
668                 void *mem;
669
670                 if ((TEMP_FAILURE_RETRY (write (fd, &head, sizeof (head)))
671                      != sizeof (head))
672                     || (TEMP_FAILURE_RETRY_VAL (posix_fallocate (fd, 0, total))
673                         != 0)
674                     || (mem = mmap (NULL, dbs[cnt].max_db_size,
675                                     PROT_READ | PROT_WRITE,
676                                     MAP_SHARED, fd, 0)) == MAP_FAILED)
677                   {
678                   write_fail:
679                     unlink (dbs[cnt].db_filename);
680                     dbg_log (_("cannot write to database file %s: %s"),
681                              dbs[cnt].db_filename, strerror (errno));
682                     dbs[cnt].persistent = 0;
683                   }
684                 else
685                   {
686                     /* Success.  */
687                     dbs[cnt].head = mem;
688                     dbs[cnt].data = (char *)
689                       &dbs[cnt].head->array[roundup (dbs[cnt].head->module,
690                                                      ALIGN / sizeof (ref_t))];
691                     dbs[cnt].memsize = total;
692                     dbs[cnt].mmap_used = true;
693
694                     /* Remember the descriptors.  */
695                     dbs[cnt].wr_fd = fd;
696                     dbs[cnt].ro_fd = ro_fd;
697                     fd = -1;
698                     ro_fd = -1;
699                   }
700
701                 if (fd != -1)
702                   close (fd);
703                 if (ro_fd != -1)
704                   close (ro_fd);
705               }
706           }
707
708         if (paranoia
709             && ((dbs[cnt].wr_fd != -1
710                  && fcntl (dbs[cnt].wr_fd, F_SETFD, FD_CLOEXEC) == -1)
711                 || (dbs[cnt].ro_fd != -1
712                     && fcntl (dbs[cnt].ro_fd, F_SETFD, FD_CLOEXEC) == -1)))
713           {
714             dbg_log (_("\
715 cannot set socket to close on exec: %s; disabling paranoia mode"),
716                      strerror (errno));
717             paranoia = 0;
718           }
719
720         if (dbs[cnt].head == NULL)
721           {
722             /* We do not use the persistent database.  Just
723                create an in-memory data structure.  */
724             assert (! dbs[cnt].persistent);
725
726             dbs[cnt].head = xmalloc (sizeof (struct database_pers_head)
727                                      + (dbs[cnt].suggested_module
728                                         * sizeof (ref_t)));
729             memset (dbs[cnt].head, '\0', sizeof (dbs[cnt].head));
730             assert (~ENDREF == 0);
731             memset (dbs[cnt].head->array, '\xff',
732                     dbs[cnt].suggested_module * sizeof (ref_t));
733             dbs[cnt].head->module = dbs[cnt].suggested_module;
734             dbs[cnt].head->data_size = (DEFAULT_DATASIZE_PER_BUCKET
735                                         * dbs[cnt].head->module);
736             dbs[cnt].data = xmalloc (dbs[cnt].head->data_size);
737             dbs[cnt].head->first_free = 0;
738
739             dbs[cnt].shared = 0;
740             assert (dbs[cnt].ro_fd == -1);
741           }
742
743         if (dbs[cnt].check_file)
744           {
745             /* We need the modification date of the file.  */
746             struct stat64 st;
747
748             if (stat64 (dbs[cnt].filename, &st) < 0)
749               {
750                 /* We cannot stat() the file, disable file checking.  */
751                 dbg_log (_("cannot stat() file `%s': %s"),
752                          dbs[cnt].filename, strerror (errno));
753                 dbs[cnt].check_file = 0;
754               }
755             else
756               dbs[cnt].file_mtime = st.st_mtime;
757           }
758       }
759
760   /* Create the socket.  */
761   sock = socket (AF_UNIX, SOCK_STREAM, 0);
762   if (sock < 0)
763     {
764       dbg_log (_("cannot open socket: %s"), strerror (errno));
765       exit (errno == EACCES ? 4 : 1);
766     }
767   /* Bind a name to the socket.  */
768   struct sockaddr_un sock_addr;
769   sock_addr.sun_family = AF_UNIX;
770   strcpy (sock_addr.sun_path, _PATH_NSCDSOCKET);
771   if (bind (sock, (struct sockaddr *) &sock_addr, sizeof (sock_addr)) < 0)
772     {
773       dbg_log ("%s: %s", _PATH_NSCDSOCKET, strerror (errno));
774       exit (errno == EACCES ? 4 : 1);
775     }
776
777   /* We don't want to get stuck on accept.  */
778   int fl = fcntl (sock, F_GETFL);
779   if (fl == -1 || fcntl (sock, F_SETFL, fl | O_NONBLOCK) == -1)
780     {
781       dbg_log (_("cannot change socket to nonblocking mode: %s"),
782                strerror (errno));
783       exit (1);
784     }
785
786   /* The descriptor needs to be closed on exec.  */
787   if (paranoia && fcntl (sock, F_SETFD, FD_CLOEXEC) == -1)
788     {
789       dbg_log (_("cannot set socket to close on exec: %s"),
790                strerror (errno));
791       exit (1);
792     }
793
794   /* Set permissions for the socket.  */
795   chmod (_PATH_NSCDSOCKET, DEFFILEMODE);
796
797   /* Set the socket up to accept connections.  */
798   if (listen (sock, SOMAXCONN) < 0)
799     {
800       dbg_log (_("cannot enable socket to accept connections: %s"),
801                strerror (errno));
802       exit (1);
803     }
804
805   /* Change to unprivileged uid/gid/groups if specifed in config file */
806   if (server_user != NULL)
807     finish_drop_privileges ();
808 }
809
810
811 /* Close the connections.  */
812 void
813 close_sockets (void)
814 {
815   close (sock);
816 }
817
818
819 static void
820 invalidate_cache (char *key)
821 {
822   dbtype number;
823
824   if (strcmp (key, "passwd") == 0)
825     number = pwddb;
826   else if (strcmp (key, "group") == 0)
827     number = grpdb;
828   else if (__builtin_expect (strcmp (key, "hosts"), 0) == 0)
829     {
830       number = hstdb;
831
832       /* Re-initialize the resolver.  resolv.conf might have changed.  */
833       res_init ();
834     }
835   else
836     return;
837
838   if (dbs[number].enabled)
839     prune_cache (&dbs[number], LONG_MAX);
840 }
841
842
843 #ifdef SCM_RIGHTS
844 static void
845 send_ro_fd (struct database_dyn *db, char *key, int fd)
846 {
847   /* If we do not have an read-only file descriptor do nothing.  */
848   if (db->ro_fd == -1)
849     return;
850
851   /* We need to send some data along with the descriptor.  */
852   struct iovec iov[1];
853   iov[0].iov_base = key;
854   iov[0].iov_len = strlen (key) + 1;
855
856   /* Prepare the control message to transfer the descriptor.  */
857   union
858   {
859     struct cmsghdr hdr;
860     char bytes[CMSG_SPACE (sizeof (int))];
861   } buf;
862   struct msghdr msg = { .msg_iov = iov, .msg_iovlen = 1,
863                         .msg_control = buf.bytes,
864                         .msg_controllen = sizeof (buf) };
865   struct cmsghdr *cmsg = CMSG_FIRSTHDR (&msg);
866
867   cmsg->cmsg_level = SOL_SOCKET;
868   cmsg->cmsg_type = SCM_RIGHTS;
869   cmsg->cmsg_len = CMSG_LEN (sizeof (int));
870
871   *(int *) CMSG_DATA (cmsg) = db->ro_fd;
872
873   msg.msg_controllen = cmsg->cmsg_len;
874
875   /* Send the control message.  We repeat when we are interrupted but
876      everything else is ignored.  */
877 #ifndef MSG_NOSIGNAL
878 # define MSG_NOSIGNAL 0
879 #endif
880   (void) TEMP_FAILURE_RETRY (sendmsg (fd, &msg, MSG_NOSIGNAL));
881
882   if (__builtin_expect (debug_level > 0, 0))
883     dbg_log (_("provide access to FD %d, for %s"), db->ro_fd, key);
884 }
885 #endif  /* SCM_RIGHTS */
886
887
888 /* Handle new request.  */
889 static void
890 handle_request (int fd, request_header *req, void *key, uid_t uid)
891 {
892   if (__builtin_expect (req->version, NSCD_VERSION) != NSCD_VERSION)
893     {
894       if (debug_level > 0)
895         dbg_log (_("\
896 cannot handle old request version %d; current version is %d"),
897                  req->version, NSCD_VERSION);
898       return;
899     }
900
901   /* Make the SELinux check before we go on to the standard checks.  We
902      need to verify that the request type is valid, since it has not
903      yet been checked at this point.  */
904   if (selinux_enabled
905       && __builtin_expect (req->type, GETPWBYNAME) >= GETPWBYNAME
906       && __builtin_expect (req->type, LASTREQ) < LASTREQ
907       && nscd_request_avc_has_perm (fd, req->type) != 0)
908     return;
909
910   struct database_dyn *db = serv2db[req->type];
911
912   // XXX Clean up so that each new command need not introduce a
913   // XXX new conditional.
914   if ((__builtin_expect (req->type, GETPWBYNAME) >= GETPWBYNAME
915        && __builtin_expect (req->type, LASTDBREQ) <= LASTDBREQ)
916       || req->type == GETAI || req->type == INITGROUPS)
917     {
918       if (__builtin_expect (debug_level, 0) > 0)
919         {
920           if (req->type == GETHOSTBYADDR || req->type == GETHOSTBYADDRv6)
921             {
922               char buf[INET6_ADDRSTRLEN];
923
924               dbg_log ("\t%s (%s)", serv2str[req->type],
925                        inet_ntop (req->type == GETHOSTBYADDR
926                                   ? AF_INET : AF_INET6,
927                                   key, buf, sizeof (buf)));
928             }
929           else
930             dbg_log ("\t%s (%s)", serv2str[req->type], (char *) key);
931         }
932
933       /* Is this service enabled?  */
934       if (!db->enabled)
935         {
936           /* No, sent the prepared record.  */
937           if (TEMP_FAILURE_RETRY (send (fd, db->disabled_iov->iov_base,
938                                         db->disabled_iov->iov_len,
939                                         MSG_NOSIGNAL))
940               != (ssize_t) db->disabled_iov->iov_len
941               && __builtin_expect (debug_level, 0) > 0)
942             {
943               /* We have problems sending the result.  */
944               char buf[256];
945               dbg_log (_("cannot write result: %s"),
946                        strerror_r (errno, buf, sizeof (buf)));
947             }
948
949           return;
950         }
951
952       /* Be sure we can read the data.  */
953       if (__builtin_expect (pthread_rwlock_tryrdlock (&db->lock) != 0, 0))
954         {
955           ++db->head->rdlockdelayed;
956           pthread_rwlock_rdlock (&db->lock);
957         }
958
959       /* See whether we can handle it from the cache.  */
960       struct datahead *cached;
961       cached = (struct datahead *) cache_search (req->type, key, req->key_len,
962                                                  db, uid);
963       if (cached != NULL)
964         {
965           /* Hurray it's in the cache.  */
966           ssize_t nwritten;
967
968 #ifdef HAVE_SENDFILE
969           if (db->mmap_used || !cached->notfound)
970             {
971               assert (db->wr_fd != -1);
972               assert ((char *) cached->data > (char *) db->data);
973               assert ((char *) cached->data - (char *) db->head
974                       + cached->recsize
975                       <= (sizeof (struct database_pers_head)
976                           + db->head->module * sizeof (ref_t)
977                           + db->head->data_size));
978               nwritten = sendfileall (fd, db->wr_fd,
979                                       (char *) cached->data
980                                       - (char *) db->head, cached->recsize);
981 # ifndef __ASSUME_SENDFILE
982               if (nwritten == -1 && errno == ENOSYS)
983                 goto use_write;
984 # endif
985             }
986           else
987 # ifndef __ASSUME_SENDFILE
988           use_write:
989 # endif
990 #endif
991             nwritten = writeall (fd, cached->data, cached->recsize);
992
993           if (nwritten != cached->recsize
994               && __builtin_expect (debug_level, 0) > 0)
995             {
996               /* We have problems sending the result.  */
997               char buf[256];
998               dbg_log (_("cannot write result: %s"),
999                        strerror_r (errno, buf, sizeof (buf)));
1000             }
1001
1002           pthread_rwlock_unlock (&db->lock);
1003
1004           return;
1005         }
1006
1007       pthread_rwlock_unlock (&db->lock);
1008     }
1009   else if (__builtin_expect (debug_level, 0) > 0)
1010     {
1011       if (req->type == INVALIDATE)
1012         dbg_log ("\t%s (%s)", serv2str[req->type], (char *) key);
1013       else
1014         dbg_log ("\t%s", serv2str[req->type]);
1015     }
1016
1017   /* Handle the request.  */
1018   switch (req->type)
1019     {
1020     case GETPWBYNAME:
1021       addpwbyname (db, fd, req, key, uid);
1022       break;
1023
1024     case GETPWBYUID:
1025       addpwbyuid (db, fd, req, key, uid);
1026       break;
1027
1028     case GETGRBYNAME:
1029       addgrbyname (db, fd, req, key, uid);
1030       break;
1031
1032     case GETGRBYGID:
1033       addgrbygid (db, fd, req, key, uid);
1034       break;
1035
1036     case GETHOSTBYNAME:
1037       addhstbyname (db, fd, req, key, uid);
1038       break;
1039
1040     case GETHOSTBYNAMEv6:
1041       addhstbynamev6 (db, fd, req, key, uid);
1042       break;
1043
1044     case GETHOSTBYADDR:
1045       addhstbyaddr (db, fd, req, key, uid);
1046       break;
1047
1048     case GETHOSTBYADDRv6:
1049       addhstbyaddrv6 (db, fd, req, key, uid);
1050       break;
1051
1052     case GETAI:
1053       addhstai (db, fd, req, key, uid);
1054       break;
1055
1056     case INITGROUPS:
1057       addinitgroups (db, fd, req, key, uid);
1058       break;
1059
1060     case GETSTAT:
1061     case SHUTDOWN:
1062     case INVALIDATE:
1063       {
1064         /* Get the callers credentials.  */
1065 #ifdef SO_PEERCRED
1066         struct ucred caller;
1067         socklen_t optlen = sizeof (caller);
1068
1069         if (getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &caller, &optlen) < 0)
1070           {
1071             char buf[256];
1072
1073             dbg_log (_("error getting callers id: %s"),
1074                      strerror_r (errno, buf, sizeof (buf)));
1075             break;
1076           }
1077
1078         uid = caller.uid;
1079 #else
1080         /* Some systems have no SO_PEERCRED implementation.  They don't
1081            care about security so we don't as well.  */
1082         uid = 0;
1083 #endif
1084       }
1085
1086       /* Accept shutdown, getstat and invalidate only from root.  For
1087          the stat call also allow the user specified in the config file.  */
1088       if (req->type == GETSTAT)
1089         {
1090           if (uid == 0 || uid == stat_uid)
1091             send_stats (fd, dbs);
1092         }
1093       else if (uid == 0)
1094         {
1095           if (req->type == INVALIDATE)
1096             invalidate_cache (key);
1097           else
1098             termination_handler (0);
1099         }
1100       break;
1101
1102     case GETFDPW:
1103     case GETFDGR:
1104     case GETFDHST:
1105 #ifdef SCM_RIGHTS
1106       send_ro_fd (serv2db[req->type], key, fd);
1107 #endif
1108       break;
1109
1110     default:
1111       /* Ignore the command, it's nothing we know.  */
1112       break;
1113     }
1114 }
1115
1116
1117 /* Restart the process.  */
1118 static void
1119 restart (void)
1120 {
1121   /* First determine the parameters.  We do not use the parameters
1122      passed to main() since in case nscd is started by running the
1123      dynamic linker this will not work.  Yes, this is not the usual
1124      case but nscd is part of glibc and we occasionally do this.  */
1125   size_t buflen = 1024;
1126   char *buf = alloca (buflen);
1127   size_t readlen = 0;
1128   int fd = open ("/proc/self/cmdline", O_RDONLY);
1129   if (fd == -1)
1130     {
1131       dbg_log (_("\
1132 cannot open /proc/self/cmdline: %s; disabling paranoia mode"),
1133                strerror (errno));
1134
1135       paranoia = 0;
1136       return;
1137     }
1138
1139   while (1)
1140     {
1141       ssize_t n = TEMP_FAILURE_RETRY (read (fd, buf + readlen,
1142                                             buflen - readlen));
1143       if (n == -1)
1144         {
1145           dbg_log (_("\
1146 cannot open /proc/self/cmdline: %s; disabling paranoia mode"),
1147                    strerror (errno));
1148
1149           close (fd);
1150           paranoia = 0;
1151           return;
1152         }
1153
1154       readlen += n;
1155
1156       if (readlen < buflen)
1157         break;
1158
1159       /* We might have to extend the buffer.  */
1160       size_t old_buflen = buflen;
1161       char *newp = extend_alloca (buf, buflen, 2 * buflen);
1162       buf = memmove (newp, buf, old_buflen);
1163     }
1164
1165   close (fd);
1166
1167   /* Parse the command line.  Worst case scenario: every two
1168      characters form one parameter (one character plus NUL).  */
1169   char **argv = alloca ((readlen / 2 + 1) * sizeof (argv[0]));
1170   int argc = 0;
1171
1172   char *cp = buf;
1173   while (cp < buf + readlen)
1174     {
1175       argv[argc++] = cp;
1176       cp = (char *) rawmemchr (cp, '\0') + 1;
1177     }
1178   argv[argc] = NULL;
1179
1180   /* Second, change back to the old user if we changed it.  */
1181   if (server_user != NULL)
1182     {
1183       if (setuid (old_uid) != 0)
1184         {
1185           dbg_log (_("\
1186 cannot change to old UID: %s; disabling paranoia mode"),
1187                    strerror (errno));
1188
1189           paranoia = 0;
1190           return;
1191         }
1192
1193       if (setgid (old_gid) != 0)
1194         {
1195           dbg_log (_("\
1196 cannot change to old GID: %s; disabling paranoia mode"),
1197                    strerror (errno));
1198
1199           setuid (server_uid);
1200           paranoia = 0;
1201           return;
1202         }
1203     }
1204
1205   /* Next change back to the old working directory.  */
1206   if (chdir (oldcwd) == -1)
1207     {
1208       dbg_log (_("\
1209 cannot change to old working directory: %s; disabling paranoia mode"),
1210                strerror (errno));
1211
1212       if (server_user != NULL)
1213         {
1214           setuid (server_uid);
1215           setgid (server_gid);
1216         }
1217       paranoia = 0;
1218       return;
1219     }
1220
1221   /* Synchronize memory.  */
1222   for (int cnt = 0; cnt < lastdb; ++cnt)
1223     {
1224       /* Make sure nobody keeps using the database.  */
1225       dbs[cnt].head->timestamp = 0;
1226
1227       if (dbs[cnt].persistent)
1228         // XXX async OK?
1229         msync (dbs[cnt].head, dbs[cnt].memsize, MS_ASYNC);
1230     }
1231
1232   /* The preparations are done.  */
1233   execv ("/proc/self/exe", argv);
1234
1235   /* If we come here, we will never be able to re-exec.  */
1236   dbg_log (_("re-exec failed: %s; disabling paranoia mode"),
1237            strerror (errno));
1238
1239   if (server_user != NULL)
1240     {
1241       setuid (server_uid);
1242       setgid (server_gid);
1243     }
1244   if (chdir ("/") != 0)
1245     dbg_log (_("cannot change current working directory to \"/\": %s"),
1246              strerror (errno));
1247   paranoia = 0;
1248 }
1249
1250
1251 /* List of file descriptors.  */
1252 struct fdlist
1253 {
1254   int fd;
1255   struct fdlist *next;
1256 };
1257 /* Memory allocated for the list.  */
1258 static struct fdlist *fdlist;
1259 /* List of currently ready-to-read file descriptors.  */
1260 static struct fdlist *readylist;
1261
1262 /* Conditional variable and mutex to signal availability of entries in
1263    READYLIST.  The condvar is initialized dynamically since we might
1264    use a different clock depending on availability.  */
1265 static pthread_cond_t readylist_cond;
1266 static pthread_mutex_t readylist_lock = PTHREAD_MUTEX_INITIALIZER;
1267
1268 /* The clock to use with the condvar.  */
1269 static clockid_t timeout_clock = CLOCK_REALTIME;
1270
1271 /* Number of threads ready to handle the READYLIST.  */
1272 static unsigned long int nready;
1273
1274
1275 /* This is the main loop.  It is replicated in different threads but the
1276    `poll' call makes sure only one thread handles an incoming connection.  */
1277 static void *
1278 __attribute__ ((__noreturn__))
1279 nscd_run (void *p)
1280 {
1281   const long int my_number = (long int) p;
1282   const int run_prune = my_number < lastdb && dbs[my_number].enabled;
1283   struct timespec prune_ts;
1284   int to = 0;
1285   char buf[256];
1286
1287   if (run_prune)
1288     {
1289       setup_thread (&dbs[my_number]);
1290
1291       /* We are running.  */
1292       dbs[my_number].head->timestamp = time (NULL);
1293
1294       if (clock_gettime (timeout_clock, &prune_ts) == -1)
1295         /* Should never happen.  */
1296         abort ();
1297
1298       /* Compute timeout time.  */
1299       prune_ts.tv_sec += CACHE_PRUNE_INTERVAL;
1300     }
1301
1302   /* Initial locking.  */
1303   pthread_mutex_lock (&readylist_lock);
1304
1305   /* One more thread available.  */
1306   ++nready;
1307
1308   while (1)
1309     {
1310       while (readylist == NULL)
1311         {
1312           if (run_prune)
1313             {
1314               /* Wait, but not forever.  */
1315               to = pthread_cond_timedwait (&readylist_cond, &readylist_lock,
1316                                            &prune_ts);
1317
1318               /* If we were woken and there is no work to be done,
1319                  just start pruning.  */
1320               if (readylist == NULL && to == ETIMEDOUT)
1321                 {
1322                   --nready;
1323                   pthread_mutex_unlock (&readylist_lock);
1324                   goto only_prune;
1325                 }
1326             }
1327           else
1328             /* No need to timeout.  */
1329             pthread_cond_wait (&readylist_cond, &readylist_lock);
1330         }
1331
1332       struct fdlist *it = readylist->next;
1333       if (readylist->next == readylist)
1334         /* Just one entry on the list.  */
1335         readylist = NULL;
1336       else
1337         readylist->next = it->next;
1338
1339       /* Extract the information and mark the record ready to be used
1340          again.  */
1341       int fd = it->fd;
1342       it->next = NULL;
1343
1344       /* One more thread available.  */
1345       --nready;
1346
1347       /* We are done with the list.  */
1348       pthread_mutex_unlock (&readylist_lock);
1349
1350       /* We do not want to block on a short read or so.  */
1351       int fl = fcntl (fd, F_GETFL);
1352       if (fl == -1 || fcntl (fd, F_SETFL, fl | O_NONBLOCK) == -1)
1353         goto close_and_out;
1354
1355       /* Now read the request.  */
1356       request_header req;
1357       if (__builtin_expect (TEMP_FAILURE_RETRY (read (fd, &req, sizeof (req)))
1358                             != sizeof (req), 0))
1359         {
1360           /* We failed to read data.  Note that this also might mean we
1361              failed because we would have blocked.  */
1362           if (debug_level > 0)
1363             dbg_log (_("short read while reading request: %s"),
1364                      strerror_r (errno, buf, sizeof (buf)));
1365           goto close_and_out;
1366         }
1367
1368       /* Check whether this is a valid request type.  */
1369       if (req.type < GETPWBYNAME || req.type >= LASTREQ)
1370         goto close_and_out;
1371
1372       /* Some systems have no SO_PEERCRED implementation.  They don't
1373          care about security so we don't as well.  */
1374       uid_t uid = -1;
1375 #ifdef SO_PEERCRED
1376       pid_t pid = 0;
1377
1378       if (__builtin_expect (debug_level > 0, 0))
1379         {
1380           struct ucred caller;
1381           socklen_t optlen = sizeof (caller);
1382
1383           if (getsockopt (fd, SOL_SOCKET, SO_PEERCRED, &caller, &optlen) == 0)
1384             pid = caller.pid;
1385         }
1386 #endif
1387
1388       /* It should not be possible to crash the nscd with a silly
1389          request (i.e., a terribly large key).  We limit the size to 1kb.  */
1390 #define MAXKEYLEN 1024
1391       if (__builtin_expect (req.key_len, 1) < 0
1392           || __builtin_expect (req.key_len, 1) > MAXKEYLEN)
1393         {
1394           if (debug_level > 0)
1395             dbg_log (_("key length in request too long: %d"), req.key_len);
1396         }
1397       else
1398         {
1399           /* Get the key.  */
1400           char keybuf[MAXKEYLEN];
1401
1402           if (__builtin_expect (TEMP_FAILURE_RETRY (read (fd, keybuf,
1403                                                           req.key_len))
1404                                 != req.key_len, 0))
1405             {
1406               /* Again, this can also mean we would have blocked.  */
1407               if (debug_level > 0)
1408                 dbg_log (_("short read while reading request key: %s"),
1409                          strerror_r (errno, buf, sizeof (buf)));
1410               goto close_and_out;
1411             }
1412
1413           if (__builtin_expect (debug_level, 0) > 0)
1414             {
1415 #ifdef SO_PEERCRED
1416               if (pid != 0)
1417                 dbg_log (_("\
1418 handle_request: request received (Version = %d) from PID %ld"),
1419                          req.version, (long int) pid);
1420               else
1421 #endif
1422                 dbg_log (_("\
1423 handle_request: request received (Version = %d)"), req.version);
1424             }
1425
1426           /* Phew, we got all the data, now process it.  */
1427           handle_request (fd, &req, keybuf, uid);
1428         }
1429
1430     close_and_out:
1431       /* We are done.  */
1432       close (fd);
1433
1434       /* Check whether we should be pruning the cache. */
1435       assert (run_prune || to == 0);
1436       if (to == ETIMEDOUT)
1437         {
1438         only_prune:
1439           /* The pthread_cond_timedwait() call timed out.  It is time
1440                  to clean up the cache.  */
1441           assert (my_number < lastdb);
1442           prune_cache (&dbs[my_number], time (NULL));
1443
1444           if (clock_gettime (timeout_clock, &prune_ts) == -1)
1445             /* Should never happen.  */
1446             abort ();
1447
1448           /* Compute next timeout time.  */
1449           prune_ts.tv_sec += CACHE_PRUNE_INTERVAL;
1450
1451           /* In case the list is emtpy we do not want to run the prune
1452              code right away again.  */
1453           to = 0;
1454         }
1455
1456       /* Re-locking.  */
1457       pthread_mutex_lock (&readylist_lock);
1458
1459       /* One more thread available.  */
1460       ++nready;
1461     }
1462 }
1463
1464
1465 static unsigned int nconns;
1466
1467 static void
1468 fd_ready (int fd)
1469 {
1470   pthread_mutex_lock (&readylist_lock);
1471
1472   /* Find an empty entry in FDLIST.  */
1473   size_t inner;
1474   for (inner = 0; inner < nconns; ++inner)
1475     if (fdlist[inner].next == NULL)
1476       break;
1477   assert (inner < nconns);
1478
1479   fdlist[inner].fd = fd;
1480
1481   if (readylist == NULL)
1482     readylist = fdlist[inner].next = &fdlist[inner];
1483   else
1484     {
1485       fdlist[inner].next = readylist->next;
1486       readylist = readylist->next = &fdlist[inner];
1487     }
1488
1489   bool do_signal = true;
1490   if (__builtin_expect (nready == 0, 0))
1491     {
1492       ++client_queued;
1493       do_signal = false;
1494
1495       /* Try to start another thread to help out.  */
1496       pthread_t th;
1497       if (nthreads < max_nthreads
1498           && pthread_create (&th, &attr, nscd_run,
1499                              (void *) (long int) nthreads) == 0)
1500         {
1501           /* We got another thread.  */
1502           ++nthreads;
1503           /* The new thread might need a kick.  */
1504           do_signal = true;
1505         }
1506
1507     }
1508
1509   pthread_mutex_unlock (&readylist_lock);
1510
1511   /* Tell one of the worker threads there is work to do.  */
1512   if (do_signal)
1513     pthread_cond_signal (&readylist_cond);
1514 }
1515
1516
1517 /* Check whether restarting should happen.  */
1518 static inline int
1519 restart_p (time_t now)
1520 {
1521   return (paranoia && readylist == NULL && nready == nthreads
1522           && now >= restart_time);
1523 }
1524
1525
1526 /* Array for times a connection was accepted.  */
1527 static time_t *starttime;
1528
1529
1530 static void
1531 __attribute__ ((__noreturn__))
1532 main_loop_poll (void)
1533 {
1534   struct pollfd *conns = (struct pollfd *) xmalloc (nconns
1535                                                     * sizeof (conns[0]));
1536
1537   conns[0].fd = sock;
1538   conns[0].events = POLLRDNORM;
1539   size_t nused = 1;
1540   size_t firstfree = 1;
1541
1542   while (1)
1543     {
1544       /* Wait for any event.  We wait at most a couple of seconds so
1545          that we can check whether we should close any of the accepted
1546          connections since we have not received a request.  */
1547 #define MAX_ACCEPT_TIMEOUT 30
1548 #define MIN_ACCEPT_TIMEOUT 5
1549 #define MAIN_THREAD_TIMEOUT \
1550   (MAX_ACCEPT_TIMEOUT * 1000                                                  \
1551    - ((MAX_ACCEPT_TIMEOUT - MIN_ACCEPT_TIMEOUT) * 1000 * nused) / (2 * nconns))
1552
1553       int n = poll (conns, nused, MAIN_THREAD_TIMEOUT);
1554
1555       time_t now = time (NULL);
1556
1557       /* If there is a descriptor ready for reading or there is a new
1558          connection, process this now.  */
1559       if (n > 0)
1560         {
1561           if (conns[0].revents != 0)
1562             {
1563               /* We have a new incoming connection.  Accept the connection.  */
1564               int fd = TEMP_FAILURE_RETRY (accept (sock, NULL, NULL));
1565
1566               /* use the descriptor if we have not reached the limit.  */
1567               if (fd >= 0 && firstfree < nconns)
1568                 {
1569                   conns[firstfree].fd = fd;
1570                   conns[firstfree].events = POLLRDNORM;
1571                   starttime[firstfree] = now;
1572                   if (firstfree >= nused)
1573                     nused = firstfree + 1;
1574
1575                   do
1576                     ++firstfree;
1577                   while (firstfree < nused && conns[firstfree].fd != -1);
1578                 }
1579
1580               --n;
1581             }
1582
1583           for (size_t cnt = 1; cnt < nused && n > 0; ++cnt)
1584             if (conns[cnt].revents != 0)
1585               {
1586                 fd_ready (conns[cnt].fd);
1587
1588                 /* Clean up the CONNS array.  */
1589                 conns[cnt].fd = -1;
1590                 if (cnt < firstfree)
1591                   firstfree = cnt;
1592                 if (cnt == nused - 1)
1593                   do
1594                     --nused;
1595                   while (conns[nused - 1].fd == -1);
1596
1597                 --n;
1598               }
1599         }
1600
1601       /* Now find entries which have timed out.  */
1602       assert (nused > 0);
1603
1604       /* We make the timeout length depend on the number of file
1605          descriptors currently used.  */
1606 #define ACCEPT_TIMEOUT \
1607   (MAX_ACCEPT_TIMEOUT                                                         \
1608    - ((MAX_ACCEPT_TIMEOUT - MIN_ACCEPT_TIMEOUT) * nused) / nconns)
1609       time_t laststart = now - ACCEPT_TIMEOUT;
1610
1611       for (size_t cnt = nused - 1; cnt > 0; --cnt)
1612         {
1613           if (conns[cnt].fd != -1 && starttime[cnt] < laststart)
1614             {
1615               /* Remove the entry, it timed out.  */
1616               (void) close (conns[cnt].fd);
1617               conns[cnt].fd = -1;
1618
1619               if (cnt < firstfree)
1620                 firstfree = cnt;
1621               if (cnt == nused - 1)
1622                 do
1623                   --nused;
1624                 while (conns[nused - 1].fd == -1);
1625             }
1626         }
1627
1628       if (restart_p (now))
1629         restart ();
1630     }
1631 }
1632
1633
1634 #ifdef HAVE_EPOLL
1635 static void
1636 main_loop_epoll (int efd)
1637 {
1638   struct epoll_event ev = { 0, };
1639   int nused = 1;
1640   size_t highest = 0;
1641
1642   /* Add the socket.  */
1643   ev.events = EPOLLRDNORM;
1644   ev.data.fd = sock;
1645   if (epoll_ctl (efd, EPOLL_CTL_ADD, sock, &ev) == -1)
1646     /* We cannot use epoll.  */
1647     return;
1648
1649   while (1)
1650     {
1651       struct epoll_event revs[100];
1652 # define nrevs (sizeof (revs) / sizeof (revs[0]))
1653
1654       int n = epoll_wait (efd, revs, nrevs, MAIN_THREAD_TIMEOUT);
1655
1656       time_t now = time (NULL);
1657
1658       for (int cnt = 0; cnt < n; ++cnt)
1659         if (revs[cnt].data.fd == sock)
1660           {
1661             /* A new connection.  */
1662             int fd = TEMP_FAILURE_RETRY (accept (sock, NULL, NULL));
1663
1664             if (fd >= 0)
1665               {
1666                 /* Try to add the  new descriptor.  */
1667                 ev.data.fd = fd;
1668                 if (fd >= nconns
1669                     || epoll_ctl (efd, EPOLL_CTL_ADD, fd, &ev) == -1)
1670                   /* The descriptor is too large or something went
1671                      wrong.  Close the descriptor.  */
1672                   close (fd);
1673                 else
1674                   {
1675                     /* Remember when we accepted the connection.  */
1676                     starttime[fd] = now;
1677
1678                     if (fd > highest)
1679                       highest = fd;
1680
1681                     ++nused;
1682                   }
1683               }
1684           }
1685         else
1686           {
1687             /* Remove the descriptor from the epoll descriptor.  */
1688             (void) epoll_ctl (efd, EPOLL_CTL_DEL, revs[cnt].data.fd, NULL);
1689
1690             /* Get a worker to handle the request.  */
1691             fd_ready (revs[cnt].data.fd);
1692
1693             /* Reset the time.  */
1694             starttime[revs[cnt].data.fd] = 0;
1695             if (revs[cnt].data.fd == highest)
1696               do
1697                 --highest;
1698               while (highest > 0 && starttime[highest] == 0);
1699
1700             --nused;
1701           }
1702
1703       /*  Now look for descriptors for accepted connections which have
1704           no reply in too long of a time.  */
1705       time_t laststart = now - ACCEPT_TIMEOUT;
1706       for (int cnt = highest; cnt > STDERR_FILENO; --cnt)
1707         if (cnt != sock && starttime[cnt] != 0 && starttime[cnt] < laststart)
1708           {
1709             /* We are waiting for this one for too long.  Close it.  */
1710             (void) epoll_ctl (efd, EPOLL_CTL_DEL, cnt, NULL);
1711
1712             (void) close (cnt);
1713
1714             starttime[cnt] = 0;
1715             if (cnt == highest)
1716               --highest;
1717           }
1718         else if (cnt != sock && starttime[cnt] == 0 && cnt == highest)
1719           --highest;
1720
1721       if (restart_p (now))
1722         restart ();
1723     }
1724 }
1725 #endif
1726
1727
1728 /* Start all the threads we want.  The initial process is thread no. 1.  */
1729 void
1730 start_threads (void)
1731 {
1732   /* Initialize the conditional variable we will use.  The only
1733      non-standard attribute we might use is the clock selection.  */
1734   pthread_condattr_t condattr;
1735   pthread_condattr_init (&condattr);
1736
1737 #if defined _POSIX_CLOCK_SELECTION && _POSIX_CLOCK_SELECTION >= 0 \
1738     && defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
1739   /* Determine whether the monotonous clock is available.  */
1740   struct timespec dummy;
1741 # if _POSIX_MONOTONIC_CLOCK == 0
1742   if (sysconf (_SC_MONOTONIC_CLOCK) > 0)
1743 # endif
1744 # if _POSIX_CLOCK_SELECTION == 0
1745     if (sysconf (_SC_CLOCK_SELECTION) > 0)
1746 # endif
1747       if (clock_getres (CLOCK_MONOTONIC, &dummy) == 0
1748           && pthread_condattr_setclock (&condattr, CLOCK_MONOTONIC) == 0)
1749         timeout_clock = CLOCK_MONOTONIC;
1750 #endif
1751
1752   pthread_cond_init (&readylist_cond, &condattr);
1753   pthread_condattr_destroy (&condattr);
1754
1755
1756   /* Create the attribute for the threads.  They are all created
1757      detached.  */
1758   pthread_attr_init (&attr);
1759   pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
1760   /* Use 1MB stacks, twice as much for 64-bit architectures.  */
1761   pthread_attr_setstacksize (&attr, 1024 * 1024 * (sizeof (void *) / 4));
1762
1763   /* We allow less than LASTDB threads only for debugging.  */
1764   if (debug_level == 0)
1765     nthreads = MAX (nthreads, lastdb);
1766
1767   int nfailed = 0;
1768   for (long int i = 0; i < nthreads; ++i)
1769     {
1770       pthread_t th;
1771       if (pthread_create (&th, &attr, nscd_run, (void *) (i - nfailed)) != 0)
1772         ++nfailed;
1773     }
1774   if (nthreads - nfailed < lastdb)
1775     {
1776       /* We could not start enough threads.  */
1777       dbg_log (_("could only start %d threads; terminating"),
1778                nthreads - nfailed);
1779       exit (1);
1780     }
1781
1782   /* Determine how much room for descriptors we should initially
1783      allocate.  This might need to change later if we cap the number
1784      with MAXCONN.  */
1785   const long int nfds = sysconf (_SC_OPEN_MAX);
1786 #define MINCONN 32
1787 #define MAXCONN 16384
1788   if (nfds == -1 || nfds > MAXCONN)
1789     nconns = MAXCONN;
1790   else if (nfds < MINCONN)
1791     nconns = MINCONN;
1792   else
1793     nconns = nfds;
1794
1795   /* We need memory to pass descriptors on to the worker threads.  */
1796   fdlist = (struct fdlist *) xcalloc (nconns, sizeof (fdlist[0]));
1797   /* Array to keep track when connection was accepted.  */
1798   starttime = (time_t *) xcalloc (nconns, sizeof (starttime[0]));
1799
1800   /* In the main thread we execute the loop which handles incoming
1801      connections.  */
1802 #ifdef HAVE_EPOLL
1803   int efd = epoll_create (100);
1804   if (efd != -1)
1805     {
1806       main_loop_epoll (efd);
1807       close (efd);
1808     }
1809 #endif
1810
1811   main_loop_poll ();
1812 }
1813
1814
1815 /* Look up the uid, gid, and supplementary groups to run nscd as. When
1816    this function is called, we are not listening on the nscd socket yet so
1817    we can just use the ordinary lookup functions without causing a lockup  */
1818 static void
1819 begin_drop_privileges (void)
1820 {
1821   struct passwd *pwd = getpwnam (server_user);
1822
1823   if (pwd == NULL)
1824     {
1825       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1826       error (EXIT_FAILURE, 0, _("Failed to run nscd as user '%s'"),
1827              server_user);
1828     }
1829
1830   server_uid = pwd->pw_uid;
1831   server_gid = pwd->pw_gid;
1832
1833   /* Save the old UID/GID if we have to change back.  */
1834   if (paranoia)
1835     {
1836       old_uid = getuid ();
1837       old_gid = getgid ();
1838     }
1839
1840   if (getgrouplist (server_user, server_gid, NULL, &server_ngroups) == 0)
1841     {
1842       /* This really must never happen.  */
1843       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1844       error (EXIT_FAILURE, errno, _("initial getgrouplist failed"));
1845     }
1846
1847   server_groups = (gid_t *) xmalloc (server_ngroups * sizeof (gid_t));
1848
1849   if (getgrouplist (server_user, server_gid, server_groups, &server_ngroups)
1850       == -1)
1851     {
1852       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1853       error (EXIT_FAILURE, errno, _("getgrouplist failed"));
1854     }
1855 }
1856
1857
1858 /* Call setgroups(), setgid(), and setuid() to drop root privileges and
1859    run nscd as the user specified in the configuration file.  */
1860 static void
1861 finish_drop_privileges (void)
1862 {
1863   if (setgroups (server_ngroups, server_groups) == -1)
1864     {
1865       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1866       error (EXIT_FAILURE, errno, _("setgroups failed"));
1867     }
1868
1869   if (setgid (server_gid) == -1)
1870     {
1871       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1872       perror ("setgid");
1873       exit (4);
1874     }
1875
1876   if (setuid (server_uid) == -1)
1877     {
1878       dbg_log (_("Failed to run nscd as user '%s'"), server_user);
1879       perror ("setuid");
1880       exit (4);
1881     }
1882 }