Plugins/PreferencesMonitor/prefsmon.c

   1 /*
   2  * Copyright (c) 2000-2008, 2010, 2012-2016 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*
  25  * Modification History
  26  *
  27  * April 2, 2004                Allan Nathanson <ajn@apple.com>
  28  * - use SCPreference notification APIs
  29  *
  30  * June 24, 2001                Allan Nathanson <ajn@apple.com>
  31  * - update to public SystemConfiguration.framework APIs
  32  *
  33  * November 10, 2000            Allan Nathanson <ajn@apple.com>
  34  * - initial revision
  35  */
  36
  37
  38 #include <TargetConditionals.h>
  39 #include <fcntl.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #include <unistd.h>
  43
  44
  45 #define SC_LOG_HANDLE   __log_PreferencesMonitor()
  46 #include <SystemConfiguration/SystemConfiguration.h>
  47 #include <SystemConfiguration/SCPrivate.h>
  48 #include <SystemConfiguration/SCValidation.h>
  49
  50
  51
  52 /* globals */
  53 static SCPreferencesRef         prefs           = NULL;
  54 static SCDynamicStoreRef        store           = NULL;
  55
  56 /* preferences "initialization" globals */
  57 static CFStringRef              initKey         = NULL;
  58 static CFRunLoopSourceRef       initRls         = NULL;
  59
  60 /* SCDynamicStore (Setup:) */
  61 static CFMutableDictionaryRef   currentPrefs;           /* current prefs */
  62 static CFMutableDictionaryRef   newPrefs;               /* new prefs */
  63 static CFMutableArrayRef        unchangedPrefsKeys;     /* new prefs keys which match current */
  64 static CFMutableArrayRef        removedPrefsKeys;       /* old prefs keys to be removed */
  65
  66 static Boolean                  rofs            = FALSE;
  67 static Boolean                  restorePrefs    = FALSE;
  68
  69 #define MY_PLUGIN_NAME          "PreferencesMonitor"
  70 #define MY_PLUGIN_ID            CFSTR("com.apple.SystemConfiguration." MY_PLUGIN_NAME)
  71
  72
  73 static os_log_t
  74 __log_PreferencesMonitor()
  75 {
  76         static os_log_t log     = NULL;
  77
  78         if (log == NULL) {
  79                 log = os_log_create("com.apple.SystemConfiguration", "PreferencesMonitor");
  80         }
  81
  82         return log;
  83 }
  84
  85
  86 static Boolean
  87 restorePreferences()
  88 {
  89         Boolean                 ok = FALSE;
  90         CFStringRef             currentModel = NULL;
  91         CFMutableStringRef      modelPrefixStr = NULL;
  92         CFArrayRef              keyList = NULL;
  93         CFIndex                 keyListCount;
  94         CFIndex                 idx;
  95         Boolean                 modified = FALSE;
  96         int                     sc_status = kSCStatusFailed;
  97
  98         while (TRUE) {
  99                 ok = SCPreferencesLock(prefs, TRUE);
 100                 if (ok) {
 101                         break;
 102                 }
 103
 104                 sc_status = SCError();
 105                 if (sc_status == kSCStatusStale) {
 106                         SCPreferencesSynchronize(prefs);
 107                 } else {
 108                         SC_log(LOG_NOTICE, "Could not acquire network configuration lock: %s",
 109                                SCErrorString(sc_status));
 110                         return FALSE;
 111                 }
 112         }
 113
 114         keyList = SCPreferencesCopyKeyList(prefs);
 115         if (keyList == NULL) {
 116                 goto error;
 117         }
 118
 119         currentModel = _SC_hw_model(FALSE);
 120         if (currentModel == NULL) {
 121                 goto error;
 122         }
 123
 124         /* Create "model:" string for prefix-check */
 125         modelPrefixStr = CFStringCreateMutableCopy(NULL, 0, currentModel);
 126         CFStringAppend(modelPrefixStr, CFSTR(":"));
 127
 128         keyListCount = CFArrayGetCount(keyList);
 129         for (idx = 0; idx < keyListCount; idx++) {
 130                 CFStringRef existingKey = CFArrayGetValueAtIndex(keyList, idx);
 131                 CFStringRef key;
 132                 CFArrayRef splitKey = NULL;
 133                 CFPropertyListRef value;
 134
 135                 if (isA_CFString(existingKey) == NULL) {
 136                         continue;
 137                 }
 138
 139                 if (!CFStringHasPrefix(existingKey, modelPrefixStr)) {
 140                             continue;
 141                 }
 142
 143                 splitKey = CFStringCreateArrayBySeparatingStrings(NULL, existingKey, CFSTR(":"));
 144                 key = CFArrayGetValueAtIndex(splitKey, 1);
 145                 value = SCPreferencesGetValue(prefs, existingKey);
 146                 SCPreferencesSetValue(prefs, key, value);
 147                 SCPreferencesRemoveValue(prefs, existingKey);
 148                 modified = TRUE;
 149                 CFRelease(splitKey);
 150         }
 151
 152         if (modified) {
 153                 SCPreferencesRef        ni_prefs = NULL;
 154                 ni_prefs = SCPreferencesCreate(NULL, MY_PLUGIN_ID, CFSTR("NetworkInterfaces.plist"));
 155                 if (ni_prefs == NULL) {
 156                         goto error;
 157                 }
 158
 159                 ok = _SCNetworkConfigurationCheckValidityWithPreferences(prefs, ni_prefs, NULL);
 160                 CFRelease(ni_prefs);
 161
 162                 //Commit the changes only if prefs files valid
 163                 if (ok) {
 164                         if (!SCPreferencesCommitChanges(prefs)) {
 165                                 if (SCError() != EROFS) {
 166                                         SC_log(LOG_NOTICE, "SCPreferencesCommitChanges() failed: %s",
 167                                                SCErrorString(SCError()));
 168                                 }
 169                                 goto error;
 170
 171                         }
 172
 173                         (void) SCPreferencesApplyChanges(prefs);
 174                 }
 175         }
 176
 177 error:
 178         (void) SCPreferencesUnlock(prefs);
 179
 180         if (keyList != NULL) {
 181                 CFRelease(keyList);
 182         }
 183         if (modelPrefixStr != NULL) {
 184                 CFRelease(modelPrefixStr);
 185         }
 186
 187         return modified;
 188 }
 189
 190 static Boolean
 191 establishNewPreferences()
 192 {
 193         SCNetworkSetRef current         = NULL;
 194         CFStringRef     new_model;
 195         Boolean         ok              = FALSE;
 196         int             sc_status       = kSCStatusFailed;
 197         SCNetworkSetRef set             = NULL;
 198         Boolean         updated         = FALSE;
 199
 200         while (TRUE) {
 201                 ok = SCPreferencesLock(prefs, TRUE);
 202                 if (ok) {
 203                         break;
 204                 }
 205
 206                 sc_status = SCError();
 207                 if (sc_status == kSCStatusStale) {
 208                         SCPreferencesSynchronize(prefs);
 209                 } else {
 210                         SC_log(LOG_NOTICE, "Could not acquire network configuration lock: %s",
 211                                SCErrorString(sc_status));
 212                         return FALSE;
 213                 }
 214         }
 215
 216         /* Ensure that the preferences has the new model */
 217         new_model = _SC_hw_model(FALSE);
 218
 219         /* Need to regenerate the new configuration for new model */
 220         if (new_model != NULL) {
 221                 CFStringRef     old_model;
 222
 223                 old_model = SCPreferencesGetValue(prefs, MODEL);
 224                 if ((old_model != NULL) && !_SC_CFEqual(old_model, new_model)) {
 225                         CFIndex         count;
 226                         CFIndex         index;
 227                         CFArrayRef      keys;
 228
 229                         keys = SCPreferencesCopyKeyList(prefs);
 230                         count = (keys != NULL) ? CFArrayGetCount(keys) : 0;
 231                         // if new hardware
 232                         for (index = 0; index < count; index++) {
 233                                 CFStringRef             existing_key;
 234
 235                                 existing_key = CFArrayGetValueAtIndex(keys, index);
 236                                 if (isA_CFString(existing_key) != NULL) {
 237                                         CFStringRef             new_key;
 238                                         CFPropertyListRef       value;
 239
 240                                         /* If it already contains a Model
 241                                            or if it already contains a MODEL:KEY key skip it*/
 242                                         if (CFEqual(existing_key, MODEL)
 243                                             || CFStringFind(existing_key, CFSTR(":"), 0).location
 244                                             != kCFNotFound) {
 245                                                 continue;
 246                                         }
 247
 248                                         value = SCPreferencesGetValue(prefs, existing_key);
 249
 250                                         /* Create a new key as OLD_MODEL:OLD_KEY */
 251                                         new_key = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@:%@"),
 252                                                                            old_model, existing_key);
 253                                         SCPreferencesSetValue(prefs, new_key, value);
 254                                         if (!CFEqual(existing_key, kSCPrefSystem)) {
 255                                                 /* preserve existing host names */
 256                                                 SCPreferencesRemoveValue(prefs, existing_key);
 257                                         }
 258                                         CFRelease(new_key);
 259                                 }
 260                         }
 261
 262                         if (keys != NULL) {
 263                                 CFRelease(keys);
 264                         }
 265                 }
 266                 /* Set the new model */
 267                 SCPreferencesSetValue(prefs, MODEL, new_model);
 268         }
 269
 270         current = SCNetworkSetCopyCurrent(prefs);
 271         if (current != NULL) {
 272                 set = current;
 273         }
 274
 275         if (set == NULL) {
 276                 set = _SCNetworkSetCreateDefault(prefs);
 277                 if (set == NULL) {
 278                         ok = FALSE;
 279                         sc_status = SCError();
 280                         goto done;
 281                 }
 282         }
 283
 284         ok = SCNetworkSetEstablishDefaultConfiguration(set);
 285         if (!ok) {
 286                 sc_status = SCError();
 287                 goto done;
 288         }
 289
 290     done :
 291
 292         if (ok) {
 293                 ok = SCPreferencesCommitChanges(prefs);
 294                 if (ok) {
 295                         SC_log(LOG_NOTICE, "New network configuration saved");
 296                         updated = TRUE;
 297                 } else {
 298                         sc_status = SCError();
 299                         if (sc_status == EROFS) {
 300                                 /* a read-only fileysstem is OK */
 301                                 ok = TRUE;
 302
 303                                 /* ... but we don't want to synchronize */
 304                                 rofs = TRUE;
 305                         }
 306                 }
 307
 308                 /* apply (committed or temporary/read-only) changes */
 309                 (void) SCPreferencesApplyChanges(prefs);
 310         } else if ((current == NULL) && (set != NULL)) {
 311                 (void) SCNetworkSetRemove(set);
 312         }
 313
 314         if (!ok) {
 315                 SC_log(LOG_NOTICE, "Could not establish network configuration: %s",
 316                        SCErrorString(sc_status));
 317         }
 318
 319         (void)SCPreferencesUnlock(prefs);
 320         if (set != NULL) CFRelease(set);
 321         return updated;
 322 }
 323
 324
 325 static Boolean
 326 quiet(Boolean *timeout)
 327 {
 328         CFDictionaryRef dict;
 329         Boolean         _quiet          = FALSE;
 330         Boolean         _timeout        = FALSE;
 331
 332         // keep the static analyzer happy
 333         assert(initKey != NULL);
 334
 335         // check if quiet
 336         dict = SCDynamicStoreCopyValue(store, initKey);
 337         if (dict != NULL) {
 338                 if (isA_CFDictionary(dict)) {
 339                         if (CFDictionaryContainsKey(dict, CFSTR("*QUIET*"))) {
 340                                 _quiet = TRUE;
 341                         }
 342                         if (CFDictionaryContainsKey(dict, CFSTR("*TIMEOUT*"))) {
 343                                 _timeout = TRUE;
 344                         }
 345                 }
 346                 CFRelease(dict);
 347         }
 348
 349         if (timeout != NULL) {
 350                 *timeout = _timeout;
 351         }
 352         return _quiet;
 353 }
 354
 355
 356 static void
 357 watchQuietDisable()
 358 {
 359         if ((initKey == NULL) || (initRls == NULL)) {
 360                 return;
 361         }
 362
 363         (void) SCDynamicStoreSetNotificationKeys(store, NULL, NULL);
 364
 365         CFRunLoopSourceInvalidate(initRls);
 366         CFRelease(initRls);
 367         initRls = NULL;
 368
 369         CFRelease(initKey);
 370         initKey = NULL;
 371
 372         return;
 373 }
 374
 375
 376 static void
 377 watchQuietEnable()
 378 {
 379         CFArrayRef      keys;
 380         Boolean         ok;
 381
 382         initKey = SCDynamicStoreKeyCreate(NULL,
 383                                           CFSTR("%@" "InterfaceNamer"),
 384                                           kSCDynamicStoreDomainPlugin);
 385
 386         initRls = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
 387         CFRunLoopAddSource(CFRunLoopGetCurrent(), initRls, kCFRunLoopDefaultMode);
 388
 389         keys = CFArrayCreate(NULL, (const void **)&initKey, 1, &kCFTypeArrayCallBacks);
 390         ok = SCDynamicStoreSetNotificationKeys(store, keys, NULL);
 391         CFRelease(keys);
 392         if (!ok) {
 393                 SC_log(LOG_NOTICE, "SCDynamicStoreSetNotificationKeys() failed: %s", SCErrorString(SCError()));
 394                 watchQuietDisable();
 395         }
 396
 397         return;
 398 }
 399
 400
 401
 402 static Boolean
 403 previousConfigurationAvailable()
 404 {
 405         CFStringRef             backupKey = NULL;
 406         CFStringRef             currentModel = NULL;
 407         CFPropertyListRef       properties = NULL;
 408
 409         currentModel = _SC_hw_model(FALSE);
 410         if (currentModel == NULL) {
 411                 goto done;
 412         }
 413
 414         /* Currently relying only if a backup of "Sets" is present */
 415         backupKey = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@:Sets"), currentModel);
 416         properties = SCPreferencesGetValue(prefs, backupKey);
 417         CFRelease(backupKey);
 418 done:
 419         return (properties != NULL);
 420 }
 421
 422 static void
 423 watchQuietCallback(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
 424 {
 425         Boolean _quiet;
 426         Boolean _timeout        = FALSE;
 427
 428         _quiet = quiet(&_timeout);
 429         if (_quiet
 430 #if     !TARGET_OS_IPHONE
 431             || _timeout
 432 #endif  /* !TARGET_OS_IPHONE */
 433            ) {
 434                 watchQuietDisable();
 435         }
 436
 437         if (_quiet || _timeout) {
 438                 static int      logged  = 0;
 439
 440                 (void) establishNewPreferences();
 441
 442                 if (restorePrefs) {
 443                         (void) restorePreferences();
 444                         restorePrefs = FALSE;
 445                 }
 446
 447                 if (_timeout && (logged++ == 0)) {
 448                         SC_log(LOG_ERR, "Network configuration creation timed out waiting for IORegistry");
 449                 }
 450         }
 451
 452         return;
 453 }
 454
 455
 456 static void
 457 updateCache(const void *key, const void *value, void *context)
 458 {
 459         CFStringRef             configKey       = (CFStringRef)key;
 460         CFPropertyListRef       configData      = (CFPropertyListRef)value;
 461         CFPropertyListRef       cacheData;
 462         CFIndex                 i;
 463
 464         cacheData = CFDictionaryGetValue(currentPrefs, configKey);
 465         if (cacheData) {
 466                 /* key exists */
 467                 if (CFEqual(cacheData, configData)) {
 468                         /*
 469                          * if the old & new property list values have
 470                          * not changed then we don't need to update
 471                          * the preference.
 472                          */
 473                         CFArrayAppendValue(unchangedPrefsKeys, configKey);
 474                 }
 475         }
 476
 477         /* in any case, this key should not be removed */
 478         i = CFArrayGetFirstIndexOfValue(removedPrefsKeys,
 479                                         CFRangeMake(0, CFArrayGetCount(removedPrefsKeys)),
 480                                         configKey);
 481         if (i != kCFNotFound) {
 482                 CFArrayRemoveValueAtIndex(removedPrefsKeys, i);
 483         }
 484
 485         return;
 486 }
 487
 488
 489 static void
 490 flatten(SCPreferencesRef        prefs,
 491         CFStringRef             key,
 492         CFDictionaryRef         base)
 493 {
 494         CFDictionaryRef         subset;
 495         CFStringRef             link;
 496         CFMutableDictionaryRef  myDict;
 497         CFStringRef             myKey;
 498         CFIndex                 i;
 499         CFIndex                 nKeys;
 500         const void              **keys;
 501         const void              **vals;
 502
 503         if (!CFDictionaryGetValueIfPresent(base, kSCResvLink, (const void **)&link)) {
 504                 /* if this dictionary is not linked */
 505                 subset = base;
 506         } else {
 507                 /* if __LINK__ key is present */
 508                 subset = SCPreferencesPathGetValue(prefs, link);
 509                 if (!subset) {
 510                         /* if error with link */
 511                         SC_log(LOG_NOTICE, "SCPreferencesPathGetValue(,%@,) failed: %s",
 512                                link,
 513                                SCErrorString(SCError()));
 514                         return;
 515                 }
 516         }
 517
 518         if (CFDictionaryContainsKey(subset, kSCResvInactive)) {
 519                 /* if __INACTIVE__ key is present */
 520                 return;
 521         }
 522
 523         myKey = CFStringCreateWithFormat(NULL,
 524                                          NULL,
 525                                          CFSTR("%@%@"),
 526                                          kSCDynamicStoreDomainSetup,
 527                                          key);
 528
 529         myDict = (CFMutableDictionaryRef)CFDictionaryGetValue(newPrefs, myKey);
 530         if (myDict) {
 531                 myDict = CFDictionaryCreateMutableCopy(NULL,
 532                                                        0,
 533                                                        (CFDictionaryRef)myDict);
 534         } else {
 535                 myDict = CFDictionaryCreateMutable(NULL,
 536                                                    0,
 537                                                    &kCFTypeDictionaryKeyCallBacks,
 538                                                    &kCFTypeDictionaryValueCallBacks);
 539         }
 540
 541         nKeys = CFDictionaryGetCount(subset);
 542         if (nKeys > 0) {
 543                 keys  = CFAllocatorAllocate(NULL, nKeys * sizeof(CFStringRef)      , 0);
 544                 vals  = CFAllocatorAllocate(NULL, nKeys * sizeof(CFPropertyListRef), 0);
 545                 CFDictionaryGetKeysAndValues(subset, keys, vals);
 546                 for (i = 0; i < nKeys; i++) {
 547                         if (CFGetTypeID((CFTypeRef)vals[i]) != CFDictionaryGetTypeID()) {
 548                                 /* add this key/value to the current dictionary */
 549                                 CFDictionarySetValue(myDict, keys[i], vals[i]);
 550                         } else {
 551                                 CFStringRef     subKey;
 552
 553                                 /* flatten [sub]dictionaries */
 554                                 subKey = CFStringCreateWithFormat(NULL,
 555                                                                   NULL,
 556                                                                   CFSTR("%@%s%@"),
 557                                                                   key,
 558                                                                   CFEqual(key, CFSTR("/")) ? "" : "/",
 559                                                                   keys[i]);
 560                                 flatten(prefs, subKey, vals[i]);
 561                                 CFRelease(subKey);
 562                         }
 563                 }
 564                 CFAllocatorDeallocate(NULL, keys);
 565                 CFAllocatorDeallocate(NULL, vals);
 566         }
 567
 568         if (CFDictionaryGetCount(myDict) > 0) {
 569                 /* add this dictionary to the new preferences */
 570                 CFDictionarySetValue(newPrefs, myKey, myDict);
 571         }
 572
 573         CFRelease(myDict);
 574         CFRelease(myKey);
 575
 576         return;
 577 }
 578
 579
 580 static void
 581 updateSCDynamicStore(SCPreferencesRef prefs)
 582 {
 583         CFStringRef             current         = NULL;
 584         CFDateRef               date            = NULL;
 585         CFMutableDictionaryRef  dict            = NULL;
 586         CFDictionaryRef         global          = NULL;
 587         CFIndex                 i;
 588         CFArrayRef              keys;
 589         CFIndex                 n;
 590         CFStringRef             pattern;
 591         CFMutableArrayRef       patterns;
 592         CFDictionaryRef         set             = NULL;
 593
 594         /*
 595          * initialize old preferences, new preferences, an array
 596          * of keys which have not changed, and an array of keys
 597          * to be removed (cleaned up).
 598          */
 599
 600         patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 601         pattern  = CFStringCreateWithFormat(NULL,
 602                                             NULL,
 603                                             CFSTR("^%@.*"),
 604                                             kSCDynamicStoreDomainSetup);
 605         CFArrayAppendValue(patterns, pattern);
 606         dict = (CFMutableDictionaryRef)SCDynamicStoreCopyMultiple(store, NULL, patterns);
 607         CFRelease(patterns);
 608         CFRelease(pattern);
 609         if (dict) {
 610                 currentPrefs = CFDictionaryCreateMutableCopy(NULL, 0, dict);
 611                 CFRelease(dict);
 612         } else {
 613                 currentPrefs = CFDictionaryCreateMutable(NULL,
 614                                                          0,
 615                                                          &kCFTypeDictionaryKeyCallBacks,
 616                                                          &kCFTypeDictionaryValueCallBacks);
 617         }
 618
 619         unchangedPrefsKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 620
 621         i = CFDictionaryGetCount(currentPrefs);
 622         if (i > 0) {
 623                 const void      **currentKeys;
 624                 CFArrayRef      array;
 625
 626                 currentKeys = CFAllocatorAllocate(NULL, i * sizeof(CFStringRef), 0);
 627                 CFDictionaryGetKeysAndValues(currentPrefs, currentKeys, NULL);
 628                 array = CFArrayCreate(NULL, currentKeys, i, &kCFTypeArrayCallBacks);
 629                 removedPrefsKeys = CFArrayCreateMutableCopy(NULL, 0, array);
 630                 CFRelease(array);
 631                 CFAllocatorDeallocate(NULL, currentKeys);
 632         } else {
 633                 removedPrefsKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 634         }
 635
 636         /*
 637          * The "newPrefs" dictionary will contain the new / updated
 638          * configuration which will be written to the configuration cache.
 639          */
 640         newPrefs = CFDictionaryCreateMutable(NULL,
 641                                                  0,
 642                                                  &kCFTypeDictionaryKeyCallBacks,
 643                                                  &kCFTypeDictionaryValueCallBacks);
 644
 645         /*
 646          * create status dictionary associated with current configuration
 647          * information including:
 648          *   - current set "name" to cache
 649          *   - time stamp indicating when the cache preferences were
 650          *     last updated.
 651          */
 652         dict = CFDictionaryCreateMutable(NULL,
 653                                          0,
 654                                          &kCFTypeDictionaryKeyCallBacks,
 655                                          &kCFTypeDictionaryValueCallBacks);
 656         date = CFDateCreate(NULL, CFAbsoluteTimeGetCurrent());
 657
 658         /*
 659          * load preferences
 660          */
 661         keys = SCPreferencesCopyKeyList(prefs);
 662         if ((keys == NULL) || (CFArrayGetCount(keys) == 0)) {
 663                 SC_log(LOG_NOTICE, "updateConfiguration(): no preferences");
 664                 goto done;
 665         }
 666
 667         /*
 668          * get "global" system preferences
 669          */
 670         global = SCPreferencesGetValue(prefs, kSCPrefSystem);
 671         if (!global) {
 672                 /* if no global preferences are defined */
 673                 goto getSet;
 674         }
 675
 676         if (!isA_CFDictionary(global)) {
 677                 SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a dictionary",
 678                        kSCPrefSystem);
 679                 goto done;
 680         }
 681
 682         /* flatten property list */
 683         flatten(prefs, CFSTR("/"), global);
 684
 685     getSet :
 686
 687         /*
 688          * get current set name
 689          */
 690         current = SCPreferencesGetValue(prefs, kSCPrefCurrentSet);
 691         if (!current) {
 692                 /* if current set not defined */
 693                 goto done;
 694         }
 695
 696         if (!isA_CFString(current)) {
 697                 SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a string",
 698                        kSCPrefCurrentSet);
 699                 goto done;
 700         }
 701
 702         /*
 703          * get current set
 704          */
 705         set = SCPreferencesPathGetValue(prefs, current);
 706         if (!set) {
 707                 /* if error with path */
 708                 SC_log(LOG_NOTICE, "%@ value (%@) not valid",
 709                        kSCPrefCurrentSet,
 710                        current);
 711                 goto done;
 712         }
 713
 714         if (!isA_CFDictionary(set)) {
 715                 SC_log(LOG_NOTICE, "updateConfiguration(): %@ is not a dictionary",
 716                        current);
 717                 goto done;
 718         }
 719
 720         /* flatten property list */
 721         flatten(prefs, CFSTR("/"), set);
 722
 723         CFDictionarySetValue(dict, kSCDynamicStorePropSetupCurrentSet, current);
 724
 725     done :
 726
 727         /* add last updated time stamp */
 728         CFDictionarySetValue(dict, kSCDynamicStorePropSetupLastUpdated, date);
 729
 730         /* add Setup: key */
 731         CFDictionarySetValue(newPrefs, kSCDynamicStoreDomainSetup, dict);
 732
 733         /* compare current and new preferences */
 734         CFDictionaryApplyFunction(newPrefs, updateCache, NULL);
 735
 736         /* remove those keys which have not changed from the update */
 737         n = CFArrayGetCount(unchangedPrefsKeys);
 738         for (i = 0; i < n; i++) {
 739                 CFStringRef     key;
 740
 741                 key = CFArrayGetValueAtIndex(unchangedPrefsKeys, i);
 742                 CFDictionaryRemoveValue(newPrefs, key);
 743         }
 744
 745         /* Update the dynamic store */
 746 #ifndef MAIN
 747         if (!SCDynamicStoreSetMultiple(store, newPrefs, removedPrefsKeys, NULL)) {
 748                 SC_log(LOG_NOTICE, "SCDynamicStoreSetMultiple() failed: %s", SCErrorString(SCError()));
 749         }
 750 #else   // !MAIN
 751         SC_log(LOG_DEBUG, "SCDynamicStore\nset: %@\nremove: %@",
 752                newPrefs,
 753                removedPrefsKeys);
 754 #endif  // !MAIN
 755
 756         CFRelease(currentPrefs);
 757         CFRelease(newPrefs);
 758         CFRelease(unchangedPrefsKeys);
 759         CFRelease(removedPrefsKeys);
 760         if (dict)       CFRelease(dict);
 761         if (date)       CFRelease(date);
 762         if (keys)       CFRelease(keys);
 763         return;
 764 }
 765
 766
 767 static void
 768 updateConfiguration(SCPreferencesRef            prefs,
 769                     SCPreferencesNotification   notificationType,
 770                     void                        *info)
 771 {
 772         os_activity_t   activity;
 773
 774         activity = os_activity_create("processing [SC] preferences.plist changes",
 775                                       OS_ACTIVITY_CURRENT,
 776                                       OS_ACTIVITY_FLAG_DEFAULT);
 777         os_activity_scope(activity);
 778
 779 #if     !TARGET_OS_IPHONE
 780         if ((notificationType & kSCPreferencesNotificationCommit) == kSCPreferencesNotificationCommit) {
 781                 SCNetworkSetRef current;
 782
 783                 current = SCNetworkSetCopyCurrent(prefs);
 784                 if (current != NULL) {
 785                         /* network configuration available, disable template creation */
 786                         watchQuietDisable();
 787                         CFRelease(current);
 788                 }
 789         }
 790 #endif  /* !TARGET_OS_IPHONE */
 791
 792         if ((notificationType & kSCPreferencesNotificationApply) != kSCPreferencesNotificationApply) {
 793                 goto done;
 794         }
 795
 796         SC_log(LOG_INFO, "updating configuration");
 797
 798         /* update SCDynamicStore (Setup:) */
 799         updateSCDynamicStore(prefs);
 800
 801         /* finished with current prefs, wait for changes */
 802         if (!rofs) {
 803                 SCPreferencesSynchronize(prefs);
 804         }
 805
 806     done :
 807
 808         os_release(activity);
 809
 810         return;
 811 }
 812
 813
 814 __private_extern__
 815 void
 816 prime_PreferencesMonitor()
 817 {
 818         SC_log(LOG_DEBUG, "prime() called");
 819
 820         /* load the initial configuration from the database */
 821         updateConfiguration(prefs, kSCPreferencesNotificationApply, (void *)store);
 822
 823         return;
 824 }
 825
 826
 827 __private_extern__
 828 void
 829 load_PreferencesMonitor(CFBundleRef bundle, Boolean bundleVerbose)
 830 {
 831         Boolean initPrefs       = TRUE;
 832
 833         SC_log(LOG_DEBUG, "load() called");
 834         SC_log(LOG_DEBUG, "  bundle ID = %@", CFBundleGetIdentifier(bundle));
 835
 836         /* open a SCDynamicStore session to allow cache updates */
 837         store = SCDynamicStoreCreate(NULL,
 838                                      CFSTR("PreferencesMonitor.bundle"),
 839                                      watchQuietCallback,
 840                                      NULL);
 841         if (store == NULL) {
 842                 SC_log(LOG_NOTICE, "SCDynamicStoreCreate() failed: %s", SCErrorString(SCError()));
 843                 goto error;
 844         }
 845
 846         /* open a SCPreferences session */
 847 #ifndef MAIN
 848         prefs = SCPreferencesCreate(NULL, CFSTR("PreferencesMonitor.bundle"), NULL);
 849 #else   // !MAIN
 850         prefs = SCPreferencesCreate(NULL, CFSTR("PreferencesMonitor.bundle"), CFSTR("/tmp/preferences.plist"));
 851 #endif  // !MAIN
 852         if (prefs != NULL) {
 853                 Boolean         need_update = FALSE;
 854                 CFStringRef     new_model;
 855
 856                 new_model = _SC_hw_model(FALSE);
 857
 858                 /* Need to regenerate the new configuration for new model */
 859                 if (new_model != NULL) {
 860                         CFStringRef     old_model;
 861
 862                         old_model = SCPreferencesGetValue(prefs, MODEL);
 863                         if (old_model != NULL && !_SC_CFEqual(old_model, new_model)) {
 864                                 // if new hardware
 865                                 need_update = TRUE;
 866                                 restorePrefs = previousConfigurationAvailable();
 867                         }
 868                 }
 869
 870                 if (!need_update) {
 871                         SCNetworkSetRef current;
 872
 873                         current = SCNetworkSetCopyCurrent(prefs);
 874                         if (current != NULL) {
 875                                 /* network configuration available, disable template creation */
 876                                 initPrefs = FALSE;
 877                                 CFRelease(current);
 878                         }
 879                 }
 880         } else {
 881                 SC_log(LOG_NOTICE, "SCPreferencesCreate() failed: %s", SCErrorString(SCError()));
 882                 goto error;
 883         }
 884
 885         /*
 886          * register for change notifications.
 887          */
 888         if (!SCPreferencesSetCallback(prefs, updateConfiguration, NULL)) {
 889                 SC_log(LOG_NOTICE, "SCPreferencesSetCallBack() failed: %s", SCErrorString(SCError()));
 890                 goto error;
 891         }
 892
 893         if (!SCPreferencesScheduleWithRunLoop(prefs, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode)) {
 894                 SC_log(LOG_NOTICE, "SCPreferencesScheduleWithRunLoop() failed: %s", SCErrorString(SCError()));
 895                 goto error;
 896         }
 897
 898         /*
 899          * if no preferences, initialize with a template (now or
 900          * when IOKit has quiesced).
 901          */
 902         if (initPrefs) {
 903                 watchQuietEnable();
 904                 watchQuietCallback(store, NULL, NULL);
 905         }
 906
 907         return;
 908
 909     error :
 910
 911         watchQuietDisable();
 912         if (store != NULL)      CFRelease(store);
 913         if (prefs != NULL)      CFRelease(prefs);
 914
 915         return;
 916 }
 917
 918
 919 #ifdef  MAIN
 920 int
 921 main(int argc, char **argv)
 922 {
 923         _sc_log     = FALSE;
 924         _sc_verbose = (argc > 1) ? TRUE : FALSE;
 925
 926         load_PreferencesMonitor(CFBundleGetMainBundle(), (argc > 1) ? TRUE : FALSE);
 927         prime_PreferencesMonitor();
 928         CFRunLoopRun();
 929         /* not reached */
 930         exit(0);
 931         return 0;
 932 }
 933 #endif