launchd/src/launchd.c

/*
 * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_APACHE_LICENSE_HEADER_START@
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @APPLE_APACHE_LICENSE_HEADER_END@
 */

static const char *const __rcs_file_version__ = "$Revision: 24863 $";

#include "config.h"
#include "launchd.h"

#include <sys/types.h>
#include <sys/queue.h>
#include <sys/event.h>
#include <sys/stat.h>
#include <sys/ucred.h>
#include <sys/fcntl.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <sys/sysctl.h>
#include <sys/sockio.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/kern_event.h>
#include <sys/reboot.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet6/nd6.h>
#include <ifaddrs.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdbool.h>
#include <paths.h>
#include <pwd.h>
#include <grp.h>
#include <ttyent.h>
#include <dlfcn.h>
#include <dirent.h>
#include <string.h>
#include <setjmp.h>
#include <spawn.h>
#include <sched.h>
#include <pthread.h>
#include <util.h>

#if HAVE_LIBAUDITD
#include <bsm/auditd_lib.h>
#include <bsm/audit_session.h>
#endif

#include "bootstrap.h"
#include "vproc.h"
#include "vproc_priv.h"
#include "vproc_internal.h"
#include "launch.h"
#include "launch_internal.h"

#include "launchd_runtime.h"
#include "launchd_core_logic.h"
#include "launchd_unix_ipc.h"

#define LAUNCHD_CONF ".launchd.conf"

extern char **environ;

static void pfsystem_callback(void *, struct kevent *);

static kq_callback kqpfsystem_callback = pfsystem_callback;

static void pid1_magic_init(void);

static void testfd_or_openfd(int fd, const char *path, int flags);
static bool get_network_state(void);
static void monitor_networking_state(void);
static void fatal_signal_handler(int sig, siginfo_t *si, void *uap);
static void handle_pid1_crashes_separately(void);
static void do_pid1_crash_diagnosis_mode(const char *msg);
static int basic_fork(void);
static bool do_pid1_crash_diagnosis_mode2(const char *msg);

static void *update_thread(void *nothing);

static bool re_exec_in_single_user_mode;
static void *crash_addr;
static pid_t crash_pid;

bool shutdown_in_progress;
bool fake_shutdown_in_progress;
bool network_up;
char g_username[128] = "__Uninitialized__";
char g_my_label[128] = "__Uninitialized__";
char g_launchd_database_dir[PATH_MAX];
FILE *g_console = NULL;
int32_t g_sync_frequency = 30;

int
main(int argc, char *const *argv)
{
	bool sflag = false;
	int ch;

	testfd_or_openfd(STDIN_FILENO, _PATH_DEVNULL, O_RDONLY);
	testfd_or_openfd(STDOUT_FILENO, _PATH_DEVNULL, O_WRONLY);
	testfd_or_openfd(STDERR_FILENO, _PATH_DEVNULL, O_WRONLY);

	if (g_use_gmalloc) {
		if (!getenv("DYLD_INSERT_LIBRARIES")) {
			setenv("DYLD_INSERT_LIBRARIES", "/usr/lib/libgmalloc.dylib", 1);
			setenv("MALLOC_STRICT_SIZE", "1", 1);
			execv(argv[0], argv);
		} else {
			unsetenv("DYLD_INSERT_LIBRARIES");
			unsetenv("MALLOC_STRICT_SIZE");
		}
	} else if (g_malloc_log_stacks) {
		if (!getenv("MallocStackLogging")) {
			setenv("MallocStackLogging", "1", 1);
			execv(argv[0], argv);
		} else {
			unsetenv("MallocStackLogging");
		}
	}

	while ((ch = getopt(argc, argv, "s")) != -1) {
		switch (ch) {
		case 's': sflag = true; break;	/* single user */
		case '?': /* we should do something with the global optopt variable here */
		default:
			fprintf(stderr, "%s: ignoring unknown arguments\n", getprogname());
			break;
		}
	}

	if (getpid() != 1 && getppid() != 1) {
		fprintf(stderr, "%s: This program is not meant to be run directly.\n", getprogname());
		exit(EXIT_FAILURE);
	}

	launchd_runtime_init();

	if (pid1_magic) {
		int cfd = -1;
		if (launchd_assumes((cfd = open(_PATH_CONSOLE, O_WRONLY | O_NOCTTY)) != -1)) {
			_fd(cfd);
			if (!launchd_assumes((g_console = fdopen(cfd, "w")) != NULL)) {
				close(cfd);
			}
		}
	}

	if (NULL == getenv("PATH")) {
		setenv("PATH", _PATH_STDPATH, 1);
	}

	if (pid1_magic) {
		pid1_magic_init();
	} else {
		ipc_server_init();

		runtime_log_push();

		struct passwd *pwent = getpwuid(getuid());
		if (pwent) {
			strlcpy(g_username, pwent->pw_name, sizeof(g_username) - 1);
		}

		snprintf(g_my_label, sizeof(g_my_label), "com.apple.launchd.peruser.%u", getuid());

		auditinfo_addr_t auinfo;
		if (launchd_assumes(getaudit_addr(&auinfo, sizeof(auinfo)) != -1)) {
			g_audit_session = auinfo.ai_asid;
			runtime_syslog(LOG_DEBUG, "Our audit session ID is %i", g_audit_session);
		}

		g_audit_session_port = _audit_session_self();
		snprintf(g_launchd_database_dir, sizeof(g_launchd_database_dir), LAUNCHD_DB_PREFIX "/com.apple.launchd.peruser.%u", getuid());
		runtime_syslog(LOG_DEBUG, "Per-user launchd for UID %u (%s) has begun.", getuid(), g_username);
	}

	if (pid1_magic) {
		runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "*** launchd[1] has started up. ***");
		if (g_use_gmalloc) {
			runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "*** Using libgmalloc. ***");
		}
		if (g_malloc_log_stacks) {
			runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "*** Logging stacks of malloc(3) allocations. ***");
		}

		if (g_verbose_boot) {
			runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "*** Verbose boot, will log to /dev/console. ***");
		}

		if (g_shutdown_debugging) {
			runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "*** Shutdown debugging is enabled. ***");
		}

		/* PID 1 doesn't have a flat namespace. */
		g_flat_mach_namespace = false;
	} else {
		if (g_use_gmalloc) {
			runtime_syslog(LOG_NOTICE, "*** Per-user launchd using libgmalloc. ***");
		}
	}

	monitor_networking_state();

	if (pid1_magic) {
		handle_pid1_crashes_separately();
	} else {
	#if !TARGET_OS_EMBEDDED
		/* prime shared memory before the 'bootstrap_port' global is set to zero */
		_vproc_transaction_begin();
		_vproc_transaction_end();
	#endif
	}

	if (pid1_magic) {
		/* Start the update thread -- rdar://problem/5039559&6153301 */
		pthread_t t = NULL;
		int err = pthread_create(&t, NULL, update_thread, NULL);
		(void)launchd_assumes(err == 0);
		(void)launchd_assumes(pthread_detach(t) == 0);
	}

	jobmgr_init(sflag);

	launchd_runtime_init2();

	launchd_runtime();
}

void
handle_pid1_crashes_separately(void)
{
	struct sigaction fsa;

	fsa.sa_sigaction = fatal_signal_handler;
	fsa.sa_flags = SA_SIGINFO;
	sigemptyset(&fsa.sa_mask);

	(void)launchd_assumes(sigaction(SIGILL, &fsa, NULL) != -1);
	(void)launchd_assumes(sigaction(SIGFPE, &fsa, NULL) != -1);
	(void)launchd_assumes(sigaction(SIGBUS, &fsa, NULL) != -1);
	(void)launchd_assumes(sigaction(SIGSEGV, &fsa, NULL) != -1);
	(void)launchd_assumes(sigaction(SIGABRT, &fsa, NULL) != -1);
	(void)launchd_assumes(sigaction(SIGTRAP, &fsa, NULL) != -1);
}

void *update_thread(void *nothing __attribute__((unused)))
{
	/* <rdar://problem/7385963> use IOPOL_PASSIVE for sync thread */
	(void)launchd_assumes(setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_THREAD, IOPOL_PASSIVE) != -1);

	while( g_sync_frequency ) {
		sync();
		sleep(g_sync_frequency);
	}

	runtime_syslog(LOG_DEBUG, "Update thread exiting.");
	return NULL;
}

#define PID1_CRASH_LOGFILE "/var/log/launchd-pid1.crash"

/* This hack forces the dynamic linker to resolve these symbols ASAP */
static __attribute__((unused)) typeof(sync) *__junk_dyld_trick1 = sync;
static __attribute__((unused)) typeof(sleep) *__junk_dyld_trick2 = sleep;
static __attribute__((unused)) typeof(reboot) *__junk_dyld_trick3 = reboot;

void
do_pid1_crash_diagnosis_mode(const char *msg)
{
	if (g_wsp) {
		kill(g_wsp, SIGKILL);
		sleep(3);
		g_wsp = 0;
	}

	while (g_shutdown_debugging && !do_pid1_crash_diagnosis_mode2(msg)) {
		sleep(1);
	}
}

int
basic_fork(void)
{
	int wstatus = 0;
	pid_t p;

	switch ((p = fork())) {
	case -1:
		runtime_syslog(LOG_ERR | LOG_CONSOLE, "Can't fork PID 1 copy for crash debugging: %m");
		return p;
	case 0:
		return p;
	default:
		do {
			(void)waitpid(p, &wstatus, 0);
		} while(!WIFEXITED(wstatus));

		fprintf(stdout, "PID 1 copy: exit status: %d\n", WEXITSTATUS(wstatus));

		return 1;
	}

	return -1;
}

bool
do_pid1_crash_diagnosis_mode2(const char *msg)
{
	if (basic_fork() == 0) {
		/* Neuter our bootstrap port so that the shell doesn't try talking to us while
		 * we're blocked waiting on it.
		 */
		if (g_console) {
			fflush(g_console);
		}
		task_set_bootstrap_port(mach_task_self(), MACH_PORT_NULL);
		if (basic_fork() != 0) {
			if (g_console) {
				fflush(g_console);
			}
			return true;
		}
	} else {
		return true;
	}

	int fd;
	revoke(_PATH_CONSOLE);
	if ((fd = open(_PATH_CONSOLE, O_RDWR)) == -1) {
		_exit(2);
	}
	if (login_tty(fd) == -1) {
		_exit(3);
	}
	setenv("TERM", "vt100", 1);
	fprintf(stdout, "\n");
	fprintf(stdout, "Entering launchd PID 1 debugging mode...\n");
	fprintf(stdout, "The PID 1 launchd has crashed %s.\n", msg);
	fprintf(stdout, "It has fork(2)ed itself for debugging.\n");
	fprintf(stdout, "To debug the crashing thread of PID 1:\n");
	fprintf(stdout, "    gdb attach %d\n", getppid());
	fprintf(stdout, "To exit this shell and shut down:\n");
	fprintf(stdout, "    kill -9 1\n");
	fprintf(stdout, "A sample of PID 1 has been written to %s\n", PID1_CRASH_LOGFILE);
	fprintf(stdout, "\n");
	fflush(stdout);

	execl(_PATH_BSHELL, "-sh", NULL);
	syslog(LOG_ERR, "can't exec %s for PID 1 crash debugging: %m", _PATH_BSHELL);
	_exit(EXIT_FAILURE);
}

void
fatal_signal_handler(int sig, siginfo_t *si, void *uap __attribute__((unused)))
{
	const char *doom_why = "at instruction";
	char msg[128];
	char *sample_args[] = { "/usr/bin/sample", "1", "1", "-file", PID1_CRASH_LOGFILE, NULL };
	pid_t sample_p;
	int wstatus;

	crash_addr = si->si_addr;
	crash_pid = si->si_pid;

	unlink(PID1_CRASH_LOGFILE);

	switch ((sample_p = vfork())) {
	case 0:
		execve(sample_args[0], sample_args, environ);
		_exit(EXIT_FAILURE);
		break;
	default:
		waitpid(sample_p, &wstatus, 0);
		break;
	case -1:
		break;
	}

	switch (sig) {
	default:
	case 0:
		break;
	case SIGBUS:
	case SIGSEGV:
		doom_why = "trying to read/write";
	case SIGILL:
	case SIGFPE:
		snprintf(msg, sizeof(msg), "%s: %p (%s sent by PID %u)", doom_why, crash_addr, strsignal(sig), crash_pid);
		sync();
		do_pid1_crash_diagnosis_mode(msg);
		sleep(3);
		reboot(0);
		break;
	}
}

void
pid1_magic_init(void)
{
	(void)launchd_assumes(setsid() != -1);
	(void)launchd_assumes(chdir("/") != -1);
	(void)launchd_assumes(setlogin("root") != -1);

	strcpy(g_my_label, "com.apple.launchd");

#if !TARGET_OS_EMBEDDED
	auditinfo_addr_t auinfo = {
		.ai_termid = { .at_type = AU_IPv4 },
		.ai_asid = AU_ASSIGN_ASID,
		.ai_auid = AU_DEFAUDITID,
		.ai_flags = AU_SESSION_FLAG_IS_INITIAL,
	};

	if (!launchd_assumes(setaudit_addr(&auinfo, sizeof(auinfo)) != -1)) {
		runtime_syslog(LOG_WARNING | LOG_CONSOLE, "Could not set audit session: %s.", strerror(errno));
		_exit(EXIT_FAILURE);
	}

	g_audit_session = auinfo.ai_asid;
	runtime_syslog(LOG_DEBUG, "Audit Session ID: %i", g_audit_session);

	g_audit_session_port = _audit_session_self();
#endif // !TARGET_OS_EMBEDDED

	strcpy(g_launchd_database_dir, LAUNCHD_DB_PREFIX "/com.apple.launchd");
}

char *
launchd_data_base_path(int db_type)
{
	static char result[PATH_MAX];
	static int last_db_type = -1;

	if (db_type == last_db_type) {
		return result;
	}

	switch (db_type) {
		case LAUNCHD_DB_TYPE_OVERRIDES	:
			snprintf(result, sizeof(result), "%s/%s", g_launchd_database_dir, "overrides.plist");
			last_db_type = db_type;
			break;
		case LAUNCHD_DB_TYPE_JOBCACHE	:
			snprintf(result, sizeof(result), "%s/%s", g_launchd_database_dir, "jobcache.launchdata");
			last_db_type = db_type;
			break;
		default							:
			break;
	}

	return result;
}

int
_fd(int fd)
{
	if (fd >= 0) {
		(void)launchd_assumes(fcntl(fd, F_SETFD, 1) != -1);
	}
	return fd;
}

void
launchd_shutdown(void)
{
	int64_t now;

	if (shutdown_in_progress) {
		return;
	}

	runtime_ktrace0(RTKT_LAUNCHD_EXITING);

	shutdown_in_progress = true;

	if (pid1_magic || g_log_per_user_shutdown) {
		/*
		 * When this changes to a more sustainable API, update this:
		 * http://howto.apple.com/db.cgi?Debugging_Apps_Non-Responsive_At_Shutdown
		 */
		runtime_setlogmask(LOG_UPTO(LOG_DEBUG));
	}

	runtime_log_push();

	now = runtime_get_wall_time();

	char *term_who = pid1_magic ? "System shutdown" : "Per-user launchd termination for ";
	runtime_syslog(LOG_INFO, "%s%s began", term_who, pid1_magic ? "" : g_username);

	launchd_assert(jobmgr_shutdown(root_jobmgr) != NULL);

#if HAVE_LIBAUDITD
	if (pid1_magic) {
		(void)launchd_assumes(audit_quick_stop() == 0);
	}
#endif
}

void
launchd_single_user(void)
{
	runtime_syslog(LOG_NOTICE, "Going to single-user mode");

	re_exec_in_single_user_mode = true;

	launchd_shutdown();

	sleep(3);

	runtime_kill(-1, SIGKILL);
}

void
launchd_SessionCreate(void)
{
#if !TARGET_OS_EMBEDDED
	auditinfo_addr_t auinfo = {
		.ai_termid = { .at_type = AU_IPv4 },
		.ai_asid = AU_ASSIGN_ASID,
		.ai_auid = getuid(),
		.ai_flags = 0,
	};
	if (launchd_assumes(setaudit_addr(&auinfo, sizeof(auinfo)) == 0)) {
		char session[16];
		snprintf(session, sizeof(session), "%x", auinfo.ai_asid);
		setenv("SECURITYSESSIONID", session, 1);
	} else {
		runtime_syslog(LOG_WARNING, "Could not set audit session: %s.", strerror(errno));
	}
#endif // !TARGET_OS_EMBEDDED
}

void
testfd_or_openfd(int fd, const char *path, int flags)
{
	int tmpfd;

	if (-1 != (tmpfd = dup(fd))) {
		(void)launchd_assumes(runtime_close(tmpfd) == 0);
	} else {
		if (-1 == (tmpfd = open(path, flags | O_NOCTTY, DEFFILEMODE))) {
			runtime_syslog(LOG_ERR, "open(\"%s\", ...): %m", path);
		} else if (tmpfd != fd) {
			(void)launchd_assumes(dup2(tmpfd, fd) != -1);
			(void)launchd_assumes(runtime_close(tmpfd) == 0);
		}
	}
}

bool
get_network_state(void)
{
	struct ifaddrs *ifa, *ifai;
	bool up = false;
	int r;

	/* Workaround 4978696: getifaddrs() reports false ENOMEM */
	while ((r = getifaddrs(&ifa)) == -1 && errno == ENOMEM) {
		runtime_syslog(LOG_DEBUG, "Worked around bug: 4978696");
		(void)launchd_assumes(sched_yield() != -1);
	}

	if (!launchd_assumes(r != -1)) {
		return network_up;
	}

	for (ifai = ifa; ifai; ifai = ifai->ifa_next) {
		if (!(ifai->ifa_flags & IFF_UP)) {
			continue;
		}
		if (ifai->ifa_flags & IFF_LOOPBACK) {
			continue;
		}
		if (ifai->ifa_addr->sa_family != AF_INET && ifai->ifa_addr->sa_family != AF_INET6) {
			continue;
		}
		up = true;
		break;
	}

	freeifaddrs(ifa);

	return up;
}

void
monitor_networking_state(void)
{
	int pfs = _fd(socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT));
	struct kev_request kev_req;

	network_up = get_network_state();

	if (!launchd_assumes(pfs != -1)) {
		return;
	}

	memset(&kev_req, 0, sizeof(kev_req));
	kev_req.vendor_code = KEV_VENDOR_APPLE;
	kev_req.kev_class = KEV_NETWORK_CLASS;

	if (!launchd_assumes(ioctl(pfs, SIOCSKEVFILT, &kev_req) != -1)) {
		runtime_close(pfs);
		return;
	}

	(void)launchd_assumes(kevent_mod(pfs, EVFILT_READ, EV_ADD, 0, 0, &kqpfsystem_callback) != -1);
}

void
pfsystem_callback(void *obj __attribute__((unused)), struct kevent *kev)
{
	bool new_networking_state;
	char buf[1024];

	(void)launchd_assumes(read((int)kev->ident, &buf, sizeof(buf)) != -1);

	new_networking_state = get_network_state();

	if (new_networking_state != network_up) {
		network_up = new_networking_state;
		jobmgr_dispatch_all_semaphores(root_jobmgr);
	}
}

void
_log_launchd_bug(const char *rcs_rev, const char *path, unsigned int line, const char *test)
{
	int saved_errno = errno;
	char buf[100];
	const char *file = strrchr(path, '/');
	char *rcs_rev_tmp = strchr(rcs_rev, ' ');

	runtime_ktrace1(RTKT_LAUNCHD_BUG);

	if (!file) {
		file = path;
	} else {
		file += 1;
	}

	if (!rcs_rev_tmp) {
		strlcpy(buf, rcs_rev, sizeof(buf));
	} else {
		strlcpy(buf, rcs_rev_tmp + 1, sizeof(buf));
		rcs_rev_tmp = strchr(buf, ' ');
		if (rcs_rev_tmp) {
			*rcs_rev_tmp = '\0';
		}
	}

	runtime_syslog(LOG_NOTICE, "Bug: %s:%u (%s):%u: %s", file, line, buf, saved_errno, test);
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_APACHE_LICENSE_HEADER_START@
	5	*
	6	* Licensed under the Apache License, Version 2.0 (the "License");
	7	* you may not use this file except in compliance with the License.
	8	* You may obtain a copy of the License at
	9	*
	10	* http://www.apache.org/licenses/LICENSE-2.0
	11	*
	12	* Unless required by applicable law or agreed to in writing, software
	13	* distributed under the License is distributed on an "AS IS" BASIS,
	14	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	15	* See the License for the specific language governing permissions and
	16	* limitations under the License.
	17	*
	18	* @APPLE_APACHE_LICENSE_HEADER_END@
	19	*/
	20
	21	static const char *const __rcs_file_version__ = "$Revision: 24863 $";
	22
	23	#include "config.h"
	24	#include "launchd.h"
	25
	26	#include <sys/types.h>
	27	#include <sys/queue.h>
	28	#include <sys/event.h>
	29	#include <sys/stat.h>
	30	#include <sys/ucred.h>
	31	#include <sys/fcntl.h>
	32	#include <sys/un.h>
	33	#include <sys/wait.h>
	34	#include <sys/sysctl.h>
	35	#include <sys/sockio.h>
	36	#include <sys/time.h>
	37	#include <sys/resource.h>
	38	#include <sys/ioctl.h>
	39	#include <sys/mount.h>
	40	#include <sys/kern_event.h>
	41	#include <sys/reboot.h>
	42	#include <sys/socket.h>
	43	#include <sys/syscall.h>
	44	#include <net/if.h>
	45	#include <netinet/in.h>
	46	#include <netinet/in_var.h>
	47	#include <netinet6/nd6.h>
	48	#include <ifaddrs.h>
	49	#include <unistd.h>
	50	#include <signal.h>
	51	#include <errno.h>
	52	#include <libgen.h>
	53	#include <stdio.h>
	54	#include <stdlib.h>
	55	#include <stdarg.h>
	56	#include <stdbool.h>
	57	#include <paths.h>
	58	#include <pwd.h>
	59	#include <grp.h>
	60	#include <ttyent.h>
	61	#include <dlfcn.h>
	62	#include <dirent.h>
	63	#include <string.h>
	64	#include <setjmp.h>
	65	#include <spawn.h>
	66	#include <sched.h>
	67	#include <pthread.h>
	68	#include <util.h>
	69
	70	#if HAVE_LIBAUDITD
	71	#include <bsm/auditd_lib.h>
	72	#include <bsm/audit_session.h>
	73	#endif
	74
	75	#include "bootstrap.h"
	76	#include "vproc.h"
	77	#include "vproc_priv.h"
	78	#include "vproc_internal.h"
	79	#include "launch.h"
	80	#include "launch_internal.h"
	81
	82	#include "launchd_runtime.h"
	83	#include "launchd_core_logic.h"
	84	#include "launchd_unix_ipc.h"
	85
	86	#define LAUNCHD_CONF ".launchd.conf"
	87
	88	extern char **environ;
	89
	90	static void pfsystem_callback(void , struct kevent );
	91
	92	static kq_callback kqpfsystem_callback = pfsystem_callback;
	93
	94	static void pid1_magic_init(void);
	95
	96	static void testfd_or_openfd(int fd, const char *path, int flags);
	97	static bool get_network_state(void);
	98	static void monitor_networking_state(void);
	99	static void fatal_signal_handler(int sig, siginfo_t si, void uap);
	100	static void handle_pid1_crashes_separately(void);
	101	static void do_pid1_crash_diagnosis_mode(const char *msg);
	102	static int basic_fork(void);
	103	static bool do_pid1_crash_diagnosis_mode2(const char *msg);
	104
	105	static void update_thread(void nothing);
	106
	107	static bool re_exec_in_single_user_mode;
	108	static void *crash_addr;
	109	static pid_t crash_pid;
	110
	111	bool shutdown_in_progress;
	112	bool fake_shutdown_in_progress;
	113	bool network_up;
	114	char g_username[128] = "__Uninitialized__";
	115	char g_my_label[128] = "__Uninitialized__";
	116	char g_launchd_database_dir[PATH_MAX];
	117	FILE *g_console = NULL;
	118	int32_t g_sync_frequency = 30;
	119
	120	int
	121	main(int argc, char const argv)
	122	{
	123	bool sflag = false;
	124	int ch;
	125
	126	testfd_or_openfd(STDIN_FILENO, _PATH_DEVNULL, O_RDONLY);
	127	testfd_or_openfd(STDOUT_FILENO, _PATH_DEVNULL, O_WRONLY);
	128	testfd_or_openfd(STDERR_FILENO, _PATH_DEVNULL, O_WRONLY);
	129
	130	if (g_use_gmalloc) {
	131	if (!getenv("DYLD_INSERT_LIBRARIES")) {
	132	setenv("DYLD_INSERT_LIBRARIES", "/usr/lib/libgmalloc.dylib", 1);
	133	setenv("MALLOC_STRICT_SIZE", "1", 1);
	134	execv(argv[0], argv);
	135	} else {
	136	unsetenv("DYLD_INSERT_LIBRARIES");
	137	unsetenv("MALLOC_STRICT_SIZE");
	138	}
	139	} else if (g_malloc_log_stacks) {
	140	if (!getenv("MallocStackLogging")) {
	141	setenv("MallocStackLogging", "1", 1);
	142	execv(argv[0], argv);
	143	} else {
	144	unsetenv("MallocStackLogging");
	145	}
	146	}
	147
	148	while ((ch = getopt(argc, argv, "s")) != -1) {
	149	switch (ch) {
	150	case 's': sflag = true; break; /* single user */
	151	case '?': /* we should do something with the global optopt variable here */
	152	default:
	153	fprintf(stderr, "%s: ignoring unknown arguments\n", getprogname());
	154	break;
	155	}
	156	}
	157
	158	if (getpid() != 1 && getppid() != 1) {
	159	fprintf(stderr, "%s: This program is not meant to be run directly.\n", getprogname());
	160	exit(EXIT_FAILURE);
	161	}
	162
	163	launchd_runtime_init();
	164
	165	if (pid1_magic) {
	166	int cfd = -1;
	167	if (launchd_assumes((cfd = open(_PATH_CONSOLE, O_WRONLY \| O_NOCTTY)) != -1)) {
	168	_fd(cfd);
	169	if (!launchd_assumes((g_console = fdopen(cfd, "w")) != NULL)) {
	170	close(cfd);
	171	}
	172	}
	173	}
	174
	175	if (NULL == getenv("PATH")) {
	176	setenv("PATH", _PATH_STDPATH, 1);
	177	}
	178
	179	if (pid1_magic) {
	180	pid1_magic_init();
	181	} else {
	182	ipc_server_init();
	183
	184	runtime_log_push();
	185
	186	struct passwd *pwent = getpwuid(getuid());
	187	if (pwent) {
	188	strlcpy(g_username, pwent->pw_name, sizeof(g_username) - 1);
	189	}
	190
	191	snprintf(g_my_label, sizeof(g_my_label), "com.apple.launchd.peruser.%u", getuid());
	192
	193	auditinfo_addr_t auinfo;
	194	if (launchd_assumes(getaudit_addr(&auinfo, sizeof(auinfo)) != -1)) {
	195	g_audit_session = auinfo.ai_asid;
	196	runtime_syslog(LOG_DEBUG, "Our audit session ID is %i", g_audit_session);
	197	}
	198
	199	g_audit_session_port = _audit_session_self();
	200	snprintf(g_launchd_database_dir, sizeof(g_launchd_database_dir), LAUNCHD_DB_PREFIX "/com.apple.launchd.peruser.%u", getuid());
	201	runtime_syslog(LOG_DEBUG, "Per-user launchd for UID %u (%s) has begun.", getuid(), g_username);
	202	}
	203
	204	if (pid1_magic) {
	205	runtime_syslog(LOG_NOTICE \| LOG_CONSOLE, "* launchd[1] has started up. *");
	206	if (g_use_gmalloc) {
	207	runtime_syslog(LOG_NOTICE \| LOG_CONSOLE, "* Using libgmalloc. *");
	208	}
	209	if (g_malloc_log_stacks) {
	210	runtime_syslog(LOG_NOTICE \| LOG_CONSOLE, "* Logging stacks of malloc(3) allocations. *");
	211	}
	212
	213	if (g_verbose_boot) {
	214	runtime_syslog(LOG_NOTICE \| LOG_CONSOLE, "* Verbose boot, will log to /dev/console. *");
	215	}
	216
	217	if (g_shutdown_debugging) {
	218	runtime_syslog(LOG_NOTICE \| LOG_CONSOLE, "* Shutdown debugging is enabled. *");
	219	}
	220
	221	/* PID 1 doesn't have a flat namespace. */
	222	g_flat_mach_namespace = false;
	223	} else {
	224	if (g_use_gmalloc) {
	225	runtime_syslog(LOG_NOTICE, "* Per-user launchd using libgmalloc. *");
	226	}
	227	}
	228
	229	monitor_networking_state();
	230
	231	if (pid1_magic) {
	232	handle_pid1_crashes_separately();
	233	} else {
	234	#if !TARGET_OS_EMBEDDED
	235	/* prime shared memory before the 'bootstrap_port' global is set to zero */
	236	_vproc_transaction_begin();
	237	_vproc_transaction_end();
	238	#endif
	239	}
	240
	241	if (pid1_magic) {
	242	/* Start the update thread -- rdar://problem/5039559&6153301 */
	243	pthread_t t = NULL;
	244	int err = pthread_create(&t, NULL, update_thread, NULL);
	245	(void)launchd_assumes(err == 0);
	246	(void)launchd_assumes(pthread_detach(t) == 0);
	247	}
	248
	249	jobmgr_init(sflag);
	250
	251	launchd_runtime_init2();
	252
	253	launchd_runtime();
	254	}
	255
	256	void
	257	handle_pid1_crashes_separately(void)
	258	{
	259	struct sigaction fsa;
	260
	261	fsa.sa_sigaction = fatal_signal_handler;
	262	fsa.sa_flags = SA_SIGINFO;
	263	sigemptyset(&fsa.sa_mask);
	264
	265	(void)launchd_assumes(sigaction(SIGILL, &fsa, NULL) != -1);
	266	(void)launchd_assumes(sigaction(SIGFPE, &fsa, NULL) != -1);
	267	(void)launchd_assumes(sigaction(SIGBUS, &fsa, NULL) != -1);
	268	(void)launchd_assumes(sigaction(SIGSEGV, &fsa, NULL) != -1);
	269	(void)launchd_assumes(sigaction(SIGABRT, &fsa, NULL) != -1);
	270	(void)launchd_assumes(sigaction(SIGTRAP, &fsa, NULL) != -1);
	271	}
	272
	273	void update_thread(void nothing __attribute__((unused)))
	274	{
	275	/* <rdar://problem/7385963> use IOPOL_PASSIVE for sync thread */
	276	(void)launchd_assumes(setiopolicy_np(IOPOL_TYPE_DISK, IOPOL_SCOPE_THREAD, IOPOL_PASSIVE) != -1);
	277
	278	while( g_sync_frequency ) {
	279	sync();
	280	sleep(g_sync_frequency);
	281	}
	282
	283	runtime_syslog(LOG_DEBUG, "Update thread exiting.");
	284	return NULL;
	285	}
	286
	287	#define PID1_CRASH_LOGFILE "/var/log/launchd-pid1.crash"
	288
	289	/* This hack forces the dynamic linker to resolve these symbols ASAP */
	290	static __attribute__((unused)) typeof(sync) *__junk_dyld_trick1 = sync;
	291	static __attribute__((unused)) typeof(sleep) *__junk_dyld_trick2 = sleep;
	292	static __attribute__((unused)) typeof(reboot) *__junk_dyld_trick3 = reboot;
	293
	294	void
	295	do_pid1_crash_diagnosis_mode(const char *msg)
	296	{
	297	if (g_wsp) {
	298	kill(g_wsp, SIGKILL);
	299	sleep(3);
	300	g_wsp = 0;
	301	}
	302
	303	while (g_shutdown_debugging && !do_pid1_crash_diagnosis_mode2(msg)) {
	304	sleep(1);
	305	}
	306	}
	307
	308	int
	309	basic_fork(void)
	310	{
	311	int wstatus = 0;
	312	pid_t p;
	313
	314	switch ((p = fork())) {
	315	case -1:
	316	runtime_syslog(LOG_ERR \| LOG_CONSOLE, "Can't fork PID 1 copy for crash debugging: %m");
	317	return p;
	318	case 0:
	319	return p;
	320	default:
	321	do {
	322	(void)waitpid(p, &wstatus, 0);
	323	} while(!WIFEXITED(wstatus));
	324
	325	fprintf(stdout, "PID 1 copy: exit status: %d\n", WEXITSTATUS(wstatus));
	326
	327	return 1;
	328	}
	329
	330	return -1;
	331	}
	332
	333	bool
	334	do_pid1_crash_diagnosis_mode2(const char *msg)
	335	{
	336	if (basic_fork() == 0) {
	337	/* Neuter our bootstrap port so that the shell doesn't try talking to us while
	338	* we're blocked waiting on it.
	339	*/
	340	if (g_console) {
	341	fflush(g_console);
	342	}
	343	task_set_bootstrap_port(mach_task_self(), MACH_PORT_NULL);
	344	if (basic_fork() != 0) {
	345	if (g_console) {
	346	fflush(g_console);
	347	}
	348	return true;
	349	}
	350	} else {
	351	return true;
	352	}
	353
	354	int fd;
	355	revoke(_PATH_CONSOLE);
	356	if ((fd = open(_PATH_CONSOLE, O_RDWR)) == -1) {
	357	_exit(2);
	358	}
	359	if (login_tty(fd) == -1) {
	360	_exit(3);
	361	}
	362	setenv("TERM", "vt100", 1);
	363	fprintf(stdout, "\n");
	364	fprintf(stdout, "Entering launchd PID 1 debugging mode...\n");
	365	fprintf(stdout, "The PID 1 launchd has crashed %s.\n", msg);
	366	fprintf(stdout, "It has fork(2)ed itself for debugging.\n");
	367	fprintf(stdout, "To debug the crashing thread of PID 1:\n");
	368	fprintf(stdout, " gdb attach %d\n", getppid());
	369	fprintf(stdout, "To exit this shell and shut down:\n");
	370	fprintf(stdout, " kill -9 1\n");
	371	fprintf(stdout, "A sample of PID 1 has been written to %s\n", PID1_CRASH_LOGFILE);
	372	fprintf(stdout, "\n");
	373	fflush(stdout);
	374
	375	execl(_PATH_BSHELL, "-sh", NULL);
	376	syslog(LOG_ERR, "can't exec %s for PID 1 crash debugging: %m", _PATH_BSHELL);
	377	_exit(EXIT_FAILURE);
	378	}
	379
	380	void
	381	fatal_signal_handler(int sig, siginfo_t si, void uap __attribute__((unused)))
	382	{
	383	const char *doom_why = "at instruction";
	384	char msg[128];
	385	char *sample_args[] = { "/usr/bin/sample", "1", "1", "-file", PID1_CRASH_LOGFILE, NULL };
	386	pid_t sample_p;
	387	int wstatus;
	388
	389	crash_addr = si->si_addr;
	390	crash_pid = si->si_pid;
	391
	392	unlink(PID1_CRASH_LOGFILE);
	393
	394	switch ((sample_p = vfork())) {
	395	case 0:
	396	execve(sample_args[0], sample_args, environ);
	397	_exit(EXIT_FAILURE);
	398	break;
	399	default:
	400	waitpid(sample_p, &wstatus, 0);
	401	break;
	402	case -1:
	403	break;
	404	}
	405
	406	switch (sig) {
	407	default:
	408	case 0:
	409	break;
	410	case SIGBUS:
	411	case SIGSEGV:
	412	doom_why = "trying to read/write";
	413	case SIGILL:
	414	case SIGFPE:
	415	snprintf(msg, sizeof(msg), "%s: %p (%s sent by PID %u)", doom_why, crash_addr, strsignal(sig), crash_pid);
	416	sync();
	417	do_pid1_crash_diagnosis_mode(msg);
	418	sleep(3);
	419	reboot(0);
	420	break;
	421	}
	422	}
	423
	424	void
	425	pid1_magic_init(void)
	426	{
	427	(void)launchd_assumes(setsid() != -1);
	428	(void)launchd_assumes(chdir("/") != -1);
	429	(void)launchd_assumes(setlogin("root") != -1);
	430
	431	strcpy(g_my_label, "com.apple.launchd");
	432
	433	#if !TARGET_OS_EMBEDDED
	434	auditinfo_addr_t auinfo = {
	435	.ai_termid = { .at_type = AU_IPv4 },
	436	.ai_asid = AU_ASSIGN_ASID,
	437	.ai_auid = AU_DEFAUDITID,
	438	.ai_flags = AU_SESSION_FLAG_IS_INITIAL,
	439	};
	440
	441	if (!launchd_assumes(setaudit_addr(&auinfo, sizeof(auinfo)) != -1)) {
	442	runtime_syslog(LOG_WARNING \| LOG_CONSOLE, "Could not set audit session: %s.", strerror(errno));
	443	_exit(EXIT_FAILURE);
	444	}
	445
	446	g_audit_session = auinfo.ai_asid;
	447	runtime_syslog(LOG_DEBUG, "Audit Session ID: %i", g_audit_session);
	448
	449	g_audit_session_port = _audit_session_self();
	450	#endif // !TARGET_OS_EMBEDDED
	451
	452	strcpy(g_launchd_database_dir, LAUNCHD_DB_PREFIX "/com.apple.launchd");
	453	}
	454
	455	char *
	456	launchd_data_base_path(int db_type)
	457	{
	458	static char result[PATH_MAX];
	459	static int last_db_type = -1;
	460
	461	if (db_type == last_db_type) {
	462	return result;
	463	}
	464
	465	switch (db_type) {
	466	case LAUNCHD_DB_TYPE_OVERRIDES :
	467	snprintf(result, sizeof(result), "%s/%s", g_launchd_database_dir, "overrides.plist");
	468	last_db_type = db_type;
	469	break;
	470	case LAUNCHD_DB_TYPE_JOBCACHE :
	471	snprintf(result, sizeof(result), "%s/%s", g_launchd_database_dir, "jobcache.launchdata");
	472	last_db_type = db_type;
	473	break;
	474	default :
	475	break;
	476	}
	477
	478	return result;
	479	}
	480
	481	int
	482	_fd(int fd)
	483	{
	484	if (fd >= 0) {
	485	(void)launchd_assumes(fcntl(fd, F_SETFD, 1) != -1);
	486	}
	487	return fd;
	488	}
	489
	490	void
	491	launchd_shutdown(void)
	492	{
	493	int64_t now;
	494
	495	if (shutdown_in_progress) {
	496	return;
	497	}
	498
	499	runtime_ktrace0(RTKT_LAUNCHD_EXITING);
	500
	501	shutdown_in_progress = true;
	502
	503	if (pid1_magic \|\| g_log_per_user_shutdown) {
	504	/*
	505	* When this changes to a more sustainable API, update this:
	506	* http://howto.apple.com/db.cgi?Debugging_Apps_Non-Responsive_At_Shutdown
	507	*/
	508	runtime_setlogmask(LOG_UPTO(LOG_DEBUG));
	509	}
	510
	511	runtime_log_push();
	512
	513	now = runtime_get_wall_time();
	514
	515	char *term_who = pid1_magic ? "System shutdown" : "Per-user launchd termination for ";
	516	runtime_syslog(LOG_INFO, "%s%s began", term_who, pid1_magic ? "" : g_username);
	517
	518	launchd_assert(jobmgr_shutdown(root_jobmgr) != NULL);
	519
	520	#if HAVE_LIBAUDITD
	521	if (pid1_magic) {
	522	(void)launchd_assumes(audit_quick_stop() == 0);
	523	}
	524	#endif
	525	}
	526
	527	void
	528	launchd_single_user(void)
	529	{
	530	runtime_syslog(LOG_NOTICE, "Going to single-user mode");
	531
	532	re_exec_in_single_user_mode = true;
	533
	534	launchd_shutdown();
	535
	536	sleep(3);
	537
	538	runtime_kill(-1, SIGKILL);
	539	}
	540
	541	void
	542	launchd_SessionCreate(void)
	543	{
	544	#if !TARGET_OS_EMBEDDED
	545	auditinfo_addr_t auinfo = {
	546	.ai_termid = { .at_type = AU_IPv4 },
	547	.ai_asid = AU_ASSIGN_ASID,
	548	.ai_auid = getuid(),
	549	.ai_flags = 0,
	550	};
	551	if (launchd_assumes(setaudit_addr(&auinfo, sizeof(auinfo)) == 0)) {
	552	char session[16];
	553	snprintf(session, sizeof(session), "%x", auinfo.ai_asid);
	554	setenv("SECURITYSESSIONID", session, 1);
	555	} else {
	556	runtime_syslog(LOG_WARNING, "Could not set audit session: %s.", strerror(errno));
	557	}
	558	#endif // !TARGET_OS_EMBEDDED
	559	}
	560
	561	void
	562	testfd_or_openfd(int fd, const char *path, int flags)
	563	{
	564	int tmpfd;
	565
	566	if (-1 != (tmpfd = dup(fd))) {
	567	(void)launchd_assumes(runtime_close(tmpfd) == 0);
	568	} else {
	569	if (-1 == (tmpfd = open(path, flags \| O_NOCTTY, DEFFILEMODE))) {
	570	runtime_syslog(LOG_ERR, "open(\"%s\", ...): %m", path);
	571	} else if (tmpfd != fd) {
	572	(void)launchd_assumes(dup2(tmpfd, fd) != -1);
	573	(void)launchd_assumes(runtime_close(tmpfd) == 0);
	574	}
	575	}
	576	}
	577
	578	bool
	579	get_network_state(void)
	580	{
	581	struct ifaddrs ifa, ifai;
	582	bool up = false;
	583	int r;
	584
	585	/* Workaround 4978696: getifaddrs() reports false ENOMEM */
	586	while ((r = getifaddrs(&ifa)) == -1 && errno == ENOMEM) {
	587	runtime_syslog(LOG_DEBUG, "Worked around bug: 4978696");
	588	(void)launchd_assumes(sched_yield() != -1);
	589	}
	590
	591	if (!launchd_assumes(r != -1)) {
	592	return network_up;
	593	}
	594
	595	for (ifai = ifa; ifai; ifai = ifai->ifa_next) {
	596	if (!(ifai->ifa_flags & IFF_UP)) {
	597	continue;
	598	}
	599	if (ifai->ifa_flags & IFF_LOOPBACK) {
	600	continue;
	601	}
	602	if (ifai->ifa_addr->sa_family != AF_INET && ifai->ifa_addr->sa_family != AF_INET6) {
	603	continue;
	604	}
	605	up = true;
	606	break;
	607	}
	608
	609	freeifaddrs(ifa);
	610
	611	return up;
	612	}
	613
	614	void
	615	monitor_networking_state(void)
	616	{
	617	int pfs = _fd(socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT));
	618	struct kev_request kev_req;
	619
	620	network_up = get_network_state();
	621
	622	if (!launchd_assumes(pfs != -1)) {
	623	return;
	624	}
	625
	626	memset(&kev_req, 0, sizeof(kev_req));
	627	kev_req.vendor_code = KEV_VENDOR_APPLE;
	628	kev_req.kev_class = KEV_NETWORK_CLASS;
	629
	630	if (!launchd_assumes(ioctl(pfs, SIOCSKEVFILT, &kev_req) != -1)) {
	631	runtime_close(pfs);
	632	return;
	633	}
	634
	635	(void)launchd_assumes(kevent_mod(pfs, EVFILT_READ, EV_ADD, 0, 0, &kqpfsystem_callback) != -1);
	636	}
	637
	638	void
	639	pfsystem_callback(void obj __attribute__((unused)), struct kevent kev)
	640	{
	641	bool new_networking_state;
	642	char buf[1024];
	643
	644	(void)launchd_assumes(read((int)kev->ident, &buf, sizeof(buf)) != -1);
	645
	646	new_networking_state = get_network_state();
	647
	648	if (new_networking_state != network_up) {
	649	network_up = new_networking_state;
	650	jobmgr_dispatch_all_semaphores(root_jobmgr);
	651	}
	652	}
	653
	654	void
	655	_log_launchd_bug(const char rcs_rev, const char path, unsigned int line, const char *test)
	656	{
	657	int saved_errno = errno;
	658	char buf[100];
	659	const char *file = strrchr(path, '/');
	660	char *rcs_rev_tmp = strchr(rcs_rev, ' ');
	661
	662	runtime_ktrace1(RTKT_LAUNCHD_BUG);
	663
	664	if (!file) {
	665	file = path;
	666	} else {
	667	file += 1;
	668	}
	669
	670	if (!rcs_rev_tmp) {
	671	strlcpy(buf, rcs_rev, sizeof(buf));
	672	} else {
	673	strlcpy(buf, rcs_rev_tmp + 1, sizeof(buf));
	674	rcs_rev_tmp = strchr(buf, ' ');
	675	if (rcs_rev_tmp) {
	676	*rcs_rev_tmp = '\0';
	677	}
	678	}
	679
	680	runtime_syslog(LOG_NOTICE, "Bug: %s:%u (%s):%u: %s", file, line, buf, saved_errno, test);
	681	}