react-native-zeroconf 0.13.8 → 0.14.0

package/android/src/main/jni/mdnsresponder/mDNSWindows/DLLX/DNSSD.cpp

@@ -0,0 +1,892 @@
+// DNSSD.cpp : Implementation of CDNSSD
+
+#include "stdafx.h"
+#include "DNSSD.h"
+#include "DNSSDService.h"
+#include "TXTRecord.h"
+#include <dns_sd.h>
+#include <CommonServices.h>
+#include <DebugServices.h>
+#include "StringServices.h"
+
+
+// CDNSSD
+
+STDMETHODIMP CDNSSD::Browse(DNSSDFlags flags, ULONG ifIndex, BSTR regtype, BSTR domain, IBrowseListener* listener, IDNSSDService** browser )
+{
+	CComObject<CDNSSDService>	*	object		= NULL;
+	std::string						regtypeUTF8;
+	std::string						domainUTF8;
+	DNSServiceRef					sref		= NULL;
+	DNSServiceErrorType				err			= 0;
+	HRESULT							hr			= 0;
+	BOOL							ok;
+
+	// Initialize
+	*browser = NULL;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( regtype, regtypeUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( domain, domainUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceBrowse( &sref, flags, ifIndex, regtypeUTF8.c_str(), domainUTF8.c_str(), ( DNSServiceBrowseReply ) &BrowseReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*browser = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::Resolve(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, IResolveListener* listener, IDNSSDService** service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	std::string						serviceNameUTF8;
+	std::string						regTypeUTF8;
+	std::string						domainUTF8;
+	DNSServiceRef					sref			= NULL;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+	BOOL							ok;
+
+	// Initialize
+	*service = NULL;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( serviceName, serviceNameUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( regType, regTypeUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( domain, domainUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceResolve( &sref, flags, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), domainUTF8.c_str(), ( DNSServiceResolveReply ) &ResolveReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::EnumerateDomains(DNSSDFlags flags, ULONG ifIndex, IDomainListener *listener, IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	DNSServiceRef					sref			= NULL;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+
+	// Initialize
+	*service = NULL;
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceEnumerateDomains( &sref, flags, ifIndex, ( DNSServiceDomainEnumReply ) &DomainEnumReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::Register(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, BSTR host, USHORT port, ITXTRecord *record, IRegisterListener *listener, IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	std::string						serviceNameUTF8;
+	std::string						regTypeUTF8;
+	std::string						domainUTF8;
+	std::string						hostUTF8;
+	const void					*	txtRecord		= NULL;
+	uint16_t						txtLen			= 0;
+	DNSServiceRef					sref			= NULL;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+	BOOL							ok;
+
+	// Initialize
+	*service = NULL;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( serviceName, serviceNameUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( regType, regTypeUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( domain, domainUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+	ok = BSTRToUTF8( host, hostUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	if ( record )
+	{
+		CComObject< CTXTRecord > * realTXTRecord;
+
+		realTXTRecord = ( CComObject< CTXTRecord >* ) record;
+
+		txtRecord	= realTXTRecord->GetBytes();
+		txtLen		= realTXTRecord->GetLen();
+	}
+
+	err = DNSServiceRegister( &sref, flags, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), domainUTF8.c_str(), hostUTF8.c_str(), port, txtLen, txtRecord, ( DNSServiceRegisterReply ) &RegisterReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::QueryRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullname, DNSSDRRType rrtype, DNSSDRRClass rrclass, IQueryRecordListener *listener, IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	DNSServiceRef					sref			= NULL;
+	std::string						fullNameUTF8;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+	BOOL							ok;
+
+	// Initialize
+	*service = NULL;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( fullname, fullNameUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceQueryRecord( &sref, flags, ifIndex, fullNameUTF8.c_str(), ( uint16_t ) rrtype, ( uint16_t ) rrclass, ( DNSServiceQueryRecordReply ) &QueryRecordReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::GetAddrInfo(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, BSTR hostName, IGetAddrInfoListener *listener, IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	DNSServiceRef					sref			= NULL;
+	std::string						hostNameUTF8;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+	BOOL							ok;
+
+	// Initialize
+	*service = NULL;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( hostName, hostNameUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceGetAddrInfo( &sref, flags, ifIndex, addressFamily, hostNameUTF8.c_str(), ( DNSServiceGetAddrInfoReply ) &GetAddrInfoReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::CreateConnection(IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object	= NULL;
+	DNSServiceRef					sref	= NULL;
+	DNSServiceErrorType				err		= 0;
+	HRESULT							hr		= 0;
+
+	// Initialize
+	*service = NULL;
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	err = DNSServiceCreateConnection( &sref );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::NATPortMappingCreate(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, DNSSDProtocol protocol, USHORT internalPort, USHORT externalPort, ULONG ttl, INATPortMappingListener *listener, IDNSSDService **service)
+{
+	CComObject<CDNSSDService>	*	object			= NULL;
+	DNSServiceRef					sref			= NULL;
+	DNSServiceProtocol				prot			= 0;
+	DNSServiceErrorType				err				= 0;
+	HRESULT							hr				= 0;
+
+	// Initialize
+	*service = NULL;
+
+	try
+	{
+		object = new CComObject<CDNSSDService>();
+	}
+	catch ( ... )
+	{
+		object = NULL;
+	}
+
+	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );
+	hr = object->FinalConstruct();
+	require_action( hr == S_OK, exit, err = kDNSServiceErr_Unknown );
+	object->AddRef();
+
+	prot = ( addressFamily | protocol );
+
+	err = DNSServiceNATPortMappingCreate( &sref, flags, ifIndex, prot, internalPort, externalPort, ttl, ( DNSServiceNATPortMappingReply ) &NATPortMappingReply, object );
+	require_noerr( err, exit );
+
+	object->SetServiceRef( sref );
+	object->SetListener( listener );
+
+	err = object->Run();
+	require_noerr( err, exit );
+
+	*service = object;
+
+exit:
+
+	if ( err && object )
+	{
+		object->Release();
+	}
+
+	return err;
+}
+
+
+STDMETHODIMP CDNSSD::GetProperty(BSTR prop, VARIANT * value )
+{
+	std::string			propUTF8;
+	std::vector< BYTE >	byteArray;
+	SAFEARRAY		*	psa			= NULL;
+	BYTE			*	pData		= NULL;
+	uint32_t			elems		= 0;
+	DNSServiceErrorType	err			= 0;
+	BOOL				ok = TRUE;
+
+	// Convert BSTR params to utf8
+	ok = BSTRToUTF8( prop, propUTF8 );
+	require_action( ok, exit, err = kDNSServiceErr_BadParam );
+
+	// Setup the byte array
+	require_action( V_VT( value ) == ( VT_ARRAY|VT_UI1 ), exit, err = kDNSServiceErr_Unknown );
+	psa = V_ARRAY( value );
+	require_action( psa, exit, err = kDNSServiceErr_Unknown );
+	require_action( SafeArrayGetDim( psa ) == 1, exit, err = kDNSServiceErr_Unknown );
+	byteArray.reserve( psa->rgsabound[0].cElements );
+	byteArray.assign( byteArray.capacity(), 0 );
+	elems = ( uint32_t ) byteArray.capacity();
+
+	// Call the function and package the return value in the Variant
+	err = DNSServiceGetProperty( propUTF8.c_str(), &byteArray[ 0 ], &elems );
+	require_noerr( err, exit );
+	ok = ByteArrayToVariant( &byteArray[ 0 ], elems, value );
+	require_action( ok, exit, err = kDNSSDError_Unknown );
+
+exit:
+
+	if ( psa )
+	{
+		SafeArrayUnaccessData( psa );
+		psa = NULL;
+	}
+
+	return err;
+}
+
+
+void DNSSD_API
+CDNSSD::DomainEnumReply
+    (
+    DNSServiceRef                       sdRef,
+    DNSServiceFlags                     flags,
+    uint32_t                            ifIndex,
+    DNSServiceErrorType                 errorCode,
+    const char                          *replyDomainUTF8,
+    void                                *context
+    )
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IDomainListener	* listener;
+
+		listener = ( IDomainListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR replyDomain;
+		
+			UTF8ToBSTR( replyDomainUTF8, replyDomain );
+
+			if ( flags & kDNSServiceFlagsAdd )
+			{
+				listener->DomainFound( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );
+			}
+			else
+			{
+				listener->DomainLost( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );
+			}
+		}
+		else
+		{
+			listener->EnumDomainsFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::BrowseReply
+		(
+		DNSServiceRef                       sdRef,
+		DNSServiceFlags                     flags,
+		uint32_t                            ifIndex,
+		DNSServiceErrorType                 errorCode,
+		const char                          *serviceNameUTF8,
+		const char                          *regTypeUTF8,
+		const char                          *replyDomainUTF8,
+		void                                *context
+		)
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IBrowseListener	* listener;
+
+		listener = ( IBrowseListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR	serviceName;
+			CComBSTR	regType;
+			CComBSTR	replyDomain;
+		
+			UTF8ToBSTR( serviceNameUTF8, serviceName );
+			UTF8ToBSTR( regTypeUTF8, regType );
+			UTF8ToBSTR( replyDomainUTF8, replyDomain );
+
+			if ( flags & kDNSServiceFlagsAdd )
+			{
+				listener->ServiceFound( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );
+			}
+			else
+			{
+				listener->ServiceLost( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );
+			}
+		}
+		else
+		{
+			listener->BrowseFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::ResolveReply
+		(
+		DNSServiceRef                       sdRef,
+		DNSServiceFlags                     flags,
+		uint32_t                            ifIndex,
+		DNSServiceErrorType                 errorCode,
+		const char                          *fullNameUTF8,
+		const char                          *hostNameUTF8,
+		uint16_t                            port,
+		uint16_t                            txtLen,
+		const unsigned char                 *txtRecord,
+		void                                *context
+		)
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IResolveListener * listener;
+
+		listener = ( IResolveListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR					fullName;
+			CComBSTR					hostName;
+			CComBSTR					regType;
+			CComBSTR					replyDomain;
+			CComObject< CTXTRecord >*	record;
+			BOOL						ok;
+
+			ok = UTF8ToBSTR( fullNameUTF8, fullName );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+			ok = UTF8ToBSTR( hostNameUTF8, hostName );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+
+			try
+			{
+				record = new CComObject<CTXTRecord>();
+			}
+			catch ( ... )
+			{
+				record = NULL;
+			}
+
+			require_action( record, exit, err = kDNSServiceErr_NoMemory );
+			record->AddRef();
+
+			char buf[ 64 ];
+			sprintf( buf, "txtLen = %d", txtLen );
+			OutputDebugStringA( buf );
+
+			if ( txtLen > 0 )
+			{
+				record->SetBytes( txtRecord, txtLen );
+			}
+
+			listener->ServiceResolved( service, ( DNSSDFlags ) flags, ifIndex, fullName, hostName, port, record );
+		}
+		else
+		{
+			listener->ResolveFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::RegisterReply
+		(
+		DNSServiceRef                       sdRef,
+		DNSServiceFlags                     flags,
+		DNSServiceErrorType                 errorCode,
+		const char                          *serviceNameUTF8,
+		const char                          *regTypeUTF8,
+		const char                          *domainUTF8,
+		void                                *context
+		)
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IRegisterListener * listener;
+
+		listener = ( IRegisterListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR					serviceName;
+			CComBSTR					regType;
+			CComBSTR					domain;
+			BOOL						ok;
+
+			ok = UTF8ToBSTR( serviceNameUTF8, serviceName );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+			ok = UTF8ToBSTR( regTypeUTF8, regType );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+			ok = UTF8ToBSTR( domainUTF8, domain );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+
+			listener->ServiceRegistered( service, ( DNSSDFlags ) flags, serviceName, regType, domain );
+		}
+		else
+		{
+			listener->ServiceRegisterFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::QueryRecordReply
+		(
+		DNSServiceRef                       sdRef,
+		DNSServiceFlags                     flags,
+		uint32_t                            ifIndex,
+		DNSServiceErrorType                 errorCode,
+		const char                          *fullNameUTF8,
+		uint16_t                            rrtype,
+		uint16_t                            rrclass,
+		uint16_t                            rdlen,
+		const void                          *rdata,
+		uint32_t                            ttl,
+		void                                *context
+		)
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IQueryRecordListener * listener;
+
+		listener = ( IQueryRecordListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR	fullName;
+			VARIANT		var;
+			BOOL		ok;
+
+			ok = UTF8ToBSTR( fullNameUTF8, fullName );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+			ok = ByteArrayToVariant( rdata, rdlen, &var );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+
+			listener->QueryRecordAnswered( service, ( DNSSDFlags ) flags, ifIndex, fullName, ( DNSSDRRType ) rrtype, ( DNSSDRRClass ) rrclass, var, ttl );
+		}
+		else
+		{
+			listener->QueryRecordFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::GetAddrInfoReply
+		(
+		DNSServiceRef                    sdRef,
+		DNSServiceFlags                  flags,
+		uint32_t                         ifIndex,
+		DNSServiceErrorType              errorCode,
+		const char                       *hostNameUTF8,
+		const struct sockaddr            *rawAddress,
+		uint32_t                         ttl,
+		void                             *context
+		)
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		IGetAddrInfoListener * listener;
+
+		listener = ( IGetAddrInfoListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			CComBSTR			hostName;
+			DWORD				sockaddrLen;
+			DNSSDAddressFamily	addressFamily;
+			char				addressUTF8[INET6_ADDRSTRLEN];
+			DWORD				addressLen = sizeof( addressUTF8 );
+			CComBSTR			address;
+			BOOL				ok;
+
+			ok = UTF8ToBSTR( hostNameUTF8, hostName );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+
+			switch ( rawAddress->sa_family )
+			{
+				case AF_INET:
+				{
+					addressFamily	= kDNSSDAddressFamily_IPv4;
+					sockaddrLen		= sizeof( sockaddr_in );
+				}
+				break;
+
+				case AF_INET6:
+				{
+					addressFamily	= kDNSSDAddressFamily_IPv6;
+					sockaddrLen		= sizeof( sockaddr_in6 );
+				}
+				break;
+			}
+
+			err = WSAAddressToStringA( ( LPSOCKADDR ) rawAddress, sockaddrLen, NULL, addressUTF8, &addressLen );
+			require_noerr( err, exit );
+			ok = UTF8ToBSTR( addressUTF8, address );
+			require_action( ok, exit, err = kDNSServiceErr_Unknown );
+
+			listener->GetAddrInfoReply( service, ( DNSSDFlags ) flags, ifIndex, hostName, addressFamily, address, ttl );
+		}
+		else
+		{
+			listener->GetAddrInfoFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+
+
+void DNSSD_API
+CDNSSD::NATPortMappingReply
+    (
+    DNSServiceRef                    sdRef,
+    DNSServiceFlags                  flags,
+    uint32_t                         ifIndex,
+    DNSServiceErrorType              errorCode,
+    uint32_t                         externalAddress,   /* four byte IPv4 address in network byte order */
+    DNSServiceProtocol               protocol,
+    uint16_t                         internalPort,
+    uint16_t                         externalPort,      /* may be different than the requested port     */
+    uint32_t                         ttl,               /* may be different than the requested ttl      */
+    void                             *context
+    )
+{
+	CComObject<CDNSSDService> * service;
+	int err;
+	
+	service = ( CComObject< CDNSSDService>* ) context;
+	require_action( service, exit, err = kDNSServiceErr_Unknown );
+
+	if ( !service->Stopped() )
+	{
+		INATPortMappingListener * listener;
+
+		listener = ( INATPortMappingListener* ) service->GetListener();
+		require_action( listener, exit, err = kDNSServiceErr_Unknown );
+
+		if ( !errorCode )
+		{
+			listener->MappingCreated( service, ( DNSSDFlags ) flags, ifIndex, externalAddress, ( DNSSDAddressFamily ) ( protocol & 0x8 ), ( DNSSDProtocol ) ( protocol & 0x80 ), internalPort, externalPort, ttl  );
+		}
+		else
+		{
+			listener->MappingFailed( service, ( DNSSDError ) errorCode );
+		}
+	}
+
+exit:
+
+	return;
+}
+