Plugins/IPMonitor/dns-configuration.c

   1 /*
   2  * Copyright (c) 2004 Apple Computer, 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  * March 22, 2004       Allan Nathanson <ajn@apple.com>
  28  * - initial revision
  29  */
  30
  31 #include <fcntl.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <sys/stat.h>
  38 #include <net/if.h>
  39 #include <netinet/in.h>
  40 #include <arpa/inet.h>
  41 #include <arpa/nameser.h>
  42 #include <resolv.h>
  43
  44 #include <CoreFoundation/CoreFoundation.h>
  45 #include <SystemConfiguration/SystemConfiguration.h>
  46 #include <SystemConfiguration/SCPrivate.h>
  47 #include <SystemConfiguration/SCValidation.h>
  48
  49 #include <dnsinfo.h>
  50 #include <dnsinfo_create.h>
  51
  52
  53 /* pre-defined (supplemental) resolver configurations */
  54 static  CFArrayRef      S_predefined  = NULL;
  55
  56
  57 static void
  58 add_supplemental(CFMutableArrayRef supplemental, CFDictionaryRef dns, uint32_t defaultOrder)
  59 {
  60         CFArrayRef      domains;
  61         CFIndex         i;
  62         CFIndex         n_domains;
  63         CFArrayRef      orders;
  64
  65
  66         domains = CFDictionaryGetValue(dns, kSCPropNetDNSSupplementalMatchDomains);
  67         n_domains = isA_CFArray(domains) ? CFArrayGetCount(domains) : 0;
  68         if (n_domains == 0) {
  69                 return;
  70         }
  71
  72         orders = CFDictionaryGetValue(dns, kSCPropNetDNSSupplementalMatchOrders);
  73         if (orders != NULL) {
  74                 if (!isA_CFArray(orders) || (n_domains != CFArrayGetCount(orders))) {
  75                         return;
  76                 }
  77         }
  78
  79         /*
  80          * yes, this is a "supplemental" resolver configuration, expand
  81          * the match domains and add each to the supplemental list.
  82          */
  83         for (i = 0; i < n_domains; i++) {
  84                 CFIndex                 j;
  85                 CFStringRef             match_domain;
  86                 CFNumberRef             match_order;
  87                 uint32_t                match_order_val = 0;
  88                 CFMutableDictionaryRef  match_resolver;
  89                 CFIndex                 n_supplemental;
  90
  91                 match_domain = CFArrayGetValueAtIndex(domains, i);
  92                 if (!isA_CFString(match_domain)) {
  93                         continue;
  94                 }
  95
  96                 match_order = (orders != NULL) ? CFArrayGetValueAtIndex(orders, i) : NULL;
  97
  98                 match_resolver = CFDictionaryCreateMutableCopy(NULL, 0, dns);
  99                 CFDictionaryRemoveValue(match_resolver, kSCPropNetDNSSupplementalMatchDomains);
 100                 CFDictionaryRemoveValue(match_resolver, kSCPropNetDNSSupplementalMatchOrders);
 101                 CFDictionaryRemoveValue(match_resolver, kSCPropNetDNSSearchDomains);
 102                 CFDictionarySetValue(match_resolver, kSCPropNetDNSDomainName, match_domain);
 103                 if (isA_CFNumber(match_order)) {
 104                         CFDictionarySetValue(match_resolver, kSCPropNetDNSSearchOrder, match_order);
 105                 } else if (!CFDictionaryContainsKey(match_resolver, kSCPropNetDNSSearchOrder)) {
 106                         CFNumberRef     num;
 107
 108                         num = CFNumberCreate(NULL, kCFNumberIntType, &defaultOrder);
 109                         CFDictionarySetValue(match_resolver, kSCPropNetDNSSearchOrder, num);
 110                         CFRelease(num);
 111
 112                         defaultOrder++;         // if multiple domains, maintain ordering
 113                 }
 114
 115                 match_order = CFDictionaryGetValue(match_resolver, kSCPropNetDNSSearchOrder);
 116                 if (!isA_CFNumber(match_order) ||
 117                     !CFNumberGetValue(match_order, kCFNumberIntType, &match_order_val)) {
 118                         match_order     = NULL;
 119                         match_order_val = 0;
 120                 }
 121
 122                 n_supplemental = CFArrayGetCount(supplemental);
 123                 for (j = 0; j < n_supplemental; j++) {
 124                         CFMutableDictionaryRef  compare;
 125                         Boolean                 match;
 126                         CFDictionaryRef         supplemental_resolver;
 127
 128                         supplemental_resolver = CFArrayGetValueAtIndex(supplemental, j);
 129                         if (CFEqual(match_resolver, supplemental_resolver)) {
 130                                 // a real duplicate
 131                                 CFRelease(match_resolver);
 132                                 match_resolver = NULL;
 133                                 break;
 134                         }
 135
 136                         compare = CFDictionaryCreateMutableCopy(NULL, 0, supplemental_resolver);
 137                         if (match_order != NULL) {
 138                                 CFDictionarySetValue(compare, kSCPropNetDNSSearchOrder, match_order);
 139                         }
 140                         match = CFEqual(match_resolver, compare);
 141                         CFRelease(compare);
 142
 143                         if (match) {
 144                                 CFNumberRef     supplemental_order;
 145                                 uint32_t        supplemental_order_val  = 0;
 146
 147                                 // if only the search order's are different
 148                                 supplemental_order = CFDictionaryGetValue(supplemental_resolver, kSCPropNetDNSSearchOrder);
 149                                 if (!isA_CFNumber(supplemental_order) ||
 150                                     !CFNumberGetValue(supplemental_order, kCFNumberIntType, &supplemental_order_val)) {
 151                                         supplemental_order_val = 0;
 152                                 }
 153
 154                                 if (match_order_val < supplemental_order_val ) {
 155                                         // if we should prefer this match resolver, else just skip it
 156                                         CFArraySetValueAtIndex(supplemental, j, match_resolver);
 157                                 }
 158
 159                                 CFRelease(match_resolver);
 160                                 match_resolver = NULL;
 161                                 break;
 162                         }
 163                 }
 164
 165                 if (match_resolver != NULL) {
 166                         CFArrayAppendValue(supplemental, match_resolver);
 167                         CFRelease(match_resolver);
 168                 }
 169         }
 170
 171         return;
 172 }
 173
 174
 175 static void
 176 add_predefined_resolvers(CFMutableArrayRef supplemental)
 177 {
 178         CFIndex i;
 179         CFIndex n;
 180
 181         if (S_predefined == NULL) {
 182                 return;
 183         }
 184
 185         n = CFArrayGetCount(S_predefined);
 186         for (i = 0; i < n; i++) {
 187                 uint32_t        defaultOrder;
 188                 CFDictionaryRef dns;
 189
 190                 dns = CFArrayGetValueAtIndex(S_predefined, i);
 191                 if (!isA_CFDictionary(dns)) {
 192                         continue;
 193                 }
 194
 195                 defaultOrder = DEFAULT_SEARCH_ORDER +
 196                                (DEFAULT_SEARCH_ORDER / 2) +
 197                                ((DEFAULT_SEARCH_ORDER / 1000) * i);
 198                 add_supplemental(supplemental, dns, defaultOrder);
 199         }
 200
 201         return;
 202 }
 203
 204
 205 #define N_QUICK 32
 206
 207
 208 static void
 209 add_supplemental_resolvers(CFMutableArrayRef supplemental, CFDictionaryRef services, CFArrayRef service_order)
 210 {
 211         const void *            keys_q[N_QUICK];
 212         const void **           keys    = keys_q;
 213         CFIndex                 i;
 214         CFIndex                 n_order;
 215         CFIndex                 n_services;
 216         const void *            vals_q[N_QUICK];
 217         const void **           vals    = vals_q;
 218
 219         n_services = isA_CFDictionary(services) ? CFDictionaryGetCount(services) : 0;
 220         if (n_services == 0) {
 221                 return;         // if no services
 222         }
 223
 224         if (n_services > (CFIndex)(sizeof(keys_q) / sizeof(CFTypeRef))) {
 225                 keys = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
 226                 vals = CFAllocatorAllocate(NULL, n_services * sizeof(CFTypeRef), 0);
 227         }
 228
 229         n_order = isA_CFArray(service_order) ? CFArrayGetCount(service_order) : 0;
 230
 231         CFDictionaryGetKeysAndValues(services, keys, vals);
 232         for (i = 0; i < n_services; i++) {
 233                 uint32_t        defaultOrder;
 234                 CFDictionaryRef dns;
 235                 CFDictionaryRef service = (CFDictionaryRef)vals[i];
 236
 237                 if (!isA_CFDictionary(service)) {
 238                         continue;
 239                 }
 240
 241                 dns = CFDictionaryGetValue(service, kSCEntNetDNS);
 242                 if (!isA_CFDictionary(dns)) {
 243                         continue;
 244                 }
 245
 246                 defaultOrder = DEFAULT_SEARCH_ORDER -
 247                                (DEFAULT_SEARCH_ORDER / 2) +
 248                                ((DEFAULT_SEARCH_ORDER / 1000) * i);
 249                 if ((n_order > 0) &&
 250                     !CFArrayContainsValue(service_order, CFRangeMake(0, n_order), keys[i])) {
 251                         // push out services not specified in service order
 252                         defaultOrder += (DEFAULT_SEARCH_ORDER / 1000) * n_services;
 253                 }
 254
 255                 add_supplemental(supplemental, dns, defaultOrder);
 256         }
 257
 258         if (keys != keys_q) {
 259                 CFAllocatorDeallocate(NULL, keys);
 260                 CFAllocatorDeallocate(NULL, vals);
 261         }
 262
 263         return;
 264 }
 265
 266
 267 static CFComparisonResult
 268 compareBySearchOrder(const void *val1, const void *val2, void *context)
 269 {
 270         CFDictionaryRef dns1    = (CFDictionaryRef)val1;
 271         CFDictionaryRef dns2    = (CFDictionaryRef)val2;
 272         CFNumberRef     num;
 273         uint32_t        order1  = DEFAULT_SEARCH_ORDER;
 274         uint32_t        order2  = DEFAULT_SEARCH_ORDER;
 275
 276         num = CFDictionaryGetValue(dns1, kSCPropNetDNSSearchOrder);
 277         if (!isA_CFNumber(num) ||
 278             !CFNumberGetValue(num, kCFNumberIntType, &order1)) {
 279                 order1 = DEFAULT_SEARCH_ORDER;
 280         }
 281
 282         num = CFDictionaryGetValue(dns2, kSCPropNetDNSSearchOrder);
 283         if (!isA_CFNumber(num) ||
 284             !CFNumberGetValue(num, kCFNumberIntType, &order2)) {
 285                 order2 = DEFAULT_SEARCH_ORDER;
 286         }
 287
 288         if (order1 == order2) {
 289                 return kCFCompareEqualTo;
 290         }
 291
 292         return (order1 < order2) ? kCFCompareLessThan : kCFCompareGreaterThan;
 293 }
 294
 295
 296 static CFStringRef
 297 trimDomain(CFStringRef domain)
 298 {
 299         CFIndex length;
 300         CFRange range;
 301         Boolean trimmed = FALSE;
 302
 303         if (!isA_CFString(domain)) {
 304                 return NULL;
 305         }
 306
 307         // remove trailing dots
 308         length = CFStringGetLength(domain);
 309         while (CFStringFindWithOptions(domain,
 310                                        CFSTR("."),
 311                                        CFRangeMake(0, length),
 312                                        kCFCompareAnchored|kCFCompareBackwards,
 313                                        &range)) {
 314                 trimmed = TRUE;
 315                 length = range.location;
 316         }
 317
 318         if (length == 0) {
 319                 return NULL;
 320         }
 321
 322         if (trimmed) {
 323                 domain = CFStringCreateWithSubstring(NULL, domain, CFRangeMake(0, length));
 324         } else {
 325                 CFRetain(domain);
 326         }
 327
 328         return domain;
 329 }
 330
 331
 332 static void
 333 update_search_domains(CFMutableDictionaryRef *defaultDomain, CFArrayRef supplemental)
 334 {
 335         CFStringRef             defaultDomainName       = NULL;
 336         uint32_t                defaultOrder            = DEFAULT_SEARCH_ORDER;
 337         CFArrayRef              defaultSearchDomains    = NULL;
 338         CFIndex                 defaultSearchIndex      = 0;
 339         CFIndex                 i;
 340         CFMutableArrayRef       mySearchDomains;
 341         CFMutableArrayRef       mySupplemental          = (CFMutableArrayRef)supplemental;
 342         CFIndex                 n_supplemental;
 343         Boolean                 searchDomainAdded       = FALSE;
 344
 345         n_supplemental = CFArrayGetCount(supplemental);
 346         if (n_supplemental == 0) {
 347                 // if no supplemental domains
 348                 return;
 349         }
 350
 351         if (*defaultDomain != NULL) {
 352                 CFNumberRef     num;
 353
 354                 num = CFDictionaryGetValue(*defaultDomain, kSCPropNetDNSSearchOrder);
 355                 if (!isA_CFNumber(num) ||
 356                     !CFNumberGetValue(num, kCFNumberIntType, &defaultOrder)) {
 357                         defaultOrder = DEFAULT_SEARCH_ORDER;
 358                 }
 359
 360                 defaultDomainName    = CFDictionaryGetValue(*defaultDomain, kSCPropNetDNSDomainName);
 361                 defaultSearchDomains = CFDictionaryGetValue(*defaultDomain, kSCPropNetDNSSearchDomains);
 362         }
 363
 364         mySearchDomains = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 365
 366         if (isA_CFArray(defaultSearchDomains)) {
 367                 CFIndex n_search;
 368
 369                 n_search = CFArrayGetCount(defaultSearchDomains);
 370                 for (i = 0; i < n_search; i++) {
 371                         CFStringRef     search;
 372
 373                         search = CFArrayGetValueAtIndex(defaultSearchDomains, i);
 374                         search = trimDomain(search);
 375                         if (search != NULL) {
 376                                 CFArrayAppendValue(mySearchDomains, search);
 377                                 CFRelease(search);
 378                         }
 379                 }
 380         } else {
 381                 defaultDomainName = trimDomain(defaultDomainName);
 382                 if (defaultDomainName != NULL) {
 383                         char    *domain;
 384                         int     domain_parts    = 1;
 385                         char    *dp;
 386
 387                         domain = _SC_cfstring_to_cstring(defaultDomainName,
 388                                                          NULL,
 389                                                          0,
 390                                                          kCFStringEncodingUTF8);
 391                         CFRelease(defaultDomainName);
 392
 393                         // count domain parts
 394                         for (dp = domain; *dp != '\0'; dp++) {
 395                                 if (*dp == '.') {
 396                                         domain_parts++;
 397                                 }
 398                         }
 399
 400                         dp = domain;
 401                         for (i = LOCALDOMAINPARTS; i <= domain_parts; i++) {
 402                                 CFStringRef     search;
 403
 404                                 search = CFStringCreateWithCString(NULL,
 405                                                                    dp,
 406                                                                    kCFStringEncodingUTF8);
 407                                 CFArrayAppendValue(mySearchDomains, search);
 408                                 CFRelease(search);
 409
 410                                 dp = strchr(dp, '.') + 1;
 411                         }
 412
 413                         CFAllocatorDeallocate(NULL, domain);
 414                 }
 415         }
 416
 417         if (n_supplemental > 1) {
 418                 mySupplemental = CFArrayCreateMutableCopy(NULL, 0, supplemental);
 419                 CFArraySortValues(mySupplemental,
 420                                   CFRangeMake(0, n_supplemental),
 421                                   compareBySearchOrder,
 422                                   NULL);
 423         }
 424
 425         for (i = 0; i < n_supplemental; i++) {
 426                 CFDictionaryRef dns;
 427                 CFIndex         domainIndex;
 428                 CFNumberRef     num;
 429                 CFStringRef     supplementalDomain;
 430                 uint32_t        supplementalOrder;
 431
 432                 dns = CFArrayGetValueAtIndex(mySupplemental, i);
 433
 434                 supplementalDomain = CFDictionaryGetValue(dns, kSCPropNetDNSDomainName);
 435                 supplementalDomain = trimDomain(supplementalDomain);
 436                 if (supplementalDomain == NULL) {
 437                         continue;
 438                 }
 439
 440                 if (CFStringHasSuffix(supplementalDomain, CFSTR(".in-addr.arpa")) ||
 441                     CFStringHasSuffix(supplementalDomain, CFSTR(".ip6.arpa"    ))) {
 442                         CFRelease(supplementalDomain);
 443                         continue;
 444                 }
 445
 446                 domainIndex = CFArrayGetFirstIndexOfValue(mySearchDomains,
 447                                                           CFRangeMake(0, CFArrayGetCount(mySearchDomains)),
 448                                                           supplementalDomain);
 449
 450                 num = CFDictionaryGetValue(dns, kSCPropNetDNSSearchOrder);
 451                 if (!isA_CFNumber(num) ||
 452                     !CFNumberGetValue(num, kCFNumberIntType, &supplementalOrder)) {
 453                         supplementalOrder = DEFAULT_SEARCH_ORDER;
 454                 }
 455
 456                 if (supplementalOrder < defaultOrder) {
 457                         if (domainIndex != kCFNotFound) {
 458                                 // if supplemental domain is already in the search list
 459                                 CFArrayRemoveValueAtIndex(mySearchDomains, domainIndex);
 460                                 if (domainIndex < defaultSearchIndex) {
 461                                         defaultSearchIndex--;
 462                                 }
 463                         }
 464                         CFArrayInsertValueAtIndex(mySearchDomains,
 465                                                   defaultSearchIndex,
 466                                                   supplementalDomain);
 467                         defaultSearchIndex++;
 468                         searchDomainAdded = TRUE;
 469                 } else {
 470                         if (domainIndex == kCFNotFound) {
 471                                 // add to the (end of the) search list
 472                                 CFArrayAppendValue(mySearchDomains, supplementalDomain);
 473                                 searchDomainAdded = TRUE;
 474                         }
 475                 }
 476
 477                 CFRelease(supplementalDomain);
 478         }
 479
 480         if (searchDomainAdded) {
 481                 if (*defaultDomain == NULL) {
 482                         *defaultDomain = CFDictionaryCreateMutable(NULL,
 483                                                                    0,
 484                                                                    &kCFTypeDictionaryKeyCallBacks,
 485                                                                    &kCFTypeDictionaryValueCallBacks);
 486                 }
 487                 CFDictionarySetValue(*defaultDomain, kSCPropNetDNSSearchDomains, mySearchDomains);
 488         }
 489
 490         CFRelease(mySearchDomains);
 491         if (mySupplemental != supplemental) CFRelease(mySupplemental);
 492         return;
 493 }
 494
 495
 496 static dns_create_resolver_t
 497 create_resolver(CFDictionaryRef dns)
 498 {
 499         CFArrayRef              list;
 500         CFNumberRef             num;
 501         dns_create_resolver_t   _resolver;
 502         CFStringRef             str;
 503
 504         _resolver = _dns_resolver_create();
 505
 506         // process domain
 507         str = CFDictionaryGetValue(dns, kSCPropNetDNSDomainName);
 508         if (isA_CFString(str)) {
 509                 char    domain[NS_MAXDNAME];
 510
 511                 if (_SC_cfstring_to_cstring(str, domain, sizeof(domain), kCFStringEncodingUTF8) != NULL) {
 512                         _dns_resolver_set_domain(&_resolver, domain);
 513                 }
 514         }
 515
 516         // process search domains
 517         list = CFDictionaryGetValue(dns, kSCPropNetDNSSearchDomains);
 518         if (isA_CFArray(list)) {
 519                 CFIndex i;
 520                 CFIndex n       = CFArrayGetCount(list);
 521
 522                 // add "search" domains
 523                 for (i = 0; i < n; i++) {
 524                         str = CFArrayGetValueAtIndex(list, i);
 525                         if (isA_CFString(str)) {
 526                                 char    search[NS_MAXDNAME];
 527
 528                                 if (_SC_cfstring_to_cstring(str, search, sizeof(search), kCFStringEncodingUTF8) != NULL) {
 529                                         _dns_resolver_add_search(&_resolver, search);
 530                                 }
 531                         }
 532                 }
 533         }
 534
 535         // process nameserver addresses
 536         list = CFDictionaryGetValue(dns, kSCPropNetDNSServerAddresses);
 537         if (isA_CFArray(list)) {
 538                 CFIndex i;
 539                 CFIndex n       = CFArrayGetCount(list);
 540
 541                 for (i = 0; i < n; i++) {
 542                         union {
 543                                 struct sockaddr         sa;
 544                                 struct sockaddr_in      sin;
 545                                 struct sockaddr_in6     sin6;
 546                         } addr;
 547                         char    buf[128];
 548
 549                         str = CFArrayGetValueAtIndex(list, i);
 550                         if (!isA_CFString(str)) {
 551                                 continue;
 552                         }
 553
 554                         if (_SC_cfstring_to_cstring(str, buf, sizeof(buf), kCFStringEncodingASCII) == NULL) {
 555                                 continue;
 556                         }
 557
 558                         bzero(&addr, sizeof(addr));
 559                         if (inet_aton(buf, &addr.sin.sin_addr) == 1) {
 560                                 /* if IPv4 address */
 561                                 addr.sin.sin_len    = sizeof(addr.sin);
 562                                 addr.sin.sin_family = AF_INET;
 563                                 _dns_resolver_add_nameserver(&_resolver, &addr.sa);
 564                         } else if (inet_pton(AF_INET6, buf, &addr.sin6.sin6_addr) == 1) {
 565                                 /* if IPv6 address */
 566                                 char    *p;
 567
 568                                 p = strchr(buf, '%');
 569                                 if (p != NULL) {
 570                                         addr.sin6.sin6_scope_id = if_nametoindex(p + 1);
 571                                 }
 572
 573                                 addr.sin6.sin6_len    = sizeof(addr.sin6);
 574                                 addr.sin6.sin6_family = AF_INET6;
 575                                 _dns_resolver_add_nameserver(&_resolver, &addr.sa);
 576                         } else {
 577                                 continue;
 578                         }
 579                 }
 580         }
 581
 582         // process search order
 583         num = CFDictionaryGetValue(dns, kSCPropNetDNSSearchOrder);
 584         if (isA_CFNumber(num)) {
 585                 uint32_t        order;
 586
 587                 if (CFNumberGetValue(num, kCFNumberIntType, &order)) {
 588                         _dns_resolver_set_order(&_resolver, order);
 589                 }
 590         }
 591
 592         // process port
 593         num = CFDictionaryGetValue(dns, kSCPropNetDNSServerPort);
 594         if (isA_CFNumber(num)) {
 595                 int     port;
 596
 597                 if (CFNumberGetValue(num, kCFNumberIntType, &port)) {
 598                         _dns_resolver_set_port(&_resolver, (uint16_t)port);
 599                 }
 600         }
 601
 602         // process timeout
 603         num = CFDictionaryGetValue(dns, kSCPropNetDNSServerTimeout);
 604         if (isA_CFNumber(num)) {
 605                 int     timeout;
 606
 607                 if (CFNumberGetValue(num, kCFNumberIntType, &timeout)) {
 608                         _dns_resolver_set_timeout(&_resolver, (uint32_t)timeout);
 609                 }
 610         }
 611
 612         // process options
 613         str = CFDictionaryGetValue(dns, kSCPropNetDNSOptions);
 614         if (isA_CFString(str)) {
 615                 char    *options;
 616
 617                 options = _SC_cfstring_to_cstring(str, NULL, 0, kCFStringEncodingUTF8);
 618                 if (options != NULL) {
 619                         _dns_resolver_set_options(&_resolver, options);
 620                         CFAllocatorDeallocate(NULL, options);
 621                 }
 622         }
 623
 624         return _resolver;
 625 }
 626
 627
 628 __private_extern__
 629 void
 630 dns_configuration_set(CFDictionaryRef   defaultResolver,
 631                       CFDictionaryRef   services,
 632                       CFArrayRef        serviceOrder)
 633 {
 634         CFIndex                 i;
 635         CFMutableDictionaryRef  myDefault;
 636         CFStringRef             myDomain        = NULL;
 637         uint32_t                myOrder         = DEFAULT_SEARCH_ORDER;
 638         Boolean                 myOrderAdded    = FALSE;
 639         CFIndex                 n_supplemental;
 640         CFNumberRef             order;
 641         dns_create_resolver_t   resolver;
 642         CFArrayRef              search;
 643         CFMutableArrayRef       supplemental;
 644
 645         if (defaultResolver == NULL) {
 646                 myDefault = CFDictionaryCreateMutable(NULL,
 647                                                       0,
 648                                                       &kCFTypeDictionaryKeyCallBacks,
 649                                                       &kCFTypeDictionaryValueCallBacks);
 650         } else {
 651                 myDefault = CFDictionaryCreateMutableCopy(NULL, 0, defaultResolver);
 652
 653                 // ensure that the default resolver has a search order
 654
 655                 order = CFDictionaryGetValue(myDefault, kSCPropNetDNSSearchOrder);
 656                 if (!isA_CFNumber(order) ||
 657                     !CFNumberGetValue(order, kCFNumberIntType, &myOrder)) {
 658                         myOrderAdded = TRUE;
 659                         myOrder = DEFAULT_SEARCH_ORDER;
 660                         order = CFNumberCreate(NULL, kCFNumberIntType, &myOrder);
 661                         CFDictionarySetValue(myDefault, kSCPropNetDNSSearchOrder, order);
 662                         CFRelease(order);
 663                 }
 664         }
 665
 666         // establish list of supplemental resolvers
 667
 668         supplemental = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 669
 670         // identify search[] list and/or domain name
 671
 672         search = CFDictionaryGetValue(myDefault, kSCPropNetDNSSearchDomains);
 673         if (isA_CFArray(search) && (CFArrayGetCount(search) > 0)) {
 674                 myDomain = CFArrayGetValueAtIndex(search, 0);
 675                 myDomain = isA_CFString(myDomain);
 676         }
 677
 678         if (myDomain == NULL) {
 679                 myDomain = CFDictionaryGetValue(myDefault, kSCPropNetDNSDomainName);
 680                 myDomain = isA_CFString(myDomain);
 681         }
 682
 683         // add match for default domain
 684
 685         if (myDomain != NULL) {
 686                 CFMutableDictionaryRef  mySupplemental;
 687
 688                 mySupplemental = CFDictionaryCreateMutableCopy(NULL, 0, myDefault);
 689                 CFDictionarySetValue   (mySupplemental, kSCPropNetDNSDomainName, myDomain);
 690                 CFDictionaryRemoveValue(mySupplemental, kSCPropNetDNSSearchDomains);
 691                 CFDictionaryRemoveValue(mySupplemental, kSCPropNetDNSSupplementalMatchDomains);
 692                 CFDictionaryRemoveValue(mySupplemental, kSCPropNetDNSSupplementalMatchOrders);
 693                 CFArrayAppendValue(supplemental, mySupplemental);
 694                 CFRelease(mySupplemental);
 695         }
 696
 697         // collect (and add) any supplemental resolver configurations
 698
 699         add_supplemental_resolvers(supplemental, services, serviceOrder);
 700
 701         // update the "search" list
 702
 703         update_search_domains(&myDefault, supplemental);
 704
 705         // add any pre-defined resolver configurations
 706
 707         add_predefined_resolvers(supplemental);
 708
 709         // check if the "match for default domain" (above) is really needed
 710
 711         if (myDomain != NULL) {
 712                 Boolean sharedDomain    = FALSE;
 713
 714                 n_supplemental = CFArrayGetCount(supplemental);
 715                 for (i = 1; i < n_supplemental; i++) {
 716                         CFStringRef     domain;
 717                         CFDictionaryRef mySupplemental;
 718
 719                         mySupplemental = CFArrayGetValueAtIndex(supplemental, i);
 720                         domain = CFDictionaryGetValue(mySupplemental, kSCPropNetDNSDomainName);
 721                         if (isA_CFString(domain)) {
 722                                 if (CFEqual(myDomain, domain)) {
 723                                         sharedDomain = TRUE;
 724                                         break;
 725                                 }
 726
 727                                 if (CFStringHasSuffix(myDomain, domain)) {
 728                                         CFIndex dotIndex;
 729
 730                                         dotIndex = CFStringGetLength(myDomain) - CFStringGetLength(domain) - 1;
 731                                         if (dotIndex > 0) {
 732                                                 UniChar dot;
 733
 734                                                 dot = CFStringGetCharacterAtIndex(myDomain, dotIndex);
 735                                                 if (dot == (UniChar)'.') {
 736                                                         sharedDomain = TRUE;
 737                                                         break;
 738                                                 }
 739                                         }
 740                                 }
 741                         }
 742                 }
 743
 744                 if (!sharedDomain) {
 745                         // if the default resolver domain name is not shared
 746                         CFArrayRemoveValueAtIndex(supplemental, 0);
 747                 }
 748         }
 749
 750         // establish resolver configuration
 751
 752         n_supplemental = CFArrayGetCount(supplemental);
 753         if ((defaultResolver == NULL) && (n_supplemental == 0)) {
 754                 /*
 755                  * if no default or supplemental resolvers
 756                  */
 757                 if (!_dns_configuration_store(NULL)) {
 758                         SCLog(TRUE, LOG_ERR, CFSTR("set_dns_configuration: could not store configuration"));
 759                 }
 760         } else {
 761                 dns_create_config_t     _config;
 762
 763                 /*
 764                  * if default and/or supplemental resolvers are defined
 765                  */
 766                 _config = _dns_configuration_create();
 767
 768                 // add [default] resolver
 769
 770                 if ((n_supplemental == 0) && myOrderAdded) {
 771                         CFDictionaryRemoveValue(myDefault, kSCPropNetDNSSearchOrder);
 772                 }
 773                 resolver = create_resolver(myDefault);
 774                 _dns_configuration_add_resolver(&_config, resolver);
 775                 _dns_resolver_free(&resolver);
 776
 777                 // add [supplemental] resolvers
 778
 779                 for (i = 0; i < n_supplemental; i++) {
 780                         CFDictionaryRef supplementalResolver;
 781
 782                         supplementalResolver = CFArrayGetValueAtIndex(supplemental, i);
 783                         resolver = create_resolver(supplementalResolver);
 784                         _dns_configuration_add_resolver(&_config, resolver);
 785                         _dns_resolver_free(&resolver);
 786                 }
 787
 788                 // save configuration
 789
 790                 if (!_dns_configuration_store(&_config)) {
 791                         SCLog(TRUE, LOG_ERR, CFSTR("set_dns_configuration() failed: could not store configuration"));
 792                 }
 793
 794                 _dns_configuration_free(&_config);
 795         }
 796
 797         CFRelease(myDefault);
 798         CFRelease(supplemental);
 799
 800         return;
 801 }
 802
 803
 804 static void
 805 load_predefined_resolvers(CFBundleRef bundle)
 806 {
 807         Boolean                 ok;
 808         CFURLRef                url;
 809         CFStringRef             xmlError        = NULL;
 810         CFDataRef               xmlResolvers    = NULL;
 811
 812         url = CFBundleCopyResourceURL(bundle, CFSTR("Resolvers"), CFSTR("plist"), NULL);
 813         if (url == NULL) {
 814                 return;
 815         }
 816
 817         ok = CFURLCreateDataAndPropertiesFromResource(NULL, url, &xmlResolvers, NULL, NULL, NULL);
 818         CFRelease(url);
 819         if (!ok || (xmlResolvers == NULL)) {
 820                 return;
 821         }
 822
 823         /* convert the XML data into a property list */
 824         S_predefined = CFPropertyListCreateFromXMLData(NULL, xmlResolvers, kCFPropertyListImmutable, &xmlError);
 825         CFRelease(xmlResolvers);
 826         if (S_predefined == NULL) {
 827                 if (xmlError != NULL) {
 828                         SCLog(TRUE, LOG_DEBUG, CFSTR("add_predefined_resolvers: %@"), xmlError);
 829                         CFRelease(xmlError);
 830                 }
 831                 return;
 832         }
 833
 834         if (!isA_CFArray(S_predefined)) {
 835                 CFRelease(S_predefined);
 836                 S_predefined = NULL;
 837                 return;
 838         }
 839
 840         return;
 841 }
 842
 843
 844 __private_extern__
 845 void
 846 dns_configuration_init(CFBundleRef bundle)
 847 {
 848         load_predefined_resolvers(bundle);
 849         return;
 850 }
 851