android-12.0.0_r34/s

/* -*- Mode: C; tab-width: 4 -*-
 *
 * Copyright (c) 2009 Apple Computer, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#pragma warning(disable:4995)


#include "stdafx.h"

#include <strsafe.h>

#include "DNSSDService.h"

#include "DNSSDEventManager.h"

#include "DNSSDRecord.h"

#include "TXTRecord.h"

#include "StringServices.h"

#include <DebugServices.h>


#define WM_SOCKET (WM_APP + 100)


// CDNSSDService


BOOL						CDNSSDService::m_registeredWindowClass	= FALSE;

HWND						CDNSSDService::m_hiddenWindow			= NULL;

CDNSSDService::SocketMap	CDNSSDService::m_socketMap;


HRESULT CDNSSDService::FinalConstruct()

{

	DNSServiceErrorType	err	= 0;

	HRESULT				hr	= S_OK;


	m_isPrimary = TRUE;

	err = DNSServiceCreateConnection( &m_primary );

	require_action( !err, exit, hr = E_FAIL );


	if ( !m_hiddenWindow )

	{

		TCHAR windowClassName[ 256 ];


		StringCchPrintf( windowClassName, sizeof( windowClassName ) / sizeof( TCHAR ), TEXT( "Bonjour Hidden Window %d" ), GetProcessId( NULL ) );


		if ( !m_registeredWindowClass )

		{

			WNDCLASS	wc;

			ATOM		atom;


			wc.style			= 0;

			wc.lpfnWndProc		= WndProc;

			wc.cbClsExtra		= 0;

			wc.cbWndExtra		= 0;

			wc.hInstance		= NULL;

			wc.hIcon			= NULL;

			wc.hCursor			= NULL;

			wc.hbrBackground	= NULL;

			wc.lpszMenuName		= NULL;

			wc.lpszClassName	= windowClassName;


			atom = RegisterClass(&wc);

			require_action( atom != NULL, exit, hr = E_FAIL );


			m_registeredWindowClass = TRUE;

		}


		m_hiddenWindow = CreateWindow( windowClassName, windowClassName, WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL, GetModuleHandle( NULL ), NULL );

		require_action( m_hiddenWindow != NULL, exit, hr = E_FAIL );

	}


	err = WSAAsyncSelect( DNSServiceRefSockFD( m_primary ), m_hiddenWindow, WM_SOCKET, FD_READ );

	require_action( !err, exit, hr = E_FAIL );


	m_socketMap[ DNSServiceRefSockFD( m_primary ) ] = this;


exit:


	return hr;

}


void CDNSSDService::FinalRelease()

{

	dlog( kDebugLevelTrace, "FinalRelease()\n" );

	Stop();

}


STDMETHODIMP CDNSSDService::EnumerateDomains(DNSSDFlags flags, ULONG ifIndex, IDNSSDEventManager *eventManager, IDNSSDService **service)

{

	CComObject<CDNSSDService>	*	object	= NULL;

	DNSServiceRef					subord	= NULL;

	DNSServiceErrorType				err		= 0;

	HRESULT							hr		= 0;


	check( m_primary );


	// Initialize

	*service = NULL;


	try

	{

		object = new CComObject<CDNSSDService>();

	}

	catch ( ... )

	{

		object = NULL;

	}


	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );

	object->AddRef();


	subord = m_primary;

	err = DNSServiceEnumerateDomains( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, ( DNSServiceDomainEnumReply ) &DomainEnumReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::Browse(DNSSDFlags flags, ULONG ifIndex, BSTR regtype, BSTR domain, IDNSSDEventManager* eventManager, IDNSSDService** service )

{

	CComObject<CDNSSDService>	*	object		= NULL;

	std::string						regtypeUTF8;

	std::string						domainUTF8;

	DNSServiceRef					subord		= NULL;

	DNSServiceErrorType				err			= 0;

	HRESULT							hr			= 0;

	BOOL							ok;


	check( m_primary );


	// Initialize

	*service = 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 );

	object->AddRef();


	subord = m_primary;

	err = DNSServiceBrowse( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, regtypeUTF8.c_str(), ( domainUTF8.size() > 0 ) ? domainUTF8.c_str() : NULL, ( DNSServiceBrowseReply ) &BrowseReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::Resolve(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, IDNSSDEventManager* eventManager, IDNSSDService** service)

{

	CComObject<CDNSSDService>	*	object			= NULL;

	std::string						serviceNameUTF8;

	std::string						regTypeUTF8;

	std::string						domainUTF8;

	DNSServiceRef					subord			= NULL;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// 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 );

	object->AddRef();


	subord = m_primary;

	err = DNSServiceResolve( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), domainUTF8.c_str(), ( DNSServiceResolveReply ) &ResolveReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::Register(DNSSDFlags flags, ULONG ifIndex, BSTR serviceName, BSTR regType, BSTR domain, BSTR host, USHORT port, ITXTRecord *record, IDNSSDEventManager *eventManager, 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					subord			= NULL;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// 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 );

	object->AddRef();


	if ( record )

	{

		CComObject< CTXTRecord > * realTXTRecord;


		realTXTRecord = ( CComObject< CTXTRecord >* ) record;


		txtRecord	= realTXTRecord->GetBytes();

		txtLen		= realTXTRecord->GetLen();

	}


	subord = m_primary;

	err = DNSServiceRegister( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, serviceNameUTF8.c_str(), regTypeUTF8.c_str(), ( domainUTF8.size() > 0 ) ? domainUTF8.c_str() : NULL, hostUTF8.c_str(), htons( port ), txtLen, txtRecord, ( DNSServiceRegisterReply ) &RegisterReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::QueryRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullname, DNSSDRRType rrtype, DNSSDRRClass rrclass, IDNSSDEventManager *eventManager, IDNSSDService **service)

{

	CComObject<CDNSSDService>	*	object			= NULL;

	DNSServiceRef					subord			= NULL;

	std::string						fullNameUTF8;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// 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 );

	object->AddRef();


	subord = m_primary;

	err = DNSServiceQueryRecord( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, fullNameUTF8.c_str(), ( uint16_t ) rrtype, ( uint16_t ) rrclass, ( DNSServiceQueryRecordReply ) &QueryRecordReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::RegisterRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullName, DNSSDRRType rrtype, DNSSDRRClass rrclass, VARIANT rdata, ULONG ttl, IDNSSDEventManager* eventManager, IDNSSDRecord** record)

{

	CComObject<CDNSSDRecord>	*	object			= NULL;

	DNSRecordRef					rref			= NULL;

	std::string						fullNameUTF8;

	std::vector< BYTE >				byteArray;

	const void					*	byteArrayPtr	= NULL;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// Initialize

	*object = NULL;


	// Convert BSTR params to utf8

	ok = BSTRToUTF8( fullName, fullNameUTF8 );

	require_action( ok, exit, err = kDNSServiceErr_BadParam );


	// Convert the VARIANT

	ok = VariantToByteArray( &rdata, byteArray );

	require_action( ok, exit, err = kDNSServiceErr_Unknown );


	try

	{

		object = new CComObject<CDNSSDRecord>();

	}

	catch ( ... )

	{

		object = NULL;

	}


	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );

	object->AddRef();


	err = DNSServiceRegisterRecord( m_primary, &rref, flags, ifIndex, fullNameUTF8.c_str(), rrtype, rrclass, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL, ttl, &RegisterRecordReply, object );

	require_noerr( err, exit );


	object->SetServiceObject( this );

	object->SetRecordRef( rref );

	this->SetEventManager( eventManager );


	*record = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::AddRecord(DNSSDFlags flags, DNSSDRRType rrtype, VARIANT rdata, ULONG ttl, IDNSSDRecord ** record)

{

	CComObject<CDNSSDRecord>	*	object			= NULL;

	DNSRecordRef					rref			= NULL;

	std::vector< BYTE >				byteArray;

	const void					*	byteArrayPtr	= NULL;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// Initialize

	*object = NULL;


	// Convert the VARIANT

	ok = VariantToByteArray( &rdata, byteArray );

	require_action( ok, exit, err = kDNSServiceErr_Unknown );


	try

	{

		object = new CComObject<CDNSSDRecord>();

	}

	catch ( ... )

	{

		object = NULL;

	}


	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );

	object->AddRef();


	err = DNSServiceAddRecord( m_primary, &rref, flags, rrtype, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL, ttl );

	require_noerr( err, exit );


	object->SetServiceObject( this );

	object->SetRecordRef( rref );


	*record = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::ReconfirmRecord(DNSSDFlags flags, ULONG ifIndex, BSTR fullName, DNSSDRRType rrtype, DNSSDRRClass rrclass, VARIANT rdata)

{

	std::string						fullNameUTF8;

	std::vector< BYTE >				byteArray;

	const void					*	byteArrayPtr	= NULL;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	// Convert BSTR params to utf8

	ok = BSTRToUTF8( fullName, fullNameUTF8 );

	require_action( ok, exit, err = kDNSServiceErr_BadParam );


	// Convert the VARIANT

	ok = VariantToByteArray( &rdata, byteArray );

	require_action( ok, exit, err = kDNSServiceErr_Unknown );


	err = DNSServiceReconfirmRecord( flags, ifIndex, fullNameUTF8.c_str(), rrtype, rrclass, ( uint16_t ) byteArray.size(), byteArray.size() > 0 ? &byteArray[ 0 ] : NULL );

	require_noerr( err, exit );


exit:


	return err;

}


STDMETHODIMP CDNSSDService::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;

}


STDMETHODIMP CDNSSDService::GetAddrInfo(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, BSTR hostName, IDNSSDEventManager *eventManager, IDNSSDService **service)

{

	CComObject<CDNSSDService>	*	object			= NULL;

	DNSServiceRef					subord			= NULL;

	std::string						hostNameUTF8;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;

	BOOL							ok;


	check( m_primary );


	// 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 );

	object->AddRef();


	subord = m_primary;

	err = DNSServiceGetAddrInfo( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, addressFamily, hostNameUTF8.c_str(), ( DNSServiceGetAddrInfoReply ) &GetAddrInfoReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::NATPortMappingCreate(DNSSDFlags flags, ULONG ifIndex, DNSSDAddressFamily addressFamily, DNSSDProtocol protocol, USHORT internalPort, USHORT externalPort, ULONG ttl, IDNSSDEventManager *eventManager, IDNSSDService **service)

{

	CComObject<CDNSSDService>	*	object			= NULL;

	DNSServiceRef					subord			= NULL;

	DNSServiceProtocol				prot			= 0;

	DNSServiceErrorType				err				= 0;

	HRESULT							hr				= 0;


	check( m_primary );


	// Initialize

	*service = NULL;


	try

	{

		object = new CComObject<CDNSSDService>();

	}

	catch ( ... )

	{

		object = NULL;

	}


	require_action( object != NULL, exit, err = kDNSServiceErr_NoMemory );

	object->AddRef();


	prot = ( addressFamily | protocol );


	subord = m_primary;

	err = DNSServiceNATPortMappingCreate( &subord, flags | kDNSServiceFlagsShareConnection, ifIndex, prot, htons( internalPort ), htons( externalPort ), ttl, ( DNSServiceNATPortMappingReply ) &NATPortMappingReply, object );

	require_noerr( err, exit );


	object->SetPrimaryRef( m_primary );

	object->SetSubordRef( subord );

	object->SetEventManager( eventManager );


	*service = object;


exit:


	if ( err && object )

	{

		object->Release();

	}


	return err;

}


STDMETHODIMP CDNSSDService::Stop(void)

{

	if ( !m_stopped )

	{

		m_stopped = TRUE;


		dlog( kDebugLevelTrace, "Stop()\n" );


		if ( m_isPrimary && m_primary )

		{

			SocketMap::iterator it;


			if ( m_hiddenWindow )

			{

				WSAAsyncSelect( DNSServiceRefSockFD( m_primary ), m_hiddenWindow, 0, 0 );

			}


			it = m_socketMap.find( DNSServiceRefSockFD( m_primary ) );


			if ( it != m_socketMap.end() )

			{

				m_socketMap.erase( it );

			}


			DNSServiceRefDeallocate( m_primary );

			m_primary = NULL;

		}

		else if ( m_subord )

		{

			DNSServiceRefDeallocate( m_subord );

			m_subord = NULL;

		}


		if ( m_eventManager != NULL )

		{

			m_eventManager->Release();

			m_eventManager = NULL;

		}

	}


	return S_OK;

}


void DNSSD_API
CDNSSDService::DomainEnumReply
    (
    DNSServiceRef                       sdRef,
    DNSServiceFlags                     flags,
    uint32_t                            ifIndex,
    DNSServiceErrorType                 errorCode,
    const char                          *replyDomainUTF8,
    void                                *context
    )

{

	CComObject<CDNSSDService>	* service		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		CComBSTR replyDomain;

		BOOL ok;


		ok = UTF8ToBSTR( replyDomainUTF8, replyDomain );

		require_action( ok, exit, err = kDNSServiceErr_Unknown );


		if ( flags & kDNSServiceFlagsAdd )

		{

			eventManager->Fire_DomainFound( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );

		}

		else

		{

			eventManager->Fire_DomainLost( service, ( DNSSDFlags ) flags, ifIndex, replyDomain );

		}

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::BrowseReply
		(
		DNSServiceRef                       sdRef,
		DNSServiceFlags                     flags,
		uint32_t                            ifIndex,
		DNSServiceErrorType                 errorCode,
		const char                          *serviceNameUTF8,
		const char                          *regTypeUTF8,
		const char                          *replyDomainUTF8,
		void                                *context
		)

{

	CComObject<CDNSSDService>	* service		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		CComBSTR	serviceName;

		CComBSTR	regType;

		CComBSTR	replyDomain;


		UTF8ToBSTR( serviceNameUTF8, serviceName );

		UTF8ToBSTR( regTypeUTF8, regType );

		UTF8ToBSTR( replyDomainUTF8, replyDomain );


		if ( flags & kDNSServiceFlagsAdd )

		{

			eventManager->Fire_ServiceFound( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );

		}

		else

		{

			eventManager->Fire_ServiceLost( service, ( DNSSDFlags ) flags, ifIndex, serviceName, regType, replyDomain );

		}

	}


exit:


	return;

}


void DNSSD_API

CDNSSDService::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		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		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();


		if ( txtLen > 0 )

		{

			record->SetBytes( txtRecord, txtLen );

		}


		eventManager->Fire_ServiceResolved( service, ( DNSSDFlags ) flags, ifIndex, fullName, hostName, ntohs( port ), record );

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::RegisterReply
		(
		DNSServiceRef                       sdRef,
		DNSServiceFlags                     flags,
		DNSServiceErrorType                 errorCode,
		const char                          *serviceNameUTF8,
		const char                          *regTypeUTF8,
		const char                          *domainUTF8,
		void                                *context
		)

{

	CComObject<CDNSSDService>	* service		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		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 );


		eventManager->Fire_ServiceRegistered( service, ( DNSSDFlags ) flags, serviceName, regType, domain );

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::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		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		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 );


		eventManager->Fire_QueryRecordAnswered( service, ( DNSSDFlags ) flags, ifIndex, fullName, ( DNSSDRRType ) rrtype, ( DNSSDRRClass ) rrclass, var, ttl );

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::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		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		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 );


		eventManager->Fire_AddressFound( service, ( DNSSDFlags ) flags, ifIndex, hostName, addressFamily, address, ttl );

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::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		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	service = ( CComObject< CDNSSDService>* ) context;

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		eventManager->Fire_MappingCreated( service, ( DNSSDFlags ) flags, ifIndex, externalAddress, ( DNSSDAddressFamily ) ( protocol & 0x8 ), ( DNSSDProtocol ) ( protocol & 0x80 ), ntohs( internalPort ), ntohs( externalPort ), ttl  );

	}


exit:


	return;

}


void DNSSD_API
CDNSSDService::RegisterRecordReply
		(
		DNSServiceRef		sdRef,
		DNSRecordRef		RecordRef,
		DNSServiceFlags		flags,
		DNSServiceErrorType	errorCode,
		void				*context
		)

{

	CComObject<CDNSSDRecord>	* record		= NULL;

	CDNSSDService				* service		= NULL;

	CDNSSDEventManager			* eventManager	= NULL;

	int err = 0;


	record = ( CComObject< CDNSSDRecord >* ) context;

	require_action( record, exit, err = kDNSServiceErr_Unknown );

	service = record->GetServiceObject();

	require_action( service, exit, err = kDNSServiceErr_Unknown );


	if ( service->ShouldHandleReply( errorCode, eventManager ) )

	{

		eventManager->Fire_RecordRegistered( record, ( DNSSDFlags ) flags );

	}


exit:


	return;

}


BOOL

CDNSSDService::ShouldHandleReply( DNSServiceErrorType errorCode, CDNSSDEventManager *& eventManager )

{

	BOOL ok = FALSE;


	if ( !this->Stopped() )

	{

		eventManager = this->GetEventManager();

		require_action( eventManager, exit, ok = FALSE );


		if ( !errorCode )

		{

			ok = TRUE;

		}

		else

		{

			eventManager->Fire_OperationFailed( this, ( DNSSDError ) errorCode );

		}

	}


exit:


	return ok;

}


LRESULT CALLBACK

CDNSSDService::WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )

{

	if ( msg == WM_SOCKET )

	{

		SocketMap::iterator it;


		it = m_socketMap.find( ( SOCKET ) wParam );

		check( it != m_socketMap.end() );


		if ( it != m_socketMap.end() )

		{

			DNSServiceProcessResult( it->second->m_primary );

		}

	}


	return DefWindowProc(hWnd, msg, wParam, lParam);;

}