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