launchd/src/launchd.c

   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: 23748 $";
  22
  23 #include "config.h"
  24 #include "launchd.h"
  25
  26 #if HAVE_SECURITY
  27 #include <Security/Authorization.h>
  28 #include <Security/AuthorizationTags.h>
  29 #include <Security/AuthSession.h>
  30 #endif
  31 #include <sys/types.h>
  32 #include <sys/queue.h>
  33 #include <sys/event.h>
  34 #include <sys/stat.h>
  35 #include <sys/ucred.h>
  36 #include <sys/fcntl.h>
  37 #include <sys/un.h>
  38 #include <sys/wait.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/sockio.h>
  41 #include <sys/time.h>
  42 #include <sys/resource.h>
  43 #include <sys/ioctl.h>
  44 #include <sys/mount.h>
  45 #include <sys/kern_event.h>
  46 #include <sys/reboot.h>
  47 #include <net/if.h>
  48 #include <netinet/in.h>
  49 #include <netinet/in_var.h>
  50 #include <netinet6/nd6.h>
  51 #include <ifaddrs.h>
  52 #include <unistd.h>
  53 #include <signal.h>
  54 #include <errno.h>
  55 #include <libgen.h>
  56 #include <stdio.h>
  57 #include <stdlib.h>
  58 #include <stdarg.h>
  59 #include <stdbool.h>
  60 #include <paths.h>
  61 #include <pwd.h>
  62 #include <grp.h>
  63 #include <ttyent.h>
  64 #include <dlfcn.h>
  65 #include <dirent.h>
  66 #include <string.h>
  67 #include <setjmp.h>
  68 #include <spawn.h>
  69 #include <sched.h>
  70 #if TARGET_OS_EMBEDDED
  71 #include <pthread.h>
  72 #endif
  73
  74 #include "bootstrap.h"
  75 #include "vproc.h"
  76 #include "vproc_internal.h"
  77 #include "launch.h"
  78
  79 #include "launchd_runtime.h"
  80 #include "launchd_core_logic.h"
  81 #include "launchd_unix_ipc.h"
  82
  83 #define LAUNCHD_CONF ".launchd.conf"
  84 #define SECURITY_LIB "/System/Library/Frameworks/Security.framework/Versions/A/Security"
  85 #define SHUTDOWN_LOG_DIR "/var/log/shutdown"
  86
  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 prep_shutdown_log_dir(void);
 102
 103 #if TARGET_OS_EMBEDDED
 104 static void *update_thread(void *nothing);
 105 #endif
 106
 107 static bool re_exec_in_single_user_mode = false;
 108 static void *crash_addr;
 109 static pid_t crash_pid;
 110
 111 #if TARGET_OS_EMBEDDED
 112 static unsigned int g_sync_frequency = 30;
 113 #endif
 114
 115 static bool shutdown_in_progress = false;
 116 bool debug_shutdown_hangs = false;
 117 bool network_up = false;
 118
 119 int
 120 main(int argc, char *const *argv)
 121 {
 122         bool sflag = false;
 123         int ch;
 124
 125         testfd_or_openfd(STDIN_FILENO, _PATH_DEVNULL, O_RDONLY);
 126         testfd_or_openfd(STDOUT_FILENO, _PATH_DEVNULL, O_WRONLY);
 127         testfd_or_openfd(STDERR_FILENO, _PATH_DEVNULL, O_WRONLY);
 128
 129         while ((ch = getopt(argc, argv, "s")) != -1) {
 130                 switch (ch) {
 131                 case 's': sflag = true; break;  /* single user */
 132                 case '?': /* we should do something with the global optopt variable here */
 133                 default:
 134                         fprintf(stderr, "%s: ignoring unknown arguments\n", getprogname());
 135                         break;
 136                 }
 137         }
 138
 139         if (getpid() != 1 && getppid() != 1) {
 140                 fprintf(stderr, "%s: This program is not meant to be run directly.\n", getprogname());
 141                 exit(EXIT_FAILURE);
 142         }
 143
 144         launchd_runtime_init();
 145
 146         if (NULL == getenv("PATH")) {
 147                 setenv("PATH", _PATH_STDPATH, 1);
 148         }
 149
 150         if (getpid() == 1) {
 151                 pid1_magic_init();
 152         } else {
 153                 ipc_server_init();
 154         }
 155
 156 #if TARGET_OS_EMBEDDED
 157         pthread_attr_t attr;
 158         pthread_attr_init(&attr);
 159         pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
 160
 161         if( getpid() == 1 ) {
 162                 /* Start the update thread -- rdar://problem/5039559&6153301 */
 163                 pthread_t t = NULL;
 164                 int err = pthread_create(&t, &attr, update_thread, NULL);
 165                 launchd_assumes(err == 0);
 166         }
 167 #endif
 168
 169         monitor_networking_state();
 170
 171         if (getpid() == 1) {
 172                 handle_pid1_crashes_separately();
 173         }
 174
 175         jobmgr_init(sflag);
 176
 177         launchd_runtime_init2();
 178
 179         launchd_runtime();
 180 }
 181
 182 void
 183 handle_pid1_crashes_separately(void)
 184 {
 185         struct sigaction fsa;
 186
 187         fsa.sa_sigaction = fatal_signal_handler;
 188         fsa.sa_flags = SA_SIGINFO;
 189         sigemptyset(&fsa.sa_mask);
 190
 191         launchd_assumes(sigaction(SIGILL, &fsa, NULL) != -1);
 192         launchd_assumes(sigaction(SIGFPE, &fsa, NULL) != -1);
 193         launchd_assumes(sigaction(SIGBUS, &fsa, NULL) != -1);
 194         launchd_assumes(sigaction(SIGSEGV, &fsa, NULL) != -1);
 195 }
 196
 197 #define PID1_CRASH_LOGFILE "/var/log/launchd-pid1.crash"
 198
 199 /* This hack forces the dynamic linker to resolve these symbols ASAP */
 200 static __attribute__((unused)) typeof(sync) *__junk_dyld_trick1 = sync;
 201 static __attribute__((unused)) typeof(sleep) *__junk_dyld_trick2 = sleep;
 202 static __attribute__((unused)) typeof(reboot) *__junk_dyld_trick3 = reboot;
 203
 204 void
 205 fatal_signal_handler(int sig, siginfo_t *si, void *uap __attribute__((unused)))
 206 {
 207         const char *doom_why = "at instruction";
 208         char *sample_args[] = { "/usr/bin/sample", "1", "1", "-file", PID1_CRASH_LOGFILE, NULL };
 209         pid_t sample_p;
 210         int wstatus;
 211
 212         crash_addr = si->si_addr;
 213         crash_pid = si->si_pid;
 214
 215         unlink(PID1_CRASH_LOGFILE);
 216
 217         switch ((sample_p = vfork())) {
 218         case 0:
 219                 execve(sample_args[0], sample_args, environ);
 220                 _exit(EXIT_FAILURE);
 221                 break;
 222         default:
 223                 waitpid(sample_p, &wstatus, 0);
 224                 break;
 225         case -1:
 226                 break;
 227         }
 228
 229         switch (sig) {
 230         default:
 231         case 0:
 232                 break;
 233         case SIGBUS:
 234         case SIGSEGV:
 235                 doom_why = "trying to read/write";
 236         case SIGILL:
 237         case SIGFPE:
 238                 runtime_syslog(LOG_EMERG, "We crashed %s: %p (sent by PID %u)", doom_why, crash_addr, crash_pid);
 239                 sync();
 240                 sleep(3);
 241                 reboot(0);
 242                 break;
 243         }
 244 }
 245
 246 void
 247 pid1_magic_init(void)
 248 {
 249         launchd_assumes(setsid() != -1);
 250         launchd_assumes(chdir("/") != -1);
 251         launchd_assumes(setlogin("root") != -1);
 252         launchd_assumes(mount("fdesc", "/dev", MNT_UNION, NULL) != -1);
 253 }
 254
 255
 256 int
 257 _fd(int fd)
 258 {
 259         if (fd >= 0) {
 260                 launchd_assumes(fcntl(fd, F_SETFD, 1) != -1);
 261         }
 262         return fd;
 263 }
 264
 265 void
 266 prep_shutdown_log_dir(void)
 267 {
 268         launchd_assumes(mkdir(SHUTDOWN_LOG_DIR, S_IRWXU) != -1 || errno == EEXIST);
 269 }
 270
 271 #if TARGET_OS_EMBEDDED
 272 void *
 273 update_thread(void *nothing __attribute__((unused)))
 274 {
 275         while( g_sync_frequency ) {
 276                 sync();
 277                 sleep(g_sync_frequency);
 278         }
 279
 280         return NULL;
 281 }
 282 #endif
 283
 284 void
 285 launchd_shutdown(void)
 286 {
 287         struct stat sb;
 288
 289         if (shutdown_in_progress) {
 290                 return;
 291         }
 292
 293         shutdown_in_progress = true;
 294
 295         if (getpid() == 1 && stat("/var/db/debugShutdownHangs", &sb) != -1) {
 296                 /*
 297                  * When this changes to a more sustainable API, update this:
 298                  * http://howto.apple.com/db.cgi?Debugging_Apps_Non-Responsive_At_Shutdown
 299                  */
 300                 runtime_setlogmask(LOG_UPTO(LOG_DEBUG));
 301                 prep_shutdown_log_dir();
 302                 debug_shutdown_hangs = true;
 303         }
 304
 305         launchd_assert(jobmgr_shutdown(root_jobmgr) != NULL);
 306 }
 307
 308 void
 309 launchd_single_user(void)
 310 {
 311         runtime_syslog(LOG_NOTICE, "Going to single-user mode");
 312
 313         re_exec_in_single_user_mode = true;
 314
 315         launchd_shutdown();
 316
 317         sleep(3);
 318
 319         runtime_kill(-1, SIGKILL);
 320 }
 321
 322 void
 323 launchd_SessionCreate(void)
 324 {
 325 #if HAVE_SECURITY
 326         OSStatus (*sescr)(SessionCreationFlags flags, SessionAttributeBits attributes);
 327         void *seclib;
 328
 329         if (launchd_assumes((seclib = dlopen(SECURITY_LIB, RTLD_LAZY)) != NULL)) {
 330                 if (launchd_assumes((sescr = dlsym(seclib, "SessionCreate")) != NULL)) {
 331                         launchd_assumes(sescr(0, 0) == noErr);
 332                 }
 333                 launchd_assumes(dlclose(seclib) != -1);
 334         }
 335 #endif
 336 }
 337
 338 void
 339 testfd_or_openfd(int fd, const char *path, int flags)
 340 {
 341         int tmpfd;
 342
 343         if (-1 != (tmpfd = dup(fd))) {
 344                 launchd_assumes(runtime_close(tmpfd) == 0);
 345         } else {
 346                 if (-1 == (tmpfd = open(path, flags | O_NOCTTY, DEFFILEMODE))) {
 347                         runtime_syslog(LOG_ERR, "open(\"%s\", ...): %m", path);
 348                 } else if (tmpfd != fd) {
 349                         launchd_assumes(dup2(tmpfd, fd) != -1);
 350                         launchd_assumes(runtime_close(tmpfd) == 0);
 351                 }
 352         }
 353 }
 354
 355 bool
 356 get_network_state(void)
 357 {
 358         struct ifaddrs *ifa, *ifai;
 359         bool up = false;
 360         int r;
 361
 362         /* Workaround 4978696: getifaddrs() reports false ENOMEM */
 363         while ((r = getifaddrs(&ifa)) == -1 && errno == ENOMEM) {
 364                 runtime_syslog(LOG_DEBUG, "Worked around bug: 4978696");
 365                 launchd_assumes(sched_yield() != -1);
 366         }
 367
 368         if (!launchd_assumes(r != -1)) {
 369                 return network_up;
 370         }
 371
 372         for (ifai = ifa; ifai; ifai = ifai->ifa_next) {
 373                 if (!(ifai->ifa_flags & IFF_UP)) {
 374                         continue;
 375                 }
 376                 if (ifai->ifa_flags & IFF_LOOPBACK) {
 377                         continue;
 378                 }
 379                 if (ifai->ifa_addr->sa_family != AF_INET && ifai->ifa_addr->sa_family != AF_INET6) {
 380                         continue;
 381                 }
 382                 up = true;
 383                 break;
 384         }
 385
 386         freeifaddrs(ifa);
 387
 388         return up;
 389 }
 390
 391 void
 392 monitor_networking_state(void)
 393 {
 394         int pfs = _fd(socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT));
 395         struct kev_request kev_req;
 396
 397         network_up = get_network_state();
 398
 399         if (!launchd_assumes(pfs != -1)) {
 400                 return;
 401         }
 402
 403         memset(&kev_req, 0, sizeof(kev_req));
 404         kev_req.vendor_code = KEV_VENDOR_APPLE;
 405         kev_req.kev_class = KEV_NETWORK_CLASS;
 406
 407         if (!launchd_assumes(ioctl(pfs, SIOCSKEVFILT, &kev_req) != -1)) {
 408                 runtime_close(pfs);
 409                 return;
 410         }
 411
 412         launchd_assumes(kevent_mod(pfs, EVFILT_READ, EV_ADD, 0, 0, &kqpfsystem_callback) != -1);
 413 }
 414
 415 void
 416 pfsystem_callback(void *obj __attribute__((unused)), struct kevent *kev)
 417 {
 418         bool new_networking_state;
 419         char buf[1024];
 420
 421         launchd_assumes(read(kev->ident, &buf, sizeof(buf)) != -1);
 422
 423         new_networking_state = get_network_state();
 424
 425         if (new_networking_state != network_up) {
 426                 network_up = new_networking_state;
 427                 jobmgr_dispatch_all_semaphores(root_jobmgr);
 428         }
 429 }
 430
 431 void
 432 _log_launchd_bug(const char *rcs_rev, const char *path, unsigned int line, const char *test)
 433 {
 434         int saved_errno = errno;
 435         char buf[100];
 436         const char *file = strrchr(path, '/');
 437         char *rcs_rev_tmp = strchr(rcs_rev, ' ');
 438
 439         if (!file) {
 440                 file = path;
 441         } else {
 442                 file += 1;
 443         }
 444
 445         if (!rcs_rev_tmp) {
 446                 strlcpy(buf, rcs_rev, sizeof(buf));
 447         } else {
 448                 strlcpy(buf, rcs_rev_tmp + 1, sizeof(buf));
 449                 rcs_rev_tmp = strchr(buf, ' ');
 450                 if (rcs_rev_tmp) {
 451                         *rcs_rev_tmp = '\0';
 452                 }
 453         }
 454
 455         runtime_syslog(LOG_NOTICE, "Bug: %s:%u (%s):%u: %s", file, line, buf, saved_errno, test);
 456 }