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: 1.217 $";
  22
  23 #include <Security/Authorization.h>
  24 #include <Security/AuthorizationTags.h>
  25 #include <Security/AuthSession.h>
  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 <net/if.h>
  42 #include <netinet/in.h>
  43 #include <netinet/in_var.h>
  44 #include <netinet6/nd6.h>
  45 #include <ifaddrs.h>
  46 #include <unistd.h>
  47 #include <signal.h>
  48 #include <errno.h>
  49 #include <syslog.h>
  50 #include <libgen.h>
  51 #include <stdio.h>
  52 #include <stdlib.h>
  53 #include <stdarg.h>
  54 #include <stdbool.h>
  55 #include <paths.h>
  56 #include <pwd.h>
  57 #include <grp.h>
  58 #include <ttyent.h>
  59 #include <dlfcn.h>
  60 #include <dirent.h>
  61 #include <string.h>
  62 #include <pthread.h>
  63
  64 #include "bootstrap_public.h"
  65 #include "bootstrap_private.h"
  66 #include "launch.h"
  67 #include "launch_priv.h"
  68 #include "launchd.h"
  69 #include "launchd_core_logic.h"
  70 #include "launchd_unix_ipc.h"
  71
  72 #include "launchd_internalServer.h"
  73 #include "launchd_internal.h"
  74 #include "notifyServer.h"
  75 #include "bootstrapServer.h"
  76
  77 union MaxRequestSize {
  78         union __RequestUnion__do_notify_subsystem req;
  79         union __ReplyUnion__do_notify_subsystem rep;
  80         union __RequestUnion__x_launchd_internal_subsystem req2;
  81         union __ReplyUnion__x_launchd_internal_subsystem rep2;
  82         union __RequestUnion__x_bootstrap_subsystem req3;
  83         union __ReplyUnion__x_bootstrap_subsystem rep3;
  84 };
  85
  86 static boolean_t launchd_internal_demux(mach_msg_header_t *Request, mach_msg_header_t *Reply);
  87
  88 #define PID1LAUNCHD_CONF "/etc/launchd.conf"
  89 #define LAUNCHD_CONF ".launchd.conf"
  90 #define LAUNCHCTL_PATH "/bin/launchctl"
  91 #define SECURITY_LIB "/System/Library/Frameworks/Security.framework/Versions/A/Security"
  92
  93 extern char **environ;
  94
  95 static void async_callback(void);
  96 static void signal_callback(void *, struct kevent *);
  97 static void fs_callback(void);
  98 static void ppidexit_callback(void);
  99 static void pfsystem_callback(void *, struct kevent *);
 100
 101 static kq_callback kqasync_callback = (kq_callback)async_callback;
 102 static kq_callback kqsignal_callback = signal_callback;
 103 static kq_callback kqfs_callback = (kq_callback)fs_callback;
 104 static kq_callback kqppidexit_callback = (kq_callback)ppidexit_callback;
 105 static kq_callback kqpfsystem_callback = pfsystem_callback;
 106
 107 static void pid1_magic_init(bool sflag);
 108
 109 static void usage(FILE *where);
 110
 111 static void testfd_or_openfd(int fd, const char *path, int flags);
 112 static bool get_network_state(void);
 113 static void monitor_networking_state(void);
 114 static void *kqueue_demand_loop(void *arg);
 115
 116 static pthread_t kqueue_demand_thread;
 117 static int mainkq = 0;
 118 static int asynckq = 0;
 119 static bool re_exec_in_single_user_mode = false;
 120 static char *pending_stdout = NULL;
 121 static char *pending_stderr = NULL;
 122 static struct jobcb *rlcj = NULL;
 123
 124 sigset_t blocked_signals = 0;
 125 bool shutdown_in_progress = false;
 126 bool network_up = false;
 127 int batch_disabler_count = 0;
 128 mach_port_t launchd_internal_port = MACH_PORT_NULL;
 129 mach_port_t ipc_port_set = MACH_PORT_NULL;
 130
 131 int
 132 main(int argc, char *const *argv)
 133 {
 134         static const int sigigns[] = { SIGHUP, SIGINT, SIGPIPE, SIGALRM,
 135                 SIGTERM, SIGURG, SIGTSTP, SIGTSTP, SIGCONT, /*SIGCHLD,*/
 136                 SIGTTIN, SIGTTOU, SIGIO, SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF,
 137                 SIGWINCH, SIGINFO, SIGUSR1, SIGUSR2
 138         };
 139         bool sflag = false, dflag = false, Dflag = false;
 140         mach_msg_type_number_t l2l_name_cnt = 0, l2l_port_cnt = 0;
 141         name_array_t l2l_names = NULL;
 142         mach_port_array_t l2l_ports = NULL;
 143         char ldconf[PATH_MAX] = PID1LAUNCHD_CONF;
 144         const char *h = getenv("HOME");
 145         const char *session_type = NULL;
 146         const char *optargs = NULL;
 147         launch_data_t ldresp, ldmsg = launch_data_new_string(LAUNCH_KEY_CHECKIN);
 148         struct jobcb *fbj = NULL;
 149         struct stat sb;
 150         size_t i, checkin_fdcnt = 0;
 151         int *checkin_fds = NULL;
 152         mach_port_t req_mport = MACH_PORT_NULL;
 153         mach_port_t checkin_mport = MACH_PORT_NULL;
 154         int ch, ker, logopts;
 155
 156         /* main() phase one: sanitize the process */
 157
 158         if (getpid() != 1 && (ldresp = launch_msg(ldmsg)) && launch_data_get_type(ldresp) == LAUNCH_DATA_DICTIONARY) {
 159                 const char *ldlabel = launch_data_get_string(launch_data_dict_lookup(ldresp, LAUNCH_JOBKEY_LABEL));
 160                 launch_data_t tmp;
 161
 162                 if ((tmp = launch_data_dict_lookup(ldresp, LAUNCH_JOBKEY_SOCKETS))) {
 163                         if ((tmp = launch_data_dict_lookup(tmp, "LaunchIPC"))) {
 164                                 checkin_fdcnt = launch_data_array_get_count(tmp);
 165                                 checkin_fds = alloca(sizeof(int) * checkin_fdcnt);
 166                                 for (i = 0; i < checkin_fdcnt; i++) {
 167                                         checkin_fds[i] = _fd(launch_data_get_fd(launch_data_array_get_index(tmp, i)));
 168                                 }
 169                         }
 170                 }
 171                 if ((tmp = launch_data_dict_lookup(ldresp, LAUNCH_JOBKEY_MACHSERVICES))) {
 172                         if ((tmp = launch_data_dict_lookup(tmp, ldlabel))) {
 173                                 checkin_mport = launch_data_get_machport(tmp);
 174                         }
 175                 }
 176                 launch_data_free(ldresp);
 177         } else {
 178                 int sigi, fdi, dts = getdtablesize();
 179                 sigset_t emptyset;
 180
 181                 for (fdi = STDERR_FILENO + 1; fdi < dts; fdi++)
 182                         close(fdi);
 183                 for (sigi = 1; sigi < NSIG; sigi++)
 184                         launchd_assumes(signal(sigi, SIG_DFL) != SIG_ERR);
 185                 sigemptyset(&emptyset);
 186                 launchd_assumes(sigprocmask(SIG_SETMASK, &emptyset, NULL) == 0);
 187         }
 188
 189         launch_data_free(ldmsg);
 190
 191         testfd_or_openfd(STDIN_FILENO, _PATH_DEVNULL, O_RDONLY|O_NOCTTY);
 192         testfd_or_openfd(STDOUT_FILENO, _PATH_DEVNULL, O_WRONLY|O_NOCTTY);
 193         testfd_or_openfd(STDERR_FILENO, _PATH_DEVNULL, O_WRONLY|O_NOCTTY);
 194
 195         /* main phase two: parse arguments */
 196
 197         if (getpid() == 1) {
 198                 optargs = "s";
 199         } else {
 200                 optargs = "DS:dh";
 201         }
 202
 203         while ((ch = getopt(argc, argv, optargs)) != -1) {
 204                 switch (ch) {
 205                 case 'S': session_type = optarg; break; /* what type of session we're creating */
 206                 case 'D': Dflag = true;   break;        /* debug */
 207                 case 'd': dflag = true;   break;        /* daemonize */
 208                 case 's': sflag = true;   break;        /* single user */
 209                 case 'h': usage(stdout);  break;        /* help */
 210                 case '?': /* we should do something with the global optopt variable here */
 211                 default:
 212                         fprintf(stderr, "ignoring unknown arguments\n");
 213                         usage(stderr);
 214                         break;
 215                 }
 216         }
 217         argc -= optind;
 218         argv += optind;
 219
 220         /* main phase three: get the party started */
 221
 222         if (dflag)
 223                 launchd_assumes(daemon(0, 0) == 0);
 224
 225         launchd_assert((errno = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_PORT_SET, &ipc_port_set)) == KERN_SUCCESS);
 226         launchd_assert(launchd_mport_create_recv(&launchd_internal_port) == KERN_SUCCESS);
 227         launchd_assert(launchd_mport_make_send(launchd_internal_port) == KERN_SUCCESS);
 228         launchd_assert((errno = mach_port_move_member(mach_task_self(), launchd_internal_port, ipc_port_set)) == KERN_SUCCESS);
 229
 230         logopts = LOG_PID|LOG_CONS;
 231         if (Dflag)
 232                 logopts |= LOG_PERROR;
 233
 234         openlog(getprogname(), logopts, LOG_LAUNCHD);
 235         setlogmask(LOG_UPTO(Dflag ? LOG_DEBUG : LOG_NOTICE));
 236
 237         launchd_assert((mainkq = kqueue()) != -1);
 238
 239         launchd_assert((asynckq = kqueue()) != -1);
 240
 241         launchd_assert(kevent_mod(asynckq, EVFILT_READ, EV_ADD, 0, 0, &kqasync_callback) != -1);
 242
 243         sigemptyset(&blocked_signals);
 244
 245         for (i = 0; i < (sizeof(sigigns) / sizeof(int)); i++) {
 246                 launchd_assumes(kevent_mod(sigigns[i], EVFILT_SIGNAL, EV_ADD, 0, 0, &kqsignal_callback) != -1);
 247                 sigaddset(&blocked_signals, sigigns[i]);
 248                 launchd_assumes(signal(sigigns[i], SIG_IGN) != SIG_ERR);
 249         }
 250
 251         /* sigh... ignoring SIGCHLD has side effects: we can't call wait*() */
 252         launchd_assert(kevent_mod(SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, &kqsignal_callback) != -1);
 253
 254         if (session_type && strcmp(session_type, "Aqua") == 0) {
 255                 mach_port_t newparent;
 256
 257                 launchd_assert(bootstrap_parent(bootstrap_port, &newparent) == BOOTSTRAP_SUCCESS);
 258
 259                 launchd_assert(_launchd_to_launchd(bootstrap_port, &req_mport, &checkin_mport,
 260                                         &l2l_names, &l2l_name_cnt, &l2l_ports, &l2l_port_cnt) == BOOTSTRAP_SUCCESS);
 261
 262                 launchd_assert(l2l_name_cnt == l2l_port_cnt);
 263
 264                 task_set_bootstrap_port(mach_task_self(), newparent);
 265                 launchd_assumes(mach_port_deallocate(mach_task_self(), bootstrap_port) == KERN_SUCCESS);
 266                 bootstrap_port = newparent;
 267         }
 268
 269         mach_init_init(req_mport, checkin_mport, l2l_names, l2l_ports, l2l_name_cnt);
 270
 271         if (h)
 272                 sprintf(ldconf, "%s/%s", h, LAUNCHD_CONF);
 273
 274         rlcj = job_new(root_job, READCONF_LABEL, LAUNCHCTL_PATH, NULL, ldconf, MACH_PORT_NULL);
 275         launchd_assert(rlcj != NULL);
 276
 277         if (argv[0])
 278                 fbj = job_new(root_job, FIRSTBORN_LABEL, NULL, (const char *const *)argv, NULL, MACH_PORT_NULL);
 279
 280         if (NULL == getenv("PATH"))
 281                 setenv("PATH", _PATH_STDPATH, 1);
 282
 283         if (getpid() == 1) {
 284                 pid1_magic_init(sflag);
 285         } else {
 286                 ipc_server_init(checkin_fds, checkin_fdcnt);
 287         }
 288
 289         monitor_networking_state();
 290
 291         /* do this after pid1_magic_init() to not catch ourselves mounting stuff */
 292         launchd_assumes(kevent_mod(0, EVFILT_FS, EV_ADD, 0, 0, &kqfs_callback) != -1);
 293
 294         if (session_type) {
 295                 pid_t pp = getppid();
 296
 297                 /* As a per session launchd, we need to exit if our parent dies.
 298                  *
 299                  * Normally, in Unix, SIGHUP would cause us to exit, but we're a
 300                  * daemon, and daemons use SIGHUP to signal the need to reread
 301                  * configuration files. "Weee."
 302                  */
 303
 304                 if (pp == 1)
 305                         exit(EXIT_SUCCESS);
 306
 307                 ker = kevent_mod(pp, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, &kqppidexit_callback);
 308
 309                 if (ker == -1)
 310                         exit(launchd_assumes(errno == ESRCH) ? EXIT_SUCCESS : EXIT_FAILURE);
 311         }
 312
 313         if (stat(ldconf, &sb) == 0)
 314                 job_start(rlcj);
 315
 316         if (fbj)
 317                 job_start(fbj);
 318
 319         pthread_attr_t attr;
 320         pthread_attr_init(&attr);
 321         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 322         pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
 323         launchd_assert(pthread_create(&kqueue_demand_thread, &attr, kqueue_demand_loop, NULL) == 0);
 324         pthread_attr_destroy(&attr);
 325
 326         mach_msg_return_t msgr;
 327         mach_msg_size_t mxmsgsz = sizeof(union MaxRequestSize) + MAX_TRAILER_SIZE;
 328
 329         if (getpid() == 1 && !job_active(rlcj))
 330                 init_pre_kevent();
 331
 332         for (;;) {
 333                 msgr = mach_msg_server(launchd_internal_demux, mxmsgsz, ipc_port_set,
 334                                 MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT) |
 335                                 MACH_RCV_TRAILER_TYPE(MACH_MSG_TRAILER_FORMAT_0));
 336                 launchd_assumes(msgr == MACH_MSG_SUCCESS);
 337         }
 338 }
 339
 340 void *
 341 kqueue_demand_loop(void *arg __attribute__((unused)))
 342 {
 343         fd_set rfds;
 344
 345         for (;;) {
 346                 FD_ZERO(&rfds);
 347                 FD_SET(mainkq, &rfds);
 348                 if (launchd_assumes(select(mainkq + 1, &rfds, NULL, NULL, NULL) == 1))
 349                         launchd_assumes(handle_kqueue(launchd_internal_port, mainkq) == 0);
 350         }
 351
 352         return NULL;
 353 }
 354
 355 kern_return_t
 356 x_handle_kqueue(mach_port_t junk __attribute__((unused)), integer_t fd)
 357 {
 358         struct timespec ts = { 0, 0 };
 359         struct kevent kev;
 360         int kevr;
 361
 362         launchd_assumes((kevr = kevent(fd, NULL, 0, &kev, 1, &ts)) != -1);
 363
 364         if (kevr == 1)
 365                 (*((kq_callback *)kev.udata))(kev.udata, &kev);
 366
 367         if (shutdown_in_progress && total_children == 0) {
 368                 mach_init_reap();
 369
 370                 shutdown_in_progress = false;
 371
 372                 if (getpid() != 1) {
 373                         exit(EXIT_SUCCESS);
 374                 } else if (re_exec_in_single_user_mode) {
 375                         re_exec_in_single_user_mode = false;
 376                         launchd_assumes(execl("/sbin/launchd", "/sbin/launchd", "-s", NULL) != -1);
 377                 }
 378         }
 379
 380         if (getpid() == 1) {
 381                 if (rlcj && job_active(rlcj))
 382                         goto out;
 383                 init_pre_kevent();
 384         }
 385
 386 out:
 387         return 0;
 388 }
 389
 390 void
 391 pid1_magic_init(bool sflag)
 392 {
 393         launchd_assumes(setsid() != -1);
 394         launchd_assumes(chdir("/") != -1);
 395         launchd_assumes(setlogin("root") != -1);
 396         launchd_assumes(mount("fdesc", "/dev", MNT_UNION, NULL) != -1);
 397
 398         init_boot(sflag);
 399 }
 400
 401
 402 void
 403 usage(FILE *where)
 404 {
 405         const char *opts = "[-d]";
 406
 407         if (getuid() == 0)
 408                 opts = "[-d] [-S <type> -U <user>]";
 409
 410         fprintf(where, "%s: %s [-- command [args ...]]\n", getprogname(), opts);
 411
 412         fprintf(where, "\t-d          Daemonize.\n");
 413         fprintf(where, "\t-h          This usage statement.\n");
 414
 415         if (getuid() == 0) {
 416                 fprintf(where, "\t-S <type>   What type of session to create (Aqua, tty or X11).\n");
 417                 fprintf(where, "\t-U <user>   Which user to create the session as.\n");
 418         }
 419
 420         if (where == stdout)
 421                 exit(EXIT_SUCCESS);
 422 }
 423
 424 int
 425 kevent_mod(uintptr_t ident, short filter, u_short flags, u_int fflags, intptr_t data, void *udata)
 426 {
 427         struct kevent kev;
 428         int q = mainkq;
 429
 430         if (EVFILT_TIMER == filter || EVFILT_VNODE == filter)
 431                 q = asynckq;
 432
 433         if (flags & EV_ADD && !launchd_assumes(udata != NULL)) {
 434                 errno = EINVAL;
 435                 return -1;
 436         }
 437
 438         EV_SET(&kev, ident, filter, flags, fflags, data, udata);
 439         return kevent(q, &kev, 1, NULL, 0, NULL);
 440 }
 441
 442 int
 443 _fd(int fd)
 444 {
 445         if (fd >= 0)
 446                 launchd_assumes(fcntl(fd, F_SETFD, 1) != -1);
 447         return fd;
 448 }
 449
 450 void
 451 ppidexit_callback(void)
 452 {
 453         launchd_shutdown();
 454
 455         /* Let's just bail for now. We should really try to wait for jobs to exit first. */
 456         exit(EXIT_SUCCESS);
 457 }
 458
 459 void
 460 launchd_shutdown(void)
 461 {
 462         shutdown_in_progress = true;
 463
 464         launchd_assumes(close(asynckq) != -1);
 465
 466         rlcj = NULL;
 467
 468         job_remove_all_inactive(root_job);
 469
 470         if (getpid() == 1)
 471                 catatonia();
 472 }
 473
 474 void
 475 launchd_single_user(void)
 476 {
 477         int tries;
 478
 479         launchd_shutdown();
 480
 481         kill(-1, SIGTERM);
 482
 483         for (tries = 0; tries < 10; tries++) {
 484                 sleep(1);
 485                 if (kill(-1, 0) == -1 && errno == ESRCH)
 486                         goto out;
 487         }
 488
 489         syslog(LOG_WARNING, "Gave up waiting for processes to exit while going to single user mode, sending SIGKILL");
 490         kill(-1, SIGKILL);
 491
 492 out:
 493         re_exec_in_single_user_mode = true;
 494 }
 495
 496 static void signal_callback(void *obj __attribute__((unused)), struct kevent *kev)
 497 {
 498         switch (kev->ident) {
 499         case SIGHUP:
 500                 if (rlcj)
 501                         job_start(rlcj);
 502                 break;
 503         case SIGTERM:
 504                 launchd_shutdown();
 505                 break;
 506         default:
 507                 break;
 508         }
 509 }
 510
 511 void
 512 fs_callback(void)
 513 {
 514         if (pending_stdout) {
 515                 int fd = open(pending_stdout, O_CREAT|O_APPEND|O_WRONLY|O_NOCTTY, DEFFILEMODE);
 516                 if (fd != -1) {
 517                         launchd_assumes(dup2(fd, STDOUT_FILENO) != -1);
 518                         launchd_assumes(close(fd) == 0);
 519                         free(pending_stdout);
 520                         pending_stdout = NULL;
 521                 }
 522         }
 523         if (pending_stderr) {
 524                 int fd = open(pending_stderr, O_CREAT|O_APPEND|O_WRONLY|O_NOCTTY, DEFFILEMODE);
 525                 if (fd != -1) {
 526                         launchd_assumes(dup2(fd, STDERR_FILENO) != -1);
 527                         launchd_assumes(close(fd) == 0);
 528                         free(pending_stderr);
 529                         pending_stderr = NULL;
 530                 }
 531         }
 532
 533         ipc_server_init(NULL, 0);
 534 }
 535
 536 void
 537 launchd_SessionCreate(void)
 538 {
 539         OSStatus (*sescr)(SessionCreationFlags flags, SessionAttributeBits attributes);
 540         void *seclib;
 541
 542         if (launchd_assumes((seclib = dlopen(SECURITY_LIB, RTLD_LAZY)) != NULL)) {
 543                 if (launchd_assumes((sescr = dlsym(seclib, "SessionCreate")) != NULL))
 544                         launchd_assumes(sescr(0, 0) == noErr);
 545                 launchd_assumes(dlclose(seclib) != -1);
 546         }
 547 }
 548
 549 void
 550 async_callback(void)
 551 {
 552         struct timespec timeout = { 0, 0 };
 553         struct kevent kev;
 554
 555         if (launchd_assumes(kevent(asynckq, NULL, 0, &kev, 1, &timeout) == 1))
 556                 (*((kq_callback *)kev.udata))(kev.udata, &kev);
 557 }
 558
 559 void
 560 testfd_or_openfd(int fd, const char *path, int flags)
 561 {
 562         int tmpfd;
 563
 564         if (-1 != (tmpfd = dup(fd))) {
 565                 launchd_assumes(close(tmpfd) == 0);
 566         } else {
 567                 if (-1 == (tmpfd = open(path, flags))) {
 568                         syslog(LOG_ERR, "open(\"%s\", ...): %m", path);
 569                 } else if (tmpfd != fd) {
 570                         launchd_assumes(dup2(tmpfd, fd) != -1);
 571                         launchd_assumes(close(tmpfd) == 0);
 572                 }
 573         }
 574 }
 575
 576 launch_data_t
 577 launchd_setstdio(int d, launch_data_t o)
 578 {
 579         launch_data_t resp = launch_data_new_errno(0);
 580
 581         if (launch_data_get_type(o) == LAUNCH_DATA_STRING) {
 582                 char **where = &pending_stderr;
 583
 584                 if (d == STDOUT_FILENO)
 585                         where = &pending_stdout;
 586                 if (*where)
 587                         free(*where);
 588                 *where = strdup(launch_data_get_string(o));
 589         } else if (launch_data_get_type(o) == LAUNCH_DATA_FD) {
 590                 launchd_assumes(dup2(launch_data_get_fd(o), d) != -1);
 591         } else {
 592                 launch_data_set_errno(resp, EINVAL);
 593         }
 594
 595         return resp;
 596 }
 597
 598 void
 599 batch_job_enable(bool e, struct conncb *c)
 600 {
 601         if (e && c->disabled_batch) {
 602                 batch_disabler_count--;
 603                 c->disabled_batch = 0;
 604                 if (batch_disabler_count == 0)
 605                         kevent_mod(asynckq, EVFILT_READ, EV_ENABLE, 0, 0, &kqasync_callback);
 606         } else if (!e && !c->disabled_batch) {
 607                 if (batch_disabler_count == 0)
 608                         kevent_mod(asynckq, EVFILT_READ, EV_DISABLE, 0, 0, &kqasync_callback);
 609                 batch_disabler_count++;
 610                 c->disabled_batch = 1;
 611         }
 612 }
 613
 614 bool
 615 get_network_state(void)
 616 {
 617         struct ifaddrs *ifa, *ifai;
 618         bool up = false;
 619
 620         if (!launchd_assumes(getifaddrs(&ifa) != -1))
 621                 return network_up;
 622
 623         for (ifai = ifa; ifai; ifai = ifai->ifa_next) {
 624                 if (!(ifai->ifa_flags & IFF_UP))
 625                         continue;
 626                 if (ifai->ifa_flags & IFF_LOOPBACK)
 627                         continue;
 628                 if (ifai->ifa_addr->sa_family != AF_INET && ifai->ifa_addr->sa_family != AF_INET6)
 629                         continue;
 630                 up = true;
 631                 break;
 632         }
 633
 634         freeifaddrs(ifa);
 635
 636         return up;
 637 }
 638
 639 void
 640 monitor_networking_state(void)
 641 {
 642         int pfs = _fd(socket(PF_SYSTEM, SOCK_RAW, SYSPROTO_EVENT));
 643         struct kev_request kev_req;
 644
 645         network_up = get_network_state();
 646
 647         if (!launchd_assumes(pfs != -1))
 648                 return;
 649
 650         memset(&kev_req, 0, sizeof(kev_req));
 651         kev_req.vendor_code = KEV_VENDOR_APPLE;
 652         kev_req.kev_class = KEV_NETWORK_CLASS;
 653
 654         if (!launchd_assumes(ioctl(pfs, SIOCSKEVFILT, &kev_req) != -1)) {
 655                 close(pfs);
 656                 return;
 657         }
 658
 659         launchd_assumes(kevent_mod(pfs, EVFILT_READ, EV_ADD, 0, 0, &kqpfsystem_callback) != -1);
 660 }
 661
 662 void
 663 pfsystem_callback(void *obj, struct kevent *kev)
 664 {
 665         bool new_networking_state;
 666         char buf[1024];
 667
 668         launchd_assumes(read(kev->ident, &buf, sizeof(buf)) != -1);
 669
 670         new_networking_state = get_network_state();
 671
 672         if (new_networking_state != network_up) {
 673                 network_up = new_networking_state;
 674                 job_dispatch_all_other_semaphores(root_job, NULL);
 675         }
 676 }
 677
 678 void
 679 _log_launchd_bug(const char *rcs_rev, const char *path, unsigned int line, const char *test)
 680 {
 681         int saved_errno = errno;
 682         char buf[100];
 683         const char *file = strrchr(path, '/');
 684         char *rcs_rev_tmp = strchr(rcs_rev, ' ');
 685
 686         if (!file) {
 687                 file = path;
 688         } else {
 689                 file += 1;
 690         }
 691
 692         if (!rcs_rev_tmp) {
 693                 strlcpy(buf, rcs_rev, sizeof(buf));
 694         } else {
 695                 strlcpy(buf, rcs_rev_tmp + 1, sizeof(buf));
 696                 rcs_rev_tmp = strchr(buf, ' ');
 697                 if (rcs_rev_tmp)
 698                         *rcs_rev_tmp = '\0';
 699         }
 700
 701         syslog(LOG_NOTICE, "Bug: %s:%u (%s):%u: %s", file, line, buf, saved_errno, test);
 702 }
 703
 704 bool
 705 progeny_check(pid_t p)
 706 {
 707         pid_t selfpid = getpid();
 708
 709         while (p != selfpid && p != 1) {
 710                 int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, p };
 711                 size_t miblen = sizeof(mib) / sizeof(mib[0]);
 712                 struct kinfo_proc kp;
 713                 size_t kplen = sizeof(kp);
 714
 715                 if (launchd_assumes(sysctl(mib, miblen, &kp, &kplen, NULL, 0) != -1)
 716                                 && launchd_assumes(kplen == sizeof(kp))) {
 717                         p = kp.kp_eproc.e_ppid;
 718                 } else {
 719                         return false;
 720                 }
 721         }
 722
 723         if (p == selfpid)
 724                 return true;
 725
 726         return false;
 727 }
 728
 729 boolean_t
 730 launchd_internal_demux(mach_msg_header_t *Request, mach_msg_header_t *Reply)
 731 {
 732         if (gc_this_job) {
 733                 job_remove(gc_this_job);
 734                 gc_this_job = NULL;
 735         }
 736
 737         if (Request->msgh_local_port == launchd_internal_port) {
 738                 if (launchd_internal_server_routine(Request))
 739                         return launchd_internal_server(Request, Reply);
 740         } else {
 741                 if (bootstrap_server_routine(Request))
 742                         return bootstrap_server(Request, Reply);
 743         }
 744
 745         return notify_server(Request, Reply);
 746 }