configd.tproj/_configset.c

   1 /*
   2  * Copyright (c) 2000-2004, 2006, 2008, 2011, 2012, 2014-2017, 2019 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  * June 1, 2001                 Allan Nathanson <ajn@apple.com>
  28  * - public API conversion
  29  *
  30  * March 24, 2000               Allan Nathanson <ajn@apple.com>
  31  * - initial revision
  32  */
  33
  34
  35 #include "configd.h"
  36 #include "session.h"
  37 #include "pattern.h"
  38
  39
  40 __private_extern__
  41 int
  42 __SCDynamicStoreSetValue(SCDynamicStoreRef store, CFStringRef key, CFDataRef value, Boolean internal)
  43 {
  44         CFDictionaryRef                 dict;
  45         serverSessionRef                mySession;
  46         CFMutableDictionaryRef          newDict;
  47         Boolean                         newEntry        = FALSE;
  48         int                             sc_status       = kSCStatusOK;
  49         CFStringRef                     sessionKey;
  50         SCDynamicStorePrivateRef        storePrivate    = (SCDynamicStorePrivateRef)store;
  51         CFStringRef                     storeSessionKey;
  52
  53         SC_trace("%s%s : %5d : %@",
  54                  internal ? "*set " : "set  ",
  55                  storePrivate->useSessionKeys ? "t " : "  ",
  56                  storePrivate->server,
  57                  key);
  58
  59         /*
  60          * Grab the current (or establish a new) dictionary for this key.
  61          */
  62
  63         dict = CFDictionaryGetValue(storeData, key);
  64         if (dict) {
  65                 newDict = CFDictionaryCreateMutableCopy(NULL,
  66                                                         0,
  67                                                         dict);
  68         } else {
  69                 newDict = CFDictionaryCreateMutable(NULL,
  70                                                     0,
  71                                                     &kCFTypeDictionaryKeyCallBacks,
  72                                                     &kCFTypeDictionaryValueCallBacks);
  73         }
  74
  75         /*
  76          * Update the dictionary entry to be saved to the store.
  77          */
  78         newEntry = !CFDictionaryContainsKey(newDict, kSCDData);
  79         CFDictionarySetValue(newDict, kSCDData, value);
  80
  81         /*
  82          * Manage per-session keys.
  83          */
  84         sessionKey = CFStringCreateWithFormat(NULL, NULL, CFSTR("%d"), storePrivate->server);
  85         if (storePrivate->useSessionKeys) {
  86                 if (newEntry) {
  87                         /*
  88                          * Add this key to my list of per-session keys
  89                          */
  90                         mySession = getSession(storePrivate->server);
  91                         if ((mySession->sessionKeys == NULL) ||
  92                             !CFArrayContainsValue(mySession->sessionKeys,
  93                                                   CFRangeMake(0, CFArrayGetCount(mySession->sessionKeys)),
  94                                                   key)) {
  95                                 /*
  96                                  * if no session keys defined "or" keys defined but not
  97                                  * this one...
  98                                  */
  99                                 if (mySession->sessionKeys == NULL) {
 100                                         /* this is an additional session key */
 101                                         mySession->sessionKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 102                                 }
 103                                 CFArrayAppendValue(mySession->sessionKeys, key);
 104                         }
 105
 106                         /*
 107                          * Mark the key as a "session" key and track the creator.
 108                          */
 109                         CFDictionarySetValue(newDict, kSCDSession, sessionKey);
 110                 } else {
 111                         /*
 112                          * Since we are using per-session keys and this key already
 113                          * exists, check if it was created by "our" session
 114                          */
 115                         dict = CFDictionaryGetValue(storeData, key);
 116                         if (!CFDictionaryGetValueIfPresent(dict, kSCDSession, (void *)&storeSessionKey) ||
 117                             !CFEqual(sessionKey, storeSessionKey)) {
 118                                 /*
 119                                  * if the key exists and is not a session key or
 120                                  * if the key exists it's not "our" session.
 121                                  */
 122                                 sc_status = kSCStatusKeyExists;
 123                                 CFRelease(sessionKey);
 124                                 CFRelease(newDict);
 125                                 goto done;
 126                         }
 127                 }
 128         } else {
 129                 /*
 130                 * Since we are updating this key we need to check and, if
 131                 * necessary, remove the indication that this key is on
 132                 * another session's remove-on-close list.
 133                 */
 134                 if (!newEntry &&
 135                     CFDictionaryGetValueIfPresent(newDict, kSCDSession, (void *)&storeSessionKey) &&
 136                     !CFEqual(sessionKey, storeSessionKey)) {
 137                         CFStringRef     removedKey;
 138
 139                         /* We are no longer a session key! */
 140                         CFDictionaryRemoveValue(newDict, kSCDSession);
 141
 142                         /* add this session key to the (session) removal list */
 143                         removedKey = CFStringCreateWithFormat(NULL, 0, CFSTR("%@:%@"), storeSessionKey, key);
 144                         CFSetAddValue(removedSessionKeys, removedKey);
 145                         CFRelease(removedKey);
 146                 }
 147         }
 148         CFRelease(sessionKey);
 149
 150         /*
 151          * Update the dictionary entry in the store.
 152          */
 153
 154         CFDictionarySetValue(storeData, key, newDict);
 155         CFRelease(newDict);
 156
 157         /*
 158          * For "new" entries to the store, check the deferred cleanup
 159          * list. If the key is flagged for removal, remove it from the
 160          * list since any defined regex's for this key are still defined
 161          * and valid. If the key is not flagged then iterate over the
 162          * sessionData dictionary looking for regex keys which match the
 163          * updated key. If a match is found then we mark those keys as
 164          * being watched.
 165          */
 166
 167         if (newEntry) {
 168                 if (CFSetContainsValue(deferredRemovals, key)) {
 169                         CFSetRemoveValue(deferredRemovals, key);
 170                 } else {
 171                         patternAddKey(key);
 172                 }
 173         }
 174
 175         /*
 176          * Mark this key as "changed". Any "watchers" will be notified
 177          * as soon as the lock is released.
 178          */
 179         CFSetAddValue(changedKeys, key);
 180
 181     done :
 182
 183         if (!internal) {
 184                 /* push changes */
 185                 __SCDynamicStorePush();
 186         }
 187
 188         return sc_status;
 189 }
 190
 191 __private_extern__
 192 kern_return_t
 193 _configset(mach_port_t                  server,
 194            xmlData_t                    keyRef,         /* raw XML bytes */
 195            mach_msg_type_number_t       keyLen,
 196            xmlData_t                    dataRef,        /* raw XML bytes */
 197            mach_msg_type_number_t       dataLen,
 198            int                          oldInstance,
 199            int                          *newInstance,
 200            int                          *sc_status,
 201            audit_token_t                audit_token)
 202 {
 203 #pragma unused(oldInstance)
 204         CFDataRef               data            = NULL; /* data (un-serialized) */
 205         CFStringRef             key             = NULL; /* key  (un-serialized) */
 206         serverSessionRef        mySession;
 207
 208         *newInstance = 0;
 209         *sc_status = kSCStatusOK;
 210
 211         /* un-serialize the key */
 212         if (!_SCUnserializeString(&key, NULL, (void *)keyRef, keyLen)) {
 213                 *sc_status = kSCStatusFailed;
 214         }
 215
 216         /* un-serialize the data */
 217         if (!_SCUnserializeData(&data, (void *)dataRef, dataLen)) {
 218                 *sc_status = kSCStatusFailed;
 219         }
 220
 221         if (*sc_status != kSCStatusOK) {
 222                 goto done;
 223         }
 224
 225         if (!isA_CFString(key)) {
 226                 *sc_status = kSCStatusInvalidArgument;
 227                 goto done;
 228         }
 229
 230         mySession = getSession(server);
 231         if (mySession == NULL) {
 232                 mySession = tempSession(server, CFSTR("SCDynamicStoreSetValue"), audit_token);
 233                 if (mySession == NULL) {
 234                         /* you must have an open session to play */
 235                         *sc_status = kSCStatusNoStoreSession;
 236                         goto done;
 237                 }
 238         }
 239
 240         if (!hasWriteAccess(mySession, "set", key)) {
 241                 *sc_status = kSCStatusAccessError;
 242                 goto done;
 243         }
 244
 245         *sc_status = __SCDynamicStoreSetValue(mySession->store, key, data, FALSE);
 246
 247     done :
 248
 249         if (key)        CFRelease(key);
 250         if (data)       CFRelease(data);
 251         return KERN_SUCCESS;
 252 }
 253
 254 static void
 255 setSpecificKey(const void *key, const void *value, void *context)
 256 {
 257         CFStringRef             k       = (CFStringRef)key;
 258         CFDataRef               v       = (CFDataRef)value;
 259         SCDynamicStoreRef       store   = (SCDynamicStoreRef)context;
 260
 261         if (!isA_CFString(k)) {
 262                 return;
 263         }
 264
 265         if (!isA_CFData(v)) {
 266                 return;
 267         }
 268
 269         (void) __SCDynamicStoreSetValue(store, k, v, TRUE);
 270
 271         return;
 272 }
 273
 274 static void
 275 removeSpecificKey(const void *value, void *context)
 276 {
 277         CFStringRef             k       = (CFStringRef)value;
 278         SCDynamicStoreRef       store   = (SCDynamicStoreRef)context;
 279
 280         if (!isA_CFString(k)) {
 281                 return;
 282         }
 283
 284         (void) __SCDynamicStoreRemoveValue(store, k, TRUE);
 285
 286         return;
 287 }
 288
 289 static void
 290 notifySpecificKey(const void *value, void *context)
 291 {
 292         CFStringRef             k       = (CFStringRef)value;
 293         SCDynamicStoreRef       store   = (SCDynamicStoreRef)context;
 294
 295         if (!isA_CFString(k)) {
 296                 return;
 297         }
 298
 299         (void) __SCDynamicStoreNotifyValue(store, k, TRUE);
 300
 301         return;
 302 }
 303
 304 __private_extern__
 305 int
 306 __SCDynamicStoreSetMultiple(SCDynamicStoreRef store, CFDictionaryRef keysToSet, CFArrayRef keysToRemove, CFArrayRef keysToNotify)
 307 {
 308         int                             sc_status       = kSCStatusOK;
 309         SCDynamicStorePrivateRef        storePrivate    = (SCDynamicStorePrivateRef)store;
 310
 311         SC_trace("set m   : %5d : %ld set, %ld remove, %ld notify",
 312                  storePrivate->server,
 313                  keysToSet    ? CFDictionaryGetCount(keysToSet)    : 0,
 314                  keysToRemove ? CFArrayGetCount     (keysToRemove) : 0,
 315                  keysToNotify ? CFArrayGetCount     (keysToNotify) : 0);
 316
 317         /*
 318          * Set the new/updated keys
 319          */
 320         if (keysToSet) {
 321                 CFDictionaryApplyFunction(keysToSet,
 322                                           setSpecificKey,
 323                                           (void *)store);
 324         }
 325
 326         /*
 327          * Remove the specified keys
 328          */
 329         if (keysToRemove) {
 330                 CFArrayApplyFunction(keysToRemove,
 331                                      CFRangeMake(0, CFArrayGetCount(keysToRemove)),
 332                                      removeSpecificKey,
 333                                      (void *)store);
 334         }
 335
 336         /*
 337          * Notify the specified keys
 338          */
 339         if (keysToNotify) {
 340                 CFArrayApplyFunction(keysToNotify,
 341                                      CFRangeMake(0, CFArrayGetCount(keysToNotify)),
 342                                      notifySpecificKey,
 343                                      (void *)store);
 344         }
 345
 346         /* push changes */
 347         __SCDynamicStorePush();
 348
 349         return sc_status;
 350 }
 351
 352 #define N_QUICK 32
 353
 354 __private_extern__
 355 kern_return_t
 356 _configset_m(mach_port_t                server,
 357              xmlData_t                  dictRef,
 358              mach_msg_type_number_t     dictLen,
 359              xmlData_t                  removeRef,
 360              mach_msg_type_number_t     removeLen,
 361              xmlData_t                  notifyRef,
 362              mach_msg_type_number_t     notifyLen,
 363              int                        *sc_status,
 364              audit_token_t              audit_token)
 365 {
 366         CFDictionaryRef         dict            = NULL;         /* key/value dictionary (un-serialized) */
 367         serverSessionRef        mySession;
 368         CFArrayRef              notify          = NULL;         /* keys to notify (un-serialized) */
 369         CFArrayRef              remove          = NULL;         /* keys to remove (un-serialized) */
 370
 371         *sc_status = kSCStatusOK;
 372
 373         if ((dictRef != NULL) && (dictLen > 0)) {
 374                 /* un-serialize the key/value pairs to set */
 375                 if (!_SCUnserialize((CFPropertyListRef *)&dict, NULL, (void *)dictRef, dictLen)) {
 376                         *sc_status = kSCStatusFailed;
 377                 }
 378         }
 379
 380         if ((removeRef != NULL) && (removeLen > 0)) {
 381                 /* un-serialize the keys to remove */
 382                 if (!_SCUnserialize((CFPropertyListRef *)&remove, NULL, (void *)removeRef, removeLen)) {
 383                         *sc_status = kSCStatusFailed;
 384                 }
 385         }
 386
 387         if ((notifyRef != NULL) && (notifyLen > 0)) {
 388                 /* un-serialize the keys to notify */
 389                 if (!_SCUnserialize((CFPropertyListRef *)&notify, NULL, (void *)notifyRef, notifyLen)) {
 390                         *sc_status = kSCStatusFailed;
 391                 }
 392         }
 393
 394         if (*sc_status != kSCStatusOK) {
 395                 goto done;
 396         }
 397
 398         if ((dict != NULL) && !isA_CFDictionary(dict)) {
 399                 *sc_status = kSCStatusInvalidArgument;
 400                 goto done;
 401         }
 402
 403         if ((remove != NULL) && !isA_CFArray(remove)) {
 404                 *sc_status = kSCStatusInvalidArgument;
 405                 goto done;
 406         }
 407
 408         if ((notify != NULL) && !isA_CFArray(notify)) {
 409                 *sc_status = kSCStatusInvalidArgument;
 410                 goto done;
 411         }
 412
 413         mySession = getSession(server);
 414         if (mySession == NULL) {
 415                 mySession = tempSession(server, CFSTR("SCDynamicStoreSetMultiple"), audit_token);
 416                 if (mySession == NULL) {
 417                         /* you must have an open session to play */
 418                         *sc_status = kSCStatusNoStoreSession;
 419                         goto done;
 420                 }
 421         }
 422
 423         if (dict != NULL) {
 424                 const void *    keys_q[N_QUICK];
 425                 const void **   keys    = keys_q;
 426                 CFIndex         i;
 427                 CFIndex         n;
 428                 Boolean         writeOK = TRUE;
 429
 430                 n = CFDictionaryGetCount(dict);
 431                 if (n > (CFIndex)(sizeof(keys_q) / sizeof(CFStringRef))) {
 432                         keys   = CFAllocatorAllocate(NULL, n * sizeof(CFStringRef), 0);
 433                 }
 434                 CFDictionaryGetKeysAndValues(dict, keys, NULL);
 435                 for (i = 0; i < n; i++) {
 436                         CFStringRef     key;
 437
 438                         key = (CFStringRef)keys[i];
 439                         if (!hasWriteAccess(mySession, "set (multiple)", key)) {
 440                                 writeOK = FALSE;
 441                                 break;
 442                         }
 443                 }
 444                 if (keys != keys_q) {
 445                         CFAllocatorDeallocate(NULL, keys);
 446                 }
 447
 448                 if (!writeOK) {
 449                         *sc_status = kSCStatusAccessError;
 450                         goto done;
 451                 }
 452         }
 453
 454         if (remove != NULL) {
 455                 CFIndex i;
 456                 CFIndex n       = CFArrayGetCount(remove);
 457
 458                 for (i = 0; i < n; i++) {
 459                         CFStringRef     key;
 460
 461                         key = CFArrayGetValueAtIndex(remove, i);
 462                         if (!hasWriteAccess(mySession, "set/remove (multiple)", key)) {
 463                                 *sc_status = kSCStatusAccessError;
 464                                 goto done;
 465                         }
 466                 }
 467         }
 468
 469         if (notify != NULL) {
 470                 CFIndex i;
 471                 CFIndex n       = CFArrayGetCount(notify);
 472
 473                 for (i = 0; i < n; i++) {
 474                         CFStringRef     key;
 475
 476                         key = CFArrayGetValueAtIndex(notify, i);
 477                         if (!hasWriteAccess(mySession, "set/notify (multiple)", key)) {
 478                                 *sc_status = kSCStatusAccessError;
 479                                 goto done;
 480                         }
 481                 }
 482         }
 483
 484         *sc_status = __SCDynamicStoreSetMultiple(mySession->store, dict, remove, notify);
 485
 486     done :
 487
 488         if (dict != NULL)       CFRelease(dict);
 489         if (remove != NULL)     CFRelease(remove);
 490         if (notify != NULL)     CFRelease(notify);
 491
 492         return KERN_SUCCESS;
 493 }