configd.tproj/configd.m

   1 /*
   2  * Copyright (c) 2000-2011, 2013 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * Modification History
  26  *
  27  * October 30, 2003             Allan Nathanson <ajn@apple.com>
  28  * - add plugin "stop()" function support
  29  *
  30  * June 1, 2001                 Allan Nathanson <ajn@apple.com>
  31  * - public API conversion
  32  *
  33  * 24 March 2000                Allan Nathanson <ajn@apple.com>
  34  * - created
  35  */
  36
  37 #define DO_NOT_INFORM
  38
  39 #include <getopt.h>
  40 #include <stdio.h>
  41 #include <sysexits.h>
  42 #include <syslog.h>
  43 #include <unistd.h>
  44 #include <paths.h>
  45 #include <fcntl.h>
  46 #include <sys/types.h>
  47 #include <sys/stat.h>
  48 #include <sys/wait.h>
  49 #include <objc/objc-runtime.h>
  50 #include <servers/bootstrap.h>
  51 #include <vproc.h>
  52 #include <vproc_priv.h>
  53
  54 #include "configd.h"
  55 #include "configd_server.h"
  56 #include "plugin_support.h"
  57
  58 #if     TARGET_OS_EMBEDDED && !defined(DO_NOT_INFORM)
  59 #include <CoreFoundation/CFUserNotification.h>
  60 #endif  // TARGET_OS_EMBEDDED && !defined(DO_NOT_INFORM)
  61
  62 __private_extern__
  63 Boolean _configd_verbose                = FALSE;        /* TRUE if verbose logging enabled */
  64
  65 __private_extern__
  66 FILE    *_configd_trace                 = NULL;         /* non-NULL if tracing enabled */
  67
  68 __private_extern__
  69 CFMutableSetRef _plugins_allowed        = NULL;         /* bundle identifiers to allow when loading */
  70
  71 __private_extern__
  72 CFMutableSetRef _plugins_exclude        = NULL;         /* bundle identifiers to exclude from loading */
  73
  74 __private_extern__
  75 Boolean _plugins_fork                   = FALSE;        /* TRUE if plugins should be exec'd in their own process */
  76
  77 __private_extern__
  78 CFMutableSetRef _plugins_verbose        = NULL;         /* bundle identifiers to enable verbose logging */
  79
  80 static CFMachPortRef termRequested      = NULL;         /* Mach port used to notify runloop of a shutdown request */
  81
  82
  83 static const struct option longopts[] = {
  84 //      { "include-plugin",     required_argument,      0,      'A' },
  85 //      { "no-bundles",         no_argument,            0,      'b' },
  86 //      { "exclude-plugin",     required_argument,      0,      'B' },
  87 //      { "no-fork",            no_argument,            0,      'd' },
  88 //      { "fork-all",           no_argument,            0,      'f' },
  89 //      { "test-bundle",        required_argument,      0,      't' },
  90 //      { "verbose",            no_argument,            0,      'v' },
  91 //      { "verbose-bundle",     required_argument,      0,      'V' },
  92         { "help",               no_argument,            0,      '?' },
  93         { 0,                    0,                      0,      0 }
  94 };
  95
  96
  97 static void
  98 usage(const char *prog)
  99 {
 100         SCPrint(TRUE, stderr, CFSTR("%s: [-d] [-v] [-V bundleID] [-b] [-B bundleID] [-A bundleID] [-t bundle-path]\n"), prog);
 101         SCPrint(TRUE, stderr, CFSTR("options:\n"));
 102         SCPrint(TRUE, stderr, CFSTR("\t-d\tdisable daemon/run in foreground\n"));
 103         SCPrint(TRUE, stderr, CFSTR("\t-v\tenable verbose logging\n"));
 104         SCPrint(TRUE, stderr, CFSTR("\t-V\tenable verbose logging for the specified plug-in\n"));
 105         SCPrint(TRUE, stderr, CFSTR("\t-f\tload ALL plug-ins in a separate process\n"));
 106         SCPrint(TRUE, stderr, CFSTR("\t-b\tdisable loading of ALL plug-ins\n"));
 107         SCPrint(TRUE, stderr, CFSTR("\t-B\tdisable loading of the specified plug-in\n"));
 108         SCPrint(TRUE, stderr, CFSTR("\t-A\tenable loading of the specified plug-in\n"));
 109         SCPrint(TRUE, stderr, CFSTR("\t-t\tload/test the specified plug-in\n"));
 110         SCPrint(TRUE, stderr, CFSTR("\t\t  (Note: only the plug-in will be started)\n"));
 111         exit (EX_USAGE);
 112 }
 113
 114
 115 static void
 116 catcher(int signum)
 117 {
 118         switch (signum) {
 119                 case SIGINT :
 120                 case SIGTERM :
 121                         if (termRequested != NULL) {
 122                                 if (_sc_log > 0) {
 123                                         /*
 124                                          * if we've received a [shutdown] SIGTERM
 125                                          * and we are syslog'ing than it's likely
 126                                          * that syslogd is also being term'd.  As
 127                                          * such, let's also push any remaining log
 128                                          * messages to stdout/stderr.
 129                                          */
 130                                         _sc_log = 2;
 131                                 }
 132
 133                                 /*
 134                                  * send message to indicate that a request has been made
 135                                  * for the daemon to be shutdown.
 136                                  */
 137                                 _SC_sendMachMessage(CFMachPortGetPort(termRequested), 0);
 138                         } else {
 139                                 _exit(EX_OK);
 140                         }
 141                         break;
 142         }
 143
 144         return;
 145 }
 146
 147
 148 static void
 149 term(CFMachPortRef port, void *msg, CFIndex size, void *info)
 150 {
 151         int     status  = EX_OK;
 152         Boolean wait;
 153
 154         wait = plugin_term(&status);
 155         if (!wait) {
 156                 // if we are not waiting on a plugin
 157                 status = server_shutdown();
 158                 exit (status);
 159         }
 160
 161         return;
 162 }
 163
 164
 165 static void
 166 parent_exit(int i)
 167 {
 168         _exit (0);
 169 }
 170
 171
 172 static void
 173 init_fds()
 174 {
 175         int     fd;
 176         int     i;
 177
 178         /* close any open FDs */
 179         for (i = getdtablesize()-1; i>=0; i--) close(i);
 180
 181         /* set stdin, stdout, stderr */
 182         fd = open(_PATH_DEVNULL, O_RDWR, 0);
 183         if (fd != -1) {
 184                 int     ofd;
 185
 186                 // stdin
 187                 (void) dup2(fd, STDIN_FILENO);
 188
 189                 // stdout, stderr
 190                 ofd = open("/var/log/configd.log", O_WRONLY|O_APPEND, 0);
 191                 if (ofd != -1) {
 192                         if (fd > STDIN_FILENO) {
 193                                 (void) close(fd);
 194                         }
 195                         fd = ofd;
 196                 }
 197                 (void) dup2(fd, STDOUT_FILENO);
 198                 (void) dup2(fd, STDERR_FILENO);
 199                 if (fd > STDERR_FILENO) {
 200                         (void) close(fd);
 201                 }
 202         }
 203
 204         SCTrace(TRUE, stdout, CFSTR("start\n"));
 205         return;
 206 }
 207
 208
 209 static void
 210 set_trace()
 211 {
 212         int     fd;
 213
 214         /* set _configd_trace */
 215         fd = open("/var/log/configd.trace", O_WRONLY|O_APPEND, 0);
 216         if (fd != -1) {
 217                 _configd_trace = fdopen(fd, "a");
 218                 SCTrace(TRUE, _configd_trace, CFSTR("start\n"));
 219         }
 220
 221         return;
 222 }
 223
 224
 225 static int
 226 fork_child()
 227 {
 228         int     child_pid;
 229
 230         signal(SIGTERM, parent_exit);
 231         child_pid = fork();
 232         switch (child_pid) {
 233                 case -1: {
 234                         return -1;
 235                 }
 236                 case 0: {
 237                         /* child: becomes the daemon (see below) */
 238                         signal(SIGTERM, SIG_DFL);
 239                         break;
 240                 }
 241                 default: {
 242                         /* parent: wait for signal, then exit */
 243                         int     status;
 244
 245                         (void) wait4(child_pid, (int *)&status, 0, 0);
 246                         if (WIFEXITED(status)) {
 247                                 fprintf(stderr,
 248                                         "*** configd (daemon) failed to start, exit status=%d",
 249                                         WEXITSTATUS(status));
 250                         } else {
 251                                 fprintf(stderr,
 252                                         "*** configd (daemon) failed to start, received signal=%d",
 253                                         WTERMSIG(status));
 254                         }
 255                         fflush (stderr);
 256                         exit (EX_SOFTWARE);
 257                 }
 258         }
 259
 260         if (setsid() == -1)
 261                 return -1;
 262
 263         (void) chdir("/");
 264
 265         return 0;
 266 }
 267
 268 static CFStringRef
 269 termMPCopyDescription(const void *info)
 270 {
 271         return CFStringCreateWithFormat(NULL, NULL, CFSTR("<SIGTERM MP>"));
 272 }
 273
 274
 275 int
 276 main(int argc, char * const argv[])
 277 {
 278         CFMachPortContext       context         = { 0
 279                                                   , (void *)1
 280                                                   , NULL
 281                                                   , NULL
 282                                                   , termMPCopyDescription
 283                                                   };
 284         Boolean                 forceForeground = FALSE;
 285         Boolean                 forcePlugin     = FALSE;
 286         int64_t                 is_launchd_job  = 0;
 287         mach_port_limits_t      limits;
 288         Boolean                 loadBundles     = TRUE;
 289         struct sigaction        nact;
 290         int                     opt;
 291 //      extern int              optind;
 292         const char              *prog           = argv[0];
 293         CFRunLoopSourceRef      rls;
 294         kern_return_t           status;
 295         CFStringRef             str;
 296         const char              *testBundle     = NULL;
 297
 298         _plugins_allowed = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
 299         _plugins_exclude = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
 300         _plugins_verbose = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
 301
 302         /* process any arguments */
 303
 304         while ((opt = getopt_long(argc, argv, "A:bB:dt:vV:f", longopts, NULL)) != -1) {
 305                 switch(opt) {
 306                         case 'A':
 307                                 str = CFStringCreateWithCString(NULL, optarg, kCFStringEncodingMacRoman);
 308                                 CFSetSetValue(_plugins_allowed, str);
 309                                 CFRelease(str);
 310                                 break;
 311                         case 'b':
 312                                 loadBundles = FALSE;
 313                                 break;
 314                         case 'B':
 315                                 str = CFStringCreateWithCString(NULL, optarg, kCFStringEncodingMacRoman);
 316                                 CFSetSetValue(_plugins_exclude, str);
 317                                 CFRelease(str);
 318                                 break;
 319                         case 'd':
 320                                 forceForeground = TRUE;
 321                                 break;
 322                         case 't':
 323                                 testBundle = optarg;
 324                                 break;
 325                         case 'v':
 326                                 _configd_verbose = TRUE;
 327                                 break;
 328                         case 'V':
 329                                 if (strcmp(optarg, "com.apple.SystemConfiguration") == 0) {
 330                                         _sc_verbose = TRUE;
 331                                 } else {
 332                                         str = CFStringCreateWithCString(NULL, optarg, kCFStringEncodingMacRoman);
 333                                         CFSetSetValue(_plugins_verbose, str);
 334                                         CFRelease(str);
 335                                 }
 336                                 break;
 337                         case 'f':
 338                                 _plugins_fork = TRUE;
 339                                 break;
 340                         case '?':
 341                         default :
 342                                 usage(prog);
 343                 }
 344         }
 345 //      argc -= optind;
 346 //      argv += optind;
 347
 348         /* check credentials */
 349 #if     !TARGET_IPHONE_SIMULATOR
 350         if (getuid() != 0) {
 351                 fprintf(stderr, "%s: permission denied.\n", prog);
 352                 exit (EX_NOPERM);
 353         }
 354 #endif  // !TARGET_IPHONE_SIMULATOR
 355
 356         /* check if we have been started by launchd */
 357         vproc_swap_integer(NULL, VPROC_GSK_IS_MANAGED, NULL, &is_launchd_job);
 358
 359 #if     TARGET_OS_EMBEDDED && !defined(DO_NOT_INFORM)
 360         // if launchd job, check to see if we have been restarted
 361         if (is_launchd_job) {
 362                 int64_t status  = 0;
 363
 364                 vproc_swap_integer(NULL, VPROC_GSK_LAST_EXIT_STATUS, NULL, &status);
 365                 if ((status != 0) && _SC_isAppleInternal()) {
 366                         int     fd;
 367
 368                         // if we've been restarted
 369                         fd = open("/var/run/configd-crash-reported", O_WRONLY|O_CREAT|O_EXCL, 0644);
 370                         if (fd >= 0) {
 371                                 // if we have not yet alerted the user
 372                                 CFUserNotificationDisplayNotice(0,
 373                                                                 kCFUserNotificationStopAlertLevel,
 374                                                                 NULL,
 375                                                                 NULL,
 376                                                                 NULL,
 377                                                                 CFSTR("\"configd\" restarted"),
 378                                                                 CFSTR("Please collect the crash report and file a Radar."),
 379                                                                 NULL);
 380                                 close(fd);
 381                         }
 382                 }
 383         }
 384 #endif  // TARGET_OS_EMBEDDED && !defined(DO_NOT_INFORM)
 385
 386         /* ensure that forked plugins behave */
 387         if ((testBundle != NULL) && (getenv("__FORKED_PLUGIN__") != NULL)) {
 388                 forcePlugin = TRUE;
 389         }
 390
 391         /* if needed, daemonize */
 392         if (!forceForeground && !is_launchd_job) {
 393                 /*
 394                  * if we haven't been asked to run in the foreground
 395                  * and have not been started by launchd (i.e. we're
 396                  * not already running as a Foreground process) then
 397                  * daemonize ourself.
 398                  */
 399                 if (fork_child() == -1) {
 400                         fprintf(stderr, "configd: fork() failed, %s\n", strerror(errno));
 401                         exit (1);
 402                 }
 403
 404                 /*
 405                  * Note: we are now the child process. The parent
 406                  *       waits/exits in fork_child.
 407                  */
 408         }
 409
 410         /*
 411          * close file descriptors, establish stdin/stdout/stderr,
 412          * setup logging.
 413          */
 414         if (!forceForeground || forcePlugin) {
 415                 int             facility        = LOG_DAEMON;
 416                 int             logopt          = LOG_CONS|LOG_NDELAY|LOG_PID;
 417                 struct stat     statbuf;
 418
 419                 if (!is_launchd_job && !forcePlugin) {
 420                         init_fds();
 421                 }
 422
 423                 if (_configd_verbose) {
 424                         logopt |= LOG_CONS;
 425                 }
 426
 427                 if (stat("/etc/rc.cdrom", &statbuf) == 0) {
 428                         facility = LOG_INSTALL;
 429                 }
 430
 431                 openlog("configd", logopt, facility);
 432         } else {
 433                 _sc_log = FALSE;        /* redirect SCLog() to stdout/stderr */
 434         }
 435
 436         /* check/enable trace logging */
 437         set_trace();
 438
 439         /* add signal handler to catch a SIGHUP */
 440         nact.sa_handler = catcher;
 441         sigemptyset(&nact.sa_mask);
 442         nact.sa_flags = SA_RESTART;
 443         if (sigaction(SIGHUP, &nact, NULL) == -1) {
 444                 SCLog(_configd_verbose, LOG_ERR,
 445                        CFSTR("sigaction(SIGHUP, ...) failed: %s"),
 446                        strerror(errno));
 447         }
 448
 449         /* add signal handler to catch a SIGPIPE */
 450         if (sigaction(SIGPIPE, &nact, NULL) == -1) {
 451                 SCLog(_configd_verbose, LOG_ERR,
 452                        CFSTR("sigaction(SIGPIPE, ...) failed: %s"),
 453                        strerror(errno));
 454         }
 455
 456         /* add signal handler to catch a SIGTERM */
 457         if (sigaction(SIGTERM, &nact, NULL) == -1) {
 458                 SCLog(_configd_verbose, LOG_ERR,
 459                       CFSTR("sigaction(SIGTERM, ...) failed: %s"),
 460                       strerror(errno));
 461         }
 462
 463         /* add signal handler to catch a SIGINT */
 464         if (sigaction(SIGINT, &nact, NULL) == -1) {
 465                 SCLog(_configd_verbose, LOG_ERR,
 466                       CFSTR("sigaction(SIGINT, ...) failed: %s"),
 467                       strerror(errno));
 468         }
 469
 470         /* create the "shutdown requested" notification port */
 471         termRequested = CFMachPortCreate(NULL, term, &context, NULL);
 472
 473         /* set queue limit */
 474         limits.mpl_qlimit = 1;
 475         status = mach_port_set_attributes(mach_task_self(),
 476                                           CFMachPortGetPort(termRequested),
 477                                           MACH_PORT_LIMITS_INFO,
 478                                           (mach_port_info_t)&limits,
 479                                           MACH_PORT_LIMITS_INFO_COUNT);
 480         if (status != KERN_SUCCESS) {
 481                 perror("mach_port_set_attributes");
 482         }
 483
 484         /* add to our runloop */
 485         rls = CFMachPortCreateRunLoopSource(NULL, termRequested, 0);
 486         CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
 487         CFRelease(rls);
 488
 489         if (testBundle == NULL) {
 490                 /* initialize primary (store management) thread */
 491                 server_init();
 492
 493                 if (!forceForeground && !is_launchd_job) {
 494                         /* synchronize with parent process */
 495                         kill(getppid(), SIGTERM);
 496                 }
 497
 498                 /* load/initialize/start bundles into the secondary thread */
 499                 if (loadBundles) {
 500                         /* start plug-in initialization */
 501                         plugin_init();
 502                 }
 503
 504                 /* start primary (store management) thread */
 505                 server_loop();
 506         } else {
 507                 /* load/initialize/start specified plug-in */
 508                 plugin_exec((void *)testBundle);
 509         }
 510
 511         exit (EX_OK);   /* insure the process exit status is 0 */
 512         return 0;       /* ...and make main fit the ANSI spec. */
 513 }