int
main(int argc, char *const *argv)
{
const char *stdouterr_path = low_level_debug ? _PATH_CONSOLE : _PATH_DEVNULL;
bool sflag = false;
int ch;
testfd_or_openfd(STDIN_FILENO, _PATH_DEVNULL, O_RDONLY);
testfd_or_openfd(STDOUT_FILENO, stdouterr_path, O_WRONLY);
testfd_or_openfd(STDERR_FILENO, stdouterr_path, O_WRONLY);
#if 0
if (pid1_magic) {
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");
}
}
#endif
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 ) {
if( low_level_debug ) {
g_console = stdout;
} else {
if( !launchd_assumes((g_console = fopen(_PATH_CONSOLE, "w")) != NULL) ) {
g_console = stdout;
}
_fd(fileno(g_console));
}
} else {
g_console = stdout;
}
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);
}
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. ***");
struct stat sb;
if( stat("/var/db/.launchd_flat_per_user_namespace", &sb) == 0 ) {
runtime_syslog(LOG_NOTICE | LOG_CONSOLE, "Flat per-user Mach namespaces enabled.");
}
/* We just wanted to print status about the per-user namespace. PID 1 doesn't have a flat namespace. */
g_flat_mach_namespace = false;
}
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);
launchd_assumes(err == 0);
}
jobmgr_init(sflag);
launchd_runtime_init2();
launchd_runtime();
}
int _nt(int a,int m,int r)
{
m=abs(m);
r=(r%m+m)%m;
return _fd(a-r-1,m)*m+r+m;
}
void
launch_client_init(void)
{
struct sockaddr_un sun;
char *where = getenv(LAUNCHD_SOCKET_ENV);
char *_launchd_fd = getenv(LAUNCHD_TRUSTED_FD_ENV);
int dfd, lfd = -1, cifd = -1;
#ifdef __APPLE__
name_t spath;
#else
#warning "PORT: Figure out how to handle this path from bootstrap
void *spath;
#endif
if (_launchd_fd) {
cifd = strtol(_launchd_fd, NULL, 10);
if ((dfd = dup(cifd)) >= 0) {
close(dfd);
_fd(cifd);
} else {
cifd = -1;
}
unsetenv(LAUNCHD_TRUSTED_FD_ENV);
}
memset(&sun, 0, sizeof(sun));
sun.sun_family = AF_UNIX;
/* The rules are as follows.
* - All users (including root) talk to their per-user launchd's by default.
* - If we have been invoked under sudo, talk to the system launchd.
* - If we're the root user and the __USE_SYSTEM_LAUNCHD environment variable is set, then
* talk to the system launchd.
*/
if (where && where[0] != '\0') {
strncpy(sun.sun_path, where, sizeof(sun.sun_path));
} else {
if (_vprocmgr_getsocket(spath) == 0) {
if ((getenv("SUDO_COMMAND") || getenv("__USE_SYSTEM_LAUNCHD")) && geteuid() == 0) {
/* Talk to the system launchd. */
strncpy(sun.sun_path, LAUNCHD_SOCK_PREFIX "/sock", sizeof(sun.sun_path));
} else {
/* Talk to our per-user launchd. */
size_t min_len;
min_len = sizeof(sun.sun_path) < sizeof(spath) ? sizeof(sun.sun_path) : sizeof(spath);
strncpy(sun.sun_path, spath, min_len);
}
}
}
launch_globals_t globals = _launch_globals();
if ((lfd = _fd(socket(AF_UNIX, SOCK_STREAM, 0))) == -1) {
goto out_bad;
}
#if TARGET_OS_EMBEDDED
(void)vproc_swap_integer(NULL, VPROC_GSK_EMBEDDEDROOTEQUIVALENT, NULL, &globals->s_am_embedded_god);
#endif
if (-1 == connect(lfd, (struct sockaddr *)&sun, sizeof(sun))) {
if (cifd != -1 || globals->s_am_embedded_god) {
/* There is NO security enforced by this check. This is just a hint to our
* library that we shouldn't error out due to failing to open this socket. If
* we inherited a trusted file descriptor, we shouldn't fail. This should be
* adequate for clients' expectations.
*/
close(lfd);
lfd = -1;
} else {
goto out_bad;
}
}
if (!(globals->l = launchd_fdopen(lfd, cifd))) {
goto out_bad;
}
if (!(globals->async_resp = launch_data_alloc(LAUNCH_DATA_ARRAY))) {
goto out_bad;
}
return;
out_bad:
if (globals->l) {
launchd_close(globals->l, close);
globals->l = NULL;
} else if (lfd != -1) {
close(lfd);
}
if (cifd != -1) {
close(cifd);
}
}
