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