SystemStarter/StartupItems.c

   1 /**
   2  * StartupItems.c - Startup Item management routines
   3  * Wilfredo Sanchez  | wsanchez@opensource.apple.com
   4  * Kevin Van Vechten | kevinvv@uclink4.berkeley.edu
   5  * $Apple$
   6  **
   7  * Copyright (c) 1999-2002 Apple Computer, Inc. All rights reserved.
   8  *
   9  * @APPLE_APACHE_LICENSE_HEADER_START@
  10  *
  11  * Licensed under the Apache License, Version 2.0 (the "License");
  12  * you may not use this file except in compliance with the License.
  13  * You may obtain a copy of the License at
  14  *
  15  *     http://www.apache.org/licenses/LICENSE-2.0
  16  *
  17  * Unless required by applicable law or agreed to in writing, software
  18  * distributed under the License is distributed on an "AS IS" BASIS,
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  * See the License for the specific language governing permissions and
  21  * limitations under the License.
  22  *
  23  * @APPLE_APACHE_LICENSE_HEADER_END@
  24  **/
  25
  26 #include <unistd.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <sys/sysctl.h>
  30 #include <sys/mman.h>
  31 #include <stdlib.h>
  32 #include <fcntl.h>
  33 #include <dirent.h>
  34 #include <limits.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <sysexits.h>
  38 #include <syslog.h>
  39 #include <CoreFoundation/CoreFoundation.h>
  40 #include "StartupItems.h"
  41
  42 #define kStartupItemsPath       "/StartupItems"
  43 #define kParametersFile         "StartupParameters.plist"
  44 #define kDisabledFile           ".disabled"
  45
  46 #define kRunSuccess CFSTR("success")
  47 #define kRunFailure CFSTR("failure")
  48
  49 static const char *argumentForAction(Action anAction)
  50 {
  51         switch (anAction) {
  52         case kActionStart:
  53                 return "start";
  54         case kActionStop:
  55                 return "stop";
  56         case kActionRestart:
  57                 return "restart";
  58         default:
  59                 return NULL;
  60         }
  61 }
  62
  63 #define checkTypeOfValue(aKey,aTypeID)                                  \
  64   {                                                                     \
  65     CFStringRef aProperty = CFDictionaryGetValue(aConfig, aKey);        \
  66     if (aProperty && CFGetTypeID(aProperty) != aTypeID)                 \
  67       return FALSE;                                                     \
  68   }
  69
  70 static int StartupItemValidate(CFDictionaryRef aConfig)
  71 {
  72         if (aConfig && CFGetTypeID(aConfig) == CFDictionaryGetTypeID()) {
  73                 checkTypeOfValue(kProvidesKey, CFArrayGetTypeID());
  74                 checkTypeOfValue(kRequiresKey, CFArrayGetTypeID());
  75
  76                 return TRUE;
  77         }
  78         return FALSE;
  79 }
  80
  81 /*
  82  *      remove item from waiting list
  83  */
  84 void RemoveItemFromWaitingList(StartupContext aStartupContext, CFMutableDictionaryRef anItem)
  85 {
  86         /* Remove the item from the waiting list. */
  87         if (aStartupContext && anItem && aStartupContext->aWaitingList) {
  88                 CFRange aRange = { 0, CFArrayGetCount(aStartupContext->aWaitingList) };
  89                 CFIndex anIndex = CFArrayGetFirstIndexOfValue(aStartupContext->aWaitingList, aRange, anItem);
  90
  91                 if (anIndex >= 0) {
  92                         CFArrayRemoveValueAtIndex(aStartupContext->aWaitingList, anIndex);
  93                 }
  94         }
  95 }
  96
  97 /*
  98  *      add item to failed list, create list if it doesn't exist
  99  *      return and fail quietly if it can't create list
 100  */
 101 void AddItemToFailedList(StartupContext aStartupContext, CFMutableDictionaryRef anItem)
 102 {
 103         if (aStartupContext && anItem) {
 104                 /* create the failed list if it doesn't exist */
 105                 if (!aStartupContext->aFailedList) {
 106                         aStartupContext->aFailedList = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 107                 }
 108                 if (aStartupContext->aFailedList) {
 109                         CFArrayAppendValue(aStartupContext->aFailedList, anItem);
 110                 }
 111         }
 112 }
 113
 114 /**
 115  * startupItemListCopyMatches returns an array of items which contain the string aService in the key aKey
 116  **/
 117 static CFMutableArrayRef startupItemListCopyMatches(CFArrayRef anItemList, CFStringRef aKey, CFStringRef aService)
 118 {
 119         CFMutableArrayRef aResult = NULL;
 120
 121         if (anItemList && aKey && aService) {
 122                 CFIndex anItemCount = CFArrayGetCount(anItemList);
 123                 CFIndex anItemIndex = 0;
 124
 125                 aResult = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 126
 127                 for (anItemIndex = 0; anItemIndex < anItemCount; ++anItemIndex) {
 128                         CFMutableDictionaryRef anItem = (CFMutableDictionaryRef) CFArrayGetValueAtIndex(anItemList, anItemIndex);
 129                         CFArrayRef aList = CFDictionaryGetValue(anItem, aKey);
 130
 131                         if (aList) {
 132                                 if (CFArrayContainsValue(aList, CFRangeMake(0, CFArrayGetCount(aList)), aService) &&
 133                                     !CFArrayContainsValue(aResult, CFRangeMake(0, CFArrayGetCount(aResult)), anItem)) {
 134                                         CFArrayAppendValue(aResult, anItem);
 135                                 }
 136                         }
 137                 }
 138         }
 139         return aResult;
 140 }
 141
 142 static void SpecialCasesStartupItemHandler(CFMutableDictionaryRef aConfig)
 143 {
 144         static const CFStringRef stubitems[] = {
 145                 CFSTR("Accounting"),
 146                 CFSTR("System Tuning"),
 147                 CFSTR("SecurityServer"),
 148                 CFSTR("Portmap"),
 149                 CFSTR("System Log"),
 150                 CFSTR("Resolver"),
 151                 CFSTR("LDAP"),
 152                 CFSTR("NetInfo"),
 153                 CFSTR("NetworkExtensions"),
 154                 CFSTR("DirectoryServices"),
 155                 CFSTR("Network Configuration"),
 156                 CFSTR("mDNSResponder"),
 157                 CFSTR("Cron"),
 158                 CFSTR("Core Graphics"),
 159                 CFSTR("Core Services"),
 160                 CFSTR("Network"),
 161                 CFSTR("TIM"),
 162                 CFSTR("Disks"),
 163                 CFSTR("NIS"),
 164                 NULL
 165         };
 166         CFMutableArrayRef aList, aNewList;
 167         CFIndex i, aCount;
 168         CFStringRef ci, type = kRequiresKey;
 169         const CFStringRef *c;
 170
 171       again:
 172         aList = (CFMutableArrayRef) CFDictionaryGetValue(aConfig, type);
 173         if (aList) {
 174                 aCount = CFArrayGetCount(aList);
 175
 176                 aNewList = CFArrayCreateMutable(kCFAllocatorDefault, aCount, &kCFTypeArrayCallBacks);
 177
 178                 for (i = 0; i < aCount; i++) {
 179                         ci = CFArrayGetValueAtIndex(aList, i);
 180                         CF_syslog(LOG_DEBUG, CFSTR("%@: Evaluating %@"), type, ci);
 181                         for (c = stubitems; *c; c++) {
 182                                 if (CFEqual(*c, ci))
 183                                         break;
 184                         }
 185                         if (*c == NULL) {
 186                                 CFArrayAppendValue(aNewList, ci);
 187                                 CF_syslog(LOG_DEBUG, CFSTR("%@: Keeping %@"), type, ci);
 188                         }
 189                 }
 190
 191                 CFDictionaryReplaceValue(aConfig, type, aNewList);
 192                 CFRelease(aNewList);
 193         }
 194         if (type == kUsesKey)
 195                 return;
 196         type = kUsesKey;
 197         goto again;
 198 }
 199
 200 CFIndex StartupItemListCountServices(CFArrayRef anItemList)
 201 {
 202         CFIndex aResult = 0;
 203
 204         if (anItemList) {
 205                 CFIndex anItemCount = CFArrayGetCount(anItemList);
 206                 CFIndex anItemIndex = 0;
 207
 208                 for (anItemIndex = 0; anItemIndex < anItemCount; ++anItemIndex) {
 209                         CFDictionaryRef anItem = CFArrayGetValueAtIndex(anItemList, anItemIndex);
 210                         CFArrayRef aProvidesList = CFDictionaryGetValue(anItem, kProvidesKey);
 211
 212                         if (aProvidesList)
 213                                 aResult += CFArrayGetCount(aProvidesList);
 214                 }
 215         }
 216         return aResult;
 217 }
 218
 219 bool StartupItemSecurityCheck(const char *aPath)
 220 {
 221         static struct timeval boot_time;
 222         struct stat aStatBuf;
 223         bool r = true;
 224
 225         if (boot_time.tv_sec == 0) {
 226                 int mib[] = { CTL_KERN, KERN_BOOTTIME };
 227                 size_t boot_time_sz = sizeof(boot_time);
 228                 int rv;
 229
 230                 rv = sysctl(mib, sizeof(mib) / sizeof(mib[0]), &boot_time, &boot_time_sz, NULL, 0);
 231
 232                 assert(rv != -1);
 233                 assert(boot_time_sz == sizeof(boot_time));
 234         }
 235
 236         /* should use lstatx_np() on Tiger? */
 237         if (lstat(aPath, &aStatBuf) == -1) {
 238                 if (errno != ENOENT)
 239                         syslog(LOG_ERR, "lstat(\"%s\"): %m", aPath);
 240                 return false;
 241         }
 242         /*
 243          * We check the boot time because of 5409386.
 244          * We ignore the boot time if PPID != 1 because of 5503536.
 245          */
 246         if ((aStatBuf.st_ctimespec.tv_sec > boot_time.tv_sec) && (getppid() == 1)) {
 247                 syslog(LOG_WARNING, "\"%s\" failed sanity check: path was created after boot up", aPath);
 248                 return false;
 249         }
 250         if (!(S_ISREG(aStatBuf.st_mode) || S_ISDIR(aStatBuf.st_mode))) {
 251                 syslog(LOG_WARNING, "\"%s\" failed security check: not a directory or regular file", aPath);
 252                 r = false;
 253         }
 254         if (aStatBuf.st_mode & S_IWOTH) {
 255                 syslog(LOG_WARNING, "\"%s\" failed security check: world writable", aPath);
 256                 r = false;
 257         }
 258         if (aStatBuf.st_mode & S_IWGRP) {
 259                 syslog(LOG_WARNING, "\"%s\" failed security check: group writable", aPath);
 260                 r = false;
 261         }
 262         if (aStatBuf.st_uid != 0) {
 263                 syslog(LOG_WARNING, "\"%s\" failed security check: not owned by UID 0", aPath);
 264                 r = false;
 265         }
 266         if (aStatBuf.st_gid != 0) {
 267                 syslog(LOG_WARNING, "\"%s\" failed security check: not owned by GID 0", aPath);
 268                 r = false;
 269         }
 270         if (r == false) {
 271                 mkdir(kFixerDir, ACCESSPERMS);
 272                 close(open(kFixerPath, O_RDWR|O_CREAT|O_NOCTTY, DEFFILEMODE));
 273         }
 274         return r;
 275 }
 276
 277 CFMutableArrayRef StartupItemListCreateWithMask(NSSearchPathDomainMask aMask)
 278 {
 279         CFMutableArrayRef anItemList = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 280
 281         char aPath[PATH_MAX];
 282         CFIndex aDomainIndex = 0;
 283
 284         NSSearchPathEnumerationState aState = NSStartSearchPathEnumeration(NSLibraryDirectory, aMask);
 285
 286         while ((aState = NSGetNextSearchPathEnumeration(aState, aPath))) {
 287                 DIR *aDirectory;
 288
 289                 strlcat(aPath, kStartupItemsPath, sizeof(aPath));
 290                 ++aDomainIndex;
 291
 292                 /* 5485016
 293                  *
 294                  * Just in case...
 295                  */
 296                 mkdir(aPath, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
 297
 298                 if (!StartupItemSecurityCheck(aPath))
 299                         continue;
 300
 301                 if ((aDirectory = opendir(aPath))) {
 302                         struct dirent *aBundle;
 303
 304                         while ((aBundle = readdir(aDirectory))) {
 305                                 struct stat aStatBuf;
 306                                 char *aBundleName = aBundle->d_name;
 307                                 char aBundlePath[PATH_MAX];
 308                                 char aBundleExecutablePath[PATH_MAX];
 309                                 char aConfigFile[PATH_MAX];
 310                                 char aDisabledFile[PATH_MAX];
 311
 312                                 if (aBundleName[0] == '.')
 313                                         continue;
 314
 315                                 syslog(LOG_DEBUG, "Found item: %s", aBundleName);
 316
 317                                 sprintf(aBundlePath, "%s/%s", aPath, aBundleName);
 318                                 sprintf(aBundleExecutablePath, "%s/%s", aBundlePath, aBundleName);
 319                                 sprintf(aConfigFile, "%s/%s", aBundlePath, kParametersFile);
 320                                 sprintf(aDisabledFile, "%s/%s", aBundlePath, kDisabledFile);
 321
 322                                 if (lstat(aDisabledFile, &aStatBuf) == 0) {
 323                                         syslog(LOG_NOTICE, "Skipping disabled StartupItem: %s", aBundlePath);
 324                                         continue;
 325                                 }
 326                                 if (!StartupItemSecurityCheck(aBundlePath))
 327                                         continue;
 328                                 if (!StartupItemSecurityCheck(aBundleExecutablePath))
 329                                         continue;
 330                                 if (!StartupItemSecurityCheck(aConfigFile))
 331                                         continue;
 332
 333                                 /* Stow away the plist data for each bundle */
 334                                 {
 335                                         int aConfigFileDescriptor;
 336
 337                                         if ((aConfigFileDescriptor = open(aConfigFile, O_RDONLY|O_NOCTTY, (mode_t) 0)) != -1) {
 338                                                 struct stat aConfigFileStatBuffer;
 339
 340                                                 if (stat(aConfigFile, &aConfigFileStatBuffer) != -1) {
 341                                                         off_t aConfigFileContentsSize = aConfigFileStatBuffer.st_size;
 342                                                         char *aConfigFileContentsBuffer;
 343
 344                                                         if ((aConfigFileContentsBuffer =
 345                                                              mmap((caddr_t) 0, aConfigFileContentsSize,
 346                                                                   PROT_READ, MAP_FILE | MAP_PRIVATE,
 347                                                                   aConfigFileDescriptor, (off_t) 0)) != (caddr_t) - 1) {
 348                                                                 CFDataRef aConfigData = NULL;
 349                                                                 CFMutableDictionaryRef aConfig = NULL;
 350
 351                                                                 aConfigData =
 352                                                                         CFDataCreateWithBytesNoCopy(NULL,
 353                                                                                                     (const UInt8 *)aConfigFileContentsBuffer,
 354                                                                                                     aConfigFileContentsSize,
 355                                                                                                     kCFAllocatorNull);
 356
 357                                                                 if (aConfigData) {
 358                                                                         aConfig = (CFMutableDictionaryRef)
 359                                                                             CFPropertyListCreateFromXMLData(NULL, aConfigData,
 360                                                                                                             kCFPropertyListMutableContainers,
 361                                                                                                             NULL);
 362                                                                 }
 363                                                                 if (StartupItemValidate(aConfig)) {
 364                                                                         CFStringRef aBundlePathString =
 365                                                                             CFStringCreateWithCString(NULL, aBundlePath,
 366                                                                                                       kCFStringEncodingUTF8);
 367
 368                                                                         CFNumberRef aDomainNumber =
 369                                                                             CFNumberCreate(NULL, kCFNumberCFIndexType,
 370                                                                                            &aDomainIndex);
 371
 372                                                                         CFDictionarySetValue(aConfig, kBundlePathKey,
 373                                                                                              aBundlePathString);
 374                                                                         CFDictionarySetValue(aConfig, kDomainKey, aDomainNumber);
 375                                                                         CFRelease(aDomainNumber);
 376                                                                         SpecialCasesStartupItemHandler(aConfig);
 377                                                                         CFArrayAppendValue(anItemList, aConfig);
 378
 379                                                                         CFRelease(aBundlePathString);
 380                                                                 } else {
 381                                                                         syslog(LOG_ERR, "Malformatted parameters file: %s",
 382                                                                                aConfigFile);
 383                                                                 }
 384
 385                                                                 if (aConfig)
 386                                                                         CFRelease(aConfig);
 387                                                                 if (aConfigData)
 388                                                                         CFRelease(aConfigData);
 389
 390                                                                 if (munmap(aConfigFileContentsBuffer, aConfigFileContentsSize) ==
 391                                                                     -1) {
 392                                                                         syslog(LOG_WARNING,
 393                                                                                "Unable to unmap parameters file %s for item %s: %m",
 394                                                                                aConfigFile, aBundleName);
 395                                                                 }
 396                                                         } else {
 397                                                                 syslog(LOG_ERR,
 398                                                                        "Unable to map parameters file %s for item %s: %m",
 399                                                                        aConfigFile, aBundleName);
 400                                                         }
 401                                                 } else {
 402                                                         syslog(LOG_ERR, "Unable to stat parameters file %s for item %s: %m",
 403                                                                aConfigFile, aBundleName);
 404                                                 }
 405
 406                                                 if (close(aConfigFileDescriptor) == -1) {
 407                                                         syslog(LOG_ERR, "Unable to close parameters file %s for item %s: %m",
 408                                                                aConfigFile, aBundleName);
 409                                                 }
 410                                         } else {
 411                                                 syslog(LOG_ERR, "Unable to open parameters file %s for item %s: %m", aConfigFile,
 412                                                        aBundleName);
 413                                         }
 414                                 }
 415                         }
 416                         if (closedir(aDirectory) == -1) {
 417                                 syslog(LOG_WARNING, "Unable to directory bundle %s: %m", aPath);
 418                         }
 419                 } else {
 420                         if (errno != ENOENT) {
 421                                 syslog(LOG_WARNING, "Open on directory %s failed: %m", aPath);
 422                                 return (NULL);
 423                         }
 424                 }
 425         }
 426
 427         return anItemList;
 428 }
 429
 430 CFMutableDictionaryRef StartupItemListGetProvider(CFArrayRef anItemList, CFStringRef aService)
 431 {
 432         CFMutableDictionaryRef aResult = NULL;
 433         CFMutableArrayRef aList = startupItemListCopyMatches(anItemList, kProvidesKey, aService);
 434
 435         if (aList && CFArrayGetCount(aList) > 0)
 436                 aResult = (CFMutableDictionaryRef) CFArrayGetValueAtIndex(aList, 0);
 437
 438         if (aList) CFRelease(aList);
 439
 440         return aResult;
 441 }
 442
 443 CFArrayRef StartupItemListCreateFromRunning(CFArrayRef anItemList)
 444 {
 445         CFMutableArrayRef aResult = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 446         if (aResult) {
 447                 CFIndex anIndex, aCount = CFArrayGetCount(anItemList);
 448                 for (anIndex = 0; anIndex < aCount; ++anIndex) {
 449                         CFDictionaryRef anItem = CFArrayGetValueAtIndex(anItemList, anIndex);
 450                         if (anItem) {
 451                                 CFNumberRef aPID = CFDictionaryGetValue(anItem, kPIDKey);
 452                                 if (aPID)
 453                                         CFArrayAppendValue(aResult, anItem);
 454                         }
 455                 }
 456         }
 457         return aResult;
 458 }
 459
 460 /*
 461  * Append items in anItemList to aDependents which depend on
 462  *  aParentItem.
 463  * If anAction is kActionStart, dependent items are those which
 464  *  require any service provided by aParentItem.
 465  * If anAction is kActionStop, dependent items are those which provide
 466  *  any service required by aParentItem.
 467  */
 468 static void appendDependents(CFMutableArrayRef aDependents, CFArrayRef anItemList, CFDictionaryRef aParentItem, Action anAction)
 469 {
 470         CFStringRef anInnerKey, anOuterKey;
 471         CFArrayRef anOuterList;
 472
 473         /* Append the parent item to the list (avoiding duplicates) */
 474         if (!CFArrayContainsValue(aDependents, CFRangeMake(0, CFArrayGetCount(aDependents)), aParentItem))
 475                 CFArrayAppendValue(aDependents, aParentItem);
 476
 477         /**
 478          * Recursively append any children of the parent item for kStartAction and kStopAction.
 479          * Do nothing for other actions.
 480          **/
 481         switch (anAction) {
 482         case kActionStart:
 483                 anInnerKey = kProvidesKey;
 484                 anOuterKey = kRequiresKey;
 485                 break;
 486         case kActionStop:
 487                 anInnerKey = kRequiresKey;
 488                 anOuterKey = kProvidesKey;
 489                 break;
 490         default:
 491                 return;
 492         }
 493
 494         anOuterList = CFDictionaryGetValue(aParentItem, anOuterKey);
 495
 496         if (anOuterList) {
 497                 CFIndex anOuterCount = CFArrayGetCount(anOuterList);
 498                 CFIndex anOuterIndex;
 499
 500                 for (anOuterIndex = 0; anOuterIndex < anOuterCount; anOuterIndex++) {
 501                         CFStringRef anOuterElement = CFArrayGetValueAtIndex(anOuterList, anOuterIndex);
 502                         CFIndex anItemCount = CFArrayGetCount(anItemList);
 503                         CFIndex anItemIndex;
 504
 505                         for (anItemIndex = 0; anItemIndex < anItemCount; anItemIndex++) {
 506                                 CFDictionaryRef anItem = CFArrayGetValueAtIndex(anItemList, anItemIndex);
 507                                 CFArrayRef anInnerList = CFDictionaryGetValue(anItem, anInnerKey);
 508
 509                                 if (anInnerList &&
 510                                     CFArrayContainsValue(anInnerList, CFRangeMake(0, CFArrayGetCount(anInnerList)),
 511                                                          anOuterElement)
 512                                     && !CFArrayContainsValue(aDependents, CFRangeMake(0, CFArrayGetCount(aDependents)), anItem))
 513                                         appendDependents(aDependents, anItemList, anItem, anAction);
 514                         }
 515                 }
 516         }
 517 }
 518
 519 CFMutableArrayRef StartupItemListCreateDependentsList(CFMutableArrayRef anItemList, CFStringRef aService, Action anAction)
 520 {
 521         CFMutableArrayRef aDependents = NULL;
 522         CFMutableDictionaryRef anItem = NULL;
 523
 524         if (anItemList && aService)
 525                 anItem = StartupItemListGetProvider(anItemList, aService);
 526
 527         if (anItem) {
 528                 switch (anAction) {
 529                 case kActionRestart:
 530                 case kActionStart:
 531                 case kActionStop:
 532                         aDependents = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
 533
 534                         if (!aDependents) {
 535                                 CF_syslog(LOG_EMERG, CFSTR("Failed to allocate dependancy list for item %@"), anItem);
 536                                 return NULL;
 537                         }
 538                         appendDependents(aDependents, anItemList, anItem, anAction);
 539                         break;
 540
 541                 default:
 542                         break;
 543                 }
 544         }
 545         return aDependents;
 546 }
 547
 548 /**
 549  * countUnmetRequirements counts the number of items in anItemList
 550  * which are pending in aStatusDict.
 551  **/
 552 static int countUnmetRequirements(CFDictionaryRef aStatusDict, CFArrayRef anItemList)
 553 {
 554         int aCount = 0;
 555         CFIndex anItemCount = CFArrayGetCount(anItemList);
 556         CFIndex anItemIndex;
 557
 558         for (anItemIndex = 0; anItemIndex < anItemCount; anItemIndex++) {
 559                 CFStringRef anItem = CFArrayGetValueAtIndex(anItemList, anItemIndex);
 560                 CFStringRef aStatus = CFDictionaryGetValue(aStatusDict, anItem);
 561
 562                 if (!aStatus || !CFEqual(aStatus, kRunSuccess)) {
 563                         CF_syslog(LOG_DEBUG, CFSTR("\tFailed requirement/uses: %@"), anItem);
 564                         aCount++;
 565                 }
 566         }
 567
 568         return aCount;
 569 }
 570
 571 /**
 572  * countDependantsPresent counts the number of items in aWaitingList
 573  * which depend on items in anItemList.
 574  **/
 575 static int countDependantsPresent(CFArrayRef aWaitingList, CFArrayRef anItemList, CFStringRef aKey)
 576 {
 577         int aCount = 0;
 578         CFIndex anItemCount = CFArrayGetCount(anItemList);
 579         CFIndex anItemIndex;
 580
 581         for (anItemIndex = 0; anItemIndex < anItemCount; anItemIndex++) {
 582                 CFStringRef anItem = CFArrayGetValueAtIndex(anItemList, anItemIndex);
 583                 CFArrayRef aMatchesList = startupItemListCopyMatches(aWaitingList, aKey, anItem);
 584
 585                 if (aMatchesList) {
 586                         aCount = aCount + CFArrayGetCount(aMatchesList);
 587                         CFRelease(aMatchesList);
 588                 }
 589         }
 590
 591         return aCount;
 592 }
 593
 594 /**
 595  * pendingAntecedents returns TRUE if any antecedents of this item
 596  * are currently running, have not yet run, or none exist.
 597  **/
 598 static Boolean
 599 pendingAntecedents(CFArrayRef aWaitingList, CFDictionaryRef aStatusDict, CFArrayRef anAntecedentList, Action anAction)
 600 {
 601         int aPendingFlag = FALSE;
 602
 603         CFIndex anAntecedentCount = CFArrayGetCount(anAntecedentList);
 604         CFIndex anAntecedentIndex;
 605
 606         for (anAntecedentIndex = 0; anAntecedentIndex < anAntecedentCount; ++anAntecedentIndex) {
 607                 CFStringRef anAntecedent = CFArrayGetValueAtIndex(anAntecedentList, anAntecedentIndex);
 608                 CFStringRef aKey = (anAction == kActionStart) ? kProvidesKey : kUsesKey;
 609                 CFArrayRef aMatchesList = startupItemListCopyMatches(aWaitingList, aKey, anAntecedent);
 610
 611                 if (aMatchesList) {
 612                         CFIndex aMatchesListCount = CFArrayGetCount(aMatchesList);
 613                         CFIndex aMatchesListIndex;
 614
 615                         for (aMatchesListIndex = 0; aMatchesListIndex < aMatchesListCount; ++aMatchesListIndex) {
 616                                 CFDictionaryRef anItem = CFArrayGetValueAtIndex(aMatchesList, aMatchesListIndex);
 617
 618                                 if (!anItem ||
 619                                     !CFDictionaryGetValue(anItem, kPIDKey) || !CFDictionaryGetValue(aStatusDict, anAntecedent)) {
 620                                         aPendingFlag = TRUE;
 621                                         break;
 622                                 }
 623                         }
 624
 625                         CFRelease(aMatchesList);
 626
 627                         if (aPendingFlag)
 628                                 break;
 629                 }
 630         }
 631         return (aPendingFlag);
 632 }
 633
 634 /**
 635  * checkForDuplicates returns TRUE if an item provides the same service as a
 636  * pending item, or an item that already succeeded.
 637  **/
 638 static Boolean checkForDuplicates(CFArrayRef aWaitingList, CFDictionaryRef aStatusDict, CFDictionaryRef anItem)
 639 {
 640         int aDuplicateFlag = FALSE;
 641
 642         CFArrayRef aProvidesList = CFDictionaryGetValue(anItem, kProvidesKey);
 643         CFIndex aProvidesCount = aProvidesList ? CFArrayGetCount(aProvidesList) : 0;
 644         CFIndex aProvidesIndex;
 645
 646         for (aProvidesIndex = 0; aProvidesIndex < aProvidesCount; ++aProvidesIndex) {
 647                 CFStringRef aProvides = CFArrayGetValueAtIndex(aProvidesList, aProvidesIndex);
 648
 649                 /* If the service succeeded, return true. */
 650                 CFStringRef aStatus = CFDictionaryGetValue(aStatusDict, aProvides);
 651                 if (aStatus && CFEqual(aStatus, kRunSuccess)) {
 652                         aDuplicateFlag = TRUE;
 653                         break;
 654                 }
 655                 /*
 656                  * Otherwise test if any item is currently running which
 657                  * might provide that service.
 658                  */
 659                 else {
 660                         CFArrayRef aMatchesList = startupItemListCopyMatches(aWaitingList, kProvidesKey, aProvides);
 661                         if (aMatchesList) {
 662                                 CFIndex aMatchesListCount = CFArrayGetCount(aMatchesList);
 663                                 CFIndex aMatchesListIndex;
 664
 665                                 for (aMatchesListIndex = 0; aMatchesListIndex < aMatchesListCount; ++aMatchesListIndex) {
 666                                         CFDictionaryRef anDupItem = CFArrayGetValueAtIndex(aMatchesList, aMatchesListIndex);
 667                                         if (anDupItem && CFDictionaryGetValue(anDupItem, kPIDKey)) {
 668                                                 /*
 669                                                  * Item is running, avoid
 670                                                  * race condition.
 671                                                  */
 672                                                 aDuplicateFlag = TRUE;
 673                                                 break;
 674                                         } else {
 675                                                 CFNumberRef anItemDomain = CFDictionaryGetValue(anItem, kDomainKey);
 676                                                 CFNumberRef anotherItemDomain = CFDictionaryGetValue(anDupItem, kDomainKey);
 677                                                 /*
 678                                                  * If anItem was found later
 679                                                  * than aDupItem, stall
 680                                                  * anItem until aDupItem
 681                                                  * runs.
 682                                                  */
 683                                                 if (anItemDomain &&
 684                                                     anotherItemDomain &&
 685                                                     CFNumberCompare(anItemDomain, anotherItemDomain,
 686                                                                     NULL) == kCFCompareGreaterThan) {
 687                                                         /*
 688                                                          * Item not running,
 689                                                          * but takes
 690                                                          * precedence.
 691                                                          */
 692                                                         aDuplicateFlag = TRUE;
 693                                                         break;
 694                                                 }
 695                                         }
 696                                 }
 697
 698                                 CFRelease(aMatchesList);
 699                                 if (aDuplicateFlag)
 700                                         break;
 701                         }
 702                 }
 703         }
 704         return (aDuplicateFlag);
 705 }
 706
 707 CFMutableDictionaryRef StartupItemListGetNext(CFArrayRef aWaitingList, CFDictionaryRef aStatusDict, Action anAction)
 708 {
 709         CFMutableDictionaryRef aNextItem = NULL;
 710         CFIndex aWaitingCount = CFArrayGetCount(aWaitingList);
 711         int aMinFailedAntecedents = INT_MAX;
 712         CFIndex aWaitingIndex;
 713
 714         switch (anAction) {
 715         case kActionStart:
 716                 break;
 717         case kActionStop:
 718                 break;
 719         case kActionRestart:
 720                 break;
 721         default:
 722                 return NULL;
 723         }
 724
 725         if (!aWaitingList || !aStatusDict || aWaitingCount <= 0)
 726                 return NULL;
 727
 728         /**
 729          * Iterate through the items in aWaitingList and look for an optimally ready item.
 730          **/
 731         for (aWaitingIndex = 0; aWaitingIndex < aWaitingCount; aWaitingIndex++) {
 732                 CFMutableDictionaryRef anItem = (CFMutableDictionaryRef) CFArrayGetValueAtIndex(aWaitingList, aWaitingIndex);
 733                 CFArrayRef anAntecedentList;
 734                 int aFailedAntecedentsCount = 0;        /* Number of unmet soft
 735                                                          * depenancies */
 736                 Boolean aBestPick = FALSE;      /* Is this the best pick
 737                                                  * so far?    */
 738
 739                 /* Filter out running items. */
 740                 if (CFDictionaryGetValue(anItem, kPIDKey))
 741                         continue;
 742
 743                 /*
 744                  * Filter out dupilicate services; if someone has
 745                  * provided what we provide, we don't run.
 746                  */
 747                 if (checkForDuplicates(aWaitingList, aStatusDict, anItem)) {
 748                         CF_syslog(LOG_DEBUG, CFSTR("Skipping %@ because of duplicate service."),
 749                                   CFDictionaryGetValue(anItem, kDescriptionKey));
 750                         continue;
 751                 }
 752                 /*
 753                  * Dependencies don't matter when restarting an item;
 754                  * stop here.
 755                  */
 756                 if (anAction == kActionRestart) {
 757                         aNextItem = anItem;
 758                         break;
 759                 }
 760                 anAntecedentList = CFDictionaryGetValue(anItem, ((anAction == kActionStart) ? kRequiresKey : kProvidesKey));
 761
 762                 CF_syslog(LOG_DEBUG, CFSTR("Checking %@"), CFDictionaryGetValue(anItem, kDescriptionKey));
 763
 764                 if (anAntecedentList)
 765                         CF_syslog(LOG_DEBUG, CFSTR("Antecedents: %@"), anAntecedentList);
 766                 else
 767                         syslog(LOG_DEBUG, "No antecedents");
 768
 769                         /**
 770                          * Filter out the items which have unsatisfied antecedents.
 771                          **/
 772                 if (anAntecedentList &&
 773                     ((anAction == kActionStart) ?
 774                      countUnmetRequirements(aStatusDict, anAntecedentList) :
 775                      countDependantsPresent(aWaitingList, anAntecedentList, kRequiresKey)))
 776                         continue;
 777
 778                         /**
 779                          * anItem has all hard dependancies met; check for soft dependancies.
 780                          * We'll favor the item with the fewest unmet soft dependancies here.
 781                          **/
 782                 anAntecedentList = CFDictionaryGetValue(anItem, ((anAction == kActionStart) ? kUsesKey : kProvidesKey));
 783
 784                 if (anAntecedentList)
 785                         CF_syslog(LOG_DEBUG, CFSTR("Soft dependancies: %@"), anAntecedentList);
 786                 else
 787                         syslog(LOG_DEBUG, "No soft dependancies");
 788
 789                 if (anAntecedentList) {
 790                         aFailedAntecedentsCount =
 791                             ((anAction == kActionStart) ?
 792                              countUnmetRequirements(aStatusDict, anAntecedentList) :
 793                              countDependantsPresent(aWaitingList, anAntecedentList, kUsesKey));
 794                 } else {
 795                         if (aMinFailedAntecedents > 0)
 796                                 aBestPick = TRUE;
 797                 }
 798
 799                 /*
 800                  * anItem has unmet dependencies that will
 801                  * likely be met in the future, so delay it
 802                  */
 803                 if (aFailedAntecedentsCount > 0 && pendingAntecedents(aWaitingList, aStatusDict, anAntecedentList, anAction)) {
 804                         continue;
 805                 }
 806                 if (aFailedAntecedentsCount > 0)
 807                         syslog(LOG_DEBUG, "Total: %d", aFailedAntecedentsCount);
 808
 809                 if (aFailedAntecedentsCount > aMinFailedAntecedents)
 810                         continue;       /* Another item already won out */
 811
 812                 if (aFailedAntecedentsCount < aMinFailedAntecedents)
 813                         aBestPick = TRUE;
 814
 815                 if (!aBestPick)
 816                         continue;
 817
 818                 /*
 819                  * anItem has less unmet
 820                  * dependancies than any
 821                  * other item so far, so it
 822                  * wins.
 823                  */
 824                 syslog(LOG_DEBUG, "Best pick so far, based on failed dependancies (%d->%d)",
 825                        aMinFailedAntecedents, aFailedAntecedentsCount);
 826
 827                 /*
 828                  * We have a winner!  Update success
 829                  * parameters to match anItem.
 830                  */
 831                 aMinFailedAntecedents = aFailedAntecedentsCount;
 832                 aNextItem = anItem;
 833
 834         }                       /* End of waiting list loop. */
 835
 836         return aNextItem;
 837 }
 838
 839 CFStringRef StartupItemCreateDescription(CFMutableDictionaryRef anItem)
 840 {
 841         CFStringRef aString = NULL;
 842
 843         if (anItem)
 844                 aString = CFDictionaryGetValue(anItem, kDescriptionKey);
 845         if (aString)
 846                 CFRetain(aString);
 847         return aString;
 848 }
 849
 850 pid_t StartupItemGetPID(CFDictionaryRef anItem)
 851 {
 852         CFIndex anItemPID = 0;
 853         CFNumberRef aPIDNumber = anItem ? CFDictionaryGetValue(anItem, kPIDKey) : NULL;
 854         if (aPIDNumber && CFNumberGetValue(aPIDNumber, kCFNumberCFIndexType, &anItemPID))
 855                 return (pid_t) anItemPID;
 856         else
 857                 return 0;
 858 }
 859
 860 CFMutableDictionaryRef StartupItemWithPID(CFArrayRef anItemList, pid_t aPID)
 861 {
 862         CFIndex anItemCount = CFArrayGetCount(anItemList);
 863         CFIndex anItemIndex;
 864
 865         for (anItemIndex = 0; anItemIndex < anItemCount; anItemIndex++) {
 866                 CFMutableDictionaryRef anItem = (CFMutableDictionaryRef) CFArrayGetValueAtIndex(anItemList, anItemIndex);
 867                 CFNumberRef aPIDNumber = CFDictionaryGetValue(anItem, kPIDKey);
 868                 CFIndex anItemPID;
 869
 870                 if (aPIDNumber) {
 871                         CFNumberGetValue(aPIDNumber, kCFNumberCFIndexType, &anItemPID);
 872
 873                         if ((pid_t) anItemPID == aPID)
 874                                 return anItem;
 875                 }
 876         }
 877
 878         return NULL;
 879 }
 880
 881 int StartupItemRun(CFMutableDictionaryRef aStatusDict, CFMutableDictionaryRef anItem, Action anAction)
 882 {
 883         int             anError = -1;
 884         CFArrayRef      aProvidesList = CFDictionaryGetValue(anItem, kProvidesKey);
 885         static const CFStringRef stubitems[] = {
 886                 CFSTR("BootROMUpdater"),                /* 3893064 */
 887                 CFSTR("FCUUpdater"),                    /* 3893064 */
 888                 CFSTR("AutoProtect Daemon"),            /* 3965785 */
 889                 CFSTR("Check For Missed Tasks"),        /* 3965785 */
 890                 CFSTR("Privacy"),                       /* 3933484 */
 891                 CFSTR("Firmware Update Checking"),      /* 4001504 */
 892
 893                 CFSTR("M-Audio FireWire Audio Support"),                /* 3931757 */
 894                 CFSTR("help for M-Audio Delta Family"),                 /* 3931757 */
 895                 CFSTR("help for M-Audio Devices"),                      /* 3931757 */
 896                 CFSTR("help for M-Audio Revo 5.1"),                     /* 3931757 */
 897                 CFSTR("M-Audio USB Duo Configuration Service"),         /* 3931757 */
 898                 CFSTR("firmware loader for M-Audio devices"),           /* 3931757 */
 899                 CFSTR("M-Audio MobilePre USB Configuration Service"),   /* 3931757 */
 900                 CFSTR("M-Audio OmniStudio USB Configuration Service"),  /* 3931757 */
 901                 CFSTR("M-Audio Transit USB Configuration Service"),     /* 3931757 */
 902                 CFSTR("M-Audio Audiophile USB Configuration Service"),  /* 3931757 */
 903                 NULL
 904         };
 905         const CFStringRef *c;
 906
 907         if (aProvidesList && anAction == kActionStop) {
 908                 CFIndex aProvidesCount = CFArrayGetCount(aProvidesList);
 909                 for (c = stubitems; *c; c++) {
 910                         if (CFArrayContainsValue(aProvidesList, CFRangeMake(0, aProvidesCount), *c)) {
 911                                 CFIndex         aPID = -1;
 912                                 CFNumberRef     aProcessNumber = CFNumberCreate(NULL, kCFNumberCFIndexType, &aPID);
 913
 914                                 CFDictionarySetValue(anItem, kPIDKey, aProcessNumber);
 915                                 CFRelease(aProcessNumber);
 916
 917                                 StartupItemExit(aStatusDict, anItem, TRUE);
 918                                 return -1;
 919                         }
 920                 }
 921         }
 922
 923         if (anAction == kActionNone) {
 924                 StartupItemExit(aStatusDict, anItem, TRUE);
 925                 anError = 0;
 926         } else {
 927                 CFStringRef aBundlePathString = CFDictionaryGetValue(anItem, kBundlePathKey);
 928                 char aBundlePath[PATH_MAX];
 929                 char anExecutable[PATH_MAX];
 930                 char *tmp;
 931
 932                 if (!CFStringGetCString(aBundlePathString, aBundlePath, sizeof(aBundlePath), kCFStringEncodingUTF8)) {
 933                         CF_syslog(LOG_EMERG, CFSTR("Internal error while running item %@"), aBundlePathString);
 934                         return (anError);
 935                 }
 936                 /* Compute path to excecutable */
 937                 tmp = rindex(aBundlePath, '/');
 938                 snprintf(anExecutable, sizeof(anExecutable), "%s%s", aBundlePath, tmp);
 939
 940                 /**
 941                  * Run the bundle
 942                  **/
 943
 944                 if (access(anExecutable, X_OK)) {
 945                         /*
 946                          * Add PID key so that this item is marked as having
 947                          * been run.
 948                          */
 949                         CFIndex aPID = -1;
 950                         CFNumberRef aProcessNumber = CFNumberCreate(NULL, kCFNumberCFIndexType, &aPID);
 951
 952                         CFDictionarySetValue(anItem, kPIDKey, aProcessNumber);
 953                         CFRelease(aProcessNumber);
 954
 955                         CFDictionarySetValue(anItem, kErrorKey, kErrorPermissions);
 956                         StartupItemExit(aStatusDict, anItem, FALSE);
 957                         syslog(LOG_ERR, "No executable file %s", anExecutable);
 958                 } else {
 959                         pid_t aProccessID = fork();
 960
 961                         switch (aProccessID) {
 962                         case -1:        /* SystemStarter (fork failed) */
 963                                 CFDictionarySetValue(anItem, kErrorKey, kErrorFork);
 964                                 StartupItemExit(aStatusDict, anItem, FALSE);
 965
 966                                 CF_syslog(LOG_ERR, CFSTR("Failed to fork for item %@: %s"), aBundlePathString, strerror(errno));
 967
 968                                 break;
 969
 970                         default:        /* SystemStarter (fork succeeded) */
 971                                 {
 972                                         CFIndex aPID = (CFIndex) aProccessID;
 973                                         CFNumberRef aProcessNumber = CFNumberCreate(NULL, kCFNumberCFIndexType, &aPID);
 974
 975                                         CFDictionarySetValue(anItem, kPIDKey, aProcessNumber);
 976                                         CFRelease(aProcessNumber);
 977
 978                                         syslog(LOG_DEBUG, "Running command (%d): %s %s",
 979                                                aProccessID, anExecutable, argumentForAction(anAction));
 980                                         anError = 0;
 981                                 }
 982                                 break;
 983
 984                         case 0: /* Child */
 985                                 {
 986                                         if (setsid() == -1)
 987                                                 syslog(LOG_WARNING, "Unable to create session for item %s: %m", anExecutable);
 988
 989                                         anError = execl(anExecutable, anExecutable, argumentForAction(anAction), NULL);
 990
 991                                         /* We shouldn't get here. */
 992
 993                                         syslog(LOG_ERR, "execl(\"%s\"): %m", anExecutable);
 994
 995                                         exit(anError);
 996                                 }
 997                         }
 998                 }
 999         }
1000
1001         return (anError);
1002 }
1003
1004 void
1005 StartupItemSetStatus(CFMutableDictionaryRef aStatusDict, CFMutableDictionaryRef anItem, CFStringRef aServiceName,
1006                      Boolean aSuccess, Boolean aReplaceFlag)
1007 {
1008         void (*anAction) (CFMutableDictionaryRef, const void *, const void *) = aReplaceFlag ?
1009             CFDictionarySetValue : CFDictionaryAddValue;
1010
1011         if (aStatusDict && anItem) {
1012                 CFArrayRef aProvidesList = CFDictionaryGetValue(anItem, kProvidesKey);
1013                 if (aProvidesList) {
1014                         CFIndex aProvidesCount = CFArrayGetCount(aProvidesList);
1015                         CFIndex aProvidesIndex;
1016
1017                         /*
1018                          * If a service name was specified, and it is valid,
1019                          * use only it.
1020                          */
1021                         if (aServiceName && CFArrayContainsValue(aProvidesList, CFRangeMake(0, aProvidesCount), aServiceName)) {
1022                                 aProvidesList = CFArrayCreate(NULL, (const void **)&aServiceName, 1, &kCFTypeArrayCallBacks);
1023                                 aProvidesCount = 1;
1024                         } else {
1025                                 CFRetain(aProvidesList);
1026                         }
1027
1028                         for (aProvidesIndex = 0; aProvidesIndex < aProvidesCount; aProvidesIndex++) {
1029                                 CFStringRef aService = CFArrayGetValueAtIndex(aProvidesList, aProvidesIndex);
1030
1031                                 if (aSuccess)
1032                                         anAction(aStatusDict, aService, kRunSuccess);
1033                                 else
1034                                         anAction(aStatusDict, aService, kRunFailure);
1035                         }
1036
1037                         CFRelease(aProvidesList);
1038                 }
1039         }
1040 }
1041
1042 void StartupItemExit(CFMutableDictionaryRef aStatusDict, CFMutableDictionaryRef anItem, Boolean aSuccess)
1043 {
1044         StartupItemSetStatus(aStatusDict, anItem, NULL, aSuccess, FALSE);
1045 }