1 /* Copyright (c) 1998-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published
6 by the Free Software Foundation; version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, see <https://www.gnu.org/licenses/>. */
16
17 /* nscd - Name Service Cache Daemon. Caches passwd, group, and hosts. */
18
19 #include <argp.h>
20 #include <assert.h>
21 #include <dirent.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <fcntl.h>
25 #include <libintl.h>
26 #include <locale.h>
27 #include <paths.h>
28 #include <pthread.h>
29 #include <signal.h>
30 #include <stdbool.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <syslog.h>
35 #include <unistd.h>
36 #include <sys/mman.h>
37 #include <sys/socket.h>
38 #include <sys/stat.h>
39 #include <sys/uio.h>
40 #include <sys/un.h>
41 #include <sys/wait.h>
42 #include <stdarg.h>
43
44 #include "dbg_log.h"
45 #include "nscd.h"
46 #include "selinux.h"
47 #include "../nss/nsswitch.h"
48 #include <device-nrs.h>
49 #ifdef HAVE_INOTIFY
50 # include <sys/inotify.h>
51 #endif
52 #include <kernel-features.h>
53
54 /* Get libc version number. */
55 #include <version.h>
56
57 #define PACKAGE _libc_intl_domainname
58
59 int do_shutdown;
60 int disabled_passwd;
61 int disabled_group;
62
63 typedef enum
64 {
65 /* Running in background as daemon. */
66 RUN_DAEMONIZE,
67 /* Running in foreground but otherwise behave like a daemon,
68 i.e., detach from terminal and use syslog. This allows
69 better integration with services like systemd. */
70 RUN_FOREGROUND,
71 /* Run in foreground in debug mode. */
72 RUN_DEBUG
73 } run_modes;
74
75 static run_modes run_mode = RUN_DAEMONIZE;
76
77 static const char *conffile = _PATH_NSCDCONF;
78
79 static const char *print_cache = NULL;
80
81 time_t start_time;
82
83 uintptr_t pagesize_m1;
84
85 int paranoia;
86 time_t restart_time;
87 time_t restart_interval = RESTART_INTERVAL;
88 const char *oldcwd;
89 uid_t old_uid;
90 gid_t old_gid;
91
92 static int check_pid (const char *file);
93 static int write_pid (const char *file);
94 static int monitor_child (int fd);
95
96 /* Name and version of program. */
97 static void print_version (FILE *stream, struct argp_state *state);
98 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
99
100 /* Function to print some extra text in the help message. */
101 static char *more_help (int key, const char *text, void *input);
102
103 /* Definitions of arguments for argp functions. */
104 static const struct argp_option options[] =
105 {
106 { "config-file", 'f', N_("NAME"), 0,
107 N_("Read configuration data from NAME") },
108 { "debug", 'd', NULL, 0,
109 N_("Do not fork and display messages on the current tty") },
110 { "print", 'p', N_("NAME"), 0,
111 N_("Print contents of the offline cache file NAME") },
112 { "foreground", 'F', NULL, 0,
113 N_("Do not fork, but otherwise behave like a daemon") },
114 { "nthreads", 't', N_("NUMBER"), 0, N_("Start NUMBER threads") },
115 { "shutdown", 'K', NULL, 0, N_("Shut the server down") },
116 { "statistics", 'g', NULL, 0, N_("Print current configuration statistics") },
117 { "invalidate", 'i', N_("TABLE"), 0,
118 N_("Invalidate the specified cache") },
119 { "secure", 'S', N_("TABLE,yes"), OPTION_HIDDEN,
120 N_("Use separate cache for each user")},
121 { NULL, 0, NULL, 0, NULL }
122 };
123
124 /* Short description of program. */
125 static const char doc[] = N_("Name Service Cache Daemon.");
126
127 /* Prototype for option handler. */
128 static error_t parse_opt (int key, char *arg, struct argp_state *state);
129
130 /* Data structure to communicate with argp functions. */
131 static struct argp argp =
132 {
133 options, parse_opt, NULL, doc, NULL, more_help
134 };
135
136 /* True if only statistics are requested. */
137 static bool get_stats;
138 static int parent_fd = -1;
139
140 int
141 main (int argc, char **argv)
142 {
143 int remaining;
144
145 /* Set locale via LC_ALL. */
146 setlocale (LC_ALL, "");
147 /* Set the text message domain. */
148 textdomain (PACKAGE);
149
150 /* Determine if the kernel has SELinux support. */
151 nscd_selinux_enabled (&selinux_enabled);
152
153 /* Parse and process arguments. */
154 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
155
156 if (remaining != argc)
157 {
158 error (0, 0, gettext ("wrong number of arguments"));
159 argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
160 exit (1);
161 }
162
163 /* Print the contents of the indicated cache file. */
164 if (print_cache != NULL)
165 /* Does not return. */
166 nscd_print_cache (print_cache);
167
168 /* Read the configuration file. */
169 if (nscd_parse_file (conffile, dbs) != 0)
170 /* We couldn't read the configuration file. We don't start the
171 server. */
172 error (EXIT_FAILURE, 0,
173 _("failure while reading configuration file; this is fatal"));
174
175 /* Do we only get statistics? */
176 if (get_stats)
177 /* Does not return. */
178 receive_print_stats ();
179
180 /* Check if we are already running. */
181 if (check_pid (_PATH_NSCDPID))
182 error (EXIT_FAILURE, 0, _("already running"));
183
184 /* Remember when we started. */
185 start_time = time (NULL);
186
187 /* Determine page size. */
188 pagesize_m1 = getpagesize () - 1;
189
190 if (run_mode == RUN_DAEMONIZE || run_mode == RUN_FOREGROUND)
191 {
192 int i;
193 pid_t pid;
194
195 /* Behave like a daemon. */
196 if (run_mode == RUN_DAEMONIZE)
197 {
198 int fd[2];
199
200 if (pipe (fd) != 0)
201 error (EXIT_FAILURE, errno,
202 _("cannot create a pipe to talk to the child"));
203
204 pid = fork ();
205 if (pid == -1)
206 error (EXIT_FAILURE, errno, _("cannot fork"));
207 if (pid != 0)
208 {
209 /* The parent only reads from the child. */
210 close (fd[1]);
211 exit (monitor_child (fd[0]));
212 }
213 else
214 {
215 /* The child only writes to the parent. */
216 close (fd[0]);
217 parent_fd = fd[1];
218 }
219 }
220
221 int nullfd = open (_PATH_DEVNULL, O_RDWR);
222 if (nullfd != -1)
223 {
224 struct stat64 st;
225
226 if (fstat64 (nullfd, &st) == 0 && S_ISCHR (st.st_mode) != 0
227 #if defined DEV_NULL_MAJOR && defined DEV_NULL_MINOR
228 && st.st_rdev == makedev (DEV_NULL_MAJOR, DEV_NULL_MINOR)
229 #endif
230 )
231 {
232 /* It is the /dev/null special device alright. */
233 (void) dup2 (nullfd, STDIN_FILENO);
234 (void) dup2 (nullfd, STDOUT_FILENO);
235 (void) dup2 (nullfd, STDERR_FILENO);
236
237 if (nullfd > 2)
238 close (nullfd);
239 }
240 else
241 {
242 /* Ugh, somebody is trying to play a trick on us. */
243 close (nullfd);
244 nullfd = -1;
245 }
246 }
247 int min_close_fd = nullfd == -1 ? 0 : STDERR_FILENO + 1;
248
249 DIR *d = opendir ("/proc/self/fd");
250 if (d != NULL)
251 {
252 struct dirent64 *dirent;
253 int dfdn = dirfd (d);
254
255 while ((dirent = readdir64 (d)) != NULL)
256 {
257 char *endp;
258 long int fdn = strtol (dirent->d_name, &endp, 10);
259
260 if (*endp == '\0' && fdn != dfdn && fdn >= min_close_fd
261 && fdn != parent_fd)
262 close ((int) fdn);
263 }
264
265 closedir (d);
266 }
267 else
268 for (i = min_close_fd; i < getdtablesize (); i++)
269 if (i != parent_fd)
270 close (i);
271
272 setsid ();
273
274 if (chdir ("/") != 0)
275 do_exit (EXIT_FAILURE, errno,
276 _("cannot change current working directory to \"/\""));
277
278 openlog ("nscd", LOG_CONS | LOG_ODELAY, LOG_DAEMON);
279
280 if (write_pid (_PATH_NSCDPID) < 0)
281 dbg_log ("%s: %s", _PATH_NSCDPID, strerror (errno));
282
283 if (!init_logfile ())
284 dbg_log (_("Could not create log file"));
285
286 /* Ignore job control signals. */
287 signal (SIGTTOU, SIG_IGN);
288 signal (SIGTTIN, SIG_IGN);
289 signal (SIGTSTP, SIG_IGN);
290 }
291 else
292 /* In debug mode we are not paranoid. */
293 paranoia = 0;
294
295 signal (SIGINT, termination_handler);
296 signal (SIGQUIT, termination_handler);
297 signal (SIGTERM, termination_handler);
298 signal (SIGPIPE, SIG_IGN);
299
300 /* Cleanup files created by a previous 'bind'. */
301 unlink (_PATH_NSCDSOCKET);
302
303 #ifdef HAVE_INOTIFY
304 /* Use inotify to recognize changed files. */
305 inotify_fd = inotify_init1 (IN_NONBLOCK);
306 # ifndef __ASSUME_IN_NONBLOCK
307 if (inotify_fd == -1 && errno == ENOSYS)
308 {
309 inotify_fd = inotify_init ();
310 if (inotify_fd != -1)
311 fcntl (inotify_fd, F_SETFL, O_RDONLY | O_NONBLOCK);
312 }
313 # endif
314 #endif
315
316 #ifdef USE_NSCD
317 /* Make sure we do not get recursive calls. */
318 __nss_disable_nscd (register_traced_file);
319 #endif
320
321 /* Init databases. */
322 nscd_init ();
323
324 /* Start the SELinux AVC. */
325 if (selinux_enabled)
326 nscd_avc_init ();
327
328 /* Handle incoming requests */
329 start_threads ();
330
331 return 0;
332 }
333
334
335 static void __attribute__ ((noreturn))
336 invalidate_db (const char *dbname)
337 {
338 int sock = nscd_open_socket ();
339
340 if (sock == -1)
341 exit (EXIT_FAILURE);
342
343 size_t dbname_len = strlen (dbname) + 1;
344 size_t reqlen = sizeof (request_header) + dbname_len;
345 struct
346 {
347 request_header req;
348 char dbname[];
349 } *reqdata = alloca (reqlen);
350
351 reqdata->req.key_len = dbname_len;
352 reqdata->req.version = NSCD_VERSION;
353 reqdata->req.type = INVALIDATE;
354 memcpy (reqdata->dbname, dbname, dbname_len);
355
356 ssize_t nbytes = TEMP_FAILURE_RETRY (send (sock, reqdata, reqlen,
357 MSG_NOSIGNAL));
358
359 if (nbytes != reqlen)
360 {
361 int err = errno;
362 close (sock);
363 error (EXIT_FAILURE, err, _("write incomplete"));
364 }
365
366 /* Wait for ack. Older nscd just closed the socket when
367 prune_cache finished, silently ignore that. */
368 int32_t resp = 0;
369 nbytes = TEMP_FAILURE_RETRY (read (sock, &resp, sizeof (resp)));
370 if (nbytes != 0 && nbytes != sizeof (resp))
371 {
372 int err = errno;
373 close (sock);
374 error (EXIT_FAILURE, err, _("cannot read invalidate ACK"));
375 }
376
377 close (sock);
378
379 if (resp != 0)
380 error (EXIT_FAILURE, resp, _("invalidation failed"));
381
382 exit (0);
383 }
384
385 static void __attribute__ ((noreturn))
386 send_shutdown (void)
387 {
388 int sock = nscd_open_socket ();
389
390 if (sock == -1)
391 exit (EXIT_FAILURE);
392
393 request_header req;
394 req.version = NSCD_VERSION;
395 req.type = SHUTDOWN;
396 req.key_len = 0;
397
398 ssize_t nbytes = TEMP_FAILURE_RETRY (send (sock, &req, sizeof req,
399 MSG_NOSIGNAL));
400 close (sock);
401 exit (nbytes != sizeof (request_header) ? EXIT_FAILURE : EXIT_SUCCESS);
402 }
403
404 /* Handle program arguments. */
405 static error_t
406 parse_opt (int key, char *arg, struct argp_state *state)
407 {
408 switch (key)
409 {
410 case 'd':
411 ++debug_level;
412 run_mode = RUN_DEBUG;
413 break;
414
415 case 'p':
416 print_cache = arg;
417 break;
418
419 case 'F':
420 run_mode = RUN_FOREGROUND;
421 break;
422
423 case 'f':
424 conffile = arg;
425 break;
426
427 case 'K':
428 if (getuid () != 0)
429 error (4, 0, _("Only root is allowed to use this option!"));
430 else
431 send_shutdown ();
432 break;
433
434 case 'g':
435 get_stats = true;
436 break;
437
438 case 'i':
439 {
440 /* Validate the database name. */
441
442 dbtype cnt;
443 for (cnt = pwddb; cnt < lastdb; ++cnt)
444 if (strcmp (arg, dbnames[cnt]) == 0)
445 break;
446
447 if (cnt == lastdb)
448 {
449 argp_error (state, _("'%s' is not a known database"), arg);
450 return EINVAL;
451 }
452 }
453 if (getuid () != 0)
454 error (4, 0, _("Only root is allowed to use this option!"));
455 else
456 invalidate_db (arg);
457 break;
458
459 case 't':
460 nthreads = atol (arg);
461 break;
462
463 case 'S':
464 error (0, 0, _("secure services not implemented anymore"));
465 break;
466
467 default:
468 return ARGP_ERR_UNKNOWN;
469 }
470
471 return 0;
472 }
473
474 /* Print bug-reporting information in the help message. */
475 static char *
476 more_help (int key, const char *text, void *input)
477 {
478 switch (key)
479 {
480 case ARGP_KEY_HELP_EXTRA:
481 {
482 /* We print some extra information. */
483
484 char *tables = xstrdup (dbnames[0]);
485 for (dbtype i = 1; i < lastdb; ++i)
486 {
487 char *more_tables;
488 if (asprintf (&more_tables, "%s %s", tables, dbnames[i]) < 0)
489 more_tables = NULL;
490 free (tables);
491 if (more_tables == NULL)
492 return NULL;
493 tables = more_tables;
494 }
495
496 char *tp;
497 if (asprintf (&tp, gettext ("\
498 Supported tables:\n\
499 %s\n\
500 \n\
501 For bug reporting instructions, please see:\n\
502 %s.\n\
503 "), tables, REPORT_BUGS_TO) < 0)
504 tp = NULL;
505 free (tables);
506 return tp;
507 }
508
509 default:
510 break;
511 }
512
513 return (char *) text;
514 }
515
516 /* Print the version information. */
517 static void
518 print_version (FILE *stream, struct argp_state *state)
519 {
520 fprintf (stream, "nscd %s%s\n", PKGVERSION, VERSION);
521 fprintf (stream, gettext ("\
522 Copyright (C) %s Free Software Foundation, Inc.\n\
523 This is free software; see the source for copying conditions. There is NO\n\
524 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
525 "), "2023");
526 fprintf (stream, gettext ("Written by %s.\n"),
527 "Thorsten Kukuk and Ulrich Drepper");
528 }
529
530
531 /* Create a socket connected to a name. */
532 int
533 nscd_open_socket (void)
534 {
535 struct sockaddr_un addr;
536 int sock;
537
538 sock = socket (PF_UNIX, SOCK_STREAM, 0);
539 if (sock < 0)
540 return -1;
541
542 addr.sun_family = AF_UNIX;
543 assert (sizeof (addr.sun_path) >= sizeof (_PATH_NSCDSOCKET));
544 strcpy (addr.sun_path, _PATH_NSCDSOCKET);
545 if (connect (sock, (struct sockaddr *) &addr, sizeof (addr)) < 0)
546 {
547 close (sock);
548 return -1;
549 }
550
551 return sock;
552 }
553
554
555 /* Cleanup. */
556 void
557 termination_handler (int signum)
558 {
559 close_sockets ();
560
561 /* Clean up the file created by 'bind'. */
562 unlink (_PATH_NSCDSOCKET);
563
564 /* Clean up pid file. */
565 unlink (_PATH_NSCDPID);
566
567 // XXX Terminate threads.
568
569 /* Synchronize memory. */
570 for (int cnt = 0; cnt < lastdb; ++cnt)
571 {
572 if (!dbs[cnt].enabled || dbs[cnt].head == NULL)
573 continue;
574
575 /* Make sure nobody keeps using the database. */
576 dbs[cnt].head->timestamp = 0;
577
578 if (dbs[cnt].persistent)
579 // XXX async OK?
580 msync (dbs[cnt].head, dbs[cnt].memsize, MS_ASYNC);
581 }
582
583 _exit (EXIT_SUCCESS);
584 }
585
586 /* Returns 1 if the process in pid file FILE is running, 0 if not. */
587 static int
588 check_pid (const char *file)
589 {
590 FILE *fp;
591
592 fp = fopen (file, "r");
593 if (fp)
594 {
595 pid_t pid;
596 int n;
597
598 n = fscanf (fp, "%d", &pid);
599 fclose (fp);
600
601 /* If we cannot parse the file default to assuming nscd runs.
602 If the PID is alive, assume it is running. That all unless
603 the PID is the same as the current process' since the latter
604 can mean we re-exec. */
605 if ((n != 1 || kill (pid, 0) == 0) && pid != getpid ())
606 return 1;
607 }
608
609 return 0;
610 }
611
612 /* Write the current process id to the file FILE.
613 Returns 0 if successful, -1 if not. */
614 static int
615 write_pid (const char *file)
616 {
617 FILE *fp;
618
619 fp = fopen (file, "w");
620 if (fp == NULL)
621 return -1;
622
623 fprintf (fp, "%d\n", getpid ());
624
625 int result = fflush (fp) || ferror (fp) ? -1 : 0;
626
627 fclose (fp);
628
629 return result;
630 }
631
632 static int
633 monitor_child (int fd)
634 {
635 int child_ret = 0;
636 int ret = read (fd, &child_ret, sizeof (child_ret));
637
638 /* The child terminated with an error, either via exit or some other abnormal
639 method, like a segfault. */
640 if (ret <= 0 || child_ret != 0)
641 {
642 int status;
643 int err = wait (&status);
644
645 if (err < 0)
646 {
647 fprintf (stderr, _("'wait' failed\n"));
648 return 1;
649 }
650
651 if (WIFEXITED (status))
652 {
653 child_ret = WEXITSTATUS (status);
654 fprintf (stderr, _("child exited with status %d\n"), child_ret);
655 }
656 if (WIFSIGNALED (status))
657 {
658 child_ret = WTERMSIG (status);
659 fprintf (stderr, _("child terminated by signal %d\n"), child_ret);
660 }
661 }
662
663 /* We have the child status, so exit with that code. */
664 close (fd);
665
666 return child_ret;
667 }
668
669 void
670 do_exit (int child_ret, int errnum, const char *format, ...)
671 {
672 if (parent_fd != -1)
673 {
674 int ret __attribute__ ((unused));
675 ret = write (parent_fd, &child_ret, sizeof (child_ret));
676 assert (ret == sizeof (child_ret));
677 close (parent_fd);
678 }
679
680 if (format != NULL)
681 {
682 /* Emulate error() since we don't have a va_list variant for it. */
683 va_list argp;
684
685 fflush (stdout);
686
687 fprintf (stderr, "%s: ", program_invocation_name);
688
689 va_start (argp, format);
690 vfprintf (stderr, format, argp);
691 va_end (argp);
692
693 fprintf (stderr, ": %s\n", strerror (errnum));
694 fflush (stderr);
695 }
696
697 /* Finally, exit. */
698 exit (child_ret);
699 }
700
701 void
702 notify_parent (int child_ret)
703 {
704 if (parent_fd == -1)
705 return;
706
707 int ret __attribute__ ((unused));
708 ret = write (parent_fd, &child_ret, sizeof (child_ret));
709 assert (ret == sizeof (child_ret));
710 close (parent_fd);
711 parent_fd = -1;
712 }