Plugins/IPMonitor/set-hostname.c

   1 /*
   2  * Copyright (c) 2004-2017 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 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <unistd.h>
  26 #include <sys/param.h>
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <sys/time.h>
  30 #include <net/if.h>
  31 #include <net/if_dl.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34 #include <netdb_async.h>
  35
  36 #include <CoreFoundation/CoreFoundation.h>
  37 #include <SystemConfiguration/SystemConfiguration.h>
  38 #include <SystemConfiguration/SCDynamicStoreCopyDHCPInfo.h>
  39 #include <SystemConfiguration/SCValidation.h>
  40 #include <SystemConfiguration/SCPrivate.h>
  41
  42 #include <notify.h>
  43
  44 #ifdef  MAIN
  45 #define my_log(__level, __format, ...)  SCPrint(TRUE, stdout, CFSTR(__format "\n"), ## __VA_ARGS__)
  46 #else   // MAIN
  47 #include "ip_plugin.h"
  48 #endif  // MAIN
  49
  50 static SCDynamicStoreRef        store           = NULL;
  51 static CFRunLoopRef             rl              = NULL;
  52 static CFRunLoopSourceRef       rls             = NULL;
  53 static dispatch_queue_t         queue           = NULL;
  54
  55 static int                      notify_token    = -1;
  56
  57 static struct timeval           ptrQueryStart;
  58 static SCNetworkReachabilityRef ptrTarget       = NULL;
  59
  60
  61 #define HOSTNAME_NOTIFY_KEY     "com.apple.system.hostname"
  62 #define SET_HOSTNAME_QUEUE      "com.apple.config.set-hostname"
  63
  64 CFStringRef copy_dhcp_hostname(CFStringRef serviceID);
  65
  66 static void
  67 set_hostname(CFStringRef hostname)
  68 {
  69         if (hostname != NULL) {
  70                 char    old_name[MAXHOSTNAMELEN];
  71                 char    new_name[MAXHOSTNAMELEN];
  72
  73                 if (gethostname(old_name, sizeof(old_name)) == -1) {
  74                         my_log(LOG_ERR, "gethostname() failed: %s", strerror(errno));
  75                         old_name[0] = '\0';
  76                 }
  77
  78                 if (_SC_cfstring_to_cstring(hostname,
  79                                             new_name,
  80                                             sizeof(new_name),
  81                                             kCFStringEncodingUTF8) == NULL) {
  82                         my_log(LOG_NOTICE, "could not convert [new] hostname");
  83                         new_name[0] = '\0';
  84                 }
  85
  86                 old_name[sizeof(old_name)-1] = '\0';
  87                 new_name[sizeof(new_name)-1] = '\0';
  88                 if (strcmp(old_name, new_name) != 0) {
  89                         if (sethostname(new_name, (int)strlen(new_name)) == 0) {
  90                                 uint32_t        status;
  91
  92                                 my_log(LOG_NOTICE,
  93                                        "setting hostname to \"%s\"",
  94                                        new_name);
  95
  96                                 status = notify_post(HOSTNAME_NOTIFY_KEY);
  97                                 if (status != NOTIFY_STATUS_OK) {
  98                                         my_log(LOG_ERR,
  99                                                "notify_post(" HOSTNAME_NOTIFY_KEY ") failed: error=%u",
 100                                                status);
 101                                 }
 102                         } else {
 103                                 my_log(LOG_ERR,
 104                                        "sethostname(%s, %ld) failed: %s",
 105                                        new_name,
 106                                        strlen(new_name),
 107                                        strerror(errno));
 108                         }
 109                 }
 110         }
 111
 112         return;
 113 }
 114
 115
 116 static CFStringRef
 117 copy_prefs_hostname(SCDynamicStoreRef store)
 118 {
 119         CFDictionaryRef         dict;
 120         CFStringRef             key;
 121         CFStringRef             name            = NULL;
 122
 123         key  = SCDynamicStoreKeyCreateComputerName(NULL);
 124         dict = SCDynamicStoreCopyValue(store, key);
 125         CFRelease(key);
 126         if (dict == NULL) {
 127                 goto done;
 128         }
 129         if (!isA_CFDictionary(dict)) {
 130                 goto done;
 131         }
 132
 133         name = isA_CFString(CFDictionaryGetValue(dict, kSCPropSystemHostName));
 134         if (name == NULL) {
 135                 goto done;
 136         }
 137         CFRetain(name);
 138
 139     done :
 140
 141         if (dict != NULL)       CFRelease(dict);
 142
 143         return name;
 144 }
 145
 146
 147 static CFStringRef
 148 copy_primary_service(SCDynamicStoreRef store)
 149 {
 150         CFDictionaryRef dict;
 151         CFStringRef     key;
 152         CFStringRef     serviceID       = NULL;
 153
 154         key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
 155                                                          kSCDynamicStoreDomainState,
 156                                                          kSCEntNetIPv4);
 157         dict = SCDynamicStoreCopyValue(store, key);
 158         CFRelease(key);
 159
 160         if (dict != NULL) {
 161                 if (isA_CFDictionary(dict)) {
 162                         serviceID = CFDictionaryGetValue(dict, kSCDynamicStorePropNetPrimaryService);
 163                         if (isA_CFString(serviceID)) {
 164                                 CFRetain(serviceID);
 165                         } else {
 166                                 serviceID = NULL;
 167                         }
 168                 }
 169                 CFRelease(dict);
 170         }
 171
 172         return serviceID;
 173 }
 174
 175
 176 static CFStringRef
 177 copy_primary_ip(SCDynamicStoreRef store, CFStringRef serviceID)
 178 {
 179         CFDictionaryRef dict;
 180         CFStringRef     key;
 181         CFStringRef     address = NULL;
 182
 183         key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
 184                                                           kSCDynamicStoreDomainState,
 185                                                           serviceID,
 186                                                           kSCEntNetIPv4);
 187         dict = SCDynamicStoreCopyValue(store, key);
 188         CFRelease(key);
 189
 190         if (dict != NULL) {
 191                 if (isA_CFDictionary(dict)) {
 192                         CFArrayRef      addresses;
 193
 194                         addresses = CFDictionaryGetValue(dict, kSCPropNetIPv4Addresses);
 195                         if (isA_CFArray(addresses) && (CFArrayGetCount(addresses) > 0)) {
 196                                 address = CFArrayGetValueAtIndex(addresses, 0);
 197                                 if (isA_CFString(address)) {
 198                                         CFRetain(address);
 199                                 } else {
 200                                         address = NULL;
 201                                 }
 202                         }
 203                 }
 204                 CFRelease(dict);
 205         }
 206
 207         return address;
 208 }
 209
 210
 211 static void
 212 ptr_query_stop()
 213 {
 214         if (ptrTarget == NULL) {
 215                 return;
 216         }
 217
 218         my_log(LOG_INFO, "hostname: ptr query stop");
 219
 220         SCNetworkReachabilitySetCallback(ptrTarget, NULL, NULL);
 221         SCNetworkReachabilityUnscheduleFromRunLoop(ptrTarget, rl, kCFRunLoopDefaultMode);
 222         CFRelease(ptrTarget);
 223         ptrTarget = NULL;
 224
 225         return;
 226 }
 227
 228
 229 /* Return a ptr record if the sharing pref name is a matching FQDN */
 230 static CFStringRef
 231 hostname_match_full(CFArrayRef hosts, CFIndex count, CFStringRef nameToMatch)
 232 {
 233         CFIndex         i;
 234         CFStringRef     matchedHostName = NULL;
 235
 236         for (i = 0; i < count; i++) {
 237                 CFStringRef tempHostName;
 238
 239                 tempHostName = CFArrayGetValueAtIndex(hosts, i);
 240                 if (CFStringCompare(tempHostName, nameToMatch, kCFCompareCaseInsensitive) == 0) {
 241                         matchedHostName = tempHostName;
 242                         break;
 243                 }
 244         }
 245         return matchedHostName;
 246 }
 247
 248
 249 /* Return a ptr record if the sharing pref name matches DNS record's first label */
 250 static CFStringRef
 251 hostname_match_first_label(CFArrayRef hosts, CFIndex count, CFStringRef nameToMatch)
 252 {
 253         CFIndex         i;
 254         CFStringRef     matchedHostName = NULL;
 255
 256         for (i = 0; i < count; i++) {
 257                 CFArrayRef      fqdnSeparated;
 258                 CFStringRef     tempHostName;
 259
 260                 tempHostName = CFArrayGetValueAtIndex(hosts, i);
 261                 fqdnSeparated = CFStringCreateArrayBySeparatingStrings(NULL, tempHostName, CFSTR("."));
 262                 if (fqdnSeparated != NULL) {
 263                         CFStringRef     firstLabel;
 264                         Boolean         matchFound;
 265
 266                         firstLabel = CFArrayGetValueAtIndex(fqdnSeparated, 0);
 267                         matchFound = (CFStringCompare(firstLabel, nameToMatch, kCFCompareCaseInsensitive) == 0);
 268                         CFRelease(fqdnSeparated);
 269                         if (matchFound) {
 270                                 matchedHostName = tempHostName;
 271                                 break;
 272                         }
 273                 }
 274         }
 275         return matchedHostName;
 276 }
 277
 278
 279 static void
 280 ptr_query_callback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info)
 281 {
 282 #pragma unused(info)
 283         CFStringRef             hostname        = NULL;
 284         struct timeval          ptrQueryComplete;
 285         struct timeval          ptrQueryElapsed;
 286
 287         (void) gettimeofday(&ptrQueryComplete, NULL);
 288         timersub(&ptrQueryComplete, &ptrQueryStart, &ptrQueryElapsed);
 289
 290         // use reverse DNS name, if available
 291
 292         if (flags & kSCNetworkReachabilityFlagsReachable) {
 293                 int             error_num;
 294                 CFArrayRef      hosts;
 295
 296                 /*
 297                  * if [reverse] DNS query was successful
 298                  */
 299                 hosts = SCNetworkReachabilityCopyResolvedAddress(target, &error_num);
 300                 if (hosts != NULL) {
 301                         CFIndex count = CFArrayGetCount(hosts);
 302                         if (count > 0) {
 303                                 CFStringRef     computerName;
 304                                 CFStringRef     localHostName;
 305
 306                                 my_log(LOG_INFO, "hostname: ptr query complete (query time = %ld.%3.3d)",
 307                                        ptrQueryElapsed.tv_sec,
 308                                        ptrQueryElapsed.tv_usec / 1000);
 309
 310                                 // first, check if ComputerName is dns-clean
 311                                 computerName = _SCPreferencesCopyComputerName(NULL, NULL);
 312                                 if (computerName != NULL) {
 313                                         if (_SC_CFStringIsValidDNSName(computerName)) {
 314                                                 CFRange dotsCheck;
 315
 316                                                 dotsCheck = CFStringFind(computerName, CFSTR("."), 0);
 317                                                 if (dotsCheck.length == 0) {
 318                                                         hostname = hostname_match_first_label(hosts, count, computerName);
 319                                                 } else {
 320                                                         hostname = hostname_match_full(hosts, count, computerName);
 321                                                 }
 322                                         }
 323                                         CFRelease(computerName);
 324                                 }
 325
 326                                 // if no match, check LocalHostName against the first label of FQDN
 327                                 localHostName = (hostname == NULL) ? SCDynamicStoreCopyLocalHostName(store) : NULL;
 328                                 if (localHostName != NULL) {
 329                                         hostname = hostname_match_first_label(hosts, count, localHostName);
 330                                         CFRelease(localHostName);
 331                                 }
 332
 333                                 // if no match, use the first of the returned names
 334                                 if (hostname == NULL) {
 335                                         hostname = CFArrayGetValueAtIndex(hosts, 0);
 336                                 }
 337
 338                                 my_log(LOG_INFO, "hostname (reverse DNS query) = %@", hostname);
 339                                 set_hostname(hostname);
 340                         } else {
 341                                 my_log(LOG_INFO, "hostname: ptr query complete w/no hosts (query time = %ld.%3.3d)",
 342                                        ptrQueryElapsed.tv_sec,
 343                                        ptrQueryElapsed.tv_usec / 1000);
 344                         }
 345                         CFRelease(hosts);
 346
 347                         if (hostname != NULL) {
 348                                 goto done;
 349                         }
 350                 } else {
 351                         // if kSCNetworkReachabilityFlagsReachable and hosts == NULL
 352                         // it means the PTR request has not come back yet
 353                         // we must wait for this callback to be called again
 354                         my_log(LOG_INFO, "hostname: ptr query reply w/no hosts (query time = %ld.%3.3d)",
 355                                ptrQueryElapsed.tv_sec,
 356                                ptrQueryElapsed.tv_usec / 1000);
 357                         return;
 358                 }
 359         } else {
 360                 my_log(LOG_INFO, "hostname: ptr query complete, host not found (query time = %ld.%3.3d)",
 361                        ptrQueryElapsed.tv_sec,
 362                        ptrQueryElapsed.tv_usec / 1000);
 363         }
 364
 365         // get local (multicast DNS) name, if available
 366
 367         hostname = SCDynamicStoreCopyLocalHostName(store);
 368         if (hostname != NULL) {
 369                 CFMutableStringRef      localHostName;
 370
 371                 my_log(LOG_INFO, "hostname (multicast DNS) = %@", hostname);
 372                 localHostName = CFStringCreateMutableCopy(NULL, 0, hostname);
 373                 assert(localHostName != NULL);
 374                 CFStringAppend(localHostName, CFSTR(".local"));
 375                 set_hostname(localHostName);
 376                 CFRelease(localHostName);
 377                 CFRelease(hostname);
 378                 goto done;
 379         }
 380
 381         // use "localhost" if not other name is available
 382
 383         my_log(LOG_INFO, "hostname (localhost)");
 384         set_hostname(CFSTR("localhost"));
 385
 386     done :
 387
 388         ptr_query_stop();
 389
 390 #ifdef  MAIN
 391         CFRunLoopStop(rl);
 392 #endif  // MAIN
 393
 394         return;
 395 }
 396
 397
 398 static Boolean
 399 ptr_query_start(CFStringRef address)
 400 {
 401         union {
 402                 struct sockaddr         sa;
 403                 struct sockaddr_in      sin;
 404                 struct sockaddr_in6     sin6;
 405         } addr;
 406         char                            buf[64];
 407         CFDataRef                       data;
 408         CFMutableDictionaryRef          options;
 409
 410         if (_SC_cfstring_to_cstring(address, buf, sizeof(buf), kCFStringEncodingASCII) == NULL) {
 411                 my_log(LOG_ERR, "could not convert [primary] address string");
 412                 return FALSE;
 413         }
 414
 415         if (_SC_string_to_sockaddr(buf, AF_UNSPEC, (void *)&addr, sizeof(addr)) == NULL) {
 416                 my_log(LOG_ERR, "could not convert [primary] address");
 417                 return FALSE;
 418         }
 419
 420         options = CFDictionaryCreateMutable(NULL,
 421                                             0,
 422                                             &kCFTypeDictionaryKeyCallBacks,
 423                                             &kCFTypeDictionaryValueCallBacks);
 424         data = CFDataCreate(NULL, (const UInt8 *)&addr.sa, addr.sa.sa_len);
 425         CFDictionarySetValue(options, kSCNetworkReachabilityOptionPTRAddress, data);
 426         CFRelease(data);
 427         ptrTarget = SCNetworkReachabilityCreateWithOptions(NULL, options);
 428         CFRelease(options);
 429         if (ptrTarget == NULL) {
 430                 my_log(LOG_ERR, "could not resolve [primary] address");
 431                 return FALSE;
 432         }
 433
 434         my_log(LOG_INFO, "hostname: ptr query start");
 435
 436         (void) SCNetworkReachabilitySetCallback(ptrTarget, ptr_query_callback, NULL);
 437         (void) SCNetworkReachabilityScheduleWithRunLoop(ptrTarget, rl, kCFRunLoopDefaultMode);
 438
 439         return TRUE;
 440 }
 441
 442
 443 static void
 444 update_hostname(SCDynamicStoreRef store, CFArrayRef changedKeys, void *info)
 445 {
 446 #pragma unused(changedKeys)
 447 #pragma unused(info)
 448         CFStringRef     address         = NULL;
 449         CFStringRef     hostname        = NULL;
 450         CFStringRef     serviceID       = NULL;
 451
 452         // if active, cancel any in-progress attempt to resolve the primary IP address
 453
 454         if (ptrTarget != NULL) {
 455                 ptr_query_stop();
 456         }
 457
 458         // get [prefs] hostname, if available
 459
 460         hostname = copy_prefs_hostname(store);
 461         if (hostname != NULL) {
 462                 my_log(LOG_INFO, "hostname (prefs) = %@", hostname);
 463                 set_hostname(hostname);
 464                 goto done;
 465         }
 466
 467         // get primary service ID
 468
 469         serviceID = copy_primary_service(store);
 470         if (serviceID == NULL) {
 471                 goto mDNS;
 472         }
 473
 474         // get DHCP provided name, if available
 475
 476         hostname = copy_dhcp_hostname(serviceID);
 477         if (hostname != NULL) {
 478                 my_log(LOG_INFO, "hostname (DHCP) = %@", hostname);
 479                 set_hostname(hostname);
 480                 goto done;
 481         }
 482
 483         // get DNS name associated with primary IP, if available
 484
 485         address = copy_primary_ip(store, serviceID);
 486         if (address != NULL) {
 487                 boolean_t       isExpensive;
 488
 489                 // start reverse DNS query using primary IP address
 490                 // if primary service is not expensive
 491                 isExpensive = check_if_service_expensive(serviceID);
 492                 if (!isExpensive) {
 493                         Boolean ok;
 494
 495                         ok = ptr_query_start(address);
 496                         if (ok) {
 497                                 // if query started
 498                                 goto done;
 499                         }
 500                 }
 501         }
 502
 503     mDNS :
 504
 505         // get local (multicast DNS) name, if available
 506
 507         hostname = SCDynamicStoreCopyLocalHostName(store);
 508         if (hostname != NULL) {
 509                 CFMutableStringRef      localHostName;
 510
 511                 my_log(LOG_INFO, "hostname (multicast DNS) = %@", hostname);
 512                 localHostName = CFStringCreateMutableCopy(NULL, 0, hostname);
 513                 assert(localHostName != NULL);
 514                 CFStringAppend(localHostName, CFSTR(".local"));
 515                 set_hostname(localHostName);
 516                 CFRelease(localHostName);
 517                 goto done;
 518         }
 519
 520         // use "localhost" if not other name is available
 521
 522         set_hostname(CFSTR("localhost"));
 523
 524     done :
 525
 526         if (address)    CFRelease(address);
 527         if (hostname)   CFRelease(hostname);
 528         if (serviceID)  CFRelease(serviceID);
 529
 530         return;
 531 }
 532
 533
 534 __private_extern__
 535 void
 536 load_hostname(Boolean verbose)
 537 {
 538 #pragma unused(verbose)
 539         CFStringRef             key;
 540         CFMutableArrayRef       keys            = NULL;
 541         dispatch_block_t        notify_block;
 542         Boolean                 ok;
 543         CFMutableArrayRef       patterns        = NULL;
 544         uint32_t                status;
 545
 546         /* initialize a few globals */
 547
 548         store = SCDynamicStoreCreate(NULL, CFSTR("set-hostname"), update_hostname, NULL);
 549         if (store == NULL) {
 550                 my_log(LOG_ERR,
 551                        "SCDynamicStoreCreate() failed: %s",
 552                        SCErrorString(SCError()));
 553                 goto error;
 554         }
 555
 556         queue = dispatch_queue_create(SET_HOSTNAME_QUEUE, NULL);
 557         if (queue == NULL) {
 558                 my_log(LOG_ERR,
 559                        "dispatch_queue_create() failed");
 560                 goto error;
 561         }
 562
 563         /* establish notification keys and patterns */
 564
 565         keys     = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 566         patterns = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
 567
 568         /* ...watch for (per-service) DHCP option changes */
 569         key = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
 570                                                           kSCDynamicStoreDomainState,
 571                                                           kSCCompAnyRegex,
 572                                                           kSCEntNetDHCP);
 573         CFArrayAppendValue(patterns, key);
 574         CFRelease(key);
 575
 576         /* ...watch for (BSD) hostname changes */
 577         key = SCDynamicStoreKeyCreateComputerName(NULL);
 578         CFArrayAppendValue(keys, key);
 579         CFRelease(key);
 580
 581         /* ...watch for local (multicast DNS) hostname changes */
 582         key = SCDynamicStoreKeyCreateHostNames(NULL);
 583         CFArrayAppendValue(keys, key);
 584         CFRelease(key);
 585
 586         /* register the keys/patterns */
 587         ok = SCDynamicStoreSetNotificationKeys(store, keys, patterns);
 588         CFRelease(keys);
 589         CFRelease(patterns);
 590         if (!ok) {
 591                 my_log(LOG_ERR,
 592                        "SCDynamicStoreSetNotificationKeys() failed: %s",
 593                        SCErrorString(SCError()));
 594                 goto error;
 595         }
 596
 597         rl = CFRunLoopGetCurrent();
 598         rls = SCDynamicStoreCreateRunLoopSource(NULL, store, 0);
 599         if (rls == NULL) {
 600                 my_log(LOG_ERR,
 601                        "SCDynamicStoreCreateRunLoopSource() failed: %s",
 602                        SCErrorString(SCError()));
 603                 goto error;
 604         }
 605         CFRunLoopAddSource(rl, rls, kCFRunLoopDefaultMode);
 606
 607         /* ...watch for primary service/interface and DNS configuration changes */
 608         notify_block = ^{
 609                 CFArrayRef      changes;
 610                 CFStringRef     key;
 611
 612                 key = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
 613                                                                  kSCDynamicStoreDomainState,
 614                                                                  kSCEntNetDNS);
 615                 changes = CFArrayCreate(NULL, (const void **)&key, 1, &kCFTypeArrayCallBacks);
 616                 (*update_hostname)(store, changes, NULL);
 617                 CFRelease(changes);
 618                 CFRelease(key);
 619
 620                 return;
 621         };
 622         status = notify_register_dispatch(_SC_NOTIFY_NETWORK_CHANGE,
 623                                           &notify_token,
 624                                           queue,
 625                                           ^(int token){
 626 #pragma unused(token)
 627                                                   CFRunLoopPerformBlock(rl,
 628                                                                         kCFRunLoopDefaultMode,
 629                                                                         notify_block);
 630                                                   CFRunLoopWakeUp(rl);
 631                                           });
 632         if (status != NOTIFY_STATUS_OK) {
 633                 my_log(LOG_ERR, "notify_register_dispatch() failed: %u", status);
 634                 goto error;
 635         }
 636
 637         return;
 638
 639     error :
 640
 641         if (rls != NULL) {
 642                 CFRunLoopRemoveSource(rl, rls, kCFRunLoopDefaultMode);
 643                 CFRelease(rls);
 644                 rls = NULL;
 645         }
 646         if (store != NULL) {
 647                 CFRelease(store);
 648                 store = NULL;
 649         }
 650         if (queue != NULL) {
 651                 dispatch_release(queue);
 652                 queue = NULL;
 653         }
 654
 655         return;
 656 }
 657
 658
 659 #ifdef  MAIN
 660 int
 661 main(int argc, char **argv)
 662 {
 663
 664 #ifdef  DEBUG
 665
 666         _sc_log = FALSE;
 667         if ((argc > 1) && (strcmp(argv[1], "-d") == 0)) {
 668                 _sc_verbose = TRUE;
 669                 argv++;
 670                 argc--;
 671         }
 672
 673         CFStringRef             address;
 674         CFStringRef             hostname;
 675         CFStringRef             serviceID;
 676         SCDynamicStoreRef       store;
 677
 678         store = SCDynamicStoreCreate(NULL, CFSTR("set-hostname"), NULL, NULL);
 679         if (store == NULL) {
 680                 SCPrint(TRUE, stdout,
 681                         CFSTR("SCDynamicStoreCreate() failed: %s\n"),
 682                         SCErrorString(SCError()));
 683                 exit(1);
 684         }
 685
 686         // get [prefs] hostname, if available
 687         hostname = copy_prefs_hostname(store);
 688         if (hostname != NULL) {
 689                 SCPrint(TRUE, stdout, CFSTR("hostname (prefs) = %@\n"), hostname);
 690                 CFRelease(hostname);
 691         }
 692
 693         // get local (multicast DNS) name, if available
 694
 695         hostname = SCDynamicStoreCopyLocalHostName(store);
 696         if (hostname != NULL) {
 697                 SCPrint(TRUE, stdout, CFSTR("hostname (multicast DNS) = %@\n"), hostname);
 698                 CFRelease(hostname);
 699         }
 700
 701         // get primary service
 702         serviceID = copy_primary_service(store);
 703         if (serviceID != NULL) {
 704                 SCPrint(TRUE, stdout, CFSTR("primary service ID = %@\n"), serviceID);
 705         } else {
 706                 SCPrint(TRUE, stdout, CFSTR("No primary service\n"));
 707         }
 708
 709         if ((argc == (2+1)) && (argv[1][0] == 's')) {
 710                 if (serviceID != NULL)  CFRelease(serviceID);
 711                 serviceID = CFStringCreateWithCString(NULL, argv[2], kCFStringEncodingUTF8);
 712                 SCPrint(TRUE, stdout, CFSTR("alternate service ID = %@\n"), serviceID);
 713         }
 714
 715         if (serviceID != NULL) {
 716                 // get DHCP provided name
 717                 hostname = copy_dhcp_hostname(serviceID);
 718                 if (hostname != NULL) {
 719                         SCPrint(TRUE, stdout, CFSTR("hostname (DHCP) = %@\n"), hostname);
 720                         CFRelease(hostname);
 721                 }
 722
 723                 // get primary IP address
 724                 address = copy_primary_ip(store, serviceID);
 725                 if (address != NULL) {
 726                         SCPrint(TRUE, stdout, CFSTR("primary address = %@\n"), address);
 727
 728                         if ((argc == (2+1)) && (argv[1][0] == 'a')) {
 729                                 if (address != NULL)    CFRelease(address);
 730                                 address = CFStringCreateWithCString(NULL, argv[2], kCFStringEncodingUTF8);
 731                                 SCPrint(TRUE, stdout, CFSTR("alternate primary address = %@\n"), address);
 732                         }
 733
 734                         // start reverse DNS query using primary IP address
 735                         (void) ptr_query_start(address);
 736                         CFRelease(address);
 737                 }
 738
 739                 CFRelease(serviceID);
 740         }
 741
 742         CFRelease(store);
 743
 744         CFRunLoopRun();
 745
 746 #else   /* DEBUG */
 747
 748         _sc_log     = FALSE;
 749         _sc_verbose = (argc > 1) ? TRUE : FALSE;
 750
 751         load_hostname((argc > 1) ? TRUE : FALSE);
 752         CFRunLoopRun();
 753         /* not reached */
 754
 755 #endif  /* DEBUG */
 756
 757         exit(0);
 758         return 0;
 759 }
 760 #endif  /* MAIN */