SystemConfiguration.fproj/v1Compatibility.c

   1 /*
   2  * Copyright (c) 2001 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22
  23 /*
  24  * Modification History
  25  *
  26  * March 28, 2001               Allan Nathanson <ajn@apple.com>
  27  * - initial revision
  28  */
  29
  30 #include <SystemConfiguration/SystemConfiguration.h>
  31 #include <SystemConfiguration/SCPrivate.h>
  32 #include "SCDynamicStoreInternal.h"
  33
  34 #include "v1Compatibility.h"
  35
  36 extern void __Initialize();
  37
  38 typedef struct {
  39
  40         /* configuration data associated with key */
  41         CFPropertyListRef       data;
  42
  43         /* instance value of last fetched data */
  44         int                     instance;
  45
  46 } SCDHandlePrivate, *SCDHandlePrivateRef;
  47
  48
  49 SCDHandleRef
  50 SCDHandleInit()
  51 {
  52         SCDHandlePrivateRef privateHandle = CFAllocatorAllocate(NULL, sizeof(SCDHandlePrivate), 0);
  53
  54         /* set data */
  55         privateHandle->data = NULL;
  56
  57         /* set instance */
  58         privateHandle->instance = 0;
  59
  60         return (SCDHandleRef)privateHandle;
  61 }
  62
  63
  64 void
  65 SCDHandleRelease(SCDHandleRef handle)
  66 {
  67         SCDHandlePrivateRef privateHandle = (SCDHandlePrivateRef)handle;
  68
  69         if (privateHandle->data)
  70                 CFRelease(privateHandle->data);
  71
  72         CFAllocatorDeallocate(NULL, privateHandle);
  73         return;
  74 }
  75
  76
  77 int
  78 SCDHandleGetInstance(SCDHandleRef handle)
  79 {
  80         SCDHandlePrivateRef privateHandle = (SCDHandlePrivateRef)handle;
  81
  82         return privateHandle->instance;
  83 }
  84
  85
  86 void
  87 _SCDHandleSetInstance(SCDHandleRef handle, int instance)
  88 {
  89         SCDHandlePrivateRef privateHandle = (SCDHandlePrivateRef)handle;
  90
  91         privateHandle->instance = instance;
  92         return;
  93 }
  94
  95
  96 CFPropertyListRef
  97 SCDHandleGetData(SCDHandleRef handle)
  98 {
  99         SCDHandlePrivateRef privateHandle = (SCDHandlePrivateRef)handle;
 100
 101         if (privateHandle->data == NULL) {
 102                 return CFSTR("SCDHandleRef not initialized.");
 103         }
 104
 105         return privateHandle->data;
 106 }
 107
 108
 109 void
 110 SCDHandleSetData(SCDHandleRef handle, CFPropertyListRef data)
 111 {
 112         SCDHandlePrivateRef privateHandle = (SCDHandlePrivateRef)handle;
 113
 114         /* remove reference to data previously associated with handle */
 115         if (privateHandle->data)
 116                 CFRelease(privateHandle->data);
 117
 118         /* associate new data with handle, keep a reference as needed */
 119         privateHandle->data = data;
 120         if (privateHandle->data)
 121                 CFRetain(privateHandle->data);
 122
 123         return;
 124 }
 125
 126 static int
 127 convert_SCDStatus_To_SCStatus(SCDStatus status)
 128 {
 129         switch (status) {
 130                 case SCD_OK                     : return kSCStatusOK;
 131                 case SCD_NOSESSION              : return kSCStatusNoStoreSession;
 132                 case SCD_NOSERVER               : return kSCStatusNoStoreServer;
 133                 case SCD_LOCKED                 : return kSCStatusLocked;
 134                 case SCD_NEEDLOCK               : return kSCStatusNeedLock;
 135                 case SCD_EACCESS                : return kSCStatusAccessError;
 136                 case SCD_NOKEY                  : return kSCStatusNoKey;
 137                 case SCD_EXISTS                 : return kSCStatusKeyExists;
 138                 case SCD_STALE                  : return kSCStatusStale;
 139                 case SCD_INVALIDARGUMENT        : return kSCStatusInvalidArgument;
 140                 case SCD_NOTIFIERACTIVE         : return kSCStatusNotifierActive;
 141                 case SCD_FAILED                 : return kSCStatusFailed;
 142                 default                         : return kSCStatusFailed;
 143         }
 144 }
 145
 146 SCDStatus
 147 SCDOpen(SCDSessionRef *session, CFStringRef name)
 148 {
 149         SCDynamicStoreRef       newStore;
 150
 151         __Initialize();         /* initialize framework */
 152
 153         newStore = SCDynamicStoreCreate(NULL, name, NULL, NULL);
 154         if (!newStore) {
 155                 return SCD_NOSERVER;
 156         }
 157
 158         *session = (SCDSessionRef)newStore;
 159         return SCD_OK;
 160 }
 161
 162 SCDStatus
 163 SCDClose(SCDSessionRef *session)
 164 {
 165         CFRelease(*session);
 166         *session = NULL;
 167         return SCD_OK;
 168 }
 169
 170 SCDStatus
 171 SCDLock(SCDSessionRef session)
 172 {
 173         return SCDynamicStoreLock((SCDynamicStoreRef)session) ? SCD_OK : SCD_FAILED;
 174 }
 175
 176 SCDStatus
 177 SCDUnlock(SCDSessionRef session)
 178 {
 179         return SCDynamicStoreUnlock((SCDynamicStoreRef)session) ? SCD_OK : SCD_FAILED;
 180 }
 181
 182 SCDStatus
 183 SCDList(SCDSessionRef session, CFStringRef key, int regexOptions, CFArrayRef *subKeys)
 184 {
 185         CFMutableStringRef      pattern;
 186
 187         pattern = CFStringCreateMutableCopy(NULL, 0, key);
 188         if ((regexOptions & kSCDRegexKey) != kSCDRegexKey) {
 189                 CFStringAppend(pattern, CFSTR(".*"));
 190         }
 191         *subKeys = SCDynamicStoreCopyKeyList((SCDynamicStoreRef)session, pattern);
 192         CFRelease(pattern);
 193
 194         return (*subKeys) ? SCD_OK : SCD_FAILED;
 195 }
 196
 197 SCDStatus
 198 SCDAdd(SCDSessionRef session, CFStringRef key, SCDHandleRef handle)
 199 {
 200         CFTypeRef       value = SCDHandleGetData(handle);
 201         return SCDynamicStoreAddValue((SCDynamicStoreRef)session, key, value) ? SCD_OK : SCD_EXISTS;
 202 }
 203
 204 SCDStatus
 205 SCDAddSession(SCDSessionRef session, CFStringRef key, SCDHandleRef handle)
 206 {
 207         CFTypeRef       value = SCDHandleGetData(handle);
 208         return SCDynamicStoreAddTemporaryValue((SCDynamicStoreRef)session, key, value) ? SCD_OK : SCD_EXISTS;
 209 }
 210
 211 SCDStatus
 212 SCDGet(SCDSessionRef session, CFStringRef key, SCDHandleRef *handle)
 213 {
 214         CFTypeRef       value;
 215
 216         value = SCDynamicStoreCopyValue((SCDynamicStoreRef)session, key);
 217         if (value) {
 218                 *handle = SCDHandleInit();
 219                 SCDHandleSetData(*handle, value);
 220                 CFRelease(value);
 221                 return SCD_OK;
 222         }
 223         return SCD_NOKEY;
 224 }
 225
 226 SCDStatus
 227 SCDSet(SCDSessionRef session, CFStringRef key, SCDHandleRef handle)
 228 {
 229         CFTypeRef       value = SCDHandleGetData(handle);
 230         return SCDynamicStoreSetValue((SCDynamicStoreRef)session, key, value) ? SCD_OK : SCD_EXISTS;
 231 }
 232
 233 SCDStatus
 234 SCDRemove(SCDSessionRef session, CFStringRef key)
 235 {
 236         return SCDynamicStoreRemoveValue((SCDynamicStoreRef)session, key) ? SCD_OK : SCD_NOKEY;
 237 }
 238
 239 SCDStatus
 240 SCDTouch(SCDSessionRef session, CFStringRef key)
 241 {
 242         return SCDynamicStoreTouchValue((SCDynamicStoreRef)session, key) ? SCD_OK : SCD_FAILED;
 243 }
 244
 245 SCDStatus
 246 SCDNotifierList(SCDSessionRef session, int regexOptions, CFArrayRef *notifierKeys)
 247 {
 248         *notifierKeys = SCDynamicStoreCopyWatchedKeyList((SCDynamicStoreRef)session,
 249                                                          ((regexOptions & kSCDRegexKey) == kSCDRegexKey));
 250         return (*notifierKeys) ? SCD_OK : SCD_FAILED;
 251 }
 252
 253 SCDStatus
 254 SCDNotifierAdd(SCDSessionRef session, CFStringRef key, int regexOptions)
 255 {
 256         return SCDynamicStoreAddWatchedKey((SCDynamicStoreRef)session,
 257                                            key,
 258                                            ((regexOptions & kSCDRegexKey) == kSCDRegexKey)) ? SCD_OK : SCD_EXISTS;
 259 }
 260
 261 SCDStatus
 262 SCDNotifierRemove(SCDSessionRef session, CFStringRef key, int regexOptions)
 263 {
 264         return SCDynamicStoreRemoveWatchedKey((SCDynamicStoreRef)session,
 265                                               key,
 266                                               ((regexOptions & kSCDRegexKey) == kSCDRegexKey)) ? SCD_OK : SCD_NOKEY;
 267 }
 268
 269 SCDStatus
 270 SCDNotifierGetChanges(SCDSessionRef session, CFArrayRef *changedKeys)
 271 {
 272         *changedKeys = SCDynamicStoreCopyNotifiedKeys((SCDynamicStoreRef)session);
 273         return (*changedKeys) ? SCD_OK : SCD_FAILED;
 274 }
 275
 276 SCDStatus
 277 SCDNotifierWait(SCDSessionRef session)
 278 {
 279         return SCDynamicStoreNotifyWait((SCDynamicStoreRef)session) ? SCD_OK : SCD_FAILED;
 280 }
 281
 282 SCDStatus
 283 SCDNotifierInformViaCallback(SCDSessionRef session, SCDCallbackRoutine_t func, void *arg)
 284 {
 285         return SCDynamicStoreNotifyCallback((SCDynamicStoreRef)session,
 286                                             CFRunLoopGetCurrent(),
 287                                             (SCDynamicStoreCallBack_v1)func,
 288                                             arg) ? SCD_OK : SCD_NOTIFIERACTIVE;
 289 }
 290
 291 SCDStatus
 292 SCDNotifierInformViaMachPort(SCDSessionRef session, mach_msg_id_t msgid, mach_port_t *port)
 293 {
 294         return SCDynamicStoreNotifyMachPort((SCDynamicStoreRef)session, msgid, port) ? SCD_OK : SCD_NOTIFIERACTIVE;
 295 }
 296
 297 SCDStatus
 298 SCDNotifierInformViaFD(SCDSessionRef session, int32_t identifier, int *fd)
 299 {
 300         return SCDynamicStoreNotifyFileDescriptor((SCDynamicStoreRef)session, identifier, fd) ? SCD_OK : SCD_NOTIFIERACTIVE;
 301 }
 302
 303 SCDStatus
 304 SCDNotifierInformViaSignal(SCDSessionRef session, pid_t pid, int sig)
 305 {
 306         return SCDynamicStoreNotifySignal((SCDynamicStoreRef)session, pid, sig) ? SCD_OK : SCD_NOTIFIERACTIVE;
 307 }
 308
 309 SCDStatus
 310 SCDNotifierCancel(SCDSessionRef session)
 311 {
 312         return SCDynamicStoreNotifyCancel((SCDynamicStoreRef)session) ? SCD_OK : SCD_NOTIFIERACTIVE;
 313 }
 314
 315 SCDStatus
 316 SCDSnapshot(SCDSessionRef session)
 317 {
 318         return SCDynamicStoreSnapshot((SCDynamicStoreRef)session) ? SCD_OK : SCD_NOTIFIERACTIVE;
 319 }
 320
 321 int
 322 SCDOptionGet(SCDSessionRef session, int option)
 323 {
 324         int             value     = 0;
 325
 326         if (session) {
 327                 static  Boolean warned = FALSE;
 328                 if (!warned) {
 329                         SCLog(TRUE, LOG_NOTICE, CFSTR("per-session options are no longer supported, using global options."));
 330                         warned = TRUE;
 331                 }
 332         }
 333
 334         switch (option) {
 335                 case kSCDOptionDebug :
 336                         value = _sc_debug ? 1 : 0;
 337                         break;
 338
 339                 case kSCDOptionVerbose :
 340                         value = _sc_verbose ? 1 : 0;
 341                         break;
 342
 343                 case kSCDOptionUseSyslog :
 344                         value = _sc_log ? 1 : 0;
 345                         break;
 346
 347                 case kSCDOptionUseCFRunLoop :
 348                         value = 1;      /* always TRUE */
 349                         break;
 350         }
 351
 352         return value;
 353 }
 354
 355 void
 356 SCDOptionSet(SCDSessionRef session, int option, int value)
 357 {
 358         if (session) {
 359                 static Boolean  warned = FALSE;
 360                 if (!warned) {
 361                         SCLog(TRUE, LOG_NOTICE, CFSTR("per-session options are no longer supported, using global options."));
 362                         warned = TRUE;
 363                 }
 364         }
 365
 366         switch (option) {
 367                 case kSCDOptionDebug :
 368                         _sc_debug = (value != 0);
 369                         _sc_log   = (value == 0);
 370                         break;
 371
 372                 case kSCDOptionVerbose :
 373                         _sc_verbose = (value != 0);
 374                         break;
 375
 376                 case kSCDOptionUseSyslog :
 377                 {
 378                         _sc_log = (value != 0);
 379                         break;
 380                 }
 381
 382                 case kSCDOptionUseCFRunLoop :
 383                 {
 384                         static Boolean warned = FALSE;
 385                         if ((value == FALSE) && !warned) {
 386                                 SCLog(TRUE, LOG_NOTICE, CFSTR("The kSCDOptionUseCFRunLoop option can no longer be set FALSE.  The"));
 387                                 SCLog(TRUE, LOG_NOTICE, CFSTR("SCDNotifierInformViaCallback requires the use of a CFRunLoop."));
 388                                 warned = TRUE;
 389                         }
 390                         break;
 391                 }
 392         }
 393
 394         return;
 395 }
 396
 397 void
 398 SCDSessionLog(SCDSessionRef session, int level, CFStringRef formatString, ...)
 399 {
 400         va_list         argList;
 401         FILE            *f = (LOG_PRI(level) > LOG_NOTICE) ? stderr : stdout;
 402         CFStringRef     resultString;
 403
 404         if ((LOG_PRI(level) == LOG_DEBUG) && !SCDOptionGet(session, kSCDOptionVerbose)) {
 405                 /* it's a debug message and we haven't requested verbose logging */
 406                 return;
 407         }
 408
 409         va_start(argList, formatString);
 410         resultString = CFStringCreateWithFormatAndArguments(NULL, NULL, formatString, argList);
 411         va_end(argList);
 412
 413         if (SCDOptionGet(session, kSCDOptionUseSyslog)) {
 414                 __SCLog(level, resultString);
 415         } else {
 416                 CFStringRef     newString;
 417
 418                 /* add a new-line */
 419                 newString = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@\n"), resultString);
 420                 __SCPrint(f, newString);
 421                 CFRelease(newString);
 422         }
 423         CFRelease(resultString);
 424 }
 425
 426 void
 427 SCDLog(int level, CFStringRef formatString, ...)
 428 {
 429         va_list         argList;
 430         FILE            *f = (LOG_PRI(level) > LOG_NOTICE) ? stderr : stdout;
 431         CFStringRef     resultString;
 432
 433         if ((LOG_PRI(level) == LOG_DEBUG) && !SCDOptionGet(NULL, kSCDOptionVerbose)) {
 434                 /* it's a debug message and we haven't requested verbose logging */
 435                 return;
 436         }
 437
 438         va_start(argList, formatString);
 439         resultString = CFStringCreateWithFormatAndArguments(NULL, NULL, formatString, argList);
 440         va_end(argList);
 441
 442         if (SCDOptionGet(NULL, kSCDOptionUseSyslog)) {
 443                 __SCLog(level, resultString);
 444         } else {
 445                 CFStringRef     newString;
 446
 447                 /* add a new-line */
 448                 newString = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@\n"), resultString);
 449                 __SCPrint(f, newString);
 450                 CFRelease(newString);
 451         }
 452         CFRelease(resultString);
 453 }
 454
 455 const char *
 456 SCDError(SCDStatus status)
 457 {
 458         return SCErrorString(convert_SCDStatus_To_SCStatus(status));
 459 }
 460
 461 CFStringRef
 462 SCDKeyCreate(CFStringRef fmt, ...)
 463 {
 464         va_list args;
 465         va_start(args, fmt);
 466         return (CFStringCreateWithFormatAndArguments(NULL,
 467                                                      NULL,
 468                                                      fmt,
 469                                                      args));
 470 }
 471
 472 CFStringRef
 473 SCDKeyCreateNetworkGlobalEntity(CFStringRef domain, CFStringRef entity)
 474 {
 475         return SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL, domain, entity);
 476 }
 477
 478 CFStringRef
 479 SCDKeyCreateNetworkInterface(CFStringRef domain)
 480 {
 481         return SCDynamicStoreKeyCreateNetworkInterface(NULL, domain);
 482 }
 483
 484 CFStringRef
 485 SCDKeyCreateNetworkInterfaceEntity(CFStringRef domain, CFStringRef ifname, CFStringRef entity)
 486 {
 487         return SCDynamicStoreKeyCreateNetworkInterfaceEntity(NULL, domain, ifname, entity);
 488 }
 489
 490 CFStringRef
 491 SCDKeyCreateNetworkServiceEntity(CFStringRef domain, CFStringRef serviceID, CFStringRef entity)
 492 {
 493         return SCDynamicStoreKeyCreateNetworkServiceEntity(NULL, domain, serviceID, entity);
 494 }
 495
 496 static int
 497 convert_SCPStatus_To_SCStatus(SCPStatus status)
 498 {
 499         switch (status) {
 500                 case SCP_OK                     : return kSCStatusOK;
 501                 case SCP_NOSESSION              : return kSCStatusNoPrefsSession;
 502                 case SCP_BUSY                   : return kSCStatusPrefsBusy;
 503                 case SCP_NEEDLOCK               : return kSCStatusNeedLock;
 504                 case SCP_EACCESS                : return kSCStatusAccessError;
 505                 case SCP_ENOENT                 : return kSCStatusNoConfigFile;
 506                 case SCP_BADCF                  : return kSCStatusFailed;
 507                 case SCP_NOKEY                  : return kSCStatusNoKey;
 508                 case SCP_NOLINK                 : return kSCStatusNoLink;
 509                 case SCP_EXISTS                 : return kSCStatusKeyExists;
 510                 case SCP_STALE                  : return kSCStatusStale;
 511                 case SCP_INVALIDARGUMENT        : return kSCStatusInvalidArgument;
 512                 case SCP_FAILED                 : return kSCStatusFailed;
 513                 default                         : return kSCStatusFailed;
 514         }
 515 }
 516
 517 SCPStatus
 518 SCPOpen(SCPSessionRef *session, CFStringRef name, CFStringRef prefsID, int options)
 519 {
 520         CFArrayRef      keys;
 521         CFIndex         nKeys;
 522
 523         __Initialize();         /* initialize framework */
 524
 525         *session = (SCPSessionRef)SCPreferencesCreate(NULL, name, prefsID);
 526         if (*session == NULL) {
 527                 return SCP_EACCESS;
 528         }
 529
 530         keys  = SCPreferencesCopyKeyList(*session);
 531         nKeys = CFArrayGetCount(keys);
 532         CFRelease(keys);
 533
 534         if ((nKeys == 0) &&
 535             ((options & kSCPOpenCreatePrefs) != kSCPOpenCreatePrefs)) {
 536                 /* if no keys and not requesting the file be created */
 537                 return SCP_ENOENT;
 538         }
 539
 540         return SCP_OK;
 541 }
 542
 543 SCPStatus
 544 SCPUserOpen(SCPSessionRef *session, CFStringRef name, CFStringRef prefsID, CFStringRef user, int options)
 545 {
 546         CFArrayRef      keys;
 547         CFIndex         nKeys;
 548
 549         __Initialize();         /* initialize framework */
 550
 551         *session = (SCPSessionRef)SCUserPreferencesCreate(NULL, name, prefsID, user);
 552         if (*session == NULL) {
 553                 return SCP_EACCESS;
 554         }
 555
 556         keys  = SCPreferencesCopyKeyList(*session);
 557         nKeys = CFArrayGetCount(keys);
 558         CFRelease(keys);
 559
 560         if ((nKeys == 0) &&
 561             ((options & kSCPOpenCreatePrefs) != kSCPOpenCreatePrefs)) {
 562                 /* if no keys and not requesting the file be created */
 563                 return SCP_ENOENT;
 564         }
 565
 566         return SCP_OK;
 567 }
 568
 569 SCPStatus
 570 SCPClose(SCPSessionRef *session)
 571 {
 572         CFRelease(*session);
 573         *session = NULL;
 574         return SCD_OK;
 575 }
 576
 577 SCPStatus
 578 SCPLock(SCPSessionRef session, boolean_t wait)
 579 {
 580         /* XXXXX: old API error codes included kSCStatusPrefsBusy, kSCStatusAccessError, and kSCStatusStale */
 581         return SCPreferencesLock((SCPreferencesRef)session, wait) ? SCP_OK : SCP_FAILED;
 582 }
 583
 584 SCPStatus
 585 SCPCommit(SCPSessionRef session)
 586 {
 587         /* XXXXX: old API error codes included kSCStatusAccessError, kSCStatusStale */
 588         return SCPreferencesCommitChanges((SCPreferencesRef)session) ? SCP_OK : SCP_FAILED;
 589 }
 590
 591 SCPStatus
 592 SCPApply(SCPSessionRef session)
 593 {
 594         return SCPreferencesApplyChanges((SCPreferencesRef)session) ? SCP_OK : SCP_EACCESS;
 595 }
 596
 597 SCPStatus
 598 SCPUnlock(SCPSessionRef session)
 599 {
 600         return SCPreferencesUnlock((SCPreferencesRef)session) ? SCP_OK : SCP_FAILED;
 601 }
 602
 603 SCPStatus
 604 SCPGetSignature(SCPSessionRef session, CFDataRef *signature)
 605 {
 606         *signature = SCPreferencesGetSignature((SCPreferencesRef)session);
 607         return (*signature) ? SCP_OK : SCP_FAILED;
 608 }
 609
 610 SCPStatus
 611 SCPList(SCPSessionRef session, CFArrayRef *keys)
 612 {
 613         *keys = SCPreferencesCopyKeyList((SCPreferencesRef)session);
 614         return (*keys) ? SCP_OK : SCP_FAILED;
 615 }
 616
 617 SCPStatus
 618 SCPGet(SCPSessionRef session, CFStringRef key, CFPropertyListRef *data)
 619 {
 620         *data = SCPreferencesGetValue((SCPreferencesRef)session, key);
 621         return (*data) ? SCP_OK : SCP_NOKEY;
 622 }
 623
 624 SCPStatus
 625 SCPAdd(SCPSessionRef session, CFStringRef key, CFPropertyListRef data)
 626 {
 627         return SCPreferencesAddValue((SCPreferencesRef)session, key, data) ? SCP_OK : SCP_EXISTS;
 628 }
 629
 630 SCPStatus
 631 SCPSet(SCPSessionRef session, CFStringRef key, CFPropertyListRef data)
 632 {
 633         return SCPreferencesSetValue((SCPreferencesRef)session, key, data) ? SCP_OK : SCP_FAILED;
 634 }
 635
 636 SCPStatus
 637 SCPRemove(SCPSessionRef session, CFStringRef key)
 638 {
 639         return SCPreferencesRemoveValue((SCPreferencesRef)session, key) ? SCP_OK : SCP_NOKEY;
 640 }
 641
 642 CFStringRef
 643 SCPNotificationKeyCreate(CFStringRef prefsID, int keyType)
 644 {
 645         return SCDynamicStoreKeyCreatePreferences(NULL, prefsID, keyType);
 646 }
 647
 648 CFStringRef
 649 SCPUserNotificationKeyCreate(CFStringRef prefsID, CFStringRef user, int keyType)
 650 {
 651         return SCDynamicStoreKeyCreateUserPreferences(NULL, prefsID, user, keyType);
 652 }
 653
 654 SCPStatus
 655 SCPPathCreateUniqueChild(SCPSessionRef session, CFStringRef prefix, CFStringRef *newPath)
 656 {
 657         *newPath = SCPreferencesPathCreateUniqueChild((SCPreferencesRef)session, prefix);
 658         return (*newPath) ? SCP_OK : SCP_NOKEY;
 659 }
 660
 661 SCPStatus
 662 SCPPathGetValue(SCPSessionRef session, CFStringRef path, CFDictionaryRef *value)
 663 {
 664         *value = SCPreferencesPathGetValue((SCPreferencesRef)session, path);
 665         return (*value) ? SCP_OK : SCP_NOKEY;
 666 }
 667
 668 SCPStatus
 669 SCPPathGetLink(SCPSessionRef session, CFStringRef path, CFStringRef *link)
 670 {
 671         *link = SCPreferencesPathGetLink((SCPreferencesRef)session, path);
 672         return (*link) ? SCP_OK : SCP_NOKEY;
 673 }
 674
 675 SCPStatus
 676 SCPPathSetValue(SCPSessionRef session, CFStringRef path, CFDictionaryRef value)
 677 {
 678         return SCPreferencesPathSetValue((SCPreferencesRef)session, path, value) ? SCP_OK : SCP_FAILED;
 679 }
 680
 681 SCPStatus
 682 SCPPathSetLink(SCPSessionRef session, CFStringRef path, CFStringRef link)
 683 {
 684         return SCPreferencesPathSetLink((SCPreferencesRef)session, path, link) ? SCP_OK : SCP_FAILED;
 685 }
 686
 687 SCPStatus
 688 SCPPathRemove(SCPSessionRef session, CFStringRef path)
 689 {
 690         return SCPreferencesPathRemoveValue((SCPreferencesRef)session, path) ? SCP_OK : SCP_NOKEY;
 691 }
 692
 693 const char *
 694 SCPError(SCPStatus status)
 695 {
 696         return SCErrorString(convert_SCPStatus_To_SCStatus(status));
 697 }
 698
 699 CFStringRef
 700 SCDKeyCreateConsoleUser()
 701 {
 702         return SCDynamicStoreKeyCreateConsoleUser(NULL);
 703 }
 704
 705 SCDStatus
 706 SCDConsoleUserGet(char *user, int userlen, uid_t *uid, gid_t *gid)
 707 {
 708         CFStringRef     consoleUser;
 709
 710         consoleUser = SCDynamicStoreCopyConsoleUser(NULL, uid, gid);
 711         if (!consoleUser) {
 712                 return SCD_NOKEY;
 713         }
 714
 715         if (user && (userlen > 0)) {
 716                 CFIndex         len;
 717                 CFRange         range;
 718
 719                 bzero(user, userlen);
 720                 range = CFRangeMake(0, CFStringGetLength(consoleUser));
 721                 (void) CFStringGetBytes(consoleUser,
 722                                         range,
 723                                         kCFStringEncodingMacRoman,
 724                                         0,
 725                                         FALSE,
 726                                         user,
 727                                         userlen,
 728                                         &len);
 729         }
 730         CFRelease(consoleUser);
 731         return SCD_OK;
 732 }
 733
 734 SCDStatus
 735 SCDConsoleUserSet(const char *user, uid_t uid, gid_t gid)
 736 {
 737         return SCDynamicStoreSetConsoleUser(NULL, user, uid, gid) ? SCD_OK : SCD_FAILED;
 738 }
 739
 740 CFStringRef
 741 SCDKeyCreateHostName()
 742 {
 743         return SCDynamicStoreKeyCreateComputerName(NULL);
 744 }
 745
 746 SCDStatus
 747 SCDHostNameGet(CFStringRef *name, CFStringEncoding *nameEncoding)
 748 {
 749         *name = SCDynamicStoreCopyComputerName(NULL, nameEncoding);
 750         return (*name) ? SCD_OK : SCD_FAILED;
 751 }
 752
 753 static SCNStatus
 754 convertReachability(int newFlags, int *oldFlags)
 755 {
 756         SCNStatus       scn_status = SCN_REACHABLE_NO;
 757
 758         if (newFlags & kSCNetworkFlagsTransientConnection) {
 759                 if (oldFlags) {
 760                         *oldFlags |= kSCNFlagsTransientConnection;
 761                 }
 762         }
 763
 764         if (newFlags & kSCNetworkFlagsReachable) {
 765                 scn_status = SCN_REACHABLE_YES;
 766
 767                 if (newFlags & kSCNetworkFlagsConnectionRequired) {
 768                         scn_status = SCN_REACHABLE_CONNECTION_REQUIRED;
 769                 }
 770
 771                 if (newFlags & kSCNetworkFlagsConnectionAutomatic) {
 772                         if (oldFlags) {
 773                                 *oldFlags |= kSCNFlagsConnectionAutomatic;
 774                         }
 775                 }
 776
 777                 if (newFlags & kSCNetworkFlagsInterventionRequired) {
 778                         if (oldFlags) {
 779                                 *oldFlags |= kSCNFlagsInterventionRequired;
 780                         }
 781                 }
 782         }
 783
 784         return scn_status;
 785 }
 786
 787 SCNStatus
 788 SCNIsReachableByAddress(const struct sockaddr *address, const int addrlen, int *flags, const char **errorMessage)
 789 {
 790         SCNetworkConnectionFlags        newFlags;
 791
 792         if (!SCNetworkCheckReachabilityByAddress(address, addrlen, &newFlags)) {
 793                 if (errorMessage) {
 794                         *errorMessage = SCErrorString(kSCStatusReachabilityUnknown);
 795                 }
 796                 return SCN_REACHABLE_UNKNOWN;
 797         }
 798
 799         return convertReachability(newFlags, flags);
 800
 801 }
 802
 803 SCNStatus
 804 SCNIsReachableByName(const char *nodename, int *flags, const char **errorMessage)
 805 {
 806         SCNetworkConnectionFlags        newFlags;
 807
 808         if (!SCNetworkCheckReachabilityByName(nodename, &newFlags)) {
 809                 if (errorMessage) {
 810                         *errorMessage = SCErrorString(kSCStatusReachabilityUnknown);
 811                 }
 812                 return SCN_REACHABLE_UNKNOWN;
 813         }
 814
 815         return convertReachability(newFlags, flags);
 816 }