/*- * Copyright (c) 2005 Michael Bushkov * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in thereg * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD: src/usr.sbin/nscd/nscd.c,v 1.7 2008/10/23 00:27:35 delphij Exp $ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "agents/passwd.h" #include "agents/group.h" #include "agents/services.h" #include "cachelib.h" #include "config.h" #include "debug.h" #include "log.h" #include "nscdcli.h" #include "parser.h" #include "pidfile.h" #include "query.h" #include "singletons.h" #ifndef CONFIG_PATH #define CONFIG_PATH "/etc/nscd.conf" #endif #define DEFAULT_CONFIG_PATH "nscd.conf" #define MAX_SOCKET_IO_SIZE 4096 struct processing_thread_args { cache the_cache; struct configuration *the_configuration; struct runtime_env *the_runtime_env; }; static void accept_connection(struct kevent *, struct runtime_env *, struct configuration *); static void destroy_cache_(cache); static void destroy_runtime_env(struct runtime_env *); static cache init_cache_(struct configuration *); static struct runtime_env *init_runtime_env(struct configuration *); static void processing_loop(cache, struct runtime_env *, struct configuration *); static void process_socket_event(struct kevent *, struct runtime_env *, struct configuration *); static void process_timer_event(struct kevent *, struct runtime_env *, struct configuration *); static void *processing_thread(void *); static void usage(void); void get_time_func(struct timeval *); static void usage(void) { fprintf(stderr, "usage: nscd [-dnst] [-i cachename] [-I cachename]\n"); exit(1); } static cache init_cache_(struct configuration *config) { struct cache_params params; cache retval; struct configuration_entry *config_entry; size_t size, i; int res; TRACE_IN(init_cache_); memset(¶ms, 0, sizeof(struct cache_params)); params.get_time_func = get_time_func; retval = init_cache(¶ms); size = configuration_get_entries_size(config); for (i = 0; i < size; ++i) { config_entry = configuration_get_entry(config, i); /* * We should register common entries now - multipart entries * would be registered automatically during the queries. */ res = register_cache_entry(retval, (struct cache_entry_params *) &config_entry->positive_cache_params); config_entry->positive_cache_entry = find_cache_entry(retval, config_entry->positive_cache_params.entry_name); assert(config_entry->positive_cache_entry != INVALID_CACHE_ENTRY); res = register_cache_entry(retval, (struct cache_entry_params *) &config_entry->negative_cache_params); config_entry->negative_cache_entry = find_cache_entry(retval, config_entry->negative_cache_params.entry_name); assert(config_entry->negative_cache_entry != INVALID_CACHE_ENTRY); } LOG_MSG_2("cache", "cache was successfully initialized"); TRACE_OUT(init_cache_); return (retval); } static void destroy_cache_(cache the_cache) { TRACE_IN(destroy_cache_); destroy_cache(the_cache); TRACE_OUT(destroy_cache_); } /* * Socket and kqueues are prepared here. We have one global queue for both * socket and timers events. */ static struct runtime_env * init_runtime_env(struct configuration *config) { int serv_addr_len; struct sockaddr_un serv_addr; struct kevent eventlist; struct timespec timeout; struct runtime_env *retval; TRACE_IN(init_runtime_env); retval = (struct runtime_env *)calloc(1, sizeof(struct runtime_env)); assert(retval != NULL); retval->sockfd = socket(PF_LOCAL, SOCK_STREAM, 0); if (config->force_unlink == 1) unlink(config->socket_path); memset(&serv_addr, 0, sizeof(struct sockaddr_un)); serv_addr.sun_family = PF_LOCAL; strlcpy(serv_addr.sun_path, config->socket_path, sizeof(serv_addr.sun_path)); serv_addr_len = sizeof(serv_addr.sun_family) + strlen(serv_addr.sun_path) + 1; if (bind(retval->sockfd, (struct sockaddr *)&serv_addr, serv_addr_len) == -1) { close(retval->sockfd); free(retval); LOG_ERR_2("runtime environment", "can't bind socket to path: " "%s", config->socket_path); TRACE_OUT(init_runtime_env); return (NULL); } LOG_MSG_2("runtime environment", "using socket %s", config->socket_path); /* * Here we're marking socket as non-blocking and setting its backlog * to the maximum value */ chmod(config->socket_path, config->socket_mode); listen(retval->sockfd, -1); fcntl(retval->sockfd, F_SETFL, O_NONBLOCK); retval->queue = kqueue(); assert(retval->queue != -1); EV_SET(&eventlist, retval->sockfd, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, 0); memset(&timeout, 0, sizeof(struct timespec)); kevent(retval->queue, &eventlist, 1, NULL, 0, &timeout); LOG_MSG_2("runtime environment", "successfully initialized"); TRACE_OUT(init_runtime_env); return (retval); } static void destroy_runtime_env(struct runtime_env *env) { TRACE_IN(destroy_runtime_env); close(env->queue); close(env->sockfd); free(env); TRACE_OUT(destroy_runtime_env); } static void accept_connection(struct kevent *event_data, struct runtime_env *env, struct configuration *config) { struct kevent eventlist[2]; struct timespec timeout; struct query_state *qstate; int fd; int res; uid_t euid; gid_t egid; TRACE_IN(accept_connection); fd = accept(event_data->ident, NULL, NULL); if (fd == -1) { LOG_ERR_2("accept_connection", "error %d during accept()", errno); TRACE_OUT(accept_connection); return; } if (getpeereid(fd, &euid, &egid) != 0) { LOG_ERR_2("accept_connection", "error %d during getpeereid()", errno); TRACE_OUT(accept_connection); return; } qstate = init_query_state(fd, sizeof(int), euid, egid); if (qstate == NULL) { LOG_ERR_2("accept_connection", "can't init query_state"); TRACE_OUT(accept_connection); return; } memset(&timeout, 0, sizeof(struct timespec)); EV_SET(&eventlist[0], fd, EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, qstate->timeout.tv_sec * 1000, qstate); EV_SET(&eventlist[1], fd, EVFILT_READ, EV_ADD | EV_ONESHOT, NOTE_LOWAT, qstate->kevent_watermark, qstate); res = kevent(env->queue, eventlist, 2, NULL, 0, &timeout); if (res < 0) LOG_ERR_2("accept_connection", "kevent error"); TRACE_OUT(accept_connection); } static void process_socket_event(struct kevent *event_data, struct runtime_env *env, struct configuration *config) { struct kevent eventlist[2]; struct timeval query_timeout; struct timespec kevent_timeout; int nevents; int eof_res, res; ssize_t io_res; struct query_state *qstate; TRACE_IN(process_socket_event); eof_res = event_data->flags & EV_EOF ? 1 : 0; res = 0; memset(&kevent_timeout, 0, sizeof(struct timespec)); EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER, EV_DELETE, 0, 0, NULL); nevents = kevent(env->queue, eventlist, 1, NULL, 0, &kevent_timeout); if (nevents == -1) { if (errno == ENOENT) { /* the timer is already handling this event */ TRACE_OUT(process_socket_event); return; } else { /* some other error happened */ LOG_ERR_2("process_socket_event", "kevent error, errno" " is %d", errno); TRACE_OUT(process_socket_event); return; } } qstate = (struct query_state *)event_data->udata; /* * If the buffer that is to be send/received is too large, * we send it implicitly, by using query_io_buffer_read and * query_io_buffer_write functions in the query_state. These functions * use the temporary buffer, which is later send/received in parts. * The code below implements buffer splitting/mergind for send/receive * operations. It also does the actual socket IO operations. */ if (((qstate->use_alternate_io == 0) && (qstate->kevent_watermark <= event_data->data)) || ((qstate->use_alternate_io != 0) && (qstate->io_buffer_watermark <= event_data->data))) { if (qstate->use_alternate_io != 0) { switch (qstate->io_buffer_filter) { case EVFILT_READ: io_res = query_socket_read(qstate, qstate->io_buffer_p, qstate->io_buffer_watermark); if (io_res < 0) { qstate->use_alternate_io = 0; qstate->process_func = NULL; } else { qstate->io_buffer_p += io_res; if (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size) { qstate->io_buffer_p = qstate->io_buffer; qstate->use_alternate_io = 0; } } break; default: break; } } if (qstate->use_alternate_io == 0) { do { res = qstate->process_func(qstate); } while ((qstate->kevent_watermark == 0) && (qstate->process_func != NULL) && (res == 0)); if (res != 0) qstate->process_func = NULL; } if ((qstate->use_alternate_io != 0) && (qstate->io_buffer_filter == EVFILT_WRITE)) { io_res = query_socket_write(qstate, qstate->io_buffer_p, qstate->io_buffer_watermark); if (io_res < 0) { qstate->use_alternate_io = 0; qstate->process_func = NULL; } else qstate->io_buffer_p += io_res; } } else { /* assuming that socket was closed */ qstate->process_func = NULL; qstate->use_alternate_io = 0; } if (((qstate->process_func == NULL) && (qstate->use_alternate_io == 0)) || (eof_res != 0) || (res != 0)) { destroy_query_state(qstate); close(event_data->ident); TRACE_OUT(process_socket_event); return; } /* updating the query_state lifetime variable */ get_time_func(&query_timeout); query_timeout.tv_usec = 0; query_timeout.tv_sec -= qstate->creation_time.tv_sec; if (query_timeout.tv_sec > qstate->timeout.tv_sec) query_timeout.tv_sec = 0; else query_timeout.tv_sec = qstate->timeout.tv_sec - query_timeout.tv_sec; if ((qstate->use_alternate_io != 0) && (qstate->io_buffer_p == qstate->io_buffer + qstate->io_buffer_size)) qstate->use_alternate_io = 0; if (qstate->use_alternate_io == 0) { /* * If we must send/receive the large block of data, * we should prepare the query_state's io_XXX fields. * We should also substitute its write_func and read_func * with the query_io_buffer_write and query_io_buffer_read, * which will allow us to implicitly send/receive this large * buffer later (in the subsequent calls to the * process_socket_event). */ if (qstate->kevent_watermark > MAX_SOCKET_IO_SIZE) { if (qstate->io_buffer != NULL) free(qstate->io_buffer); qstate->io_buffer = (char *)calloc(1, qstate->kevent_watermark); assert(qstate->io_buffer != NULL); qstate->io_buffer_p = qstate->io_buffer; qstate->io_buffer_size = qstate->kevent_watermark; qstate->io_buffer_filter = qstate->kevent_filter; qstate->write_func = query_io_buffer_write; qstate->read_func = query_io_buffer_read; if (qstate->kevent_filter == EVFILT_READ) qstate->use_alternate_io = 1; qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE; EV_SET(&eventlist[1], event_data->ident, qstate->kevent_filter, EV_ADD | EV_ONESHOT, NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate); } else { EV_SET(&eventlist[1], event_data->ident, qstate->kevent_filter, EV_ADD | EV_ONESHOT, NOTE_LOWAT, qstate->kevent_watermark, qstate); } } else { if (qstate->io_buffer + qstate->io_buffer_size - qstate->io_buffer_p < MAX_SOCKET_IO_SIZE) { qstate->io_buffer_watermark = qstate->io_buffer + qstate->io_buffer_size - qstate->io_buffer_p; EV_SET(&eventlist[1], event_data->ident, qstate->io_buffer_filter, EV_ADD | EV_ONESHOT, NOTE_LOWAT, qstate->io_buffer_watermark, qstate); } else { qstate->io_buffer_watermark = MAX_SOCKET_IO_SIZE; EV_SET(&eventlist[1], event_data->ident, qstate->io_buffer_filter, EV_ADD | EV_ONESHOT, NOTE_LOWAT, MAX_SOCKET_IO_SIZE, qstate); } } EV_SET(&eventlist[0], event_data->ident, EVFILT_TIMER, EV_ADD | EV_ONESHOT, 0, query_timeout.tv_sec * 1000, qstate); kevent(env->queue, eventlist, 2, NULL, 0, &kevent_timeout); TRACE_OUT(process_socket_event); } /* * This routine is called if timer event has been signaled in the kqueue. It * just closes the socket and destroys the query_state. */ static void process_timer_event(struct kevent *event_data, struct runtime_env *env, struct configuration *config) { struct query_state *qstate; TRACE_IN(process_timer_event); qstate = (struct query_state *)event_data->udata; destroy_query_state(qstate); close(event_data->ident); TRACE_OUT(process_timer_event); } /* * Processing loop is the basic processing routine, that forms a body of each * procssing thread */ static void processing_loop(cache the_cache, struct runtime_env *env, struct configuration *config) { struct timespec timeout; const int eventlist_size = 1; struct kevent eventlist[eventlist_size]; int nevents, i; TRACE_MSG("=> processing_loop"); memset(&timeout, 0, sizeof(struct timespec)); memset(&eventlist, 0, sizeof(struct kevent) * eventlist_size); for (;;) { nevents = kevent(env->queue, NULL, 0, eventlist, eventlist_size, NULL); /* * we can only receive 1 event on success */ if (nevents == 1) { struct kevent *event_data; event_data = &eventlist[0]; if (event_data->ident == env->sockfd) { for (i = 0; i < event_data->data; ++i) accept_connection(event_data, env, config); EV_SET(eventlist, s_runtime_env->sockfd, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, 0); memset(&timeout, 0, sizeof(struct timespec)); kevent(s_runtime_env->queue, eventlist, 1, NULL, 0, &timeout); } else { switch (event_data->filter) { case EVFILT_READ: case EVFILT_WRITE: process_socket_event(event_data, env, config); break; case EVFILT_TIMER: process_timer_event(event_data, env, config); break; default: break; } } } else { /* this branch shouldn't be currently executed */ } } TRACE_MSG("<= processing_loop"); } /* * Wrapper above the processing loop function. It sets the thread signal mask * to avoid SIGPIPE signals (which can happen if the client works incorrectly). */ static void * processing_thread(void *data) { struct processing_thread_args *args; sigset_t new; TRACE_MSG("=> processing_thread"); args = (struct processing_thread_args *)data; sigemptyset(&new); sigaddset(&new, SIGPIPE); if (pthread_sigmask(SIG_BLOCK, &new, NULL) != 0) LOG_ERR_1("processing thread", "thread can't block the SIGPIPE signal"); processing_loop(args->the_cache, args->the_runtime_env, args->the_configuration); free(args); TRACE_MSG("<= processing_thread"); return (NULL); } void get_time_func(struct timeval *time) { struct timespec res; memset(&res, 0, sizeof(struct timespec)); clock_gettime(CLOCK_MONOTONIC, &res); time->tv_sec = res.tv_sec; time->tv_usec = 0; } /* * The idea of _nss_cache_cycle_prevention_function is that nsdispatch will * search for this symbol in the executable. This symbol is the attribute of * the caching daemon. So, if it exists, nsdispatch won't try to connect to * the caching daemon and will just ignore the 'cache' source in the * nsswitch.conf. This method helps to avoid cycles and organize * self-performing requests. */ void _nss_cache_cycle_prevention_function(void) { } int main(int argc, char *argv[]) { struct processing_thread_args *thread_args; pthread_t *threads; struct pidfh *pidfile; pid_t pid; char const *config_file; char const *error_str; int error_line; int i, res; int trace_mode_enabled; int force_single_threaded; int do_not_daemonize; int clear_user_cache_entries, clear_all_cache_entries; char *user_config_entry_name, *global_config_entry_name; int show_statistics; int daemon_mode, interactive_mode; /* by default all debug messages are omitted */ TRACE_OFF(); /* parsing command line arguments */ trace_mode_enabled = 0; force_single_threaded = 0; do_not_daemonize = 0; clear_user_cache_entries = 0; clear_all_cache_entries = 0; show_statistics = 0; user_config_entry_name = NULL; global_config_entry_name = NULL; while ((res = getopt(argc, argv, "nstdi:I:")) != -1) { switch (res) { case 'n': do_not_daemonize = 1; break; case 's': force_single_threaded = 1; break; case 't': trace_mode_enabled = 1; break; case 'i': clear_user_cache_entries = 1; if (optarg != NULL) if (strcmp(optarg, "all") != 0) user_config_entry_name = strdup(optarg); break; case 'I': clear_all_cache_entries = 1; if (optarg != NULL) if (strcmp(optarg, "all") != 0) global_config_entry_name = strdup(optarg); break; case 'd': show_statistics = 1; break; case '?': default: usage(); /* NOT REACHED */ } } daemon_mode = do_not_daemonize | force_single_threaded | trace_mode_enabled; interactive_mode = clear_user_cache_entries | clear_all_cache_entries | show_statistics; if ((daemon_mode != 0) && (interactive_mode != 0)) { LOG_ERR_1("main", "daemon mode and interactive_mode arguments " "can't be used together"); usage(); } if (interactive_mode != 0) { FILE *pidfin = fopen(DEFAULT_PIDFILE_PATH, "r"); char pidbuf[256]; struct nscd_connection_params connection_params; nscd_connection connection; int result; if (pidfin == NULL) errx(EXIT_FAILURE, "There is no daemon running."); memset(pidbuf, 0, sizeof(pidbuf)); fread(pidbuf, sizeof(pidbuf) - 1, 1, pidfin); fclose(pidfin); if (ferror(pidfin) != 0) errx(EXIT_FAILURE, "Can't read from pidfile."); if (sscanf(pidbuf, "%d", &pid) != 1) errx(EXIT_FAILURE, "Invalid pidfile."); LOG_MSG_1("main", "daemon PID is %d", pid); memset(&connection_params, 0, sizeof(struct nscd_connection_params)); connection_params.socket_path = DEFAULT_SOCKET_PATH; connection = open_nscd_connection__(&connection_params); if (connection == INVALID_NSCD_CONNECTION) errx(EXIT_FAILURE, "Can't connect to the daemon."); if (clear_user_cache_entries != 0) { result = nscd_transform__(connection, user_config_entry_name, TT_USER); if (result != 0) LOG_MSG_1("main", "user cache transformation failed"); else LOG_MSG_1("main", "user cache_transformation " "succeeded"); } if (clear_all_cache_entries != 0) { if (geteuid() != 0) errx(EXIT_FAILURE, "Only root can initiate " "global cache transformation."); result = nscd_transform__(connection, global_config_entry_name, TT_ALL); if (result != 0) LOG_MSG_1("main", "global cache transformation " "failed"); else LOG_MSG_1("main", "global cache transformation " "succeeded"); } close_nscd_connection__(connection); free(user_config_entry_name); free(global_config_entry_name); return (EXIT_SUCCESS); } pidfile = pidfile_open(DEFAULT_PIDFILE_PATH, 0644, &pid); if (pidfile == NULL) { if (errno == EEXIST) errx(EXIT_FAILURE, "Daemon already running, pid: %d.", pid); warn("Cannot open or create pidfile"); } if (trace_mode_enabled == 1) TRACE_ON(); /* blocking the main thread from receiving SIGPIPE signal */ sigblock(sigmask(SIGPIPE)); /* daemonization */ if (do_not_daemonize == 0) { res = daemon(0, trace_mode_enabled == 0 ? 0 : 1); if (res != 0) { LOG_ERR_1("main", "can't daemonize myself: %s", strerror(errno)); pidfile_remove(pidfile); goto fin; } else LOG_MSG_1("main", "successfully daemonized"); } pidfile_write(pidfile); s_agent_table = init_agent_table(); register_agent(s_agent_table, init_passwd_agent()); register_agent(s_agent_table, init_passwd_mp_agent()); register_agent(s_agent_table, init_group_agent()); register_agent(s_agent_table, init_group_mp_agent()); register_agent(s_agent_table, init_services_agent()); register_agent(s_agent_table, init_services_mp_agent()); LOG_MSG_1("main", "request agents registered successfully"); /* * Hosts agent can't work properly until we have access to the * appropriate dtab structures, which are used in nsdispatch * calls * register_agent(s_agent_table, init_hosts_agent()); */ /* configuration initialization */ s_configuration = init_configuration(); fill_configuration_defaults(s_configuration); error_str = NULL; error_line = 0; config_file = CONFIG_PATH; res = parse_config_file(s_configuration, config_file, &error_str, &error_line); if ((res != 0) && (error_str == NULL)) { config_file = DEFAULT_CONFIG_PATH; res = parse_config_file(s_configuration, config_file, &error_str, &error_line); } if (res != 0) { if (error_str != NULL) { LOG_ERR_1("main", "error in configuration file(%s, %d): %s\n", config_file, error_line, error_str); } else { LOG_ERR_1("main", "no configuration file found " "- was looking for %s and %s", CONFIG_PATH, DEFAULT_CONFIG_PATH); } destroy_configuration(s_configuration); return (-1); } if (force_single_threaded == 1) s_configuration->threads_num = 1; /* cache initialization */ s_cache = init_cache_(s_configuration); if (s_cache == NULL) { LOG_ERR_1("main", "can't initialize the cache"); destroy_configuration(s_configuration); return (-1); } /* runtime environment initialization */ s_runtime_env = init_runtime_env(s_configuration); if (s_runtime_env == NULL) { LOG_ERR_1("main", "can't initialize the runtime environment"); destroy_configuration(s_configuration); destroy_cache_(s_cache); return (-1); } if (s_configuration->threads_num > 1) { threads = (pthread_t *)calloc(1, sizeof(pthread_t) * s_configuration->threads_num); for (i = 0; i < s_configuration->threads_num; ++i) { thread_args = (struct processing_thread_args *)malloc( sizeof(struct processing_thread_args)); thread_args->the_cache = s_cache; thread_args->the_runtime_env = s_runtime_env; thread_args->the_configuration = s_configuration; LOG_MSG_1("main", "thread #%d was successfully created", i); pthread_create(&threads[i], NULL, processing_thread, thread_args); thread_args = NULL; } for (i = 0; i < s_configuration->threads_num; ++i) pthread_join(threads[i], NULL); } else { LOG_MSG_1("main", "working in single-threaded mode"); processing_loop(s_cache, s_runtime_env, s_configuration); } fin: /* runtime environment destruction */ destroy_runtime_env(s_runtime_env); /* cache destruction */ destroy_cache_(s_cache); /* configuration destruction */ destroy_configuration(s_configuration); /* agents table destruction */ destroy_agent_table(s_agent_table); pidfile_remove(pidfile); return (EXIT_SUCCESS); }