mDNSWindows/DNSServices/DNSServiceDiscovery.c

   1 /*
   2  * Copyright (c) 2002-2003 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  24
  25     Change History (most recent first):
  26
  27 $Log: DNSServiceDiscovery.c,v $
  28 Revision 1.2  2003/08/20 07:06:34  bradley
  29 Update to APSL 2.0. Updated change history to match other mDNSResponder files.
  30
  31 Revision 1.1  2003/08/20 06:04:45  bradley
  32 Platform-neutral DNSServices-based emulation layer for the Mac OS X DNSServiceDiscovery API.
  33
  34 */
  35
  36 #include        <stddef.h>
  37 #include        <stdlib.h>
  38 #include        <string.h>
  39
  40 #if( macintosh || __MACH__ )
  41
  42         #include        <sys/types.h>
  43         #include        <sys/socket.h>
  44         #include        <netinet/in.h>
  45
  46 #elif( defined( _MSC_VER ) || defined( __MWERKS__ ) )
  47
  48         #pragma warning( disable:4054 )         // Disable "type cast : from function pointer to data pointer".
  49         #pragma warning( disable:4055 )         // Disable "type cast : from data pointer to function pointer".
  50         #pragma warning( disable:4127 )         // Disable "conditional expression is constant" warning for debug macros.
  51         #pragma warning( disable:4152 )         // Disable "nonstandard extension, function/data pointer conversion in expression".
  52
  53         #define WIN32_LEAN_AND_MEAN                     // Needed to avoid redefinitions by Windows interfaces.
  54
  55         #include        <winsock2.h>
  56
  57 #endif
  58
  59 #include        "mDNSClientAPI.h"
  60 #include        "mDNSPlatformFunctions.h"
  61 #include        "DNSServices.h"
  62
  63 #include        "DNSServiceDiscovery.h"
  64
  65 #ifdef  __cplusplus
  66         extern "C" {
  67 #endif
  68
  69 #if 0
  70 #pragma mark == Constants & Types ==
  71 #endif
  72
  73 //===========================================================================================================================
  74 //      Constants & Types
  75 //===========================================================================================================================
  76
  77 #define DEBUG_NAME              "[DNSServiceDiscovery] "
  78
  79 typedef enum
  80 {
  81         kDNSServiceDiscoveryObjectTypeRegistration                      = 1,
  82         kDNSServiceDiscoveryObjectTypeDomainEnumeration         = 2,
  83         kDNSServiceDiscoveryObjectTypeBrowser                           = 3,
  84         kDNSServiceDiscoveryObjectTypeResolver                          = 4
  85
  86 }       DNSServiceDiscoveryObjectType;
  87
  88 typedef struct _dns_service_discovery_t         _dns_service_discovery_t;
  89 struct  _dns_service_discovery_t
  90 {
  91         DNSServiceDiscoveryObjectType           type;
  92         void *                                                          ref;
  93         void *                                                          callback;
  94         void *                                                          context;
  95 };
  96
  97 #if 0
  98 #pragma mark == Macros ==
  99 #endif
 100
 101 //===========================================================================================================================
 102 //      Macros
 103 //===========================================================================================================================
 104
 105 // Emulate Mac OS debugging macros for non-Mac platforms.
 106
 107 #if( !TARGET_OS_MAC )
 108         #define check(assertion)
 109         #define check_string( assertion, cstring )
 110         #define check_noerr(err)
 111         #define check_noerr_string( error, cstring )
 112         #define debug_string( cstring )
 113         #define require( assertion, label )                                                                     do { if( !(assertion) ) goto label; } while(0)
 114         #define require_string( assertion, label, string )                                      require(assertion, label)
 115         #define require_quiet( assertion, label )                                                       require( assertion, label )
 116         #define require_noerr( error, label )                                                           do { if( (error) != 0 ) goto label; } while(0)
 117         #define require_noerr_quiet( assertion, label )                                         require_noerr( assertion, label )
 118         #define require_noerr_action( error, label, action )                            do { if( (error) != 0 ) { {action;}; goto label; } } while(0)
 119         #define require_noerr_action_quiet( assertion, label, action )          require_noerr_action( assertion, label, action )
 120         #define require_action( assertion, label, action )                                      do { if( !(assertion) ) { {action;}; goto label; } } while(0)
 121         #define require_action_quiet( assertion, label, action )                        require_action( assertion, label, action )
 122         #define require_action_string( assertion, label, action, cstring )      do { if( !(assertion) ) { {action;}; goto label; } } while(0)
 123 #endif
 124
 125 #if 0
 126 #pragma mark == Prototypes ==
 127 #endif
 128
 129 //===========================================================================================================================
 130 //      Prototypes
 131 //===========================================================================================================================
 132
 133 DNS_LOCAL void
 134         DNSServiceRegistrationPrivateCallBack(
 135                 void *                                                  inContext,
 136                 DNSRegistrationRef                              inRef,
 137                 DNSStatus                                               inStatusCode,
 138                 const DNSRegistrationEvent *    inEvent );
 139
 140 DNS_LOCAL void
 141         DNSServiceDomainEnumerationPrivateCallBack(
 142                 void *                                  inContext,
 143                 DNSBrowserRef                   inRef,
 144                 DNSStatus                               inStatusCode,
 145                 const DNSBrowserEvent * inEvent );
 146
 147 DNS_LOCAL void
 148         DNSServiceBrowserPrivateCallBack(
 149                 void *                                  inContext,
 150                 DNSBrowserRef                   inRef,
 151                 DNSStatus                               inStatusCode,
 152                 const DNSBrowserEvent * inEvent );
 153
 154 DNS_LOCAL void
 155         DNSServiceResolverPrivateCallBack(
 156                 void *                                          inContext,
 157                 DNSResolverRef                          inRef,
 158                 DNSStatus                                       inStatusCode,
 159                 const DNSResolverEvent *        inEvent );
 160
 161 #if 0
 162 #pragma mark -
 163 #endif
 164
 165 //===========================================================================================================================
 166 //      DNSServiceRegistrationCreate
 167 //===========================================================================================================================
 168
 169 dns_service_discovery_ref
 170         DNSServiceRegistrationCreate(
 171                 const char *                            inName,
 172                 const char *                            inType,
 173                 const char *                            inDomain,
 174                 uint16_t                                        inPort,
 175                 const char *                            inTextRecord,
 176                 DNSServiceRegistrationReply     inCallBack,
 177                 void *                                          inContext )
 178 {
 179         DNSStatus                                               err;
 180         dns_service_discovery_ref               result;
 181         dns_service_discovery_ref               obj;
 182         void *                                                  txt;
 183         size_t                                                  txtSize;
 184         DNSRegistrationRef                              registration;
 185
 186         result  = NULL;
 187         txt             = NULL;
 188         txtSize = 0;
 189
 190         // Allocate and initialize the object.
 191
 192         obj = (dns_service_discovery_ref) malloc( sizeof( *obj ) );
 193         require_action( obj, exit, err = kDNSNoMemoryErr );
 194
 195         obj->type               = kDNSServiceDiscoveryObjectTypeRegistration;
 196         obj->ref                = NULL;
 197         obj->callback   = inCallBack;
 198         obj->context    = inContext;
 199
 200         // Create the underlying registration. Build a \001-escaped text record if needed.
 201
 202         if( inTextRecord )
 203         {
 204                 err = DNSDynamicTextRecordBuildEscaped( inTextRecord, &txt, &txtSize );
 205                 require_noerr( err, exit );
 206         }
 207
 208         err = DNSRegistrationCreate( kDNSRegistrationFlagPreFormattedTextRecord, inName, inType, inDomain, inPort, txt,
 209                                                                  (DNSCount) txtSize, NULL, NULL, DNSServiceRegistrationPrivateCallBack, obj, &registration );
 210         require_noerr( err, exit );
 211         obj->ref = registration;
 212
 213         // Success!
 214
 215         result  = obj;
 216         obj             = NULL;
 217
 218 exit:
 219         if( txt )
 220         {
 221                 DNSDynamicTextRecordRelease( txt );
 222         }
 223         if( obj )
 224         {
 225                 DNSServiceDiscoveryDeallocate( obj );
 226         }
 227         return( result );
 228 }
 229
 230 //===========================================================================================================================
 231 //      DNSServiceRegistrationPrivateCallBack
 232 //===========================================================================================================================
 233
 234 DNS_LOCAL void
 235         DNSServiceRegistrationPrivateCallBack(
 236                 void *                                                  inContext,
 237                 DNSRegistrationRef                              inRef,
 238                 DNSStatus                                               inStatusCode,
 239                 const DNSRegistrationEvent *    inEvent )
 240 {
 241         dns_service_discovery_ref               obj;
 242         DNSServiceRegistrationReply             callback;
 243
 244         DNS_UNUSED( inRef );
 245         DNS_UNUSED( inStatusCode );
 246
 247         check( inContext );
 248         obj = (dns_service_discovery_ref) inContext;
 249         check( obj->callback );
 250         callback = (DNSServiceRegistrationReply) obj->callback;
 251
 252         switch( inEvent->type )
 253         {
 254                 case kDNSRegistrationEventTypeRegistered:
 255                         debugf( DEBUG_NAME "name registered and active\n" );
 256
 257                         if( callback )
 258                         {
 259                                 callback( kDNSServiceDiscoveryNoError, obj->context );
 260                         }
 261                         break;
 262
 263                 case kDNSRegistrationEventTypeNameCollision:
 264                         debugf( DEBUG_NAME "name in use, please choose another name\n" );
 265
 266                         if( callback )
 267                         {
 268                                 callback( kDNSServiceDiscoveryNameConflict, obj->context );
 269                         }
 270                         break;
 271
 272                 default:
 273                         break;
 274         }
 275 }
 276
 277 //===========================================================================================================================
 278 //      DNSServiceRegistrationAddRecord
 279 //===========================================================================================================================
 280
 281 DNSRecordReference
 282         DNSServiceRegistrationAddRecord(
 283                 dns_service_discovery_ref       inRef,
 284                 uint16_t                                        inRRType,
 285                 uint16_t                                        inRDLength,
 286                 const char *                            inRData,
 287                 uint32_t                                        inTTL )
 288 {
 289         DNS_UNUSED( inRef );
 290         DNS_UNUSED( inRRType );
 291         DNS_UNUSED( inRDLength );
 292         DNS_UNUSED( inRData );
 293         DNS_UNUSED( inTTL );
 294
 295         debugf( DEBUG_NAME "DNSServiceRegistrationAddRecord is currently not supported\n" );
 296         return( 0 );
 297 }
 298
 299 //===========================================================================================================================
 300 //      DNSServiceRegistrationUpdateRecord
 301 //===========================================================================================================================
 302
 303 DNSServiceRegistrationReplyErrorType
 304         DNSServiceRegistrationUpdateRecord(
 305                 dns_service_discovery_ref       inRef,
 306                 DNSRecordReference                      inRecordRef,
 307                 uint16_t                                        inRDLength,
 308                 const char *                            inRData,
 309                 uint32_t                                        inTTL )
 310 {
 311         DNS_UNUSED( inRef );
 312         DNS_UNUSED( inRecordRef );
 313         DNS_UNUSED( inRDLength );
 314         DNS_UNUSED( inRData );
 315         DNS_UNUSED( inTTL );
 316
 317         debugf( DEBUG_NAME "DNSServiceRegistrationUpdateRecord is currently not supported\n" );
 318         return( kDNSServiceDiscoveryUnsupportedErr );
 319 }
 320
 321 //===========================================================================================================================
 322 //      DNSServiceRegistrationRemoveRecord
 323 //===========================================================================================================================
 324
 325 DNSServiceRegistrationReplyErrorType
 326         DNSServiceRegistrationRemoveRecord(
 327                 dns_service_discovery_ref       inRef,
 328                 DNSRecordReference                      inRecordRef )
 329 {
 330         DNS_UNUSED( inRef );
 331         DNS_UNUSED( inRecordRef );
 332
 333         debugf( DEBUG_NAME "DNSServiceRegistrationRemoveRecord is currently not supported\n" );
 334         return( kDNSServiceDiscoveryUnsupportedErr );
 335 }
 336
 337 //===========================================================================================================================
 338 //      DNSServiceDomainEnumerationCreate
 339 //===========================================================================================================================
 340
 341 dns_service_discovery_ref
 342         DNSServiceDomainEnumerationCreate(
 343                 int                                                             inRegistrationDomains,
 344                 DNSServiceDomainEnumerationReply        inCallBack,
 345                 void *                                                          inContext )
 346 {
 347         DNSStatus                                               err;
 348         dns_service_discovery_ref               result;
 349         dns_service_discovery_ref               obj;
 350         DNSBrowserRef                                   browser;
 351         DNSBrowserFlags                                 flags;
 352
 353         result  = NULL;
 354         browser = NULL;
 355
 356         // Allocate and initialize the object.
 357
 358         obj = (dns_service_discovery_ref) malloc( sizeof( *obj ) );
 359         require_action( obj, exit, err = kDNSNoMemoryErr );
 360
 361         obj->type               = kDNSServiceDiscoveryObjectTypeDomainEnumeration;
 362         obj->ref                = NULL;
 363         obj->callback   = inCallBack;
 364         obj->context    = inContext;
 365
 366         // Create the underlying browser and start searching for domains.
 367
 368         err = DNSBrowserCreate( 0, DNSServiceDomainEnumerationPrivateCallBack, obj, &browser );
 369         require_noerr( err, exit );
 370         obj->ref = browser;
 371
 372         if( inRegistrationDomains )
 373         {
 374                 flags = kDNSBrowserFlagRegistrationDomainsOnly;
 375         }
 376         else
 377         {
 378                 flags = 0;
 379         }
 380         err = DNSBrowserStartDomainSearch( browser, flags );
 381         require_noerr( err, exit );
 382
 383         // Success!
 384
 385         result          = obj;
 386         browser         = NULL;
 387         obj                     = NULL;
 388
 389 exit:
 390         if( browser )
 391         {
 392                 DNSBrowserRelease( browser, 0 );
 393         }
 394         if( obj )
 395         {
 396                 DNSServiceDiscoveryDeallocate( obj );
 397         }
 398         return( result );
 399 }
 400
 401 //===========================================================================================================================
 402 //      DNSServiceDomainEnumerationPrivateCallBack
 403 //===========================================================================================================================
 404
 405 DNS_LOCAL void
 406         DNSServiceDomainEnumerationPrivateCallBack(
 407                 void *                                  inContext,
 408                 DNSBrowserRef                   inRef,
 409                 DNSStatus                               inStatusCode,
 410                 const DNSBrowserEvent * inEvent )
 411 {
 412         dns_service_discovery_ref                               obj;
 413         DNSServiceDomainEnumerationReply                callback;
 414
 415         DNS_UNUSED( inRef );
 416         DNS_UNUSED( inStatusCode );
 417
 418         check( inContext );
 419         obj = (dns_service_discovery_ref) inContext;
 420         check( obj->callback );
 421         callback = (DNSServiceDomainEnumerationReply) obj->callback;
 422
 423         switch( inEvent->type )
 424         {
 425                 case kDNSBrowserEventTypeAddDomain:
 426                         debugf( DEBUG_NAME "add domain \"%s\"\n", inEvent->data.addDomain.domain );
 427
 428                         if( callback )
 429                         {
 430                                 callback( DNSServiceDomainEnumerationReplyAddDomain, inEvent->data.addDomain.domain,
 431                                                   DNSServiceDiscoverReplyFlagsFinished, obj->context );
 432                         }
 433                         break;
 434
 435                 case kDNSBrowserEventTypeAddDefaultDomain:
 436                         debugf( DEBUG_NAME "add default domain \"%s\"\n", inEvent->data.addDefaultDomain.domain );
 437
 438                         if( callback )
 439                         {
 440                                 callback( DNSServiceDomainEnumerationReplyAddDomainDefault, inEvent->data.addDefaultDomain.domain,
 441                                                   DNSServiceDiscoverReplyFlagsFinished, obj->context );
 442                         }
 443                         break;
 444
 445                 case kDNSBrowserEventTypeRemoveDomain:
 446                         debugf( DEBUG_NAME "add default domain \"%s\"\n", inEvent->data.removeDomain.domain );
 447
 448                         if( callback )
 449                         {
 450                                 callback( DNSServiceDomainEnumerationReplyRemoveDomain, inEvent->data.removeDomain.domain,
 451                                                   DNSServiceDiscoverReplyFlagsFinished, obj->context );
 452                         }
 453                         break;
 454
 455                 default:
 456                         break;
 457         }
 458 }
 459
 460 //===========================================================================================================================
 461 //      DNSServiceBrowserCreate
 462 //===========================================================================================================================
 463
 464 dns_service_discovery_ref
 465         DNSServiceBrowserCreate(
 466                 const char *                    inType,
 467                 const char *                    inDomain,
 468                 DNSServiceBrowserReply  inCallBack,
 469                 void *                                  inContext )
 470 {
 471         DNSStatus                                               err;
 472         dns_service_discovery_ref               result;
 473         dns_service_discovery_ref               obj;
 474         DNSBrowserRef                                   browser;
 475
 476         result  = NULL;
 477         browser = NULL;
 478
 479         // Allocate and initialize the object.
 480
 481         obj = (dns_service_discovery_ref) malloc( sizeof( *obj ) );
 482         require_action( obj, exit, err = kDNSNoMemoryErr );
 483
 484         obj->type               = kDNSServiceDiscoveryObjectTypeBrowser;
 485         obj->ref                = NULL;
 486         obj->callback   = inCallBack;
 487         obj->context    = inContext;
 488
 489         // Create the underlying browser and start searching for domains.
 490
 491         err = DNSBrowserCreate( 0, DNSServiceBrowserPrivateCallBack, obj, &browser );
 492         require_noerr( err, exit );
 493         obj->ref = browser;
 494
 495         err = DNSBrowserStartServiceSearch( browser, 0, inType, inDomain );
 496         require_noerr( err, exit );
 497
 498         // Success!
 499
 500         result          = obj;
 501         browser         = NULL;
 502         obj                     = NULL;
 503
 504 exit:
 505         if( browser )
 506         {
 507                 DNSBrowserRelease( browser, 0 );
 508         }
 509         if( obj )
 510         {
 511                 DNSServiceDiscoveryDeallocate( obj );
 512         }
 513         return( result );
 514 }
 515
 516 //===========================================================================================================================
 517 //      DNSServiceBrowserPrivateCallBack
 518 //===========================================================================================================================
 519
 520 DNS_LOCAL void
 521         DNSServiceBrowserPrivateCallBack(
 522                 void *                                  inContext,
 523                 DNSBrowserRef                   inRef,
 524                 DNSStatus                               inStatusCode,
 525                 const DNSBrowserEvent * inEvent )
 526 {
 527         dns_service_discovery_ref               obj;
 528         DNSServiceBrowserReply                  callback;
 529
 530         DNS_UNUSED( inRef );
 531         DNS_UNUSED( inStatusCode );
 532
 533         check( inContext );
 534         obj = (dns_service_discovery_ref) inContext;
 535         check( obj->callback );
 536         callback = (DNSServiceBrowserReply) obj->callback;
 537
 538         switch( inEvent->type )
 539         {
 540                 case kDNSBrowserEventTypeAddService:
 541                         debugf( DEBUG_NAME "add service \"%s.%s%s\"\n",
 542                                   inEvent->data.addService.name,
 543                                   inEvent->data.addService.type,
 544                                   inEvent->data.addService.domain );
 545
 546                         if( callback )
 547                         {
 548                                 callback( DNSServiceBrowserReplyAddInstance,
 549                                                   inEvent->data.addService.name,
 550                                                   inEvent->data.addService.type,
 551                                                   inEvent->data.addService.domain,
 552                                                   DNSServiceDiscoverReplyFlagsFinished,
 553                                                   obj->context );
 554                         }
 555                         break;
 556
 557                 case kDNSBrowserEventTypeRemoveService:
 558                         debugf( DEBUG_NAME "remove service \"%s.%s%s\"\n",
 559                                   inEvent->data.removeService.name,
 560                                   inEvent->data.removeService.type,
 561                                   inEvent->data.removeService.domain );
 562
 563                         if( callback )
 564                         {
 565                                 callback( DNSServiceBrowserReplyRemoveInstance,
 566                                                   inEvent->data.removeService.name,
 567                                                   inEvent->data.removeService.type,
 568                                                   inEvent->data.removeService.domain,
 569                                                   DNSServiceDiscoverReplyFlagsFinished,
 570                                                   obj->context );
 571                         }
 572                         break;
 573
 574                 default:
 575                         break;
 576         }
 577 }
 578
 579 //===========================================================================================================================
 580 //      DNSServiceResolverResolve
 581 //===========================================================================================================================
 582
 583 dns_service_discovery_ref
 584         DNSServiceResolverResolve(
 585                 const char *                    inName,
 586                 const char *                    inType,
 587                 const char *                    inDomain,
 588                 DNSServiceResolverReply inCallBack,
 589                 void *                                  inContext )
 590 {
 591         DNSStatus                                               err;
 592         dns_service_discovery_ref               result;
 593         dns_service_discovery_ref               obj;
 594         DNSResolverRef                                  resolver;
 595
 596         result = NULL;
 597
 598         // Allocate and initialize the object.
 599
 600         obj = (dns_service_discovery_ref) malloc( sizeof( *obj ) );
 601         require_action( obj, exit, err = kDNSNoMemoryErr );
 602
 603         obj->type               = kDNSServiceDiscoveryObjectTypeResolver;
 604         obj->ref                = NULL;
 605         obj->callback   = inCallBack;
 606         obj->context    = inContext;
 607
 608         // Create the underlying resolver and start searching for domains.
 609
 610         err = DNSResolverCreate( 0, inName, inType, inDomain, DNSServiceResolverPrivateCallBack, obj, NULL, &resolver );
 611         require_noerr( err, exit );
 612         obj->ref = resolver;
 613
 614         // Success!
 615
 616         result  = obj;
 617         obj             = NULL;
 618
 619 exit:
 620         if( obj )
 621         {
 622                 DNSServiceDiscoveryDeallocate( obj );
 623         }
 624         return( result );
 625 }
 626
 627 //===========================================================================================================================
 628 //      DNSServiceResolverPrivateCallBack
 629 //===========================================================================================================================
 630
 631 DNS_LOCAL void
 632         DNSServiceResolverPrivateCallBack(
 633                 void *                                          inContext,
 634                 DNSResolverRef                          inRef,
 635                 DNSStatus                                       inStatusCode,
 636                 const DNSResolverEvent *        inEvent )
 637 {
 638         dns_service_discovery_ref               obj;
 639         DNSServiceResolverReply                 callback;
 640         struct sockaddr_in                              interfaceAddr;
 641         struct sockaddr_in                              addr;
 642
 643         DNS_UNUSED( inRef );
 644         DNS_UNUSED( inStatusCode );
 645
 646         check( inContext );
 647         obj = (dns_service_discovery_ref) inContext;
 648         check( obj->callback );
 649         callback = (DNSServiceResolverReply) obj->callback;
 650
 651         switch( inEvent->type )
 652         {
 653                 case kDNSResolverEventTypeResolved:
 654                         debugf( DEBUG_NAME "resolved \"%s.%s%s\"\n",
 655                                   inEvent->data.resolved.name,
 656                                   inEvent->data.resolved.type,
 657                                   inEvent->data.resolved.domain );
 658
 659                         memset( &interfaceAddr, 0, sizeof( interfaceAddr ) );
 660                         interfaceAddr.sin_family                = AF_INET;
 661                         interfaceAddr.sin_port                  = 0;
 662                         interfaceAddr.sin_addr.s_addr   = inEvent->data.resolved.interfaceIP.u.ipv4.addr.v32;
 663
 664                         memset( &addr, 0, sizeof( addr ) );
 665                         addr.sin_family                 = AF_INET;
 666                         addr.sin_port                   = inEvent->data.resolved.address.u.ipv4.port.v16;
 667                         addr.sin_addr.s_addr    = inEvent->data.resolved.address.u.ipv4.addr.v32;
 668
 669                         if( callback )
 670                         {
 671                                 callback( (struct sockaddr *) &interfaceAddr, (struct sockaddr *) &addr, inEvent->data.resolved.textRecord,
 672                                                   DNSServiceDiscoverReplyFlagsFinished, obj->context );
 673                         }
 674                         break;
 675
 676                 default:
 677                         break;
 678         }
 679 }
 680
 681 //===========================================================================================================================
 682 //      DNSServiceDiscoveryMachPort
 683 //===========================================================================================================================
 684
 685 mach_port_t     DNSServiceDiscoveryMachPort( dns_service_discovery_ref inRef )
 686 {
 687         DNS_UNUSED( inRef );
 688
 689         debugf( DEBUG_NAME "DNSServiceDiscoveryMachPort is not supported\n" );
 690         return( 0 );
 691 }
 692
 693 //===========================================================================================================================
 694 //      DNSServiceDiscoveryDeallocate
 695 //===========================================================================================================================
 696
 697 void    DNSServiceDiscoveryDeallocate( dns_service_discovery_ref inRef )
 698 {
 699         _dns_service_discovery_t *              obj;
 700         DNSStatus                                               err;
 701
 702         check( inRef );
 703         check( inRef->ref );
 704
 705         obj = (_dns_service_discovery_t *) inRef;
 706         switch( obj->type )
 707         {
 708                 case kDNSServiceDiscoveryObjectTypeRegistration:
 709                         if( inRef->ref )
 710                         {
 711                                 err = DNSRegistrationRelease( (DNSRegistrationRef) inRef->ref, 0 );
 712                                 check_noerr( err );
 713                         }
 714                         free( inRef );
 715                         break;
 716
 717                 case kDNSServiceDiscoveryObjectTypeDomainEnumeration:
 718                         if( inRef->ref )
 719                         {
 720                                 err = DNSBrowserRelease( (DNSBrowserRef) inRef->ref, 0 );
 721                                 check_noerr( err );
 722                         }
 723                         free( inRef );
 724                         break;
 725
 726                 case kDNSServiceDiscoveryObjectTypeBrowser:
 727                         if( inRef->ref )
 728                         {
 729                                 err = DNSBrowserRelease( (DNSBrowserRef) inRef->ref, 0 );
 730                                 check_noerr( err );
 731                         }
 732                         free( inRef );
 733                         break;
 734
 735                 case kDNSServiceDiscoveryObjectTypeResolver:
 736                         if( inRef->ref )
 737                         {
 738                                 err = DNSResolverRelease( (DNSResolverRef) inRef->ref, 0 );
 739                                 check_noerr( err );
 740                         }
 741                         free( inRef );
 742                         break;
 743
 744                 default:
 745                         debugf( DEBUG_NAME "unknown object type (%d)\n", obj->type );
 746                         break;
 747         }
 748 }
 749
 750 //===========================================================================================================================
 751 //      DNSServiceDiscovery_handleReply
 752 //===========================================================================================================================
 753
 754 void    DNSServiceDiscovery_handleReply( void *inReplyMessage )
 755 {
 756         DNS_UNUSED( inReplyMessage );
 757
 758         debugf( DEBUG_NAME "DNSServiceDiscovery_handleReply is not supported\n" );
 759 }
 760
 761 #ifdef  __cplusplus
 762         }
 763 #endif