SystemConfiguration.fproj/SCNetworkService.c

   1 /*
   2  * Copyright (c) 2004-2009 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  * May 13, 2004         Allan Nathanson <ajn@apple.com>
  28  * - initial revision
  29  */
  30
  31
  32 #include <CoreFoundation/CoreFoundation.h>
  33 #include <CoreFoundation/CFRuntime.h>
  34 #include <SystemConfiguration/SystemConfiguration.h>
  35 #include "SCNetworkConfigurationInternal.h"
  36 #include <SystemConfiguration/SCValidation.h>
  37 #include <SystemConfiguration/SCPrivate.h>
  38
  39 #include <pthread.h>
  40
  41
  42 static CFStringRef      __SCNetworkServiceCopyDescription       (CFTypeRef cf);
  43 static void             __SCNetworkServiceDeallocate            (CFTypeRef cf);
  44 static Boolean          __SCNetworkServiceEqual                 (CFTypeRef cf1, CFTypeRef cf2);
  45 static CFHashCode       __SCNetworkServiceHash                  (CFTypeRef cf);
  46
  47
  48 static CFTypeID __kSCNetworkServiceTypeID               = _kCFRuntimeNotATypeID;
  49
  50
  51 static const CFRuntimeClass __SCNetworkServiceClass = {
  52         0,                                      // version
  53         "SCNetworkService",                     // className
  54         NULL,                                   // init
  55         NULL,                                   // copy
  56         __SCNetworkServiceDeallocate,           // dealloc
  57         __SCNetworkServiceEqual,                // equal
  58         __SCNetworkServiceHash,                 // hash
  59         NULL,                                   // copyFormattingDesc
  60         __SCNetworkServiceCopyDescription       // copyDebugDesc
  61 };
  62
  63
  64 static pthread_once_t           initialized             = PTHREAD_ONCE_INIT;
  65
  66
  67 static CFStringRef
  68 __SCNetworkServiceCopyDescription(CFTypeRef cf)
  69 {
  70         CFAllocatorRef                  allocator       = CFGetAllocator(cf);
  71         CFMutableStringRef              result;
  72         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)cf;
  73
  74         result = CFStringCreateMutable(allocator, 0);
  75         CFStringAppendFormat(result, NULL, CFSTR("<SCNetworkService %p [%p]> {"), cf, allocator);
  76         CFStringAppendFormat(result, NULL, CFSTR("id = %@"), servicePrivate->serviceID);
  77         if (servicePrivate->prefs != NULL) {
  78                 CFStringAppendFormat(result, NULL, CFSTR(", prefs = %p"), servicePrivate->prefs);
  79         } else if (servicePrivate->store != NULL) {
  80                 CFStringAppendFormat(result, NULL, CFSTR(", store = %p"), servicePrivate->store);
  81         }
  82         if (servicePrivate->name != NULL) {
  83                 CFStringAppendFormat(result, NULL, CFSTR(", name = %@"), servicePrivate->name);
  84         }
  85         CFStringAppendFormat(result, NULL, CFSTR("}"));
  86
  87         return result;
  88 }
  89
  90
  91 static void
  92 __SCNetworkServiceDeallocate(CFTypeRef cf)
  93 {
  94         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)cf;
  95
  96         /* release resources */
  97
  98         CFRelease(servicePrivate->serviceID);
  99         if (servicePrivate->interface != NULL) CFRelease(servicePrivate->interface);
 100         if (servicePrivate->prefs != NULL) CFRelease(servicePrivate->prefs);
 101         if (servicePrivate->store != NULL) CFRelease(servicePrivate->store);
 102         if (servicePrivate->name != NULL) CFRelease(servicePrivate->name);
 103
 104         return;
 105 }
 106
 107
 108 static Boolean
 109 __SCNetworkServiceEqual(CFTypeRef cf1, CFTypeRef cf2)
 110 {
 111         SCNetworkServicePrivateRef      s1      = (SCNetworkServicePrivateRef)cf1;
 112         SCNetworkServicePrivateRef      s2      = (SCNetworkServicePrivateRef)cf2;
 113
 114         if (s1 == s2)
 115                 return TRUE;
 116
 117         if (s1->prefs != s2->prefs)
 118                 return FALSE;   // if not the same prefs
 119
 120         if (!CFEqual(s1->serviceID, s2->serviceID))
 121                 return FALSE;   // if not the same service identifier
 122
 123         return TRUE;
 124 }
 125
 126
 127 static CFHashCode
 128 __SCNetworkServiceHash(CFTypeRef cf)
 129 {
 130         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)cf;
 131
 132         return CFHash(servicePrivate->serviceID);
 133 }
 134
 135
 136 static void
 137 __SCNetworkServiceInitialize(void)
 138 {
 139         __kSCNetworkServiceTypeID = _CFRuntimeRegisterClass(&__SCNetworkServiceClass);
 140         return;
 141 }
 142
 143
 144 __private_extern__ SCNetworkServicePrivateRef
 145 __SCNetworkServiceCreatePrivate(CFAllocatorRef          allocator,
 146                                 SCPreferencesRef        prefs,
 147                                 CFStringRef             serviceID,
 148                                 SCNetworkInterfaceRef   interface)
 149 {
 150         SCNetworkServicePrivateRef              servicePrivate;
 151         uint32_t                                size;
 152
 153         /* initialize runtime */
 154         pthread_once(&initialized, __SCNetworkServiceInitialize);
 155
 156         /* allocate target */
 157         size           = sizeof(SCNetworkServicePrivate) - sizeof(CFRuntimeBase);
 158         servicePrivate = (SCNetworkServicePrivateRef)_CFRuntimeCreateInstance(allocator,
 159                                                                               __kSCNetworkServiceTypeID,
 160                                                                               size,
 161                                                                               NULL);
 162         if (servicePrivate == NULL) {
 163                 return NULL;
 164         }
 165
 166         servicePrivate->prefs           = (prefs != NULL) ? CFRetain(prefs): NULL;
 167         servicePrivate->serviceID       = CFStringCreateCopy(NULL, serviceID);
 168         servicePrivate->interface       = (interface != NULL) ? CFRetain(interface) : NULL;
 169         servicePrivate->name            = NULL;
 170
 171         return servicePrivate;
 172 }
 173
 174
 175 #pragma mark -
 176 #pragma mark SCNetworkService APIs
 177
 178
 179 #define N_QUICK 64
 180
 181
 182 static CFDictionaryRef
 183 _protocolTemplate(SCNetworkServiceRef service, CFStringRef protocolType)
 184 {
 185         CFDictionaryRef                 newEntity       = NULL;
 186         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 187
 188         if (servicePrivate->interface != NULL) {
 189                 SCNetworkInterfaceRef   childInterface;
 190                 CFStringRef             childInterfaceType      = NULL;
 191                 CFStringRef             interfaceType;
 192
 193                 interfaceType = SCNetworkInterfaceGetInterfaceType(servicePrivate->interface);
 194                 childInterface = SCNetworkInterfaceGetInterface(servicePrivate->interface);
 195                 if (childInterface != NULL) {
 196                         childInterfaceType = SCNetworkInterfaceGetInterfaceType(childInterface);
 197                 }
 198
 199                 newEntity = __copyProtocolTemplate(interfaceType, childInterfaceType, protocolType);
 200         }
 201
 202         if (newEntity == NULL) {
 203                 newEntity = CFDictionaryCreate(NULL,
 204                                                NULL,
 205                                                NULL,
 206                                                0,
 207                                                &kCFTypeDictionaryKeyCallBacks,
 208                                                &kCFTypeDictionaryValueCallBacks);
 209         }
 210
 211         return newEntity;
 212 }
 213
 214
 215 Boolean
 216 SCNetworkServiceAddProtocolType(SCNetworkServiceRef service, CFStringRef protocolType)
 217 {
 218         CFDictionaryRef                 entity;
 219         CFDictionaryRef                 newEntity       = NULL;
 220         Boolean                         ok              = FALSE;
 221         CFStringRef                     path;
 222         SCNetworkProtocolRef            protocol;
 223         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 224
 225         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 226                 _SCErrorSet(kSCStatusInvalidArgument);
 227                 return FALSE;
 228         }
 229
 230         if (!__SCNetworkProtocolIsValidType(protocolType)) {
 231                 _SCErrorSet(kSCStatusInvalidArgument);
 232                 return FALSE;
 233         }
 234
 235         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 236                                                               servicePrivate->serviceID,        // service
 237                                                               protocolType);                    // entity
 238
 239         entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
 240         if (entity != NULL) {
 241                 // if "protocol" already exists
 242                 _SCErrorSet(kSCStatusKeyExists);
 243                 goto done;
 244         }
 245
 246         newEntity = CFDictionaryCreate(NULL,
 247                                        NULL,
 248                                        NULL,
 249                                        0,
 250                                        &kCFTypeDictionaryKeyCallBacks,
 251                                        &kCFTypeDictionaryValueCallBacks);
 252         ok = SCPreferencesPathSetValue(servicePrivate->prefs, path, newEntity);
 253         CFRelease(newEntity);
 254         if (!ok) {
 255                 goto done;
 256         }
 257
 258         protocol  = SCNetworkServiceCopyProtocol(service, protocolType);
 259         newEntity = _protocolTemplate(service, protocolType);
 260         ok = SCNetworkProtocolSetConfiguration(protocol, newEntity);
 261         CFRelease(newEntity);
 262         CFRelease(protocol);
 263
 264     done :
 265
 266         CFRelease(path);
 267         return ok;
 268 }
 269
 270
 271 CFArrayRef /* of SCNetworkServiceRef's */
 272 SCNetworkServiceCopyAll(SCPreferencesRef prefs)
 273 {
 274         CFMutableArrayRef       array;
 275         CFIndex                 n;
 276         CFStringRef             path;
 277         CFDictionaryRef         services;
 278
 279         path = SCPreferencesPathKeyCreateNetworkServices(NULL);
 280         services = SCPreferencesPathGetValue(prefs, path);
 281         CFRelease(path);
 282
 283         if ((services != NULL) && !isA_CFDictionary(services)) {
 284                 return NULL;
 285         }
 286
 287         array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 288
 289         n = (services != NULL) ? CFDictionaryGetCount(services) : 0;
 290         if (n > 0) {
 291                 CFIndex         i;
 292                 const void *    keys_q[N_QUICK];
 293                 const void **   keys    = keys_q;
 294                 const void *    vals_q[N_QUICK];
 295                 const void **   vals    = vals_q;
 296
 297                 if (n > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
 298                         keys = CFAllocatorAllocate(NULL, n * sizeof(CFTypeRef), 0);
 299                         vals = CFAllocatorAllocate(NULL, n * sizeof(CFPropertyListRef), 0);
 300                 }
 301                 CFDictionaryGetKeysAndValues(services, keys, vals);
 302                 for (i = 0; i < n; i++) {
 303                         CFDictionaryRef                 entity;
 304                         SCNetworkServicePrivateRef      servicePrivate;
 305
 306                         if (!isA_CFDictionary(vals[i])) {
 307                                 SCLog(TRUE,
 308                                       LOG_INFO,
 309                                       CFSTR("SCNetworkServiceCopyAll(): error w/service \"%@\"\n"),
 310                                       keys[i]);
 311                                 continue;
 312                         }
 313
 314                         entity = CFDictionaryGetValue(vals[i], kSCEntNetInterface);
 315                         if (!isA_CFDictionary(entity)) {
 316                                 // if no "interface"
 317                                 SCLog(TRUE,
 318                                       LOG_INFO,
 319                                       CFSTR("SCNetworkServiceCopyAll(): no \"%@\" entity for service \"%@\"\n"),
 320                                       kSCEntNetInterface,
 321                                       keys[i]);
 322                                 continue;
 323                         }
 324
 325                         servicePrivate = __SCNetworkServiceCreatePrivate(NULL, prefs, keys[i], NULL);
 326                         CFArrayAppendValue(array, (SCNetworkServiceRef)servicePrivate);
 327                         CFRelease(servicePrivate);
 328                 }
 329                 if (keys != keys_q) {
 330                         CFAllocatorDeallocate(NULL, keys);
 331                         CFAllocatorDeallocate(NULL, vals);
 332                 }
 333         }
 334
 335         return array;
 336 }
 337
 338
 339 /*
 340  * build a list of all of a servives entity types that are associated
 341  * with the services interface.  The list will include :
 342  *
 343  * - entity types associated with the interface type (Ethernet, FireWire, PPP, ...)
 344  * - entity types associated with the interface sub-type (PPPSerial, PPPoE, L2TP, PPTP, ...)
 345  * - entity types associated with the hardware device (Ethernet, AirPort, FireWire, Modem, ...)
 346  */
 347 static CFSetRef
 348 _copyInterfaceEntityTypes(CFDictionaryRef protocols)
 349 {
 350         CFDictionaryRef interface;
 351         CFMutableSetRef interface_entity_types;
 352
 353         interface_entity_types = CFSetCreateMutable(NULL, 0, &kCFTypeSetCallBacks);
 354
 355         interface = CFDictionaryGetValue(protocols, kSCEntNetInterface);
 356         if (isA_CFDictionary(interface)) {
 357                 CFStringRef     entities[]      = { kSCPropNetInterfaceType,
 358                                                     kSCPropNetInterfaceSubType,
 359                                                     kSCPropNetInterfaceHardware };
 360                 int             i;
 361
 362                 // include the "Interface" entity itself
 363                 CFSetAddValue(interface_entity_types, kSCEntNetInterface);
 364
 365                 // include the entities associated with the interface
 366                 for (i = 0; i < sizeof(entities)/sizeof(entities[0]); i++) {
 367                         CFStringRef     entity;
 368
 369                         entity = CFDictionaryGetValue(interface, entities[i]);
 370                         if (isA_CFString(entity)) {
 371                                 CFSetAddValue(interface_entity_types, entity);
 372                         }
 373                 }
 374
 375                 /*
 376                  * and, because we've found some misguided network preference code
 377                  * developers leaving [PPP] entity dictionaries around even though
 378                  * they are unused and/or unneeded...
 379                  */
 380                 CFSetAddValue(interface_entity_types, kSCEntNetPPP);
 381         }
 382
 383         return interface_entity_types;
 384 }
 385
 386
 387 SCNetworkServiceRef
 388 SCNetworkServiceCopy(SCPreferencesRef prefs, CFStringRef serviceID)
 389 {
 390         CFDictionaryRef                 entity;
 391         CFStringRef                     path;
 392         SCNetworkServicePrivateRef      servicePrivate;
 393
 394         if (!isA_CFString(serviceID)) {
 395                 _SCErrorSet(kSCStatusInvalidArgument);
 396                 return NULL;
 397         }
 398
 399         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                     // allocator
 400                                                               serviceID,                // service
 401                                                               kSCEntNetInterface);      // entity
 402         entity = SCPreferencesPathGetValue(prefs, path);
 403         CFRelease(path);
 404
 405         if (!isA_CFDictionary(entity)) {
 406                 // a "service" must have an "interface"
 407                 _SCErrorSet(kSCStatusNoKey);
 408                 return NULL;
 409         }
 410
 411         servicePrivate = __SCNetworkServiceCreatePrivate(NULL, prefs, serviceID, NULL);
 412         return (SCNetworkServiceRef)servicePrivate;
 413 }
 414
 415
 416 SCNetworkServiceRef
 417 _SCNetworkServiceCopyActive(SCDynamicStoreRef store, CFStringRef serviceID)
 418 {
 419         SCNetworkServicePrivateRef      servicePrivate;
 420
 421         if (!isA_CFString(serviceID)) {
 422                 _SCErrorSet(kSCStatusInvalidArgument);
 423                 return NULL;
 424         }
 425
 426         servicePrivate = __SCNetworkServiceCreatePrivate(NULL, NULL, serviceID, NULL);
 427         if (store != NULL) {
 428                 servicePrivate->store = CFRetain(store);
 429         }
 430         return (SCNetworkServiceRef)servicePrivate;
 431 }
 432
 433
 434 SCNetworkProtocolRef
 435 SCNetworkServiceCopyProtocol(SCNetworkServiceRef service, CFStringRef protocolType)
 436 {
 437         CFSetRef                        non_protocol_entities;
 438         CFStringRef                     path;
 439         CFDictionaryRef                 protocols;
 440         SCNetworkProtocolPrivateRef     protocolPrivate = NULL;
 441         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 442
 443         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 444                 _SCErrorSet(kSCStatusInvalidArgument);
 445                 return NULL;
 446         }
 447
 448         if (!isA_CFString(protocolType)) {
 449                 _SCErrorSet(kSCStatusInvalidArgument);
 450                 return NULL;
 451         }
 452
 453         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 454                                                               servicePrivate->serviceID,        // service
 455                                                               NULL);                            // entity
 456         protocols = SCPreferencesPathGetValue(servicePrivate->prefs, path);
 457         CFRelease(path);
 458
 459         if (!isA_CFDictionary(protocols)) {
 460                 // if corrupt prefs
 461                 _SCErrorSet(kSCStatusFailed);
 462                 return NULL;
 463         }
 464
 465         non_protocol_entities = _copyInterfaceEntityTypes(protocols);
 466         if (CFSetContainsValue(non_protocol_entities, protocolType)) {
 467                 // if the "protocolType" matches an interface entity type
 468                 _SCErrorSet(kSCStatusInvalidArgument);
 469                 goto done;
 470         }
 471
 472         if (!CFDictionaryContainsKey(protocols, protocolType)) {
 473                 // if the "protocolType" entity does not exist
 474                 _SCErrorSet(kSCStatusNoKey);
 475                 goto done;
 476         }
 477
 478         protocolPrivate = __SCNetworkProtocolCreatePrivate(NULL, protocolType, service);
 479
 480     done :
 481
 482         CFRelease(non_protocol_entities);
 483
 484         return (SCNetworkProtocolRef)protocolPrivate;
 485 }
 486
 487
 488 CFArrayRef /* of SCNetworkProtocolRef's */
 489 SCNetworkServiceCopyProtocols(SCNetworkServiceRef service)
 490 {
 491         CFMutableArrayRef               array;
 492         CFIndex                         n;
 493         CFSetRef                        non_protocol_entities;
 494         CFStringRef                     path;
 495         CFDictionaryRef                 protocols;
 496         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 497
 498         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 499                 _SCErrorSet(kSCStatusInvalidArgument);
 500                 return NULL;
 501         }
 502
 503         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 504                                                               servicePrivate->serviceID,        // service
 505                                                               NULL);                            // entity
 506         protocols = SCPreferencesPathGetValue(servicePrivate->prefs, path);
 507         CFRelease(path);
 508
 509         if (!isA_CFDictionary(protocols)) {
 510                 // if corrupt prefs
 511                 _SCErrorSet(kSCStatusFailed);
 512                 return NULL;
 513         }
 514
 515         non_protocol_entities = _copyInterfaceEntityTypes(protocols);
 516
 517         array = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 518
 519         n = CFDictionaryGetCount(protocols);
 520         if (n > 0) {
 521                 CFIndex                         i;
 522                 const void *                    keys_q[N_QUICK];
 523                 const void **                   keys            = keys_q;
 524                 const void *                    vals_q[N_QUICK];
 525                 const void **                   vals            = vals_q;
 526
 527                 if (n > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
 528                         keys = CFAllocatorAllocate(NULL, n * sizeof(CFTypeRef), 0);
 529                         vals = CFAllocatorAllocate(NULL, n * sizeof(CFPropertyListRef), 0);
 530                 }
 531                 CFDictionaryGetKeysAndValues(protocols, keys, vals);
 532                 for (i = 0; i < n; i++) {
 533                         SCNetworkProtocolPrivateRef     protocolPrivate;
 534
 535                         if (!isA_CFDictionary(vals[i])) {
 536                                 // if it's not a dictionary then it can't be a protocol entity
 537                                 continue;
 538                         }
 539
 540                         if (CFSetContainsValue(non_protocol_entities, keys[i])) {
 541                                 // skip any non-protocol (interface) entities
 542                                 continue;
 543                         }
 544
 545                         protocolPrivate = __SCNetworkProtocolCreatePrivate(NULL, keys[i], service);
 546                         CFArrayAppendValue(array, (SCNetworkProtocolRef)protocolPrivate);
 547
 548                         CFRelease(protocolPrivate);
 549                 }
 550                 if (keys != keys_q) {
 551                         CFAllocatorDeallocate(NULL, keys);
 552                         CFAllocatorDeallocate(NULL, vals);
 553                 }
 554         }
 555
 556         CFRelease(non_protocol_entities);
 557
 558         return array;
 559 }
 560
 561
 562 static Boolean
 563 __SCNetworkServiceSetInterfaceEntity(SCNetworkServiceRef     service,
 564                                      SCNetworkInterfaceRef   interface)
 565 {
 566         CFDictionaryRef                 entity;
 567         Boolean                         ok;
 568         CFStringRef                     path;
 569         SCNetworkServicePrivateRef      servicePrivate          = (SCNetworkServicePrivateRef)service;
 570
 571         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 572                                                               servicePrivate->serviceID,        // service
 573                                                               kSCEntNetInterface);              // entity
 574         entity = __SCNetworkInterfaceCopyInterfaceEntity(interface);
 575         ok = SCPreferencesPathSetValue(servicePrivate->prefs, path, entity);
 576         CFRelease(entity);
 577         CFRelease(path);
 578
 579         return ok;
 580 }
 581
 582
 583 static void
 584 mergeDict(const void *key, const void *value, void *context)
 585 {
 586         CFMutableDictionaryRef  newDict = (CFMutableDictionaryRef)context;
 587
 588         CFDictionarySetValue(newDict, key, value);
 589         return;
 590 }
 591
 592
 593 SCNetworkServiceRef
 594 SCNetworkServiceCreate(SCPreferencesRef prefs, SCNetworkInterfaceRef interface)
 595 {
 596         CFArrayRef                      components;
 597         CFArrayRef                      interface_config;
 598         CFStringRef                     interface_name;
 599         SCNetworkInterfaceRef           newInterface;
 600         CFStringRef                     path;
 601         CFStringRef                     prefix;
 602         CFStringRef                     serviceID;
 603         SCNetworkServicePrivateRef      servicePrivate;
 604         CFArrayRef                      supported_protocols;
 605
 606         if (!isA_SCNetworkInterface(interface)) {
 607                 _SCErrorSet(kSCStatusInvalidArgument);
 608                 return NULL;
 609         }
 610
 611         // only allow network interfaces which support one or more protocols
 612         // to be added to a service.  The one exception is that we allow
 613         // third-party interface types to be configured.
 614         supported_protocols = SCNetworkInterfaceGetSupportedProtocolTypes(interface);
 615         if (supported_protocols == NULL) {
 616                 CFStringRef     interface_type;
 617
 618                 interface_type = SCNetworkInterfaceGetInterfaceType(interface);
 619                 if (CFStringFind(interface_type, CFSTR("."), 0).location == kCFNotFound) {
 620                         return NULL;
 621                 }
 622         }
 623
 624         // establish the service
 625         prefix = SCPreferencesPathKeyCreateNetworkServices(NULL);
 626         path = __SCPreferencesPathCreateUniqueChild_WithMoreSCFCompatibility(prefs, prefix);
 627         if (path == NULL) path = SCPreferencesPathCreateUniqueChild(prefs, prefix);
 628         CFRelease(prefix);
 629         if (path == NULL) {
 630                 return NULL;
 631         }
 632
 633         components = CFStringCreateArrayBySeparatingStrings(NULL, path, CFSTR("/"));
 634         CFRelease(path);
 635
 636         serviceID = CFArrayGetValueAtIndex(components, 2);
 637         servicePrivate = __SCNetworkServiceCreatePrivate(NULL, prefs, serviceID, NULL);
 638         CFRelease(components);
 639
 640         // duplicate the interface and associate the copy with the new service
 641         newInterface = (SCNetworkInterfaceRef)__SCNetworkInterfaceCreateCopy(NULL,
 642                                                                              interface,
 643                                                                              prefs,
 644                                                                              serviceID);
 645         servicePrivate->interface = newInterface;
 646
 647         // establish "default" configuration(s) for the interface
 648         for (interface = newInterface;
 649              interface != NULL;
 650              interface = SCNetworkInterfaceGetInterface(interface)) {
 651                 SCNetworkInterfaceRef   childInterface;
 652                 CFStringRef             childInterfaceType      = NULL;
 653                 CFDictionaryRef         config;
 654                 CFStringRef             interfaceType;
 655
 656                 interfaceType = SCNetworkInterfaceGetInterfaceType(interface);
 657                 childInterface = SCNetworkInterfaceGetInterface(interface);
 658                 if (childInterface != NULL) {
 659                         childInterfaceType = SCNetworkInterfaceGetInterfaceType(childInterface);
 660                 }
 661
 662                 config = __copyInterfaceTemplate(interfaceType, childInterfaceType);
 663                 if (config != NULL) {
 664                         if (CFEqual(interfaceType, kSCNetworkInterfaceTypeBluetooth) ||
 665                             CFEqual(interfaceType, kSCNetworkInterfaceTypeIrDA     ) ||
 666                             CFEqual(interfaceType, kSCNetworkInterfaceTypeModem    ) ||
 667                             CFEqual(interfaceType, kSCNetworkInterfaceTypeSerial   ) ||
 668                             CFEqual(interfaceType, kSCNetworkInterfaceTypeWWAN     )) {
 669                                 CFDictionaryRef overrides;
 670
 671                                 overrides = __SCNetworkInterfaceGetTemplateOverrides(interface, kSCNetworkInterfaceTypeModem);
 672
 673                                 // a ConnectionScript (and related keys) from the interface
 674                                 // should trump the settings from the configuration template.
 675                                 if ((overrides != NULL) &&
 676                                     CFDictionaryContainsKey(overrides, kSCPropNetModemConnectionScript)) {
 677                                         CFMutableDictionaryRef  newConfig;
 678
 679                                         newConfig = CFDictionaryCreateMutableCopy(NULL, 0, config);
 680                                         CFDictionaryRemoveValue(newConfig, kSCPropNetModemConnectionPersonality);
 681                                         CFDictionaryRemoveValue(newConfig, kSCPropNetModemConnectionScript);
 682                                         CFDictionaryRemoveValue(newConfig, kSCPropNetModemDeviceVendor);
 683                                         CFDictionaryRemoveValue(newConfig, kSCPropNetModemDeviceModel);
 684                                         CFRelease(config);
 685                                         config = newConfig;
 686                                 }
 687
 688                                 if (overrides != NULL) {
 689                                         CFMutableDictionaryRef  newConfig;
 690
 691                                         newConfig = CFDictionaryCreateMutableCopy(NULL, 0, config);
 692                                         CFDictionaryApplyFunction(overrides, mergeDict, newConfig);
 693                                         CFRelease(config);
 694                                         config = newConfig;
 695                                 }
 696                         } else if (CFEqual(interfaceType, kSCNetworkInterfaceTypePPP)) {
 697                                 CFDictionaryRef         overrides;
 698
 699                                 overrides = __SCNetworkInterfaceGetTemplateOverrides(interface, kSCNetworkInterfaceTypePPP);
 700                                 if (overrides != NULL) {
 701                                         CFMutableDictionaryRef  newConfig;
 702
 703                                         newConfig = CFDictionaryCreateMutableCopy(NULL, 0, config);
 704                                         CFDictionaryApplyFunction(overrides, mergeDict, newConfig);
 705                                         CFRelease(config);
 706                                         config = newConfig;
 707                                 }
 708                         }
 709
 710                         if (!__SCNetworkInterfaceSetConfiguration(interface, NULL, config, TRUE)) {
 711                                 SCLog(TRUE, LOG_DEBUG,
 712                                       CFSTR("SCNetworkService __SCNetworkInterfaceSetConfiguration failed(), interface=%@, type=NULL"),
 713                                       interface);
 714                         }
 715                         CFRelease(config);
 716                 }
 717         }
 718
 719         // add the interface [entity] to the service
 720         (void) __SCNetworkServiceSetInterfaceEntity((SCNetworkServiceRef)servicePrivate,
 721                                                     servicePrivate->interface);
 722
 723         // push the [deep] interface configuration into the service.
 724         interface_config = __SCNetworkInterfaceCopyDeepConfiguration(NULL, servicePrivate->interface);
 725         __SCNetworkInterfaceSetDeepConfiguration(NULL, servicePrivate->interface, interface_config);
 726         if (interface_config != NULL) CFRelease(interface_config);
 727
 728         // set the service name to match that of the associated interface
 729         //
 730         // Note: It might seem a bit odd to call SCNetworkServiceGetName
 731         // followed by an immediate call to SCNetworkServiceSetName.  The
 732         // trick here is that if no name has previously been set, the
 733         // "get" function will return the name of the associated interface.
 734         //
 735         // ... and we "set" a name to ensure that applications that do
 736         // not use the APIs will still find a UserDefinedName property
 737         // in the SCDynamicStore.
 738         //
 739         interface_name = SCNetworkServiceGetName((SCNetworkServiceRef)servicePrivate);
 740         if (interface_name != NULL) {
 741                 (void) SCNetworkServiceSetName((SCNetworkServiceRef)servicePrivate,
 742                                                interface_name);
 743         }
 744
 745         return (SCNetworkServiceRef)servicePrivate;
 746 }
 747
 748
 749 Boolean
 750 SCNetworkServiceEstablishDefaultConfiguration(SCNetworkServiceRef service)
 751 {
 752         CFIndex                         i;
 753         SCNetworkInterfaceRef           interface;
 754         CFIndex                         n;
 755         CFArrayRef                      protocolTypes;
 756         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 757
 758         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 759                 _SCErrorSet(kSCStatusInvalidArgument);
 760                 return FALSE;
 761         }
 762
 763         interface = SCNetworkServiceGetInterface(service);
 764         if (interface == NULL) {
 765                 return FALSE;
 766         }
 767
 768         protocolTypes = SCNetworkInterfaceGetSupportedProtocolTypes(interface);
 769         n = (protocolTypes != NULL) ? CFArrayGetCount(protocolTypes) : 0;
 770         for (i = 0; i < n; i++) {
 771                 Boolean                 enabled;
 772                 CFDictionaryRef         newEntity       = NULL;
 773                 Boolean                 ok;
 774                 SCNetworkProtocolRef    protocol        = NULL;
 775                 CFStringRef             protocolType;
 776
 777                 protocolType = CFArrayGetValueAtIndex(protocolTypes, i);
 778                 ok = SCNetworkServiceAddProtocolType(service, protocolType);
 779                 if (!ok && (SCError() != kSCStatusKeyExists)) {
 780                         // could not add protocol
 781                         goto nextProtocol;
 782                 }
 783
 784                 protocol = SCNetworkServiceCopyProtocol(service, protocolType);
 785                 if (protocol == NULL) {
 786                         // oops, somethings wrong (should never happen)
 787                         goto nextProtocol;
 788                 }
 789
 790                 newEntity = _protocolTemplate(service, protocolType);
 791                 ok = SCNetworkProtocolSetConfiguration(protocol, newEntity);
 792                 if (!ok) {
 793                         // could not set default configuration
 794                         goto nextProtocol;
 795                 }
 796
 797                 enabled = !CFDictionaryContainsKey(newEntity, kSCResvInactive);
 798                 ok = SCNetworkProtocolSetEnabled(protocol, enabled);
 799                 if (!ok) {
 800                         // could not enable/disable protocol
 801                         goto nextProtocol;
 802                 }
 803
 804             nextProtocol :
 805
 806                 if (newEntity != NULL) CFRelease(newEntity);
 807                 if (protocol  != NULL) CFRelease(protocol);
 808         }
 809
 810         return TRUE;
 811 }
 812
 813
 814 Boolean
 815 SCNetworkServiceGetEnabled(SCNetworkServiceRef service)
 816 {
 817         Boolean                         enabled;
 818         CFStringRef                     path;
 819         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 820
 821         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 822                 _SCErrorSet(kSCStatusInvalidArgument);
 823                 return FALSE;
 824         }
 825
 826         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 827                                                               servicePrivate->serviceID,        // service
 828                                                               NULL);                            // entity
 829         enabled = __getPrefsEnabled(servicePrivate->prefs, path);
 830         CFRelease(path);
 831
 832         return enabled;
 833 }
 834
 835
 836 SCNetworkInterfaceRef
 837 SCNetworkServiceGetInterface(SCNetworkServiceRef service)
 838 {
 839         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 840
 841         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 842                 _SCErrorSet(kSCStatusInvalidArgument);
 843                 return NULL;
 844         }
 845
 846         if (servicePrivate->interface == NULL) {
 847                 CFDictionaryRef entity;
 848                 CFStringRef     path;
 849
 850                 path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 851                                                                       servicePrivate->serviceID,        // service
 852                                                                       kSCEntNetInterface);              // entity
 853                 entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
 854                 CFRelease(path);
 855
 856                 if (isA_CFDictionary(entity)) {
 857                         servicePrivate->interface = _SCNetworkInterfaceCreateWithEntity(NULL, entity, service);
 858                 }
 859         }
 860
 861         return servicePrivate->interface;
 862 }
 863
 864
 865 CFStringRef
 866 SCNetworkServiceGetName(SCNetworkServiceRef service)
 867 {
 868         CFDictionaryRef                 entity;
 869         SCNetworkInterfaceRef           interface;
 870         CFStringRef                     name            = NULL;
 871         CFStringRef                     path;
 872         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
 873
 874         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
 875                 _SCErrorSet(kSCStatusInvalidArgument);
 876                 return NULL;
 877         }
 878
 879         if (servicePrivate->name != NULL) {
 880                 return servicePrivate->name;
 881         }
 882
 883         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
 884                                                               servicePrivate->serviceID,        // service
 885                                                               NULL);                            // entity
 886         entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
 887         CFRelease(path);
 888
 889         if (isA_CFDictionary(entity)) {
 890                 name = CFDictionaryGetValue(entity, kSCPropUserDefinedName);
 891                 if (isA_CFString(name)) {
 892                         servicePrivate->name = CFRetain(name);
 893                 }
 894         }
 895
 896         interface = SCNetworkServiceGetInterface(service);
 897         while (interface != NULL) {
 898                 SCNetworkInterfaceRef   childInterface;
 899
 900                 childInterface = SCNetworkInterfaceGetInterface(interface);
 901                 if ((childInterface == NULL) || CFEqual(childInterface, kSCNetworkInterfaceIPv4)) {
 902                         break;
 903                 }
 904
 905                 interface = childInterface;
 906         }
 907
 908         if (interface != NULL) {
 909                 int             i;
 910                 CFStringRef     interface_name  = NULL;
 911                 CFStringRef     suffix          = NULL;
 912
 913                 //
 914                 // check if the [stored] service name matches the non-localized interface
 915                 // name.  If so, return the localized name.
 916                 //
 917                 // Also, the older "Built-in XXX" interface names are too long for the
 918                 // current UI. If we find that the [stored] service name matches the older
 919                 // name, return the newer (and shorter) localized name.
 920                 //
 921                 // Note: the user/admin will no longer be able to set the service name
 922                 //       to "Built-in Ethernet".
 923                 //
 924                 for (i = 0; i < 3; i++) {
 925                         if (servicePrivate->name == NULL) {
 926                                 // if no [stored] service name to compare
 927                                 break;
 928                         }
 929
 930                         switch (i) {
 931                                 case 0 :
 932                                         // compare the non-localized interface name
 933                                         interface_name = __SCNetworkInterfaceGetNonLocalizedDisplayName(interface);
 934                                         if (interface_name != NULL) {
 935                                                 CFRetain(interface_name);
 936                                         }
 937                                         break;
 938                                 case 1 :
 939                                         // compare the older "Built-in XXX" localized name
 940                                         interface_name = __SCNetworkInterfaceCopyXLocalizedDisplayName(interface);
 941                                         break;
 942                                 case 2 :
 943                                         // compare the older "Built-in XXX" non-localized name
 944                                         interface_name = __SCNetworkInterfaceCopyXNonLocalizedDisplayName(interface);
 945                                         break;
 946                         }
 947
 948                         if (interface_name != NULL) {
 949                                 Boolean match   = FALSE;
 950
 951                                 if (CFEqual(name, interface_name)) {
 952                                         // if service name matches the OLD localized
 953                                         // interface name
 954                                         match = TRUE;
 955                                 } else if (CFStringHasPrefix(name, interface_name)) {
 956                                         CFIndex prefixLen       = CFStringGetLength(interface_name);
 957                                         CFIndex suffixLen       = CFStringGetLength(name);
 958
 959                                         suffix = CFStringCreateWithSubstring(NULL,
 960                                                                              name,
 961                                                                              CFRangeMake(prefixLen, suffixLen - prefixLen));
 962                                         match = TRUE;
 963                                 }
 964                                 CFRelease(interface_name);
 965
 966                                 if (match) {
 967                                         CFRelease(servicePrivate->name);
 968                                         servicePrivate->name = NULL;
 969                                         break;
 970                                 }
 971                         }
 972                 }
 973
 974                 //
 975                 // if the service name has not been set, use the localized interface name
 976                 //
 977                 if (servicePrivate->name == NULL) {
 978                         interface_name = SCNetworkInterfaceGetLocalizedDisplayName(interface);
 979                         if (interface_name != NULL) {
 980                                 if (suffix != NULL) {
 981                                         servicePrivate->name = CFStringCreateWithFormat(NULL,
 982                                                                                         NULL,
 983                                                                                         CFSTR("%@%@"),
 984                                                                                         interface_name,
 985                                                                                         suffix);
 986                                 } else {
 987                                         servicePrivate->name = CFRetain(interface_name);
 988                                 }
 989                         }
 990                 }
 991                 if (suffix != NULL) CFRelease(suffix);
 992         }
 993
 994         return servicePrivate->name;
 995 }
 996
 997
 998 CFStringRef
 999 SCNetworkServiceGetServiceID(SCNetworkServiceRef service)
1000 {
1001         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1002
1003         if (!isA_SCNetworkService(service)) {
1004                 _SCErrorSet(kSCStatusInvalidArgument);
1005                 return NULL;
1006         }
1007
1008         return servicePrivate->serviceID;
1009 }
1010
1011
1012 CFTypeID
1013 SCNetworkServiceGetTypeID(void)
1014 {
1015         pthread_once(&initialized, __SCNetworkServiceInitialize);       /* initialize runtime */
1016         return __kSCNetworkServiceTypeID;
1017 }
1018
1019
1020 Boolean
1021 SCNetworkServiceRemove(SCNetworkServiceRef service)
1022 {
1023         Boolean                         ok              = FALSE;
1024         CFStringRef                     path;
1025         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1026         CFArrayRef                      sets;
1027
1028         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
1029                 _SCErrorSet(kSCStatusInvalidArgument);
1030                 return FALSE;
1031         }
1032
1033         // remove service from all sets
1034
1035         sets = SCNetworkSetCopyAll(servicePrivate->prefs);
1036         if (sets != NULL) {
1037                 CFIndex i;
1038                 CFIndex n;
1039
1040                 n = CFArrayGetCount(sets);
1041                 for (i = 0; i < n; i++) {
1042                         SCNetworkSetRef set;
1043
1044                         set = CFArrayGetValueAtIndex(sets, i);
1045                         ok = SCNetworkSetRemoveService(set, service);
1046                         if (!ok && (SCError() != kSCStatusNoKey)) {
1047                                 CFRelease(sets);
1048                                 return ok;
1049                         }
1050                 }
1051                 CFRelease(sets);
1052         }
1053
1054         // remove service
1055
1056         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
1057                                                               servicePrivate->serviceID,        // service
1058                                                               NULL);                            // entity
1059         ok = SCPreferencesPathRemoveValue(servicePrivate->prefs, path);
1060         CFRelease(path);
1061
1062         return ok;
1063 }
1064
1065
1066 Boolean
1067 SCNetworkServiceRemoveProtocolType(SCNetworkServiceRef service, CFStringRef protocolType)
1068 {
1069         CFDictionaryRef                 entity;
1070         Boolean                         ok              = FALSE;
1071         CFStringRef                     path;
1072         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1073
1074         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
1075                 _SCErrorSet(kSCStatusInvalidArgument);
1076                 return FALSE;
1077         }
1078
1079         if (!__SCNetworkProtocolIsValidType(protocolType)) {
1080                 _SCErrorSet(kSCStatusInvalidArgument);
1081                 return FALSE;
1082         }
1083
1084         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
1085                                                               servicePrivate->serviceID,        // service
1086                                                               protocolType);                    // entity
1087
1088         entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
1089         if (entity == NULL) {
1090                 // if "protocol" does not exist
1091                 _SCErrorSet(kSCStatusNoKey);
1092                 goto done;
1093         }
1094
1095         ok = SCPreferencesPathRemoveValue(servicePrivate->prefs, path);
1096
1097     done :
1098
1099         CFRelease(path);
1100         return ok;
1101 }
1102
1103
1104 Boolean
1105 SCNetworkServiceSetEnabled(SCNetworkServiceRef service, Boolean enabled)
1106 {
1107         Boolean                         ok;
1108         CFStringRef                     path;
1109         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1110
1111         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
1112                 _SCErrorSet(kSCStatusInvalidArgument);
1113                 return FALSE;
1114         }
1115
1116         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
1117                                                               servicePrivate->serviceID,        // service
1118                                                               NULL);                            // entity
1119         ok = __setPrefsEnabled(servicePrivate->prefs, path, enabled);
1120         CFRelease(path);
1121
1122         return ok;
1123 }
1124
1125
1126 Boolean
1127 SCNetworkServiceSetName(SCNetworkServiceRef service, CFStringRef name)
1128 {
1129         CFDictionaryRef                 entity;
1130         Boolean                         ok              = FALSE;
1131         CFStringRef                     path;
1132         CFStringRef                     saveName        = NULL;
1133         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1134
1135         if (!isA_SCNetworkService(service) || (servicePrivate->prefs == NULL)) {
1136                 _SCErrorSet(kSCStatusInvalidArgument);
1137                 return FALSE;
1138         }
1139
1140         if (name != NULL) {
1141                 if (!isA_CFString(name)) {
1142                         _SCErrorSet(kSCStatusInvalidArgument);
1143                         return FALSE;
1144                 }
1145                 saveName = CFRetain(name);
1146         }
1147
1148         if (name != NULL) {
1149                 SCNetworkInterfaceRef   interface;
1150
1151                 interface = SCNetworkServiceGetInterface(service);
1152                 while (interface != NULL) {
1153                         SCNetworkInterfaceRef   childInterface;
1154
1155                         childInterface = SCNetworkInterfaceGetInterface(interface);
1156                         if (childInterface == NULL) {
1157                                 break;
1158                         }
1159
1160                         interface = childInterface;
1161                 }
1162
1163                 if (interface != NULL) {
1164                         CFStringRef     interface_name;
1165
1166                         interface_name = SCNetworkInterfaceGetLocalizedDisplayName(interface);
1167                         if (interface_name != NULL) {
1168                                 if (CFEqual(name, interface_name)) {
1169                                         // if service name matches the localized interface name
1170                                         // then store the non-localized name.
1171                                         interface_name = __SCNetworkInterfaceGetNonLocalizedDisplayName(interface);
1172                                         if (interface_name != NULL) {
1173                                                 CFRelease(saveName);
1174                                                 saveName = CFRetain(interface_name);
1175                                         }
1176                                 } else if (CFStringHasPrefix(name, interface_name)) {
1177                                         CFIndex         prefixLen       = CFStringGetLength(interface_name);
1178                                         CFStringRef     suffix;
1179                                         CFIndex         suffixLen       = CFStringGetLength(name);
1180
1181                                         // if service name matches the localized interface name plus
1182                                         // a few extra characters) then store the non-localized name with
1183                                         // the same suffix.
1184                                         suffix = CFStringCreateWithSubstring(NULL,
1185                                                                              name,
1186                                                                              CFRangeMake(prefixLen, suffixLen - prefixLen));
1187                                         interface_name = __SCNetworkInterfaceGetNonLocalizedDisplayName(interface);
1188                                         if (interface_name != NULL) {
1189                                                 CFRelease(saveName);
1190                                                 saveName = CFStringCreateWithFormat(NULL,
1191                                                                                     NULL,
1192                                                                                     CFSTR("%@%@"),
1193                                                                                     interface_name,
1194                                                                                     suffix);
1195                                         }
1196                                         CFRelease(suffix);
1197                                 }
1198                         }
1199                 }
1200         }
1201
1202 #define PREVENT_DUPLICATE_SERVICE_NAMES
1203 #ifdef  PREVENT_DUPLICATE_SERVICE_NAMES
1204         if (name != NULL) {
1205                 CFArrayRef      sets;
1206
1207                 // ensure that each service is uniquely named within its sets
1208
1209                 sets = SCNetworkSetCopyAll(servicePrivate->prefs);
1210                 if (sets != NULL) {
1211                         CFIndex         set_index;
1212                         CFIndex         set_count;
1213
1214                         set_count = CFArrayGetCount(sets);
1215                         for (set_index = 0; set_index < set_count; set_index++) {
1216                                 CFIndex         service_index;
1217                                 Boolean         isDup           = FALSE;
1218                                 Boolean         isMember        = FALSE;
1219                                 CFIndex         service_count;
1220                                 CFArrayRef      services;
1221                                 SCNetworkSetRef set             = CFArrayGetValueAtIndex(sets, set_index);
1222
1223                                 services = SCNetworkSetCopyServices(set);
1224
1225                                 service_count = CFArrayGetCount(services);
1226                                 for (service_index = 0; service_index < service_count; service_index++) {
1227                                         CFStringRef             otherID;
1228                                         CFStringRef             otherName;
1229                                         SCNetworkServiceRef     otherService;
1230
1231                                         otherService = CFArrayGetValueAtIndex(services, service_index);
1232
1233                                         otherID = SCNetworkServiceGetServiceID(otherService);
1234                                         if (CFEqual(servicePrivate->serviceID, otherID)) {
1235                                                 // if the service is a member of this set
1236                                                 isMember = TRUE;
1237                                                 continue;
1238                                         }
1239
1240                                         otherName = SCNetworkServiceGetName(otherService);
1241                                         if ((otherName != NULL) && CFEqual(name, otherName)) {
1242                                                 isDup = TRUE;
1243                                                 continue;
1244                                         }
1245                                 }
1246
1247                                 CFRelease(services);
1248
1249                                 if (isMember && isDup) {
1250                                         /*
1251                                          * if this service is a member of the set and
1252                                          * the "name" is not unique.
1253                                          */
1254                                         CFRelease(sets);
1255                                         if (saveName != NULL) CFRelease(saveName);
1256                                         _SCErrorSet(kSCStatusKeyExists);
1257                                         return FALSE;
1258                                 }
1259                         }
1260
1261                         CFRelease(sets);
1262                 }
1263         }
1264 #endif  /* PREVENT_DUPLICATE_SERVICE_NAMES */
1265
1266         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,                             // allocator
1267                                                               servicePrivate->serviceID,        // service
1268                                                               NULL);                            // entity
1269         entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
1270         if (isA_CFDictionary(entity) ||
1271             ((entity == NULL) && (name != NULL))) {
1272                 CFMutableDictionaryRef  newEntity;
1273
1274                 if (entity != NULL) {
1275                         newEntity = CFDictionaryCreateMutableCopy(NULL, 0, entity);
1276                 } else {
1277                         newEntity = CFDictionaryCreateMutable(NULL,
1278                                                               0,
1279                                                               &kCFTypeDictionaryKeyCallBacks,
1280                                                               &kCFTypeDictionaryValueCallBacks);
1281                 }
1282                 if (saveName != NULL) {
1283                         CFDictionarySetValue(newEntity, kSCPropUserDefinedName, saveName);
1284                 } else {
1285                         CFDictionaryRemoveValue(newEntity, kSCPropUserDefinedName);
1286                 }
1287                 ok = SCPreferencesPathSetValue(servicePrivate->prefs, path, newEntity);
1288                 CFRelease(newEntity);
1289         }
1290         CFRelease(path);
1291         if (saveName != NULL) CFRelease(saveName);
1292
1293         if (servicePrivate->name != NULL) CFRelease(servicePrivate->name);
1294         if (name != NULL) CFRetain(name);
1295         servicePrivate->name = name;
1296
1297         return ok;
1298 }
1299
1300
1301 #pragma mark -
1302 #pragma mark SCNetworkService SPIs
1303
1304
1305 static Boolean
1306 str_to_rank(CFStringRef rankStr, SCNetworkServicePrimaryRank *rank)
1307 {
1308         if (isA_CFString(rankStr)) {
1309                 if (CFEqual(rankStr, kSCValNetServicePrimaryRankFirst)) {
1310                         *rank = kSCNetworkServicePrimaryRankFirst;
1311                 } else if (CFEqual(rankStr, kSCValNetServicePrimaryRankLast)) {
1312                         *rank = kSCNetworkServicePrimaryRankLast;
1313                 } else if (CFEqual(rankStr, kSCValNetServicePrimaryRankNever)) {
1314                         *rank = kSCNetworkServicePrimaryRankNever;
1315                 } else {
1316                         return FALSE;
1317                 }
1318         } else if (rankStr == NULL) {
1319                 *rank = kSCNetworkServicePrimaryRankDefault;
1320         } else {
1321                 return FALSE;
1322         }
1323
1324         return TRUE;
1325 }
1326
1327
1328 SCNetworkServicePrimaryRank
1329 SCNetworkServiceGetPrimaryRank(SCNetworkServiceRef service)
1330 {
1331         CFDictionaryRef                 entity;
1332         Boolean                         ok              = TRUE;
1333         CFStringRef                     path;
1334         SCNetworkServicePrimaryRank     rank            = kSCNetworkServicePrimaryRankDefault;
1335         CFStringRef                     rankStr         = NULL;
1336         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1337
1338         if (!isA_SCNetworkService(service)) {
1339                 _SCErrorSet(kSCStatusInvalidArgument);
1340                 return rank;
1341         }
1342
1343         if (servicePrivate->prefs != NULL) {
1344                 path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,
1345                                                                       servicePrivate->serviceID,
1346                                                                       NULL);
1347                 entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
1348                 CFRelease(path);
1349                 if (isA_CFDictionary(entity)) {
1350                         rankStr = CFDictionaryGetValue(entity, kSCPropNetServicePrimaryRank);
1351                         ok = str_to_rank(rankStr, &rank);
1352                 }
1353         } else if (servicePrivate->store != NULL) {
1354                 path = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
1355                                                                    kSCDynamicStoreDomainState,
1356                                                                    servicePrivate->serviceID,
1357                                                                    NULL);
1358                 entity = SCDynamicStoreCopyValue(servicePrivate->store, path);
1359                 CFRelease(path);
1360                 if (entity != NULL) {
1361                         if (isA_CFDictionary(entity)) {
1362                                 rankStr = CFDictionaryGetValue(entity, kSCPropNetServicePrimaryRank);
1363                                 ok = str_to_rank(rankStr, &rank);
1364                         }
1365                         CFRelease(entity);
1366                 }
1367         } else {
1368                 _SCErrorSet(kSCStatusInvalidArgument);
1369                 return rank;
1370         }
1371
1372         if (!ok) {
1373                 rank = kSCNetworkServicePrimaryRankDefault;
1374                 _SCErrorSet(kSCStatusInvalidArgument);
1375         } else if (rank == kSCNetworkServicePrimaryRankDefault) {
1376                 _SCErrorSet(kSCStatusOK);
1377         }
1378
1379         return rank;
1380 }
1381
1382
1383 static Boolean
1384 rank_to_str(SCNetworkServicePrimaryRank rank, CFStringRef *rankStr)
1385 {
1386         switch (rank) {
1387                 case kSCNetworkServicePrimaryRankDefault :
1388                         *rankStr = NULL;
1389                         break;
1390                 case kSCNetworkServicePrimaryRankFirst :
1391                         *rankStr = kSCValNetServicePrimaryRankFirst;
1392                         break;
1393                 case kSCNetworkServicePrimaryRankLast :
1394                         *rankStr = kSCValNetServicePrimaryRankLast;
1395                         break;
1396                 case kSCNetworkServicePrimaryRankNever :
1397                         *rankStr = kSCValNetServicePrimaryRankNever;
1398                         break;
1399                 default :
1400                         return FALSE;
1401         }
1402
1403         return TRUE;
1404 }
1405
1406
1407 Boolean
1408 SCNetworkServiceSetPrimaryRank(SCNetworkServiceRef              service,
1409                                SCNetworkServicePrimaryRank      newRank)
1410 {
1411         Boolean                         ok;
1412         CFDictionaryRef                 entity;
1413         CFMutableDictionaryRef          newEntity;
1414         CFStringRef                     path            = NULL;
1415         CFStringRef                     rankStr         = NULL;
1416         SCNetworkServicePrivateRef      servicePrivate  = (SCNetworkServicePrivateRef)service;
1417
1418         if (!isA_SCNetworkService(service)) {
1419                 _SCErrorSet(kSCStatusInvalidArgument);
1420                 return FALSE;
1421         }
1422
1423         ok = rank_to_str(newRank, &rankStr);
1424         if (!ok) {
1425                 _SCErrorSet(kSCStatusInvalidArgument);
1426                 return FALSE;
1427         }
1428
1429         if (servicePrivate->prefs != NULL) {
1430                 if ((newRank == kSCNetworkServicePrimaryRankDefault) || (newRank == kSCNetworkServicePrimaryRankNever)) {
1431                         path = SCPreferencesPathKeyCreateNetworkServiceEntity(NULL,
1432                                                                               servicePrivate->serviceID,
1433                                                                               NULL);
1434                         entity = SCPreferencesPathGetValue(servicePrivate->prefs, path);
1435                         if (entity != NULL) {
1436                                 if (!isA_CFDictionary(entity)) {
1437                                         // if corrupt prefs
1438                                         _SCErrorSet(kSCStatusFailed);
1439                                         goto done;
1440                                 }
1441                                 newEntity = CFDictionaryCreateMutableCopy(NULL, 0, entity);
1442                         } else {
1443                                 newEntity = CFDictionaryCreateMutable(NULL,
1444                                                                       0,
1445                                                                       &kCFTypeDictionaryKeyCallBacks,
1446                                                                       &kCFTypeDictionaryValueCallBacks);
1447                         }
1448                         if (rankStr != NULL) {
1449                                 CFDictionarySetValue(newEntity, kSCPropNetServicePrimaryRank, rankStr);
1450                         } else {
1451                                 CFDictionaryRemoveValue(newEntity, kSCPropNetServicePrimaryRank);
1452                         }
1453                         if (CFDictionaryGetCount(newEntity) > 0) {
1454                                 ok = SCPreferencesPathSetValue(servicePrivate->prefs, path, newEntity);
1455                         } else {
1456                                 ok = SCPreferencesPathRemoveValue(servicePrivate->prefs, path);
1457                         }
1458                         CFRelease(newEntity);
1459                         if (!ok) {
1460                                 goto done;
1461                         }
1462                 } else {
1463                         _SCErrorSet(kSCStatusInvalidArgument);
1464                         return FALSE;
1465                 }
1466         } else if (servicePrivate->store != NULL) {
1467                 path = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
1468                                                                    kSCDynamicStoreDomainState,
1469                                                                    servicePrivate->serviceID,
1470                                                                    NULL);
1471                 entity = SCDynamicStoreCopyValue(servicePrivate->store, path);
1472                 if (entity != NULL) {
1473                         if (!isA_CFDictionary(entity)) {
1474                                 // if corrupt prefs
1475                                 CFRelease(entity);
1476                                 _SCErrorSet(kSCStatusFailed);
1477                                 goto done;
1478                         }
1479                         newEntity = CFDictionaryCreateMutableCopy(NULL, 0, entity);
1480                         CFRelease(entity);
1481                 } else {
1482                         newEntity = CFDictionaryCreateMutable(NULL,
1483                                                               0,
1484                                                               &kCFTypeDictionaryKeyCallBacks,
1485                                                               &kCFTypeDictionaryValueCallBacks);
1486                 }
1487                 if (rankStr != NULL) {
1488                         CFDictionarySetValue(newEntity, kSCPropNetServicePrimaryRank, rankStr);
1489                 } else {
1490                         CFDictionaryRemoveValue(newEntity, kSCPropNetServicePrimaryRank);
1491                 }
1492                 if (CFDictionaryGetCount(newEntity) > 0) {
1493                         ok = SCDynamicStoreSetValue(servicePrivate->store, path, newEntity);
1494                 } else {
1495                         ok = SCDynamicStoreRemoveValue(servicePrivate->store, path);
1496                 }
1497                 CFRelease(newEntity);
1498                 if (!ok) {
1499                         goto done;
1500                 }
1501         } else {
1502                 _SCErrorSet(kSCStatusInvalidArgument);
1503                 return FALSE;
1504         }
1505
1506     done :
1507
1508         if (path != NULL)       CFRelease(path);
1509         return ok;
1510 }