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