17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 53ad28c1eSrm * Common Development and Distribution License (the "License"). 63ad28c1eSrm * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22eb1a3463STruong Nguyen * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate /* 277c478bd9Sstevel@tonic-gate * NOTES: To be expanded. 287c478bd9Sstevel@tonic-gate * 297c478bd9Sstevel@tonic-gate * The SMF inetd. 307c478bd9Sstevel@tonic-gate * 317c478bd9Sstevel@tonic-gate * Below are some high level notes of the operation of the SMF inetd. The 327c478bd9Sstevel@tonic-gate * notes don't go into any real detail, and the viewer of this file is 337c478bd9Sstevel@tonic-gate * encouraged to look at the code and its associated comments to better 347c478bd9Sstevel@tonic-gate * understand inetd's operation. This saves the potential for the code 357c478bd9Sstevel@tonic-gate * and these notes diverging over time. 367c478bd9Sstevel@tonic-gate * 377c478bd9Sstevel@tonic-gate * Inetd's major work is done from the context of event_loop(). Within this 387c478bd9Sstevel@tonic-gate * loop, inetd polls for events arriving from a number of different file 397c478bd9Sstevel@tonic-gate * descriptors, representing the following event types, and initiates 407c478bd9Sstevel@tonic-gate * any necessary event processing: 417c478bd9Sstevel@tonic-gate * - incoming network connections/datagrams. 427c478bd9Sstevel@tonic-gate * - notification of terminated processes (discovered via contract events). 437c478bd9Sstevel@tonic-gate * - instance specific events originating from the SMF master restarter. 447c478bd9Sstevel@tonic-gate * - stop/refresh requests from the inetd method processes (coming in on a 457c478bd9Sstevel@tonic-gate * Unix Domain socket). 467c478bd9Sstevel@tonic-gate * There's also a timeout set for the poll, which is set to the nearest 477c478bd9Sstevel@tonic-gate * scheduled timer in a timer queue that inetd uses to perform delayed 487c478bd9Sstevel@tonic-gate * processing, such as bind retries. 497c478bd9Sstevel@tonic-gate * The SIGHUP and SIGINT signals can also interrupt the poll, and will 507c478bd9Sstevel@tonic-gate * result in inetd being refreshed or stopped respectively, as was the 517c478bd9Sstevel@tonic-gate * behavior with the old inetd. 527c478bd9Sstevel@tonic-gate * 537c478bd9Sstevel@tonic-gate * Inetd implements a state machine for each instance. The states within the 547c478bd9Sstevel@tonic-gate * machine are: offline, online, disabled, maintenance, uninitialized and 557c478bd9Sstevel@tonic-gate * specializations of the offline state for when an instance exceeds one of 567c478bd9Sstevel@tonic-gate * its DOS limits. The state of an instance can be changed as a 577c478bd9Sstevel@tonic-gate * result/side-effect of one of the above events occurring, or inetd being 587c478bd9Sstevel@tonic-gate * started up. The ongoing state of an instance is stored in the SMF 597c478bd9Sstevel@tonic-gate * repository, as required of SMF restarters. This enables an administrator 607c478bd9Sstevel@tonic-gate * to view the state of each instance, and, if inetd was to terminate 617c478bd9Sstevel@tonic-gate * unexpectedly, it could use the stored state to re-commence where it left off. 627c478bd9Sstevel@tonic-gate * 637c478bd9Sstevel@tonic-gate * Within the state machine a number of methods are run (if provided) as part 647c478bd9Sstevel@tonic-gate * of a state transition to aid/ effect a change in an instance's state. The 657c478bd9Sstevel@tonic-gate * supported methods are: offline, online, disable, refresh and start. The 667c478bd9Sstevel@tonic-gate * latter of these is the equivalent of the server program and its arguments 677c478bd9Sstevel@tonic-gate * in the old inetd. 687c478bd9Sstevel@tonic-gate * 697c478bd9Sstevel@tonic-gate * Events from the SMF master restarter come in on a number of threads 707c478bd9Sstevel@tonic-gate * created in the registration routine of librestart, the delegated restarter 717c478bd9Sstevel@tonic-gate * library. These threads call into the restart_event_proxy() function 727c478bd9Sstevel@tonic-gate * when an event arrives. To serialize the processing of instances, these events 737c478bd9Sstevel@tonic-gate * are then written down a pipe to the process's main thread, which listens 747c478bd9Sstevel@tonic-gate * for these events via a poll call, with the file descriptor of the other 757c478bd9Sstevel@tonic-gate * end of the pipe in its read set, and processes the event appropriately. 767c478bd9Sstevel@tonic-gate * When the event has been processed (which may be delayed if the instance 777c478bd9Sstevel@tonic-gate * for which the event is for is in the process of executing one of its methods 787c478bd9Sstevel@tonic-gate * as part of a state transition) it writes an acknowledgement back down the 797c478bd9Sstevel@tonic-gate * pipe the event was received on. The thread in restart_event_proxy() that 807c478bd9Sstevel@tonic-gate * wrote the event will read the acknowledgement it was blocked upon, and will 817c478bd9Sstevel@tonic-gate * then be able to return to its caller, thus implicitly acknowledging the 827c478bd9Sstevel@tonic-gate * event, and allowing another event to be written down the pipe for the main 837c478bd9Sstevel@tonic-gate * thread to process. 847c478bd9Sstevel@tonic-gate */ 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate #include <netdb.h> 887c478bd9Sstevel@tonic-gate #include <stdio.h> 89004388ebScasper #include <stdio_ext.h> 907c478bd9Sstevel@tonic-gate #include <stdlib.h> 917c478bd9Sstevel@tonic-gate #include <strings.h> 927c478bd9Sstevel@tonic-gate #include <unistd.h> 937c478bd9Sstevel@tonic-gate #include <assert.h> 947c478bd9Sstevel@tonic-gate #include <sys/types.h> 957c478bd9Sstevel@tonic-gate #include <sys/socket.h> 967c478bd9Sstevel@tonic-gate #include <netinet/in.h> 977c478bd9Sstevel@tonic-gate #include <fcntl.h> 987c478bd9Sstevel@tonic-gate #include <signal.h> 997c478bd9Sstevel@tonic-gate #include <errno.h> 1007c478bd9Sstevel@tonic-gate #include <locale.h> 1017c478bd9Sstevel@tonic-gate #include <syslog.h> 1027c478bd9Sstevel@tonic-gate #include <libintl.h> 1037c478bd9Sstevel@tonic-gate #include <librestart.h> 1047c478bd9Sstevel@tonic-gate #include <pthread.h> 1057c478bd9Sstevel@tonic-gate #include <sys/stat.h> 1067c478bd9Sstevel@tonic-gate #include <time.h> 1077c478bd9Sstevel@tonic-gate #include <limits.h> 1087c478bd9Sstevel@tonic-gate #include <libgen.h> 1097c478bd9Sstevel@tonic-gate #include <tcpd.h> 1107c478bd9Sstevel@tonic-gate #include <libscf.h> 1117c478bd9Sstevel@tonic-gate #include <libuutil.h> 1127c478bd9Sstevel@tonic-gate #include <stddef.h> 1137c478bd9Sstevel@tonic-gate #include <bsm/adt_event.h> 1147cd7ea0bSrs #include <ucred.h> 1157c478bd9Sstevel@tonic-gate #include "inetd_impl.h" 1167c478bd9Sstevel@tonic-gate 1177c478bd9Sstevel@tonic-gate /* path to inetd's binary */ 1187c478bd9Sstevel@tonic-gate #define INETD_PATH "/usr/lib/inet/inetd" 1197c478bd9Sstevel@tonic-gate 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * inetd's default configuration file paths. /etc/inetd/inetd.conf is set 1227c478bd9Sstevel@tonic-gate * be be the primary file, so it is checked before /etc/inetd.conf. 1237c478bd9Sstevel@tonic-gate */ 1247c478bd9Sstevel@tonic-gate #define PRIMARY_DEFAULT_CONF_FILE "/etc/inet/inetd.conf" 1257c478bd9Sstevel@tonic-gate #define SECONDARY_DEFAULT_CONF_FILE "/etc/inetd.conf" 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate /* Arguments passed to this binary to request which method to execute. */ 1287c478bd9Sstevel@tonic-gate #define START_METHOD_ARG "start" 1297c478bd9Sstevel@tonic-gate #define STOP_METHOD_ARG "stop" 1307c478bd9Sstevel@tonic-gate #define REFRESH_METHOD_ARG "refresh" 1317c478bd9Sstevel@tonic-gate 1327c478bd9Sstevel@tonic-gate /* connection backlog for unix domain socket */ 1337c478bd9Sstevel@tonic-gate #define UDS_BACKLOG 2 1347c478bd9Sstevel@tonic-gate 1357c478bd9Sstevel@tonic-gate /* number of retries to recv() a request on the UDS socket before giving up */ 1367c478bd9Sstevel@tonic-gate #define UDS_RECV_RETRIES 10 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate /* enumeration of the different ends of a pipe */ 1397c478bd9Sstevel@tonic-gate enum pipe_end { 1407c478bd9Sstevel@tonic-gate PE_CONSUMER, 1417c478bd9Sstevel@tonic-gate PE_PRODUCER 1427c478bd9Sstevel@tonic-gate }; 1437c478bd9Sstevel@tonic-gate 1447c478bd9Sstevel@tonic-gate typedef struct { 1457c478bd9Sstevel@tonic-gate internal_inst_state_t istate; 1467c478bd9Sstevel@tonic-gate const char *name; 1477c478bd9Sstevel@tonic-gate restarter_instance_state_t smf_state; 1487c478bd9Sstevel@tonic-gate instance_method_t method_running; 1497c478bd9Sstevel@tonic-gate } state_info_t; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate 1527c478bd9Sstevel@tonic-gate /* 1537c478bd9Sstevel@tonic-gate * Collection of information for each state. 1547c478bd9Sstevel@tonic-gate * NOTE: This table is indexed into using the internal_inst_state_t 1557c478bd9Sstevel@tonic-gate * enumeration, so the ordering needs to be kept in synch. 1567c478bd9Sstevel@tonic-gate */ 1577c478bd9Sstevel@tonic-gate static state_info_t states[] = { 1587c478bd9Sstevel@tonic-gate {IIS_UNINITIALIZED, "uninitialized", RESTARTER_STATE_UNINIT, 1597c478bd9Sstevel@tonic-gate IM_NONE}, 1607c478bd9Sstevel@tonic-gate {IIS_ONLINE, "online", RESTARTER_STATE_ONLINE, IM_START}, 1617c478bd9Sstevel@tonic-gate {IIS_IN_ONLINE_METHOD, "online_method", RESTARTER_STATE_OFFLINE, 1627c478bd9Sstevel@tonic-gate IM_ONLINE}, 1637c478bd9Sstevel@tonic-gate {IIS_OFFLINE, "offline", RESTARTER_STATE_OFFLINE, IM_NONE}, 1647c478bd9Sstevel@tonic-gate {IIS_IN_OFFLINE_METHOD, "offline_method", RESTARTER_STATE_OFFLINE, 1657c478bd9Sstevel@tonic-gate IM_OFFLINE}, 1667c478bd9Sstevel@tonic-gate {IIS_DISABLED, "disabled", RESTARTER_STATE_DISABLED, IM_NONE}, 1677c478bd9Sstevel@tonic-gate {IIS_IN_DISABLE_METHOD, "disabled_method", RESTARTER_STATE_OFFLINE, 1687c478bd9Sstevel@tonic-gate IM_DISABLE}, 1697c478bd9Sstevel@tonic-gate {IIS_IN_REFRESH_METHOD, "refresh_method", RESTARTER_STATE_ONLINE, 1707c478bd9Sstevel@tonic-gate IM_REFRESH}, 1717c478bd9Sstevel@tonic-gate {IIS_MAINTENANCE, "maintenance", RESTARTER_STATE_MAINT, IM_NONE}, 1727c478bd9Sstevel@tonic-gate {IIS_OFFLINE_CONRATE, "cr_offline", RESTARTER_STATE_OFFLINE, IM_NONE}, 1737c478bd9Sstevel@tonic-gate {IIS_OFFLINE_BIND, "bind_offline", RESTARTER_STATE_OFFLINE, IM_NONE}, 1747c478bd9Sstevel@tonic-gate {IIS_OFFLINE_COPIES, "copies_offline", RESTARTER_STATE_OFFLINE, 1757c478bd9Sstevel@tonic-gate IM_NONE}, 1767c478bd9Sstevel@tonic-gate {IIS_DEGRADED, "degraded", RESTARTER_STATE_DEGRADED, IM_NONE}, 1777c478bd9Sstevel@tonic-gate {IIS_NONE, "none", RESTARTER_STATE_NONE, IM_NONE} 1787c478bd9Sstevel@tonic-gate }; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate /* 1817c478bd9Sstevel@tonic-gate * Pipe used to send events from the threads created by restarter_bind_handle() 1827c478bd9Sstevel@tonic-gate * to the main thread of control. 1837c478bd9Sstevel@tonic-gate */ 1847c478bd9Sstevel@tonic-gate static int rst_event_pipe[] = {-1, -1}; 1857c478bd9Sstevel@tonic-gate /* 1867c478bd9Sstevel@tonic-gate * Used to protect the critical section of code in restarter_event_proxy() that 1877c478bd9Sstevel@tonic-gate * involves writing an event down the event pipe and reading an acknowledgement. 1887c478bd9Sstevel@tonic-gate */ 1897c478bd9Sstevel@tonic-gate static pthread_mutex_t rst_event_pipe_mtx = PTHREAD_MUTEX_INITIALIZER; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate /* handle used in communication with the master restarter */ 1927c478bd9Sstevel@tonic-gate static restarter_event_handle_t *rst_event_handle = NULL; 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate /* set to indicate a refresh of inetd is requested */ 1957c478bd9Sstevel@tonic-gate static boolean_t refresh_inetd_requested = B_FALSE; 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate /* set by the SIGTERM handler to flag we got a SIGTERM */ 1987c478bd9Sstevel@tonic-gate static boolean_t got_sigterm = B_FALSE; 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate /* 2017c478bd9Sstevel@tonic-gate * Timer queue used to store timers for delayed event processing, such as 2027c478bd9Sstevel@tonic-gate * bind retries. 2037c478bd9Sstevel@tonic-gate */ 2047c478bd9Sstevel@tonic-gate iu_tq_t *timer_queue = NULL; 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate /* 2077c478bd9Sstevel@tonic-gate * fd of Unix Domain socket used to communicate stop and refresh requests 2087c478bd9Sstevel@tonic-gate * to the inetd start method process. 2097c478bd9Sstevel@tonic-gate */ 2107c478bd9Sstevel@tonic-gate static int uds_fd = -1; 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate /* 2137c478bd9Sstevel@tonic-gate * List of inetd's currently managed instances; each containing its state, 2147c478bd9Sstevel@tonic-gate * and in certain states its configuration. 2157c478bd9Sstevel@tonic-gate */ 2167c478bd9Sstevel@tonic-gate static uu_list_pool_t *instance_pool = NULL; 2177c478bd9Sstevel@tonic-gate uu_list_t *instance_list = NULL; 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate /* set to indicate we're being stopped */ 2207c478bd9Sstevel@tonic-gate boolean_t inetd_stopping = B_FALSE; 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /* TCP wrappers syslog globals. Consumed by libwrap. */ 2237c478bd9Sstevel@tonic-gate int allow_severity = LOG_INFO; 2247c478bd9Sstevel@tonic-gate int deny_severity = LOG_WARNING; 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate /* path of the configuration file being monitored by check_conf_file() */ 2277c478bd9Sstevel@tonic-gate static char *conf_file = NULL; 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate /* Auditing session handle */ 2307c478bd9Sstevel@tonic-gate static adt_session_data_t *audit_handle; 2317c478bd9Sstevel@tonic-gate 232ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India /* Number of pending connections */ 233ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India static size_t tlx_pending_counter; 234ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India 2357c478bd9Sstevel@tonic-gate static void uds_fini(void); 2367c478bd9Sstevel@tonic-gate static int uds_init(void); 2377c478bd9Sstevel@tonic-gate static int run_method(instance_t *, instance_method_t, const proto_info_t *); 2387c478bd9Sstevel@tonic-gate static void create_bound_fds(instance_t *); 2397c478bd9Sstevel@tonic-gate static void destroy_bound_fds(instance_t *); 2407c478bd9Sstevel@tonic-gate static void destroy_instance(instance_t *); 2417c478bd9Sstevel@tonic-gate static void inetd_stop(void); 242b823d4c7Sdstaff static void 243b823d4c7Sdstaff exec_method(instance_t *instance, instance_method_t method, method_info_t *mi, 244b823d4c7Sdstaff struct method_context *mthd_ctxt, const proto_info_t *pi) __NORETURN; 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate /* 2477c478bd9Sstevel@tonic-gate * The following two functions are callbacks that libumem uses to determine 2487c478bd9Sstevel@tonic-gate * inetd's desired debugging/logging levels. The interface they consume is 2497c478bd9Sstevel@tonic-gate * exported by FMA and is consolidation private. The comments in the two 2507c478bd9Sstevel@tonic-gate * functions give the environment variable that will effectively be set to 2517c478bd9Sstevel@tonic-gate * their returned value, and thus whose behavior for this value, described in 2527c478bd9Sstevel@tonic-gate * umem_debug(3MALLOC), will be followed. 2537c478bd9Sstevel@tonic-gate */ 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate const char * 2567c478bd9Sstevel@tonic-gate _umem_debug_init(void) 2577c478bd9Sstevel@tonic-gate { 2587c478bd9Sstevel@tonic-gate return ("default,verbose"); /* UMEM_DEBUG setting */ 2597c478bd9Sstevel@tonic-gate } 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate const char * 2627c478bd9Sstevel@tonic-gate _umem_logging_init(void) 2637c478bd9Sstevel@tonic-gate { 2647c478bd9Sstevel@tonic-gate return ("fail,contents"); /* UMEM_LOGGING setting */ 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate static void 2687c478bd9Sstevel@tonic-gate log_invalid_cfg(const char *fmri) 2697c478bd9Sstevel@tonic-gate { 2707c478bd9Sstevel@tonic-gate error_msg(gettext( 2717c478bd9Sstevel@tonic-gate "Invalid configuration for instance %s, placing in maintenance"), 2727c478bd9Sstevel@tonic-gate fmri); 2737c478bd9Sstevel@tonic-gate } 2747c478bd9Sstevel@tonic-gate 2757c478bd9Sstevel@tonic-gate /* 2767c478bd9Sstevel@tonic-gate * Returns B_TRUE if the instance is in a suitable state for inetd to stop. 2777c478bd9Sstevel@tonic-gate */ 2787c478bd9Sstevel@tonic-gate static boolean_t 2797c478bd9Sstevel@tonic-gate instance_stopped(const instance_t *inst) 2807c478bd9Sstevel@tonic-gate { 2817c478bd9Sstevel@tonic-gate return ((inst->cur_istate == IIS_OFFLINE) || 2827c478bd9Sstevel@tonic-gate (inst->cur_istate == IIS_MAINTENANCE) || 2837c478bd9Sstevel@tonic-gate (inst->cur_istate == IIS_DISABLED) || 2847c478bd9Sstevel@tonic-gate (inst->cur_istate == IIS_UNINITIALIZED)); 2857c478bd9Sstevel@tonic-gate } 2867c478bd9Sstevel@tonic-gate 287eb1a3463STruong Nguyen /* 288eb1a3463STruong Nguyen * Given the instance fmri, obtain the corresonding scf_instance. 289eb1a3463STruong Nguyen * Caller is responsible for freeing the returned scf_instance and 290eb1a3463STruong Nguyen * its scf_handle. 291eb1a3463STruong Nguyen */ 292eb1a3463STruong Nguyen static int 293eb1a3463STruong Nguyen fmri_to_instance(char *fmri, scf_instance_t **scf_instp) 294eb1a3463STruong Nguyen { 295eb1a3463STruong Nguyen int retries, ret = 1; 296eb1a3463STruong Nguyen scf_handle_t *h; 297eb1a3463STruong Nguyen scf_instance_t *scf_inst; 298eb1a3463STruong Nguyen 299eb1a3463STruong Nguyen if ((h = scf_handle_create(SCF_VERSION)) == NULL) { 300eb1a3463STruong Nguyen error_msg(gettext("Failed to get instance for %s"), fmri); 301eb1a3463STruong Nguyen return (1); 302eb1a3463STruong Nguyen } 303eb1a3463STruong Nguyen 304eb1a3463STruong Nguyen if ((scf_inst = scf_instance_create(h)) == NULL) 305eb1a3463STruong Nguyen goto out; 306eb1a3463STruong Nguyen 307eb1a3463STruong Nguyen for (retries = 0; retries <= REP_OP_RETRIES; retries++) { 308eb1a3463STruong Nguyen if (make_handle_bound(h) == -1) 309eb1a3463STruong Nguyen break; 310eb1a3463STruong Nguyen 311eb1a3463STruong Nguyen if (scf_handle_decode_fmri(h, fmri, NULL, NULL, scf_inst, 312eb1a3463STruong Nguyen NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0) { 313eb1a3463STruong Nguyen ret = 0; 314eb1a3463STruong Nguyen *scf_instp = scf_inst; 315eb1a3463STruong Nguyen break; 316eb1a3463STruong Nguyen } 317eb1a3463STruong Nguyen 318eb1a3463STruong Nguyen if (scf_error() != SCF_ERROR_CONNECTION_BROKEN) 319eb1a3463STruong Nguyen break; 320eb1a3463STruong Nguyen } 321eb1a3463STruong Nguyen 322eb1a3463STruong Nguyen out: 323eb1a3463STruong Nguyen if (ret != 0) { 324eb1a3463STruong Nguyen error_msg(gettext("Failed to get instance for %s"), fmri); 325eb1a3463STruong Nguyen scf_instance_destroy(scf_inst); 326eb1a3463STruong Nguyen scf_handle_destroy(h); 327eb1a3463STruong Nguyen } 328eb1a3463STruong Nguyen 329eb1a3463STruong Nguyen return (ret); 330eb1a3463STruong Nguyen } 331eb1a3463STruong Nguyen 3327c478bd9Sstevel@tonic-gate /* 3337c478bd9Sstevel@tonic-gate * Updates the current and next repository states of instance 'inst'. If 3347c478bd9Sstevel@tonic-gate * any errors occur an error message is output. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate static void 3377c478bd9Sstevel@tonic-gate update_instance_states(instance_t *inst, internal_inst_state_t new_cur_state, 3387c478bd9Sstevel@tonic-gate internal_inst_state_t new_next_state, restarter_error_t err) 3397c478bd9Sstevel@tonic-gate { 3407c478bd9Sstevel@tonic-gate internal_inst_state_t old_cur = inst->cur_istate; 3417c478bd9Sstevel@tonic-gate internal_inst_state_t old_next = inst->next_istate; 342eb1a3463STruong Nguyen scf_instance_t *scf_inst = NULL; 3437c478bd9Sstevel@tonic-gate scf_error_t sret; 3447c478bd9Sstevel@tonic-gate int ret; 345eb1a3463STruong Nguyen char *aux = "none"; 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate /* update the repository/cached internal state */ 3487c478bd9Sstevel@tonic-gate inst->cur_istate = new_cur_state; 3497c478bd9Sstevel@tonic-gate inst->next_istate = new_next_state; 3507c478bd9Sstevel@tonic-gate (void) set_single_rep_val(inst->cur_istate_rep, 3517c478bd9Sstevel@tonic-gate (int64_t)new_cur_state); 3527c478bd9Sstevel@tonic-gate (void) set_single_rep_val(inst->next_istate_rep, 3537c478bd9Sstevel@tonic-gate (int64_t)new_next_state); 3547c478bd9Sstevel@tonic-gate 3557c478bd9Sstevel@tonic-gate if (((sret = store_rep_vals(inst->cur_istate_rep, inst->fmri, 3567c478bd9Sstevel@tonic-gate PR_NAME_CUR_INT_STATE)) != 0) || 3577c478bd9Sstevel@tonic-gate ((sret = store_rep_vals(inst->next_istate_rep, inst->fmri, 3587c478bd9Sstevel@tonic-gate PR_NAME_NEXT_INT_STATE)) != 0)) 3597c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to update state of instance %s in " 3607c478bd9Sstevel@tonic-gate "repository: %s"), inst->fmri, scf_strerror(sret)); 3617c478bd9Sstevel@tonic-gate 362eb1a3463STruong Nguyen if (fmri_to_instance(inst->fmri, &scf_inst) == 0) { 363eb1a3463STruong Nguyen /* 364eb1a3463STruong Nguyen * If transitioning to maintenance, check auxiliary_tty set 365eb1a3463STruong Nguyen * by svcadm and assign appropriate value to auxiliary_state. 366eb1a3463STruong Nguyen * If the maintenance event comes from a service request, 367eb1a3463STruong Nguyen * validate auxiliary_fmri and copy it to 368eb1a3463STruong Nguyen * restarter/auxiliary_fmri. 369eb1a3463STruong Nguyen */ 370eb1a3463STruong Nguyen if (new_cur_state == IIS_MAINTENANCE) { 371eb1a3463STruong Nguyen if (restarter_inst_ractions_from_tty(scf_inst) == 0) 372eb1a3463STruong Nguyen aux = "service_request"; 373eb1a3463STruong Nguyen else 374eb1a3463STruong Nguyen aux = "administrative_request"; 375eb1a3463STruong Nguyen } 376eb1a3463STruong Nguyen 377eb1a3463STruong Nguyen if (strcmp(aux, "service_request") == 0) { 378eb1a3463STruong Nguyen if (restarter_inst_validate_ractions_aux_fmri( 379eb1a3463STruong Nguyen scf_inst) == 0) { 380eb1a3463STruong Nguyen if (restarter_inst_set_aux_fmri(scf_inst)) 381eb1a3463STruong Nguyen error_msg(gettext("Could not set " 382eb1a3463STruong Nguyen "auxiliary_fmri property for %s"), 383eb1a3463STruong Nguyen inst->fmri); 384eb1a3463STruong Nguyen } else { 385eb1a3463STruong Nguyen if (restarter_inst_reset_aux_fmri(scf_inst)) 386eb1a3463STruong Nguyen error_msg(gettext("Could not reset " 387eb1a3463STruong Nguyen "auxiliary_fmri property for %s"), 388eb1a3463STruong Nguyen inst->fmri); 389eb1a3463STruong Nguyen } 390eb1a3463STruong Nguyen } 391eb1a3463STruong Nguyen scf_handle_destroy(scf_instance_handle(scf_inst)); 392eb1a3463STruong Nguyen scf_instance_destroy(scf_inst); 393eb1a3463STruong Nguyen } 394eb1a3463STruong Nguyen 3957c478bd9Sstevel@tonic-gate /* update the repository SMF state */ 3967c478bd9Sstevel@tonic-gate if ((ret = restarter_set_states(rst_event_handle, inst->fmri, 3977c478bd9Sstevel@tonic-gate states[old_cur].smf_state, states[new_cur_state].smf_state, 3987c478bd9Sstevel@tonic-gate states[old_next].smf_state, states[new_next_state].smf_state, 399eb1a3463STruong Nguyen err, aux)) != 0) 4007c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to update state of instance %s in " 4017c478bd9Sstevel@tonic-gate "repository: %s"), inst->fmri, strerror(ret)); 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate void 4057c478bd9Sstevel@tonic-gate update_state(instance_t *inst, internal_inst_state_t new_cur, 4067c478bd9Sstevel@tonic-gate restarter_error_t err) 4077c478bd9Sstevel@tonic-gate { 4087c478bd9Sstevel@tonic-gate update_instance_states(inst, new_cur, IIS_NONE, err); 4097c478bd9Sstevel@tonic-gate } 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate /* 4127c478bd9Sstevel@tonic-gate * Sends a refresh event to the inetd start method process and returns 4137c478bd9Sstevel@tonic-gate * SMF_EXIT_OK if it managed to send it. If it fails to send the request for 4147c478bd9Sstevel@tonic-gate * some reason it returns SMF_EXIT_ERR_OTHER. 4157c478bd9Sstevel@tonic-gate */ 4167c478bd9Sstevel@tonic-gate static int 4177c478bd9Sstevel@tonic-gate refresh_method(void) 4187c478bd9Sstevel@tonic-gate { 4197c478bd9Sstevel@tonic-gate uds_request_t req = UR_REFRESH_INETD; 4207c478bd9Sstevel@tonic-gate int fd; 4217c478bd9Sstevel@tonic-gate 4227c478bd9Sstevel@tonic-gate if ((fd = connect_to_inetd()) < 0) { 4237c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to connect to inetd: %s"), 4247c478bd9Sstevel@tonic-gate strerror(errno)); 4257c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 4267c478bd9Sstevel@tonic-gate } 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate /* write the request and return success */ 4297c478bd9Sstevel@tonic-gate if (safe_write(fd, &req, sizeof (req)) == -1) { 4307c478bd9Sstevel@tonic-gate error_msg( 4317c478bd9Sstevel@tonic-gate gettext("Failed to send refresh request to inetd: %s"), 4327c478bd9Sstevel@tonic-gate strerror(errno)); 4337c478bd9Sstevel@tonic-gate (void) close(fd); 4347c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate (void) close(fd); 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate return (SMF_EXIT_OK); 4407c478bd9Sstevel@tonic-gate } 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate /* 4437c478bd9Sstevel@tonic-gate * Sends a stop event to the inetd start method process and wait till it goes 4447c478bd9Sstevel@tonic-gate * away. If inetd is determined to have stopped SMF_EXIT_OK is returned, else 4457c478bd9Sstevel@tonic-gate * SMF_EXIT_ERR_OTHER is returned. 4467c478bd9Sstevel@tonic-gate */ 4477c478bd9Sstevel@tonic-gate static int 4487c478bd9Sstevel@tonic-gate stop_method(void) 4497c478bd9Sstevel@tonic-gate { 4507c478bd9Sstevel@tonic-gate uds_request_t req = UR_STOP_INETD; 4517c478bd9Sstevel@tonic-gate int fd; 4527c478bd9Sstevel@tonic-gate char c; 4537c478bd9Sstevel@tonic-gate ssize_t ret; 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate if ((fd = connect_to_inetd()) == -1) { 4567c478bd9Sstevel@tonic-gate debug_msg(gettext("Failed to connect to inetd: %s"), 4577c478bd9Sstevel@tonic-gate strerror(errno)); 4587c478bd9Sstevel@tonic-gate /* 4597c478bd9Sstevel@tonic-gate * Assume connect_to_inetd() failed because inetd was already 4607c478bd9Sstevel@tonic-gate * stopped, and return success. 4617c478bd9Sstevel@tonic-gate */ 4627c478bd9Sstevel@tonic-gate return (SMF_EXIT_OK); 4637c478bd9Sstevel@tonic-gate } 4647c478bd9Sstevel@tonic-gate 4657c478bd9Sstevel@tonic-gate /* 4667c478bd9Sstevel@tonic-gate * This is safe to do since we're fired off in a separate process 4677c478bd9Sstevel@tonic-gate * than inetd and in the case we get wedged, the stop method timeout 4687c478bd9Sstevel@tonic-gate * will occur and we'd be killed by our restarter. 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate enable_blocking(fd); 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate /* write the stop request to inetd and wait till it goes away */ 4737c478bd9Sstevel@tonic-gate if (safe_write(fd, &req, sizeof (req)) != 0) { 4747c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to send stop request to inetd")); 4757c478bd9Sstevel@tonic-gate (void) close(fd); 4767c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 4777c478bd9Sstevel@tonic-gate } 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate /* wait until remote end of socket is closed */ 4807c478bd9Sstevel@tonic-gate while (((ret = recv(fd, &c, sizeof (c), 0)) != 0) && (errno == EINTR)) 4817c478bd9Sstevel@tonic-gate ; 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate (void) close(fd); 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate if (ret != 0) { 4867c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to determine whether inetd stopped")); 4877c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 4887c478bd9Sstevel@tonic-gate } 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate return (SMF_EXIT_OK); 4917c478bd9Sstevel@tonic-gate } 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate /* 4957c478bd9Sstevel@tonic-gate * This function is called to handle restarter events coming in from the 4967c478bd9Sstevel@tonic-gate * master restarter. It is registered with the master restarter via 4977c478bd9Sstevel@tonic-gate * restarter_bind_handle() and simply passes a pointer to the event down 4987c478bd9Sstevel@tonic-gate * the event pipe, which will be discovered by the poll in the event loop 4997c478bd9Sstevel@tonic-gate * and processed there. It waits for an acknowledgement to be written back down 5007c478bd9Sstevel@tonic-gate * the pipe before returning. 5017c478bd9Sstevel@tonic-gate * Writing a pointer to the function's 'event' parameter down the pipe will 5027c478bd9Sstevel@tonic-gate * be safe, as the thread in restarter_event_proxy() doesn't return until 5037c478bd9Sstevel@tonic-gate * the main thread has finished its processing of the passed event, thus 5047c478bd9Sstevel@tonic-gate * the referenced event will remain around until the function returns. 5057c478bd9Sstevel@tonic-gate * To impose the limit of only one event being in the pipe and processed 5067c478bd9Sstevel@tonic-gate * at once, a lock is taken on entry to this function and returned on exit. 5077c478bd9Sstevel@tonic-gate * Always returns 0. 5087c478bd9Sstevel@tonic-gate */ 5097c478bd9Sstevel@tonic-gate static int 5107c478bd9Sstevel@tonic-gate restarter_event_proxy(restarter_event_t *event) 5117c478bd9Sstevel@tonic-gate { 5127c478bd9Sstevel@tonic-gate boolean_t processed; 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&rst_event_pipe_mtx); 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate /* write the event to the main worker thread down the pipe */ 5177c478bd9Sstevel@tonic-gate if (safe_write(rst_event_pipe[PE_PRODUCER], &event, 5187c478bd9Sstevel@tonic-gate sizeof (event)) != 0) 5197c478bd9Sstevel@tonic-gate goto pipe_error; 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* 5227c478bd9Sstevel@tonic-gate * Wait for an acknowledgement that the event has been processed from 5237c478bd9Sstevel@tonic-gate * the same pipe. In the case that inetd is stopping, any thread in 5247c478bd9Sstevel@tonic-gate * this function will simply block on this read until inetd eventually 5257c478bd9Sstevel@tonic-gate * exits. This will result in this function not returning success to 5267c478bd9Sstevel@tonic-gate * its caller, and the event that was being processed when the 5277c478bd9Sstevel@tonic-gate * function exited will be re-sent when inetd is next started. 5287c478bd9Sstevel@tonic-gate */ 5297c478bd9Sstevel@tonic-gate if (safe_read(rst_event_pipe[PE_PRODUCER], &processed, 5307c478bd9Sstevel@tonic-gate sizeof (processed)) != 0) 5317c478bd9Sstevel@tonic-gate goto pipe_error; 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&rst_event_pipe_mtx); 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate return (processed ? 0 : EAGAIN); 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate pipe_error: 5387c478bd9Sstevel@tonic-gate /* 5397c478bd9Sstevel@tonic-gate * Something's seriously wrong with the event pipe. Notify the 5407c478bd9Sstevel@tonic-gate * worker thread by closing this end of the event pipe and pause till 5417c478bd9Sstevel@tonic-gate * inetd exits. 5427c478bd9Sstevel@tonic-gate */ 5437c478bd9Sstevel@tonic-gate error_msg(gettext("Can't process restarter events: %s"), 5447c478bd9Sstevel@tonic-gate strerror(errno)); 5457c478bd9Sstevel@tonic-gate (void) close(rst_event_pipe[PE_PRODUCER]); 5467c478bd9Sstevel@tonic-gate for (;;) 5477c478bd9Sstevel@tonic-gate (void) pause(); 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate /* NOTREACHED */ 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate /* 5537c478bd9Sstevel@tonic-gate * Let restarter_event_proxy() know we're finished with the event it's blocked 5547c478bd9Sstevel@tonic-gate * upon. The 'processed' argument denotes whether we successfully processed the 5557c478bd9Sstevel@tonic-gate * event. 5567c478bd9Sstevel@tonic-gate */ 5577c478bd9Sstevel@tonic-gate static void 5587c478bd9Sstevel@tonic-gate ack_restarter_event(boolean_t processed) 5597c478bd9Sstevel@tonic-gate { 5607c478bd9Sstevel@tonic-gate /* 5617c478bd9Sstevel@tonic-gate * If safe_write returns -1 something's seriously wrong with the event 5627c478bd9Sstevel@tonic-gate * pipe, so start the shutdown proceedings. 5637c478bd9Sstevel@tonic-gate */ 5647c478bd9Sstevel@tonic-gate if (safe_write(rst_event_pipe[PE_CONSUMER], &processed, 5657c478bd9Sstevel@tonic-gate sizeof (processed)) == -1) 5667c478bd9Sstevel@tonic-gate inetd_stop(); 5677c478bd9Sstevel@tonic-gate } 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate /* 5707c478bd9Sstevel@tonic-gate * Switch the syslog identification string to 'ident'. 5717c478bd9Sstevel@tonic-gate */ 5727c478bd9Sstevel@tonic-gate static void 5737c478bd9Sstevel@tonic-gate change_syslog_ident(const char *ident) 5747c478bd9Sstevel@tonic-gate { 5757c478bd9Sstevel@tonic-gate closelog(); 5767c478bd9Sstevel@tonic-gate openlog(ident, LOG_PID|LOG_CONS, LOG_DAEMON); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate 5797c478bd9Sstevel@tonic-gate /* 5807c478bd9Sstevel@tonic-gate * Perform TCP wrappers checks on this instance. Due to the fact that the 5817c478bd9Sstevel@tonic-gate * current wrappers code used in Solaris is taken untouched from the open 5827c478bd9Sstevel@tonic-gate * source version, we're stuck with using the daemon name for the checks, as 5837c478bd9Sstevel@tonic-gate * opposed to making use of instance FMRIs. Sigh. 5847c478bd9Sstevel@tonic-gate * Returns B_TRUE if the check passed, else B_FALSE. 5857c478bd9Sstevel@tonic-gate */ 5867c478bd9Sstevel@tonic-gate static boolean_t 5877c478bd9Sstevel@tonic-gate tcp_wrappers_ok(instance_t *instance) 5887c478bd9Sstevel@tonic-gate { 5897c478bd9Sstevel@tonic-gate boolean_t rval = B_TRUE; 5907c478bd9Sstevel@tonic-gate char *daemon_name; 5917c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 5927c478bd9Sstevel@tonic-gate struct request_info req; 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate /* 5957c478bd9Sstevel@tonic-gate * Wrap the service using libwrap functions. The code below implements 5967c478bd9Sstevel@tonic-gate * the functionality of tcpd. This is done only for stream,nowait 5977c478bd9Sstevel@tonic-gate * services, following the convention of other vendors. udp/dgram and 5987c478bd9Sstevel@tonic-gate * stream/wait can NOT be wrapped with this libwrap, so be wary of 5997c478bd9Sstevel@tonic-gate * changing the test below. 6007c478bd9Sstevel@tonic-gate */ 6017c478bd9Sstevel@tonic-gate if (cfg->do_tcp_wrappers && !cfg->iswait && !cfg->istlx) { 6027c478bd9Sstevel@tonic-gate 6037c478bd9Sstevel@tonic-gate daemon_name = instance->config->methods[ 6047c478bd9Sstevel@tonic-gate IM_START]->exec_args_we.we_wordv[0]; 6057c478bd9Sstevel@tonic-gate if (*daemon_name == '/') 6067c478bd9Sstevel@tonic-gate daemon_name = strrchr(daemon_name, '/') + 1; 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate /* 6097c478bd9Sstevel@tonic-gate * Change the syslog message identity to the name of the 6107c478bd9Sstevel@tonic-gate * daemon being wrapped, as opposed to "inetd". 6117c478bd9Sstevel@tonic-gate */ 6127c478bd9Sstevel@tonic-gate change_syslog_ident(daemon_name); 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate (void) request_init(&req, RQ_DAEMON, daemon_name, RQ_FILE, 6157c478bd9Sstevel@tonic-gate instance->conn_fd, NULL); 6167c478bd9Sstevel@tonic-gate fromhost(&req); 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate if (strcasecmp(eval_hostname(req.client), paranoid) == 0) { 6197c478bd9Sstevel@tonic-gate syslog(deny_severity, 6207c478bd9Sstevel@tonic-gate "refused connect from %s (name/address mismatch)", 6217c478bd9Sstevel@tonic-gate eval_client(&req)); 6227c478bd9Sstevel@tonic-gate if (req.sink != NULL) 6237c478bd9Sstevel@tonic-gate req.sink(instance->conn_fd); 6247c478bd9Sstevel@tonic-gate rval = B_FALSE; 6257c478bd9Sstevel@tonic-gate } else if (!hosts_access(&req)) { 6267c478bd9Sstevel@tonic-gate syslog(deny_severity, 6277c478bd9Sstevel@tonic-gate "refused connect from %s (access denied)", 6287c478bd9Sstevel@tonic-gate eval_client(&req)); 6297c478bd9Sstevel@tonic-gate if (req.sink != NULL) 6307c478bd9Sstevel@tonic-gate req.sink(instance->conn_fd); 6317c478bd9Sstevel@tonic-gate rval = B_FALSE; 6327c478bd9Sstevel@tonic-gate } else { 6337c478bd9Sstevel@tonic-gate syslog(allow_severity, "connect from %s", 6347c478bd9Sstevel@tonic-gate eval_client(&req)); 6357c478bd9Sstevel@tonic-gate } 6367c478bd9Sstevel@tonic-gate 6377c478bd9Sstevel@tonic-gate /* Revert syslog identity back to "inetd". */ 6387c478bd9Sstevel@tonic-gate change_syslog_ident(SYSLOG_IDENT); 6397c478bd9Sstevel@tonic-gate } 6407c478bd9Sstevel@tonic-gate return (rval); 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate /* 6447c478bd9Sstevel@tonic-gate * Handler registered with the timer queue code to remove an instance from 6457c478bd9Sstevel@tonic-gate * the connection rate offline state when it has been there for its allotted 6467c478bd9Sstevel@tonic-gate * time. 6477c478bd9Sstevel@tonic-gate */ 6487c478bd9Sstevel@tonic-gate /* ARGSUSED */ 6497c478bd9Sstevel@tonic-gate static void 6507c478bd9Sstevel@tonic-gate conn_rate_online(iu_tq_t *tq, void *arg) 6517c478bd9Sstevel@tonic-gate { 6527c478bd9Sstevel@tonic-gate instance_t *instance = arg; 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate assert(instance->cur_istate == IIS_OFFLINE_CONRATE); 6557c478bd9Sstevel@tonic-gate instance->timer_id = -1; 6567c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, RERR_RESTART); 6577c478bd9Sstevel@tonic-gate process_offline_inst(instance); 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate /* 6617c478bd9Sstevel@tonic-gate * Check whether this instance in the offline state is in transition to 6627c478bd9Sstevel@tonic-gate * another state and do the work to continue this transition. 6637c478bd9Sstevel@tonic-gate */ 6647c478bd9Sstevel@tonic-gate void 6657c478bd9Sstevel@tonic-gate process_offline_inst(instance_t *inst) 6667c478bd9Sstevel@tonic-gate { 6677c478bd9Sstevel@tonic-gate if (inst->disable_req) { 6687c478bd9Sstevel@tonic-gate inst->disable_req = B_FALSE; 6697c478bd9Sstevel@tonic-gate (void) run_method(inst, IM_DISABLE, NULL); 6707c478bd9Sstevel@tonic-gate } else if (inst->maintenance_req) { 6717c478bd9Sstevel@tonic-gate inst->maintenance_req = B_FALSE; 6727c478bd9Sstevel@tonic-gate update_state(inst, IIS_MAINTENANCE, RERR_RESTART); 6737c478bd9Sstevel@tonic-gate /* 6747c478bd9Sstevel@tonic-gate * If inetd is in the process of stopping, we don't want to enter 6757c478bd9Sstevel@tonic-gate * any states but offline, disabled and maintenance. 6767c478bd9Sstevel@tonic-gate */ 6777c478bd9Sstevel@tonic-gate } else if (!inetd_stopping) { 6787c478bd9Sstevel@tonic-gate if (inst->conn_rate_exceeded) { 6797c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = inst->config->basic; 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate inst->conn_rate_exceeded = B_FALSE; 6827c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE_CONRATE, RERR_RESTART); 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * Schedule a timer to bring the instance out of the 6857c478bd9Sstevel@tonic-gate * connection rate offline state. 6867c478bd9Sstevel@tonic-gate */ 6877c478bd9Sstevel@tonic-gate inst->timer_id = iu_schedule_timer(timer_queue, 6887c478bd9Sstevel@tonic-gate cfg->conn_rate_offline, conn_rate_online, 6897c478bd9Sstevel@tonic-gate inst); 6907c478bd9Sstevel@tonic-gate if (inst->timer_id == -1) { 6917c478bd9Sstevel@tonic-gate error_msg(gettext("%s unable to set timer, " 6927c478bd9Sstevel@tonic-gate "won't be brought on line after %d " 6937c478bd9Sstevel@tonic-gate "seconds."), inst->fmri, 6947c478bd9Sstevel@tonic-gate cfg->conn_rate_offline); 6957c478bd9Sstevel@tonic-gate } 6967c478bd9Sstevel@tonic-gate 6977c478bd9Sstevel@tonic-gate } else if (copies_limit_exceeded(inst)) { 6987c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE_COPIES, RERR_RESTART); 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate 7037c478bd9Sstevel@tonic-gate /* 7047c478bd9Sstevel@tonic-gate * Create a socket bound to the instance's configured address. If the 7057c478bd9Sstevel@tonic-gate * bind fails, returns -1, else the fd of the bound socket. 7067c478bd9Sstevel@tonic-gate */ 7077c478bd9Sstevel@tonic-gate static int 708fff9db26Svp create_bound_socket(const instance_t *inst, socket_info_t *sock_info) 7097c478bd9Sstevel@tonic-gate { 7107c478bd9Sstevel@tonic-gate int fd; 7117c478bd9Sstevel@tonic-gate int on = 1; 712fff9db26Svp const char *fmri = inst->fmri; 7137c478bd9Sstevel@tonic-gate rpc_info_t *rpc = sock_info->pr_info.ri; 7147c478bd9Sstevel@tonic-gate const char *proto = sock_info->pr_info.proto; 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate fd = socket(sock_info->local_addr.ss_family, sock_info->type, 7177c478bd9Sstevel@tonic-gate sock_info->protocol); 7187c478bd9Sstevel@tonic-gate if (fd < 0) { 7197c478bd9Sstevel@tonic-gate error_msg(gettext( 7207c478bd9Sstevel@tonic-gate "Socket creation failure for instance %s, proto %s: %s"), 7217c478bd9Sstevel@tonic-gate fmri, proto, strerror(errno)); 7227c478bd9Sstevel@tonic-gate return (-1); 7237c478bd9Sstevel@tonic-gate } 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) == -1) { 7267c478bd9Sstevel@tonic-gate error_msg(gettext("setsockopt SO_REUSEADDR failed for service " 7277c478bd9Sstevel@tonic-gate "instance %s, proto %s: %s"), fmri, proto, strerror(errno)); 7287c478bd9Sstevel@tonic-gate (void) close(fd); 7297c478bd9Sstevel@tonic-gate return (-1); 7307c478bd9Sstevel@tonic-gate } 731*e23de8e2SGary Mills if (inst->config->basic->do_tcp_keepalive && 732*e23de8e2SGary Mills !inst->config->basic->iswait && !inst->config->basic->istlx) { 733*e23de8e2SGary Mills /* set the keepalive option */ 734*e23de8e2SGary Mills if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, 735*e23de8e2SGary Mills sizeof (on)) == -1) { 736*e23de8e2SGary Mills error_msg(gettext("setsockopt SO_KEEPALIVE failed for " 737*e23de8e2SGary Mills "service instance %s, proto %s: %s"), fmri, 738*e23de8e2SGary Mills proto, strerror(errno)); 739*e23de8e2SGary Mills (void) close(fd); 740*e23de8e2SGary Mills return (-1); 741*e23de8e2SGary Mills } 742*e23de8e2SGary Mills } 7437c478bd9Sstevel@tonic-gate if (sock_info->pr_info.v6only) { 7447c478bd9Sstevel@tonic-gate /* restrict socket to IPv6 communications only */ 7457c478bd9Sstevel@tonic-gate if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &on, 7467c478bd9Sstevel@tonic-gate sizeof (on)) == -1) { 7477c478bd9Sstevel@tonic-gate error_msg(gettext("setsockopt IPV6_V6ONLY failed for " 7487c478bd9Sstevel@tonic-gate "service instance %s, proto %s: %s"), fmri, proto, 7497c478bd9Sstevel@tonic-gate strerror(errno)); 7507c478bd9Sstevel@tonic-gate (void) close(fd); 7517c478bd9Sstevel@tonic-gate return (-1); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate if (rpc != NULL) 7567c478bd9Sstevel@tonic-gate SS_SETPORT(sock_info->local_addr, 0); 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate if (bind(fd, (struct sockaddr *)&(sock_info->local_addr), 7597c478bd9Sstevel@tonic-gate SS_ADDRLEN(sock_info->local_addr)) < 0) { 7607c478bd9Sstevel@tonic-gate error_msg(gettext( 7617c478bd9Sstevel@tonic-gate "Failed to bind to the port of service instance %s, " 7627c478bd9Sstevel@tonic-gate "proto %s: %s"), fmri, proto, strerror(errno)); 7637c478bd9Sstevel@tonic-gate (void) close(fd); 7647c478bd9Sstevel@tonic-gate return (-1); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate /* 7687c478bd9Sstevel@tonic-gate * Retrieve and store the address bound to for RPC services. 7697c478bd9Sstevel@tonic-gate */ 7707c478bd9Sstevel@tonic-gate if (rpc != NULL) { 7717c478bd9Sstevel@tonic-gate struct sockaddr_storage ss; 7727c478bd9Sstevel@tonic-gate int ss_size = sizeof (ss); 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate if (getsockname(fd, (struct sockaddr *)&ss, &ss_size) < 0) { 7757c478bd9Sstevel@tonic-gate error_msg(gettext("Failed getsockname for instance %s, " 7767c478bd9Sstevel@tonic-gate "proto %s: %s"), fmri, proto, strerror(errno)); 7777c478bd9Sstevel@tonic-gate (void) close(fd); 7787c478bd9Sstevel@tonic-gate return (-1); 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate (void) memcpy(rpc->netbuf.buf, &ss, 7817c478bd9Sstevel@tonic-gate sizeof (struct sockaddr_storage)); 7827c478bd9Sstevel@tonic-gate rpc->netbuf.len = SS_ADDRLEN(ss); 7837c478bd9Sstevel@tonic-gate rpc->netbuf.maxlen = SS_ADDRLEN(ss); 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate 786fff9db26Svp if (sock_info->type == SOCK_STREAM) { 787fff9db26Svp int qlen = inst->config->basic->conn_backlog; 788fff9db26Svp 789fff9db26Svp debug_msg("Listening for service %s with backlog queue" 790fff9db26Svp " size %d", fmri, qlen); 791fff9db26Svp (void) listen(fd, qlen); 792fff9db26Svp } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate return (fd); 7957c478bd9Sstevel@tonic-gate } 7967c478bd9Sstevel@tonic-gate 7977c478bd9Sstevel@tonic-gate /* 7987c478bd9Sstevel@tonic-gate * Handler registered with the timer queue code to retry the creation 7997c478bd9Sstevel@tonic-gate * of a bound fd. 8007c478bd9Sstevel@tonic-gate */ 8017c478bd9Sstevel@tonic-gate /* ARGSUSED */ 8027c478bd9Sstevel@tonic-gate static void 8037c478bd9Sstevel@tonic-gate retry_bind(iu_tq_t *tq, void *arg) 8047c478bd9Sstevel@tonic-gate { 8057c478bd9Sstevel@tonic-gate instance_t *instance = arg; 8067c478bd9Sstevel@tonic-gate 8077c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 8087c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 8097c478bd9Sstevel@tonic-gate case IIS_ONLINE: 8107c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 8117c478bd9Sstevel@tonic-gate case IIS_IN_ONLINE_METHOD: 8127c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 8137c478bd9Sstevel@tonic-gate break; 8147c478bd9Sstevel@tonic-gate default: 8157c478bd9Sstevel@tonic-gate #ifndef NDEBUG 8167c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:%d: Unknown instance state %d.\n", 8177c478bd9Sstevel@tonic-gate __FILE__, __LINE__, instance->cur_istate); 8187c478bd9Sstevel@tonic-gate #endif 8197c478bd9Sstevel@tonic-gate abort(); 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate instance->bind_timer_id = -1; 8237c478bd9Sstevel@tonic-gate create_bound_fds(instance); 8247c478bd9Sstevel@tonic-gate } 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* 8277c478bd9Sstevel@tonic-gate * For each of the fds for the given instance that are bound, if 'listen' is 8285e2844d4SRenaud Manus * set add them to the poll set, else remove them from it. If proto_name is 8295e2844d4SRenaud Manus * not NULL then apply the change only to this specific protocol endpoint. 8305e2844d4SRenaud Manus * If any additions fail, returns -1, else 0 on success. 8317c478bd9Sstevel@tonic-gate */ 8327c478bd9Sstevel@tonic-gate int 8335e2844d4SRenaud Manus poll_bound_fds(instance_t *instance, boolean_t listen, char *proto_name) 8347c478bd9Sstevel@tonic-gate { 8357c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 8367c478bd9Sstevel@tonic-gate proto_info_t *pi; 8377c478bd9Sstevel@tonic-gate int ret = 0; 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 8407c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 8417c478bd9Sstevel@tonic-gate if (pi->listen_fd != -1) { /* fd bound */ 8425e2844d4SRenaud Manus if (proto_name == NULL || 8435e2844d4SRenaud Manus strcmp(pi->proto, proto_name) == 0) { 8445e2844d4SRenaud Manus if (listen == B_FALSE) { 8455e2844d4SRenaud Manus clear_pollfd(pi->listen_fd); 8465e2844d4SRenaud Manus } else if (set_pollfd(pi->listen_fd, 8475e2844d4SRenaud Manus POLLIN) == -1) { 8485e2844d4SRenaud Manus ret = -1; 8495e2844d4SRenaud Manus } 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate return (ret); 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate 8577c478bd9Sstevel@tonic-gate /* 8587c478bd9Sstevel@tonic-gate * Handle the case were we either fail to create a bound fd or we fail 8597c478bd9Sstevel@tonic-gate * to add a bound fd to the poll set for the given instance. 8607c478bd9Sstevel@tonic-gate */ 8617c478bd9Sstevel@tonic-gate static void 8627c478bd9Sstevel@tonic-gate handle_bind_failure(instance_t *instance) 8637c478bd9Sstevel@tonic-gate { 8647c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate /* 8677c478bd9Sstevel@tonic-gate * We must be being called as a result of a failed poll_bound_fds() 8687c478bd9Sstevel@tonic-gate * as a bind retry is already scheduled. Just return and let it do 8697c478bd9Sstevel@tonic-gate * the work. 8707c478bd9Sstevel@tonic-gate */ 8717c478bd9Sstevel@tonic-gate if (instance->bind_timer_id != -1) 8727c478bd9Sstevel@tonic-gate return; 8737c478bd9Sstevel@tonic-gate 8747c478bd9Sstevel@tonic-gate /* 8757c478bd9Sstevel@tonic-gate * Check if the rebind retries limit is operative and if so, 8767c478bd9Sstevel@tonic-gate * if it has been reached. 8777c478bd9Sstevel@tonic-gate */ 8787c478bd9Sstevel@tonic-gate if (((cfg->bind_fail_interval <= 0) || /* no retries */ 8797c478bd9Sstevel@tonic-gate ((cfg->bind_fail_max >= 0) && /* limit reached */ 8807c478bd9Sstevel@tonic-gate (++instance->bind_fail_count > cfg->bind_fail_max))) || 8817c478bd9Sstevel@tonic-gate ((instance->bind_timer_id = iu_schedule_timer(timer_queue, 8827c478bd9Sstevel@tonic-gate cfg->bind_fail_interval, retry_bind, instance)) == -1)) { 8837c478bd9Sstevel@tonic-gate proto_info_t *pi; 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate instance->bind_fail_count = 0; 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 8887c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 8897c478bd9Sstevel@tonic-gate case IIS_ONLINE: 8907c478bd9Sstevel@tonic-gate /* check if any of the fds are being poll'd upon */ 8917c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 8927c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 8937c478bd9Sstevel@tonic-gate if ((pi->listen_fd != -1) && 8947c478bd9Sstevel@tonic-gate (find_pollfd(pi->listen_fd) != NULL)) 8957c478bd9Sstevel@tonic-gate break; 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate if (pi != NULL) { /* polling on > 0 fds */ 8987c478bd9Sstevel@tonic-gate warn_msg(gettext("Failed to bind on " 8997c478bd9Sstevel@tonic-gate "all protocols for instance %s, " 9007c478bd9Sstevel@tonic-gate "transitioning to degraded"), 9017c478bd9Sstevel@tonic-gate instance->fmri); 9027c478bd9Sstevel@tonic-gate update_state(instance, IIS_DEGRADED, RERR_NONE); 9037c478bd9Sstevel@tonic-gate instance->bind_retries_exceeded = B_TRUE; 9047c478bd9Sstevel@tonic-gate break; 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 9087c478bd9Sstevel@tonic-gate /* 9097c478bd9Sstevel@tonic-gate * In the case we failed the 'bind' because set_pollfd() 9107c478bd9Sstevel@tonic-gate * failed on all bound fds, use the offline handling. 9117c478bd9Sstevel@tonic-gate */ 9127c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 9137c478bd9Sstevel@tonic-gate case IIS_OFFLINE: 9147c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 9157c478bd9Sstevel@tonic-gate error_msg(gettext("Too many bind failures for instance " 9167c478bd9Sstevel@tonic-gate "%s, transitioning to maintenance"), instance->fmri); 9177c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, 9187c478bd9Sstevel@tonic-gate RERR_FAULT); 9197c478bd9Sstevel@tonic-gate break; 9207c478bd9Sstevel@tonic-gate case IIS_IN_ONLINE_METHOD: 9217c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 9227c478bd9Sstevel@tonic-gate warn_msg(gettext("Failed to bind on all " 9237c478bd9Sstevel@tonic-gate "protocols for instance %s, instance will go to " 9247c478bd9Sstevel@tonic-gate "degraded"), instance->fmri); 9257c478bd9Sstevel@tonic-gate /* 9267c478bd9Sstevel@tonic-gate * Set the retries exceeded flag so when the method 9277c478bd9Sstevel@tonic-gate * completes the instance goes to the degraded state. 9287c478bd9Sstevel@tonic-gate */ 9297c478bd9Sstevel@tonic-gate instance->bind_retries_exceeded = B_TRUE; 9307c478bd9Sstevel@tonic-gate break; 9317c478bd9Sstevel@tonic-gate default: 9327c478bd9Sstevel@tonic-gate #ifndef NDEBUG 9337c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9347c478bd9Sstevel@tonic-gate "%s:%d: Unknown instance state %d.\n", 9357c478bd9Sstevel@tonic-gate __FILE__, __LINE__, instance->cur_istate); 9367c478bd9Sstevel@tonic-gate #endif 9377c478bd9Sstevel@tonic-gate abort(); 9387c478bd9Sstevel@tonic-gate } 9397c478bd9Sstevel@tonic-gate } else if (instance->cur_istate == IIS_OFFLINE) { 9407c478bd9Sstevel@tonic-gate /* 9417c478bd9Sstevel@tonic-gate * bind re-scheduled, so if we're offline reflect this in the 9427c478bd9Sstevel@tonic-gate * state. 9437c478bd9Sstevel@tonic-gate */ 9447c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE_BIND, RERR_NONE); 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate } 9477c478bd9Sstevel@tonic-gate 948b823d4c7Sdstaff 949b823d4c7Sdstaff /* 950513ad6b4Sdstaff * Check if two transport protocols for RPC conflict. 951b823d4c7Sdstaff */ 952b823d4c7Sdstaff 953b823d4c7Sdstaff boolean_t 954b823d4c7Sdstaff is_rpc_proto_conflict(const char *proto0, const char *proto1) { 955b823d4c7Sdstaff if (strcmp(proto0, "tcp") == 0) { 956b823d4c7Sdstaff if (strcmp(proto1, "tcp") == 0) 957b823d4c7Sdstaff return (B_TRUE); 958b823d4c7Sdstaff if (strcmp(proto1, "tcp6") == 0) 959b823d4c7Sdstaff return (B_TRUE); 960b823d4c7Sdstaff return (B_FALSE); 961b823d4c7Sdstaff } 962b823d4c7Sdstaff 963b823d4c7Sdstaff if (strcmp(proto0, "tcp6") == 0) { 964b823d4c7Sdstaff if (strcmp(proto1, "tcp") == 0) 965b823d4c7Sdstaff return (B_TRUE); 966b823d4c7Sdstaff if (strcmp(proto1, "tcp6only") == 0) 967b823d4c7Sdstaff return (B_TRUE); 968b823d4c7Sdstaff if (strcmp(proto1, "tcp6") == 0) 969b823d4c7Sdstaff return (B_TRUE); 970b823d4c7Sdstaff return (B_FALSE); 971b823d4c7Sdstaff } 972b823d4c7Sdstaff 973b823d4c7Sdstaff if (strcmp(proto0, "tcp6only") == 0) { 974b823d4c7Sdstaff if (strcmp(proto1, "tcp6only") == 0) 975b823d4c7Sdstaff return (B_TRUE); 976b823d4c7Sdstaff if (strcmp(proto1, "tcp6") == 0) 977b823d4c7Sdstaff return (B_TRUE); 978b823d4c7Sdstaff return (B_FALSE); 979b823d4c7Sdstaff } 980b823d4c7Sdstaff 981b823d4c7Sdstaff if (strcmp(proto0, "udp") == 0) { 982b823d4c7Sdstaff if (strcmp(proto1, "udp") == 0) 983b823d4c7Sdstaff return (B_TRUE); 984b823d4c7Sdstaff if (strcmp(proto1, "udp6") == 0) 985b823d4c7Sdstaff return (B_TRUE); 986b823d4c7Sdstaff return (B_FALSE); 987b823d4c7Sdstaff } 988b823d4c7Sdstaff 989b823d4c7Sdstaff if (strcmp(proto0, "udp6") == 0) { 990b823d4c7Sdstaff 991b823d4c7Sdstaff if (strcmp(proto1, "udp") == 0) 992b823d4c7Sdstaff return (B_TRUE); 993b823d4c7Sdstaff if (strcmp(proto1, "udp6only") == 0) 994b823d4c7Sdstaff return (B_TRUE); 995b823d4c7Sdstaff if (strcmp(proto1, "udp6") == 0) 996b823d4c7Sdstaff return (B_TRUE); 997b823d4c7Sdstaff return (B_FALSE); 998b823d4c7Sdstaff } 999b823d4c7Sdstaff 1000b823d4c7Sdstaff if (strcmp(proto0, "udp6only") == 0) { 1001b823d4c7Sdstaff 1002b823d4c7Sdstaff if (strcmp(proto1, "udp6only") == 0) 1003b823d4c7Sdstaff return (B_TRUE); 1004b823d4c7Sdstaff if (strcmp(proto1, "udp6") == 0) 1005b823d4c7Sdstaff return (B_TRUE); 1006b823d4c7Sdstaff return (0); 1007b823d4c7Sdstaff } 1008b823d4c7Sdstaff 1009b823d4c7Sdstaff /* 1010b823d4c7Sdstaff * If the protocol isn't TCP/IP or UDP/IP assume that it has its own 1011b823d4c7Sdstaff * port namepsace and that conflicts can be detected by literal string 1012b823d4c7Sdstaff * comparison. 1013b823d4c7Sdstaff */ 1014b823d4c7Sdstaff 1015b823d4c7Sdstaff if (strcmp(proto0, proto1)) 1016b823d4c7Sdstaff return (FALSE); 1017b823d4c7Sdstaff 1018b823d4c7Sdstaff return (B_TRUE); 1019b823d4c7Sdstaff } 1020b823d4c7Sdstaff 1021b823d4c7Sdstaff 1022b823d4c7Sdstaff /* 1023b823d4c7Sdstaff * Check if inetd thinks this RPC program number is already registered. 1024b823d4c7Sdstaff * 1025b823d4c7Sdstaff * An RPC protocol conflict occurs if 1026b823d4c7Sdstaff * a) the program numbers are the same and, 1027b823d4c7Sdstaff * b) the version numbers overlap, 1028b823d4c7Sdstaff * c) the protocols (TCP vs UDP vs tic*) are the same. 1029b823d4c7Sdstaff */ 1030b823d4c7Sdstaff 1031b823d4c7Sdstaff boolean_t 1032b823d4c7Sdstaff is_rpc_num_in_use(int rpc_n, char *proto, int lowver, int highver) { 1033b823d4c7Sdstaff instance_t *i; 1034b823d4c7Sdstaff basic_cfg_t *cfg; 1035b823d4c7Sdstaff proto_info_t *pi; 1036b823d4c7Sdstaff 1037b823d4c7Sdstaff for (i = uu_list_first(instance_list); i != NULL; 1038b823d4c7Sdstaff i = uu_list_next(instance_list, i)) { 1039b823d4c7Sdstaff 1040b823d4c7Sdstaff if (i->cur_istate != IIS_ONLINE) 1041b823d4c7Sdstaff continue; 10427778f43aSdstaff cfg = i->config->basic; 1043b823d4c7Sdstaff 1044b823d4c7Sdstaff for (pi = uu_list_first(cfg->proto_list); pi != NULL; 1045b823d4c7Sdstaff pi = uu_list_next(cfg->proto_list, pi)) { 1046b823d4c7Sdstaff 1047b823d4c7Sdstaff if (pi->ri == NULL) 1048b823d4c7Sdstaff continue; 1049b823d4c7Sdstaff if (pi->ri->prognum != rpc_n) 1050b823d4c7Sdstaff continue; 1051513ad6b4Sdstaff if (!is_rpc_proto_conflict(pi->proto, proto)) 1052b823d4c7Sdstaff continue; 1053b823d4c7Sdstaff if ((lowver < pi->ri->lowver && 1054b823d4c7Sdstaff highver < pi->ri->lowver) || 1055b823d4c7Sdstaff (lowver > pi->ri->highver && 1056b823d4c7Sdstaff highver > pi->ri->highver)) 1057b823d4c7Sdstaff continue; 1058b823d4c7Sdstaff return (B_TRUE); 1059b823d4c7Sdstaff } 1060b823d4c7Sdstaff } 1061b823d4c7Sdstaff return (B_FALSE); 1062b823d4c7Sdstaff } 1063b823d4c7Sdstaff 1064b823d4c7Sdstaff 10657c478bd9Sstevel@tonic-gate /* 10667c478bd9Sstevel@tonic-gate * Independent of the transport, for each of the entries in the instance's 10677c478bd9Sstevel@tonic-gate * proto list this function first attempts to create an associated network fd; 10687c478bd9Sstevel@tonic-gate * for RPC services these are then bound to a kernel chosen port and the 10697c478bd9Sstevel@tonic-gate * fd is registered with rpcbind; for non-RPC services the fds are bound 10707c478bd9Sstevel@tonic-gate * to the port associated with the instance's service name. On any successful 10717c478bd9Sstevel@tonic-gate * binds the instance is taken online. Failed binds are handled by 10727c478bd9Sstevel@tonic-gate * handle_bind_failure(). 10737c478bd9Sstevel@tonic-gate */ 10747c478bd9Sstevel@tonic-gate void 10757c478bd9Sstevel@tonic-gate create_bound_fds(instance_t *instance) 10767c478bd9Sstevel@tonic-gate { 10777c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 10787c478bd9Sstevel@tonic-gate boolean_t failure = B_FALSE; 10797c478bd9Sstevel@tonic-gate boolean_t success = B_FALSE; 10807c478bd9Sstevel@tonic-gate proto_info_t *pi; 10817c478bd9Sstevel@tonic-gate 10827c478bd9Sstevel@tonic-gate /* 10837c478bd9Sstevel@tonic-gate * Loop through and try and bind any unbound protos. 10847c478bd9Sstevel@tonic-gate */ 10857c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 10867c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 10877c478bd9Sstevel@tonic-gate if (pi->listen_fd != -1) 10887c478bd9Sstevel@tonic-gate continue; 10897c478bd9Sstevel@tonic-gate if (cfg->istlx) { 1090fff9db26Svp pi->listen_fd = create_bound_endpoint(instance, 10917c478bd9Sstevel@tonic-gate (tlx_info_t *)pi); 10927c478bd9Sstevel@tonic-gate } else { 10937c478bd9Sstevel@tonic-gate /* 10947c478bd9Sstevel@tonic-gate * We cast pi to a void so we can then go on to cast 10957c478bd9Sstevel@tonic-gate * it to a socket_info_t without lint complaining 10967c478bd9Sstevel@tonic-gate * about alignment. This is done because the x86 10977c478bd9Sstevel@tonic-gate * version of lint thinks a lint suppression directive 10987c478bd9Sstevel@tonic-gate * is unnecessary and flags it as such, yet the sparc 10997c478bd9Sstevel@tonic-gate * version complains if it's absent. 11007c478bd9Sstevel@tonic-gate */ 11017c478bd9Sstevel@tonic-gate void *p = pi; 1102fff9db26Svp pi->listen_fd = create_bound_socket(instance, 11037c478bd9Sstevel@tonic-gate (socket_info_t *)p); 11047c478bd9Sstevel@tonic-gate } 11057c478bd9Sstevel@tonic-gate if (pi->listen_fd == -1) { 11067c478bd9Sstevel@tonic-gate failure = B_TRUE; 11077c478bd9Sstevel@tonic-gate continue; 11087c478bd9Sstevel@tonic-gate } 11097c478bd9Sstevel@tonic-gate 11107c478bd9Sstevel@tonic-gate if (pi->ri != NULL) { 1111b823d4c7Sdstaff 1112b823d4c7Sdstaff /* 1113b823d4c7Sdstaff * Don't register the same RPC program number twice. 1114b823d4c7Sdstaff * Doing so silently discards the old service 1115b823d4c7Sdstaff * without causing an error. 1116b823d4c7Sdstaff */ 1117b823d4c7Sdstaff if (is_rpc_num_in_use(pi->ri->prognum, pi->proto, 11187cd7ea0bSrs pi->ri->lowver, pi->ri->highver)) { 1119b823d4c7Sdstaff failure = B_TRUE; 1120b823d4c7Sdstaff close_net_fd(instance, pi->listen_fd); 1121b823d4c7Sdstaff pi->listen_fd = -1; 1122b823d4c7Sdstaff continue; 1123b823d4c7Sdstaff } 1124b823d4c7Sdstaff 11257c478bd9Sstevel@tonic-gate unregister_rpc_service(instance->fmri, pi->ri); 11267c478bd9Sstevel@tonic-gate if (register_rpc_service(instance->fmri, pi->ri) == 11277c478bd9Sstevel@tonic-gate -1) { 11287c478bd9Sstevel@tonic-gate close_net_fd(instance, pi->listen_fd); 11297c478bd9Sstevel@tonic-gate pi->listen_fd = -1; 11307c478bd9Sstevel@tonic-gate failure = B_TRUE; 11317c478bd9Sstevel@tonic-gate continue; 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate } 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate success = B_TRUE; 11367c478bd9Sstevel@tonic-gate } 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 11397c478bd9Sstevel@tonic-gate case IIS_OFFLINE: 11407c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 11417c478bd9Sstevel@tonic-gate /* 11427c478bd9Sstevel@tonic-gate * If we've managed to bind at least one proto lets run the 11437c478bd9Sstevel@tonic-gate * online method, so we can start listening for it. 11447c478bd9Sstevel@tonic-gate */ 11457c478bd9Sstevel@tonic-gate if (success && run_method(instance, IM_ONLINE, NULL) == -1) 11467c478bd9Sstevel@tonic-gate return; /* instance gone to maintenance */ 11477c478bd9Sstevel@tonic-gate break; 11487c478bd9Sstevel@tonic-gate case IIS_ONLINE: 11497c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 11507c478bd9Sstevel@tonic-gate /* 11517c478bd9Sstevel@tonic-gate * We're 'online', so start polling on any bound fds we're 11527c478bd9Sstevel@tonic-gate * currently not. 11537c478bd9Sstevel@tonic-gate */ 11545e2844d4SRenaud Manus if (poll_bound_fds(instance, B_TRUE, NULL) != 0) { 11557c478bd9Sstevel@tonic-gate failure = B_TRUE; 11567c478bd9Sstevel@tonic-gate } else if (!failure) { 11577c478bd9Sstevel@tonic-gate /* 11587c478bd9Sstevel@tonic-gate * We've successfully bound and poll'd upon all protos, 11597c478bd9Sstevel@tonic-gate * so reset the failure count. 11607c478bd9Sstevel@tonic-gate */ 11617c478bd9Sstevel@tonic-gate instance->bind_fail_count = 0; 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate break; 11647c478bd9Sstevel@tonic-gate case IIS_IN_ONLINE_METHOD: 11657c478bd9Sstevel@tonic-gate /* 11667c478bd9Sstevel@tonic-gate * Nothing to do here as the method completion code will start 11677c478bd9Sstevel@tonic-gate * listening for any successfully bound fds. 11687c478bd9Sstevel@tonic-gate */ 11697c478bd9Sstevel@tonic-gate break; 11707c478bd9Sstevel@tonic-gate default: 11717c478bd9Sstevel@tonic-gate #ifndef NDEBUG 11727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:%d: Unknown instance state %d.\n", 11737c478bd9Sstevel@tonic-gate __FILE__, __LINE__, instance->cur_istate); 11747c478bd9Sstevel@tonic-gate #endif 11757c478bd9Sstevel@tonic-gate abort(); 11767c478bd9Sstevel@tonic-gate } 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate if (failure) 11797c478bd9Sstevel@tonic-gate handle_bind_failure(instance); 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate /* 11837c478bd9Sstevel@tonic-gate * Counter to create_bound_fds(), for each of the bound network fds this 11847c478bd9Sstevel@tonic-gate * function unregisters the instance from rpcbind if it's an RPC service, 11857c478bd9Sstevel@tonic-gate * stops listening for new connections for it and then closes the listening fd. 11867c478bd9Sstevel@tonic-gate */ 11877c478bd9Sstevel@tonic-gate static void 11887c478bd9Sstevel@tonic-gate destroy_bound_fds(instance_t *instance) 11897c478bd9Sstevel@tonic-gate { 11907c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 11917c478bd9Sstevel@tonic-gate proto_info_t *pi; 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 11947c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 11957c478bd9Sstevel@tonic-gate if (pi->listen_fd != -1) { 11967c478bd9Sstevel@tonic-gate if (pi->ri != NULL) 11977c478bd9Sstevel@tonic-gate unregister_rpc_service(instance->fmri, pi->ri); 11987c478bd9Sstevel@tonic-gate clear_pollfd(pi->listen_fd); 11997c478bd9Sstevel@tonic-gate close_net_fd(instance, pi->listen_fd); 12007c478bd9Sstevel@tonic-gate pi->listen_fd = -1; 12017c478bd9Sstevel@tonic-gate } 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate /* cancel any bind retries */ 12057c478bd9Sstevel@tonic-gate if (instance->bind_timer_id != -1) 12067c478bd9Sstevel@tonic-gate cancel_bind_timer(instance); 12077c478bd9Sstevel@tonic-gate 12087c478bd9Sstevel@tonic-gate instance->bind_retries_exceeded = B_FALSE; 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate /* 12127c478bd9Sstevel@tonic-gate * Perform %A address expansion and return a pointer to a static string 12137c478bd9Sstevel@tonic-gate * array containing crafted arguments. This expansion is provided for 12147c478bd9Sstevel@tonic-gate * compatibility with 4.2BSD daemons, and as such we've copied the logic of 12157c478bd9Sstevel@tonic-gate * the legacy inetd to maintain this compatibility as much as possible. This 12167c478bd9Sstevel@tonic-gate * logic is a bit scatty, but it dates back at least as far as SunOS 4.x. 12177c478bd9Sstevel@tonic-gate */ 12187c478bd9Sstevel@tonic-gate static char ** 12197c478bd9Sstevel@tonic-gate expand_address(instance_t *inst, const proto_info_t *pi) 12207c478bd9Sstevel@tonic-gate { 12217c478bd9Sstevel@tonic-gate static char addrbuf[sizeof ("ffffffff.65536")]; 12227c478bd9Sstevel@tonic-gate static char *ret[3]; 12237c478bd9Sstevel@tonic-gate instance_cfg_t *cfg = inst->config; 12247c478bd9Sstevel@tonic-gate /* 12257c478bd9Sstevel@tonic-gate * We cast pi to a void so we can then go on to cast it to a 12267c478bd9Sstevel@tonic-gate * socket_info_t without lint complaining about alignment. This 12277c478bd9Sstevel@tonic-gate * is done because the x86 version of lint thinks a lint suppression 12287c478bd9Sstevel@tonic-gate * directive is unnecessary and flags it as such, yet the sparc 12297c478bd9Sstevel@tonic-gate * version complains if it's absent. 12307c478bd9Sstevel@tonic-gate */ 12317c478bd9Sstevel@tonic-gate const void *p = pi; 12327c478bd9Sstevel@tonic-gate 12337c478bd9Sstevel@tonic-gate /* set ret[0] to the basename of exec path */ 12347c478bd9Sstevel@tonic-gate if ((ret[0] = strrchr(cfg->methods[IM_START]->exec_path, '/')) 12357c478bd9Sstevel@tonic-gate != NULL) { 12367c478bd9Sstevel@tonic-gate ret[0]++; 12377c478bd9Sstevel@tonic-gate } else { 12387c478bd9Sstevel@tonic-gate ret[0] = cfg->methods[IM_START]->exec_path; 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate 12417c478bd9Sstevel@tonic-gate if (!cfg->basic->istlx && 12427c478bd9Sstevel@tonic-gate (((socket_info_t *)p)->type == SOCK_DGRAM)) { 12437c478bd9Sstevel@tonic-gate ret[1] = NULL; 12447c478bd9Sstevel@tonic-gate } else { 12457c478bd9Sstevel@tonic-gate addrbuf[0] = '\0'; 12467c478bd9Sstevel@tonic-gate if (!cfg->basic->iswait && 12477c478bd9Sstevel@tonic-gate (inst->remote_addr.ss_family == AF_INET)) { 12487c478bd9Sstevel@tonic-gate struct sockaddr_in *sp; 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate sp = (struct sockaddr_in *)&(inst->remote_addr); 12517c478bd9Sstevel@tonic-gate (void) snprintf(addrbuf, sizeof (addrbuf), "%x.%hu", 12527c478bd9Sstevel@tonic-gate ntohl(sp->sin_addr.s_addr), ntohs(sp->sin_port)); 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate ret[1] = addrbuf; 12557c478bd9Sstevel@tonic-gate ret[2] = NULL; 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate return (ret); 12597c478bd9Sstevel@tonic-gate } 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate /* 12627c478bd9Sstevel@tonic-gate * Returns the state associated with the supplied method being run for an 12637c478bd9Sstevel@tonic-gate * instance. 12647c478bd9Sstevel@tonic-gate */ 12657c478bd9Sstevel@tonic-gate static internal_inst_state_t 12667c478bd9Sstevel@tonic-gate get_method_state(instance_method_t method) 12677c478bd9Sstevel@tonic-gate { 12687c478bd9Sstevel@tonic-gate state_info_t *sip; 12697c478bd9Sstevel@tonic-gate 12707c478bd9Sstevel@tonic-gate for (sip = states; sip->istate != IIS_NONE; sip++) { 12717c478bd9Sstevel@tonic-gate if (sip->method_running == method) 12727c478bd9Sstevel@tonic-gate break; 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate assert(sip->istate != IIS_NONE); 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate return (sip->istate); 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate /* 12807c478bd9Sstevel@tonic-gate * Store the method's PID and CID in the repository. If the store fails 12817c478bd9Sstevel@tonic-gate * we ignore it and just drive on. 12827c478bd9Sstevel@tonic-gate */ 12837c478bd9Sstevel@tonic-gate static void 12847c478bd9Sstevel@tonic-gate add_method_ids(instance_t *ins, pid_t pid, ctid_t cid, instance_method_t mthd) 12857c478bd9Sstevel@tonic-gate { 12867c478bd9Sstevel@tonic-gate if (cid != -1) 128794501b61Sskamm (void) add_remove_contract(ins, B_TRUE, cid); 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate if (mthd == IM_START) { 12907c478bd9Sstevel@tonic-gate if (add_rep_val(ins->start_pids, (int64_t)pid) == 0) { 12917c478bd9Sstevel@tonic-gate (void) store_rep_vals(ins->start_pids, ins->fmri, 12927c478bd9Sstevel@tonic-gate PR_NAME_START_PIDS); 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate } else { 12957c478bd9Sstevel@tonic-gate if (add_rep_val(ins->non_start_pid, (int64_t)pid) == 0) { 12967c478bd9Sstevel@tonic-gate (void) store_rep_vals(ins->non_start_pid, ins->fmri, 12977c478bd9Sstevel@tonic-gate PR_NAME_NON_START_PID); 12987c478bd9Sstevel@tonic-gate } 12997c478bd9Sstevel@tonic-gate } 13007c478bd9Sstevel@tonic-gate } 13017c478bd9Sstevel@tonic-gate 13027c478bd9Sstevel@tonic-gate /* 13037c478bd9Sstevel@tonic-gate * Remove the method's PID and CID from the repository. If the removal 13047c478bd9Sstevel@tonic-gate * fails we ignore it and drive on. 13057c478bd9Sstevel@tonic-gate */ 13067c478bd9Sstevel@tonic-gate void 13077c478bd9Sstevel@tonic-gate remove_method_ids(instance_t *inst, pid_t pid, ctid_t cid, 13087c478bd9Sstevel@tonic-gate instance_method_t mthd) 13097c478bd9Sstevel@tonic-gate { 13107c478bd9Sstevel@tonic-gate if (cid != -1) 131194501b61Sskamm (void) add_remove_contract(inst, B_FALSE, cid); 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate if (mthd == IM_START) { 13147c478bd9Sstevel@tonic-gate remove_rep_val(inst->start_pids, (int64_t)pid); 13157c478bd9Sstevel@tonic-gate (void) store_rep_vals(inst->start_pids, inst->fmri, 13167c478bd9Sstevel@tonic-gate PR_NAME_START_PIDS); 13177c478bd9Sstevel@tonic-gate } else { 13187c478bd9Sstevel@tonic-gate remove_rep_val(inst->non_start_pid, (int64_t)pid); 13197c478bd9Sstevel@tonic-gate (void) store_rep_vals(inst->non_start_pid, inst->fmri, 13207c478bd9Sstevel@tonic-gate PR_NAME_NON_START_PID); 13217c478bd9Sstevel@tonic-gate } 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate 13247c478bd9Sstevel@tonic-gate static instance_t * 13257c478bd9Sstevel@tonic-gate create_instance(const char *fmri) 13267c478bd9Sstevel@tonic-gate { 13277c478bd9Sstevel@tonic-gate instance_t *ret; 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate if (((ret = calloc(1, sizeof (instance_t))) == NULL) || 13307c478bd9Sstevel@tonic-gate ((ret->fmri = strdup(fmri)) == NULL)) 13317c478bd9Sstevel@tonic-gate goto alloc_fail; 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate ret->conn_fd = -1; 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate ret->copies = 0; 13367c478bd9Sstevel@tonic-gate 13377c478bd9Sstevel@tonic-gate ret->conn_rate_count = 0; 13387c478bd9Sstevel@tonic-gate ret->fail_rate_count = 0; 13397c478bd9Sstevel@tonic-gate ret->bind_fail_count = 0; 13407c478bd9Sstevel@tonic-gate 13417c478bd9Sstevel@tonic-gate if (((ret->non_start_pid = create_rep_val_list()) == NULL) || 134294501b61Sskamm ((ret->start_pids = create_rep_val_list()) == NULL) || 134394501b61Sskamm ((ret->start_ctids = create_rep_val_list()) == NULL)) 13447c478bd9Sstevel@tonic-gate goto alloc_fail; 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate ret->cur_istate = IIS_NONE; 13477c478bd9Sstevel@tonic-gate ret->next_istate = IIS_NONE; 13487c478bd9Sstevel@tonic-gate 13497c478bd9Sstevel@tonic-gate if (((ret->cur_istate_rep = create_rep_val_list()) == NULL) || 13507c478bd9Sstevel@tonic-gate ((ret->next_istate_rep = create_rep_val_list()) == NULL)) 13517c478bd9Sstevel@tonic-gate goto alloc_fail; 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate ret->config = NULL; 13547c478bd9Sstevel@tonic-gate ret->new_config = NULL; 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate ret->timer_id = -1; 13577c478bd9Sstevel@tonic-gate ret->bind_timer_id = -1; 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate ret->disable_req = B_FALSE; 13607c478bd9Sstevel@tonic-gate ret->maintenance_req = B_FALSE; 13617c478bd9Sstevel@tonic-gate ret->conn_rate_exceeded = B_FALSE; 13627c478bd9Sstevel@tonic-gate ret->bind_retries_exceeded = B_FALSE; 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate ret->pending_rst_event = RESTARTER_EVENT_TYPE_INVALID; 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate return (ret); 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate alloc_fail: 13697c478bd9Sstevel@tonic-gate error_msg(strerror(errno)); 13707c478bd9Sstevel@tonic-gate destroy_instance(ret); 13717c478bd9Sstevel@tonic-gate return (NULL); 13727c478bd9Sstevel@tonic-gate } 13737c478bd9Sstevel@tonic-gate 13747c478bd9Sstevel@tonic-gate static void 13757c478bd9Sstevel@tonic-gate destroy_instance(instance_t *inst) 13767c478bd9Sstevel@tonic-gate { 13777c478bd9Sstevel@tonic-gate if (inst == NULL) 13787c478bd9Sstevel@tonic-gate return; 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate destroy_instance_cfg(inst->config); 13817c478bd9Sstevel@tonic-gate destroy_instance_cfg(inst->new_config); 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate destroy_rep_val_list(inst->cur_istate_rep); 13847c478bd9Sstevel@tonic-gate destroy_rep_val_list(inst->next_istate_rep); 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate destroy_rep_val_list(inst->start_pids); 13877c478bd9Sstevel@tonic-gate destroy_rep_val_list(inst->non_start_pid); 138894501b61Sskamm destroy_rep_val_list(inst->start_ctids); 13897c478bd9Sstevel@tonic-gate 13907c478bd9Sstevel@tonic-gate free(inst->fmri); 13917c478bd9Sstevel@tonic-gate 13927c478bd9Sstevel@tonic-gate free(inst); 13937c478bd9Sstevel@tonic-gate } 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate /* 13967c478bd9Sstevel@tonic-gate * Retrieves the current and next states internal states. Returns 0 on success, 13977c478bd9Sstevel@tonic-gate * else returns one of the following on error: 13987c478bd9Sstevel@tonic-gate * SCF_ERROR_NO_MEMORY if memory allocation failed. 13997c478bd9Sstevel@tonic-gate * SCF_ERROR_CONNECTION_BROKEN if the connection to the repository was broken. 14007c478bd9Sstevel@tonic-gate * SCF_ERROR_TYPE_MISMATCH if the property was of an unexpected type. 14017c478bd9Sstevel@tonic-gate * SCF_ERROR_NO_RESOURCES if the server doesn't have adequate resources. 14027c478bd9Sstevel@tonic-gate * SCF_ERROR_NO_SERVER if the server isn't running. 14037c478bd9Sstevel@tonic-gate */ 14047c478bd9Sstevel@tonic-gate static scf_error_t 14057c478bd9Sstevel@tonic-gate retrieve_instance_state(instance_t *inst) 14067c478bd9Sstevel@tonic-gate { 14077c478bd9Sstevel@tonic-gate scf_error_t ret; 14087c478bd9Sstevel@tonic-gate 14097c478bd9Sstevel@tonic-gate /* retrieve internal states */ 14107c478bd9Sstevel@tonic-gate if (((ret = retrieve_rep_vals(inst->cur_istate_rep, inst->fmri, 14117c478bd9Sstevel@tonic-gate PR_NAME_CUR_INT_STATE)) != 0) || 14127c478bd9Sstevel@tonic-gate ((ret = retrieve_rep_vals(inst->next_istate_rep, inst->fmri, 14137c478bd9Sstevel@tonic-gate PR_NAME_NEXT_INT_STATE)) != 0)) { 14147c478bd9Sstevel@tonic-gate if (ret != SCF_ERROR_NOT_FOUND) { 14157c478bd9Sstevel@tonic-gate error_msg(gettext( 14167c478bd9Sstevel@tonic-gate "Failed to read state of instance %s: %s"), 14177c478bd9Sstevel@tonic-gate inst->fmri, scf_strerror(scf_error())); 14187c478bd9Sstevel@tonic-gate return (ret); 14197c478bd9Sstevel@tonic-gate } 14207c478bd9Sstevel@tonic-gate 14217c478bd9Sstevel@tonic-gate debug_msg("instance with no previous int state - " 14227c478bd9Sstevel@tonic-gate "setting state to uninitialized"); 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate if ((set_single_rep_val(inst->cur_istate_rep, 14257c478bd9Sstevel@tonic-gate (int64_t)IIS_UNINITIALIZED) == -1) || 14267c478bd9Sstevel@tonic-gate (set_single_rep_val(inst->next_istate_rep, 14277c478bd9Sstevel@tonic-gate (int64_t)IIS_NONE) == -1)) { 14287c478bd9Sstevel@tonic-gate return (SCF_ERROR_NO_MEMORY); 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate } 14317c478bd9Sstevel@tonic-gate 14327c478bd9Sstevel@tonic-gate /* update convenience states */ 14337c478bd9Sstevel@tonic-gate inst->cur_istate = get_single_rep_val(inst->cur_istate_rep); 14347c478bd9Sstevel@tonic-gate inst->next_istate = get_single_rep_val(inst->next_istate_rep); 14357c478bd9Sstevel@tonic-gate return (0); 14367c478bd9Sstevel@tonic-gate } 14377c478bd9Sstevel@tonic-gate 14387c478bd9Sstevel@tonic-gate /* 14397c478bd9Sstevel@tonic-gate * Retrieve stored process ids and register each of them so we process their 14407c478bd9Sstevel@tonic-gate * termination. 14417c478bd9Sstevel@tonic-gate */ 14427c478bd9Sstevel@tonic-gate static int 14437c478bd9Sstevel@tonic-gate retrieve_method_pids(instance_t *inst) 14447c478bd9Sstevel@tonic-gate { 14457c478bd9Sstevel@tonic-gate rep_val_t *rv; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate switch (retrieve_rep_vals(inst->start_pids, inst->fmri, 14487c478bd9Sstevel@tonic-gate PR_NAME_START_PIDS)) { 14497c478bd9Sstevel@tonic-gate case 0: 14507c478bd9Sstevel@tonic-gate break; 14517c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 14527c478bd9Sstevel@tonic-gate return (0); 14537c478bd9Sstevel@tonic-gate default: 14547c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to retrieve the start pids of " 14557c478bd9Sstevel@tonic-gate "instance %s from repository: %s"), inst->fmri, 14567c478bd9Sstevel@tonic-gate scf_strerror(scf_error())); 14577c478bd9Sstevel@tonic-gate return (-1); 14587c478bd9Sstevel@tonic-gate } 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate rv = uu_list_first(inst->start_pids); 14617c478bd9Sstevel@tonic-gate while (rv != NULL) { 14627c478bd9Sstevel@tonic-gate if (register_method(inst, (pid_t)rv->val, (ctid_t)-1, 14635e2844d4SRenaud Manus IM_START, NULL) == 0) { 14647c478bd9Sstevel@tonic-gate inst->copies++; 14657c478bd9Sstevel@tonic-gate rv = uu_list_next(inst->start_pids, rv); 14667c478bd9Sstevel@tonic-gate } else if (errno == ENOENT) { 14677c478bd9Sstevel@tonic-gate pid_t pid = (pid_t)rv->val; 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate /* 14707c478bd9Sstevel@tonic-gate * The process must have already terminated. Remove 14717c478bd9Sstevel@tonic-gate * it from the list. 14727c478bd9Sstevel@tonic-gate */ 14737c478bd9Sstevel@tonic-gate rv = uu_list_next(inst->start_pids, rv); 14747c478bd9Sstevel@tonic-gate remove_rep_val(inst->start_pids, pid); 14757c478bd9Sstevel@tonic-gate } else { 14767c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to listen for the completion " 14777c478bd9Sstevel@tonic-gate "of %s method of instance %s"), START_METHOD_NAME, 14787c478bd9Sstevel@tonic-gate inst->fmri); 14797c478bd9Sstevel@tonic-gate rv = uu_list_next(inst->start_pids, rv); 14807c478bd9Sstevel@tonic-gate } 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate /* synch the repository pid list to remove any terminated pids */ 14847c478bd9Sstevel@tonic-gate (void) store_rep_vals(inst->start_pids, inst->fmri, PR_NAME_START_PIDS); 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate return (0); 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate 14897c478bd9Sstevel@tonic-gate /* 14907c478bd9Sstevel@tonic-gate * Remove the passed instance from inetd control. 14917c478bd9Sstevel@tonic-gate */ 14927c478bd9Sstevel@tonic-gate static void 14937c478bd9Sstevel@tonic-gate remove_instance(instance_t *instance) 14947c478bd9Sstevel@tonic-gate { 14957c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 14967c478bd9Sstevel@tonic-gate case IIS_ONLINE: 14977c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 14987c478bd9Sstevel@tonic-gate /* stop listening for network connections */ 14997c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 15007c478bd9Sstevel@tonic-gate break; 15017c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 15027c478bd9Sstevel@tonic-gate cancel_bind_timer(instance); 15037c478bd9Sstevel@tonic-gate break; 15047c478bd9Sstevel@tonic-gate case IIS_OFFLINE_CONRATE: 15057c478bd9Sstevel@tonic-gate cancel_inst_timer(instance); 15067c478bd9Sstevel@tonic-gate break; 15077c478bd9Sstevel@tonic-gate } 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate /* stop listening for terminated methods */ 15107c478bd9Sstevel@tonic-gate unregister_instance_methods(instance); 15117c478bd9Sstevel@tonic-gate 15127c478bd9Sstevel@tonic-gate uu_list_remove(instance_list, instance); 15137c478bd9Sstevel@tonic-gate destroy_instance(instance); 15147c478bd9Sstevel@tonic-gate } 15157c478bd9Sstevel@tonic-gate 15167c478bd9Sstevel@tonic-gate /* 15177c478bd9Sstevel@tonic-gate * Refresh the configuration of instance 'inst'. This method gets called as 15187c478bd9Sstevel@tonic-gate * a result of a refresh event for the instance from the master restarter, so 15197c478bd9Sstevel@tonic-gate * we can rely upon the instance's running snapshot having been updated from 15207c478bd9Sstevel@tonic-gate * its configuration snapshot. 15217c478bd9Sstevel@tonic-gate */ 15227c478bd9Sstevel@tonic-gate void 15237c478bd9Sstevel@tonic-gate refresh_instance(instance_t *inst) 15247c478bd9Sstevel@tonic-gate { 15257c478bd9Sstevel@tonic-gate instance_cfg_t *cfg; 15267c478bd9Sstevel@tonic-gate 15277c478bd9Sstevel@tonic-gate switch (inst->cur_istate) { 15287c478bd9Sstevel@tonic-gate case IIS_MAINTENANCE: 15297c478bd9Sstevel@tonic-gate case IIS_DISABLED: 15307c478bd9Sstevel@tonic-gate case IIS_UNINITIALIZED: 15317c478bd9Sstevel@tonic-gate /* 15327c478bd9Sstevel@tonic-gate * Ignore any possible changes, we'll re-read the configuration 15337c478bd9Sstevel@tonic-gate * automatically when we exit these states. 15347c478bd9Sstevel@tonic-gate */ 15357c478bd9Sstevel@tonic-gate break; 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate case IIS_OFFLINE_COPIES: 15387c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 15397c478bd9Sstevel@tonic-gate case IIS_OFFLINE: 15407c478bd9Sstevel@tonic-gate case IIS_OFFLINE_CONRATE: 15417c478bd9Sstevel@tonic-gate destroy_instance_cfg(inst->config); 15427c478bd9Sstevel@tonic-gate if ((inst->config = read_instance_cfg(inst->fmri)) == NULL) { 15437c478bd9Sstevel@tonic-gate log_invalid_cfg(inst->fmri); 15447c478bd9Sstevel@tonic-gate if (inst->cur_istate == IIS_OFFLINE_BIND) { 15457c478bd9Sstevel@tonic-gate cancel_bind_timer(inst); 15467c478bd9Sstevel@tonic-gate } else if (inst->cur_istate == IIS_OFFLINE_CONRATE) { 15477c478bd9Sstevel@tonic-gate cancel_inst_timer(inst); 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate update_state(inst, IIS_MAINTENANCE, RERR_FAULT); 15507c478bd9Sstevel@tonic-gate } else { 15517c478bd9Sstevel@tonic-gate switch (inst->cur_istate) { 15527c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 15537c478bd9Sstevel@tonic-gate if (copies_limit_exceeded(inst)) { 15547c478bd9Sstevel@tonic-gate /* Cancel scheduled bind retries. */ 15557c478bd9Sstevel@tonic-gate cancel_bind_timer(inst); 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate /* 15587c478bd9Sstevel@tonic-gate * Take the instance to the copies 15597c478bd9Sstevel@tonic-gate * offline state, via the offline 15607c478bd9Sstevel@tonic-gate * state. 15617c478bd9Sstevel@tonic-gate */ 15627c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE, 15637c478bd9Sstevel@tonic-gate RERR_RESTART); 15647c478bd9Sstevel@tonic-gate process_offline_inst(inst); 15657c478bd9Sstevel@tonic-gate } 15667c478bd9Sstevel@tonic-gate break; 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate case IIS_OFFLINE: 15697c478bd9Sstevel@tonic-gate process_offline_inst(inst); 15707c478bd9Sstevel@tonic-gate break; 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate case IIS_OFFLINE_CONRATE: 15737c478bd9Sstevel@tonic-gate /* 15747c478bd9Sstevel@tonic-gate * Since we're already in a DOS state, 15757c478bd9Sstevel@tonic-gate * don't bother evaluating the copies 15767c478bd9Sstevel@tonic-gate * limit. This will be evaluated when 15777c478bd9Sstevel@tonic-gate * we leave this state in 15787c478bd9Sstevel@tonic-gate * process_offline_inst(). 15797c478bd9Sstevel@tonic-gate */ 15807c478bd9Sstevel@tonic-gate break; 15817c478bd9Sstevel@tonic-gate 15827c478bd9Sstevel@tonic-gate case IIS_OFFLINE_COPIES: 15837c478bd9Sstevel@tonic-gate /* 15847c478bd9Sstevel@tonic-gate * Check if the copies limit has been increased 15857c478bd9Sstevel@tonic-gate * above the current count. 15867c478bd9Sstevel@tonic-gate */ 15877c478bd9Sstevel@tonic-gate if (!copies_limit_exceeded(inst)) { 15887c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE, 15897c478bd9Sstevel@tonic-gate RERR_RESTART); 15907c478bd9Sstevel@tonic-gate process_offline_inst(inst); 15917c478bd9Sstevel@tonic-gate } 15927c478bd9Sstevel@tonic-gate break; 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate default: 15957c478bd9Sstevel@tonic-gate assert(0); 15967c478bd9Sstevel@tonic-gate } 15977c478bd9Sstevel@tonic-gate } 15987c478bd9Sstevel@tonic-gate break; 15997c478bd9Sstevel@tonic-gate 16007c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 16017c478bd9Sstevel@tonic-gate case IIS_ONLINE: 16027c478bd9Sstevel@tonic-gate if ((cfg = read_instance_cfg(inst->fmri)) != NULL) { 16037c478bd9Sstevel@tonic-gate instance_cfg_t *ocfg = inst->config; 16047c478bd9Sstevel@tonic-gate 16057c478bd9Sstevel@tonic-gate /* 16067c478bd9Sstevel@tonic-gate * Try to avoid the overhead of taking an instance 16077c478bd9Sstevel@tonic-gate * offline and back on again. We do this by limiting 16087c478bd9Sstevel@tonic-gate * this behavior to two eventualities: 16097c478bd9Sstevel@tonic-gate * - there needs to be a re-bind to listen on behalf 16107c478bd9Sstevel@tonic-gate * of the instance with its new configuration. This 16117c478bd9Sstevel@tonic-gate * could be because for example its service has been 16127c478bd9Sstevel@tonic-gate * associated with a different port, or because the 16137c478bd9Sstevel@tonic-gate * v6only protocol option has been newly applied to 16147c478bd9Sstevel@tonic-gate * the instance. 16157c478bd9Sstevel@tonic-gate * - one or both of the start or online methods of the 16167c478bd9Sstevel@tonic-gate * instance have changed in the new configuration. 16177c478bd9Sstevel@tonic-gate * Without taking the instance offline when the 16187c478bd9Sstevel@tonic-gate * start method changed the instance may be running 16197c478bd9Sstevel@tonic-gate * with unwanted parameters (or event an unwanted 16207c478bd9Sstevel@tonic-gate * binary); and without taking the instance offline 16217c478bd9Sstevel@tonic-gate * if its online method was to change, some part of 16227c478bd9Sstevel@tonic-gate * its running environment may have changed and would 16237c478bd9Sstevel@tonic-gate * not be picked up until the instance next goes 16247c478bd9Sstevel@tonic-gate * offline for another reason. 16257c478bd9Sstevel@tonic-gate */ 16267c478bd9Sstevel@tonic-gate if ((!bind_config_equal(ocfg->basic, cfg->basic)) || 16277c478bd9Sstevel@tonic-gate !method_info_equal(ocfg->methods[IM_ONLINE], 16287c478bd9Sstevel@tonic-gate cfg->methods[IM_ONLINE]) || 16297c478bd9Sstevel@tonic-gate !method_info_equal(ocfg->methods[IM_START], 16307c478bd9Sstevel@tonic-gate cfg->methods[IM_START])) { 16317c478bd9Sstevel@tonic-gate destroy_bound_fds(inst); 16327c478bd9Sstevel@tonic-gate 16337c478bd9Sstevel@tonic-gate assert(inst->new_config == NULL); 16347c478bd9Sstevel@tonic-gate inst->new_config = cfg; 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate (void) run_method(inst, IM_OFFLINE, NULL); 16377c478bd9Sstevel@tonic-gate } else { /* no bind config / method changes */ 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate /* 16407c478bd9Sstevel@tonic-gate * swap the proto list over from the old 16417c478bd9Sstevel@tonic-gate * configuration to the new, so we retain 16427c478bd9Sstevel@tonic-gate * our set of network fds. 16437c478bd9Sstevel@tonic-gate */ 16447c478bd9Sstevel@tonic-gate destroy_proto_list(cfg->basic); 16457c478bd9Sstevel@tonic-gate cfg->basic->proto_list = 16467c478bd9Sstevel@tonic-gate ocfg->basic->proto_list; 16477c478bd9Sstevel@tonic-gate ocfg->basic->proto_list = NULL; 16487c478bd9Sstevel@tonic-gate destroy_instance_cfg(ocfg); 16497c478bd9Sstevel@tonic-gate inst->config = cfg; 16507c478bd9Sstevel@tonic-gate 16517c478bd9Sstevel@tonic-gate /* re-evaluate copies limits based on new cfg */ 16527c478bd9Sstevel@tonic-gate if (copies_limit_exceeded(inst)) { 16537c478bd9Sstevel@tonic-gate destroy_bound_fds(inst); 16547c478bd9Sstevel@tonic-gate (void) run_method(inst, IM_OFFLINE, 16557c478bd9Sstevel@tonic-gate NULL); 16567c478bd9Sstevel@tonic-gate } else { 16577c478bd9Sstevel@tonic-gate /* 16587c478bd9Sstevel@tonic-gate * Since the instance isn't being 16597c478bd9Sstevel@tonic-gate * taken offline, where we assume it 16607c478bd9Sstevel@tonic-gate * would pick-up any configuration 16617c478bd9Sstevel@tonic-gate * changes automatically when it goes 16627c478bd9Sstevel@tonic-gate * back online, run its refresh method 16637c478bd9Sstevel@tonic-gate * to allow it to pick-up any changes 16647c478bd9Sstevel@tonic-gate * whilst still online. 16657c478bd9Sstevel@tonic-gate */ 16667c478bd9Sstevel@tonic-gate (void) run_method(inst, IM_REFRESH, 16677c478bd9Sstevel@tonic-gate NULL); 16687c478bd9Sstevel@tonic-gate } 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate } else { 16717c478bd9Sstevel@tonic-gate log_invalid_cfg(inst->fmri); 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate destroy_bound_fds(inst); 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate inst->maintenance_req = B_TRUE; 16767c478bd9Sstevel@tonic-gate (void) run_method(inst, IM_OFFLINE, NULL); 16777c478bd9Sstevel@tonic-gate } 16787c478bd9Sstevel@tonic-gate break; 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate default: 16817c478bd9Sstevel@tonic-gate debug_msg("Unhandled current state %d for instance in " 16827c478bd9Sstevel@tonic-gate "refresh_instance", inst->cur_istate); 16837c478bd9Sstevel@tonic-gate assert(0); 16847c478bd9Sstevel@tonic-gate } 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate 16877c478bd9Sstevel@tonic-gate /* 16887c478bd9Sstevel@tonic-gate * Called by process_restarter_event() to handle a restarter event for an 16897c478bd9Sstevel@tonic-gate * instance. 16907c478bd9Sstevel@tonic-gate */ 16917c478bd9Sstevel@tonic-gate static void 16927c478bd9Sstevel@tonic-gate handle_restarter_event(instance_t *instance, restarter_event_type_t event, 16937c478bd9Sstevel@tonic-gate boolean_t send_ack) 16947c478bd9Sstevel@tonic-gate { 16957c478bd9Sstevel@tonic-gate switch (event) { 16968977779cSvp case RESTARTER_EVENT_TYPE_ADD_INSTANCE: 16978977779cSvp /* 16988977779cSvp * When startd restarts, it sends _ADD_INSTANCE to delegated 16998977779cSvp * restarters for all those services managed by them. We should 17008977779cSvp * acknowledge this event, as startd's graph needs to be updated 17018977779cSvp * about the current state of the service, when startd is 17028977779cSvp * restarting. 17038977779cSvp * update_state() is ok to be called here, as commands for 17048977779cSvp * instances in transition are deferred by 17058977779cSvp * process_restarter_event(). 17068977779cSvp */ 17078977779cSvp update_state(instance, instance->cur_istate, RERR_NONE); 17088977779cSvp goto done; 17097c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_REFRESH: 17107c478bd9Sstevel@tonic-gate refresh_instance(instance); 17117c478bd9Sstevel@tonic-gate goto done; 17128977779cSvp case RESTARTER_EVENT_TYPE_ADMIN_RESTART: 17138977779cSvp /* 17148977779cSvp * We've got a restart event, so if the instance is online 17158977779cSvp * in any way initiate taking it offline, and rely upon 17168977779cSvp * our restarter to send us an online event to bring 17178977779cSvp * it back online. 17188977779cSvp */ 17198977779cSvp switch (instance->cur_istate) { 17208977779cSvp case IIS_ONLINE: 17218977779cSvp case IIS_DEGRADED: 17228977779cSvp destroy_bound_fds(instance); 17238977779cSvp (void) run_method(instance, IM_OFFLINE, NULL); 17248977779cSvp } 17258977779cSvp goto done; 17267c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_REMOVE_INSTANCE: 17277c478bd9Sstevel@tonic-gate remove_instance(instance); 17287c478bd9Sstevel@tonic-gate goto done; 17297c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_STOP: 17307c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 17317c478bd9Sstevel@tonic-gate case IIS_OFFLINE_CONRATE: 17327c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 17337c478bd9Sstevel@tonic-gate case IIS_OFFLINE_COPIES: 17347c478bd9Sstevel@tonic-gate /* 17357c478bd9Sstevel@tonic-gate * inetd must be closing down as we wouldn't get this 17367c478bd9Sstevel@tonic-gate * event in one of these states from the master 17377c478bd9Sstevel@tonic-gate * restarter. Take the instance to the offline resting 17387c478bd9Sstevel@tonic-gate * state. 17397c478bd9Sstevel@tonic-gate */ 17407c478bd9Sstevel@tonic-gate if (instance->cur_istate == IIS_OFFLINE_BIND) { 17417c478bd9Sstevel@tonic-gate cancel_bind_timer(instance); 17427c478bd9Sstevel@tonic-gate } else if (instance->cur_istate == 17437c478bd9Sstevel@tonic-gate IIS_OFFLINE_CONRATE) { 17447c478bd9Sstevel@tonic-gate cancel_inst_timer(instance); 17457c478bd9Sstevel@tonic-gate } 17467c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, RERR_RESTART); 17477c478bd9Sstevel@tonic-gate goto done; 17487c478bd9Sstevel@tonic-gate } 17497c478bd9Sstevel@tonic-gate break; 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate 17527c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 17537c478bd9Sstevel@tonic-gate case IIS_OFFLINE: 17547c478bd9Sstevel@tonic-gate switch (event) { 17557c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_START: 17567c478bd9Sstevel@tonic-gate /* 17577c478bd9Sstevel@tonic-gate * Dependencies are met, let's take the service online. 17587c478bd9Sstevel@tonic-gate * Only try and bind for a wait type service if 17597c478bd9Sstevel@tonic-gate * no process is running on its behalf. Otherwise, just 17607c478bd9Sstevel@tonic-gate * mark the service online and binding will be attempted 17617c478bd9Sstevel@tonic-gate * when the process exits. 17627c478bd9Sstevel@tonic-gate */ 17637c478bd9Sstevel@tonic-gate if (!(instance->config->basic->iswait && 17647c478bd9Sstevel@tonic-gate (uu_list_first(instance->start_pids) != NULL))) { 17657c478bd9Sstevel@tonic-gate create_bound_fds(instance); 17667c478bd9Sstevel@tonic-gate } else { 17677c478bd9Sstevel@tonic-gate update_state(instance, IIS_ONLINE, RERR_NONE); 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate break; 17707c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 17717c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DISABLE: 17727c478bd9Sstevel@tonic-gate /* 17737c478bd9Sstevel@tonic-gate * The instance should be disabled, so run the 17747c478bd9Sstevel@tonic-gate * instance's disabled method that will do the work 17757c478bd9Sstevel@tonic-gate * to take it there. 17767c478bd9Sstevel@tonic-gate */ 17777c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_DISABLE, NULL); 17787c478bd9Sstevel@tonic-gate break; 17797c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 17807c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 17817c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 17827c478bd9Sstevel@tonic-gate /* 17837c478bd9Sstevel@tonic-gate * The master restarter has requested the instance 17847c478bd9Sstevel@tonic-gate * go to maintenance; since we're already offline 17857c478bd9Sstevel@tonic-gate * just update the state to the maintenance state. 17867c478bd9Sstevel@tonic-gate */ 17877c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_RESTART); 17887c478bd9Sstevel@tonic-gate break; 17897c478bd9Sstevel@tonic-gate } 17907c478bd9Sstevel@tonic-gate break; 17917c478bd9Sstevel@tonic-gate 17927c478bd9Sstevel@tonic-gate case IIS_OFFLINE_BIND: 17937c478bd9Sstevel@tonic-gate switch (event) { 17947c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 17957c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DISABLE: 17967c478bd9Sstevel@tonic-gate /* 17977c478bd9Sstevel@tonic-gate * The instance should be disabled. Firstly, as for 17987c478bd9Sstevel@tonic-gate * the above dependencies unmet comment, cancel 17997c478bd9Sstevel@tonic-gate * the bind retry timer and update the state to 18007c478bd9Sstevel@tonic-gate * offline. Then, run the disable method to do the 18017c478bd9Sstevel@tonic-gate * work to take the instance from offline to 18027c478bd9Sstevel@tonic-gate * disabled. 18037c478bd9Sstevel@tonic-gate */ 18047c478bd9Sstevel@tonic-gate cancel_bind_timer(instance); 18057c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, RERR_RESTART); 18067c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_DISABLE, NULL); 18077c478bd9Sstevel@tonic-gate break; 18087c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 18097c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 18107c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 18117c478bd9Sstevel@tonic-gate /* 18127c478bd9Sstevel@tonic-gate * The master restarter has requested the instance 18137c478bd9Sstevel@tonic-gate * be placed in the maintenance state. Cancel the 18147c478bd9Sstevel@tonic-gate * outstanding retry timer, and since we're already 18157c478bd9Sstevel@tonic-gate * offline, update the state to maintenance. 18167c478bd9Sstevel@tonic-gate */ 18177c478bd9Sstevel@tonic-gate cancel_bind_timer(instance); 18187c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_RESTART); 18197c478bd9Sstevel@tonic-gate break; 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate break; 18227c478bd9Sstevel@tonic-gate 18237c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 18247c478bd9Sstevel@tonic-gate case IIS_ONLINE: 18257c478bd9Sstevel@tonic-gate switch (event) { 18267c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 18277c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DISABLE: 18287c478bd9Sstevel@tonic-gate /* 18297c478bd9Sstevel@tonic-gate * The instance needs to be disabled. Do the same work 18307c478bd9Sstevel@tonic-gate * as for the dependencies unmet event below to 18317c478bd9Sstevel@tonic-gate * take the instance offline. 18327c478bd9Sstevel@tonic-gate */ 18337c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 18347c478bd9Sstevel@tonic-gate /* 18357c478bd9Sstevel@tonic-gate * Indicate that the offline method is being run 18367c478bd9Sstevel@tonic-gate * as part of going to the disabled state, and to 18377c478bd9Sstevel@tonic-gate * carry on this transition. 18387c478bd9Sstevel@tonic-gate */ 18397c478bd9Sstevel@tonic-gate instance->disable_req = B_TRUE; 18407c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_OFFLINE, NULL); 18417c478bd9Sstevel@tonic-gate break; 18427c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 18437c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 18447c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 18457c478bd9Sstevel@tonic-gate /* 18467c478bd9Sstevel@tonic-gate * The master restarter has requested the instance be 18477c478bd9Sstevel@tonic-gate * placed in the maintenance state. This involves 18487c478bd9Sstevel@tonic-gate * firstly taking the service offline, so do the 18497c478bd9Sstevel@tonic-gate * same work as for the dependencies unmet event 18507c478bd9Sstevel@tonic-gate * below. We set the maintenance_req flag to 18517c478bd9Sstevel@tonic-gate * indicate that when we get to the offline state 18527c478bd9Sstevel@tonic-gate * we should be placed directly into the maintenance 18537c478bd9Sstevel@tonic-gate * state. 18547c478bd9Sstevel@tonic-gate */ 18557c478bd9Sstevel@tonic-gate instance->maintenance_req = B_TRUE; 18567c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 18577c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_STOP: 18587c478bd9Sstevel@tonic-gate /* 18597c478bd9Sstevel@tonic-gate * Dependencies have become unmet. Close and 18607c478bd9Sstevel@tonic-gate * stop listening on the instance's network file 18617c478bd9Sstevel@tonic-gate * descriptor, and run the offline method to do 18627c478bd9Sstevel@tonic-gate * any work required to take us to the offline state. 18637c478bd9Sstevel@tonic-gate */ 18647c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 18657c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_OFFLINE, NULL); 18667c478bd9Sstevel@tonic-gate } 18677c478bd9Sstevel@tonic-gate break; 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate case IIS_UNINITIALIZED: 18707c478bd9Sstevel@tonic-gate if (event == RESTARTER_EVENT_TYPE_DISABLE || 18717c478bd9Sstevel@tonic-gate event == RESTARTER_EVENT_TYPE_ADMIN_DISABLE) { 18727c478bd9Sstevel@tonic-gate update_state(instance, IIS_DISABLED, RERR_NONE); 18737c478bd9Sstevel@tonic-gate break; 18747c478bd9Sstevel@tonic-gate } else if (event != RESTARTER_EVENT_TYPE_ENABLE) { 18757c478bd9Sstevel@tonic-gate /* 18767c478bd9Sstevel@tonic-gate * Ignore other events until we know whether we're 18777c478bd9Sstevel@tonic-gate * enabled or not. 18787c478bd9Sstevel@tonic-gate */ 18797c478bd9Sstevel@tonic-gate break; 18807c478bd9Sstevel@tonic-gate } 18817c478bd9Sstevel@tonic-gate 18827c478bd9Sstevel@tonic-gate /* 18837c478bd9Sstevel@tonic-gate * We've got an enabled event; make use of the handling in the 18847c478bd9Sstevel@tonic-gate * disable case. 18857c478bd9Sstevel@tonic-gate */ 18867c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 18877c478bd9Sstevel@tonic-gate 18887c478bd9Sstevel@tonic-gate case IIS_DISABLED: 18897c478bd9Sstevel@tonic-gate switch (event) { 18907c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ENABLE: 18917c478bd9Sstevel@tonic-gate /* 18927c478bd9Sstevel@tonic-gate * The instance needs enabling. Commence reading its 18937c478bd9Sstevel@tonic-gate * configuration and if successful place the instance 18947c478bd9Sstevel@tonic-gate * in the offline state and let process_offline_inst() 18957c478bd9Sstevel@tonic-gate * take it from there. 18967c478bd9Sstevel@tonic-gate */ 18977c478bd9Sstevel@tonic-gate destroy_instance_cfg(instance->config); 18987c478bd9Sstevel@tonic-gate instance->config = read_instance_cfg(instance->fmri); 18997c478bd9Sstevel@tonic-gate if (instance->config != NULL) { 19007c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, 19017c478bd9Sstevel@tonic-gate RERR_RESTART); 19027c478bd9Sstevel@tonic-gate process_offline_inst(instance); 19037c478bd9Sstevel@tonic-gate } else { 19047c478bd9Sstevel@tonic-gate log_invalid_cfg(instance->fmri); 19057c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, 19067c478bd9Sstevel@tonic-gate RERR_RESTART); 19077c478bd9Sstevel@tonic-gate } 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate break; 19107c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 19117c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 19127c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 19137c478bd9Sstevel@tonic-gate /* 19147c478bd9Sstevel@tonic-gate * The master restarter has requested the instance be 19157c478bd9Sstevel@tonic-gate * placed in the maintenance state, so just update its 19167c478bd9Sstevel@tonic-gate * state to maintenance. 19177c478bd9Sstevel@tonic-gate */ 19187c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_RESTART); 19197c478bd9Sstevel@tonic-gate break; 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate break; 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate case IIS_MAINTENANCE: 19247c478bd9Sstevel@tonic-gate switch (event) { 19257c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_OFF: 19267c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_DISABLE: 19277c478bd9Sstevel@tonic-gate /* 19287c478bd9Sstevel@tonic-gate * The master restarter has requested that the instance 19297c478bd9Sstevel@tonic-gate * be taken out of maintenance. Read its configuration, 19307c478bd9Sstevel@tonic-gate * and if successful place the instance in the offline 19317c478bd9Sstevel@tonic-gate * state and call process_offline_inst() to take it 19327c478bd9Sstevel@tonic-gate * from there. 19337c478bd9Sstevel@tonic-gate */ 19347c478bd9Sstevel@tonic-gate destroy_instance_cfg(instance->config); 19357c478bd9Sstevel@tonic-gate instance->config = read_instance_cfg(instance->fmri); 19367c478bd9Sstevel@tonic-gate if (instance->config != NULL) { 19377c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, 19387c478bd9Sstevel@tonic-gate RERR_RESTART); 19397c478bd9Sstevel@tonic-gate process_offline_inst(instance); 19407c478bd9Sstevel@tonic-gate } else { 19417c478bd9Sstevel@tonic-gate boolean_t enabled; 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate /* 19447c478bd9Sstevel@tonic-gate * The configuration was invalid. If the 19457c478bd9Sstevel@tonic-gate * service has disabled requested, let's 19467c478bd9Sstevel@tonic-gate * just place the instance in disabled even 19477c478bd9Sstevel@tonic-gate * though we haven't been able to run its 19487c478bd9Sstevel@tonic-gate * disable method, as the slightly incorrect 19497c478bd9Sstevel@tonic-gate * state is likely to be less of an issue to 19507c478bd9Sstevel@tonic-gate * an administrator than refusing to move an 19517c478bd9Sstevel@tonic-gate * instance to disabled. If disable isn't 19527c478bd9Sstevel@tonic-gate * requested, re-mark the service's state 19537c478bd9Sstevel@tonic-gate * as maintenance, so the administrator can 19547c478bd9Sstevel@tonic-gate * see the request was processed. 19557c478bd9Sstevel@tonic-gate */ 19567c478bd9Sstevel@tonic-gate if ((read_enable_merged(instance->fmri, 19577c478bd9Sstevel@tonic-gate &enabled) == 0) && !enabled) { 19587c478bd9Sstevel@tonic-gate update_state(instance, IIS_DISABLED, 19597c478bd9Sstevel@tonic-gate RERR_RESTART); 19607c478bd9Sstevel@tonic-gate } else { 19617c478bd9Sstevel@tonic-gate log_invalid_cfg(instance->fmri); 19627c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, 19637c478bd9Sstevel@tonic-gate RERR_FAULT); 19647c478bd9Sstevel@tonic-gate } 19657c478bd9Sstevel@tonic-gate } 19667c478bd9Sstevel@tonic-gate break; 19677c478bd9Sstevel@tonic-gate } 19687c478bd9Sstevel@tonic-gate break; 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate case IIS_OFFLINE_CONRATE: 19717c478bd9Sstevel@tonic-gate switch (event) { 19727c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 19737c478bd9Sstevel@tonic-gate /* 19747c478bd9Sstevel@tonic-gate * The instance wants disabling. Take the instance 19757c478bd9Sstevel@tonic-gate * offline as for the dependencies unmet event above, 19767c478bd9Sstevel@tonic-gate * and then from there run the disable method to do 19777c478bd9Sstevel@tonic-gate * the work to take the instance to the disabled state. 19787c478bd9Sstevel@tonic-gate */ 19797c478bd9Sstevel@tonic-gate cancel_inst_timer(instance); 19807c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, RERR_RESTART); 19817c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_DISABLE, NULL); 19827c478bd9Sstevel@tonic-gate break; 19837c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 19847c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 19857c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 19867c478bd9Sstevel@tonic-gate /* 19877c478bd9Sstevel@tonic-gate * The master restarter has requested the instance 19887c478bd9Sstevel@tonic-gate * be taken to maintenance. Cancel the timer setup 19897c478bd9Sstevel@tonic-gate * when we entered this state, and go directly to 19907c478bd9Sstevel@tonic-gate * maintenance. 19917c478bd9Sstevel@tonic-gate */ 19927c478bd9Sstevel@tonic-gate cancel_inst_timer(instance); 19937c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_RESTART); 19947c478bd9Sstevel@tonic-gate break; 19957c478bd9Sstevel@tonic-gate } 19967c478bd9Sstevel@tonic-gate break; 19977c478bd9Sstevel@tonic-gate 19987c478bd9Sstevel@tonic-gate case IIS_OFFLINE_COPIES: 19997c478bd9Sstevel@tonic-gate switch (event) { 20007c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DISABLE: 20017c478bd9Sstevel@tonic-gate /* 20027c478bd9Sstevel@tonic-gate * The instance wants disabling. Update the state 20037c478bd9Sstevel@tonic-gate * to offline, and run the disable method to do the 20047c478bd9Sstevel@tonic-gate * work to take it to the disabled state. 20057c478bd9Sstevel@tonic-gate */ 20067c478bd9Sstevel@tonic-gate update_state(instance, IIS_OFFLINE, RERR_RESTART); 20077c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_DISABLE, NULL); 20087c478bd9Sstevel@tonic-gate break; 20097c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_ADMIN_MAINT_ON: 20107c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_DEPENDENCY_CYCLE: 20117c478bd9Sstevel@tonic-gate case RESTARTER_EVENT_TYPE_INVALID_DEPENDENCY: 20127c478bd9Sstevel@tonic-gate /* 20137c478bd9Sstevel@tonic-gate * The master restarter has requested the instance be 20147c478bd9Sstevel@tonic-gate * placed in maintenance. Since it's already offline 20157c478bd9Sstevel@tonic-gate * simply update the state. 20167c478bd9Sstevel@tonic-gate */ 20177c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_RESTART); 20187c478bd9Sstevel@tonic-gate break; 20197c478bd9Sstevel@tonic-gate } 20207c478bd9Sstevel@tonic-gate break; 20217c478bd9Sstevel@tonic-gate 20227c478bd9Sstevel@tonic-gate default: 20237c478bd9Sstevel@tonic-gate debug_msg("handle_restarter_event: instance in an " 20247c478bd9Sstevel@tonic-gate "unexpected state"); 20257c478bd9Sstevel@tonic-gate assert(0); 20267c478bd9Sstevel@tonic-gate } 20277c478bd9Sstevel@tonic-gate 20287c478bd9Sstevel@tonic-gate done: 20297c478bd9Sstevel@tonic-gate if (send_ack) 20307c478bd9Sstevel@tonic-gate ack_restarter_event(B_TRUE); 20317c478bd9Sstevel@tonic-gate } 20327c478bd9Sstevel@tonic-gate 20337c478bd9Sstevel@tonic-gate /* 20347c478bd9Sstevel@tonic-gate * Tries to read and process an event from the event pipe. If there isn't one 20357c478bd9Sstevel@tonic-gate * or an error occurred processing the event it returns -1. Else, if the event 20367c478bd9Sstevel@tonic-gate * is for an instance we're not already managing we read its state, add it to 20377c478bd9Sstevel@tonic-gate * our list to manage, and if appropriate read its configuration. Whether it's 20387c478bd9Sstevel@tonic-gate * new to us or not, we then handle the specific event. 20397c478bd9Sstevel@tonic-gate * Returns 0 if an event was read and processed successfully, else -1. 20407c478bd9Sstevel@tonic-gate */ 20417c478bd9Sstevel@tonic-gate static int 20427c478bd9Sstevel@tonic-gate process_restarter_event(void) 20437c478bd9Sstevel@tonic-gate { 20447c478bd9Sstevel@tonic-gate char *fmri; 20457c478bd9Sstevel@tonic-gate size_t fmri_size; 20467c478bd9Sstevel@tonic-gate restarter_event_type_t event_type; 20477c478bd9Sstevel@tonic-gate instance_t *instance; 20487c478bd9Sstevel@tonic-gate restarter_event_t *event; 20497c478bd9Sstevel@tonic-gate ssize_t sz; 20507c478bd9Sstevel@tonic-gate 20517c478bd9Sstevel@tonic-gate /* 20527c478bd9Sstevel@tonic-gate * Try to read an event pointer from the event pipe. 20537c478bd9Sstevel@tonic-gate */ 20547c478bd9Sstevel@tonic-gate errno = 0; 20557c478bd9Sstevel@tonic-gate switch (safe_read(rst_event_pipe[PE_CONSUMER], &event, 20567c478bd9Sstevel@tonic-gate sizeof (event))) { 20577c478bd9Sstevel@tonic-gate case 0: 20587c478bd9Sstevel@tonic-gate break; 20597c478bd9Sstevel@tonic-gate case 1: 20607c478bd9Sstevel@tonic-gate if (errno == EAGAIN) /* no event to read */ 20617c478bd9Sstevel@tonic-gate return (-1); 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate /* other end of pipe closed */ 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 20667c478bd9Sstevel@tonic-gate default: /* unexpected read error */ 20677c478bd9Sstevel@tonic-gate /* 20687c478bd9Sstevel@tonic-gate * There's something wrong with the event pipe. Let's 20697c478bd9Sstevel@tonic-gate * shutdown and be restarted. 20707c478bd9Sstevel@tonic-gate */ 20717c478bd9Sstevel@tonic-gate inetd_stop(); 20727c478bd9Sstevel@tonic-gate return (-1); 20737c478bd9Sstevel@tonic-gate } 20747c478bd9Sstevel@tonic-gate 20757c478bd9Sstevel@tonic-gate /* 20767c478bd9Sstevel@tonic-gate * Check if we're currently managing the instance which the event 20777c478bd9Sstevel@tonic-gate * pertains to. If not, read its complete state and add it to our 20787c478bd9Sstevel@tonic-gate * list to manage. 20797c478bd9Sstevel@tonic-gate */ 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate fmri_size = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 20827c478bd9Sstevel@tonic-gate if ((fmri = malloc(fmri_size)) == NULL) { 20837c478bd9Sstevel@tonic-gate error_msg(strerror(errno)); 20847c478bd9Sstevel@tonic-gate goto fail; 20857c478bd9Sstevel@tonic-gate } 20867c478bd9Sstevel@tonic-gate sz = restarter_event_get_instance(event, fmri, fmri_size); 20877c478bd9Sstevel@tonic-gate if (sz >= fmri_size) 20887c478bd9Sstevel@tonic-gate assert(0); 20897c478bd9Sstevel@tonic-gate 20907c478bd9Sstevel@tonic-gate for (instance = uu_list_first(instance_list); instance != NULL; 20917c478bd9Sstevel@tonic-gate instance = uu_list_next(instance_list, instance)) { 20927c478bd9Sstevel@tonic-gate if (strcmp(instance->fmri, fmri) == 0) 20937c478bd9Sstevel@tonic-gate break; 20947c478bd9Sstevel@tonic-gate } 20957c478bd9Sstevel@tonic-gate 20967c478bd9Sstevel@tonic-gate if (instance == NULL) { 20977c478bd9Sstevel@tonic-gate int err; 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate debug_msg("New instance to manage: %s", fmri); 21007c478bd9Sstevel@tonic-gate 21017c478bd9Sstevel@tonic-gate if (((instance = create_instance(fmri)) == NULL) || 21027c478bd9Sstevel@tonic-gate (retrieve_instance_state(instance) != 0) || 21037c478bd9Sstevel@tonic-gate (retrieve_method_pids(instance) != 0)) { 21047c478bd9Sstevel@tonic-gate destroy_instance(instance); 21057c478bd9Sstevel@tonic-gate free(fmri); 21067c478bd9Sstevel@tonic-gate goto fail; 21077c478bd9Sstevel@tonic-gate } 21087c478bd9Sstevel@tonic-gate 210994501b61Sskamm if (((err = iterate_repository_contracts(instance, 0)) 21107c478bd9Sstevel@tonic-gate != 0) && (err != ENOENT)) { 21117c478bd9Sstevel@tonic-gate error_msg(gettext( 21127c478bd9Sstevel@tonic-gate "Failed to adopt contracts of instance %s: %s"), 21137c478bd9Sstevel@tonic-gate instance->fmri, strerror(err)); 21147c478bd9Sstevel@tonic-gate destroy_instance(instance); 21157c478bd9Sstevel@tonic-gate free(fmri); 21167c478bd9Sstevel@tonic-gate goto fail; 21177c478bd9Sstevel@tonic-gate } 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate uu_list_node_init(instance, &instance->link, instance_pool); 21207c478bd9Sstevel@tonic-gate (void) uu_list_insert_after(instance_list, NULL, instance); 21217c478bd9Sstevel@tonic-gate 21227c478bd9Sstevel@tonic-gate /* 21237c478bd9Sstevel@tonic-gate * Only read configuration for instances that aren't in any of 21247c478bd9Sstevel@tonic-gate * the disabled, maintenance or uninitialized states, since 21257c478bd9Sstevel@tonic-gate * they'll read it on state exit. 21267c478bd9Sstevel@tonic-gate */ 21277c478bd9Sstevel@tonic-gate if ((instance->cur_istate != IIS_DISABLED) && 21287c478bd9Sstevel@tonic-gate (instance->cur_istate != IIS_MAINTENANCE) && 21297c478bd9Sstevel@tonic-gate (instance->cur_istate != IIS_UNINITIALIZED)) { 21307c478bd9Sstevel@tonic-gate instance->config = read_instance_cfg(instance->fmri); 21317c478bd9Sstevel@tonic-gate if (instance->config == NULL) { 21327c478bd9Sstevel@tonic-gate log_invalid_cfg(instance->fmri); 21337c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, 21347c478bd9Sstevel@tonic-gate RERR_FAULT); 21357c478bd9Sstevel@tonic-gate } 21367c478bd9Sstevel@tonic-gate } 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate free(fmri); 21407c478bd9Sstevel@tonic-gate 21417c478bd9Sstevel@tonic-gate event_type = restarter_event_get_type(event); 21427c478bd9Sstevel@tonic-gate debug_msg("Event type: %d for instance: %s", event_type, 21437c478bd9Sstevel@tonic-gate instance->fmri); 21447c478bd9Sstevel@tonic-gate 21457c478bd9Sstevel@tonic-gate /* 21467c478bd9Sstevel@tonic-gate * If the instance is currently running a method, don't process the 21477c478bd9Sstevel@tonic-gate * event now, but attach it to the instance for processing when 21487c478bd9Sstevel@tonic-gate * the instance finishes its transition. 21497c478bd9Sstevel@tonic-gate */ 21507c478bd9Sstevel@tonic-gate if (INST_IN_TRANSITION(instance)) { 21517c478bd9Sstevel@tonic-gate debug_msg("storing event %d for instance %s", event_type, 21527c478bd9Sstevel@tonic-gate instance->fmri); 21537c478bd9Sstevel@tonic-gate instance->pending_rst_event = event_type; 21547c478bd9Sstevel@tonic-gate } else { 21557c478bd9Sstevel@tonic-gate handle_restarter_event(instance, event_type, B_TRUE); 21567c478bd9Sstevel@tonic-gate } 21577c478bd9Sstevel@tonic-gate 21587c478bd9Sstevel@tonic-gate return (0); 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate fail: 21617c478bd9Sstevel@tonic-gate ack_restarter_event(B_FALSE); 21627c478bd9Sstevel@tonic-gate return (-1); 21637c478bd9Sstevel@tonic-gate } 21647c478bd9Sstevel@tonic-gate 21657c478bd9Sstevel@tonic-gate /* 21667c478bd9Sstevel@tonic-gate * Do the state machine processing associated with the termination of instance 21675e2844d4SRenaud Manus * 'inst''s start method for the 'proto_name' protocol if this parameter is not 21685e2844d4SRenaud Manus * NULL. 21697c478bd9Sstevel@tonic-gate */ 21707c478bd9Sstevel@tonic-gate void 21715e2844d4SRenaud Manus process_start_term(instance_t *inst, char *proto_name) 21727c478bd9Sstevel@tonic-gate { 21737c478bd9Sstevel@tonic-gate basic_cfg_t *cfg; 21747c478bd9Sstevel@tonic-gate 21757c478bd9Sstevel@tonic-gate inst->copies--; 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate if ((inst->cur_istate == IIS_MAINTENANCE) || 21787c478bd9Sstevel@tonic-gate (inst->cur_istate == IIS_DISABLED)) { 21797c478bd9Sstevel@tonic-gate /* do any further processing/checks when we exit these states */ 21807c478bd9Sstevel@tonic-gate return; 21817c478bd9Sstevel@tonic-gate } 21827c478bd9Sstevel@tonic-gate 21837c478bd9Sstevel@tonic-gate cfg = inst->config->basic; 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate if (cfg->iswait) { 21867c478bd9Sstevel@tonic-gate proto_info_t *pi; 21875e2844d4SRenaud Manus boolean_t listen; 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate switch (inst->cur_istate) { 21907c478bd9Sstevel@tonic-gate case IIS_ONLINE: 21917c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 21927c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 21937c478bd9Sstevel@tonic-gate /* 21947c478bd9Sstevel@tonic-gate * A wait type service's start method has exited. 21957c478bd9Sstevel@tonic-gate * Check if the method was fired off in this inetd's 21967c478bd9Sstevel@tonic-gate * lifetime, or a previous one; if the former, 21977c478bd9Sstevel@tonic-gate * re-commence listening on the service's behalf; if 21987c478bd9Sstevel@tonic-gate * the latter, mark the service offline and let bind 21997c478bd9Sstevel@tonic-gate * attempts commence. 22007c478bd9Sstevel@tonic-gate */ 22015e2844d4SRenaud Manus listen = B_FALSE; 22027c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 22037c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 22047c478bd9Sstevel@tonic-gate /* 22057c478bd9Sstevel@tonic-gate * If a bound fd exists, the method was fired 22067c478bd9Sstevel@tonic-gate * off during this inetd's lifetime. 22077c478bd9Sstevel@tonic-gate */ 22085e2844d4SRenaud Manus if (pi->listen_fd != -1) { 22095e2844d4SRenaud Manus listen = B_TRUE; 22105e2844d4SRenaud Manus if (proto_name == NULL || 22115e2844d4SRenaud Manus strcmp(pi->proto, proto_name) == 0) 22125e2844d4SRenaud Manus break; 22135e2844d4SRenaud Manus } 22147c478bd9Sstevel@tonic-gate } 22157c478bd9Sstevel@tonic-gate if (pi != NULL) { 22165e2844d4SRenaud Manus if (poll_bound_fds(inst, B_TRUE, proto_name) != 22175e2844d4SRenaud Manus 0) 22187c478bd9Sstevel@tonic-gate handle_bind_failure(inst); 22195e2844d4SRenaud Manus } else if (listen == B_FALSE) { 22207c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE, RERR_RESTART); 22217c478bd9Sstevel@tonic-gate create_bound_fds(inst); 22227c478bd9Sstevel@tonic-gate } 22237c478bd9Sstevel@tonic-gate } 22247c478bd9Sstevel@tonic-gate } else { 22257c478bd9Sstevel@tonic-gate /* 22267c478bd9Sstevel@tonic-gate * Check if a nowait service should be brought back online 22277c478bd9Sstevel@tonic-gate * after exceeding its copies limit. 22287c478bd9Sstevel@tonic-gate */ 22297c478bd9Sstevel@tonic-gate if ((inst->cur_istate == IIS_OFFLINE_COPIES) && 22307c478bd9Sstevel@tonic-gate !copies_limit_exceeded(inst)) { 22317c478bd9Sstevel@tonic-gate update_state(inst, IIS_OFFLINE, RERR_NONE); 22327c478bd9Sstevel@tonic-gate process_offline_inst(inst); 22337c478bd9Sstevel@tonic-gate } 22347c478bd9Sstevel@tonic-gate } 22357c478bd9Sstevel@tonic-gate } 22367c478bd9Sstevel@tonic-gate 22377c478bd9Sstevel@tonic-gate /* 22387c478bd9Sstevel@tonic-gate * If the instance has a pending event process it and initiate the 22397c478bd9Sstevel@tonic-gate * acknowledgement. 22407c478bd9Sstevel@tonic-gate */ 22417c478bd9Sstevel@tonic-gate static void 22427c478bd9Sstevel@tonic-gate process_pending_rst_event(instance_t *inst) 22437c478bd9Sstevel@tonic-gate { 22447c478bd9Sstevel@tonic-gate if (inst->pending_rst_event != RESTARTER_EVENT_TYPE_INVALID) { 22457c478bd9Sstevel@tonic-gate restarter_event_type_t re; 22467c478bd9Sstevel@tonic-gate 22477c478bd9Sstevel@tonic-gate debug_msg("Injecting pending event %d for instance %s", 22487c478bd9Sstevel@tonic-gate inst->pending_rst_event, inst->fmri); 22497c478bd9Sstevel@tonic-gate re = inst->pending_rst_event; 22507c478bd9Sstevel@tonic-gate inst->pending_rst_event = RESTARTER_EVENT_TYPE_INVALID; 22517c478bd9Sstevel@tonic-gate handle_restarter_event(inst, re, B_TRUE); 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate } 22547c478bd9Sstevel@tonic-gate 22557c478bd9Sstevel@tonic-gate /* 22567c478bd9Sstevel@tonic-gate * Do the state machine processing associated with the termination 22577c478bd9Sstevel@tonic-gate * of the specified instance's non-start method with the specified status. 22587c478bd9Sstevel@tonic-gate * Once the processing of the termination is done, the function also picks up 22597c478bd9Sstevel@tonic-gate * any processing that was blocked on the method running. 22607c478bd9Sstevel@tonic-gate */ 22617c478bd9Sstevel@tonic-gate void 22627c478bd9Sstevel@tonic-gate process_non_start_term(instance_t *inst, int status) 22637c478bd9Sstevel@tonic-gate { 22647c478bd9Sstevel@tonic-gate boolean_t ran_online_method = B_FALSE; 22657c478bd9Sstevel@tonic-gate 22667c478bd9Sstevel@tonic-gate if (status == IMRET_FAILURE) { 22677c478bd9Sstevel@tonic-gate error_msg(gettext("The %s method of instance %s failed, " 22687c478bd9Sstevel@tonic-gate "transitioning to maintenance"), 22697c478bd9Sstevel@tonic-gate methods[states[inst->cur_istate].method_running].name, 22707c478bd9Sstevel@tonic-gate inst->fmri); 22717c478bd9Sstevel@tonic-gate 22727c478bd9Sstevel@tonic-gate if ((inst->cur_istate == IIS_IN_ONLINE_METHOD) || 22737c478bd9Sstevel@tonic-gate (inst->cur_istate == IIS_IN_REFRESH_METHOD)) 22747c478bd9Sstevel@tonic-gate destroy_bound_fds(inst); 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate update_state(inst, IIS_MAINTENANCE, RERR_FAULT); 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate inst->maintenance_req = B_FALSE; 22797c478bd9Sstevel@tonic-gate inst->conn_rate_exceeded = B_FALSE; 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate if (inst->new_config != NULL) { 22827c478bd9Sstevel@tonic-gate destroy_instance_cfg(inst->new_config); 22837c478bd9Sstevel@tonic-gate inst->new_config = NULL; 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate if (!inetd_stopping) 22877c478bd9Sstevel@tonic-gate process_pending_rst_event(inst); 22887c478bd9Sstevel@tonic-gate 22897c478bd9Sstevel@tonic-gate return; 22907c478bd9Sstevel@tonic-gate } 22917c478bd9Sstevel@tonic-gate 22927c478bd9Sstevel@tonic-gate /* non-failure method return */ 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate if (status != IMRET_SUCCESS) { 22957c478bd9Sstevel@tonic-gate /* 22967c478bd9Sstevel@tonic-gate * An instance method never returned a supported return code. 22977c478bd9Sstevel@tonic-gate * We'll assume this means the method succeeded for now whilst 22987c478bd9Sstevel@tonic-gate * non-GL-cognizant methods are used - eg. pkill. 22997c478bd9Sstevel@tonic-gate */ 23007c478bd9Sstevel@tonic-gate debug_msg("The %s method of instance %s returned " 23017c478bd9Sstevel@tonic-gate "non-compliant exit code: %d, assuming success", 23027c478bd9Sstevel@tonic-gate methods[states[inst->cur_istate].method_running].name, 23037c478bd9Sstevel@tonic-gate inst->fmri, status); 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate /* 23077c478bd9Sstevel@tonic-gate * Update the state from the in-transition state. 23087c478bd9Sstevel@tonic-gate */ 23097c478bd9Sstevel@tonic-gate switch (inst->cur_istate) { 23107c478bd9Sstevel@tonic-gate case IIS_IN_ONLINE_METHOD: 23117c478bd9Sstevel@tonic-gate ran_online_method = B_TRUE; 23127c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 23137c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 23147c478bd9Sstevel@tonic-gate /* 23157c478bd9Sstevel@tonic-gate * If we've exhausted the bind retries, flag that by setting 23167c478bd9Sstevel@tonic-gate * the instance's state to degraded. 23177c478bd9Sstevel@tonic-gate */ 23187c478bd9Sstevel@tonic-gate if (inst->bind_retries_exceeded) { 23197c478bd9Sstevel@tonic-gate update_state(inst, IIS_DEGRADED, RERR_NONE); 23207c478bd9Sstevel@tonic-gate break; 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 23237c478bd9Sstevel@tonic-gate default: 23247c478bd9Sstevel@tonic-gate update_state(inst, 23257c478bd9Sstevel@tonic-gate methods[states[inst->cur_istate].method_running].dst_state, 23267c478bd9Sstevel@tonic-gate RERR_NONE); 23277c478bd9Sstevel@tonic-gate } 23287c478bd9Sstevel@tonic-gate 23297c478bd9Sstevel@tonic-gate if (inst->cur_istate == IIS_OFFLINE) { 23307c478bd9Sstevel@tonic-gate if (inst->new_config != NULL) { 23317c478bd9Sstevel@tonic-gate /* 23327c478bd9Sstevel@tonic-gate * This instance was found during refresh to need 23337c478bd9Sstevel@tonic-gate * taking offline because its newly read configuration 23347c478bd9Sstevel@tonic-gate * was sufficiently different. Now we're offline, 23357c478bd9Sstevel@tonic-gate * activate this new configuration. 23367c478bd9Sstevel@tonic-gate */ 23377c478bd9Sstevel@tonic-gate destroy_instance_cfg(inst->config); 23387c478bd9Sstevel@tonic-gate inst->config = inst->new_config; 23397c478bd9Sstevel@tonic-gate inst->new_config = NULL; 23407c478bd9Sstevel@tonic-gate } 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate /* continue/complete any transitions that are in progress */ 23437c478bd9Sstevel@tonic-gate process_offline_inst(inst); 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate } else if (ran_online_method) { 23467c478bd9Sstevel@tonic-gate /* 23477c478bd9Sstevel@tonic-gate * We've just successfully executed the online method. We have 23487c478bd9Sstevel@tonic-gate * a set of bound network fds that were created before running 23497c478bd9Sstevel@tonic-gate * this method, so now we're online start listening for 23507c478bd9Sstevel@tonic-gate * connections on them. 23517c478bd9Sstevel@tonic-gate */ 23525e2844d4SRenaud Manus if (poll_bound_fds(inst, B_TRUE, NULL) != 0) 23537c478bd9Sstevel@tonic-gate handle_bind_failure(inst); 23547c478bd9Sstevel@tonic-gate } 23557c478bd9Sstevel@tonic-gate 23567c478bd9Sstevel@tonic-gate /* 23577c478bd9Sstevel@tonic-gate * If we're now out of transition (process_offline_inst() could have 23587c478bd9Sstevel@tonic-gate * fired off another method), carry out any jobs that were blocked by 23597c478bd9Sstevel@tonic-gate * us being in transition. 23607c478bd9Sstevel@tonic-gate */ 23617c478bd9Sstevel@tonic-gate if (!INST_IN_TRANSITION(inst)) { 23627c478bd9Sstevel@tonic-gate if (inetd_stopping) { 23637c478bd9Sstevel@tonic-gate if (!instance_stopped(inst)) { 23647c478bd9Sstevel@tonic-gate /* 23657c478bd9Sstevel@tonic-gate * inetd is stopping, and this instance hasn't 23667c478bd9Sstevel@tonic-gate * been stopped. Inject a stop event. 23677c478bd9Sstevel@tonic-gate */ 23687c478bd9Sstevel@tonic-gate handle_restarter_event(inst, 23697c478bd9Sstevel@tonic-gate RESTARTER_EVENT_TYPE_STOP, B_FALSE); 23707c478bd9Sstevel@tonic-gate } 23717c478bd9Sstevel@tonic-gate } else { 23727c478bd9Sstevel@tonic-gate process_pending_rst_event(inst); 23737c478bd9Sstevel@tonic-gate } 23747c478bd9Sstevel@tonic-gate } 23757c478bd9Sstevel@tonic-gate } 23767c478bd9Sstevel@tonic-gate 23777c478bd9Sstevel@tonic-gate /* 23787c478bd9Sstevel@tonic-gate * Check if configuration file specified is readable. If not return B_FALSE, 23797c478bd9Sstevel@tonic-gate * else return B_TRUE. 23807c478bd9Sstevel@tonic-gate */ 23817c478bd9Sstevel@tonic-gate static boolean_t 23827c478bd9Sstevel@tonic-gate can_read_file(const char *path) 23837c478bd9Sstevel@tonic-gate { 23847c478bd9Sstevel@tonic-gate int ret; 23857c478bd9Sstevel@tonic-gate int serrno; 23867c478bd9Sstevel@tonic-gate 23877c478bd9Sstevel@tonic-gate do { 23887c478bd9Sstevel@tonic-gate ret = access(path, R_OK); 23897c478bd9Sstevel@tonic-gate } while ((ret < 0) && (errno == EINTR)); 23907c478bd9Sstevel@tonic-gate if (ret < 0) { 23917c478bd9Sstevel@tonic-gate if (errno != ENOENT) { 23927c478bd9Sstevel@tonic-gate serrno = errno; 23937c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to access configuration " 23947c478bd9Sstevel@tonic-gate "file %s for performing modification checks: %s"), 23957c478bd9Sstevel@tonic-gate path, strerror(errno)); 23967c478bd9Sstevel@tonic-gate errno = serrno; 23977c478bd9Sstevel@tonic-gate } 23987c478bd9Sstevel@tonic-gate return (B_FALSE); 23997c478bd9Sstevel@tonic-gate } 24007c478bd9Sstevel@tonic-gate return (B_TRUE); 24017c478bd9Sstevel@tonic-gate } 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate /* 24047c478bd9Sstevel@tonic-gate * Check whether the configuration file has changed contents since inetd 24057c478bd9Sstevel@tonic-gate * was last started/refreshed, and if so, log a message indicating that 24067c478bd9Sstevel@tonic-gate * inetconv needs to be run. 24077c478bd9Sstevel@tonic-gate */ 24087c478bd9Sstevel@tonic-gate static void 24097c478bd9Sstevel@tonic-gate check_conf_file(void) 24107c478bd9Sstevel@tonic-gate { 24117c478bd9Sstevel@tonic-gate char *new_hash; 24127c478bd9Sstevel@tonic-gate char *old_hash = NULL; 24137c478bd9Sstevel@tonic-gate scf_error_t ret; 24147c478bd9Sstevel@tonic-gate const char *file; 24157c478bd9Sstevel@tonic-gate 24167c478bd9Sstevel@tonic-gate if (conf_file == NULL) { 24177c478bd9Sstevel@tonic-gate /* 24187c478bd9Sstevel@tonic-gate * No explicit config file specified, so see if one of the 24197c478bd9Sstevel@tonic-gate * default two are readable, checking the primary one first 24207c478bd9Sstevel@tonic-gate * followed by the secondary. 24217c478bd9Sstevel@tonic-gate */ 24227c478bd9Sstevel@tonic-gate if (can_read_file(PRIMARY_DEFAULT_CONF_FILE)) { 24237c478bd9Sstevel@tonic-gate file = PRIMARY_DEFAULT_CONF_FILE; 24247c478bd9Sstevel@tonic-gate } else if ((errno == ENOENT) && 24257c478bd9Sstevel@tonic-gate can_read_file(SECONDARY_DEFAULT_CONF_FILE)) { 24267c478bd9Sstevel@tonic-gate file = SECONDARY_DEFAULT_CONF_FILE; 24277c478bd9Sstevel@tonic-gate } else { 24287c478bd9Sstevel@tonic-gate return; 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate } else { 24317c478bd9Sstevel@tonic-gate file = conf_file; 24327c478bd9Sstevel@tonic-gate if (!can_read_file(file)) 24337c478bd9Sstevel@tonic-gate return; 24347c478bd9Sstevel@tonic-gate } 24357c478bd9Sstevel@tonic-gate 24367c478bd9Sstevel@tonic-gate if (calculate_hash(file, &new_hash) == 0) { 24377c478bd9Sstevel@tonic-gate ret = retrieve_inetd_hash(&old_hash); 24387c478bd9Sstevel@tonic-gate if (((ret == SCF_ERROR_NONE) && 24397c478bd9Sstevel@tonic-gate (strcmp(old_hash, new_hash) != 0))) { 24407c478bd9Sstevel@tonic-gate /* modified config file */ 24417c478bd9Sstevel@tonic-gate warn_msg(gettext( 24427c478bd9Sstevel@tonic-gate "Configuration file %s has been modified since " 24437c478bd9Sstevel@tonic-gate "inetconv was last run. \"inetconv -i %s\" must be " 24447c478bd9Sstevel@tonic-gate "run to apply any changes to the SMF"), file, file); 24457c478bd9Sstevel@tonic-gate } else if ((ret != SCF_ERROR_NOT_FOUND) && 24467c478bd9Sstevel@tonic-gate (ret != SCF_ERROR_NONE)) { 24477c478bd9Sstevel@tonic-gate /* No message if hash not yet computed */ 24487c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to check whether " 24497c478bd9Sstevel@tonic-gate "configuration file %s has been modified: %s"), 24507c478bd9Sstevel@tonic-gate file, scf_strerror(ret)); 24517c478bd9Sstevel@tonic-gate } 24527c478bd9Sstevel@tonic-gate free(old_hash); 24537c478bd9Sstevel@tonic-gate free(new_hash); 24547c478bd9Sstevel@tonic-gate } else { 24557c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to check whether configuration file " 24567c478bd9Sstevel@tonic-gate "%s has been modified: %s"), file, strerror(errno)); 24577c478bd9Sstevel@tonic-gate } 24587c478bd9Sstevel@tonic-gate } 24597c478bd9Sstevel@tonic-gate 24607c478bd9Sstevel@tonic-gate /* 24617c478bd9Sstevel@tonic-gate * Refresh all inetd's managed instances and check the configuration file 24627c478bd9Sstevel@tonic-gate * for any updates since inetconv was last run, logging a message if there 24637c478bd9Sstevel@tonic-gate * are. We call the SMF refresh function to refresh each instance so that 24647c478bd9Sstevel@tonic-gate * the refresh request goes through the framework, and thus results in the 24657c478bd9Sstevel@tonic-gate * running snapshot of each instance being updated from the configuration 24667c478bd9Sstevel@tonic-gate * snapshot. 24677c478bd9Sstevel@tonic-gate */ 24687c478bd9Sstevel@tonic-gate static void 24697c478bd9Sstevel@tonic-gate inetd_refresh(void) 24707c478bd9Sstevel@tonic-gate { 24717c478bd9Sstevel@tonic-gate instance_t *inst; 24727c478bd9Sstevel@tonic-gate 2473eed64e98Sgm refresh_debug_flag(); 24747c478bd9Sstevel@tonic-gate 24757c478bd9Sstevel@tonic-gate /* call libscf to send refresh requests for all managed instances */ 24767c478bd9Sstevel@tonic-gate for (inst = uu_list_first(instance_list); inst != NULL; 24777c478bd9Sstevel@tonic-gate inst = uu_list_next(instance_list, inst)) { 24787c478bd9Sstevel@tonic-gate if (smf_refresh_instance(inst->fmri) < 0) { 24797c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to refresh instance %s: %s"), 24807c478bd9Sstevel@tonic-gate inst->fmri, scf_strerror(scf_error())); 24817c478bd9Sstevel@tonic-gate } 24827c478bd9Sstevel@tonic-gate } 24837c478bd9Sstevel@tonic-gate 24847c478bd9Sstevel@tonic-gate /* 24857c478bd9Sstevel@tonic-gate * Log a message if the configuration file has changed since inetconv 24867c478bd9Sstevel@tonic-gate * was last run. 24877c478bd9Sstevel@tonic-gate */ 24887c478bd9Sstevel@tonic-gate check_conf_file(); 24897c478bd9Sstevel@tonic-gate } 24907c478bd9Sstevel@tonic-gate 24917c478bd9Sstevel@tonic-gate /* 24927c478bd9Sstevel@tonic-gate * Initiate inetd's shutdown. 24937c478bd9Sstevel@tonic-gate */ 24947c478bd9Sstevel@tonic-gate static void 24957c478bd9Sstevel@tonic-gate inetd_stop(void) 24967c478bd9Sstevel@tonic-gate { 24977c478bd9Sstevel@tonic-gate instance_t *inst; 24987c478bd9Sstevel@tonic-gate 24997c478bd9Sstevel@tonic-gate /* Block handling signals for stop and refresh */ 25007c478bd9Sstevel@tonic-gate (void) sighold(SIGHUP); 25017c478bd9Sstevel@tonic-gate (void) sighold(SIGTERM); 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate /* Indicate inetd is coming down */ 25047c478bd9Sstevel@tonic-gate inetd_stopping = B_TRUE; 25057c478bd9Sstevel@tonic-gate 25067c478bd9Sstevel@tonic-gate /* Stop polling on restarter events. */ 25077c478bd9Sstevel@tonic-gate clear_pollfd(rst_event_pipe[PE_CONSUMER]); 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate /* Stop polling for any more stop/refresh requests. */ 25107c478bd9Sstevel@tonic-gate clear_pollfd(uds_fd); 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate /* 25137c478bd9Sstevel@tonic-gate * Send a stop event to all currently unstopped instances that 25147c478bd9Sstevel@tonic-gate * aren't in transition. For those that are in transition, the 25157c478bd9Sstevel@tonic-gate * event will get sent when the transition completes. 25167c478bd9Sstevel@tonic-gate */ 25177c478bd9Sstevel@tonic-gate for (inst = uu_list_first(instance_list); inst != NULL; 25187c478bd9Sstevel@tonic-gate inst = uu_list_next(instance_list, inst)) { 25197c478bd9Sstevel@tonic-gate if (!instance_stopped(inst) && !INST_IN_TRANSITION(inst)) 25207c478bd9Sstevel@tonic-gate handle_restarter_event(inst, 25217c478bd9Sstevel@tonic-gate RESTARTER_EVENT_TYPE_STOP, B_FALSE); 25227c478bd9Sstevel@tonic-gate } 25237c478bd9Sstevel@tonic-gate } 25247c478bd9Sstevel@tonic-gate 25257c478bd9Sstevel@tonic-gate /* 25267c478bd9Sstevel@tonic-gate * Sets up the intra-inetd-process Unix Domain Socket. 25277c478bd9Sstevel@tonic-gate * Returns -1 on error, else 0. 25287c478bd9Sstevel@tonic-gate */ 25297c478bd9Sstevel@tonic-gate static int 25307c478bd9Sstevel@tonic-gate uds_init(void) 25317c478bd9Sstevel@tonic-gate { 25327c478bd9Sstevel@tonic-gate struct sockaddr_un addr; 25337c478bd9Sstevel@tonic-gate 25347c478bd9Sstevel@tonic-gate if ((uds_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { 25357c478bd9Sstevel@tonic-gate error_msg("socket: %s", strerror(errno)); 25367c478bd9Sstevel@tonic-gate return (-1); 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate 25397c478bd9Sstevel@tonic-gate disable_blocking(uds_fd); 25407c478bd9Sstevel@tonic-gate 25417c478bd9Sstevel@tonic-gate (void) unlink(INETD_UDS_PATH); /* clean-up any stale files */ 25427c478bd9Sstevel@tonic-gate 25437c478bd9Sstevel@tonic-gate (void) memset(&addr, 0, sizeof (addr)); 25447c478bd9Sstevel@tonic-gate addr.sun_family = AF_UNIX; 25457c478bd9Sstevel@tonic-gate /* CONSTCOND */ 25467c478bd9Sstevel@tonic-gate assert(sizeof (INETD_UDS_PATH) <= sizeof (addr.sun_path)); 25477c478bd9Sstevel@tonic-gate (void) strlcpy(addr.sun_path, INETD_UDS_PATH, sizeof (addr.sun_path)); 25487c478bd9Sstevel@tonic-gate 25497c478bd9Sstevel@tonic-gate if (bind(uds_fd, (struct sockaddr *)(&addr), sizeof (addr)) < 0) { 25507c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to bind socket to %s: %s"), 25517c478bd9Sstevel@tonic-gate INETD_UDS_PATH, strerror(errno)); 25527c478bd9Sstevel@tonic-gate (void) close(uds_fd); 25537c478bd9Sstevel@tonic-gate return (-1); 25547c478bd9Sstevel@tonic-gate } 25557c478bd9Sstevel@tonic-gate 25567c478bd9Sstevel@tonic-gate (void) listen(uds_fd, UDS_BACKLOG); 25577c478bd9Sstevel@tonic-gate 25587c478bd9Sstevel@tonic-gate if ((set_pollfd(uds_fd, POLLIN)) == -1) { 25597c478bd9Sstevel@tonic-gate (void) close(uds_fd); 25607c478bd9Sstevel@tonic-gate (void) unlink(INETD_UDS_PATH); 25617c478bd9Sstevel@tonic-gate return (-1); 25627c478bd9Sstevel@tonic-gate } 25637c478bd9Sstevel@tonic-gate 25647c478bd9Sstevel@tonic-gate return (0); 25657c478bd9Sstevel@tonic-gate } 25667c478bd9Sstevel@tonic-gate 25677c478bd9Sstevel@tonic-gate static void 25687c478bd9Sstevel@tonic-gate uds_fini(void) 25697c478bd9Sstevel@tonic-gate { 25707c478bd9Sstevel@tonic-gate if (uds_fd != -1) 25717c478bd9Sstevel@tonic-gate (void) close(uds_fd); 25727c478bd9Sstevel@tonic-gate (void) unlink(INETD_UDS_PATH); 25737c478bd9Sstevel@tonic-gate } 25747c478bd9Sstevel@tonic-gate 25757c478bd9Sstevel@tonic-gate /* 25767c478bd9Sstevel@tonic-gate * Handle an incoming request on the Unix Domain Socket. Returns -1 if there 25777c478bd9Sstevel@tonic-gate * was an error handling the event, else 0. 25787c478bd9Sstevel@tonic-gate */ 25797c478bd9Sstevel@tonic-gate static int 25807c478bd9Sstevel@tonic-gate process_uds_event(void) 25817c478bd9Sstevel@tonic-gate { 25827c478bd9Sstevel@tonic-gate uds_request_t req; 25837c478bd9Sstevel@tonic-gate int fd; 25847c478bd9Sstevel@tonic-gate struct sockaddr_un addr; 25857c478bd9Sstevel@tonic-gate socklen_t len = sizeof (addr); 25867c478bd9Sstevel@tonic-gate int ret; 25877c478bd9Sstevel@tonic-gate uint_t retries = 0; 25887cd7ea0bSrs ucred_t *ucred = NULL; 25897cd7ea0bSrs uid_t euid; 25907c478bd9Sstevel@tonic-gate 25917c478bd9Sstevel@tonic-gate do { 25927c478bd9Sstevel@tonic-gate fd = accept(uds_fd, (struct sockaddr *)&addr, &len); 25937c478bd9Sstevel@tonic-gate } while ((fd < 0) && (errno == EINTR)); 25947c478bd9Sstevel@tonic-gate if (fd < 0) { 25957c478bd9Sstevel@tonic-gate if (errno != EWOULDBLOCK) 25967c478bd9Sstevel@tonic-gate error_msg("accept failed: %s", strerror(errno)); 25977c478bd9Sstevel@tonic-gate return (-1); 25987c478bd9Sstevel@tonic-gate } 25997c478bd9Sstevel@tonic-gate 26007cd7ea0bSrs if (getpeerucred(fd, &ucred) == -1) { 26017cd7ea0bSrs error_msg("getpeerucred failed: %s", strerror(errno)); 26027cd7ea0bSrs (void) close(fd); 26037cd7ea0bSrs return (-1); 26047cd7ea0bSrs } 26057cd7ea0bSrs 26067cd7ea0bSrs /* Check peer credentials before acting on the request */ 26077cd7ea0bSrs euid = ucred_geteuid(ucred); 26087cd7ea0bSrs ucred_free(ucred); 26097cd7ea0bSrs if (euid != 0 && getuid() != euid) { 26107cd7ea0bSrs debug_msg("peer euid %u != uid %u", 26117cd7ea0bSrs (uint_t)euid, (uint_t)getuid()); 26127cd7ea0bSrs (void) close(fd); 26137cd7ea0bSrs return (-1); 26147cd7ea0bSrs } 26157cd7ea0bSrs 26167c478bd9Sstevel@tonic-gate for (retries = 0; retries < UDS_RECV_RETRIES; retries++) { 26177c478bd9Sstevel@tonic-gate if (((ret = safe_read(fd, &req, sizeof (req))) != 1) || 26187c478bd9Sstevel@tonic-gate (errno != EAGAIN)) 26197c478bd9Sstevel@tonic-gate break; 26207c478bd9Sstevel@tonic-gate 26217c478bd9Sstevel@tonic-gate (void) poll(NULL, 0, 100); /* 100ms pause */ 26227c478bd9Sstevel@tonic-gate } 26237c478bd9Sstevel@tonic-gate 26247c478bd9Sstevel@tonic-gate if (ret != 0) { 26257c478bd9Sstevel@tonic-gate error_msg(gettext("Failed read: %s"), strerror(errno)); 26267c478bd9Sstevel@tonic-gate (void) close(fd); 26277c478bd9Sstevel@tonic-gate return (-1); 26287c478bd9Sstevel@tonic-gate } 26297c478bd9Sstevel@tonic-gate 26307c478bd9Sstevel@tonic-gate switch (req) { 26317c478bd9Sstevel@tonic-gate case UR_REFRESH_INETD: 26327c478bd9Sstevel@tonic-gate /* flag the request for event_loop() to process */ 26337c478bd9Sstevel@tonic-gate refresh_inetd_requested = B_TRUE; 26347c478bd9Sstevel@tonic-gate (void) close(fd); 26357c478bd9Sstevel@tonic-gate break; 26367c478bd9Sstevel@tonic-gate case UR_STOP_INETD: 26377c478bd9Sstevel@tonic-gate inetd_stop(); 26387c478bd9Sstevel@tonic-gate break; 26397c478bd9Sstevel@tonic-gate default: 26407c478bd9Sstevel@tonic-gate error_msg("unexpected UDS request"); 26417c478bd9Sstevel@tonic-gate (void) close(fd); 26427c478bd9Sstevel@tonic-gate return (-1); 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate return (0); 26467c478bd9Sstevel@tonic-gate } 26477c478bd9Sstevel@tonic-gate 26487c478bd9Sstevel@tonic-gate /* 26497c478bd9Sstevel@tonic-gate * Perform checks for common exec string errors. We limit the checks to 26507c478bd9Sstevel@tonic-gate * whether the file exists, is a regular file, and has at least one execute 26517c478bd9Sstevel@tonic-gate * bit set. We leave the core security checks to exec() so as not to duplicate 26527c478bd9Sstevel@tonic-gate * and thus incur the associated drawbacks, but hope to catch the common 26537c478bd9Sstevel@tonic-gate * errors here. 26547c478bd9Sstevel@tonic-gate */ 26557c478bd9Sstevel@tonic-gate static boolean_t 26567c478bd9Sstevel@tonic-gate passes_basic_exec_checks(const char *instance, const char *method, 26577c478bd9Sstevel@tonic-gate const char *path) 26587c478bd9Sstevel@tonic-gate { 26597c478bd9Sstevel@tonic-gate struct stat sbuf; 26607c478bd9Sstevel@tonic-gate 26617c478bd9Sstevel@tonic-gate /* check the file exists */ 26627c478bd9Sstevel@tonic-gate while (stat(path, &sbuf) == -1) { 26637c478bd9Sstevel@tonic-gate if (errno != EINTR) { 26647c478bd9Sstevel@tonic-gate error_msg(gettext( 26657c478bd9Sstevel@tonic-gate "Can't stat the %s method of instance %s: %s"), 26667c478bd9Sstevel@tonic-gate method, instance, strerror(errno)); 26677c478bd9Sstevel@tonic-gate return (B_FALSE); 26687c478bd9Sstevel@tonic-gate } 26697c478bd9Sstevel@tonic-gate } 26707c478bd9Sstevel@tonic-gate 26717c478bd9Sstevel@tonic-gate /* 26727c478bd9Sstevel@tonic-gate * Check if the file is a regular file and has at least one execute 26737c478bd9Sstevel@tonic-gate * bit set. 26747c478bd9Sstevel@tonic-gate */ 26757c478bd9Sstevel@tonic-gate if ((sbuf.st_mode & S_IFMT) != S_IFREG) { 26767c478bd9Sstevel@tonic-gate error_msg(gettext( 26777c478bd9Sstevel@tonic-gate "The %s method of instance %s isn't a regular file"), 26787c478bd9Sstevel@tonic-gate method, instance); 26797c478bd9Sstevel@tonic-gate return (B_FALSE); 26807c478bd9Sstevel@tonic-gate } else if ((sbuf.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) == 0) { 26817c478bd9Sstevel@tonic-gate error_msg(gettext("The %s method instance %s doesn't have " 26827c478bd9Sstevel@tonic-gate "any execute permissions set"), method, instance); 26837c478bd9Sstevel@tonic-gate return (B_FALSE); 26847c478bd9Sstevel@tonic-gate } 26857c478bd9Sstevel@tonic-gate 26867c478bd9Sstevel@tonic-gate return (B_TRUE); 26877c478bd9Sstevel@tonic-gate } 26887c478bd9Sstevel@tonic-gate 26897c478bd9Sstevel@tonic-gate static void 26907c478bd9Sstevel@tonic-gate exec_method(instance_t *instance, instance_method_t method, method_info_t *mi, 26917c478bd9Sstevel@tonic-gate struct method_context *mthd_ctxt, const proto_info_t *pi) 26927c478bd9Sstevel@tonic-gate { 26937c478bd9Sstevel@tonic-gate char **args; 26947c478bd9Sstevel@tonic-gate char **env; 26957c478bd9Sstevel@tonic-gate const char *errf; 26967c478bd9Sstevel@tonic-gate int serrno; 26977c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate if (method == IM_START) { 27007c478bd9Sstevel@tonic-gate /* 27017c478bd9Sstevel@tonic-gate * If wrappers checks fail, pretend the method was exec'd and 27027c478bd9Sstevel@tonic-gate * failed. 27037c478bd9Sstevel@tonic-gate */ 27047c478bd9Sstevel@tonic-gate if (!tcp_wrappers_ok(instance)) 27057c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 27067c478bd9Sstevel@tonic-gate } 27077c478bd9Sstevel@tonic-gate 27087c478bd9Sstevel@tonic-gate /* 27097c478bd9Sstevel@tonic-gate * Revert the disposition of handled signals and ignored signals to 27107c478bd9Sstevel@tonic-gate * their defaults, unblocking any blocked ones as a side effect. 27117c478bd9Sstevel@tonic-gate */ 27127c478bd9Sstevel@tonic-gate (void) sigset(SIGHUP, SIG_DFL); 27137c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, SIG_DFL); 27147c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_DFL); 27157c478bd9Sstevel@tonic-gate 27167c478bd9Sstevel@tonic-gate /* 27177c478bd9Sstevel@tonic-gate * Setup exec arguments. Do this before the fd setup below, so our 27187c478bd9Sstevel@tonic-gate * logging related file fd doesn't get taken over before we call 27197c478bd9Sstevel@tonic-gate * expand_address(). 27207c478bd9Sstevel@tonic-gate */ 27217c478bd9Sstevel@tonic-gate if ((method == IM_START) && 27227c478bd9Sstevel@tonic-gate (strcmp(mi->exec_args_we.we_wordv[0], "%A") == 0)) { 27237c478bd9Sstevel@tonic-gate args = expand_address(instance, pi); 27247c478bd9Sstevel@tonic-gate } else { 27257c478bd9Sstevel@tonic-gate args = mi->exec_args_we.we_wordv; 27267c478bd9Sstevel@tonic-gate } 27277c478bd9Sstevel@tonic-gate 27287c478bd9Sstevel@tonic-gate /* Generate audit trail for start operations */ 27297c478bd9Sstevel@tonic-gate if (method == IM_START) { 27307c478bd9Sstevel@tonic-gate adt_event_data_t *ae; 27317c478bd9Sstevel@tonic-gate struct sockaddr_storage ss; 27327c478bd9Sstevel@tonic-gate priv_set_t *privset; 27337c478bd9Sstevel@tonic-gate socklen_t sslen = sizeof (ss); 27347c478bd9Sstevel@tonic-gate 27357c478bd9Sstevel@tonic-gate if ((ae = adt_alloc_event(audit_handle, ADT_inetd_connect)) 27367c478bd9Sstevel@tonic-gate == NULL) { 27377c478bd9Sstevel@tonic-gate error_msg(gettext("Unable to allocate audit event for " 27387c478bd9Sstevel@tonic-gate "the %s method of instance %s"), 27397c478bd9Sstevel@tonic-gate methods[method].name, instance->fmri); 27407c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 27417c478bd9Sstevel@tonic-gate } 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate /* 27447c478bd9Sstevel@tonic-gate * The inetd_connect audit record consists of: 27457c478bd9Sstevel@tonic-gate * Service name 27467c478bd9Sstevel@tonic-gate * Execution path 27477c478bd9Sstevel@tonic-gate * Remote address and port 27487c478bd9Sstevel@tonic-gate * Local port 27497c478bd9Sstevel@tonic-gate * Process privileges 27507c478bd9Sstevel@tonic-gate */ 27517c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.service_name = cfg->svc_name; 27527c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.cmd = mi->exec_path; 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate if (instance->remote_addr.ss_family == AF_INET) { 27557c478bd9Sstevel@tonic-gate struct in_addr *in = SS_SINADDR(instance->remote_addr); 27567c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_adr[0] = in->s_addr; 27577c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_type = ADT_IPv4; 27587c478bd9Sstevel@tonic-gate } else { 27597c478bd9Sstevel@tonic-gate uint32_t *addr6; 27607c478bd9Sstevel@tonic-gate int i; 27617c478bd9Sstevel@tonic-gate 27627c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_type = ADT_IPv6; 27637c478bd9Sstevel@tonic-gate addr6 = (uint32_t *)SS_SINADDR(instance->remote_addr); 27647c478bd9Sstevel@tonic-gate for (i = 0; i < 4; ++i) 27657c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_adr[i] = addr6[i]; 27667c478bd9Sstevel@tonic-gate } 27677c478bd9Sstevel@tonic-gate 27687c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_remote_port = 27697c478bd9Sstevel@tonic-gate ntohs(SS_PORT(instance->remote_addr)); 27707c478bd9Sstevel@tonic-gate 27717c478bd9Sstevel@tonic-gate if (getsockname(instance->conn_fd, (struct sockaddr *)&ss, 27727c478bd9Sstevel@tonic-gate &sslen) == 0) 27737c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.ip_local_port = 27747c478bd9Sstevel@tonic-gate ntohs(SS_PORT(ss)); 27757c478bd9Sstevel@tonic-gate 27767c478bd9Sstevel@tonic-gate privset = mthd_ctxt->priv_set; 27777c478bd9Sstevel@tonic-gate if (privset == NULL) { 27787c478bd9Sstevel@tonic-gate privset = priv_allocset(); 27797c478bd9Sstevel@tonic-gate if (privset != NULL && 27807c478bd9Sstevel@tonic-gate getppriv(PRIV_EFFECTIVE, privset) != 0) { 27817c478bd9Sstevel@tonic-gate priv_freeset(privset); 27827c478bd9Sstevel@tonic-gate privset = NULL; 27837c478bd9Sstevel@tonic-gate } 27847c478bd9Sstevel@tonic-gate } 27857c478bd9Sstevel@tonic-gate 27867c478bd9Sstevel@tonic-gate ae->adt_inetd_connect.privileges = privset; 27877c478bd9Sstevel@tonic-gate 27887c478bd9Sstevel@tonic-gate (void) adt_put_event(ae, ADT_SUCCESS, ADT_SUCCESS); 27897c478bd9Sstevel@tonic-gate adt_free_event(ae); 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate if (privset != NULL && mthd_ctxt->priv_set == NULL) 27927c478bd9Sstevel@tonic-gate priv_freeset(privset); 27937c478bd9Sstevel@tonic-gate } 27947c478bd9Sstevel@tonic-gate 27957c478bd9Sstevel@tonic-gate /* 27967c478bd9Sstevel@tonic-gate * Set method context before the fd setup below so we can output an 27977c478bd9Sstevel@tonic-gate * error message if it fails. 27987c478bd9Sstevel@tonic-gate */ 27997c478bd9Sstevel@tonic-gate if ((errno = restarter_set_method_context(mthd_ctxt, &errf)) != 0) { 28007c478bd9Sstevel@tonic-gate const char *msg; 28017c478bd9Sstevel@tonic-gate 28027c478bd9Sstevel@tonic-gate if (errno == -1) { 28037c478bd9Sstevel@tonic-gate if (strcmp(errf, "core_set_process_path") == 0) { 28047c478bd9Sstevel@tonic-gate msg = gettext("Failed to set the corefile path " 28057c478bd9Sstevel@tonic-gate "for the %s method of instance %s"); 28067c478bd9Sstevel@tonic-gate } else if (strcmp(errf, "setproject") == 0) { 28077c478bd9Sstevel@tonic-gate msg = gettext("Failed to assign a resource " 28087c478bd9Sstevel@tonic-gate "control for the %s method of instance %s"); 28097c478bd9Sstevel@tonic-gate } else if (strcmp(errf, "pool_set_binding") == 0) { 28107c478bd9Sstevel@tonic-gate msg = gettext("Failed to bind the %s method of " 28117c478bd9Sstevel@tonic-gate "instance %s to a pool due to a system " 28127c478bd9Sstevel@tonic-gate "error"); 28137c478bd9Sstevel@tonic-gate } else { 28147c478bd9Sstevel@tonic-gate assert(0); 28157c478bd9Sstevel@tonic-gate abort(); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate error_msg(msg, methods[method].name, instance->fmri); 28197c478bd9Sstevel@tonic-gate 28207c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 28217c478bd9Sstevel@tonic-gate } 28227c478bd9Sstevel@tonic-gate 28237c478bd9Sstevel@tonic-gate if (errf != NULL && strcmp(errf, "pool_set_binding") == 0) { 28247c478bd9Sstevel@tonic-gate switch (errno) { 28257c478bd9Sstevel@tonic-gate case ENOENT: 28267c478bd9Sstevel@tonic-gate msg = gettext("Failed to find resource pool " 28277c478bd9Sstevel@tonic-gate "for the %s method of instance %s"); 28287c478bd9Sstevel@tonic-gate break; 28297c478bd9Sstevel@tonic-gate 28307c478bd9Sstevel@tonic-gate case EBADF: 28317c478bd9Sstevel@tonic-gate msg = gettext("Failed to bind the %s method of " 28327c478bd9Sstevel@tonic-gate "instance %s to a pool due to invalid " 28337c478bd9Sstevel@tonic-gate "configuration"); 28347c478bd9Sstevel@tonic-gate break; 28357c478bd9Sstevel@tonic-gate 28363ad28c1eSrm case EINVAL: 28373ad28c1eSrm msg = gettext("Failed to bind the %s method of " 28383ad28c1eSrm "instance %s to a pool due to invalid " 28393ad28c1eSrm "pool name"); 28403ad28c1eSrm break; 28413ad28c1eSrm 28427c478bd9Sstevel@tonic-gate default: 28437c478bd9Sstevel@tonic-gate assert(0); 28447c478bd9Sstevel@tonic-gate abort(); 28457c478bd9Sstevel@tonic-gate } 28467c478bd9Sstevel@tonic-gate 28477c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 28487c478bd9Sstevel@tonic-gate } 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate if (errf != NULL) { 28517c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to set credentials for the " 28527c478bd9Sstevel@tonic-gate "%s method of instance %s (%s: %s)"), 28537c478bd9Sstevel@tonic-gate methods[method].name, instance->fmri, errf, 28547c478bd9Sstevel@tonic-gate strerror(errno)); 28557c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 28567c478bd9Sstevel@tonic-gate } 28577c478bd9Sstevel@tonic-gate 28587c478bd9Sstevel@tonic-gate switch (errno) { 28597c478bd9Sstevel@tonic-gate case ENOMEM: 28607c478bd9Sstevel@tonic-gate msg = gettext("Failed to set credentials for the %s " 28617c478bd9Sstevel@tonic-gate "method of instance %s (out of memory)"); 28627c478bd9Sstevel@tonic-gate break; 28637c478bd9Sstevel@tonic-gate 28647c478bd9Sstevel@tonic-gate case ENOENT: 28657c478bd9Sstevel@tonic-gate msg = gettext("Failed to set credentials for the %s " 28667c478bd9Sstevel@tonic-gate "method of instance %s (no passwd or shadow " 28677c478bd9Sstevel@tonic-gate "entry for user)"); 28687c478bd9Sstevel@tonic-gate break; 28697c478bd9Sstevel@tonic-gate 28707c478bd9Sstevel@tonic-gate default: 28717c478bd9Sstevel@tonic-gate assert(0); 28727c478bd9Sstevel@tonic-gate abort(); 28737c478bd9Sstevel@tonic-gate } 28747c478bd9Sstevel@tonic-gate 28757c478bd9Sstevel@tonic-gate error_msg(msg, methods[method].name, instance->fmri); 28767c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 28777c478bd9Sstevel@tonic-gate } 28787c478bd9Sstevel@tonic-gate 28797c478bd9Sstevel@tonic-gate /* let exec() free mthd_ctxt */ 28807c478bd9Sstevel@tonic-gate 28817c478bd9Sstevel@tonic-gate /* setup standard fds */ 28827c478bd9Sstevel@tonic-gate if (method == IM_START) { 28837c478bd9Sstevel@tonic-gate (void) dup2(instance->conn_fd, STDIN_FILENO); 28847c478bd9Sstevel@tonic-gate } else { 28857c478bd9Sstevel@tonic-gate (void) close(STDIN_FILENO); 28867c478bd9Sstevel@tonic-gate (void) open("/dev/null", O_RDONLY); 28877c478bd9Sstevel@tonic-gate } 28887c478bd9Sstevel@tonic-gate (void) dup2(STDIN_FILENO, STDOUT_FILENO); 28897c478bd9Sstevel@tonic-gate (void) dup2(STDIN_FILENO, STDERR_FILENO); 28907c478bd9Sstevel@tonic-gate 28917c478bd9Sstevel@tonic-gate closefrom(STDERR_FILENO + 1); 28927c478bd9Sstevel@tonic-gate 28937c478bd9Sstevel@tonic-gate method_preexec(); 28947c478bd9Sstevel@tonic-gate 28957c478bd9Sstevel@tonic-gate env = set_smf_env(mthd_ctxt, instance, methods[method].name); 28967c478bd9Sstevel@tonic-gate 28977c478bd9Sstevel@tonic-gate if (env != NULL) { 28987c478bd9Sstevel@tonic-gate do { 28997c478bd9Sstevel@tonic-gate (void) execve(mi->exec_path, args, env); 29007c478bd9Sstevel@tonic-gate } while (errno == EINTR); 29017c478bd9Sstevel@tonic-gate } 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate serrno = errno; 29047c478bd9Sstevel@tonic-gate /* start up logging again to report the error */ 29057c478bd9Sstevel@tonic-gate msg_init(); 29067c478bd9Sstevel@tonic-gate errno = serrno; 29077c478bd9Sstevel@tonic-gate 29087c478bd9Sstevel@tonic-gate error_msg( 29097c478bd9Sstevel@tonic-gate gettext("Failed to exec %s method of instance %s: %s"), 29107c478bd9Sstevel@tonic-gate methods[method].name, instance->fmri, strerror(errno)); 29117c478bd9Sstevel@tonic-gate 29127c478bd9Sstevel@tonic-gate if ((method == IM_START) && (instance->config->basic->iswait)) { 29137c478bd9Sstevel@tonic-gate /* 29147c478bd9Sstevel@tonic-gate * We couldn't exec the start method for a wait type service. 29157c478bd9Sstevel@tonic-gate * Eat up data from the endpoint, so that hopefully the 29167c478bd9Sstevel@tonic-gate * service's fd won't wake poll up on the next time round 29177c478bd9Sstevel@tonic-gate * event_loop(). This behavior is carried over from the old 29187c478bd9Sstevel@tonic-gate * inetd, and it seems somewhat arbitrary that it isn't 29197c478bd9Sstevel@tonic-gate * also done in the case of fork failures; but I guess 29207c478bd9Sstevel@tonic-gate * it assumes an exec failure is less likely to be the result 29217c478bd9Sstevel@tonic-gate * of a resource shortage, and is thus not worth retrying. 29227c478bd9Sstevel@tonic-gate */ 29237c478bd9Sstevel@tonic-gate consume_wait_data(instance, 0); 29247c478bd9Sstevel@tonic-gate } 29257c478bd9Sstevel@tonic-gate 29267c478bd9Sstevel@tonic-gate exit(IMRET_FAILURE); 29277c478bd9Sstevel@tonic-gate } 29287c478bd9Sstevel@tonic-gate 29297c478bd9Sstevel@tonic-gate static restarter_error_t 29307c478bd9Sstevel@tonic-gate get_method_error_success(instance_method_t method) 29317c478bd9Sstevel@tonic-gate { 29327c478bd9Sstevel@tonic-gate switch (method) { 29337c478bd9Sstevel@tonic-gate case IM_OFFLINE: 29347c478bd9Sstevel@tonic-gate return (RERR_RESTART); 29357c478bd9Sstevel@tonic-gate case IM_ONLINE: 29367c478bd9Sstevel@tonic-gate return (RERR_RESTART); 29377c478bd9Sstevel@tonic-gate case IM_DISABLE: 29387c478bd9Sstevel@tonic-gate return (RERR_RESTART); 29397c478bd9Sstevel@tonic-gate case IM_REFRESH: 29407c478bd9Sstevel@tonic-gate return (RERR_REFRESH); 29417c478bd9Sstevel@tonic-gate case IM_START: 29427c478bd9Sstevel@tonic-gate return (RERR_RESTART); 29437c478bd9Sstevel@tonic-gate } 2944b823d4c7Sdstaff (void) fprintf(stderr, gettext("Internal fatal error in inetd.\n")); 2945b823d4c7Sdstaff 2946b823d4c7Sdstaff abort(); 29477c478bd9Sstevel@tonic-gate /* NOTREACHED */ 29487c478bd9Sstevel@tonic-gate } 29497c478bd9Sstevel@tonic-gate 2950324baee5Sstevep static int 2951324baee5Sstevep smf_kill_process(instance_t *instance, int sig) 2952324baee5Sstevep { 2953324baee5Sstevep rep_val_t *rv; 2954324baee5Sstevep int ret = IMRET_SUCCESS; 2955324baee5Sstevep 2956324baee5Sstevep /* Carry out process assassination */ 2957324baee5Sstevep for (rv = uu_list_first(instance->start_pids); 2958324baee5Sstevep rv != NULL; 2959324baee5Sstevep rv = uu_list_next(instance->start_pids, rv)) { 2960324baee5Sstevep if ((kill((pid_t)rv->val, sig) != 0) && 2961324baee5Sstevep (errno != ESRCH)) { 2962324baee5Sstevep ret = IMRET_FAILURE; 2963324baee5Sstevep error_msg(gettext("Unable to kill " 29647cd7ea0bSrs "start process (%ld) of instance %s: %s"), 29657cd7ea0bSrs rv->val, instance->fmri, strerror(errno)); 2966324baee5Sstevep } 2967324baee5Sstevep } 2968324baee5Sstevep return (ret); 2969324baee5Sstevep } 2970324baee5Sstevep 29717c478bd9Sstevel@tonic-gate /* 29727c478bd9Sstevel@tonic-gate * Runs the specified method of the specified service instance. 29737c478bd9Sstevel@tonic-gate * If the method was never specified, we handle it the same as if the 29747c478bd9Sstevel@tonic-gate * method was called and returned success, carrying on any transition the 29757c478bd9Sstevel@tonic-gate * instance may be in the midst of. 29767c478bd9Sstevel@tonic-gate * If the method isn't executable in its specified profile or an error occurs 29777c478bd9Sstevel@tonic-gate * forking a process to run the method in the function returns -1. 29787c478bd9Sstevel@tonic-gate * If a method binary is successfully executed, the function switches the 29797c478bd9Sstevel@tonic-gate * instance's cur state to the method's associated 'run' state and the next 29807c478bd9Sstevel@tonic-gate * state to the methods associated next state. 29817c478bd9Sstevel@tonic-gate * Returns -1 if there's an error before forking, else 0. 29827c478bd9Sstevel@tonic-gate */ 29837c478bd9Sstevel@tonic-gate int 29847c478bd9Sstevel@tonic-gate run_method(instance_t *instance, instance_method_t method, 29857c478bd9Sstevel@tonic-gate const proto_info_t *start_info) 29867c478bd9Sstevel@tonic-gate { 29877c478bd9Sstevel@tonic-gate pid_t child_pid; 29887c478bd9Sstevel@tonic-gate method_info_t *mi; 29897c478bd9Sstevel@tonic-gate struct method_context *mthd_ctxt = NULL; 2990324baee5Sstevep int sig = 0; 29917c478bd9Sstevel@tonic-gate int ret; 29927c478bd9Sstevel@tonic-gate instance_cfg_t *cfg = instance->config; 29937c478bd9Sstevel@tonic-gate ctid_t cid; 29947c478bd9Sstevel@tonic-gate boolean_t trans_failure = B_TRUE; 29957c478bd9Sstevel@tonic-gate int serrno; 29967c478bd9Sstevel@tonic-gate 29977c478bd9Sstevel@tonic-gate /* 29987c478bd9Sstevel@tonic-gate * Don't bother updating the instance's state for the start method 29997c478bd9Sstevel@tonic-gate * as there isn't a separate start method state. 30007c478bd9Sstevel@tonic-gate */ 30017c478bd9Sstevel@tonic-gate if (method != IM_START) 30027c478bd9Sstevel@tonic-gate update_instance_states(instance, get_method_state(method), 30037c478bd9Sstevel@tonic-gate methods[method].dst_state, 30047c478bd9Sstevel@tonic-gate get_method_error_success(method)); 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate if ((mi = cfg->methods[method]) == NULL) { 30077c478bd9Sstevel@tonic-gate /* 3008324baee5Sstevep * If the absent method is IM_OFFLINE, default action needs 3009324baee5Sstevep * to be taken to avoid lingering processes which can prevent 3010324baee5Sstevep * the upcoming rebinding from happening. 30117c478bd9Sstevel@tonic-gate */ 3012324baee5Sstevep if ((method == IM_OFFLINE) && instance->config->basic->iswait) { 3013324baee5Sstevep warn_msg(gettext("inetd_offline method for instance %s " 3014324baee5Sstevep "is unspecified. Taking default action: kill."), 3015324baee5Sstevep instance->fmri); 3016324baee5Sstevep (void) str2sig("TERM", &sig); 3017324baee5Sstevep ret = smf_kill_process(instance, sig); 3018324baee5Sstevep process_non_start_term(instance, ret); 3019324baee5Sstevep return (0); 3020324baee5Sstevep } else { 3021324baee5Sstevep process_non_start_term(instance, IMRET_SUCCESS); 3022324baee5Sstevep return (0); 3023324baee5Sstevep } 30247c478bd9Sstevel@tonic-gate } 30257c478bd9Sstevel@tonic-gate 30267c478bd9Sstevel@tonic-gate /* Handle special method tokens, not allowed on start */ 30277c478bd9Sstevel@tonic-gate if (method != IM_START) { 30287c478bd9Sstevel@tonic-gate if (restarter_is_null_method(mi->exec_path)) { 30297c478bd9Sstevel@tonic-gate /* :true means nothing should be done */ 30307c478bd9Sstevel@tonic-gate process_non_start_term(instance, IMRET_SUCCESS); 30317c478bd9Sstevel@tonic-gate return (0); 30327c478bd9Sstevel@tonic-gate } 30337c478bd9Sstevel@tonic-gate 30347c478bd9Sstevel@tonic-gate if ((sig = restarter_is_kill_method(mi->exec_path)) >= 0) { 30357c478bd9Sstevel@tonic-gate /* Carry out contract assassination */ 303694501b61Sskamm ret = iterate_repository_contracts(instance, sig); 30377c478bd9Sstevel@tonic-gate /* ENOENT means we didn't find any contracts */ 30387c478bd9Sstevel@tonic-gate if (ret != 0 && ret != ENOENT) { 30397c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to send signal %d " 30407c478bd9Sstevel@tonic-gate "to contracts of instance %s: %s"), sig, 30417c478bd9Sstevel@tonic-gate instance->fmri, strerror(ret)); 30427c478bd9Sstevel@tonic-gate goto prefork_failure; 30437c478bd9Sstevel@tonic-gate } else { 30447c478bd9Sstevel@tonic-gate process_non_start_term(instance, IMRET_SUCCESS); 30457c478bd9Sstevel@tonic-gate return (0); 30467c478bd9Sstevel@tonic-gate } 30477c478bd9Sstevel@tonic-gate } 30487c478bd9Sstevel@tonic-gate 30497c478bd9Sstevel@tonic-gate if ((sig = restarter_is_kill_proc_method(mi->exec_path)) >= 0) { 3050324baee5Sstevep ret = smf_kill_process(instance, sig); 30517c478bd9Sstevel@tonic-gate process_non_start_term(instance, ret); 30527c478bd9Sstevel@tonic-gate return (0); 30537c478bd9Sstevel@tonic-gate } 30547c478bd9Sstevel@tonic-gate } 30557c478bd9Sstevel@tonic-gate 30567c478bd9Sstevel@tonic-gate /* 30577c478bd9Sstevel@tonic-gate * Get the associated method context before the fork so we can 30587c478bd9Sstevel@tonic-gate * modify the instances state if things go wrong. 30597c478bd9Sstevel@tonic-gate */ 30607c478bd9Sstevel@tonic-gate if ((mthd_ctxt = read_method_context(instance->fmri, 3061870ad75aSSean Wilcox methods[method].name, mi->exec_path)) == NULL) 30627c478bd9Sstevel@tonic-gate goto prefork_failure; 30637c478bd9Sstevel@tonic-gate 30647c478bd9Sstevel@tonic-gate /* 30657c478bd9Sstevel@tonic-gate * Perform some basic checks before we fork to limit the possibility 30667c478bd9Sstevel@tonic-gate * of exec failures, so we can modify the instance state if necessary. 30677c478bd9Sstevel@tonic-gate */ 30687c478bd9Sstevel@tonic-gate if (!passes_basic_exec_checks(instance->fmri, methods[method].name, 30697c478bd9Sstevel@tonic-gate mi->exec_path)) { 30707c478bd9Sstevel@tonic-gate trans_failure = B_FALSE; 30717c478bd9Sstevel@tonic-gate goto prefork_failure; 30727c478bd9Sstevel@tonic-gate } 30737c478bd9Sstevel@tonic-gate 30747b209c2cSacruz if (contract_prefork(instance->fmri, method) == -1) 30757c478bd9Sstevel@tonic-gate goto prefork_failure; 30767c478bd9Sstevel@tonic-gate child_pid = fork(); 30777c478bd9Sstevel@tonic-gate serrno = errno; 30787c478bd9Sstevel@tonic-gate contract_postfork(); 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate switch (child_pid) { 30817c478bd9Sstevel@tonic-gate case -1: 30827c478bd9Sstevel@tonic-gate error_msg(gettext( 30837c478bd9Sstevel@tonic-gate "Unable to fork %s method of instance %s: %s"), 30847c478bd9Sstevel@tonic-gate methods[method].name, instance->fmri, strerror(serrno)); 30857c478bd9Sstevel@tonic-gate if ((serrno != EAGAIN) && (serrno != ENOMEM)) 30867c478bd9Sstevel@tonic-gate trans_failure = B_FALSE; 30877c478bd9Sstevel@tonic-gate goto prefork_failure; 30887c478bd9Sstevel@tonic-gate case 0: /* child */ 30897c478bd9Sstevel@tonic-gate exec_method(instance, method, mi, mthd_ctxt, start_info); 3090b823d4c7Sdstaff /* NOTREACHED */ 30917c478bd9Sstevel@tonic-gate default: /* parent */ 30927c478bd9Sstevel@tonic-gate restarter_free_method_context(mthd_ctxt); 30937c478bd9Sstevel@tonic-gate mthd_ctxt = NULL; 30947c478bd9Sstevel@tonic-gate 30957c478bd9Sstevel@tonic-gate if (get_latest_contract(&cid) < 0) 30967c478bd9Sstevel@tonic-gate cid = -1; 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate /* 30997c478bd9Sstevel@tonic-gate * Register this method so its termination is noticed and 31007c478bd9Sstevel@tonic-gate * the state transition this method participates in is 31017c478bd9Sstevel@tonic-gate * continued. 31027c478bd9Sstevel@tonic-gate */ 31035e2844d4SRenaud Manus if (register_method(instance, child_pid, cid, method, 31045e2844d4SRenaud Manus start_info->proto) != 0) { 31057c478bd9Sstevel@tonic-gate /* 31067c478bd9Sstevel@tonic-gate * Since we will never find out about the termination 31077c478bd9Sstevel@tonic-gate * of this method, if it's a non-start method treat 31087c478bd9Sstevel@tonic-gate * is as a failure so we don't block restarter event 31097c478bd9Sstevel@tonic-gate * processing on it whilst it languishes in a method 31107c478bd9Sstevel@tonic-gate * running state. 31117c478bd9Sstevel@tonic-gate */ 31127c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to monitor status of " 31137c478bd9Sstevel@tonic-gate "%s method of instance %s"), methods[method].name, 31147c478bd9Sstevel@tonic-gate instance->fmri); 31157c478bd9Sstevel@tonic-gate if (method != IM_START) 31167c478bd9Sstevel@tonic-gate process_non_start_term(instance, IMRET_FAILURE); 31177c478bd9Sstevel@tonic-gate } 31187c478bd9Sstevel@tonic-gate 31197c478bd9Sstevel@tonic-gate add_method_ids(instance, child_pid, cid, method); 31207c478bd9Sstevel@tonic-gate 31217c478bd9Sstevel@tonic-gate /* do tcp tracing for those nowait instances that request it */ 31227c478bd9Sstevel@tonic-gate if ((method == IM_START) && cfg->basic->do_tcp_trace && 31237c478bd9Sstevel@tonic-gate !cfg->basic->iswait) { 31247c478bd9Sstevel@tonic-gate char buf[INET6_ADDRSTRLEN]; 31257c478bd9Sstevel@tonic-gate 31267c478bd9Sstevel@tonic-gate syslog(LOG_NOTICE, "%s[%d] from %s %d", 31277c478bd9Sstevel@tonic-gate cfg->basic->svc_name, child_pid, 31287c478bd9Sstevel@tonic-gate inet_ntop_native(instance->remote_addr.ss_family, 31297c478bd9Sstevel@tonic-gate SS_SINADDR(instance->remote_addr), buf, 31307c478bd9Sstevel@tonic-gate sizeof (buf)), 31317c478bd9Sstevel@tonic-gate ntohs(SS_PORT(instance->remote_addr))); 31327c478bd9Sstevel@tonic-gate } 31337c478bd9Sstevel@tonic-gate } 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate return (0); 31367c478bd9Sstevel@tonic-gate 31377c478bd9Sstevel@tonic-gate prefork_failure: 31387c478bd9Sstevel@tonic-gate if (mthd_ctxt != NULL) { 31397c478bd9Sstevel@tonic-gate restarter_free_method_context(mthd_ctxt); 31407c478bd9Sstevel@tonic-gate mthd_ctxt = NULL; 31417c478bd9Sstevel@tonic-gate } 31427c478bd9Sstevel@tonic-gate 31437c478bd9Sstevel@tonic-gate if (method == IM_START) { 31447c478bd9Sstevel@tonic-gate /* 31457c478bd9Sstevel@tonic-gate * Only place a start method in maintenance if we're sure 31467c478bd9Sstevel@tonic-gate * that the failure was non-transient. 31477c478bd9Sstevel@tonic-gate */ 31487c478bd9Sstevel@tonic-gate if (!trans_failure) { 31497c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 31507c478bd9Sstevel@tonic-gate update_state(instance, IIS_MAINTENANCE, RERR_FAULT); 31517c478bd9Sstevel@tonic-gate } 31527c478bd9Sstevel@tonic-gate } else { 31537c478bd9Sstevel@tonic-gate /* treat the failure as if the method ran and failed */ 31547c478bd9Sstevel@tonic-gate process_non_start_term(instance, IMRET_FAILURE); 31557c478bd9Sstevel@tonic-gate } 31567c478bd9Sstevel@tonic-gate 31577c478bd9Sstevel@tonic-gate return (-1); 31587c478bd9Sstevel@tonic-gate } 31597c478bd9Sstevel@tonic-gate 3160ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India static int 3161ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India pending_connections(instance_t *instance, proto_info_t *pi) 3162ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India { 3163ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India if (instance->config->basic->istlx) { 3164ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_info_t *tl = (tlx_info_t *)pi; 3165ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India 3166ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India return (uu_list_numnodes(tl->conn_ind_queue) != 0); 3167ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India } else { 3168ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India return (0); 3169ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India } 3170ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India } 3171ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India 31727c478bd9Sstevel@tonic-gate static int 31737c478bd9Sstevel@tonic-gate accept_connection(instance_t *instance, proto_info_t *pi) 31747c478bd9Sstevel@tonic-gate { 31757c478bd9Sstevel@tonic-gate int fd; 31767c478bd9Sstevel@tonic-gate socklen_t size; 31777c478bd9Sstevel@tonic-gate 31787c478bd9Sstevel@tonic-gate if (instance->config->basic->istlx) { 3179ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_info_t *tl = (tlx_info_t *)pi; 3180ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_pending_counter = \ 3181ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_pending_counter - uu_list_numnodes(tl->conn_ind_queue); 3182ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India 31837c478bd9Sstevel@tonic-gate fd = tlx_accept(instance->fmri, (tlx_info_t *)pi, 31847c478bd9Sstevel@tonic-gate &(instance->remote_addr)); 3185ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India 3186ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_pending_counter = \ 3187ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India tlx_pending_counter + uu_list_numnodes(tl->conn_ind_queue); 31887c478bd9Sstevel@tonic-gate } else { 31897c478bd9Sstevel@tonic-gate size = sizeof (instance->remote_addr); 31907c478bd9Sstevel@tonic-gate fd = accept(pi->listen_fd, 31917c478bd9Sstevel@tonic-gate (struct sockaddr *)&(instance->remote_addr), &size); 31927c478bd9Sstevel@tonic-gate if (fd < 0) 31937c478bd9Sstevel@tonic-gate error_msg("accept: %s", strerror(errno)); 31947c478bd9Sstevel@tonic-gate } 31957c478bd9Sstevel@tonic-gate 31967c478bd9Sstevel@tonic-gate return (fd); 31977c478bd9Sstevel@tonic-gate } 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate /* 32007c478bd9Sstevel@tonic-gate * Handle an incoming connection request for a nowait service. 32017c478bd9Sstevel@tonic-gate * This involves accepting the incoming connection on a new fd. Connection 32027c478bd9Sstevel@tonic-gate * rate checks are then performed, transitioning the service to the 32037c478bd9Sstevel@tonic-gate * conrate offline state if these fail. Otherwise, the service's start method 32047c478bd9Sstevel@tonic-gate * is run (performing TCP wrappers checks if applicable as we do), and on 32057c478bd9Sstevel@tonic-gate * success concurrent copies checking is done, transitioning the service to the 32067c478bd9Sstevel@tonic-gate * copies offline state if this fails. 32077c478bd9Sstevel@tonic-gate */ 32087c478bd9Sstevel@tonic-gate static void 32097c478bd9Sstevel@tonic-gate process_nowait_request(instance_t *instance, proto_info_t *pi) 32107c478bd9Sstevel@tonic-gate { 32117c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 32127c478bd9Sstevel@tonic-gate int ret; 32137c478bd9Sstevel@tonic-gate adt_event_data_t *ae; 32147c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate /* accept nowait service connections on a new fd */ 32177c478bd9Sstevel@tonic-gate if ((instance->conn_fd = accept_connection(instance, pi)) == -1) { 32187c478bd9Sstevel@tonic-gate /* 32197c478bd9Sstevel@tonic-gate * Failed accept. Return and allow the event loop to initiate 32207c478bd9Sstevel@tonic-gate * another attempt later if the request is still present. 32217c478bd9Sstevel@tonic-gate */ 32227c478bd9Sstevel@tonic-gate return; 32237c478bd9Sstevel@tonic-gate } 32247c478bd9Sstevel@tonic-gate 32257c478bd9Sstevel@tonic-gate /* 32267c478bd9Sstevel@tonic-gate * Limit connection rate of nowait services. If either conn_rate_max 32277c478bd9Sstevel@tonic-gate * or conn_rate_offline are <= 0, no connection rate limit checking 32287c478bd9Sstevel@tonic-gate * is done. If the configured rate is exceeded, the instance is taken 32297c478bd9Sstevel@tonic-gate * to the connrate_offline state and a timer scheduled to try and 32307c478bd9Sstevel@tonic-gate * bring the instance back online after the configured offline time. 32317c478bd9Sstevel@tonic-gate */ 32327c478bd9Sstevel@tonic-gate if ((cfg->conn_rate_max > 0) && (cfg->conn_rate_offline > 0)) { 32337c478bd9Sstevel@tonic-gate if (instance->conn_rate_count++ == 0) { 32347c478bd9Sstevel@tonic-gate instance->conn_rate_start = time(NULL); 32357c478bd9Sstevel@tonic-gate } else if (instance->conn_rate_count > 32367c478bd9Sstevel@tonic-gate cfg->conn_rate_max) { 32377c478bd9Sstevel@tonic-gate time_t now = time(NULL); 32387c478bd9Sstevel@tonic-gate 32397c478bd9Sstevel@tonic-gate if ((now - instance->conn_rate_start) > 1) { 32407c478bd9Sstevel@tonic-gate instance->conn_rate_start = now; 32417c478bd9Sstevel@tonic-gate instance->conn_rate_count = 1; 32427c478bd9Sstevel@tonic-gate } else { 32437c478bd9Sstevel@tonic-gate /* Generate audit record */ 32447c478bd9Sstevel@tonic-gate if ((ae = adt_alloc_event(audit_handle, 32457c478bd9Sstevel@tonic-gate ADT_inetd_ratelimit)) == NULL) { 32467c478bd9Sstevel@tonic-gate error_msg(gettext("Unable to allocate " 32477c478bd9Sstevel@tonic-gate "rate limit audit event")); 32487c478bd9Sstevel@tonic-gate } else { 32497c478bd9Sstevel@tonic-gate adt_inetd_ratelimit_t *rl = 32507c478bd9Sstevel@tonic-gate &ae->adt_inetd_ratelimit; 32517c478bd9Sstevel@tonic-gate /* 32527c478bd9Sstevel@tonic-gate * The inetd_ratelimit audit 32537c478bd9Sstevel@tonic-gate * record consists of: 32547c478bd9Sstevel@tonic-gate * Service name 32557c478bd9Sstevel@tonic-gate * Connection rate limit 32567c478bd9Sstevel@tonic-gate */ 32577c478bd9Sstevel@tonic-gate rl->service_name = cfg->svc_name; 32587c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), 32597c478bd9Sstevel@tonic-gate "limit=%lld", cfg->conn_rate_max); 32607c478bd9Sstevel@tonic-gate rl->limit = buf; 32617c478bd9Sstevel@tonic-gate (void) adt_put_event(ae, ADT_SUCCESS, 32627c478bd9Sstevel@tonic-gate ADT_SUCCESS); 32637c478bd9Sstevel@tonic-gate adt_free_event(ae); 32647c478bd9Sstevel@tonic-gate } 32657c478bd9Sstevel@tonic-gate 32667c478bd9Sstevel@tonic-gate error_msg(gettext( 32677c478bd9Sstevel@tonic-gate "Instance %s has exceeded its configured " 32687c478bd9Sstevel@tonic-gate "connection rate, additional connections " 32697c478bd9Sstevel@tonic-gate "will not be accepted for %d seconds"), 32707c478bd9Sstevel@tonic-gate instance->fmri, cfg->conn_rate_offline); 32717c478bd9Sstevel@tonic-gate 32727c478bd9Sstevel@tonic-gate close_net_fd(instance, instance->conn_fd); 32737c478bd9Sstevel@tonic-gate instance->conn_fd = -1; 32747c478bd9Sstevel@tonic-gate 32757c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 32767c478bd9Sstevel@tonic-gate 32777c478bd9Sstevel@tonic-gate instance->conn_rate_count = 0; 32787c478bd9Sstevel@tonic-gate 32797c478bd9Sstevel@tonic-gate instance->conn_rate_exceeded = B_TRUE; 32807c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_OFFLINE, NULL); 32817c478bd9Sstevel@tonic-gate 32827c478bd9Sstevel@tonic-gate return; 32837c478bd9Sstevel@tonic-gate } 32847c478bd9Sstevel@tonic-gate } 32857c478bd9Sstevel@tonic-gate } 32867c478bd9Sstevel@tonic-gate 32877c478bd9Sstevel@tonic-gate ret = run_method(instance, IM_START, pi); 32887c478bd9Sstevel@tonic-gate 32897c478bd9Sstevel@tonic-gate close_net_fd(instance, instance->conn_fd); 32907c478bd9Sstevel@tonic-gate instance->conn_fd = -1; 32917c478bd9Sstevel@tonic-gate 32927c478bd9Sstevel@tonic-gate if (ret == -1) /* the method wasn't forked */ 32937c478bd9Sstevel@tonic-gate return; 32947c478bd9Sstevel@tonic-gate 32957c478bd9Sstevel@tonic-gate instance->copies++; 32967c478bd9Sstevel@tonic-gate 32977c478bd9Sstevel@tonic-gate /* 32987c478bd9Sstevel@tonic-gate * Limit concurrent connections of nowait services. 32997c478bd9Sstevel@tonic-gate */ 33007c478bd9Sstevel@tonic-gate if (copies_limit_exceeded(instance)) { 33017c478bd9Sstevel@tonic-gate /* Generate audit record */ 33027c478bd9Sstevel@tonic-gate if ((ae = adt_alloc_event(audit_handle, ADT_inetd_copylimit)) 33037c478bd9Sstevel@tonic-gate == NULL) { 33047c478bd9Sstevel@tonic-gate error_msg(gettext("Unable to allocate copy limit " 33057c478bd9Sstevel@tonic-gate "audit event")); 33067c478bd9Sstevel@tonic-gate } else { 33077c478bd9Sstevel@tonic-gate /* 33087c478bd9Sstevel@tonic-gate * The inetd_copylimit audit record consists of: 33097c478bd9Sstevel@tonic-gate * Service name 33107c478bd9Sstevel@tonic-gate * Copy limit 33117c478bd9Sstevel@tonic-gate */ 33127c478bd9Sstevel@tonic-gate ae->adt_inetd_copylimit.service_name = cfg->svc_name; 33137c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "limit=%lld", 33147c478bd9Sstevel@tonic-gate cfg->max_copies); 33157c478bd9Sstevel@tonic-gate ae->adt_inetd_copylimit.limit = buf; 33167c478bd9Sstevel@tonic-gate (void) adt_put_event(ae, ADT_SUCCESS, ADT_SUCCESS); 33177c478bd9Sstevel@tonic-gate adt_free_event(ae); 33187c478bd9Sstevel@tonic-gate } 33197c478bd9Sstevel@tonic-gate 33207c478bd9Sstevel@tonic-gate warn_msg(gettext("Instance %s has reached its maximum " 33217c478bd9Sstevel@tonic-gate "configured copies, no new connections will be accepted"), 33227c478bd9Sstevel@tonic-gate instance->fmri); 33237c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 33247c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_OFFLINE, NULL); 33257c478bd9Sstevel@tonic-gate } 33267c478bd9Sstevel@tonic-gate } 33277c478bd9Sstevel@tonic-gate 33287c478bd9Sstevel@tonic-gate /* 33297c478bd9Sstevel@tonic-gate * Handle an incoming request for a wait type service. 33307c478bd9Sstevel@tonic-gate * Failure rate checking is done first, taking the service to the maintenance 33317c478bd9Sstevel@tonic-gate * state if the checks fail. Following this, the service's start method is run, 33327c478bd9Sstevel@tonic-gate * and on success, we stop listening for new requests for this service. 33337c478bd9Sstevel@tonic-gate */ 33347c478bd9Sstevel@tonic-gate static void 33357c478bd9Sstevel@tonic-gate process_wait_request(instance_t *instance, const proto_info_t *pi) 33367c478bd9Sstevel@tonic-gate { 33377c478bd9Sstevel@tonic-gate basic_cfg_t *cfg = instance->config->basic; 33387c478bd9Sstevel@tonic-gate int ret; 33397c478bd9Sstevel@tonic-gate adt_event_data_t *ae; 33407c478bd9Sstevel@tonic-gate char buf[BUFSIZ]; 33417c478bd9Sstevel@tonic-gate 33427c478bd9Sstevel@tonic-gate instance->conn_fd = pi->listen_fd; 33437c478bd9Sstevel@tonic-gate 33447c478bd9Sstevel@tonic-gate /* 33457c478bd9Sstevel@tonic-gate * Detect broken servers and transition them to maintenance. If a 33467c478bd9Sstevel@tonic-gate * wait type service exits without accepting the connection or 33477c478bd9Sstevel@tonic-gate * consuming (reading) the datagram, that service's descriptor will 33487c478bd9Sstevel@tonic-gate * select readable again, and inetd will fork another instance of 33497c478bd9Sstevel@tonic-gate * the server. If either wait_fail_cnt or wait_fail_interval are <= 0, 33507c478bd9Sstevel@tonic-gate * no failure rate detection is done. 33517c478bd9Sstevel@tonic-gate */ 33527c478bd9Sstevel@tonic-gate if ((cfg->wait_fail_cnt > 0) && (cfg->wait_fail_interval > 0)) { 33537c478bd9Sstevel@tonic-gate if (instance->fail_rate_count++ == 0) { 33547c478bd9Sstevel@tonic-gate instance->fail_rate_start = time(NULL); 33557c478bd9Sstevel@tonic-gate } else if (instance->fail_rate_count > cfg->wait_fail_cnt) { 33567c478bd9Sstevel@tonic-gate time_t now = time(NULL); 33577c478bd9Sstevel@tonic-gate 33587c478bd9Sstevel@tonic-gate if ((now - instance->fail_rate_start) > 33597c478bd9Sstevel@tonic-gate cfg->wait_fail_interval) { 33607c478bd9Sstevel@tonic-gate instance->fail_rate_start = now; 33617c478bd9Sstevel@tonic-gate instance->fail_rate_count = 1; 33627c478bd9Sstevel@tonic-gate } else { 33637c478bd9Sstevel@tonic-gate /* Generate audit record */ 33647c478bd9Sstevel@tonic-gate if ((ae = adt_alloc_event(audit_handle, 33657c478bd9Sstevel@tonic-gate ADT_inetd_failrate)) == NULL) { 33667c478bd9Sstevel@tonic-gate error_msg(gettext("Unable to allocate " 33677c478bd9Sstevel@tonic-gate "failure rate audit event")); 33687c478bd9Sstevel@tonic-gate } else { 33697c478bd9Sstevel@tonic-gate adt_inetd_failrate_t *fr = 33707c478bd9Sstevel@tonic-gate &ae->adt_inetd_failrate; 33717c478bd9Sstevel@tonic-gate /* 33727c478bd9Sstevel@tonic-gate * The inetd_failrate audit record 33737c478bd9Sstevel@tonic-gate * consists of: 33747c478bd9Sstevel@tonic-gate * Service name 33757c478bd9Sstevel@tonic-gate * Failure rate 33767c478bd9Sstevel@tonic-gate * Interval 33777c478bd9Sstevel@tonic-gate * Last two are expressed as k=v pairs 33787c478bd9Sstevel@tonic-gate * in the values field. 33797c478bd9Sstevel@tonic-gate */ 33807c478bd9Sstevel@tonic-gate fr->service_name = cfg->svc_name; 33817c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), 33827c478bd9Sstevel@tonic-gate "limit=%lld,interval=%d", 33837c478bd9Sstevel@tonic-gate cfg->wait_fail_cnt, 33847c478bd9Sstevel@tonic-gate cfg->wait_fail_interval); 33857c478bd9Sstevel@tonic-gate fr->values = buf; 33867c478bd9Sstevel@tonic-gate (void) adt_put_event(ae, ADT_SUCCESS, 33877c478bd9Sstevel@tonic-gate ADT_SUCCESS); 33887c478bd9Sstevel@tonic-gate adt_free_event(ae); 33897c478bd9Sstevel@tonic-gate } 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate error_msg(gettext( 33927c478bd9Sstevel@tonic-gate "Instance %s has exceeded its configured " 33937c478bd9Sstevel@tonic-gate "failure rate, transitioning to " 33947c478bd9Sstevel@tonic-gate "maintenance"), instance->fmri); 33957c478bd9Sstevel@tonic-gate instance->fail_rate_count = 0; 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate destroy_bound_fds(instance); 33987c478bd9Sstevel@tonic-gate 33997c478bd9Sstevel@tonic-gate instance->maintenance_req = B_TRUE; 34007c478bd9Sstevel@tonic-gate (void) run_method(instance, IM_OFFLINE, NULL); 34017c478bd9Sstevel@tonic-gate return; 34027c478bd9Sstevel@tonic-gate } 34037c478bd9Sstevel@tonic-gate } 34047c478bd9Sstevel@tonic-gate } 34057c478bd9Sstevel@tonic-gate 34067c478bd9Sstevel@tonic-gate ret = run_method(instance, IM_START, pi); 34077c478bd9Sstevel@tonic-gate 34087c478bd9Sstevel@tonic-gate instance->conn_fd = -1; 34097c478bd9Sstevel@tonic-gate 34107c478bd9Sstevel@tonic-gate if (ret == 0) { 34117c478bd9Sstevel@tonic-gate /* 34127c478bd9Sstevel@tonic-gate * Stop listening for connections now we've fired off the 34137c478bd9Sstevel@tonic-gate * server for a wait type instance. 34147c478bd9Sstevel@tonic-gate */ 34155e2844d4SRenaud Manus (void) poll_bound_fds(instance, B_FALSE, pi->proto); 34167c478bd9Sstevel@tonic-gate } 34177c478bd9Sstevel@tonic-gate } 34187c478bd9Sstevel@tonic-gate 34197c478bd9Sstevel@tonic-gate /* 34207c478bd9Sstevel@tonic-gate * Process any networks requests for each proto for each instance. 34217c478bd9Sstevel@tonic-gate */ 34227c478bd9Sstevel@tonic-gate void 34237c478bd9Sstevel@tonic-gate process_network_events(void) 34247c478bd9Sstevel@tonic-gate { 34257c478bd9Sstevel@tonic-gate instance_t *instance; 34267c478bd9Sstevel@tonic-gate 34277c478bd9Sstevel@tonic-gate for (instance = uu_list_first(instance_list); instance != NULL; 34287c478bd9Sstevel@tonic-gate instance = uu_list_next(instance_list, instance)) { 34297c478bd9Sstevel@tonic-gate basic_cfg_t *cfg; 34307c478bd9Sstevel@tonic-gate proto_info_t *pi; 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate /* 34337c478bd9Sstevel@tonic-gate * Ignore instances in states that definitely don't have any 34347c478bd9Sstevel@tonic-gate * listening fds. 34357c478bd9Sstevel@tonic-gate */ 34367c478bd9Sstevel@tonic-gate switch (instance->cur_istate) { 34377c478bd9Sstevel@tonic-gate case IIS_ONLINE: 34387c478bd9Sstevel@tonic-gate case IIS_DEGRADED: 34397c478bd9Sstevel@tonic-gate case IIS_IN_REFRESH_METHOD: 34407c478bd9Sstevel@tonic-gate break; 34417c478bd9Sstevel@tonic-gate default: 34427c478bd9Sstevel@tonic-gate continue; 34437c478bd9Sstevel@tonic-gate } 34447c478bd9Sstevel@tonic-gate 34457c478bd9Sstevel@tonic-gate cfg = instance->config->basic; 34467c478bd9Sstevel@tonic-gate 34477c478bd9Sstevel@tonic-gate for (pi = uu_list_first(cfg->proto_list); pi != NULL; 34487c478bd9Sstevel@tonic-gate pi = uu_list_next(cfg->proto_list, pi)) { 3449ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India if (((pi->listen_fd != -1) && 3450ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India isset_pollfd(pi->listen_fd)) || 3451ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India pending_connections(instance, pi)) { 34527c478bd9Sstevel@tonic-gate if (cfg->iswait) { 34537c478bd9Sstevel@tonic-gate process_wait_request(instance, pi); 34547c478bd9Sstevel@tonic-gate } else { 34557c478bd9Sstevel@tonic-gate process_nowait_request(instance, pi); 34567c478bd9Sstevel@tonic-gate } 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate } 34597c478bd9Sstevel@tonic-gate } 34607c478bd9Sstevel@tonic-gate } 34617c478bd9Sstevel@tonic-gate 34627c478bd9Sstevel@tonic-gate /* ARGSUSED0 */ 34637c478bd9Sstevel@tonic-gate static void 34647c478bd9Sstevel@tonic-gate sigterm_handler(int sig) 34657c478bd9Sstevel@tonic-gate { 34667c478bd9Sstevel@tonic-gate got_sigterm = B_TRUE; 34677c478bd9Sstevel@tonic-gate } 34687c478bd9Sstevel@tonic-gate 34697c478bd9Sstevel@tonic-gate /* ARGSUSED0 */ 34707c478bd9Sstevel@tonic-gate static void 34717c478bd9Sstevel@tonic-gate sighup_handler(int sig) 34727c478bd9Sstevel@tonic-gate { 34737c478bd9Sstevel@tonic-gate refresh_inetd_requested = B_TRUE; 34747c478bd9Sstevel@tonic-gate } 34757c478bd9Sstevel@tonic-gate 34767c478bd9Sstevel@tonic-gate /* 34777c478bd9Sstevel@tonic-gate * inetd's major work loop. This function sits in poll waiting for events 34787c478bd9Sstevel@tonic-gate * to occur, processing them when they do. The possible events are 34797c478bd9Sstevel@tonic-gate * master restarter requests, expired timer queue timers, stop/refresh signal 34807c478bd9Sstevel@tonic-gate * requests, contract events indicating process termination, stop/refresh 34817c478bd9Sstevel@tonic-gate * requests originating from one of the stop/refresh inetd processes and 34827c478bd9Sstevel@tonic-gate * network events. 34837c478bd9Sstevel@tonic-gate * The loop is exited when a stop request is received and processed, and 34847c478bd9Sstevel@tonic-gate * all the instances have reached a suitable 'stopping' state. 34857c478bd9Sstevel@tonic-gate */ 34867c478bd9Sstevel@tonic-gate static void 34877c478bd9Sstevel@tonic-gate event_loop(void) 34887c478bd9Sstevel@tonic-gate { 34897c478bd9Sstevel@tonic-gate instance_t *instance; 34907c478bd9Sstevel@tonic-gate int timeout; 34917c478bd9Sstevel@tonic-gate 34927c478bd9Sstevel@tonic-gate for (;;) { 34937c478bd9Sstevel@tonic-gate int pret = -1; 34947c478bd9Sstevel@tonic-gate 3495ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India if (tlx_pending_counter != 0) 3496ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India timeout = 0; 3497ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India else 3498ca35ed50SYateesh Kumar Vusirika - Sun Microsystems - Bangalore India timeout = iu_earliest_timer(timer_queue); 34997c478bd9Sstevel@tonic-gate 35007c478bd9Sstevel@tonic-gate if (!got_sigterm && !refresh_inetd_requested) { 35017c478bd9Sstevel@tonic-gate pret = poll(poll_fds, num_pollfds, timeout); 35027c478bd9Sstevel@tonic-gate if ((pret == -1) && (errno != EINTR)) { 35037c478bd9Sstevel@tonic-gate error_msg(gettext("poll failure: %s"), 35047c478bd9Sstevel@tonic-gate strerror(errno)); 35057c478bd9Sstevel@tonic-gate continue; 35067c478bd9Sstevel@tonic-gate } 35077c478bd9Sstevel@tonic-gate } 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate if (got_sigterm) { 35107c478bd9Sstevel@tonic-gate msg_fini(); 35117c478bd9Sstevel@tonic-gate inetd_stop(); 35127c478bd9Sstevel@tonic-gate got_sigterm = B_FALSE; 35137c478bd9Sstevel@tonic-gate goto check_if_stopped; 35147c478bd9Sstevel@tonic-gate } 35157c478bd9Sstevel@tonic-gate 35167c478bd9Sstevel@tonic-gate /* 35177c478bd9Sstevel@tonic-gate * Process any stop/refresh requests from the Unix Domain 35187c478bd9Sstevel@tonic-gate * Socket. 35197c478bd9Sstevel@tonic-gate */ 35207c478bd9Sstevel@tonic-gate if ((pret != -1) && isset_pollfd(uds_fd)) { 35217c478bd9Sstevel@tonic-gate while (process_uds_event() == 0) 35227c478bd9Sstevel@tonic-gate ; 35237c478bd9Sstevel@tonic-gate } 35247c478bd9Sstevel@tonic-gate 35257c478bd9Sstevel@tonic-gate /* 35267c478bd9Sstevel@tonic-gate * Process refresh request. We do this check after the UDS 35277c478bd9Sstevel@tonic-gate * event check above, as it would be wasted processing if we 35287c478bd9Sstevel@tonic-gate * started refreshing inetd based on a SIGHUP, and then were 35297c478bd9Sstevel@tonic-gate * told to shut-down via a UDS event. 35307c478bd9Sstevel@tonic-gate */ 35317c478bd9Sstevel@tonic-gate if (refresh_inetd_requested) { 35327c478bd9Sstevel@tonic-gate refresh_inetd_requested = B_FALSE; 35337c478bd9Sstevel@tonic-gate if (!inetd_stopping) 35347c478bd9Sstevel@tonic-gate inetd_refresh(); 35357c478bd9Sstevel@tonic-gate } 35367c478bd9Sstevel@tonic-gate 35377c478bd9Sstevel@tonic-gate /* 35387c478bd9Sstevel@tonic-gate * We were interrupted by a signal. Don't waste any more 35397c478bd9Sstevel@tonic-gate * time processing a potentially inaccurate poll return. 35407c478bd9Sstevel@tonic-gate */ 35417c478bd9Sstevel@tonic-gate if (pret == -1) 35427c478bd9Sstevel@tonic-gate continue; 35437c478bd9Sstevel@tonic-gate 35447c478bd9Sstevel@tonic-gate /* 35457c478bd9Sstevel@tonic-gate * Process any instance restarter events. 35467c478bd9Sstevel@tonic-gate */ 35477c478bd9Sstevel@tonic-gate if (isset_pollfd(rst_event_pipe[PE_CONSUMER])) { 35487c478bd9Sstevel@tonic-gate while (process_restarter_event() == 0) 35497c478bd9Sstevel@tonic-gate ; 35507c478bd9Sstevel@tonic-gate } 35517c478bd9Sstevel@tonic-gate 35527c478bd9Sstevel@tonic-gate /* 35537c478bd9Sstevel@tonic-gate * Process any expired timers (bind retry, con-rate offline, 35547c478bd9Sstevel@tonic-gate * method timeouts). 35557c478bd9Sstevel@tonic-gate */ 35567c478bd9Sstevel@tonic-gate (void) iu_expire_timers(timer_queue); 35577c478bd9Sstevel@tonic-gate 35587c478bd9Sstevel@tonic-gate process_terminated_methods(); 35597c478bd9Sstevel@tonic-gate 35607c478bd9Sstevel@tonic-gate /* 35617c478bd9Sstevel@tonic-gate * If inetd is stopping, check whether all our managed 35627c478bd9Sstevel@tonic-gate * instances have been stopped and we can return. 35637c478bd9Sstevel@tonic-gate */ 35647c478bd9Sstevel@tonic-gate if (inetd_stopping) { 35657c478bd9Sstevel@tonic-gate check_if_stopped: 35667c478bd9Sstevel@tonic-gate for (instance = uu_list_first(instance_list); 35677c478bd9Sstevel@tonic-gate instance != NULL; 35687c478bd9Sstevel@tonic-gate instance = uu_list_next(instance_list, instance)) { 35697c478bd9Sstevel@tonic-gate if (!instance_stopped(instance)) { 35707c478bd9Sstevel@tonic-gate debug_msg("%s not yet stopped", 35717c478bd9Sstevel@tonic-gate instance->fmri); 35727c478bd9Sstevel@tonic-gate break; 35737c478bd9Sstevel@tonic-gate } 35747c478bd9Sstevel@tonic-gate } 35757c478bd9Sstevel@tonic-gate /* if all instances are stopped, return */ 35767c478bd9Sstevel@tonic-gate if (instance == NULL) 35777c478bd9Sstevel@tonic-gate return; 35787c478bd9Sstevel@tonic-gate } 35797c478bd9Sstevel@tonic-gate 35807c478bd9Sstevel@tonic-gate process_network_events(); 35817c478bd9Sstevel@tonic-gate } 35827c478bd9Sstevel@tonic-gate } 35837c478bd9Sstevel@tonic-gate 35847c478bd9Sstevel@tonic-gate static void 35857c478bd9Sstevel@tonic-gate fini(void) 35867c478bd9Sstevel@tonic-gate { 35877c478bd9Sstevel@tonic-gate method_fini(); 35887c478bd9Sstevel@tonic-gate uds_fini(); 35897c478bd9Sstevel@tonic-gate if (timer_queue != NULL) 35907c478bd9Sstevel@tonic-gate iu_tq_destroy(timer_queue); 3591b823d4c7Sdstaff 35927c478bd9Sstevel@tonic-gate 35937c478bd9Sstevel@tonic-gate /* 3594b823d4c7Sdstaff * We don't bother to undo the restarter interface at all. 3595b823d4c7Sdstaff * Because of quirks in the interface, there is no way to 3596b823d4c7Sdstaff * disconnect from the channel and cause any new events to be 3597b823d4c7Sdstaff * queued. However, any events which are received and not 3598b823d4c7Sdstaff * acknowledged will be re-sent when inetd restarts as long as inetd 3599b823d4c7Sdstaff * uses the same subscriber ID, which it does. 3600b823d4c7Sdstaff * 3601b823d4c7Sdstaff * By keeping the event pipe open but ignoring it, any events which 3602b823d4c7Sdstaff * occur will cause restarter_event_proxy to hang without breaking 3603b823d4c7Sdstaff * anything. 36047c478bd9Sstevel@tonic-gate */ 36057c478bd9Sstevel@tonic-gate 36067c478bd9Sstevel@tonic-gate if (instance_list != NULL) { 36077c478bd9Sstevel@tonic-gate void *cookie = NULL; 36087c478bd9Sstevel@tonic-gate instance_t *inst; 36097c478bd9Sstevel@tonic-gate 36107c478bd9Sstevel@tonic-gate while ((inst = uu_list_teardown(instance_list, &cookie)) != 36117c478bd9Sstevel@tonic-gate NULL) 36127c478bd9Sstevel@tonic-gate destroy_instance(inst); 36137c478bd9Sstevel@tonic-gate uu_list_destroy(instance_list); 36147c478bd9Sstevel@tonic-gate } 36157c478bd9Sstevel@tonic-gate if (instance_pool != NULL) 36167c478bd9Sstevel@tonic-gate uu_list_pool_destroy(instance_pool); 36177c478bd9Sstevel@tonic-gate tlx_fini(); 36187c478bd9Sstevel@tonic-gate config_fini(); 36197c478bd9Sstevel@tonic-gate repval_fini(); 36207c478bd9Sstevel@tonic-gate poll_fini(); 36217c478bd9Sstevel@tonic-gate 36227c478bd9Sstevel@tonic-gate /* Close audit session */ 36237c478bd9Sstevel@tonic-gate (void) adt_end_session(audit_handle); 36247c478bd9Sstevel@tonic-gate } 36257c478bd9Sstevel@tonic-gate 36267c478bd9Sstevel@tonic-gate static int 36277c478bd9Sstevel@tonic-gate init(void) 36287c478bd9Sstevel@tonic-gate { 36297c478bd9Sstevel@tonic-gate int err; 36307c478bd9Sstevel@tonic-gate 36317c478bd9Sstevel@tonic-gate if (repval_init() < 0) 36327c478bd9Sstevel@tonic-gate goto failed; 36337c478bd9Sstevel@tonic-gate 36347c478bd9Sstevel@tonic-gate if (config_init() < 0) 36357c478bd9Sstevel@tonic-gate goto failed; 36367c478bd9Sstevel@tonic-gate 3637eed64e98Sgm refresh_debug_flag(); 3638eed64e98Sgm 36397c478bd9Sstevel@tonic-gate if (tlx_init() < 0) 36407c478bd9Sstevel@tonic-gate goto failed; 36417c478bd9Sstevel@tonic-gate 36427c478bd9Sstevel@tonic-gate /* Setup instance list. */ 36437c478bd9Sstevel@tonic-gate if ((instance_pool = uu_list_pool_create("instance_pool", 36447c478bd9Sstevel@tonic-gate sizeof (instance_t), offsetof(instance_t, link), NULL, 36457c478bd9Sstevel@tonic-gate UU_LIST_POOL_DEBUG)) == NULL) { 36467c478bd9Sstevel@tonic-gate error_msg("%s: %s", 36477c478bd9Sstevel@tonic-gate gettext("Failed to create instance pool"), 36487c478bd9Sstevel@tonic-gate uu_strerror(uu_error())); 36497c478bd9Sstevel@tonic-gate goto failed; 36507c478bd9Sstevel@tonic-gate } 36517c478bd9Sstevel@tonic-gate if ((instance_list = uu_list_create(instance_pool, NULL, 0)) == NULL) { 36527c478bd9Sstevel@tonic-gate error_msg("%s: %s", 36537c478bd9Sstevel@tonic-gate gettext("Failed to create instance list"), 36547c478bd9Sstevel@tonic-gate uu_strerror(uu_error())); 36557c478bd9Sstevel@tonic-gate goto failed; 36567c478bd9Sstevel@tonic-gate } 36577c478bd9Sstevel@tonic-gate 36587c478bd9Sstevel@tonic-gate /* 36597c478bd9Sstevel@tonic-gate * Create event pipe to communicate events with the main event 36607c478bd9Sstevel@tonic-gate * loop and add it to the event loop's fdset. 36617c478bd9Sstevel@tonic-gate */ 36627c478bd9Sstevel@tonic-gate if (pipe(rst_event_pipe) < 0) { 36637c478bd9Sstevel@tonic-gate error_msg("pipe: %s", strerror(errno)); 36647c478bd9Sstevel@tonic-gate goto failed; 36657c478bd9Sstevel@tonic-gate } 36667c478bd9Sstevel@tonic-gate /* 36677c478bd9Sstevel@tonic-gate * We only leave the producer end to block on reads/writes as we 36687c478bd9Sstevel@tonic-gate * can't afford to block in the main thread, yet need to in 36697c478bd9Sstevel@tonic-gate * the restarter event thread, so it can sit and wait for an 36707c478bd9Sstevel@tonic-gate * acknowledgement to be written to the pipe. 36717c478bd9Sstevel@tonic-gate */ 36727c478bd9Sstevel@tonic-gate disable_blocking(rst_event_pipe[PE_CONSUMER]); 36737c478bd9Sstevel@tonic-gate if ((set_pollfd(rst_event_pipe[PE_CONSUMER], POLLIN)) == -1) 36747c478bd9Sstevel@tonic-gate goto failed; 36757c478bd9Sstevel@tonic-gate 36767c478bd9Sstevel@tonic-gate /* 36777c478bd9Sstevel@tonic-gate * Register with master restarter for managed service events. This 36787c478bd9Sstevel@tonic-gate * will fail, amongst other reasons, if inetd is already running. 36797c478bd9Sstevel@tonic-gate */ 36807c478bd9Sstevel@tonic-gate if ((err = restarter_bind_handle(RESTARTER_EVENT_VERSION, 36817c478bd9Sstevel@tonic-gate INETD_INSTANCE_FMRI, restarter_event_proxy, 0, 36827c478bd9Sstevel@tonic-gate &rst_event_handle)) != 0) { 36837c478bd9Sstevel@tonic-gate error_msg(gettext( 36847c478bd9Sstevel@tonic-gate "Failed to register for restarter events: %s"), 36857c478bd9Sstevel@tonic-gate strerror(err)); 36867c478bd9Sstevel@tonic-gate goto failed; 36877c478bd9Sstevel@tonic-gate } 36887c478bd9Sstevel@tonic-gate 36897c478bd9Sstevel@tonic-gate if (contract_init() < 0) 36907c478bd9Sstevel@tonic-gate goto failed; 36917c478bd9Sstevel@tonic-gate 36927c478bd9Sstevel@tonic-gate if ((timer_queue = iu_tq_create()) == NULL) { 36937c478bd9Sstevel@tonic-gate error_msg(gettext("Failed to create timer queue.")); 36947c478bd9Sstevel@tonic-gate goto failed; 36957c478bd9Sstevel@tonic-gate } 36967c478bd9Sstevel@tonic-gate 36977c478bd9Sstevel@tonic-gate if (uds_init() < 0) 36987c478bd9Sstevel@tonic-gate goto failed; 36997c478bd9Sstevel@tonic-gate 37007c478bd9Sstevel@tonic-gate if (method_init() < 0) 37017c478bd9Sstevel@tonic-gate goto failed; 37027c478bd9Sstevel@tonic-gate 37037c478bd9Sstevel@tonic-gate /* Initialize auditing session */ 37047c478bd9Sstevel@tonic-gate if (adt_start_session(&audit_handle, NULL, ADT_USE_PROC_DATA) != 0) { 37057c478bd9Sstevel@tonic-gate error_msg(gettext("Unable to start audit session")); 37067c478bd9Sstevel@tonic-gate } 37077c478bd9Sstevel@tonic-gate 37087c478bd9Sstevel@tonic-gate /* 37097c478bd9Sstevel@tonic-gate * Initialize signal dispositions/masks 37107c478bd9Sstevel@tonic-gate */ 37117c478bd9Sstevel@tonic-gate (void) sigset(SIGHUP, sighup_handler); 37127c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, sigterm_handler); 37137c478bd9Sstevel@tonic-gate (void) sigignore(SIGINT); 37147c478bd9Sstevel@tonic-gate 37157c478bd9Sstevel@tonic-gate return (0); 37167c478bd9Sstevel@tonic-gate 37177c478bd9Sstevel@tonic-gate failed: 37187c478bd9Sstevel@tonic-gate fini(); 37197c478bd9Sstevel@tonic-gate return (-1); 37207c478bd9Sstevel@tonic-gate } 37217c478bd9Sstevel@tonic-gate 37227c478bd9Sstevel@tonic-gate static int 37237c478bd9Sstevel@tonic-gate start_method(void) 37247c478bd9Sstevel@tonic-gate { 37257c478bd9Sstevel@tonic-gate int i; 37267c478bd9Sstevel@tonic-gate int pipe_fds[2]; 37277c478bd9Sstevel@tonic-gate int child; 37287c478bd9Sstevel@tonic-gate 37297c478bd9Sstevel@tonic-gate /* Create pipe for child to notify parent of initialization success. */ 37307c478bd9Sstevel@tonic-gate if (pipe(pipe_fds) < 0) { 3731eed64e98Sgm error_msg("pipe: %s", strerror(errno)); 37327c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 37337c478bd9Sstevel@tonic-gate } 37347c478bd9Sstevel@tonic-gate 37357c478bd9Sstevel@tonic-gate if ((child = fork()) == -1) { 3736eed64e98Sgm error_msg("fork: %s", strerror(errno)); 37377c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_CONSUMER]); 37387c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_PRODUCER]); 37397c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 37407c478bd9Sstevel@tonic-gate } else if (child > 0) { /* parent */ 37417c478bd9Sstevel@tonic-gate 37427c478bd9Sstevel@tonic-gate /* Wait on child to return success of initialization. */ 37437c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_PRODUCER]); 37447c478bd9Sstevel@tonic-gate if ((safe_read(pipe_fds[PE_CONSUMER], &i, sizeof (i)) != 0) || 37457c478bd9Sstevel@tonic-gate (i < 0)) { 37467c478bd9Sstevel@tonic-gate error_msg(gettext( 37477c478bd9Sstevel@tonic-gate "Initialization failed, unable to start")); 37487c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_CONSUMER]); 37497c478bd9Sstevel@tonic-gate /* 37507c478bd9Sstevel@tonic-gate * Batch all initialization errors as 'other' errors, 37517c478bd9Sstevel@tonic-gate * resulting in retries being attempted. 37527c478bd9Sstevel@tonic-gate */ 37537c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_OTHER); 37547c478bd9Sstevel@tonic-gate } else { 37557c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_CONSUMER]); 37567c478bd9Sstevel@tonic-gate return (SMF_EXIT_OK); 37577c478bd9Sstevel@tonic-gate } 37587c478bd9Sstevel@tonic-gate } else { /* child */ 37597c478bd9Sstevel@tonic-gate /* 37607c478bd9Sstevel@tonic-gate * Perform initialization and return success code down 37617c478bd9Sstevel@tonic-gate * the pipe. 37627c478bd9Sstevel@tonic-gate */ 37637c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_CONSUMER]); 37647c478bd9Sstevel@tonic-gate i = init(); 37657c478bd9Sstevel@tonic-gate if ((safe_write(pipe_fds[PE_PRODUCER], &i, sizeof (i)) < 0) || 37667c478bd9Sstevel@tonic-gate (i < 0)) { 37677c478bd9Sstevel@tonic-gate error_msg(gettext("pipe write failure: %s"), 37687c478bd9Sstevel@tonic-gate strerror(errno)); 37697c478bd9Sstevel@tonic-gate exit(1); 37707c478bd9Sstevel@tonic-gate } 37717c478bd9Sstevel@tonic-gate (void) close(pipe_fds[PE_PRODUCER]); 37727c478bd9Sstevel@tonic-gate 37737c478bd9Sstevel@tonic-gate (void) setsid(); 37747c478bd9Sstevel@tonic-gate 37757c478bd9Sstevel@tonic-gate /* 37767c478bd9Sstevel@tonic-gate * Log a message if the configuration file has changed since 37777c478bd9Sstevel@tonic-gate * inetconv was last run. 37787c478bd9Sstevel@tonic-gate */ 37797c478bd9Sstevel@tonic-gate check_conf_file(); 37807c478bd9Sstevel@tonic-gate 37817c478bd9Sstevel@tonic-gate event_loop(); 37827c478bd9Sstevel@tonic-gate 37837c478bd9Sstevel@tonic-gate fini(); 37847c478bd9Sstevel@tonic-gate debug_msg("inetd stopped"); 37857c478bd9Sstevel@tonic-gate msg_fini(); 37867c478bd9Sstevel@tonic-gate exit(0); 37877c478bd9Sstevel@tonic-gate } 37887c478bd9Sstevel@tonic-gate /* NOTREACHED */ 37897c478bd9Sstevel@tonic-gate } 37907c478bd9Sstevel@tonic-gate 37917c478bd9Sstevel@tonic-gate /* 37927c478bd9Sstevel@tonic-gate * When inetd is run from outside the SMF, this message is output to provide 37937c478bd9Sstevel@tonic-gate * the person invoking inetd with further information that will help them 37947c478bd9Sstevel@tonic-gate * understand how to start and stop inetd, and to achieve the other 37957c478bd9Sstevel@tonic-gate * behaviors achievable with the legacy inetd command line interface, if 37967c478bd9Sstevel@tonic-gate * it is possible. 37977c478bd9Sstevel@tonic-gate */ 37987c478bd9Sstevel@tonic-gate static void 37997c478bd9Sstevel@tonic-gate legacy_usage(void) 38007c478bd9Sstevel@tonic-gate { 38017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 38027c478bd9Sstevel@tonic-gate "inetd is now an smf(5) managed service and can no longer be run " 38037c478bd9Sstevel@tonic-gate "from the\n" 38047c478bd9Sstevel@tonic-gate "command line. To enable or disable inetd refer to svcadm(1M) on\n" 38057c478bd9Sstevel@tonic-gate "how to enable \"%s\", the inetd instance.\n" 38067c478bd9Sstevel@tonic-gate "\n" 38077c478bd9Sstevel@tonic-gate "The traditional inetd command line option mappings are:\n" 38087c478bd9Sstevel@tonic-gate "\t-d : there is no supported debug output\n" 38097c478bd9Sstevel@tonic-gate "\t-s : inetd is only runnable from within the SMF\n" 38107c478bd9Sstevel@tonic-gate "\t-t : See inetadm(1M) on how to enable TCP tracing\n" 38117c478bd9Sstevel@tonic-gate "\t-r : See inetadm(1M) on how to set a failure rate\n" 38127c478bd9Sstevel@tonic-gate "\n" 38137c478bd9Sstevel@tonic-gate "To specify an alternative configuration file see svccfg(1M)\n" 38147c478bd9Sstevel@tonic-gate "for how to modify the \"%s/%s\" string type property of\n" 38157c478bd9Sstevel@tonic-gate "the inetd instance, and modify it according to the syntax:\n" 38167c478bd9Sstevel@tonic-gate "\"%s [alt_config_file] %%m\".\n" 38177c478bd9Sstevel@tonic-gate "\n" 38187c478bd9Sstevel@tonic-gate "For further information on inetd see inetd(1M).\n", 38197c478bd9Sstevel@tonic-gate INETD_INSTANCE_FMRI, START_METHOD_ARG, SCF_PROPERTY_EXEC, 38207c478bd9Sstevel@tonic-gate INETD_PATH); 38217c478bd9Sstevel@tonic-gate } 38227c478bd9Sstevel@tonic-gate 38237c478bd9Sstevel@tonic-gate /* 38247c478bd9Sstevel@tonic-gate * Usage message printed out for usage errors when running under the SMF. 38257c478bd9Sstevel@tonic-gate */ 38267c478bd9Sstevel@tonic-gate static void 38277c478bd9Sstevel@tonic-gate smf_usage(const char *arg0) 38287c478bd9Sstevel@tonic-gate { 38297c478bd9Sstevel@tonic-gate error_msg("Usage: %s [alt_conf_file] %s|%s|%s", arg0, START_METHOD_ARG, 38307c478bd9Sstevel@tonic-gate STOP_METHOD_ARG, REFRESH_METHOD_ARG); 38317c478bd9Sstevel@tonic-gate } 38327c478bd9Sstevel@tonic-gate 38337c478bd9Sstevel@tonic-gate /* 38347c478bd9Sstevel@tonic-gate * Returns B_TRUE if we're being run from within the SMF, else B_FALSE. 38357c478bd9Sstevel@tonic-gate */ 38367c478bd9Sstevel@tonic-gate static boolean_t 38377c478bd9Sstevel@tonic-gate run_through_smf(void) 38387c478bd9Sstevel@tonic-gate { 38397c478bd9Sstevel@tonic-gate char *fmri; 38407c478bd9Sstevel@tonic-gate 38417c478bd9Sstevel@tonic-gate /* 38427c478bd9Sstevel@tonic-gate * check if the instance fmri environment variable has been set by 38437c478bd9Sstevel@tonic-gate * our restarter. 38447c478bd9Sstevel@tonic-gate */ 38457c478bd9Sstevel@tonic-gate return (((fmri = getenv("SMF_FMRI")) != NULL) && 38467c478bd9Sstevel@tonic-gate (strcmp(fmri, INETD_INSTANCE_FMRI) == 0)); 38477c478bd9Sstevel@tonic-gate } 38487c478bd9Sstevel@tonic-gate 38497c478bd9Sstevel@tonic-gate int 38507c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 38517c478bd9Sstevel@tonic-gate { 38527c478bd9Sstevel@tonic-gate char *method; 38537c478bd9Sstevel@tonic-gate int ret; 38547c478bd9Sstevel@tonic-gate 38557c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) 38567c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" 38577c478bd9Sstevel@tonic-gate #endif 38587c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 38597c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 38607c478bd9Sstevel@tonic-gate 38617c478bd9Sstevel@tonic-gate if (!run_through_smf()) { 38627c478bd9Sstevel@tonic-gate legacy_usage(); 38637c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_NOSMF); 38647c478bd9Sstevel@tonic-gate } 38657c478bd9Sstevel@tonic-gate 38667c478bd9Sstevel@tonic-gate msg_init(); /* setup logging */ 38677c478bd9Sstevel@tonic-gate 3868004388ebScasper (void) enable_extended_FILE_stdio(-1, -1); 3869004388ebScasper 38707c478bd9Sstevel@tonic-gate /* inetd invocation syntax is inetd [alt_conf_file] method_name */ 38717c478bd9Sstevel@tonic-gate 38727c478bd9Sstevel@tonic-gate switch (argc) { 38737c478bd9Sstevel@tonic-gate case 2: 38747c478bd9Sstevel@tonic-gate method = argv[1]; 38757c478bd9Sstevel@tonic-gate break; 38767c478bd9Sstevel@tonic-gate case 3: 38777c478bd9Sstevel@tonic-gate conf_file = argv[1]; 38787c478bd9Sstevel@tonic-gate method = argv[2]; 38797c478bd9Sstevel@tonic-gate break; 38807c478bd9Sstevel@tonic-gate default: 38817c478bd9Sstevel@tonic-gate smf_usage(argv[0]); 38827c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_CONFIG); 38837c478bd9Sstevel@tonic-gate 38847c478bd9Sstevel@tonic-gate } 38857c478bd9Sstevel@tonic-gate 38867c478bd9Sstevel@tonic-gate if (strcmp(method, START_METHOD_ARG) == 0) { 38877c478bd9Sstevel@tonic-gate ret = start_method(); 38887c478bd9Sstevel@tonic-gate } else if (strcmp(method, STOP_METHOD_ARG) == 0) { 38897c478bd9Sstevel@tonic-gate ret = stop_method(); 38907c478bd9Sstevel@tonic-gate } else if (strcmp(method, REFRESH_METHOD_ARG) == 0) { 38917c478bd9Sstevel@tonic-gate ret = refresh_method(); 38927c478bd9Sstevel@tonic-gate } else { 38937c478bd9Sstevel@tonic-gate smf_usage(argv[0]); 38947c478bd9Sstevel@tonic-gate return (SMF_EXIT_ERR_CONFIG); 38957c478bd9Sstevel@tonic-gate } 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate return (ret); 38987c478bd9Sstevel@tonic-gate } 3899