xref: /freebsd/usr.sbin/nscd/nscd.c (revision 10b59a9b4add0320d52c15ce057dd697261e7dfc)
1  /*-
2   * Copyright (c) 2005 Michael Bushkov <bushman@rsu.ru>
3   * All rights reserved.
4   *
5   * Redistribution and use in source and binary forms, with or without
6   * modification, are permitted provided that the following conditions
7   * are met:
8   * 1. Redistributions of source code must retain the above copyright
9   *    notice, this list of conditions and the following disclaimer.
10   * 2. Redistributions in binary form must reproduce the above copyright
11   *    notice, this list of conditions and the following disclaimer in thereg
12   *    documentation and/or other materials provided with the distribution.
13   *
14   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17   * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22   * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23   * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24   * SUCH DAMAGE.
25   *
26   */
27  
28  #include <sys/cdefs.h>
29  __FBSDID("$FreeBSD$");
30  
31  #include <sys/param.h>
32  #include <sys/event.h>
33  #include <sys/socket.h>
34  #include <sys/stat.h>
35  #include <sys/time.h>
36  #include <sys/un.h>
37  
38  #include <assert.h>
39  #include <err.h>
40  #include <errno.h>
41  #include <fcntl.h>
42  #include <libutil.h>
43  #include <pthread.h>
44  #include <signal.h>
45  #include <stdio.h>
46  #include <stdlib.h>
47  #include <string.h>
48  #include <unistd.h>
49  
50  #include "agents/passwd.h"
51  #include "agents/group.h"
52  #include "agents/services.h"
53  #include "cachelib.h"
54  #include "config.h"
55  #include "debug.h"
56  #include "log.h"
57  #include "nscdcli.h"
58  #include "parser.h"
59  #include "query.h"
60  #include "singletons.h"
61  
62  #ifndef CONFIG_PATH
63  #define CONFIG_PATH "/etc/nscd.conf"
64  #endif
65  #define DEFAULT_CONFIG_PATH	"nscd.conf"
66  
67  #define MAX_SOCKET_IO_SIZE	4096
68  
69  struct processing_thread_args {
70  	cache	the_cache;
71  	struct configuration	*the_configuration;
72  	struct runtime_env		*the_runtime_env;
73  };
74  
75  static void accept_connection(struct kevent *, struct runtime_env *,
76  	struct configuration *);
77  static void destroy_cache_(cache);
78  static void destroy_runtime_env(struct runtime_env *);
79  static cache init_cache_(struct configuration *);
80  static struct runtime_env *init_runtime_env(struct configuration *);
81  static void processing_loop(cache, struct runtime_env *,
82  	struct configuration *);
83  static void process_socket_event(struct kevent *, struct runtime_env *,
84  	struct configuration *);
85  static void process_timer_event(struct kevent *, struct runtime_env *,
86  	struct configuration *);
87  static void *processing_thread(void *);
88  static void usage(void);
89  
90  void get_time_func(struct timeval *);
91  
92  static void
93  usage(void)
94  {
95  	fprintf(stderr,
96  	    "usage: nscd [-dnst] [-i cachename] [-I cachename]\n");
97  	exit(1);
98  }
99  
100  static cache
101  init_cache_(struct configuration *config)
102  {
103  	struct cache_params params;
104  	cache retval;
105  
106  	struct configuration_entry *config_entry;
107  	size_t	size, i;
108  	int res;
109  
110  	TRACE_IN(init_cache_);
111  
112  	memset(&params, 0, sizeof(struct cache_params));
113  	params.get_time_func = get_time_func;
114  	retval = init_cache(&params);
115  
116  	size = configuration_get_entries_size(config);
117  	for (i = 0; i < size; ++i) {
118  		config_entry = configuration_get_entry(config, i);
119  	    	/*
120  	    	 * We should register common entries now - multipart entries
121  	    	 * would be registered automatically during the queries.
122  	    	 */
123  		res = register_cache_entry(retval, (struct cache_entry_params *)
124  			&config_entry->positive_cache_params);
125  		config_entry->positive_cache_entry = find_cache_entry(retval,
126  			config_entry->positive_cache_params.cep.entry_name);
127  		assert(config_entry->positive_cache_entry !=
128  			INVALID_CACHE_ENTRY);
129  
130  		res = register_cache_entry(retval, (struct cache_entry_params *)
131  			&config_entry->negative_cache_params);
132  		config_entry->negative_cache_entry = find_cache_entry(retval,
133  			config_entry->negative_cache_params.cep.entry_name);
134  		assert(config_entry->negative_cache_entry !=
135  			INVALID_CACHE_ENTRY);
136  	}
137  
138  	LOG_MSG_2("cache", "cache was successfully initialized");
139  	TRACE_OUT(init_cache_);
140  	return (retval);
141  }
142  
143  static void
144  destroy_cache_(cache the_cache)
145  {
146  	TRACE_IN(destroy_cache_);
147  	destroy_cache(the_cache);
148  	TRACE_OUT(destroy_cache_);
149  }
150  
151  /*
152   * Socket and kqueues are prepared here. We have one global queue for both
153   * socket and timers events.
154   */
155  static struct runtime_env *
156  init_runtime_env(struct configuration *config)
157  {
158  	int serv_addr_len;
159  	struct sockaddr_un serv_addr;
160  
161  	struct kevent eventlist;
162  	struct timespec timeout;
163  
164  	struct runtime_env *retval;
165  
166  	TRACE_IN(init_runtime_env);
167  	retval = calloc(1, sizeof(*retval));
168  	assert(retval != NULL);
169  
170  	retval->sockfd = socket(PF_LOCAL, SOCK_STREAM, 0);
171  
172  	if (config->force_unlink == 1)
173  		unlink(config->socket_path);
174  
175  	memset(&serv_addr, 0, sizeof(struct sockaddr_un));
176  	serv_addr.sun_family = PF_LOCAL;
177  	strlcpy(serv_addr.sun_path, config->socket_path,
178  		sizeof(serv_addr.sun_path));
179  	serv_addr_len = sizeof(serv_addr.sun_family) +
180  		strlen(serv_addr.sun_path) + 1;
181  
182  	if (bind(retval->sockfd, (struct sockaddr *)&serv_addr,
183  		serv_addr_len) == -1) {
184  		close(retval->sockfd);
185  		free(retval);
186  
187  		LOG_ERR_2("runtime environment", "can't bind socket to path: "
188  			"%s", config->socket_path);
189  		TRACE_OUT(init_runtime_env);
190  		return (NULL);
191  	}
192  	LOG_MSG_2("runtime environment", "using socket %s",
193  		config->socket_path);
194  
195  	/*
196  	 * Here we're marking socket as non-blocking and setting its backlog
197  	 * to the maximum value
198  	 */
199  	chmod(config->socket_path, config->socket_mode);
200  	listen(retval->sockfd, -1);
201  	fcntl(retval->sockfd, F_SETFL, O_NONBLOCK);
202  
203  	retval->queue = kqueue();
204  	assert(retval->queue != -1);
205  
206  	EV_SET(&eventlist, retval->sockfd, EVFILT_READ, EV_ADD | EV_ONESHOT,
207  		0, 0, 0);
208  	memset(&timeout, 0, sizeof(struct timespec));
209  	kevent(retval->queue, &eventlist, 1, NULL, 0, &timeout);
210  
211  	LOG_MSG_2("runtime environment", "successfully initialized");
212  	TRACE_OUT(init_runtime_env);
213  	return (retval);
214  }
215  
216  static void
217  destroy_runtime_env(struct runtime_env *env)
218  {
219  	TRACE_IN(destroy_runtime_env);
220  	close(env->queue);
221  	close(env->sockfd);
222  	free(env);
223  	TRACE_OUT(destroy_runtime_env);
224  }
225  
226  static void
227  accept_connection(struct kevent *event_data, struct runtime_env *env,
228  	struct configuration *config)
229  {
230  	struct kevent	eventlist[2];
231  	struct timespec	timeout;
232  	struct query_state	*qstate;
233  
234  	int	fd;
235  	int	res;
236  
237  	uid_t	euid;
238  	gid_t	egid;
239  
240  	TRACE_IN(accept_connection);
241  	fd = accept(event_data->ident, NULL, NULL);
242  	if (fd == -1) {
243  		LOG_ERR_2("accept_connection", "error %d during accept()",
244  		    errno);
245  		TRACE_OUT(accept_connection);
246  		return;
247  	}
248  
249  	if (getpeereid(fd, &euid, &egid) != 0) {
250  		LOG_ERR_2("accept_connection", "error %d during getpeereid()",
251  			errno);
252  		TRACE_OUT(accept_connection);
253  		return;
254  	}
255  
256  	qstate = init_query_state(fd, sizeof(int), euid, egid);
257  	if (qstate == NULL) {
258  		LOG_ERR_2("accept_connection", "can't init query_state");
259  		TRACE_OUT(accept_connection);
260  		return;
261  	}
262  
263  	memset(&timeout, 0, sizeof(struct timespec));
264  	EV_SET(&eventlist[0], fd, EVFILT_TIMER, EV_ADD | EV_ONESHOT,
265  		0, qstate->timeout.tv_sec * 1000, qstate);
266  	EV_SET(&eventlist[1], fd, EVFILT_READ, EV_ADD | EV_ONESHOT,
267  		NOTE_LOWAT, qstate->kevent_watermark, qstate);
268  	res = kevent(env->queue, eventlist, 2, NULL, 0, &timeout);
269  	if (res < 0)
270  		LOG_ERR_2("accept_connection", "kevent error");
271  
272  	TRACE_OUT(accept_connection);
273  }
274  
275  static void
276  process_socket_event(struct kevent *event_data, struct runtime_env *env,
277  	struct configuration *config)
278  {
279  	struct kevent	eventlist[2];
280  	struct timeval	query_timeout;
281  	struct timespec	kevent_timeout;
282  	int	nevents;
283  	int	eof_res, res;
284  	ssize_t	io_res;
285  	struct query_state *qstate;
286  
287  	TRACE_IN(process_socket_event);
288  	eof_res = event_data->flags & EV_EOF ? 1 : 0;
289  	res = 0;
290  
291  	memset(&kevent_timeout, 0, sizeof(struct timespec));
292  	EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER, EV_DELETE,
293  		0, 0, NULL);
294  	nevents = kevent(env->queue, eventlist, 1, NULL, 0, &kevent_timeout);
295  	if (nevents == -1) {
296  		if (errno == ENOENT) {
297  			/* the timer is already handling this event */
298  			TRACE_OUT(process_socket_event);
299  			return;
300  		} else {
301  			/* some other error happened */
302  			LOG_ERR_2("process_socket_event", "kevent error, errno"
303  				" is %d", errno);
304  			TRACE_OUT(process_socket_event);
305  			return;
306  		}
307  	}
308  	qstate = (struct query_state *)event_data->udata;
309  
310  	/*
311  	 * If the buffer that is to be send/received is too large,
312  	 * we send it implicitly, by using query_io_buffer_read and
313  	 * query_io_buffer_write functions in the query_state. These functions
314  	 * use the temporary buffer, which is later send/received in parts.
315  	 * The code below implements buffer splitting/mergind for send/receive
316  	 * operations. It also does the actual socket IO operations.
317  	 */
318  	if (((qstate->use_alternate_io == 0) &&
319  		(qstate->kevent_watermark <= (size_t)event_data->data)) ||
320  		((qstate->use_alternate_io != 0) &&
321  		(qstate->io_buffer_watermark <= (size_t)event_data->data))) {
322  		if (qstate->use_alternate_io != 0) {
323  			switch (qstate->io_buffer_filter) {
324  			case EVFILT_READ:
325  				io_res = query_socket_read(qstate,
326  					qstate->io_buffer_p,
327  					qstate->io_buffer_watermark);
328  				if (io_res < 0) {
329  					qstate->use_alternate_io = 0;
330  					qstate->process_func = NULL;
331  				} else {
332  					qstate->io_buffer_p += io_res;
333  					if (qstate->io_buffer_p ==
334  					    	qstate->io_buffer +
335  						qstate->io_buffer_size) {
336  						qstate->io_buffer_p =
337  						    qstate->io_buffer;
338  						qstate->use_alternate_io = 0;
339  					}
340  				}
341  			break;
342  			default:
343  			break;
344  			}
345  		}
346  
347  		if (qstate->use_alternate_io == 0) {
348  			do {
349  				res = qstate->process_func(qstate);
350  			} while ((qstate->kevent_watermark == 0) &&
351  					(qstate->process_func != NULL) &&
352  					(res == 0));
353  
354  			if (res != 0)
355  				qstate->process_func = NULL;
356  		}
357  
358  		if ((qstate->use_alternate_io != 0) &&
359  			(qstate->io_buffer_filter == EVFILT_WRITE)) {
360  			io_res = query_socket_write(qstate, qstate->io_buffer_p,
361  				qstate->io_buffer_watermark);
362  			if (io_res < 0) {
363  				qstate->use_alternate_io = 0;
364  				qstate->process_func = NULL;
365  			} else
366  				qstate->io_buffer_p += io_res;
367  		}
368  	} else {
369  		/* assuming that socket was closed */
370  		qstate->process_func = NULL;
371  		qstate->use_alternate_io = 0;
372  	}
373  
374  	if (((qstate->process_func == NULL) &&
375  	    	(qstate->use_alternate_io == 0)) ||
376  		(eof_res != 0) || (res != 0)) {
377  		destroy_query_state(qstate);
378  		close(event_data->ident);
379  		TRACE_OUT(process_socket_event);
380  		return;
381  	}
382  
383  	/* updating the query_state lifetime variable */
384  	get_time_func(&query_timeout);
385  	query_timeout.tv_usec = 0;
386  	query_timeout.tv_sec -= qstate->creation_time.tv_sec;
387  	if (query_timeout.tv_sec > qstate->timeout.tv_sec)
388  		query_timeout.tv_sec = 0;
389  	else
390  		query_timeout.tv_sec = qstate->timeout.tv_sec -
391  			query_timeout.tv_sec;
392  
393  	if ((qstate->use_alternate_io != 0) && (qstate->io_buffer_p ==
394  		qstate->io_buffer + qstate->io_buffer_size))
395  		qstate->use_alternate_io = 0;
396  
397  	if (qstate->use_alternate_io == 0) {
398  		/*
399  		 * If we must send/receive the large block of data,
400  		 * we should prepare the query_state's io_XXX fields.
401  		 * We should also substitute its write_func and read_func
402  		 * with the query_io_buffer_write and query_io_buffer_read,
403  		 * which will allow us to implicitly send/receive this large
404  		 * buffer later (in the subsequent calls to the
405  		 * process_socket_event).
406  		 */
407  		if (qstate->kevent_watermark > MAX_SOCKET_IO_SIZE) {
408  			if (qstate->io_buffer != NULL)
409  				free(qstate->io_buffer);
410  
411  			qstate->io_buffer = calloc(1,
412  				qstate->kevent_watermark);
413  			assert(qstate->io_buffer != NULL);
414  
415  			qstate->io_buffer_p = qstate->io_buffer;
416  			qstate->io_buffer_size = qstate->kevent_watermark;
417  			qstate->io_buffer_filter = qstate->kevent_filter;
418  
419  			qstate->write_func = query_io_buffer_write;
420  			qstate->read_func = query_io_buffer_read;
421  
422  			if (qstate->kevent_filter == EVFILT_READ)
423  				qstate->use_alternate_io = 1;
424  
425  			qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE;
426  			EV_SET(&eventlist[1], event_data->ident,
427  				qstate->kevent_filter, EV_ADD | EV_ONESHOT,
428  				NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate);
429  		} else {
430  			EV_SET(&eventlist[1], event_data->ident,
431  		    		qstate->kevent_filter, EV_ADD | EV_ONESHOT,
432  		    		NOTE_LOWAT, qstate->kevent_watermark, qstate);
433  		}
434  	} else {
435  		if (qstate->io_buffer + qstate->io_buffer_size -
436  		    	qstate->io_buffer_p <
437  			MAX_SOCKET_IO_SIZE) {
438  			qstate->io_buffer_watermark = qstate->io_buffer +
439  				qstate->io_buffer_size - qstate->io_buffer_p;
440  			EV_SET(&eventlist[1], event_data->ident,
441  			    	qstate->io_buffer_filter,
442  				EV_ADD | EV_ONESHOT, NOTE_LOWAT,
443  				qstate->io_buffer_watermark,
444  				qstate);
445  		} else {
446  			qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE;
447  			EV_SET(&eventlist[1], event_data->ident,
448  		    		qstate->io_buffer_filter, EV_ADD | EV_ONESHOT,
449  		    		NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate);
450  		}
451  	}
452  	EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER,
453  		EV_ADD | EV_ONESHOT, 0, query_timeout.tv_sec * 1000, qstate);
454  	kevent(env->queue, eventlist, 2, NULL, 0, &kevent_timeout);
455  
456  	TRACE_OUT(process_socket_event);
457  }
458  
459  /*
460   * This routine is called if timer event has been signaled in the kqueue. It
461   * just closes the socket and destroys the query_state.
462   */
463  static void
464  process_timer_event(struct kevent *event_data, struct runtime_env *env,
465  	struct configuration *config)
466  {
467  	struct query_state	*qstate;
468  
469  	TRACE_IN(process_timer_event);
470  	qstate = (struct query_state *)event_data->udata;
471  	destroy_query_state(qstate);
472  	close(event_data->ident);
473  	TRACE_OUT(process_timer_event);
474  }
475  
476  /*
477   * Processing loop is the basic processing routine, that forms a body of each
478   * procssing thread
479   */
480  static void
481  processing_loop(cache the_cache, struct runtime_env *env,
482  	struct configuration *config)
483  {
484  	struct timespec timeout;
485  	const int eventlist_size = 1;
486  	struct kevent eventlist[eventlist_size];
487  	int nevents, i;
488  
489  	TRACE_MSG("=> processing_loop");
490  	memset(&timeout, 0, sizeof(struct timespec));
491  	memset(&eventlist, 0, sizeof(struct kevent) * eventlist_size);
492  
493  	for (;;) {
494  		nevents = kevent(env->queue, NULL, 0, eventlist,
495  	    		eventlist_size, NULL);
496  		/*
497  		 * we can only receive 1 event on success
498  		 */
499  		if (nevents == 1) {
500  			struct kevent *event_data;
501  			event_data = &eventlist[0];
502  
503  			if ((int)event_data->ident == env->sockfd) {
504  				for (i = 0; i < event_data->data; ++i)
505  				    accept_connection(event_data, env, config);
506  
507  				EV_SET(eventlist, s_runtime_env->sockfd,
508  				    EVFILT_READ, EV_ADD | EV_ONESHOT,
509  				    0, 0, 0);
510  				memset(&timeout, 0,
511  				    sizeof(struct timespec));
512  				kevent(s_runtime_env->queue, eventlist,
513  				    1, NULL, 0, &timeout);
514  
515  			} else {
516  				switch (event_data->filter) {
517  				case EVFILT_READ:
518  				case EVFILT_WRITE:
519  					process_socket_event(event_data,
520  						env, config);
521  					break;
522  				case EVFILT_TIMER:
523  					process_timer_event(event_data,
524  						env, config);
525  					break;
526  				default:
527  					break;
528  				}
529  			}
530  		} else {
531  			/* this branch shouldn't be currently executed */
532  		}
533  	}
534  
535  	TRACE_MSG("<= processing_loop");
536  }
537  
538  /*
539   * Wrapper above the processing loop function. It sets the thread signal mask
540   * to avoid SIGPIPE signals (which can happen if the client works incorrectly).
541   */
542  static void *
543  processing_thread(void *data)
544  {
545  	struct processing_thread_args	*args;
546  	sigset_t new;
547  
548  	TRACE_MSG("=> processing_thread");
549  	args = (struct processing_thread_args *)data;
550  
551  	sigemptyset(&new);
552  	sigaddset(&new, SIGPIPE);
553  	if (pthread_sigmask(SIG_BLOCK, &new, NULL) != 0)
554  		LOG_ERR_1("processing thread",
555  			"thread can't block the SIGPIPE signal");
556  
557  	processing_loop(args->the_cache, args->the_runtime_env,
558  		args->the_configuration);
559  	free(args);
560  	TRACE_MSG("<= processing_thread");
561  
562  	return (NULL);
563  }
564  
565  void
566  get_time_func(struct timeval *time)
567  {
568  	struct timespec res;
569  	memset(&res, 0, sizeof(struct timespec));
570  	clock_gettime(CLOCK_MONOTONIC, &res);
571  
572  	time->tv_sec = res.tv_sec;
573  	time->tv_usec = 0;
574  }
575  
576  /*
577   * The idea of _nss_cache_cycle_prevention_function is that nsdispatch
578   * will search for this symbol in the executable. This symbol is the
579   * attribute of the caching daemon. So, if it exists, nsdispatch won't try
580   * to connect to the caching daemon and will just ignore the 'cache'
581   * source in the nsswitch.conf. This method helps to avoid cycles and
582   * organize self-performing requests.
583   *
584   * (not actually a function; it used to be, but it doesn't make any
585   * difference, as long as it has external linkage)
586   */
587  void *_nss_cache_cycle_prevention_function;
588  
589  int
590  main(int argc, char *argv[])
591  {
592  	struct processing_thread_args *thread_args;
593  	pthread_t *threads;
594  
595  	struct pidfh *pidfile;
596  	pid_t pid;
597  
598  	char const *config_file;
599  	char const *error_str;
600  	int error_line;
601  	int i, res;
602  
603  	int trace_mode_enabled;
604  	int force_single_threaded;
605  	int do_not_daemonize;
606  	int clear_user_cache_entries, clear_all_cache_entries;
607  	char *user_config_entry_name, *global_config_entry_name;
608  	int show_statistics;
609  	int daemon_mode, interactive_mode;
610  
611  
612  	/* by default all debug messages are omitted */
613  	TRACE_OFF();
614  
615  	/* parsing command line arguments */
616  	trace_mode_enabled = 0;
617  	force_single_threaded = 0;
618  	do_not_daemonize = 0;
619  	clear_user_cache_entries = 0;
620  	clear_all_cache_entries = 0;
621  	show_statistics = 0;
622  	user_config_entry_name = NULL;
623  	global_config_entry_name = NULL;
624  	while ((res = getopt(argc, argv, "nstdi:I:")) != -1) {
625  		switch (res) {
626  		case 'n':
627  			do_not_daemonize = 1;
628  			break;
629  		case 's':
630  			force_single_threaded = 1;
631  			break;
632  		case 't':
633  			trace_mode_enabled = 1;
634  			break;
635  		case 'i':
636  			clear_user_cache_entries = 1;
637  			if (optarg != NULL)
638  				if (strcmp(optarg, "all") != 0)
639  					user_config_entry_name = strdup(optarg);
640  			break;
641  		case 'I':
642  			clear_all_cache_entries = 1;
643  			if (optarg != NULL)
644  				if (strcmp(optarg, "all") != 0)
645  					global_config_entry_name =
646  						strdup(optarg);
647  			break;
648  		case 'd':
649  			show_statistics = 1;
650  			break;
651  		case '?':
652  		default:
653  			usage();
654  			/* NOT REACHED */
655  		}
656  	}
657  
658  	daemon_mode = do_not_daemonize | force_single_threaded |
659  		trace_mode_enabled;
660  	interactive_mode = clear_user_cache_entries | clear_all_cache_entries |
661  		show_statistics;
662  
663  	if ((daemon_mode != 0) && (interactive_mode != 0)) {
664  		LOG_ERR_1("main", "daemon mode and interactive_mode arguments "
665  			"can't be used together");
666  		usage();
667  	}
668  
669  	if (interactive_mode != 0) {
670  		FILE *pidfin = fopen(DEFAULT_PIDFILE_PATH, "r");
671  		char pidbuf[256];
672  
673  		struct nscd_connection_params connection_params;
674  		nscd_connection connection;
675  
676  		int result;
677  
678  		if (pidfin == NULL)
679  			errx(EXIT_FAILURE, "There is no daemon running.");
680  
681  		memset(pidbuf, 0, sizeof(pidbuf));
682  		fread(pidbuf, sizeof(pidbuf) - 1, 1, pidfin);
683  		fclose(pidfin);
684  
685  		if (ferror(pidfin) != 0)
686  			errx(EXIT_FAILURE, "Can't read from pidfile.");
687  
688  		if (sscanf(pidbuf, "%d", &pid) != 1)
689  			errx(EXIT_FAILURE, "Invalid pidfile.");
690  		LOG_MSG_1("main", "daemon PID is %d", pid);
691  
692  
693  		memset(&connection_params, 0,
694  			sizeof(struct nscd_connection_params));
695  		connection_params.socket_path = DEFAULT_SOCKET_PATH;
696  		connection = open_nscd_connection__(&connection_params);
697  		if (connection == INVALID_NSCD_CONNECTION)
698  			errx(EXIT_FAILURE, "Can't connect to the daemon.");
699  
700  		if (clear_user_cache_entries != 0) {
701  			result = nscd_transform__(connection,
702  				user_config_entry_name, TT_USER);
703  			if (result != 0)
704  				LOG_MSG_1("main",
705  					"user cache transformation failed");
706  			else
707  				LOG_MSG_1("main",
708  					"user cache_transformation "
709  					"succeeded");
710  		}
711  
712  		if (clear_all_cache_entries != 0) {
713  			if (geteuid() != 0)
714  				errx(EXIT_FAILURE, "Only root can initiate "
715  					"global cache transformation.");
716  
717  			result = nscd_transform__(connection,
718  				global_config_entry_name, TT_ALL);
719  			if (result != 0)
720  				LOG_MSG_1("main",
721  					"global cache transformation "
722  					"failed");
723  			else
724  				LOG_MSG_1("main",
725  					"global cache transformation "
726  					"succeeded");
727  		}
728  
729  		close_nscd_connection__(connection);
730  
731  		free(user_config_entry_name);
732  		free(global_config_entry_name);
733  		return (EXIT_SUCCESS);
734  	}
735  
736  	pidfile = pidfile_open(DEFAULT_PIDFILE_PATH, 0644, &pid);
737  	if (pidfile == NULL) {
738  		if (errno == EEXIST)
739  			errx(EXIT_FAILURE, "Daemon already running, pid: %d.",
740  				pid);
741  		warn("Cannot open or create pidfile");
742  	}
743  
744  	if (trace_mode_enabled == 1)
745  		TRACE_ON();
746  
747  	/* blocking the main thread from receiving SIGPIPE signal */
748  	sigblock(sigmask(SIGPIPE));
749  
750  	/* daemonization */
751  	if (do_not_daemonize == 0) {
752  		res = daemon(0, trace_mode_enabled == 0 ? 0 : 1);
753  		if (res != 0) {
754  			LOG_ERR_1("main", "can't daemonize myself: %s",
755  		    		strerror(errno));
756  			pidfile_remove(pidfile);
757  			goto fin;
758  		} else
759  			LOG_MSG_1("main", "successfully daemonized");
760  	}
761  
762  	pidfile_write(pidfile);
763  
764  	s_agent_table = init_agent_table();
765  	register_agent(s_agent_table, init_passwd_agent());
766  	register_agent(s_agent_table, init_passwd_mp_agent());
767  	register_agent(s_agent_table, init_group_agent());
768  	register_agent(s_agent_table, init_group_mp_agent());
769  	register_agent(s_agent_table, init_services_agent());
770  	register_agent(s_agent_table, init_services_mp_agent());
771  	LOG_MSG_1("main", "request agents registered successfully");
772  
773  	/*
774   	 * Hosts agent can't work properly until we have access to the
775  	 * appropriate dtab structures, which are used in nsdispatch
776  	 * calls
777  	 *
778  	 register_agent(s_agent_table, init_hosts_agent());
779  	*/
780  
781  	/* configuration initialization */
782  	s_configuration = init_configuration();
783  	fill_configuration_defaults(s_configuration);
784  
785  	error_str = NULL;
786  	error_line = 0;
787  	config_file = CONFIG_PATH;
788  
789  	res = parse_config_file(s_configuration, config_file, &error_str,
790  		&error_line);
791  	if ((res != 0) && (error_str == NULL)) {
792  		config_file = DEFAULT_CONFIG_PATH;
793  		res = parse_config_file(s_configuration, config_file,
794  			&error_str, &error_line);
795  	}
796  
797  	if (res != 0) {
798  		if (error_str != NULL) {
799  		LOG_ERR_1("main", "error in configuration file(%s, %d): %s\n",
800  			config_file, error_line, error_str);
801  		} else {
802  		LOG_ERR_1("main", "no configuration file found "
803  		    	"- was looking for %s and %s",
804  			CONFIG_PATH, DEFAULT_CONFIG_PATH);
805  		}
806  		destroy_configuration(s_configuration);
807  		return (-1);
808  	}
809  
810  	if (force_single_threaded == 1)
811  		s_configuration->threads_num = 1;
812  
813  	/* cache initialization */
814  	s_cache = init_cache_(s_configuration);
815  	if (s_cache == NULL) {
816  		LOG_ERR_1("main", "can't initialize the cache");
817  		destroy_configuration(s_configuration);
818  		return (-1);
819  	}
820  
821  	/* runtime environment initialization */
822  	s_runtime_env = init_runtime_env(s_configuration);
823  	if (s_runtime_env == NULL) {
824  		LOG_ERR_1("main", "can't initialize the runtime environment");
825  		destroy_configuration(s_configuration);
826  		destroy_cache_(s_cache);
827  		return (-1);
828  	}
829  
830  	if (s_configuration->threads_num > 1) {
831  		threads = calloc(1, sizeof(*threads) *
832  			s_configuration->threads_num);
833  		for (i = 0; i < s_configuration->threads_num; ++i) {
834  			thread_args = malloc(
835  				sizeof(*thread_args));
836  			thread_args->the_cache = s_cache;
837  			thread_args->the_runtime_env = s_runtime_env;
838  			thread_args->the_configuration = s_configuration;
839  
840  			LOG_MSG_1("main", "thread #%d was successfully created",
841  				i);
842  			pthread_create(&threads[i], NULL, processing_thread,
843  				thread_args);
844  
845  			thread_args = NULL;
846  		}
847  
848  		for (i = 0; i < s_configuration->threads_num; ++i)
849  			pthread_join(threads[i], NULL);
850  	} else {
851  		LOG_MSG_1("main", "working in single-threaded mode");
852  		processing_loop(s_cache, s_runtime_env, s_configuration);
853  	}
854  
855  fin:
856  	/* runtime environment destruction */
857  	destroy_runtime_env(s_runtime_env);
858  
859  	/* cache destruction */
860  	destroy_cache_(s_cache);
861  
862  	/* configuration destruction */
863  	destroy_configuration(s_configuration);
864  
865  	/* agents table destruction */
866  	destroy_agent_table(s_agent_table);
867  
868  	pidfile_remove(pidfile);
869  	return (EXIT_SUCCESS);
870  }
871