windows-xp/Source/XPSP1/NT/multimedia/directx/dplay/dpnathlp/dpnhupnp/dpnhupnpintfobj.cpp

/***************************************************************************
 *
 *  Copyright (C) 2001-2002 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:		dpnhupnpintfobj.cpp
 *
 *  Content:	DPNHUPNP main interface object class.
 *
 *  History:
 *   Date      By        Reason
 *  ========  ========  =========
 *  04/16/01  VanceO    Split DPNATHLP into DPNHUPNP and DPNHPAST.
 *
 ***************************************************************************/



#include "dpnhupnpi.h"





//=============================================================================
// Definitions
//=============================================================================
#define ACTIVE_MAPPING_VERSION							2					// version identifier for active mapping registry data

#define MAX_LONG_LOCK_WAITING_THREADS					0xFFFF				// that's a lot of simultaneous threads!

#define UPNP_SEARCH_MESSAGE_INTERVAL					499					// how often discovery multicast messages should be sent, in case of packet loss (note Win9x errata for values 500-1000ms)

#define UPNP_DGRAM_RECV_BUFFER_SIZE						1500
#define UPNP_STREAM_RECV_BUFFER_INITIAL_SIZE			(4 * 1024)			// 4 K, must be less than MAX_RECEIVE_BUFFER_SIZE

#define MAX_UPNP_HEADER_LENGTH							UPNP_STREAM_RECV_BUFFER_INITIAL_SIZE

#define LEASE_RENEW_TIME								120000				// renew if less than 2 minutes remaining

#define FAKE_PORT_LEASE_TIME							300000				// 5 minutes

#define IOCOMPLETE_WAIT_INTERVAL						100					// 100 ms between attempts
#define MAX_NUM_IOCOMPLETE_WAITS						10					// wait at most 1 second

#define MAX_NUM_HOMENETUNMAP_ATTEMPTS					3					// 3 tries
#define HOMENETUNMAP_SLEEP_FACTOR						10					// 10 ms, 20 ms, 30 ms


#define MAX_UPNP_MAPPING_DESCRIPTION_SIZE				256					// 255 characters + NULL termination

#define MAX_INSTANCENAMEDOBJECT_SIZE					64
#define INSTANCENAMEDOBJECT_FORMATSTRING				_T("DPNHUPnP Instance %u")

#define GUID_STRING_LENGTH								42					// maximum length of "{xxx...}" guid string, without NULL termination


#define PORTMAPPINGPROTOCOL_TCP							6
#define PORTMAPPINGPROTOCOL_UDP							17

#define MAX_RESERVED_PORT								1024

#define MAX_NUM_INSTANCE_EVENT_ATTEMPTS					5
#define MAX_NUM_RANDOM_PORT_TRIES						5

#ifdef DBG
#define MAX_TRANSACTION_LOG_SIZE						(5 * 1024 * 1024)	// 5 MB
#endif // DBG





#ifndef DPNBUILD_NOWINSOCK2
//=============================================================================
// WinSock 1 version of IP options
//=============================================================================
#define IP_MULTICAST_IF_WINSOCK1	2
#define IP_MULTICAST_TTL_WINSOCK1	3
#define IP_TTL_WINSOCK1				7
#endif // ! DPNBUILD_NOWINSOCK2




//=============================================================================
// Macros
//=============================================================================
//#ifdef _X86
#define IS_CLASSD_IPV4_ADDRESS(dwAddr)	(( (*((BYTE*) &(dwAddr))) & 0xF0) == 0xE0)	// 1110 high bits or 224.0.0.0 - 239.255.255.255 multicast address, in network byte order
#define NTOHS(x)						( (((x) >> 8) & 0x00FF) | (((x) << 8) & 0xFF00) )
#define HTONS(x)						NTOHS(x)
//#endif _X86




//=============================================================================
// HTTP/SSDP/SOAP/UPnP header strings (from upnpmsgs.h)
//=============================================================================
const char *	c_szResponseHeaders[] =
{
	//
	// Headers used in discovery response
	//
	"CACHE-CONTROL",
	"DATE",
	"EXT",
	"LOCATION",
	"SERVER",
	"ST",
	"USN",

	//
	// Additional headers used in description response
	//
	"CONTENT-LANGUAGE",
	"CONTENT-LENGTH",
	"CONTENT-TYPE",
	"TRANSFER-ENCODING",

	//
	// Other known headers
	//
	"HOST",
	"NT",
	"NTS",
	"MAN",
	"MX",
	"AL",
	"CALLBACK",
	"TIMEOUT",
	"SCOPE",
	"SID",
	"SEQ",
};






//=============================================================================
// Pre-built UPnP message strings (from upnpmsgs.h)
//=============================================================================

const char		c_szUPnPMsg_Discover_Service_WANIPConnection[] = "M-SEARCH * " HTTP_VERSION EOL
																"HOST: " UPNP_DISCOVERY_MULTICAST_ADDRESS ":" UPNP_PORT_A EOL
																"MAN: \"ssdp:discover\"" EOL
																"MX: 2" EOL
																"ST: " URI_SERVICE_WANIPCONNECTION_A EOL
																EOL;

const char		c_szUPnPMsg_Discover_Service_WANPPPConnection[] = "M-SEARCH * " HTTP_VERSION EOL
																"HOST: " UPNP_DISCOVERY_MULTICAST_ADDRESS ":" UPNP_PORT_A EOL
																"MAN: \"ssdp:discover\"" EOL
																"MX: 2" EOL
																"ST: " URI_SERVICE_WANPPPCONNECTION_A EOL
																EOL;


//
// The disclaimer:
//
// A UPnP device may implement both the WANIPConnection and WANPPPConnection
// services.  We do not have any fancy logic to pick one, we just use the first
// device that responds to our discovery requests, and use the first matching
// service we encounter in the device description XML.
//
// Additionally, future UPnP devices may wish to present multiple device or
// service instances with the intention that one client gets control of the
// entire instance (additional clients would need to use a different instance).
// It's not clear to me what a UPnP device (or client, for that matter) would
// really gain by having such a setup.  I imagine a new error code would have
// to be returned whenever a client tried to control an instance that another
// client already owned (don't ask me how it would know that, by picking the
// first user or selectively responding to discovery requests, I guess).
// Regardless, we do not currently support that.  As noted above, we pick the
// first instance and run with it. 
//


//
// Topmost <?xml> tag is considered optional for all XML and is ignored.
//


//
// This solution assumes InternetGatewayDevice (not WANDevice or
// WANConnectionDevice) will be the topmost item in the response.  This is based
// on the following UPnP spec excerpt:
//
//	"Note that a single physical device may include multiple logical devices.
//	 Multiple logical devices can be modeled as a single root device with
//	 embedded devices (and services) or as multiple root devices (perhaps with
//	 no embedded devices). In the former case, there is one UPnP device
//	 description for the root device, and that device description contains a
//	 description for all embedded devices. In the latter case, there are
//	 multiple UPnP device descriptions, one for each root device."
//
const char *	c_szElementStack_service[] =
{
	"root",
	"device",		// InternetGatewayDevice
	"deviceList",
	"device",		// WANDevice
	"deviceList",
	"device",		// WANConnectionDevice
	"serviceList",
	"service"
};



/*
const char *	c_szElementStack_QueryStateVariableResponse[] =
{
	"Envelope",
	"Body",
	CONTROL_QUERYSTATEVARIABLE_A CONTROL_RESPONSESUFFIX_A
};
*/
const char *	c_szElementStack_GetExternalIPAddressResponse[] =
{
	"Envelope",
	"Body",
	ACTION_GETEXTERNALIPADDRESS_A CONTROL_RESPONSESUFFIX_A
};

const char *	c_szElementStack_AddPortMappingResponse[] =
{
	"Envelope",
	"Body",
	ACTION_ADDPORTMAPPING_A CONTROL_RESPONSESUFFIX_A
};

const char *	c_szElementStack_GetSpecificPortMappingEntryResponse[] =
{
	"Envelope",
	"Body",
	ACTION_GETSPECIFICPORTMAPPINGENTRY_A CONTROL_RESPONSESUFFIX_A
};

const char *	c_szElementStack_DeletePortMappingResponse[] =
{
	"Envelope",
	"Body",
	ACTION_DELETEPORTMAPPING_A CONTROL_RESPONSESUFFIX_A
};


const char *	c_szElementStack_ControlResponseFailure[] =
{
	"Envelope",
	"Body",
	"Fault",
	"detail",
	"UPnPError"
};




#ifdef WINNT
//=============================================================================
// Related UPnP services
//=============================================================================
TCHAR *		c_tszUPnPServices[] =
{
	_T("SSDPSRV"),	// SSDP Discovery Service
	_T("UPNPHOST"),	// Universal Plug and Play Device Host - we key off this even though it's for device hosts instead of control points
};
#endif // WINNT





//=============================================================================
// Local structures
//=============================================================================
typedef struct _CONTROLRESPONSEPARSECONTEXT
{
	CONTROLRESPONSETYPE			ControlResponseType;	// type of control response expected
	CUPnPDevice *				pUPnPDevice;			// pointer to UPnP device being used
	DWORD						dwHTTPResponseCode;		// HTTP response code for this message
	PUPNP_CONTROLRESPONSE_INFO	pControlResponseInfo;	// place to info returned in control response
} CONTROLRESPONSEPARSECONTEXT, * PCONTROLRESPONSEPARSECONTEXT;

typedef struct _DPNHACTIVEFIREWALLMAPPING
{
	DWORD	dwVersion;		// version identifier for this mapping
	DWORD	dwInstanceKey;	// key identifying DPNHUPNP instance that created this mapping
	DWORD	dwFlags;		// flags describing port being registered
	DWORD	dwAddressV4;	// address being mapped
	WORD	wPort;			// port being mapped
} DPNHACTIVEFIREWALLMAPPING, * PDPNHACTIVEFIREWALLMAPPING;

typedef struct _DPNHACTIVENATMAPPING
{
	DWORD	dwVersion;				// version identifier for this mapping
	DWORD	dwInstanceKey;			// key identifying DPNHUPNP instance that created this mapping
	DWORD	dwUPnPDeviceID;			// identifier for particular UPnP device corresponding to this mapping (meaningful only to owning instance)
	DWORD	dwFlags;				// flags describing port being registered
	DWORD	dwInternalAddressV4;	// internal client address being mapped
	WORD	wInternalPort;			// internal client port being mapped
	DWORD	dwExternalAddressV4;	// external public address that was mapped
	WORD	wExternalPort;			// external public port that was mapped
} DPNHACTIVENATMAPPING, * PDPNHACTIVENATMAPPING;






//=============================================================================
// Local functions
//=============================================================================
VOID strtrim(CHAR ** pszStr);

#ifdef WINCE
void GetExeName(WCHAR * wszPath);
#endif // WINCE





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CNATHelpUPnP"
//=============================================================================
// CNATHelpUPnP constructor
//-----------------------------------------------------------------------------
//
// Description: Initializes the new CNATHelpUPnP object.
//
// Arguments:
//	BOOL fNotCreatedWithCOM		- TRUE if this object is being instantiated
//									without COM, FALSE if it is through COM.
//
// Returns: None (the object).
//=============================================================================
CNATHelpUPnP::CNATHelpUPnP(const BOOL fNotCreatedWithCOM)
{
	this->m_blList.Initialize();


	this->m_Sig[0]	= 'N';
	this->m_Sig[1]	= 'A';
	this->m_Sig[2]	= 'T';
	this->m_Sig[3]	= 'H';

	this->m_lRefCount						= 1; // someone must have a pointer to this object

	if (fNotCreatedWithCOM)
	{
		this->m_dwFlags						= NATHELPUPNPOBJ_NOTCREATEDWITHCOM;
	}
	else
	{
		this->m_dwFlags						= 0;
	}

	this->m_hLongLockSemaphore				= NULL;
	this->m_lNumLongLockWaitingThreads		= 0;
	this->m_dwLockThreadID					= 0;
#ifndef DPNBUILD_NOWINSOCK2
	this->m_hAlertEvent						= NULL;
	this->m_hAlertIOCompletionPort			= NULL;
	this->m_dwAlertCompletionKey			= 0;
#endif // ! DPNBUILD_NOWINSOCK2

	this->m_blDevices.Initialize();
	this->m_blRegisteredPorts.Initialize();
	this->m_blUnownedPorts.Initialize();

	this->m_dwLastUpdateServerStatusTime	= 0;
	this->m_dwNextPollInterval				= 0;
	this->m_dwNumLeases						= 0;
	this->m_dwEarliestLeaseExpirationTime	= 0;

	this->m_blUPnPDevices.Initialize();
	this->m_dwInstanceKey					= 0;
	this->m_dwCurrentUPnPDeviceID			= 0;
	this->m_hMappingStillActiveNamedObject	= NULL;

#ifndef DPNBUILD_NOWINSOCK2
	this->m_hIpHlpApiDLL					= NULL;
	this->m_pfnGetAdaptersInfo				= NULL;
	this->m_pfnGetIpForwardTable			= NULL;
	this->m_pfnGetBestRoute					= NULL;

	this->m_hRasApi32DLL					= NULL;
	this->m_pfnRasGetEntryHrasconnW			= NULL;
	this->m_pfnRasGetProjectionInfo			= NULL;

	this->m_sIoctls							= INVALID_SOCKET;
	this->m_polAddressListChange			= NULL;
#endif // ! DPNBUILD_NOWINSOCK2

	this->m_hWinSockDLL						= NULL;
	this->m_pfnWSAStartup					= NULL;
	this->m_pfnWSACleanup					= NULL;
	this->m_pfnWSAGetLastError				= NULL;
	this->m_pfnsocket						= NULL;
	this->m_pfnclosesocket					= NULL;
	this->m_pfnbind							= NULL;
	this->m_pfnsetsockopt					= NULL;
	this->m_pfngetsockname					= NULL;
	this->m_pfnselect						= NULL;
	this->m_pfn__WSAFDIsSet					= NULL;
	this->m_pfnrecvfrom						= NULL;
	this->m_pfnsendto						= NULL;
	this->m_pfngethostname					= NULL;
	this->m_pfngethostbyname				= NULL;
	this->m_pfninet_addr					= NULL;
#ifndef DPNBUILD_NOWINSOCK2
	this->m_pfnWSASocketA					= NULL;
	this->m_pfnWSAIoctl						= NULL;
	this->m_pfnWSAGetOverlappedResult		= NULL;
#endif // ! DPNBUILD_NOWINSOCK2
	this->m_pfnioctlsocket					= NULL;
	this->m_pfnconnect						= NULL;
	this->m_pfnshutdown						= NULL;
	this->m_pfnsend							= NULL;
	this->m_pfnrecv							= NULL;
#ifdef DBG
	this->m_pfngetsockopt					= NULL;

	this->m_dwNumDeviceAdds					= 0;
	this->m_dwNumDeviceRemoves				= 0;
	this->m_dwNumServerFailures				= 0;
#endif // DBG
} // CNATHelpUPnP::CNATHelpUPnP






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::~CNATHelpUPnP"
//=============================================================================
// CNATHelpUPnP destructor
//-----------------------------------------------------------------------------
//
// Description: Frees the CNATHelpUPnP object.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
CNATHelpUPnP::~CNATHelpUPnP(void)
{
	DPFX(DPFPREP, 8, "(0x%p) NumDeviceAdds = %u, NumDeviceRemoves = %u, NumServerFailures = %u",
		this, this->m_dwNumDeviceAdds, this->m_dwNumDeviceRemoves,
		this->m_dwNumServerFailures);


	DNASSERT(this->m_blList.IsEmpty());


	DNASSERT(this->m_lRefCount == 0);
	DNASSERT((this->m_dwFlags & ~NATHELPUPNPOBJ_NOTCREATEDWITHCOM) == 0);

	DNASSERT(this->m_hLongLockSemaphore == NULL);
	DNASSERT(this->m_lNumLongLockWaitingThreads == 0);
	DNASSERT(this->m_dwLockThreadID == 0);
#ifndef DPNBUILD_NOWINSOCK2
	DNASSERT(this->m_hAlertEvent == NULL);
	DNASSERT(this->m_hAlertIOCompletionPort == NULL);
#endif // ! DPNBUILD_NOWINSOCK2

	DNASSERT(this->m_blDevices.IsEmpty());
	DNASSERT(this->m_blRegisteredPorts.IsEmpty());
	DNASSERT(this->m_blUnownedPorts.IsEmpty());

	DNASSERT(this->m_dwNumLeases == 0);

	DNASSERT(this->m_blUPnPDevices.IsEmpty());
	DNASSERT(this->m_hMappingStillActiveNamedObject == NULL);

#ifndef DPNBUILD_NOWINSOCK2
	DNASSERT(this->m_hIpHlpApiDLL == NULL);
	DNASSERT(this->m_hRasApi32DLL == NULL);
	DNASSERT(this->m_hWinSockDLL == NULL);

	DNASSERT(this->m_sIoctls == INVALID_SOCKET);
	DNASSERT(this->m_polAddressListChange == NULL);
#endif // ! DPNBUILD_NOWINSOCK2


	//
	// For grins, change the signature before deleting the object.
	//
	this->m_Sig[3]	= 'h';
} // CNATHelpUPnP::~CNATHelpUPnP




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::QueryInterface"
//=============================================================================
// CNATHelpUPnP::QueryInterface
//-----------------------------------------------------------------------------
//
// Description: Retrieves a new reference for an interfaces supported by this
//				CNATHelpUPnP object.
//
// Arguments:
//	REFIID riid			- Reference to interface ID GUID.
//	LPVOID * ppvObj		- Place to store pointer to object.
//
// Returns: HRESULT
//	S_OK					- Returning a valid interface pointer.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPOINTER	- The destination pointer is invalid.
//	E_NOINTERFACE			- Invalid interface was specified.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
	HRESULT		hr = DPNH_OK;


	DPFX(DPFPREP, 3, "(0x%p) Parameters: (REFIID, 0x%p)", this, ppvObj);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid NATHelper object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if ((! IsEqualIID(riid, IID_IUnknown)) &&
		(! IsEqualIID(riid, IID_IDirectPlayNATHelp)))
	{
		DPFX(DPFPREP, 0, "Unsupported interface!");
		hr = E_NOINTERFACE;
		goto Failure;
	}

	if ((ppvObj == NULL) ||
		(IsBadWritePtr(ppvObj, sizeof(void*))))
	{
		DPFX(DPFPREP, 0, "Invalid interface pointer specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}


	//
	// Add a reference, and return the interface pointer (which is actually
	// just the object pointer, they line up because CNATHelpUPnP inherits from
	// the interface declaration).
	//
	this->AddRef();
	(*ppvObj) = this;


Exit:

	DPFX(DPFPREP, 3, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::QueryInterface




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::AddRef"
//=============================================================================
// CNATHelpUPnP::AddRef
//-----------------------------------------------------------------------------
//
// Description: Adds a reference to this CNATHelpUPnP object.
//
// Arguments: None.
//
// Returns: New refcount.
//=============================================================================
STDMETHODIMP_(ULONG) CNATHelpUPnP::AddRef(void)
{
	LONG	lRefCount;


	DNASSERT(this->IsValidObject());


	//
	// There must be at least 1 reference to this object, since someone is
	// calling AddRef.
	//
	DNASSERT(this->m_lRefCount > 0);

	lRefCount = InterlockedIncrement(&this->m_lRefCount);

	DPFX(DPFPREP, 3, "[0x%p] RefCount [0x%lx]", this, lRefCount);

	return lRefCount;
} // CNATHelpUPnP::AddRef




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::Release"
//=============================================================================
// CNATHelpUPnP::Release
//-----------------------------------------------------------------------------
//
// Description: Removes a reference to this CNATHelpUPnP object.  When the
//				refcount reaches 0, this object is destroyed.
//				You must NULL out your pointer to this object after calling
//				this function.
//
// Arguments: None.
//
// Returns: New refcount.
//=============================================================================
STDMETHODIMP_(ULONG) CNATHelpUPnP::Release(void)
{
	LONG	lRefCount;


	DNASSERT(this->IsValidObject());

	//
	// There must be at least 1 reference to this object, since someone is
	// calling Release.
	//
	DNASSERT(this->m_lRefCount > 0);

	lRefCount = InterlockedDecrement(&this->m_lRefCount);

	//
	// Was that the last reference?  If so, we're going to destroy this object.
	//
	if (lRefCount == 0)
	{
		DPFX(DPFPREP, 3, "[0x%p] RefCount hit 0, destroying object.", this);

		//
		// First pull it off the global list.
		//
		DNEnterCriticalSection(&g_csGlobalsLock);

		this->m_blList.RemoveFromList();

		DNASSERT(g_lOutstandingInterfaceCount > 0);
		g_lOutstandingInterfaceCount--;	// update count so DLL can unload now works correctly
		
		DNLeaveCriticalSection(&g_csGlobalsLock);


		//
		// Make sure it's closed.
		//
		if (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED)
		{
			//
			// Assert so that the user can fix his/her broken code!
			//
			DNASSERT(! "DirectPlayNATHelpUPNP object being released without calling Close first!");

			//
			// Then go ahead and do the right thing.  Ignore error, we can't do
			// much about it.
			//
			this->Close(0);
		}


		//
		// Then uninitialize the object.
		//
		this->UninitializeObject();

		//
		// Finally delete this (!) object.
		//
		delete this;
	}
	else
	{
		DPFX(DPFPREP, 3, "[0x%p] RefCount [0x%lx]", this, lRefCount);
	}

	return lRefCount;
} // CNATHelpUPnP::Release




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::Initialize"
//=============================================================================
// CNATHelpUPnP::Initialize
//-----------------------------------------------------------------------------
//
// Description:    Prepares the object for use.  No attempt is made to contact
//				any Internet gateway servers at this time.  The user should
//				call GetCaps with the DPNHGETCAPS_UPDATESERVERSTATUS flag to
//				search for a server.
//
//				   Initialize must be called before using any other function,
//				and must be balanced with a call to Close.  Initialize can only
//				be called once unless Close returns it to the uninitialized
//				state.
//
//				   One of DPNHINITIALIZE_DISABLEREMOTENATSUPPORT or
//				DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT may be specified,
//				but not both.
//
// Arguments:
//	DWORD dwFlags	- Flags to use when initializing.
//
// Returns: HRESULT
//	DPNH_OK						- Initialization was successful.
//	DPNHERR_ALREADYINITIALIZED	- Initialize has already been called.
//	DPNHERR_GENERIC				- An error occurred while initializing.
//	DPNHERR_INVALIDFLAGS		- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT		- The interface object is invalid.
//	DPNHERR_INVALIDPARAM		- An invalid parameter was specified.
//	DPNHERR_OUTOFMEMORY			- There is not enough memory to initialize.
//	DPNHERR_REENTRANT			- The interface has been re-entered on the same
//									thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::Initialize(const DWORD dwFlags)
{
	HRESULT						hr;
	BOOL						fHaveLock = FALSE;
	BOOL						fSetFlags = FALSE;
#ifndef WINCE
	OSVERSIONINFO				osvi;
#endif // ! WINCE
	BOOL						fWinSockStarted = FALSE;
	WSADATA						wsadata;
	int							iError;
#ifndef DPNBUILD_NOWINSOCK2
	SOCKADDR_IN					saddrinTemp;
#endif // ! DPNBUILD_NOWINSOCK2
	TCHAR						tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	PSECURITY_ATTRIBUTES		pSecurityAttributes;
	DWORD						dwTry;
#ifdef WINNT
	SID_IDENTIFIER_AUTHORITY	SidIdentifierAuthorityWorld = SECURITY_WORLD_SID_AUTHORITY;
	PSID						pSid = NULL;
	DWORD						dwAclLength;
	ACL *						pAcl = NULL;
	BYTE						abSecurityDescriptorBuffer[SECURITY_DESCRIPTOR_MIN_LENGTH];
	SECURITY_ATTRIBUTES			SecurityAttributes;
#endif // WINNT
#ifdef DBG
	DWORD						dwError;
#endif // DBG


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%lx)", this, dwFlags);


#ifndef WINCE
	//
	// Print info about the current build. 
	//
#ifdef WINNT
	DPFX(DPFPREP, 7, "Build type = NT, platform = %s",
		((DNGetOSType() == VER_PLATFORM_WIN32_NT) ? _T("NT") : _T("9x")));
#else // ! WINNT
	DPFX(DPFPREP, 7, "Build type = 9x, platform = %s, filedate = %s",
		((DNGetOSType() == VER_PLATFORM_WIN32_NT) ? _T("NT") : _T("9x")));
#endif // ! WINNT
#endif // ! WINCE


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;

		//
		// Skip the failure cleanup code, we haven't set anything up.
		//
		goto Exit;
	}


	//
	// Validate the parameters.
	//

	if (dwFlags & ~(DPNHINITIALIZE_DISABLEGATEWAYSUPPORT | DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT))
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;

		//
		// Skip the failure cleanup code, we haven't set anything up.
		//
		goto Exit;
	}

	//
	// Both flags cannot be specified at the same time.  If the caller doesn't
	// want any NAT functionality, why use this object all?
	//
	if ((dwFlags & (DPNHINITIALIZE_DISABLEGATEWAYSUPPORT | DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT)) == (DPNHINITIALIZE_DISABLEGATEWAYSUPPORT | DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT))
	{
		DPFX(DPFPREP, 0, "Either DISABLEGATEWAYSUPPORT flag or DISABLELOCALFIREWALLSUPPORT flag can be used, but not both!");
		hr = DPNHERR_INVALIDFLAGS;

		//
		// Skip the failure cleanup code, we haven't set anything up.
		//
		goto Exit;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");

		//
		// Skip the failure cleanup code, we haven't set anything up.
		//
		goto Exit;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if ((this->m_dwFlags & ~NATHELPUPNPOBJ_NOTCREATEDWITHCOM) != 0)
	{
		DPFX(DPFPREP, 0, "Object already initialized!");
		hr = DPNHERR_ALREADYINITIALIZED;

		//
		// Skip the failure cleanup code, we haven't set anything up.
		//
		goto Exit;
	}


	//
	// Read in the manual override settings from the registry
	//
	ReadRegistrySettings();


	//
	// We're not completely initialized yet, but set the flag(s) now.
	//
	this->m_dwFlags |= NATHELPUPNPOBJ_INITIALIZED;
	fSetFlags = TRUE;


	//
	// Store the user's settings.
	//

	if (dwFlags & DPNHINITIALIZE_DISABLEGATEWAYSUPPORT)
	{
		DPFX(DPFPREP, 1, "User requested that Internet gateways not be supported.");
	}
	else
	{
		this->m_dwFlags |= NATHELPUPNPOBJ_USEUPNP;
	}

#ifndef DPNBUILD_NOHNETFWAPI
	if (dwFlags & DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT)
	{
		DPFX(DPFPREP, 1, "User requested that local firewalls not be supported.");
	}
	else
	{
		this->m_dwFlags |= NATHELPUPNPOBJ_USEHNETFWAPI;
	}
#endif // ! DPNBUILD_NOHNETFWAPI


	switch (g_dwUPnPMode)
	{
		case OVERRIDEMODE_FORCEON:
		{
			//
			// Force UPnP on.
			//
			DPFX(DPFPREP, 1, "Forcing UPnP support on.");
			this->m_dwFlags |= NATHELPUPNPOBJ_USEUPNP;
			break;
		}

		case OVERRIDEMODE_FORCEOFF:
		{
			//
			// Force UPnP off.
			//
			DPFX(DPFPREP, 1, "Forcing UPnP support off.");
			this->m_dwFlags &= ~NATHELPUPNPOBJ_USEUPNP;
			break;
		}

		default:
		{
			//
			// Leave UPnP settings as they were set by the application.
			//
#ifdef WINNT
			//
			// But if UPnP related service(s) are disabled, we'll take that as
			// our cue to not use UPnP NAT traversal even though we don't
			// actually use those services.  We assume the user wanted to
			// squelch all SSDP/UPnP activity.  It can still be forced back on
			// with a reg key, though, as indicated by the other switch cases.
			//
			if (this->IsUPnPServiceDisabled())
			{
				DPFX(DPFPREP, 1, "Not using UPnP because a related service was disabled.");
				this->m_dwFlags &= ~NATHELPUPNPOBJ_USEUPNP;
			}
#endif // WINNT
			break;
		}
	}

#ifndef DPNBUILD_NOHNETFWAPI
	switch (g_dwHNetFWAPIMode)
	{
		case OVERRIDEMODE_FORCEON:
		{
			//
			// Force HNet firewall API on.
			//
			DPFX(DPFPREP, 1, "Forcing HNet firewall API support on.");
			this->m_dwFlags |= NATHELPUPNPOBJ_USEHNETFWAPI;
			break;
		}

		case OVERRIDEMODE_FORCEOFF:
		{
			//
			// Force HNet firewall API off.
			//
			DPFX(DPFPREP, 1, "Forcing HNet firewall API support off.");
			this->m_dwFlags &= ~NATHELPUPNPOBJ_USEHNETFWAPI;
			break;
		}

		default:
		{
			//
			// Leave HNet firewall API settings alone.
			//
			break;
		}
	}
#endif // ! DPNBUILD_NOHNETFWAPI


#ifndef WINCE
	//
	// Determine whether we're on a Win2K or higher NT OS, and if so, use the
	// "Global\\" prefix for named kernel objects so we can have Terminal
	// Server and Fast User Switching support.
	//
	ZeroMemory(&osvi, sizeof(osvi));
	osvi.dwOSVersionInfoSize = sizeof(osvi);
	if (GetVersionEx(&osvi))
	{
		if ((osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
			(osvi.dwMajorVersion >= 5))
		{
			DPFX(DPFPREP, 8, "Running Win2K or higher NT OS, using \"Global\\\" prefix.");
			this->m_dwFlags |= NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX;
		}
#ifdef DBG
		else
		{
			DPFX(DPFPREP, 8, "Not on NT, or its pre-Win2K, not using \"Global\\\" prefix.");
		}
#endif // DBG
	}
#ifdef DBG
else
	{
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't get OS version information (err = %u)!  Not using \"Global\\\" prefix.",
			dwError);
	}
#endif // DBG
#endif // ! WINCE


#ifdef DPNBUILD_NOWINSOCK2
#if defined(WINCE) && !defined(WINCE_ON_DESKTOP)
	this->m_hWinSockDLL = LoadLibrary( _T("winsock.dll") );
#else // ! WINCE
	this->m_hWinSockDLL = LoadLibrary( _T("wsock32.dll") );
#endif // ! WINCE
	if (this->m_hWinSockDLL == NULL)
	{
#ifdef DBG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't load WinSock 1 DLL (err = 0x%lx)!.",
			dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}
#else // ! DPNBUILD_NOWINSOCK2
	//
	// Try loading the IP helper DLL.
	//
	this->m_hIpHlpApiDLL = LoadLibrary( _T("iphlpapi.dll") );
	if (this->m_hIpHlpApiDLL == NULL)
	{
#ifdef DBG
		dwError = GetLastError();
		DPFX(DPFPREP, 1, "Unable to load \"iphlpapi.dll\" (error = 0x%lx).",
			dwError);
#endif // DBG

		//
		// That's not fatal, we can still function.
		//
	}
	else
	{
		//
		// Load the functions we'll use.
		//

		this->m_pfnGetAdaptersInfo = (PFN_GETADAPTERSINFO) GetProcAddress(this->m_hIpHlpApiDLL,
																		_TWINCE("GetAdaptersInfo"));
		if (this->m_pfnGetAdaptersInfo == NULL)
		{
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Unable to get \"GetAdaptersInfo\" function (error = 0x%lx)!",
				dwError);
#endif // DBG
			goto Exit;
		}

		this->m_pfnGetIpForwardTable = (PFN_GETIPFORWARDTABLE) GetProcAddress(this->m_hIpHlpApiDLL,
																			_TWINCE("GetIpForwardTable"));
		if (this->m_pfnGetIpForwardTable == NULL)
		{
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Unable to get \"GetIpForwardTable\" function (error = 0x%lx)!",
				dwError);
#endif // DBG
			goto Exit;
		}

		this->m_pfnGetBestRoute = (PFN_GETBESTROUTE) GetProcAddress(this->m_hIpHlpApiDLL,
																	_TWINCE("GetBestRoute"));
		if (this->m_pfnGetBestRoute == NULL)
		{
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Unable to get \"GetBestRoute\" function (error = 0x%lx)!",
				dwError);
#endif // DBG
			goto Exit;
		}
	}



	//
	// Try loading the RAS API DLL.
	//
	this->m_hRasApi32DLL = LoadLibrary( _T("rasapi32.dll") );
	if (this->m_hRasApi32DLL == NULL)
	{
#ifdef DBG
		dwError = GetLastError();
		DPFX(DPFPREP, 1, "Unable to load \"rasapi32.dll\" (error = 0x%lx).",
			dwError);
#endif // DBG

		//
		// That's not fatal, we can still function.
		//
	}
	else
	{
		//
		// Load the functions we'll use.
		//

		this->m_pfnRasGetEntryHrasconnW = (PFN_RASGETENTRYHRASCONNW) GetProcAddress(this->m_hRasApi32DLL,
																					_TWINCE("RasGetEntryHrasconnW"));
		if (this->m_pfnRasGetEntryHrasconnW == NULL)
		{
			//
			// This function does not exist on non-NT platforms.  That's fine,
			// just dump the DLL handle so we don't try to use it.
			//
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 1, "Unable to get \"RasGetEntryHrasconnW\" function (error = 0x%lx), forgetting RAS DLL.",
				dwError);
#endif // DBG

			FreeLibrary(this->m_hRasApi32DLL);
			this->m_hRasApi32DLL = NULL;
		}
		else
		{
			this->m_pfnRasGetProjectionInfo = (PFN_RASGETPROJECTIONINFO) GetProcAddress(this->m_hRasApi32DLL,
#ifdef UNICODE
																						_TWINCE("RasGetProjectionInfoW"));
#else // ! UNICODE
																						_TWINCE("RasGetProjectionInfoA"));
#endif // ! UNICODE
			if (this->m_pfnRasGetProjectionInfo == NULL)
			{
#ifdef DBG
				dwError = GetLastError();
				DPFX(DPFPREP, 0, "Unable to get \"RasGetProjectionInfoA/W\" function (error = 0x%lx)!",
					dwError);
#endif // DBG
				goto Exit;
			}
		}
	}


	//
	// Load WinSock because we may be using our private UPnP implementation, or
	// we just need to get the devices.
	//
	this->m_hWinSockDLL = LoadLibrary( _T("ws2_32.dll") );
	if (this->m_hWinSockDLL == NULL)
	{
#ifdef DBG
		dwError = GetLastError();
		DPFX(DPFPREP, 1, "Couldn't load \"ws2_32.dll\" (err = 0x%lx), resorting to WinSock 1 functionality.",
			dwError);
#endif // DBG

		this->m_hWinSockDLL = LoadLibrary( _T("wsock32.dll") );
		if (this->m_hWinSockDLL == NULL)
		{
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Couldn't load \"wsock32.dll\" either (err = 0x%lx)!.",
				dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		//
		// Remember that we had to resort to WinSock 1.
		//
		this->m_dwFlags |= NATHELPUPNPOBJ_WINSOCK1;
	}
	else
	{
		DPFX(DPFPREP, 1, "Loaded \"ws2_32.dll\", using WinSock 2 functionality.");
	}
#endif // DPNBUILD_NOWINSOCK2


	//
	// Load pointers to all the functions we use in WinSock.
	//
	hr = this->LoadWinSockFunctionPointers();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't load WinSock function pointers!");
		goto Failure;
	}


	//
	// Fire up WinSock.  Request 2.2 if we can.  For the most part we only use
	// version 1.1 capabilities and interfaces anyway.  The only exceptions are
	// using the event or I/O completion port handles for notification.
	//
	ZeroMemory(&wsadata, sizeof(wsadata));

#ifndef DPNBUILD_NOWINSOCK2
	if (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1)
	{
#endif // ! DPNBUILD_NOWINSOCK2
		iError = this->m_pfnWSAStartup(MAKEWORD(1, 1), &wsadata);
#ifndef DPNBUILD_NOWINSOCK2
	}
	else
	{
		iError = this->m_pfnWSAStartup(MAKEWORD(2, 2), &wsadata);
	}
#endif // ! DPNBUILD_NOWINSOCK2
	if (iError != 0)
	{
		DPFX(DPFPREP, 0, "Couldn't startup WinSock (error = %i)!", iError);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	fWinSockStarted = TRUE;

	DPFX(DPFPREP, 4, "Initialized WinSock version %u.%u.",
		LOBYTE(wsadata.wVersion), HIBYTE(wsadata.wVersion));



#ifndef DPNBUILD_NOWINSOCK2
	//
	// Try creating a UDP socket for use with WSAIoctl.  Do this even if we're
	// WinSock 1 and can't use WSAIoctl socket.  This allows us to make sure
	// TCP/IP is installed and working.
	//

	this->m_sIoctls = this->m_pfnsocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (this->m_sIoctls == INVALID_SOCKET)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Couldn't create Ioctl socket, error = %u!", dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Try binding the socket.  This is a continuation of the validation.
	//
	ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
	saddrinTemp.sin_family				= AF_INET;
	//saddrinTemp.sin_addr.S_un.S_addr	= INADDR_ANY;
	//saddrinTemp.sin_port				= 0;

	if (this->m_pfnbind(this->m_sIoctls,
						(SOCKADDR *) (&saddrinTemp),
						sizeof(saddrinTemp)) != 0)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Couldn't bind the Ioctl socket to arbitrary port on any interface, error = %u!",
			dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}
#endif // ! DPNBUILD_NOWINSOCK2


	//
	// Build appropriate access control structures.  On NT, we want to allow
	// read access to everyone.  On other platforms, security is ignored.
	//
#ifdef WINNT
	if (! AllocateAndInitializeSid(&SidIdentifierAuthorityWorld,
									1,
									SECURITY_WORLD_RID,
									0,
									0,
									0,
									0,
									0,
									0,
									0,
									&pSid))
	{
#ifdef DEBUG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't allocate and initialize SID, error = %u!",
			dwError);
#endif // DEBUG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	dwAclLength = sizeof(ACL)
					+ sizeof(ACCESS_ALLOWED_ACE)
					- sizeof(DWORD)					// subtract out sizeof(ACCESS_ALLOWED_ACE.SidStart)
					+ GetLengthSid(pSid);

	pAcl = (ACL*) DNMalloc(dwAclLength);
	if (pAcl == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	if (! InitializeAcl(pAcl, dwAclLength, ACL_REVISION))
	{
#ifdef DEBUG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't initialize ACL, error = %u!",
			dwError);
#endif // DEBUG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if (! AddAccessAllowedAce(pAcl, ACL_REVISION, SYNCHRONIZE, pSid))
	{
#ifdef DEBUG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't add access allowed ACE, error = %u!",
			dwError);
#endif // DEBUG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if (! InitializeSecurityDescriptor((PSECURITY_DESCRIPTOR) abSecurityDescriptorBuffer,
										SECURITY_DESCRIPTOR_REVISION))
	{
#ifdef DEBUG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't initialize security descriptor, error = %u!",
			dwError);
#endif // DEBUG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if (! SetSecurityDescriptorDacl((PSECURITY_DESCRIPTOR) abSecurityDescriptorBuffer,
									TRUE,
									pAcl,
									FALSE))
	{
#ifdef DEBUG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't set security descriptor DACL, error = %u!",
			dwError);
#endif // DEBUG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	SecurityAttributes.nLength					= sizeof(SecurityAttributes);
	SecurityAttributes.lpSecurityDescriptor		= abSecurityDescriptorBuffer;
	SecurityAttributes.bInheritHandle			= FALSE;

	pSecurityAttributes = &SecurityAttributes;
#else // ! WINNT
	pSecurityAttributes = NULL;
#endif // ! WINNT


	//
	// Use a random number for the instance key and event.  We use this to let
	// other instances know that we're alive to avoid the crash-cleanup code.
	// Try to create the named event a couple times before giving up.
	//
	dwTry = 0;
	do
	{
		this->m_dwInstanceKey = GetGlobalRand();
		DPFX(DPFPREP, 2, "Using crash cleanup key %u.", this->m_dwInstanceKey);

#ifndef WINCE
		if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
		{
			wsprintf(tszObjectName, _T("Global\\") INSTANCENAMEDOBJECT_FORMATSTRING, this->m_dwInstanceKey);
			this->m_hMappingStillActiveNamedObject = DNCreateEvent(pSecurityAttributes, FALSE, FALSE, tszObjectName);
		}
		else
#endif // ! WINCE
		{
			wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, this->m_dwInstanceKey);
			this->m_hMappingStillActiveNamedObject = DNCreateEvent(pSecurityAttributes, FALSE, FALSE, tszObjectName);
		}

		if (this->m_hMappingStillActiveNamedObject == NULL)
		{
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Couldn't create mapping-still-active named object, error = %u!", dwError);
#endif // DBG

			dwTry++;
			if (dwTry >= MAX_NUM_INSTANCE_EVENT_ATTEMPTS)
			{
				hr = DPNHERR_GENERIC;
				goto Failure;
			}

			//
			// Continue...
			//
		}
	}
	while (this->m_hMappingStillActiveNamedObject == NULL);

#ifdef WINNT
	DNFree(pAcl);
	pAcl = NULL;

	FreeSid(pSid);
	pSid = NULL;
#endif // WINNT


	//
	// Build the list of IP capable devices.
	//
	hr = this->CheckForNewDevices(NULL);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't build device list!");
		goto Failure;
	}


	//
	// We could technically try to contact UPnP devices right now, but we don't
	// because it's a slow blocking operation, and users have to call GetCaps
	// at least once anyway.
	//


Exit:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (this->m_hMappingStillActiveNamedObject != NULL)
	{
		DNCloseHandle(this->m_hMappingStillActiveNamedObject);
		this->m_hMappingStillActiveNamedObject = NULL;
	}

#ifdef WINNT
	if (pAcl != NULL)
	{
		DNFree(pAcl);
		pAcl = NULL;
	}

	if (pSid != NULL)
	{
		FreeSid(pSid);
		pSid = NULL;
	}
#endif // WINNT

	this->RemoveAllItems();

#ifndef DPNBUILD_NOWINSOCK2
	if (this->m_sIoctls != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(this->m_sIoctls);	// ignore error
		this->m_sIoctls = INVALID_SOCKET;
	}
#endif // ! DPNBUILD_NOWINSOCK2

	if (fWinSockStarted)
	{
		this->m_pfnWSACleanup(); // ignore error
	}

#ifndef DPNBUILD_NOWINSOCK2
	if (this->m_hWinSockDLL != NULL)
	{
		this->m_pfnWSAStartup				= NULL;
		this->m_pfnWSACleanup				= NULL;
		this->m_pfnWSAGetLastError			= NULL;
		this->m_pfnsocket					= NULL;
		this->m_pfnclosesocket				= NULL;
		this->m_pfnbind						= NULL;
		this->m_pfnsetsockopt				= NULL;
		this->m_pfngetsockname				= NULL;
		this->m_pfnselect					= NULL;
		this->m_pfn__WSAFDIsSet				= NULL;
		this->m_pfnrecvfrom					= NULL;
		this->m_pfnsendto					= NULL;
		this->m_pfngethostname				= NULL;
		this->m_pfngethostbyname			= NULL;
		this->m_pfninet_addr				= NULL;
		this->m_pfnWSASocketA				= NULL;
		this->m_pfnWSAIoctl					= NULL;
		this->m_pfnWSAGetOverlappedResult	= NULL;
		this->m_pfnioctlsocket				= NULL;
		this->m_pfnconnect					= NULL;
		this->m_pfnshutdown					= NULL;
		this->m_pfnsend						= NULL;
		this->m_pfnrecv						= NULL;
#ifdef DBG
		this->m_pfngetsockopt				= NULL;
#endif // DBG


		this->m_dwFlags &= ~NATHELPUPNPOBJ_WINSOCK1;

		FreeLibrary(this->m_hWinSockDLL);
		this->m_hWinSockDLL = NULL;
	}

	if (this->m_hRasApi32DLL != NULL)
	{
		this->m_pfnRasGetEntryHrasconnW		= NULL;
		this->m_pfnRasGetProjectionInfo		= NULL;

		FreeLibrary(this->m_hRasApi32DLL);
		this->m_hRasApi32DLL = NULL;
	}

	if (this->m_hIpHlpApiDLL != NULL)
	{
		this->m_pfnGetAdaptersInfo			= NULL;
		this->m_pfnGetIpForwardTable		= NULL;
		this->m_pfnGetBestRoute				= NULL;

		FreeLibrary(this->m_hIpHlpApiDLL);
		this->m_hIpHlpApiDLL = NULL;
	}
#endif // ! DPNBUILD_NOWINSOCK2

	if (fSetFlags)
	{
		this->m_dwFlags &= ~(NATHELPUPNPOBJ_INITIALIZED |
							NATHELPUPNPOBJ_USEUPNP |
#ifndef DPNBUILD_NOHNETFWAPI
							NATHELPUPNPOBJ_USEHNETFWAPI |
#endif // ! DPNBUILD_NOHNETFWAPI
#ifdef WINCE
							NATHELPUPNPOBJ_DEVICECHANGED);
#else // ! WINCE
							NATHELPUPNPOBJ_DEVICECHANGED |
							NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX);
#endif // ! WINCE
	}

	goto Exit;
} // CNATHelpUPnP::Initialize






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::Close"
//=============================================================================
// CNATHelpUPnP::Close
//-----------------------------------------------------------------------------
//
// Description:    Shuts down and de-registers this application with any
//				Internet gateway servers.  All port assignments are implicitly
//				freed as a result of this operation.
//
//				   This must balance a successful call to Initialize.
//
// Arguments:
//	DWORD dwFlags	- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK					- Closing the helper API was successful.
//	DPNHERR_GENERIC			- An error occurred while closing.
//	DPNHERR_INVALIDFLAGS	- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPARAM	- An invalid parameter was specified.
//	DPNHERR_NOTINITIALIZED	- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY		- There is not enough memory to close.
//	DPNHERR_REENTRANT		- The interface has been re-entered on the same
//								thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::Close(const DWORD dwFlags)
{
	HRESULT		hr;
	BOOL		fHaveLock = FALSE;
	int			iError;
#ifdef DBG
	DWORD		dwError;
#endif // DBG


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%lx)", this, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if (dwFlags != 0)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}


	//
	// We need to actively deregister any devices which are registered with
	// Internet gateways.
	//
	this->RemoveAllItems();


	//
	// Close the named object since this process is going away.
	//
	if (this->m_hMappingStillActiveNamedObject != NULL)
	{
		DNCloseHandle(this->m_hMappingStillActiveNamedObject);
		this->m_hMappingStillActiveNamedObject = NULL;
	}


#ifndef DPNBUILD_NOWINSOCK2
	//
	// Close the Ioctl socket.
	//
	DNASSERT(this->m_sIoctls != INVALID_SOCKET);
	this->m_pfnclosesocket(this->m_sIoctls);	// ignore error
	this->m_sIoctls = INVALID_SOCKET;



	//
	// If we submitted overlapped I/O, see if it got cancelled.
	//
	if (this->m_polAddressListChange != NULL)
	{
		OSVERSIONINFO		osvi;
		OSVERSIONINFOEX		osvix;
		BOOL				fCanWait;
		DWORD				dwAttempt;


		ZeroMemory(&osvi, sizeof(osvi));
		osvi.dwOSVersionInfoSize = sizeof(osvi);

		if (GetVersionEx(&osvi))
		{
			//
			// Any platform but Win2K Gold, Win2K + SP1, or Win2K + SP2 can
			// just go ahead and wait for the I/O to complete.
			//
			if ((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) ||
				(osvi.dwMajorVersion > 5) ||
				(osvi.dwMinorVersion > 0))
			{
				DPFX(DPFPREP, 3, "Windows %s version %u.%u detected, waiting for address list change Ioctl to complete.",
					((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) ? _T("9x") : _T("NT")),
					osvi.dwMajorVersion, osvi.dwMinorVersion);

				fCanWait = TRUE;
			}
			else
			{
				//
				// Win2K versions < SP3 have a bug where the I/O is not always
				// cancelled by closing the socket.  We can't wait for the
				// completion, sometimes it doesn't happen.
				//

				fCanWait = FALSE;

				ZeroMemory(&osvix, sizeof(osvix));
				osvix.dwOSVersionInfoSize = sizeof(osvix);

				if (GetVersionEx((LPOSVERSIONINFO) (&osvix)))
				{
					//
					// If SP3 or later is applied, we know it's fixed.
					//
					if (osvix.wServicePackMajor >= 3)
					{
						DPFX(DPFPREP, 3, "Windows 2000 Service Pack %u detected, waiting for address list change Ioctl to complete.",
							osvix.wServicePackMajor);
						fCanWait = TRUE;
					}
#ifdef DBG
					else
					{
						if (osvix.wServicePackMajor == 0)
						{
							DPFX(DPFPREP, 2, "Windows 2000 Gold detected, not waiting for address list change Ioctl to complete.");
						}
						else
						{
							DPFX(DPFPREP, 2, "Windows 2000 Service Pack %u detected, not waiting for address list change Ioctl to complete.",
								osvix.wServicePackMajor);
						}
					}
#endif // DBG
				}
#ifdef DBG
				else
				{
					dwError = GetLastError();
					DPFX(DPFPREP, 0, "Couldn't get extended OS version information (err = %u)!  Assuming not Win2K < SP3.",
						dwError);
				}
#endif // DBG
			}


			//
			// Wait, if we can.  Otherwise, leak the memory.
			//
			if (fCanWait)
			{
				//
				// Keep looping until I/O completes.  We will give up after a
				// while to prevent hangs.
				//
				dwAttempt = 0;
				while (! HasOverlappedIoCompleted(this->m_polAddressListChange))
				{
					DPFX(DPFPREP, 2, "Waiting %u ms for address list change Ioctl to complete.",
						IOCOMPLETE_WAIT_INTERVAL);

					//
					// Give the OS some time to complete it.
					//
					Sleep(IOCOMPLETE_WAIT_INTERVAL);

					dwAttempt++;

					if (dwAttempt >= MAX_NUM_IOCOMPLETE_WAITS)
					{
						break;
					}
				}
			}
			else
			{
				//
				// Just leak the memory.  See above notes and debug print
				// statements
				//
			}
		}
#ifdef DBG
		else
		{
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Couldn't get OS version information (err = %u)!  Assuming not Win2K < SP3.",
				dwError);
		}
#endif // DBG


		//
		// We've either freed the memory or committed to leaking the object.
		//
		if (HasOverlappedIoCompleted(this->m_polAddressListChange))
		{
			//
			// We didn't allocate it through DNMalloc, use the matching free
			// function.
			//
			HeapFree(GetProcessHeap(), 0, this->m_polAddressListChange);
		}
		else
		{
			DPFX(DPFPREP, 1, "Overlapped address list change Ioctl has not completed yet, leaking %u byte overlapped structure at 0x%p.",
				sizeof(WSAOVERLAPPED), this->m_polAddressListChange);
		}

		this->m_polAddressListChange = NULL;
	}
#endif // ! DPNBUILD_NOWINSOCK2



	//
	// Cleanup WinSock.
	//
	iError = this->m_pfnWSACleanup();
	if (iError != 0)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Couldn't cleanup WinSock (error = %u)!", dwError);
#endif // DBG

		//
		// Continue anyway, so we can finish cleaning up the object.
		//
	}


	//
	// Unload the library.
	//

	this->m_pfnWSAStartup				= NULL;
	this->m_pfnWSACleanup				= NULL;
	this->m_pfnWSAGetLastError			= NULL;
	this->m_pfnsocket					= NULL;
	this->m_pfnclosesocket				= NULL;
	this->m_pfnbind						= NULL;
	this->m_pfnsetsockopt				= NULL;
	this->m_pfngetsockname				= NULL;
	this->m_pfnselect					= NULL;
	this->m_pfn__WSAFDIsSet				= NULL;
	this->m_pfnrecvfrom					= NULL;
	this->m_pfnsendto					= NULL;
	this->m_pfngethostname				= NULL;
	this->m_pfngethostbyname			= NULL;
	this->m_pfninet_addr				= NULL;
#ifndef DPNBUILD_NOWINSOCK2
	this->m_pfnWSASocketA				= NULL;
	this->m_pfnWSAIoctl					= NULL;
	this->m_pfnWSAGetOverlappedResult	= NULL;
#endif // ! DPNBUILD_NOWINSOCK2
	this->m_pfnioctlsocket				= NULL;
	this->m_pfnconnect					= NULL;
	this->m_pfnshutdown					= NULL;
	this->m_pfnsend						= NULL;
	this->m_pfnrecv						= NULL;
#ifdef DBG
	this->m_pfngetsockopt				= NULL;
#endif // DBG


	FreeLibrary(this->m_hWinSockDLL);
	this->m_hWinSockDLL = NULL;


#ifndef DPNBUILD_NOWINSOCK2
	//
	// If we loaded RASAPI32.DLL, unload it.
	//
	if (this->m_hRasApi32DLL != NULL)
	{
		this->m_pfnRasGetEntryHrasconnW		= NULL;
		this->m_pfnRasGetProjectionInfo		= NULL;

		FreeLibrary(this->m_hRasApi32DLL);
		this->m_hRasApi32DLL = NULL;
	}


	//
	// If we loaded IPHLPAPI.DLL, unload it.
	//
	if (this->m_hIpHlpApiDLL != NULL)
	{
		this->m_pfnGetAdaptersInfo			= NULL;
		this->m_pfnGetIpForwardTable		= NULL;
		this->m_pfnGetBestRoute				= NULL;

		FreeLibrary(this->m_hIpHlpApiDLL);
		this->m_hIpHlpApiDLL = NULL;
	}


	//
	// If there was an alert event, we're done with it.
	//
	if (this->m_hAlertEvent != NULL)
	{
		CloseHandle(this->m_hAlertEvent);
		this->m_hAlertEvent = NULL;
	}

	//
	// If there was an alert I/O completion port, we're done with it.
	//
	if (this->m_hAlertIOCompletionPort != NULL)
	{
		CloseHandle(this->m_hAlertIOCompletionPort);
		this->m_hAlertIOCompletionPort = NULL;
	}
#endif // ! DPNBUILD_NOWINSOCK2


	//
	// Turn off flags which should reset it back to 0 or just the
	// NOTCREATEDWITHCOM flag.
	//
	this->m_dwFlags &= ~(NATHELPUPNPOBJ_INITIALIZED |
						NATHELPUPNPOBJ_USEUPNP |
#ifndef DPNBUILD_NOHNETFWAPI
						NATHELPUPNPOBJ_USEHNETFWAPI |
#endif // ! DPNBUILD_NOHNETFWAPI
#ifndef DPNBUILD_NOWINSOCK2
						NATHELPUPNPOBJ_WINSOCK1 |
#endif // ! DPNBUILD_NOWINSOCK2
						NATHELPUPNPOBJ_DEVICECHANGED |
						NATHELPUPNPOBJ_ADDRESSESCHANGED |
#ifdef WINCE
						NATHELPUPNPOBJ_PORTREGISTERED);
#else // ! WINCE
						NATHELPUPNPOBJ_PORTREGISTERED |
						NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX);
#endif // ! WINCE
	DNASSERT((this->m_dwFlags & ~NATHELPUPNPOBJ_NOTCREATEDWITHCOM) == 0);


	this->DropLock();
	fHaveLock = FALSE;


Exit:

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::Close





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetCaps"
//=============================================================================
// CNATHelpUPnP::GetCaps
//-----------------------------------------------------------------------------
//
// Description:    Retrieves the capabilities of the Internet gateway server(s)
//				and information on leased ports.  This function should be
//				called periodically with the DPNHGETCAPS_UPDATESERVERSTATUS
//				flag to automatically extend port leases that are about to
//				expire (that are in last 2 minutes of their lease).
//
//				   The DPNHGETCAPS_UPDATESERVERSTATUS flag also causes
//				detection of changes in the servers' status since the last
//				similar call to GetCaps.  If a new server becomes available, an
//				existing one became unavailable, or a server's public address
//				changed in a way that affects an existing registered port
//				mapping, then DPNHSUCCESS_ADDRESSESCHANGED is returned instead
//				of DPNH_OK.  The user should then update its port binding
//				information via GetRegisteredAddresses.
//
//				   When DPNHGETCAPS_UPDATESERVERSTATUS is specified, this
//				function may block for a short period of time while attempts
//				are made to communicate with the server(s).
//
//				   GetCaps must be called with the
//				DPNHGETCAPS_UPDATESERVERSTATUS flag at least once prior to
//				using the GetRegisteredAddresses or QueryAddress methods.
//
// Arguments:
//	DPNHCAPS * pdpnhcaps	- Pointer to structure to be filled with the NAT
//								helper's current capabilities.  The dwSize
//								field of the structure must be filled in before
//								calling GetCaps.
//	DWORD dwFlags			- Flags to use when retrieving capabilities
//								(DPNHGETCAPS_xxx).
//
// Returns: HRESULT
//	DPNH_OK							- Determining capabilities was successful.
//										Address status has not changed.
//	DPNHSUCCESS_ADDRESSESCHANGED	- One or more of the registered port
//										mappings' addresses changed, retrieve
//										updated mappings with
//										GetRegisteredAddress.
//	DPNHERR_GENERIC					- An error occurred while determining
//										capabilities.
//	DPNHERR_INVALIDFLAGS			- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT			- The interface object is invalid.
//	DPNHERR_INVALIDPARAM			- An invalid parameter was specified.
//	DPNHERR_INVALIDPOINTER			- An invalid pointer was specified.
//	DPNHERR_NOTINITIALIZED			- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY				- There is not enough memory to get
//										capabilities.
//	DPNHERR_REENTRANT				- The interface has been re-entered on the
//										same thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::GetCaps(DPNHCAPS * const pdpnhcaps,
									const DWORD dwFlags)
{
	HRESULT				hr;
	BOOL				fHaveLock = FALSE;
	DWORD				dwCurrentTime;
	DWORD				dwLeaseTimeRemaining;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;
	CDevice *			pDevice;
	CUPnPDevice *		pUPnPDevice = NULL;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%lx)",
		this, pdpnhcaps, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if ((pdpnhcaps == NULL) ||
		(IsBadWritePtr(pdpnhcaps, sizeof(DPNHCAPS))))
	{
		DPFX(DPFPREP, 0, "Invalid caps structure pointer specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (pdpnhcaps->dwSize != sizeof(DPNHCAPS))
	{
		DPFX(DPFPREP, 0, "Invalid caps structure specified, dwSize must be %u!",
			sizeof(DPNHCAPS));
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags & ~DPNHGETCAPS_UPDATESERVERSTATUS)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}


	//
	// Fill in the base caps structure.
	//

	pdpnhcaps->dwFlags = 0;

	pdpnhcaps->dwNumRegisteredPorts = 0;

	pdpnhcaps->dwMinLeaseTimeRemaining = -1;

	//
	// pdpnhcaps->dwRecommendedGetCapsInterval is initialized below
	//


	if (dwFlags & DPNHGETCAPS_UPDATESERVERSTATUS)
	{
		//
		// Remove any cached mappings that have expired.
		//
		this->ExpireOldCachedMappings();


		//
		// Extend leases, if necessary.
		//
		hr = this->ExtendAllExpiringLeases();
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Extending all expiring leases failed!");
			goto Failure;
		}


		//
		// Check for any new devices.
		//
		hr = this->CheckForNewDevices(NULL);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Checking for new devices failed!");
			goto Failure;
		}


		//
		// Check for possible changes in any server's status.  The
		// ADDRESSESCHANGED flag will be set on this object if there were
		// changes that affected existing port mappings.
		//
		hr = this->UpdateServerStatus();
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Updating servers' status failed!");
			goto Failure;
		}


		//
		// Okay, so if things are different, alert the caller.
		//
		if (this->m_dwFlags & NATHELPUPNPOBJ_ADDRESSESCHANGED)
		{
			hr = DPNHSUCCESS_ADDRESSESCHANGED;
			this->m_dwFlags &= ~NATHELPUPNPOBJ_ADDRESSESCHANGED;
		}


#ifdef DBG
		//
		// This flag should have been turned off by now if it ever got turned
		// on.
		//
		DNASSERT(! (this->m_dwFlags & NATHELPUPNPOBJ_DEVICECHANGED));


		//
		// Print the current device and mapping status for debugging purposes.
		//
		this->DebugPrintCurrentStatus();
#endif // DBG
	}
	else
	{
		//
		// Not extending expiring leases or updating server status.
		//
	}


	//
	// Loop through all the devices, getting their gateway capabilities.
	//
	pBilink = this->m_blDevices.GetNext();
	while (pBilink != (&this->m_blDevices))
	{
		DNASSERT(! pBilink->IsEmpty());
		pDevice = DEVICE_FROM_BILINK(pBilink);

#ifndef DPNBUILD_NOHNETFWAPI
		if (pDevice->IsHNetFirewalled())
		{
			//
			// The firewall does not actively notify you of it going down.
			//
			pdpnhcaps->dwFlags |= DPNHCAPSFLAG_LOCALFIREWALLPRESENT | DPNHCAPSFLAG_PUBLICADDRESSAVAILABLE | DPNHCAPSFLAG_NOTALLSUPPORTACTIVENOTIFY;
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		pUPnPDevice = pDevice->GetUPnPDevice();
		if (pUPnPDevice != NULL)
		{
			DNASSERT(pUPnPDevice->IsReady());

			pdpnhcaps->dwFlags |= DPNHCAPSFLAG_GATEWAYPRESENT;

			if (pUPnPDevice->IsLocal())
			{
				pdpnhcaps->dwFlags |= DPNHCAPSFLAG_GATEWAYISLOCAL;
			}

			if (pUPnPDevice->GetExternalIPAddressV4() != 0)
			{
				pdpnhcaps->dwFlags |= DPNHCAPSFLAG_PUBLICADDRESSAVAILABLE;
			}

			//
			// The custom UPnP stack currently does not support active
			// notification...
			//
			pdpnhcaps->dwFlags |= DPNHCAPSFLAG_NOTALLSUPPORTACTIVENOTIFY;
		}

		pBilink = pBilink->GetNext();
	}


	//
	// Loop through all registered ports, counting them.
	// We have the appropriate lock.
	//
	pBilink = this->m_blRegisteredPorts.GetNext();
	dwCurrentTime = GETTIMESTAMP();

	while (pBilink != (&this->m_blRegisteredPorts))
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);

		//
		// Count these registered addresses toward the total.
		//
		pdpnhcaps->dwNumRegisteredPorts += pRegisteredPort->GetNumAddresses();


		pDevice = pRegisteredPort->GetOwningDevice();
		if (pDevice != NULL)
		{
			DNASSERT(! (pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts)));

			//
			// If they're registered with any UPnP devices using a non-
			// permanent lease, calculate the minimum lease time remaining.
			//

			if ((pRegisteredPort->HasUPnPPublicAddresses()) &&
				(! pRegisteredPort->HasPermanentUPnPLease()))
			{
				dwLeaseTimeRemaining = pRegisteredPort->GetUPnPLeaseExpiration() - dwCurrentTime;
				if (dwLeaseTimeRemaining < pdpnhcaps->dwMinLeaseTimeRemaining)
				{
					//
					// Temporarily store how much time remains.
					//
					pdpnhcaps->dwMinLeaseTimeRemaining = dwLeaseTimeRemaining;
				}
			}
		}
		else
		{
			DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts));
		}

		pBilink = pBilink->GetNext();
	}


	//
	// There are different default recommended GetCaps intervals depending on
	// whether there's a server present, and whether it supports active address
	// change notification (that we can alert on) or not.
	//
	// If there are any leases which need to be renewed before that default
	// time, the recommendation will be shortened appropriately.
	//

	//
	// If GetCaps hasn't been called with UPDATESERVERSTATUS yet, recommend an
	// immediate check.
	//
	if (this->m_dwLastUpdateServerStatusTime == 0)
	{
		DPFX(DPFPREP, 1, "Server status has not been updated yet, recommending immediate GetCaps.");

		//
		// Drop the lock, we're done here.
		//
		this->DropLock();
		fHaveLock = FALSE;

		goto Exit;
	}


	//
	// In an ideal world, we could get notified of changes and we would never
	// have to poll.  Unfortunately that isn't the case.  We need to recommend
	// a relatively short poll interval.
	//
	// Start by figuring out how long it's been since the last server update.
	// This calculation really should not go negative.  If it does, it means
	// the caller hasn't updated the server status in ages anyway, so we should
	// recommend immediate GetCaps.
	//
	// Otherwise if the 'port registered' flag is still set at this point, then
	// the user must have called GetCaps previously, then RegisterPorts, then
	// made this second GetCaps call before g_dwMinUpdateServerStatusInterval
	// elapsed.  Recommend that the user call us again as soon as the minimum
	// update interval does elapse.
	//
	// In all other cases, generate a recommendation based on the current
	// backed off poll interval.
	//
	dwCurrentTime = dwCurrentTime - this->m_dwLastUpdateServerStatusTime;

	if ((int) dwCurrentTime < 0)
	{
		DPFX(DPFPREP, 1, "Server status was last updated a really long time ago (%u ms), recommending immediate GetCaps.",
			dwCurrentTime);
		pdpnhcaps->dwRecommendedGetCapsInterval = 0;
	}
	else if (this->m_dwFlags & NATHELPUPNPOBJ_PORTREGISTERED)
	{
		DPFX(DPFPREP, 1, "Didn't handle new port registration because server was last updated %u ms ago, (poll interval staying at %u ms).",
			dwCurrentTime, this->m_dwNextPollInterval);

		pdpnhcaps->dwRecommendedGetCapsInterval = g_dwMinUpdateServerStatusInterval - dwCurrentTime;
		if ((int) pdpnhcaps->dwRecommendedGetCapsInterval < 0)
		{
			pdpnhcaps->dwRecommendedGetCapsInterval = 0;
		}
	}
	else
	{
		DPFX(DPFPREP, 7, "Server was last updated %u ms ago, current poll interval is %u ms.",
			dwCurrentTime, this->m_dwNextPollInterval);

		//
		// Calculate a new recommended interval based on the current value, and
		// backoff that interval if necessary.
		//
		pdpnhcaps->dwRecommendedGetCapsInterval = this->m_dwNextPollInterval - dwCurrentTime;
		this->m_dwNextPollInterval += GetGlobalRand() % g_dwPollIntervalBackoff;
		if (this->m_dwNextPollInterval > g_dwMaxPollInterval)
		{
			this->m_dwNextPollInterval = g_dwMaxPollInterval;
			DPFX(DPFPREP, 3, "Capping next poll interval at %u ms.",
				this->m_dwNextPollInterval);
		}
		else
		{
			DPFX(DPFPREP, 8, "Next poll interval will be %u ms.",
				this->m_dwNextPollInterval);
		}


		//
		// If that time went negative, then it implies that the interval has
		// already elapsed.  Recommend immediate GetCaps.
		//
		if (((int) pdpnhcaps->dwRecommendedGetCapsInterval) < 0)
		{
			DPFX(DPFPREP, 1, "Recommended interval already elapsed (%i ms), suggesting immediate GetCaps.",
				((int) pdpnhcaps->dwRecommendedGetCapsInterval));
			pdpnhcaps->dwRecommendedGetCapsInterval = 0;
		}
	}


	this->DropLock();
	fHaveLock = FALSE;


	//
	// If there is a non-INFINITE lease time remaining, see if that affects the
	// GetCaps interval.
	//
	if (pdpnhcaps->dwMinLeaseTimeRemaining != -1)
	{
		//
		// If there are leases that need to be refreshed before the default
		// recommendation, then use those instead.
		//
		if (pdpnhcaps->dwMinLeaseTimeRemaining < LEASE_RENEW_TIME)
		{
			DPFX(DPFPREP, 1, "Lease needs renewing right away (min %u < %u ms), recommending immediate GetCaps.",
				pdpnhcaps->dwMinLeaseTimeRemaining, LEASE_RENEW_TIME);

			pdpnhcaps->dwRecommendedGetCapsInterval = 0;
		}
		else
		{
			//
			// Either pick the time when the lease should be renewed or leave
			// it as the recommended time, whichever is shorter.
			//
			if ((pdpnhcaps->dwMinLeaseTimeRemaining - LEASE_RENEW_TIME) < pdpnhcaps->dwRecommendedGetCapsInterval)
			{
				pdpnhcaps->dwRecommendedGetCapsInterval = pdpnhcaps->dwMinLeaseTimeRemaining - LEASE_RENEW_TIME;
			}
		}
	}


	DPFX(DPFPREP, 7, "GetCaps flags = 0x%lx, num registered ports = %u, min lease time remaining = %i, recommended interval = %i.",
		pdpnhcaps->dwFlags,
		pdpnhcaps->dwNumRegisteredPorts,
		((int) pdpnhcaps->dwMinLeaseTimeRemaining),
		((int) pdpnhcaps->dwRecommendedGetCapsInterval));


Exit:

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::GetCaps





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::RegisterPorts"
//=============================================================================
// CNATHelpUPnP::RegisterPorts
//-----------------------------------------------------------------------------
//
// Description:    Asks for public realm port(s) that are aliases for the local
//				port(s) on this private realm node.  If a server is available,
//				all traffic directed to the gateway on the public side at the
//				allocated public ports-- which the gateway provides and
//				specifies in the response-- will be directed to the specified
//				local ports.  If the DPNHREGISTERPORTS_FIXEDPORTS flag is not
//				specified, the ports assigned on the public interface are
//				arbitrary (i.e. may not be the same as those in awLocalPort).
//				The address and ports actually allocated can be retrieved by
//				calling GetRegisteredAddresses.
//
//				   The address component for every SOCKADDR structure in the
//				array must be the same.  A separate RegisterPorts call is
//				required to register multiple ports that are not using the same
//				interface.  The address can be INADDR_ANY, in which case the
//				"best" server will be used.  If multiple servers are available
//				via different adapters, an adapter with an Internet gateway is
//				selected.  If no adapters have Internet gateways, the first
//				adapter with a local firewall is selected.  If neither are
//				available, then the first one where either a gateway or a
//				firewall becomes available will be automatically selected.
//				Once one of the adapters has been assigned, it cannot be
//				changed.  Since the server chosen by this method may not be
//				optimal for a particular application, it is recommended that
//				individual addresses be registered instead of INADDR_ANY.
//
//				   If the address in aLocalAddresses is not one of those
//				available to the local machine, the registration will still
//				succeed.  If an adapter with that address becomes available,
//				the port mapping will automatically be applied, and it will
//				gain a public mapping with any server available to that
//				adapter.  If the address was originally available but the
//				network adapter is subsequently removed from the system, any
//				public address mapping is lost.  It will be automatically
//				regained if the local address becomes available again.  It is
//				recommended that the caller detect local address changes
//				independently and de-register/re-register mappings per adapter
//				as appropriate for maximum control.
//
//				   If the DPNHREGISTERPORTS_SHAREDPORTS flag is used, the
//				server will allow other NAT clients to register it as well.
//				Any UDP traffic received on the public interface will be
//				forwarded to all clients registered.  This requires the
//				DPNHREGISTERPORTS_FIXEDPORTS flag and cannot be used with
//				DPNHREGISTERPORTS_TCP.
//
//				   The user should specify a requested lease time that the
//				server will attempt to honor.  The actual time remaining can be
//				can be retrieved by calling GetRegisteredAddresses.
//
//				   Note that if a server is not available, this function will
//				still succeed. GetRegisteredAddresses will return
//				DPNHERR_NOMAPPING for the handle returned in phRegisteredPorts
//				in that case.  If the server arrives later during the session,
//				calling GetCaps periodically can detect this and automatically
//				map previously registered ports.  Use GetRegisteredAddresses to
//				retrieve the newly mapped address when that occurs.
//
//				   Only 16 ports may be registered at a time, but RegisterPorts
//				may be called as many times as desired.
//
//				   The same array of addresses may be registered more than
//				once.  Each DPNHHANDLE returned must be released with
//				DeregisterPorts or Close.  If an individual address was
//				previously registered but in a different array or a different
//				order in the array, then the DPNHERR_PORTALREADYREGISTERED
//				error code is returned.
//
// Arguments:
//	SOCKADDR * aLocalAddresses		- Array of local address and port tuples
//										for which remote ports are requested.
//	DWORD dwAddressesSize			- Size of entire local addresses array.
//	DWORD dwNumAddresses			- Number of SOCKADDR structures in local
//										addresses array.
//	DWORD dwLeaseTime				- Requested time, in milliseconds, to lease
//										the ports.  As long as GetCaps is
//										called before this time has expired,
//										the lease will automatically be
//										renewed.
//	DPNHHANDLE * phRegisteredPorts	- Place to store an identifier for this
//										binding which can later be used to
//										query or release the binding.
//	DWORD dwFlags					- Flags to use when registering the port
//										(DPNHREGISTERPORTS_xxx).
//
// Returns: HRESULT
//	DPNH_OK							- The ports were successfully registered
//										(although no public address may be
//										available yet).
//	DPNHERR_GENERIC					- An error occurred that prevented
//										registration of the requested ports.
//	DPNHERR_INVALIDFLAGS			- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT			- The interface object is invalid.
//	DPNHERR_INVALIDPARAM			- An invalid parameter was specified.
//	DPNHERR_INVALIDPOINTER			- An invalid pointer was specified.
//	DPNHERR_NOTINITIALIZED			- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY				- There is not enough memory to register
//										the ports.
//	DPNHERR_PORTALREADYREGISTERED	- At least one of the ports has already
//										been registered in a different address
//										array or order.
//	DPNHERR_REENTRANT				- The interface has been re-entered on the
//										same thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::RegisterPorts(const SOCKADDR * const aLocalAddresses,
										const DWORD dwAddressesSize,
										const DWORD dwNumAddresses,
										const DWORD dwLeaseTime,
										DPNHHANDLE * const phRegisteredPorts,
										const DWORD dwFlags)
{
	HRESULT				hr;
	ULONG				ulFirstAddress;
	DWORD				dwTemp;
	DWORD				dwMatch;
	BOOL				fHaveLock = FALSE;
	CRegisteredPort *	pRegisteredPort = NULL;
	CDevice *			pDevice = NULL;
	CBilink *			pBilink;
	SOCKADDR_IN *		pasaddrinTemp;
	CUPnPDevice *		pUPnPDevice = NULL;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, %u, %u, %u, 0x%p, 0x%lx)",
		this, aLocalAddresses, dwAddressesSize, dwNumAddresses, dwLeaseTime,
		phRegisteredPorts, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if (aLocalAddresses == NULL)
	{
		DPFX(DPFPREP, 0, "Local addresses array cannot be NULL!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (dwNumAddresses == 0)
	{
		DPFX(DPFPREP, 0, "Number of addresses cannot be 0!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwAddressesSize != (dwNumAddresses * sizeof(SOCKADDR)))
	{
		DPFX(DPFPREP, 0, "Addresses array size invalid!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (IsBadReadPtr(aLocalAddresses, dwAddressesSize))
	{
		DPFX(DPFPREP, 0, "Local addresses array buffer is invalid!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (dwNumAddresses > DPNH_MAX_SIMULTANEOUS_PORTS)
	{
		DPFX(DPFPREP, 0, "Only %u ports may be registered at a time!", DPNH_MAX_SIMULTANEOUS_PORTS);
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (((SOCKADDR_IN*) aLocalAddresses)->sin_family != AF_INET)
	{
		DPFX(DPFPREP, 0, "First address in array is not AF_INET, only IPv4 addresses are supported!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_addr == INADDR_BROADCAST)
	{
		DPFX(DPFPREP, 0, "First address cannot be broadcast address!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (((SOCKADDR_IN*) aLocalAddresses)->sin_port == 0)
	{
		DPFX(DPFPREP, 0, "First port in array is 0, a valid port must be specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	ulFirstAddress = ((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_addr;

	for(dwTemp = 1; dwTemp < dwNumAddresses; dwTemp++)
	{
		//
		// Make sure this address family type is supported.
		//
		if (((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_family != AF_INET)
		{
			DPFX(DPFPREP, 0, "Address at array index %u is not AF_INET, all items in the array must be the same IPv4 address!",
				dwTemp);
			hr = DPNHERR_INVALIDPARAM;
			goto Failure;
		}

		//
		// If this address doesn't match the first, then the caller broke the
		// rules.
		//
		if (((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_addr != ulFirstAddress)
		{
			//
			// Don't use inet_ntoa because we may not be initialized yet.
			//
			DPFX(DPFPREP, 0, "Address %u.%u.%u.%u at array index %u differs from the first, all addresses in the array must match!",
				((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_un_b.s_b1,
				((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_un_b.s_b2,
				((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_un_b.s_b3,
				((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_un_b.s_b4,
				dwTemp);
			hr = DPNHERR_INVALIDPARAM;
			goto Failure;
		}

		//
		// Make sure this port isn't 0 either.
		//
		if (((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_port == 0)
		{
			DPFX(DPFPREP, 0, "Port at array index %u is 0, valid ports must be specified!", dwTemp);
			hr = DPNHERR_INVALIDPARAM;
			goto Failure;
		}
	}

	if (dwLeaseTime == 0)
	{
		DPFX(DPFPREP, 0, "Invalid lease time specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if ((phRegisteredPorts == NULL) ||
		(IsBadWritePtr(phRegisteredPorts, sizeof(DPNHHANDLE))))
	{
		DPFX(DPFPREP, 0, "Invalid port mapping handle pointer specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (dwFlags & ~(DPNHREGISTERPORTS_TCP | DPNHREGISTERPORTS_FIXEDPORTS | DPNHREGISTERPORTS_SHAREDPORTS))
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}

	if (dwFlags & DPNHREGISTERPORTS_SHAREDPORTS)
	{
		//
		// SHAREDPORTS cannot be used with TCP and requires a FIXEDPORTS.
		//
		if ((dwFlags & DPNHREGISTERPORTS_TCP) || (! (dwFlags & DPNHREGISTERPORTS_FIXEDPORTS)))
		{
			DPFX(DPFPREP, 0, "SHAREDPORTS flag requires FIXEDPORTS flag and cannot be used with TCP flag!");
			hr = DPNHERR_INVALIDFLAGS;
			goto Failure;
		}
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}



	//
	// Loop through all existing registered port mappings and look for this
	// array of ports.
	//
	pBilink = this->m_blRegisteredPorts.GetNext();
	while (pBilink != &this->m_blRegisteredPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);

		//
		// Don't bother looking at addresses of the wrong type or at arrays of
		// the wrong size.
		//
		if (((pRegisteredPort->IsTCP() && (dwFlags & DPNHREGISTERPORTS_TCP)) ||
			((! pRegisteredPort->IsTCP()) && (! (dwFlags & DPNHREGISTERPORTS_TCP)))) &&
			(pRegisteredPort->GetNumAddresses() == dwNumAddresses))
		{
			pasaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
			for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
			{
				//
				// If the addresses don't match, stop looping.
				//
				if ((pasaddrinTemp[dwTemp].sin_port != ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_port) ||
					(pasaddrinTemp[dwTemp].sin_addr.S_un.S_addr != ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_addr))
				{
					break;
				}
			}


			//
			// If all the addresses matched, then this item was already
			// registered.
			//
			if (dwTemp >= dwNumAddresses)
			{
				DPFX(DPFPREP, 1, "Array of %u addresses was already registered, returning existing mapping 0x%p.",
					dwNumAddresses, pRegisteredPort);
				goto ReturnUserHandle;
			}

			DPFX(DPFPREP, 7, "Existing mapping 0x%p does not match all %u addresses.",
				pRegisteredPort, dwNumAddresses);
		}
		else
		{
			//
			// Existing mapping isn't same type or doesn't have same number of
			// items in array.
			//
		}

		pBilink = pBilink->GetNext();
	}


	//
	// If we're here, none of the existing mappings match.  Loop through each
	// of the ports and make sure they aren't already registered inside some
	// other mapping.
	//
	for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
	{
		pBilink = this->m_blRegisteredPorts.GetNext();
		while (pBilink != &this->m_blRegisteredPorts)
		{
			DNASSERT(! pBilink->IsEmpty());
			pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);

			pasaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
			for(dwMatch = 0; dwMatch < pRegisteredPort->GetNumAddresses(); dwMatch++)
			{
				//
				// If the addresses match, then we can't map these ports.
				//
				if ((pasaddrinTemp[dwMatch].sin_port == ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_port) &&
					(pasaddrinTemp[dwMatch].sin_addr.S_un.S_addr == ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_addr.S_un.S_addr))
				{
					DPFX(DPFPREP, 0, "Existing mapping 0x%p already registered the address %u.%u.%u.%u:%u!",
						pRegisteredPort,
						pasaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b1,
						pasaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b2,
						pasaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b3,
						pasaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b4,
						NTOHS(pasaddrinTemp[dwMatch].sin_port));

					//
					// Clear the pointer so we don't delete the object.
					//
					pRegisteredPort = NULL;

					hr = DPNHERR_PORTALREADYREGISTERED;
					goto Failure;
				}
			}

			pBilink = pBilink->GetNext();
		}
	}


	//
	// If we're here the ports are all unique.  Create a new mapping object
	// we'll use to refer to the binding.
	//
	pRegisteredPort = new CRegisteredPort(dwLeaseTime, dwFlags);
	if (pRegisteredPort == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	hr = pRegisteredPort->SetPrivateAddresses((SOCKADDR_IN*) aLocalAddresses, dwNumAddresses);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't store private addresses array!");
		goto Failure;
	}


	//
	// Find the device that matches the given addresses.
	//
	// The first entry of aLocalAddresses is representative of all entries since
	// they should all share the same address.
	//
	// Since there won't be an existing registered port for this address, don't
	// bother looking through them for a matching address.
	//
	pDevice = this->FindMatchingDevice((SOCKADDR_IN*) (&aLocalAddresses[0]),
										FALSE);
	if (pDevice == NULL)
	{
		DPFX(DPFPREP, 1, "No device for given address (%u.%u.%u.%u), storing 0x%p in unowned list.",
			((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_un_b.s_b1,
			((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_un_b.s_b2,
			((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_un_b.s_b3,
			((SOCKADDR_IN*) aLocalAddresses)->sin_addr.S_un.S_un_b.s_b4,
			pRegisteredPort);

		pRegisteredPort->m_blDeviceList.InsertBefore(&this->m_blUnownedPorts);
	}
	else
	{
		pRegisteredPort->MakeDeviceOwner(pDevice);


#ifndef DPNBUILD_NOHNETFWAPI
		//
		// Start by mapping with the local firewall, if there is one.
		//
		if (pDevice->IsHNetFirewalled())
		{
			hr = this->CheckForLocalHNetFirewallAndMapPorts(pDevice,
															pRegisteredPort);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't check for local HNet firewall and map ports (err = 0x%lx)!  Continuing.",
					hr);
				DNASSERT(! pDevice->IsHNetFirewalled());
				hr = DPNH_OK;
			}
		}
		else
		{
			//
			// No local HomeNet firewall (last time we checked).
			//
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		//
		// Map the ports on the UPnP device, if there is one.
		//
		pUPnPDevice = pDevice->GetUPnPDevice();
		if (pUPnPDevice != NULL)
		{
			//
			// GetUPnPDevice did not add a reference to pUPnPDevice for us.
			//
			pUPnPDevice->AddRef();


			DNASSERT(pUPnPDevice->IsReady());

			//
			// Actually map the ports.
			//
			hr = this->MapPortsOnUPnPDevice(pUPnPDevice, pRegisteredPort);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't map ports on UPnP device 0x%p (0x%lx)!  Ignoring.",
					pUPnPDevice, hr);

				//
				// It may have been cleared already, but doing it twice
				// shouldn't be harmful.
				//
				this->ClearDevicesUPnPDevice(pRegisteredPort->GetOwningDevice());

				hr = DPNH_OK;
			}

			pUPnPDevice->DecRef();
			pUPnPDevice = NULL;
		}
		else
		{
			//
			// No UPnP device.
			//
		}
	}


	//
	// Save the mapping in the global list (we have the lock).
	//
	pRegisteredPort->m_blGlobalList.InsertBefore(&this->m_blRegisteredPorts);


ReturnUserHandle:

	//
	// Remember that a port has been registered.
	//
	this->m_dwFlags |= NATHELPUPNPOBJ_PORTREGISTERED;

	//
	// We're about to give the port to the user.
	//
	pRegisteredPort->AddUserRef();

	//
	// We're going to give the user a direct pointer to the object (disguised
	// as an opaque DPNHHANDLE, of course).
	//
	(*phRegisteredPorts) = (DPNHHANDLE) pRegisteredPort;


	this->DropLock();
	fHaveLock = FALSE;


	DPFX(DPFPREP, 5, "Returning registered port 0x%p (first private address = %u.%u.%u.%u:%u).",
		pRegisteredPort,
		((SOCKADDR_IN*) aLocalAddresses)[0].sin_addr.S_un.S_un_b.s_b1,
		((SOCKADDR_IN*) aLocalAddresses)[0].sin_addr.S_un.S_un_b.s_b2,
		((SOCKADDR_IN*) aLocalAddresses)[0].sin_addr.S_un.S_un_b.s_b3,
		((SOCKADDR_IN*) aLocalAddresses)[0].sin_addr.S_un.S_un_b.s_b4,
		NTOHS(((SOCKADDR_IN*) aLocalAddresses)[0].sin_port));


	hr = DPNH_OK;


Exit:

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pUPnPDevice != NULL)
	{
		pUPnPDevice->DecRef();
	}

	if (pRegisteredPort != NULL)
	{
#ifndef DPNBUILD_NOHNETFWAPI
		if (pRegisteredPort->IsMappedOnHNetFirewall())
		{
			HRESULT		temphr;


			//
			// Unmap the port.
			//
			// Don't bother alerting user about address change.  It would have
			// already been taken care of if this was due to a fatal error, and
			// there would be no perceived changed if not.
			//
			temphr = this->UnmapPortOnLocalHNetFirewall(pRegisteredPort, TRUE, FALSE);
			if (temphr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed unmapping registered port 0x%p on local HomeNet firewall (err = 0x%lx)!  Ignoring.",
					pRegisteredPort, temphr);

				pRegisteredPort->NoteNotMappedOnHNetFirewall();
				pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
			}
		}
#endif // ! DPNBUILD_NOHNETFWAPI

		if (pDevice != NULL)
		{
			pRegisteredPort->ClearDeviceOwner();
		}

		pRegisteredPort->ClearPrivateAddresses();
		delete pRegisteredPort;
	}

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::RegisterPorts






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetRegisteredAddresses"
//=============================================================================
// CNATHelpUPnP::GetRegisteredAddresses
//-----------------------------------------------------------------------------
//
// Description:    Returns the current public address mappings for a given
//				registered port group.  If there are no servers currently
//				available, then DPNHERR_SERVERNOTAVAILABLE is returned.  If the
//				servers' public interfaces are not currently valid, then
//				DPNHERR_NOMAPPING is returned, but appropriate values will
//				still be placed in pdwAddressTypeFlags and
//				pdwLeaseTimeRemaining.
//
//				   If the mapping was registered with the
//				DPNHREGISTERPORTS_FIXEDPORTS flag, but at least one port is
//				already in use on the gateway, then DPNHERR_PORTUNAVAILABLE is
//				returned and appropriate flags will still be placed in
//				pdwAddressTypeFlags.
//
//				   If the local machine has a cooperative firewall installed,
//				the requested port is opened locally on the firewall before
//				being mapped on the Internet gateway.  Normally this function
//				returns the public address on the Internet gateway address when
//				both are present.  Since some firewalls remap the port number
//				when opening non-fixed ports, the
//				DPNHGETREGISTEREDADDRESSES_LOCALFIREWALLREMAPONLY allows the
//				caller to retrieve the locally remapped address, even if there
//				is a mapping on an Internet gateway.
//
//				   Some gateway devices do not natively support ports that are
//				not fixed, and may generate the DPNHERR_PORTUNAVAILABLE return
//				code even when the DPNHREGISTERPORTS_FIXEDPORTS flag was not
//				specified.  The caller should de-register the port mapping
//				handle, rebind the application to different ports, and call
//				RegisterPorts again.
//
//				   If the buffer indicated by paPublicAddresses is too small,
//				then the size required is returned in pdwPublicAddressesSize
//				and DPNHERR_BUFFERTOOSMALL is returned.  Otherwise the number of
//				bytes written is returned in pdwPublicAddressesSize.
//
//				   Even though the addresses are returned as individual
//				SOCKADDRs, all ports registered at the same time will share the
//				same public address.  Only the port components will vary.
//
//				   All buffers are optional and may be NULL, but if
//				paPublicAddresses is specified, it must be accompanied by an
//				appropriate size in pdwPublicAddressesSize.
//
//				   If GetCaps has not been previously called with the
//				DPNHGETCAPS_UPDATESERVERSTATUS flag at least once, then the
//				error code DPNHERR_UPDATESERVERSTATUS is returned.
//
// Arguments:
//	DPNHHANDLE hRegisteredPorts		- Handle for a specific binding returned by
//										RegisterPorts.
//	SOCKADDR * paPublicAddresses	- Buffer to return assigned public realm
//										address, or NULL if not desired.
//	DWORD * pdwPublicAddressesSize	- Pointer to size of paPublicAddresses
//										buffer, or place to store size
//										required/written.  Cannot be NULL if
//										paPublicAddresses is not NULL.
//	DWORD * pdwAddressTypeFlags		- Place to store flags describing the
//										address types returned, or NULL if not
//										desired.
//	DWORD * pdwLeaseTimeRemaining	- Place to store approximate number of
//										milliseconds remaining in the port
//										lease, or NULL if not desired.  Call
//										GetCaps to automatically extend leases
//										about to expire.
//	DWORD dwFlags					- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK						- Information on the port mapping was found and
//									the addresses were stored in
//									paPublicAddresses.
//	DPNHERR_BUFFERTOOSMALL		- There was not enough room in the buffer to
//									store the addresses. 
//	DPNHERR_GENERIC				- An error occurred while retrieving the
//									requested port mapping.
//	DPNHERR_INVALIDFLAGS		- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT		- The interface object is invalid.
//	DPNHERR_INVALIDPARAM		- An invalid parameter was specified.
//	DPNHERR_INVALIDPOINTER		- An invalid pointer was specified.
//	DPNHERR_NOMAPPING			- The server(s) do not have valid public
//									interfaces.
//	DPNHERR_NOTINITIALIZED		- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY			- There is not enough memory to get the
//									addresses.
//	DPNHERR_PORTUNAVAILABLE		- At least one of the ports is not available on
//									the server.
//	DPNHERR_REENTRANT			- The interface has been re-entered on the same
//									thread.
//	DPNHERR_SERVERNOTAVAILABLE	- No servers are currently present.
//	DPNHERR_UPDATESERVERSTATUS	- GetCaps has not been called with the
//									DPNHGETCAPS_UPDATESERVERSTATUS flag yet.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::GetRegisteredAddresses(const DPNHHANDLE hRegisteredPorts,
												SOCKADDR * const paPublicAddresses,
												DWORD * const pdwPublicAddressesSize,
												DWORD * const pdwAddressTypeFlags,
												DWORD * const pdwLeaseTimeRemaining,
												const DWORD dwFlags)
{
	HRESULT				hr;
	CRegisteredPort *	pRegisteredPort;
	BOOL				fHaveLock = FALSE;
	BOOL				fRegisteredWithServer = FALSE;
	BOOL				fFoundValidMapping = FALSE;
	BOOL				fPortIsUnavailable = FALSE;
	DWORD				dwSizeRequired;
	DWORD				dwAddressTypeFlags;
	DWORD				dwCurrentTime;
	//DWORD				dwTempLeaseTimeRemaining;
	DWORD				dwLeaseTimeRemaining = -1;
	CDevice *			pDevice;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, 0x%p, 0x%p, 0x%lx)",
		this, hRegisteredPorts, paPublicAddresses, pdwPublicAddressesSize,
		pdwAddressTypeFlags, pdwLeaseTimeRemaining, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	pRegisteredPort = (CRegisteredPort*) hRegisteredPorts;
	if (! pRegisteredPort->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid registered port mapping handle specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (paPublicAddresses != NULL)
	{
		if ((pdwPublicAddressesSize == NULL) ||
			(IsBadWritePtr(pdwPublicAddressesSize, sizeof(DWORD))))
		{
			DPFX(DPFPREP, 0, "When specifying a public addresses buffer, a valid size must be given!");
			hr = DPNHERR_INVALIDPOINTER;
			goto Failure;
		}

		if (IsBadWritePtr(paPublicAddresses, (*pdwPublicAddressesSize)))
		{
			DPFX(DPFPREP, 0, "The public addresses buffer is invalid!");
			hr = DPNHERR_INVALIDPOINTER;
			goto Failure;
		}
	}
	else
	{
		if ((pdwPublicAddressesSize != NULL) &&
			(IsBadWritePtr(pdwPublicAddressesSize, sizeof(DWORD))))
		{
			DPFX(DPFPREP, 0, "Invalid pointer for size of public addresses buffer!");
			hr = DPNHERR_INVALIDPOINTER;
			goto Failure;
		}
	}

	if ((pdwAddressTypeFlags != NULL) &&
		(IsBadWritePtr(pdwAddressTypeFlags, sizeof(DWORD))))
	{
		DPFX(DPFPREP, 0, "Invalid pointer for address type flags!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if ((pdwLeaseTimeRemaining != NULL) &&
		(IsBadWritePtr(pdwLeaseTimeRemaining, sizeof(DWORD))))
	{
		DPFX(DPFPREP, 0, "Invalid pointer for lease time remaining!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (dwFlags & ~DPNHGETREGISTEREDADDRESSES_LOCALFIREWALLREMAPONLY)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}



	//
	// Start the flags off with the information regarding TCP vs. UDP.
	//
	if (pRegisteredPort->IsTCP())
	{
		dwAddressTypeFlags = DPNHADDRESSTYPE_TCP;
	}
	else
	{
		dwAddressTypeFlags = 0;
	}


	//
	// Add in other flags we know already.
	//

	if (pRegisteredPort->IsFixedPort())
	{
		dwAddressTypeFlags |= DPNHADDRESSTYPE_FIXEDPORTS;
	}

	if (pRegisteredPort->IsSharedPort())
	{
		dwAddressTypeFlags |= DPNHADDRESSTYPE_SHAREDPORTS;
	}




	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}

	if (this->m_dwLastUpdateServerStatusTime == 0)
	{
		DPFX(DPFPREP, 0, "GetCaps has not been called with UPDATESERVERSTATUS flag yet!");
		hr = DPNHERR_UPDATESERVERSTATUS;
		goto Failure;
	}


	//
	// Get a shortcut pointer to the device (may not exist).
	//
	pDevice = pRegisteredPort->GetOwningDevice();


	//
	// Get the current time for both the remote and local lease
	// calculations.
	//
	dwCurrentTime = GETTIMESTAMP();


	if (! (dwFlags & DPNHGETREGISTEREDADDRESSES_LOCALFIREWALLREMAPONLY))
	{
		CUPnPDevice *	pUPnPDevice;


		//
		// First check for a mapping on the UPnP device.
		//
		if (pRegisteredPort->HasUPnPPublicAddresses())
		{
			DNASSERT(pDevice != NULL);

			pUPnPDevice = pDevice->GetUPnPDevice();
			DNASSERT(pUPnPDevice != NULL);

			fRegisteredWithServer = TRUE;

			//
			// Make sure the UPnP device currently has a valid external
			// address.  If so, hand the mapping out.
			//
			if (pUPnPDevice->GetExternalIPAddressV4() != 0)
			{
				if (pdwPublicAddressesSize != NULL)
				{
					dwSizeRequired = pRegisteredPort->GetAddressesSize();

					if ((paPublicAddresses == NULL) ||
						(dwSizeRequired > (*pdwPublicAddressesSize)))
					{
						//
						// Not enough room in buffer, return the size required
						// and the BUFFERTOOSMALL error code.
						//
						(*pdwPublicAddressesSize) = dwSizeRequired;
						hr = DPNHERR_BUFFERTOOSMALL;
					}
					else
					{
						//
						// Buffer was large enough, return the size written.
						//
						(*pdwPublicAddressesSize) = dwSizeRequired;
						pRegisteredPort->CopyUPnPPublicAddresses((SOCKADDR_IN*) paPublicAddresses);
					}
				}
				else
				{
					//
					// Not using address buffer.
					//
				}

				fFoundValidMapping = TRUE;
			}
			else
			{
				DPFX(DPFPREP, 8, "The UPnP Internet Gateway Device does not currently have a valid public address.");
			}

			//
			// Add in the flag indicating that there's a UPnP device.
			//
			dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY;

			//
			// See if the UPnP device is local.
			//
			if (pUPnPDevice->IsLocal())
			{
				dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAYISLOCAL;
			}

			//
			// Get the relative UPnP lease time remaining, if it's not
			// permanent.
			//
			if (! pRegisteredPort->HasPermanentUPnPLease())
			{
				dwLeaseTimeRemaining = pRegisteredPort->GetUPnPLeaseExpiration() - dwCurrentTime;

				if (((int) dwLeaseTimeRemaining) < 0)
				{
					DPFX(DPFPREP, 1, "Registered port mapping's UPnP lease has already expired, returning 0 for lease time remaining.");
					dwLeaseTimeRemaining = 0;
				}
			}
		}
		else if (pRegisteredPort->IsUPnPPortUnavailable())
		{
			DNASSERT(pDevice != NULL);

			pUPnPDevice = pDevice->GetUPnPDevice();
			DNASSERT(pUPnPDevice != NULL);

			fRegisteredWithServer = TRUE;
			fPortIsUnavailable = TRUE;

			DPFX(DPFPREP, 8, "The UPnP device indicates the port(s) are unavailable.");

			//
			// Add in the flag indicating that there's a UPnP device.
			//
			dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY;

			//
			// See if the UPnP device is local.
			//
			if (pUPnPDevice->IsLocal())
			{
				dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAYISLOCAL;
			}
		}
	}
	else
	{
		//
		// We're not allowed to return the UPnP mapping.
		//
		DPFX(DPFPREP, 8, "Ignoring any Internet gateway mappings, LOCALFIREWALLREMAPONLY was specified.");
	}


#ifndef DPNBUILD_NOHNETFWAPI
	//
	// Finally, check for a mapping on a local firewall.
	//
	if (pRegisteredPort->IsMappedOnHNetFirewall())
	{
		DNASSERT(pDevice != NULL);
		DNASSERT(pDevice->IsHNetFirewalled());


		fRegisteredWithServer = TRUE;


		//
		// If we didn't already get a remote mapping, return this local one.
		//
		if (! fFoundValidMapping)
		{
			if (pdwPublicAddressesSize != NULL)
			{
				dwSizeRequired = pRegisteredPort->GetAddressesSize();

				if ((paPublicAddresses == NULL) ||
					(dwSizeRequired > (*pdwPublicAddressesSize)))
				{
					//
					// Not enough room in buffer, return the size required
					// and the BUFFERTOOSMALL error code.
					//
					(*pdwPublicAddressesSize) = dwSizeRequired;
					hr = DPNHERR_BUFFERTOOSMALL;
				}
				else
				{
					SOCKADDR_IN *	pasaddrinPrivate;
					DWORD			dwTemp;


					//
					// Buffer was large enough, return the size written.
					//
					(*pdwPublicAddressesSize) = dwSizeRequired;

					//
					// Note that the addresses mapped on the firewall are the
					// same as the private addresses.
					//
					pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

					DNASSERT(pasaddrinPrivate != NULL);

					memcpy(paPublicAddresses, pasaddrinPrivate, dwSizeRequired);


					//
					// However, we don't want to ever return 0.0.0.0, so make
					// sure they get the device address.
					//
					if (pasaddrinPrivate[0].sin_addr.S_un.S_addr == INADDR_ANY)
					{
						for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
						{
							((SOCKADDR_IN*) paPublicAddresses)[dwTemp].sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
						}

						DPFX(DPFPREP, 7, "Returning device address %u.%u.%u.%u instead of INADDR_ANY for firewalled port mapping 0x%p.",
							((SOCKADDR_IN*) paPublicAddresses)[0].sin_addr.S_un.S_un_b.s_b1,
							((SOCKADDR_IN*) paPublicAddresses)[0].sin_addr.S_un.S_un_b.s_b2,
							((SOCKADDR_IN*) paPublicAddresses)[0].sin_addr.S_un.S_un_b.s_b3,
							((SOCKADDR_IN*) paPublicAddresses)[0].sin_addr.S_un.S_un_b.s_b4,
							pRegisteredPort);
					}
				}
			}
			else
			{
				//
				// Not using address buffer.
				//
			}

			fFoundValidMapping = TRUE;
		}
		else
		{
			DPFX(DPFPREP, 6, "Ignoring local HomeNet firewall mapping due to UPnP mapping.");
		}


		//
		// Add in the flag indicating the local firewall.
		//
		dwAddressTypeFlags |= DPNHADDRESSTYPE_LOCALFIREWALL;


		//
		// The firewall API does not allow for lease times.
		//
	}
	else
	{
		if (pRegisteredPort->IsHNetFirewallPortUnavailable())
		{
			DNASSERT(pDevice != NULL);
			DNASSERT(pDevice->IsHNetFirewalled());


			fRegisteredWithServer = TRUE;
			fPortIsUnavailable = TRUE;

			DPFX(DPFPREP, 8, "The local HomeNet firewall indicates the port(s) are unavailable.");


			//
			// Add in the flag indicating the local firewall.
			//
			dwAddressTypeFlags |= DPNHADDRESSTYPE_LOCALFIREWALL;
		}
#ifdef DBG
		else
		{
			//
			// No local firewall or it's an unowned port.
			//
			if (pDevice != NULL)
			{
				DNASSERT(! pDevice->IsHNetFirewalled());
			}
			else
			{
				DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts));
			}
		}
#endif // DBG
	}
#endif // ! DPNBUILD_NOHNETFWAPI
	

	this->DropLock();
	fHaveLock = FALSE;


	if (fRegisteredWithServer)
	{
		DNASSERT(dwAddressTypeFlags & (DPNHADDRESSTYPE_LOCALFIREWALL | DPNHADDRESSTYPE_GATEWAY));


		if (! fFoundValidMapping)
		{
			if (fPortIsUnavailable)
			{
				//
				// The servers indicated that the ports were already in use.
				// Return PORTUNAVAILABLE.
				//
				DPFX(DPFPREP, 1, "The Internet gateway(s) could not map the port, returning PORTUNAVAILABLE.");
				hr = DPNHERR_PORTUNAVAILABLE;
			}
			else
			{
				//
				// The servers didn't have public addresses.  Return NOMAPPING.
				//
				DPFX(DPFPREP, 1, "The Internet gateway(s) did not offer valid public addresses, returning NOMAPPING.");
				hr = DPNHERR_NOMAPPING;
			}
		}
		else
		{
			//
			// One of the servers had a public address.
			//
			DNASSERT((hr == DPNH_OK) || (hr == DPNHERR_BUFFERTOOSMALL));
		}
	}
	else
	{
		//
		// The ports aren't registered, because there aren't any gateways.
		// Return SERVERNOTAVAILABLE.
		//
		DPFX(DPFPREP, 1, "No Internet gateways, returning SERVERNOTAVAILABLE.");
		hr = DPNHERR_SERVERNOTAVAILABLE;
	}


	//
	// If the caller wants information on the type of these addresses, return
	// the flags we detected.
	//
	if (pdwAddressTypeFlags != NULL)
	{
		(*pdwAddressTypeFlags) = dwAddressTypeFlags;
	}


	//
	// Return the minimum lease time remaining that we already calculated, if
	// the caller wants it.
	//
	if (pdwLeaseTimeRemaining != NULL)
	{
		(*pdwLeaseTimeRemaining) = dwLeaseTimeRemaining;
	}


#ifdef DBG
	//
	// If the port is unavailable or there aren't any servers, we better not
	// have a lease time.
	//
	if ((hr == DPNHERR_PORTUNAVAILABLE) ||
		(hr == DPNHERR_SERVERNOTAVAILABLE))
	{
		DNASSERT(dwLeaseTimeRemaining == -1);
	}


	//
	// If there aren't any servers, we better not have server flags.
	//
	if (hr == DPNHERR_SERVERNOTAVAILABLE)
	{
		DNASSERT(! (dwAddressTypeFlags & (DPNHADDRESSTYPE_LOCALFIREWALL | DPNHADDRESSTYPE_GATEWAY)));
	}
#endif // DBG


	DPFX(DPFPREP, 5, "Registered port 0x%p addr type flags = 0x%lx, lease time remaining = %i.",
		pRegisteredPort, dwAddressTypeFlags, (int) dwLeaseTimeRemaining);


Exit:

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::GetRegisteredAddresses





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DeregisterPorts"
//=============================================================================
// CNATHelpUPnP::DeregisterPorts
//-----------------------------------------------------------------------------
//
// Description:    Removes the lease record for the port group and informs the
//				Internet gateway server that the binding is no longer needed.
//				The port mapping handle must not be used after de-registering
//				it.
//
// Arguments:
//	DPNHHANDLE hRegisteredPorts		- Handle for a specific binding returned by
//										RegisterPorts.
//	DWORD dwFlags					- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK					- The binding was successfully released.
//	DPNHERR_GENERIC			- An error occurred that prevented the
//								de-registration of the ports.
//	DPNHERR_INVALIDFLAGS	- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPARAM	- An invalid parameter was specified.
//	DPNHERR_NOTINITIALIZED	- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY		- There is not enough memory to de-register.
//	DPNHERR_REENTRANT		- The interface has been re-entered on the same
//								thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::DeregisterPorts(const DPNHHANDLE hRegisteredPorts,
											const DWORD dwFlags)
{
	HRESULT				hr;
	CRegisteredPort *	pRegisteredPort;
	BOOL				fHaveLock = FALSE;
	LONG				lResult;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%lx)",
		this, hRegisteredPorts, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	pRegisteredPort = (CRegisteredPort*) hRegisteredPorts;
	if (! pRegisteredPort->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid registered port mapping handle specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags != 0)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}


	//
	// If this isn't the last user reference on the registered port, don't
	// unmap it yet.
	//
	lResult = pRegisteredPort->DecUserRef();
	if (lResult != 0)
	{
		DPFX(DPFPREP, 1, "Still %i references left on registered port 0x%p, not unmapping.",
			lResult, pRegisteredPort);
		goto Exit;
	}


	//
	// First unmap from UPnP device, if necessary.
	//
	if (pRegisteredPort->HasUPnPPublicAddresses())
	{
		hr = this->UnmapUPnPPort(pRegisteredPort,
								pRegisteredPort->GetNumAddresses(),	// free all ports
								TRUE);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't delete port mapping with UPnP device (0x%lx)!  Ignoring.", hr);

			//
			// We'll treat this as non-fatal, but we have to dump the device.
			//
			this->ClearDevicesUPnPDevice(pRegisteredPort->GetOwningDevice());
			hr = DPNH_OK;
		}
	}


#ifndef DPNBUILD_NOHNETFWAPI
	//
	// Then unmap from the local firewall, if necessary.
	//
	if (pRegisteredPort->IsMappedOnHNetFirewall())
	{
		//
		// Unmap the port.
		//
		// Don't bother alerting user about address change, this is normal
		// operation.
		//
		hr = this->UnmapPortOnLocalHNetFirewall(pRegisteredPort, TRUE, FALSE);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed unmapping registered port 0x%p on local HomeNet firewall (err = 0x%lx)!  Ignoring.",
				pRegisteredPort, hr);

			pRegisteredPort->NoteNotMappedOnHNetFirewall();
			pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

			hr = DPNH_OK;
		}
	}
#endif // ! DPNBUILD_NOHNETFWAPI


	//
	// Pull the item out of the lists.
	// We have the appropriate lock.
	//

	DNASSERT(pRegisteredPort->m_blGlobalList.IsListMember(&this->m_blRegisteredPorts));
	pRegisteredPort->m_blGlobalList.RemoveFromList();

	if (pRegisteredPort->GetOwningDevice() != NULL)
	{
		DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&((pRegisteredPort->GetOwningDevice())->m_blOwnedRegPorts)));
		pRegisteredPort->ClearDeviceOwner();
	}
	else
	{
		DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts));
		pRegisteredPort->m_blDeviceList.RemoveFromList();
	}

	pRegisteredPort->ClearPrivateAddresses();
	delete pRegisteredPort;


Exit:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::DeregisterPorts





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::QueryAddress"
//=============================================================================
// CNATHelpUPnP::QueryAddress
//-----------------------------------------------------------------------------
//
// Description:    Some Internet gateways do not loopback if an attempt is made
//				to connect to an address behind (on the same private side of)
//				the public interface.  QueryAddress is used to determine a
//				possible private alias for a given public address.
//
//				   In most cases, this function is called prior to connecting
//				to a new address.  pSourceAddress should contain the address of
//				the socket that will perform the connect.  Similar to
//				RegisterPorts, the address may be INADDR_ANY, in which case the
//				"best" server will be used.  Since the server chosen may not be
//				optimal for a particular application, it is recommended that a
//				specific network interface be used instead of INADDR_ANY, when
//				possible.
//
//				   If no mapping for that address has been made by the gateway,
//				the error code DPNHERR_NOMAPPING is returned.  When the
//				DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED flag is used, an
//				extra effort is made to determine whether the address is behind
//				the same Internet gateway without being mapped on the gateway.
//				If that is the case, DPNHERR_NOMAPPINGBUTPRIVATE is returned.
//				DPNHERR_NOMAPPING is still returned for addresses that are
//				neither mapped nor private.
//
//				   pQueryAddress may not be INADDR_ANY or INADDR_BROADCAST.
//				The port component may be zero if and only if the
//				DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED flag is used.  If
//				the port is zero, a specific mapping cannot be verified, and
//				only the DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED aspect of
//				the address is tested.
//
//				   The resulting address (or lack thereof) can be cached for
//				quick future retrieval using the DPNHQUERYADDRESS_CACHEFOUND
//				and DPNHQUERYADDRESS_CACHENOTFOUND flags.  The cached mappings
//				will expire in 1 minute, or whenever the server's address
//				changes.
//
//				   If the given source address is not currently connected to an
//				Internet gateway, then the error DPNHERR_SERVERNOTAVAILABLE is
//				returned.
//
//				   If GetCaps has not been previously called with the
//				DPNHGETCAPS_UPDATESERVERSTATUS flag at least once, then the
//				error code DPNHERR_UPDATESERVERSTATUS is returned.
//
// Arguments:
//	SOCKADDR * pSourceAddress	- Address for network interface that is using
//									the address in question.
//	SOCKADDR * pQueryAddress	- Address to look up.
//	SOCKADDR * pResponseAddress	- Place to store public address, if one exists.
//	int iAddressesSize			- Size of the SOCKADDR structure used for the
//									pSourceAddress, pQueryAddress and
//									pResponseAddress buffers.
//	DWORD dwFlags				- Flags to use when querying
//									(DPNHQUERYADDRESS_xxx).
//
// Returns: HRESULT
//	DPNH_OK						- The address was found and its mapping was
//									stored in pResponseAddress.
//	DPNHERR_GENERIC				- An error occurred that prevented mapping the
//									requested address.
//	DPNHERR_INVALIDFLAGS		- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT		- The interface object is invalid.
//	DPNHERR_INVALIDPARAM		- An invalid parameter was specified.
//	DPNHERR_INVALIDPOINTER		- An invalid pointer was specified.
//	DPNHERR_NOMAPPING			- The server indicated that no mapping for the
//									requested address was found.
//	DPNHERR_NOMAPPINGBUTPRIVATE	- The server indicated that no mapping was
//									found, but it is a private address.
//	DPNHERR_NOTINITIALIZED		- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY			- There is not enough memory to query.
//	DPNHERR_REENTRANT			- The interface has been re-entered on the same
//									thread.
//	DPNHERR_SERVERNOTAVAILABLE	- There are no servers to query.
//	DPNHERR_UPDATESERVERSTATUS	- GetCaps has not been called with the
//									DPNHGETCAPS_UPDATESERVERSTATUS flag yet.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::QueryAddress(const SOCKADDR * const pSourceAddress,
										const SOCKADDR * const pQueryAddress,
										SOCKADDR * const pResponseAddress,
										const int iAddressesSize,
										const DWORD dwFlags)
{
	HRESULT			hr;
	BOOL			fHaveLock = FALSE;
	CDevice *		pDevice;
	SOCKADDR_IN *	psaddrinNextServerQueryAddress = NULL;
	CUPnPDevice *	pUPnPDevice = NULL;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, %i, 0x%lx)",
		this, pSourceAddress, pQueryAddress, pResponseAddress, iAddressesSize,
		dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if (pSourceAddress == NULL)
	{
		DPFX(DPFPREP, 0, "Invalid source address specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (pQueryAddress == NULL)
	{
		DPFX(DPFPREP, 0, "Invalid query address specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (pResponseAddress == NULL)
	{
		DPFX(DPFPREP, 0, "Invalid response address specified!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (iAddressesSize < sizeof(SOCKADDR_IN))
	{
		DPFX(DPFPREP, 0, "The address buffers must be at least %i bytes!",
			sizeof(SOCKADDR_IN));
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (IsBadReadPtr(pSourceAddress, sizeof(SOCKADDR_IN)))
	{
		DPFX(DPFPREP, 0, "Invalid source address buffer used!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (IsBadReadPtr(pQueryAddress, sizeof(SOCKADDR_IN)))
	{
		DPFX(DPFPREP, 0, "Invalid query address buffer used!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if (IsBadWritePtr(pResponseAddress, sizeof(SOCKADDR_IN)))
	{
		DPFX(DPFPREP, 0, "Invalid response address buffer used!");
		hr = DPNHERR_INVALIDPOINTER;
		goto Failure;
	}

	if ((((SOCKADDR_IN*) pSourceAddress)->sin_family != AF_INET) ||
		(((SOCKADDR_IN*) pQueryAddress)->sin_family != AF_INET))
	{
		DPFX(DPFPREP, 0, "Source or query address is not AF_INET, only IPv4 addresses are supported!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (((SOCKADDR_IN*) pSourceAddress)->sin_addr.S_un.S_addr == INADDR_BROADCAST)
	{
		DPFX(DPFPREP, 0, "Source address cannot be broadcast address!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if ((((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_addr == INADDR_ANY) ||
		(((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_addr == INADDR_BROADCAST))
	{
		//
		// Don't use inet_ntoa because we may not be initialized yet.
		//
		DPFX(DPFPREP, 0, "Query address (%u.%u.%u.%u) is invalid, cannot be zero or broadcast!",
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b1,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b2,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b3,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b4);
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags & ~(DPNHQUERYADDRESS_TCP | DPNHQUERYADDRESS_CACHEFOUND | DPNHQUERYADDRESS_CACHENOTFOUND | DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED))
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}

	if ((((SOCKADDR_IN*) pQueryAddress)->sin_port == 0) &&
		(! (dwFlags & DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED)))
	{
		DPFX(DPFPREP, 0, "Query address port cannot be zero unless CHECKFORPRIVATEBUTUNMAPPED is specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}

	if (this->m_dwLastUpdateServerStatusTime == 0)
	{
		DPFX(DPFPREP, 0, "GetCaps has not been called with UPDATESERVERSTATUS flag yet!");
		hr = DPNHERR_UPDATESERVERSTATUS;
		goto Failure;
	}


	pDevice = this->FindMatchingDevice((SOCKADDR_IN*) pSourceAddress, TRUE);
	if (pDevice == NULL)
	{
		DPFX(DPFPREP, 1, "Couldn't determine owning device for source %u.%u.%u.%u, returning SERVERNOTAVAILABLE for query %u.%u.%u.%u:%u.",
			((SOCKADDR_IN*) pSourceAddress)->sin_addr.S_un.S_un_b.s_b1,
			((SOCKADDR_IN*) pSourceAddress)->sin_addr.S_un.S_un_b.s_b2,
			((SOCKADDR_IN*) pSourceAddress)->sin_addr.S_un.S_un_b.s_b3,
			((SOCKADDR_IN*) pSourceAddress)->sin_addr.S_un.S_un_b.s_b4,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b1,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b2,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b3,
			((SOCKADDR_IN*) pQueryAddress)->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(((SOCKADDR_IN*) pQueryAddress)->sin_port));
		hr = DPNHERR_SERVERNOTAVAILABLE;
		goto Exit;
	}



	//
	// Assume no servers are available.  This will get overridden as
	// appropriate.
	//
	hr = DPNHERR_SERVERNOTAVAILABLE;


	//
	// Start by querying the address passed in.
	//
	psaddrinNextServerQueryAddress = (SOCKADDR_IN*) pQueryAddress;


	//
	// If the port is zero, then we can't actually lookup a mapping.  Just do
	// the address locality check.
	//
	if (psaddrinNextServerQueryAddress->sin_port == 0)
	{
		//
		// We should have caught this in parameter validation above, but I'm
		// being paranoid.
		//
		DNASSERT(dwFlags & DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED);


		//
		// We don't cache these results, since there's no server (and thus, no
		// network traffic) associated with it.  No need to look anything up.
		//


		//
		// If there aren't any Internet gateways, then no need to check.
		//
#ifdef DPNBUILD_NOHNETFWAPI
		if (pDevice->GetUPnPDevice() == NULL)
#else // ! DPNBUILD_NOHNETFWAPI
		if ((pDevice->GetUPnPDevice() == NULL) &&
			(! pDevice->IsHNetFirewalled()))
#endif // ! DPNBUILD_NOHNETFWAPI
		{
			DPFX(DPFPREP, 5, "No port queried and there aren't any gateways, returning SERVERNOTAVAILABLE.");
			hr = DPNHERR_SERVERNOTAVAILABLE;
		}
		else
		{
			//
			// There is an Internet gateway of some kind, our locality check
			// would be meaningful.
			//
			if (this->IsAddressLocal(pDevice, psaddrinNextServerQueryAddress))
			{
				DPFX(DPFPREP, 5, "No port queried, but address appears to be local, returning NOMAPPINGBUTPRIVATE.");
				hr = DPNHERR_NOMAPPINGBUTPRIVATE;
			}
			else
			{
				DPFX(DPFPREP, 5, "No port queried and address does not appear to be local, returning NOMAPPING.");
				hr = DPNHERR_NOMAPPING;
			}
		}


		//
		// We've done all we can do.
		//
		goto Exit;
	}


	//
	// Query the UPnP gateway, if there is one.
	//
	pUPnPDevice = pDevice->GetUPnPDevice();
	if (pUPnPDevice != NULL)
	{
		//
		// GetUPnPDevice did not add a reference to pUPnPDevice for us.
		//
		pUPnPDevice->AddRef();


		DNASSERT(pUPnPDevice->IsReady());


		//
		// Actually query the device.
		//
		hr = this->InternalUPnPQueryAddress(pUPnPDevice,
											psaddrinNextServerQueryAddress,
											(SOCKADDR_IN*) pResponseAddress,
											dwFlags);
		switch (hr)
		{
			case DPNH_OK:
			{
				//
				// There was a mapping.
				//
				//psaddrinNextServerQueryAddress = (SOCKADDR_IN*) pResponseAddress;
				break;
			}

			case DPNHERR_NOMAPPING:
			{
				//
				// There's no mapping.
				//
				break;
			}

			case DPNHERR_NOMAPPINGBUTPRIVATE:
			{
				//
				// There's no mapping although the address is private.
				//
				break;
			}

			case DPNHERR_SERVERNOTRESPONDING:
			{
				//
				// The device stopped responding, so we should get rid of it.
				//

				DPFX(DPFPREP, 1, "UPnP device stopped responding while querying port mapping, removing it.");

				this->ClearDevicesUPnPDevice(pDevice);


				//
				// We also set the return code back to SERVERNOTAVAILABLE.
				//
				hr = DPNHERR_SERVERNOTAVAILABLE;

				//
				// Continue through to querying the HomeNet firewall.
				//
				break;
			}

			default:
			{
				DPFX(DPFPREP, 0, "Querying UPnP device for port mapping failed!");
				goto Failure;
				break;
			}
		}

		pUPnPDevice->DecRef();
		pUPnPDevice = NULL;
	}
	else
	{
		//
		// No UPnP device.
		//
	}


#ifndef DPNBUILD_NOHNETFWAPI
	//
	// If there's a HomeNet firewall and we didn't already get a UPnP result,
	// take the easy way out and return NOMAPPING instead of going through the
	// trouble of looking up the mapping and returning success only if it maps
	// to a local address.
	//
	// Note: we may want to look it up, but right now I'm not seeing any
	// benefit to implementing that code.
	//
	if ((pDevice->IsHNetFirewalled()) && (hr == DPNHERR_SERVERNOTAVAILABLE))
	{
		DPFX(DPFPREP, 7, "Device is HomeNet firewalled, and no UPnP result obtained, returning NOMAPPING.");
		hr = DPNHERR_NOMAPPING;
	}
#endif // ! DPNBUILD_NOHNETFWAPI


	//
	// If we got here with hr still set to SERVERNOTAVAILABLE, that means
	// there weren't any servers.  The error code is appropriate, leave it
	// alone.
	//
#ifdef DBG
	if (hr == DPNHERR_SERVERNOTAVAILABLE)
	{
		DPFX(DPFPREP, 1, "No Internet gateways, unable to query port mapping.");
	}
#endif // DBG
	



Exit:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pUPnPDevice != NULL)
	{
		pUPnPDevice->DecRef();
	}

	goto Exit;
} // CNATHelpUPnP::QueryAddress





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SetAlertEvent"
//=============================================================================
// CNATHelpUPnP::SetAlertEvent
//-----------------------------------------------------------------------------
//
// Description:    This function allows the user to specify an event that will
//				be set when some maintenance needs to be performed.  The user
//				should call GetCaps using the DPNHGETCAPS_UPDATESERVERSTATUS
//				flag when the event is signalled.
//
//				   This function is not available on Windows 95 without WinSock
//				2, may only be called once, and cannot be used after
//				SetAlertIOCompletionPort is called.
//
//					Note that the event is used in addition to the regular
//				polling of GetCaps, it simply allows the polling to be less
//				frequent.
//
// Arguments:
//	HANDLE hEvent	- Handle to event to signal when GetCaps is to be called.
//	DWORD dwFlags	- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK					- The event was successfully registered.
//	DPNHERR_GENERIC			- An error occurred that prevented registering the
//								event.
//	DPNHERR_INVALIDFLAGS	- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPARAM	- An invalid parameter was specified.
//	DPNHERR_NOTINITIALIZED	- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY		- There is not enough memory.
//	DPNHERR_REENTRANT		- The interface has been re-entered on the same
//								thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::SetAlertEvent(const HANDLE hEvent,
										const DWORD dwFlags)
{
#ifdef DPNBUILD_NOWINSOCK2
	DPFX(DPFPREP, 0, "Cannot set alert event (0x%p)!", hEvent);
	return E_NOTIMPL;
#else // ! DPNBUILD_NOWINSOCK2
	HRESULT		hr;
	BOOL		fHaveLock = FALSE;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%lx)", this, hEvent, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if (hEvent == NULL)
	{
		DPFX(DPFPREP, 0, "Invalid event handle specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags != 0)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED))
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}

	if (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1)
	{
		DPFX(DPFPREP, 0, "Cannot use alert mechanism on WinSock 1!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if ((this->m_hAlertEvent != NULL) || (this->m_hAlertIOCompletionPort != NULL))
	{
		DPFX(DPFPREP, 0, "An alert event or I/O completion port has already been set!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Now save the event handle.
	//
	if (! DuplicateHandle(GetCurrentProcess(),
						hEvent,
						GetCurrentProcess(),
						&this->m_hAlertEvent,
						0,
						FALSE,
						DUPLICATE_SAME_ACCESS))
	{
#ifdef DBG
		DWORD	dwError;


		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't duplicate event (error = %u)!", dwError);
#endif // DBG

		DNASSERT(this->m_hAlertEvent == NULL);

		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}


	//
	// Create overlapped structure.  Don't allocate it through DNMalloc,
	// because we may have to leak it on purpose.  We don't want those memory
	// allocation asserts firing in that case.
	//
	this->m_polAddressListChange = (WSAOVERLAPPED*) HeapAlloc(GetProcessHeap(),
															HEAP_ZERO_MEMORY,
															sizeof(WSAOVERLAPPED));
	if (this->m_polAddressListChange == NULL)
	{
		//
		// Close the alert handle we set.
		//
		CloseHandle(this->m_hAlertEvent);
		this->m_hAlertEvent = NULL;

		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}


	//
	// Save the event in the address list change overlapped structure.
	//
	this->m_polAddressListChange->hEvent = this->m_hAlertEvent;


	//
	// Start getting notified of local address changes.
	//
	hr = this->RequestLocalAddressListChangeNotification();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't request local address list change notification!");

		//
		// Free the memory we allocated.
		//
		HeapFree(GetProcessHeap(), 0, this->m_polAddressListChange);
		this->m_polAddressListChange = NULL;

		//
		// Close the alert handle we set.
		//
		CloseHandle(this->m_hAlertEvent);
		this->m_hAlertEvent = NULL;

		goto Failure;
	}


Exit:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
#endif // ! DPNBUILD_NOWINSOCK2
} // CNATHelpUPnP::SetAlertEvent






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SetAlertIOCompletionPort"
//=============================================================================
// CNATHelpUPnP::SetAlertIOCompletionPort
//-----------------------------------------------------------------------------
//
// Description:    This function allows the user to specify an I/O completion
//				port that will receive notification when some maintenance needs
//				to be performed.  The user should call GetCaps using the
//				DPNHGETCAPS_UPDATESERVERSTATUS flag when the packet with the
//				given completion key is dequeued.
//
//				   This function is only available on Windows NT, may only be
//				called once, and cannot be used after SetAlertEvent is called.
//
//					Note that the completion port is used in addition to the
//				regular polling of GetCaps, it simply allows the polling to be
//				less frequent.
//
// Arguments:
//	HANDLE hIOCompletionPort		- Handle to I/O completion port which will
//										be used to signal when GetCaps is to be
//										called.
//	DWORD dwCompletionKey			- Key to use when indicating I/O
//										completion.
//	DWORD dwNumConcurrentThreads	- Number of concurrent threads allowed to
//										process, or zero for default.
//	DWORD dwFlags					- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK					- The I/O completion port was successfully
//								registered.
//	DPNHERR_GENERIC			- An error occurred that prevented registering the
//								I/O completion port.
//	DPNHERR_INVALIDFLAGS	- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPARAM	- An invalid parameter was specified.
//	DPNHERR_NOTINITIALIZED	- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY		- There is not enough memory.
//	DPNHERR_REENTRANT		- The interface has been re-entered on the same
//								thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::SetAlertIOCompletionPort(const HANDLE hIOCompletionPort,
													const DWORD dwCompletionKey,
													const DWORD dwNumConcurrentThreads,
													const DWORD dwFlags)
{
#ifdef DPNBUILD_NOWINSOCK2
	DPFX(DPFPREP, 0, "Cannot set alert I/O completion port (0x%p, %u, %u)!",
		hIOCompletionPort, dwCompletionKey, dwNumConcurrentThreads);
	return E_NOTIMPL;
#else // ! DPNBUILD_NOWINSOCK2
	HRESULT		hr;
	BOOL		fHaveLock = FALSE;
	HANDLE		hIOCompletionPortResult;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, 0x%lx, %u, 0x%lx)",
		this, hIOCompletionPort, dwCompletionKey, dwNumConcurrentThreads, dwFlags);



	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	if (hIOCompletionPort == NULL)
	{
		DPFX(DPFPREP, 0, "Invalid I/O completion port handle specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags != 0)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED))
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}

	if (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1)
	{
		DPFX(DPFPREP, 0, "Cannot use alert mechanism on WinSock 1!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if ((this->m_hAlertEvent != NULL) || (this->m_hAlertIOCompletionPort != NULL))
	{
		DPFX(DPFPREP, 0, "An alert event or I/O completion port has already been set!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Now save the I/O completion port handle.
	//
	if (! DuplicateHandle(GetCurrentProcess(),
						hIOCompletionPort,
						GetCurrentProcess(),
						&this->m_hAlertIOCompletionPort,
						0,
						FALSE,
						DUPLICATE_SAME_ACCESS))
	{
#ifdef DBG
		DWORD	dwError;


		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't duplicate I/O completion port (error = %u)!", dwError);
#endif // DBG

		DNASSERT(this->m_hAlertIOCompletionPort == NULL);

		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	this->m_dwAlertCompletionKey = dwCompletionKey;


	//
	// Associate our Ioctl socket with this IO completion port.
	//
	DNASSERT(this->m_sIoctls != INVALID_SOCKET);
	hIOCompletionPortResult = CreateIoCompletionPort((HANDLE) this->m_sIoctls,
													this->m_hAlertIOCompletionPort,
													dwCompletionKey,
													dwNumConcurrentThreads);
	if (hIOCompletionPortResult == NULL)
	{
#ifdef DBG
		DWORD	dwError;


		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't associate I/O completion port with Ioctl socket (error = %u)!", dwError);
#endif // DBG

		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	//
	// We should have just gotten the same I/O completion port back.
	//
	DNASSERT(hIOCompletionPortResult == this->m_hAlertIOCompletionPort);


	//
	// Create overlapped structure.  Don't allocate it through DNMalloc,
	// because we may have to leak it on purpose.  We don't want those memory
	// allocation asserts firing in that case.
	//
	this->m_polAddressListChange = (WSAOVERLAPPED*) HeapAlloc(GetProcessHeap(),
															HEAP_ZERO_MEMORY,
															sizeof(WSAOVERLAPPED));
	if (this->m_polAddressListChange == NULL)
	{
		//
		// Close the alert IOCP we set.
		//
		CloseHandle(this->m_hAlertIOCompletionPort);
		this->m_hAlertIOCompletionPort = NULL;

		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}


	//
	// Start getting notified of local address changes.
	//
	hr = this->RequestLocalAddressListChangeNotification();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't request local address list change notification!");

		//
		// Free the memory we allocated.
		//
		HeapFree(GetProcessHeap(), 0, this->m_polAddressListChange);
		this->m_polAddressListChange = NULL;

		//
		// Close the alert IOCP we set.
		//
		CloseHandle(this->m_hAlertIOCompletionPort);
		this->m_hAlertIOCompletionPort = NULL;

		goto Failure;
	}



Exit:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
#endif // ! DPNBUILD_NOWINSOCK2
} // CNATHelpUPnP::SetAlertIOCompletionPort





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ExtendRegisteredPortsLease"
//=============================================================================
// CNATHelpUPnP::ExtendRegisteredPortsLease
//-----------------------------------------------------------------------------
//
// Description:    Manually extends the lease of the given registered port
//				mapping by the requested time.  The periodic calling of GetCaps
//				can take care of this for the user, this function is only
//				necessary to change the lease extension time or for finer
//				control of individual mappings.
//
//				   The user should specify a requested lease extension time
//				that the server will attempt to honor.  It will be added to any
//				time remaining in the existing lease, and the new total can be
//				retrieved by calling GetRegisteredAddresses.
//
// Arguments:
//	DPNHHANDLE hRegisteredPorts		- Handle for a specific binding returned by
//										RegisterPorts.
//	DWORD dwLeaseTime				- Requested time, in milliseconds, to
//										extend the lease.  If 0, the previous
//										requested lease time is used.
//	DWORD dwFlags					- Unused, must be zero.
//
// Returns: HRESULT
//	DPNH_OK					- The lease was successfully extended.
//	DPNHERR_GENERIC			- An error occurred that prevented the extending
//								the lease.
//	DPNHERR_INVALIDFLAGS	- Invalid flags were specified.
//	DPNHERR_INVALIDOBJECT	- The interface object is invalid.
//	DPNHERR_INVALIDPARAM	- An invalid parameter was specified.
//	DPNHERR_NOTINITIALIZED	- Initialize has not been called.
//	DPNHERR_OUTOFMEMORY		- There is not enough memory to extend the lease.
//	DPNHERR_REENTRANT		- The interface has been re-entered on the same
//								thread.
//=============================================================================
STDMETHODIMP CNATHelpUPnP::ExtendRegisteredPortsLease(const DPNHHANDLE hRegisteredPorts,
													const DWORD dwLeaseTime,
													const DWORD dwFlags)
{
	HRESULT				hr;
	CRegisteredPort *	pRegisteredPort;
	CDevice *			pDevice;
	BOOL				fHaveLock = FALSE;


	DPFX(DPFPREP, 2, "(0x%p) Parameters: (0x%p, %u, 0x%lx)",
		this, hRegisteredPorts, dwLeaseTime, dwFlags);


	//
	// Validate the object.
	//
	if (! this->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid DirectPlay NAT Help object!");
		hr = DPNHERR_INVALIDOBJECT;
		goto Failure;
	}


	//
	// Validate the parameters.
	//

	pRegisteredPort = (CRegisteredPort*) hRegisteredPorts;
	if (! pRegisteredPort->IsValidObject())
	{
		DPFX(DPFPREP, 0, "Invalid registered port mapping handle specified!");
		hr = DPNHERR_INVALIDPARAM;
		goto Failure;
	}

	if (dwFlags != 0)
	{
		DPFX(DPFPREP, 0, "Invalid flags specified!");
		hr = DPNHERR_INVALIDFLAGS;
		goto Failure;
	}


	//
	// Attempt to take the lock, but be prepared for the re-entrancy error.
	//
	hr = this->TakeLock();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Could not lock object!");
		goto Failure;
	}

	fHaveLock = TRUE;


	//
	// Make sure object is in right state.
	//

	if (! (this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED) )
	{
		DPFX(DPFPREP, 0, "Object not initialized!");
		hr = DPNHERR_NOTINITIALIZED;
		goto Failure;
	}


	//
	// If they wanted to change the lease time, update it.
	//
	if (dwLeaseTime != 0)
	{
		pRegisteredPort->UpdateRequestedLeaseTime(dwLeaseTime);
	}

	
	pDevice = pRegisteredPort->GetOwningDevice();


	//
	// If the port is registered with the UPnP device, extend that lease.
	//
	if (pRegisteredPort->HasUPnPPublicAddresses())
	{
		DNASSERT(pDevice != NULL);


		hr = this->ExtendUPnPLease(pRegisteredPort);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on UPnP device (0x%lx)!  Ignoring.", hr);

			//
			// We'll treat this as non-fatal, but we have to dump the
			// server.  This may have already been done, but doing it
			// twice shouldn't be harmful.
			//
			this->ClearDevicesUPnPDevice(pDevice);
			hr = DPNH_OK;
		}
	}
	else
	{
		DPFX(DPFPREP, 2, "Port mapping not registered with UPnP gateway device.");
	}


	//
	// Firewall mappings never have lease times to extend.
	//


	this->DropLock();
	fHaveLock = FALSE;


Exit:

	DPFX(DPFPREP, 2, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (fHaveLock)
	{
		this->DropLock();
		fHaveLock = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::ExtendRegisteredPortsLease






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::InitializeObject"
//=============================================================================
// CNATHelpUPnP::InitializeObject
//-----------------------------------------------------------------------------
//
// Description:    Sets up the object for use like the constructor, but may
//				fail with OUTOFMEMORY.  Should only be called by class factory
//				creation routine.
//
// Arguments: None.
//
// Returns: HRESULT
//	S_OK			- Initialization was successful.
//	E_OUTOFMEMORY	- There is not enough memory to initialize.
//=============================================================================
HRESULT CNATHelpUPnP::InitializeObject(void)
{
	HRESULT		hr;
	BOOL		fInittedCriticalSection = FALSE;


	DPFX(DPFPREP, 5, "(0x%p) Enter", this);

	DNASSERT(this->IsValidObject());


	//
	// Create the lock.
	// 

	if (! DNInitializeCriticalSection(&this->m_csLock))
	{
		hr = E_OUTOFMEMORY;
		goto Failure;
	}

	fInittedCriticalSection = TRUE;


	//
	// Don't allow critical section reentry.
	//
	DebugSetCriticalSectionRecursionCount(&this->m_csLock, 0);


	this->m_hLongLockSemaphore = DNCreateSemaphore(NULL,
													0,
													MAX_LONG_LOCK_WAITING_THREADS,
													NULL);
	if (this->m_hLongLockSemaphore == NULL)
	{
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	hr = S_OK;

Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (fInittedCriticalSection)
	{
		DNDeleteCriticalSection(&this->m_csLock);
		fInittedCriticalSection = FALSE;
	}

	goto Exit;
} // CNATHelpUPnP::InitializeObject






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UninitializeObject"
//=============================================================================
// CNATHelpUPnP::UninitializeObject
//-----------------------------------------------------------------------------
//
// Description:    Cleans up the object like the destructor, mostly to balance
//				InitializeObject.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::UninitializeObject(void)
{
	DPFX(DPFPREP, 5, "(0x%p) Enter", this);


	DNASSERT(this->IsValidObject());


	DNCloseHandle(this->m_hLongLockSemaphore);
	this->m_hLongLockSemaphore = NULL;

	DNDeleteCriticalSection(&this->m_csLock);


	DPFX(DPFPREP, 5, "(0x%p) Leave", this);
} // CNATHelpUPnP::UninitializeObject





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::TakeLock"
//=============================================================================
// CNATHelpUPnP::TakeLock
//-----------------------------------------------------------------------------
//
// Description:    Takes the main object lock.  If some other thread is already
//				holding the long lock, we wait for that first.
//
// Arguments: None.
//
// Returns: DPNH_OK if lock was taken successfully, DPNHERR_REENTRANT if lock
//			was re-entered.
//=============================================================================
HRESULT CNATHelpUPnP::TakeLock(void)
{
	HRESULT		hr = DPNH_OK;
#ifdef DBG
	DWORD		dwStartTime;


	dwStartTime = GETTIMESTAMP();
#endif // DBG


	DNEnterCriticalSection(&this->m_csLock);


	//
	// If this same thread is already holding the lock, then bail.
	//
	if (this->m_dwLockThreadID == GetCurrentThreadId())
	{
		DPFX(DPFPREP, 0, "Thread re-entering!");
		goto Failure;
	}

	
	//
	// If someone is holding the long lock, we need to wait for that.  Of
	// course another thread could come in and take the long lock after the
	// first one drops it and before we can take the main one.  This algorithm
	// does not attempt to be fair in this case.  Theoretically we could wait
	// forever if this continued to occur.  That shouldn't happen in the real
	// world.
	// This whole mess of code is a huge... uh... workaround for stress hits
	// involving critical section timeouts.
	//
	while (this->m_dwFlags & NATHELPUPNPOBJ_LONGLOCK)
	{
		DNASSERT(this->m_lNumLongLockWaitingThreads >= 0);
		this->m_lNumLongLockWaitingThreads++;

		//
		// We need to keep looping until we do get the lock.
		//
		DNLeaveCriticalSection(&this->m_csLock);


		DPFX(DPFPREP, 3, "Waiting for long lock to be released.");

		DNWaitForSingleObject(this->m_hLongLockSemaphore, INFINITE);


		DNEnterCriticalSection(&this->m_csLock);


		//
		// If this same thread is already holding the lock, then bail.
		//
		if (this->m_dwLockThreadID == GetCurrentThreadId())
		{
			DPFX(DPFPREP, 0, "Thread re-entering after waiting for long lock!");
			goto Failure;
		}
	}


#ifdef DBG
	DPFX(DPFPREP, 8, "Took main object lock, elapsed time = %u ms.",
		(GETTIMESTAMP() - dwStartTime));
#endif // DBG

	//
	// Save this thread's ID so we know who's holding the lock.
	//
	this->m_dwLockThreadID = GetCurrentThreadId();


Exit:

	return hr;


Failure:

	//
	// We're reentering.  Drop the lock and return the failure.
	//
	DNLeaveCriticalSection(&this->m_csLock);

	hr = DPNHERR_REENTRANT;

	goto Exit;
} // CNATHelpUPnP::TakeLock




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DropLock"
//=============================================================================
// CNATHelpUPnP::DropLock
//-----------------------------------------------------------------------------
//
// Description:    Drops the main object lock.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::DropLock(void)
{
	DNASSERT(! (this->m_dwFlags & NATHELPUPNPOBJ_LONGLOCK));
	DNASSERT(this->m_lNumLongLockWaitingThreads == 0);
	DNASSERT(this->m_dwLockThreadID == GetCurrentThreadId());

	this->m_dwLockThreadID = 0;
	DNLeaveCriticalSection(&this->m_csLock);

	DPFX(DPFPREP, 8, "Dropped main object lock.");
} // CNATHelpUPnP::DropLock




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SwitchToLongLock"
//=============================================================================
// CNATHelpUPnP::SwitchToLongLock
//-----------------------------------------------------------------------------
//
// Description:    Switches from holding the main object lock to holding the
//				long lock.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::SwitchToLongLock(void)
{
	AssertCriticalSectionIsTakenByThisThread(&this->m_csLock, TRUE);
	DNASSERT(! (this->m_dwFlags & NATHELPUPNPOBJ_LONGLOCK));
	DNASSERT(this->m_lNumLongLockWaitingThreads == 0);


	DPFX(DPFPREP, 8, "Switching to long lock.");


	this->m_dwFlags |= NATHELPUPNPOBJ_LONGLOCK;

	DNLeaveCriticalSection(&this->m_csLock);
} // CNATHelpUPnP::SwitchToLongLock




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SwitchFromLongLock"
//=============================================================================
// CNATHelpUPnP::SwitchFromLongLock
//-----------------------------------------------------------------------------
//
// Description:    Switches from holding the long lock back to holding the main
//				object lock.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::SwitchFromLongLock(void)
{
	DNEnterCriticalSection(&this->m_csLock);

	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_LONGLOCK);
	this->m_dwFlags &= ~NATHELPUPNPOBJ_LONGLOCK;


	DPFX(DPFPREP, 8, "Switching from long lock, alerting %i threads.",
		this->m_lNumLongLockWaitingThreads);


	//
	// This is non-optimal in that we release the semaphore but the waiting
	// threads still won't actually be able to do anything since we now hold
	// the main lock.
	//
	DNASSERT(this->m_lNumLongLockWaitingThreads >= 0);
	DNReleaseSemaphore(this->m_hLongLockSemaphore,
						this->m_lNumLongLockWaitingThreads,
						NULL);

	this->m_lNumLongLockWaitingThreads = 0;
} // CNATHelpUPnP::SwitchFromLongLock






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::LoadWinSockFunctionPointers"
//=============================================================================
// CNATHelpUPnP::LoadWinSockFunctionPointers
//-----------------------------------------------------------------------------
//
// Description:    Loads pointers to all the functions that we use in WinSock.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: HRESULT
//	DPNH_OK			- Loading was successful.
//	DPNHERR_GENERIC	- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::LoadWinSockFunctionPointers(void)
{
	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#ifdef DBG

#define PRINTERRORIFDEBUG(name)						\
	{\
		dwError = GetLastError();\
		DPFX(DPFPREP, 0, "Couldn't get \"%hs\" function!  0x%lx", name, dwError);\
	}

#else // ! DBG

#define PRINTERRORIFDEBUG(name)

#endif // ! DBG


#define LOADWINSOCKFUNCTION(var, proctype, name)	\
	{\
		var = (##proctype) GetProcAddress(this->m_hWinSockDLL, _TWINCE(name));\
		if (var == NULL)\
		{\
			PRINTERRORIFDEBUG(name);\
			hr = DPNHERR_GENERIC;\
			goto Failure;\
		}\
	}

	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

	HRESULT		hr = DPNH_OK;
#ifdef DBG
	DWORD		dwError;
#endif // DBG


	LOADWINSOCKFUNCTION(this->m_pfnWSAStartup,				LPFN_WSASTARTUP,				"WSAStartup");
	LOADWINSOCKFUNCTION(this->m_pfnWSACleanup,				LPFN_WSACLEANUP,				"WSACleanup");
#ifdef WINCE
	this->m_pfnWSAGetLastError = (LPFN_WSAGETLASTERROR) GetLastError;
#else // ! WINCE
	LOADWINSOCKFUNCTION(this->m_pfnWSAGetLastError,			LPFN_WSAGETLASTERROR,			"WSAGetLastError");
#endif // ! WINCE
	LOADWINSOCKFUNCTION(this->m_pfnsocket,					LPFN_SOCKET,					"socket");
	LOADWINSOCKFUNCTION(this->m_pfnclosesocket,				LPFN_CLOSESOCKET,				"closesocket");
	LOADWINSOCKFUNCTION(this->m_pfnbind,					LPFN_BIND,						"bind");
	LOADWINSOCKFUNCTION(this->m_pfnsetsockopt,				LPFN_SETSOCKOPT,				"setsockopt");
	LOADWINSOCKFUNCTION(this->m_pfngetsockname,				LPFN_GETSOCKNAME,				"getsockname");
	LOADWINSOCKFUNCTION(this->m_pfnselect,					LPFN_SELECT,					"select");
	LOADWINSOCKFUNCTION(this->m_pfn__WSAFDIsSet,			LPFN___WSAFDISSET,				"__WSAFDIsSet");
	LOADWINSOCKFUNCTION(this->m_pfnrecvfrom,				LPFN_RECVFROM,					"recvfrom");
	LOADWINSOCKFUNCTION(this->m_pfnsendto,					LPFN_SENDTO,					"sendto");
	LOADWINSOCKFUNCTION(this->m_pfngethostname,				LPFN_GETHOSTNAME,				"gethostname");
	LOADWINSOCKFUNCTION(this->m_pfngethostbyname,			LPFN_GETHOSTBYNAME,				"gethostbyname");
	LOADWINSOCKFUNCTION(this->m_pfninet_addr,				LPFN_INET_ADDR,					"inet_addr");

#ifndef DPNBUILD_NOWINSOCK2
	if (! (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1))
	{
		LOADWINSOCKFUNCTION(this->m_pfnWSASocketA,				LPFN_WSASOCKETA,				"WSASocketA");
		LOADWINSOCKFUNCTION(this->m_pfnWSAIoctl,				LPFN_WSAIOCTL,					"WSAIoctl");
		LOADWINSOCKFUNCTION(this->m_pfnWSAGetOverlappedResult,	LPFN_WSAGETOVERLAPPEDRESULT,	"WSAGetOverlappedResult");
	}
#endif // ! DPNBUILD_NOWINSOCK2

	LOADWINSOCKFUNCTION(this->m_pfnioctlsocket,				LPFN_IOCTLSOCKET,				"ioctlsocket");
	LOADWINSOCKFUNCTION(this->m_pfnconnect,					LPFN_CONNECT,					"connect");
	LOADWINSOCKFUNCTION(this->m_pfnshutdown,				LPFN_SHUTDOWN,					"shutdown");
	LOADWINSOCKFUNCTION(this->m_pfnsend,					LPFN_SEND,						"send");
	LOADWINSOCKFUNCTION(this->m_pfnrecv,					LPFN_RECV,						"recv");

#ifdef DBG
	LOADWINSOCKFUNCTION(this->m_pfngetsockopt,				LPFN_GETSOCKOPT,				"getsockopt");
#endif // DBG


Exit:

	return hr;


Failure:

	hr = DPNHERR_GENERIC;

	goto Exit;
} // CNATHelpUPnP::LoadWinSockFunctionPointers






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CheckForNewDevices"
//=============================================================================
// CNATHelpUPnP::CheckForNewDevices
//-----------------------------------------------------------------------------
//
// Description:    Detects new IP capable devices that have been added and
//				removes old ones no longer available.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	BOOL * pfFoundNewDevices	Pointer to boolean to set to TRUE if new
//								devices were added, or NULL if don't care.
//
// Returns: HRESULT
//	DPNH_OK				- The check was successful.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CheckForNewDevices(BOOL * const pfFoundNewDevices)
{
	HRESULT				hr = DPNH_OK;
#if ((defined(DBG)) || (! defined(DPNBUILD_NOWINSOCK2)))
	DWORD				dwError;
#endif // DBG or ! DPNBUILD_NOWINSOCK2
#ifndef DPNBUILD_NOWINSOCK2
	int					iReturn;
#endif // ! DPNBUILD_NOWINSOCK2
	char				szName[1000];
	PHOSTENT			phostent;
	IN_ADDR **			ppinaddr;
	DWORD				dwAddressesSize = 0;
	DWORD				dwNumAddresses = 0;
	IN_ADDR *			painaddrAddresses = NULL;
	CBilink *			pBilinkDevice;
	CDevice *			pDevice = NULL; // NULL it for PREfix, even though fDeviceCreated guards it
	BOOL				fDeviceCreated = FALSE;
	BOOL				fFound;
	CBilink *			pBilinkRegPort;
	CRegisteredPort *	pRegisteredPort;
	SOCKET				sTemp = INVALID_SOCKET;
	SOCKADDR_IN			saddrinTemp;
	DWORD				dwTemp;
#ifndef DPNBUILD_NOWINSOCK2
	SOCKET_ADDRESS *	paSocketAddresses;
#endif // ! DPNBUILD_NOWINSOCK2



	DPFX(DPFPREP, 5, "(0x%p) Parameters (0x%p)", this, pfFoundNewDevices);


#ifndef DPNBUILD_NOWINSOCK2
	//
	// Handle any address list change Ioctl completions that may have gotten us
	// here.
	//
	if ((this->m_hAlertEvent != NULL) ||
		(this->m_hAlertIOCompletionPort != NULL))
	{
		DNASSERT(this->m_sIoctls != INVALID_SOCKET);
		DNASSERT(this->m_polAddressListChange != NULL);

		if (this->m_pfnWSAGetOverlappedResult(this->m_sIoctls,					//
												this->m_polAddressListChange,	//
												&dwTemp,						// ignore bytes transferred
												FALSE,							// don't wait
												&dwTemp))						// ignore flags
		{
			DPFX(DPFPREP, 1, "Received address list change notification.");
			

			//
			// Overlapped result completed.  Reissue it.
			//
			hr = this->RequestLocalAddressListChangeNotification();
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't request local address list change notification!");
				goto Failure;
			}
		}
		else
		{
			//
			// Figure out what error it was.
			//
			dwError = this->m_pfnWSAGetLastError();
			switch (dwError)
			{
				case WSA_IO_INCOMPLETE:
				{
					//
					// It hasn't completed yet.
					//
					break;
				}

				case ERROR_OPERATION_ABORTED:
				{
					//
					// The thread that we originally submitted the Ioctl on
					// went away and so the OS kindly cancelled the operation
					// on us.  How nice.  Well, let's try resubmitting it.
					//

					DPFX(DPFPREP, 1, "Thread that submitted previous address list change notification went away, rerequesting.");
					
					hr = this->RequestLocalAddressListChangeNotification();
					if (hr != DPNH_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't request local address list change notification!");
						goto Failure;
					}
					break;
				}
			
				default:
				{
					DPFX(DPFPREP, 0, "Couldn't get overlapped result, error = %u!  Ignoring.", dwError);
					break;
				}
			} // end switch (on error)
		}
	}


	//
	// If we're on WinSock 2, let's try getting the address list with
	// an Ioctl.
	//
	if (! (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1))
	{
		DNASSERT(this->m_sIoctls != INVALID_SOCKET);
		DNASSERT(this->m_pfnWSAIoctl != NULL);

		//
		// Keep trying to get the address list until we have a large enough
		// buffer.  We use the IN_ADDR array pointer simply because it's
		// already there.  We know that IN_ADDRs are smaller than
		// SOCKET_ADDRESSes, so we can reuse the same buffer.
		//
		do
		{
			iReturn = this->m_pfnWSAIoctl(this->m_sIoctls,			// use the special Ioctl socket
										SIO_ADDRESS_LIST_QUERY,		//
										NULL,						// no input data
										0,							// no input data
										painaddrAddresses,			// output buffer
										dwAddressesSize,			// output buffer size
										&dwTemp,					// bytes needed
										NULL,						// no overlapped structure
										NULL);						// no completion routine

			if (iReturn != 0)
			{
				dwError = this->m_pfnWSAGetLastError();

				//
				// Free the previous buffer, no matter what error it was.
				//
				if (painaddrAddresses != NULL)
				{
					DNFree(painaddrAddresses);
					painaddrAddresses = NULL;
				}
				
				if (dwError != WSAEFAULT)
				{
					DPFX(DPFPREP, 1, "Retrieving address list failed (err = %u), trying WinSock 1 method.", dwError);

					//
					// We'll try the old-fashioned WinSock 1 way.
					//
					break;
				}


				//
				// Be absolutely sure WinSock isn't causing us trouble.
				//
				if (dwTemp < sizeof(SOCKET_ADDRESS_LIST))
				{
					DPFX(DPFPREP, 0, "Received an invalid buffer size (%u < %u)!",
						dwTemp, sizeof(SOCKET_ADDRESS_LIST));

					//
					// We'll try the old-fashioned WinSock 1 way.
					//
					break;
				}


				//
				// The buffer wasn't large enough.  Try again.
				//
				painaddrAddresses = (IN_ADDR*) DNMalloc(dwTemp);
				if (painaddrAddresses == NULL)
				{
					hr = DPNHERR_OUTOFMEMORY;
					goto Failure;
				}

				dwAddressesSize = dwTemp;
			}
			else
			{
				//
				// Success!  We're going to being sneaky and reuse the buffer.
				// We know that the SOCKET_ADDRESS_LIST returned will be larger
				// than an array of IN_ADDRs, so we can save a malloc.
				//
				// But first, be absolutely sure WinSock isn't causing us
				// trouble.
				//

				if (painaddrAddresses == NULL)
				{
					DPFX(DPFPREP, 0, "WinSock returned success with a NULL buffer!");

					//
					// We'll try the old-fashioned WinSock 1 way.
					//
					break;
				}

				dwNumAddresses = ((SOCKET_ADDRESS_LIST*) painaddrAddresses)->iAddressCount;
				dwAddressesSize = 0;


				//
				// Make sure there are addresses. 
				//
				if (dwNumAddresses > 0)
				{
					DPFX(DPFPREP, 7, "WinSock 2 Ioctl returned %u addresses:", dwNumAddresses);

					paSocketAddresses = ((SOCKET_ADDRESS_LIST*) painaddrAddresses)->Address;
					for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
					{
						DNASSERT(paSocketAddresses[dwTemp].iSockaddrLength == sizeof(SOCKADDR_IN));
						DNASSERT(paSocketAddresses[dwTemp].lpSockaddr != NULL);
						DNASSERT(paSocketAddresses[dwTemp].lpSockaddr->sa_family == AF_INET);

						//
						// Ignore 0.0.0.0 addresses.
						//
						if (((SOCKADDR_IN*) (paSocketAddresses[dwTemp].lpSockaddr))->sin_addr.S_un.S_addr != INADDR_NONE)
						{
							//
							// Move the IN_ADDR component of this address
							// toward the front of the buffer, into it's
							// correct place in the array.
							//
							painaddrAddresses[dwTemp].S_un.S_addr = ((SOCKADDR_IN*) (paSocketAddresses[dwTemp].lpSockaddr))->sin_addr.S_un.S_addr;

							DPFX(DPFPREP, 7, "\t%u- %u.%u.%u.%u",
								dwTemp,
								painaddrAddresses[dwTemp].S_un.S_un_b.s_b1,
								painaddrAddresses[dwTemp].S_un.S_un_b.s_b2,
								painaddrAddresses[dwTemp].S_un.S_un_b.s_b3,
								painaddrAddresses[dwTemp].S_un.S_un_b.s_b4);
						}
						else
						{
							DPFX(DPFPREP, 1, "\t%u- Ignoring 0.0.0.0 address.", dwTemp);
							dwAddressesSize++;

							//
							// The code should handle this fine, but why is
							// WinSock doing this to us?
							//
							DNASSERT(FALSE);
						}
					}

					//
					// Subtract out any invalid addresses that we skipped.
					//
					dwNumAddresses -= dwAddressesSize;
					if (dwNumAddresses == 0)
					{
						DPFX(DPFPREP, 1, "WinSock 2 reported only invalid addresses, hoping WinSock 1 method picks up the loopback address.");

						DNFree(painaddrAddresses);
						painaddrAddresses = NULL;
					}
				}
				else
				{
					DPFX(DPFPREP, 1, "WinSock 2 Ioctl did not report any valid addresses, hoping WinSock 1 method picks up the loopback address.");

					DNFree(painaddrAddresses);
					painaddrAddresses = NULL;
				}

				//
				// Get out of the loop.
				//
				break;
			}
		}
		while (TRUE);
	}


	//
	// Get the list of all available addresses from the WinSock 1 API if we
	// don't already have them.
	//
	if (painaddrAddresses == NULL)
#endif // ! DPNBUILD_NOWINSOCK2
	{
		if (this->m_pfngethostname(szName, 1000) != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't get host name, error = %u!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		phostent = this->m_pfngethostbyname(szName);
		if (phostent == NULL)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't retrieve addresses, error = %u!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// WinSock says that you need to copy this data before you make any
		// other API calls.  So first we count the number of entries we need to
		// copy.
		//
		ppinaddr = (IN_ADDR**) phostent->h_addr_list;
		while ((*ppinaddr) != NULL)
		{
			//
			// Ignore 0.0.0.0 addresses.
			//
			if ((*ppinaddr)->S_un.S_addr != INADDR_NONE)
			{
				dwNumAddresses++;
			}
			else
			{
				DPFX(DPFPREP, 1, "Ignoring 0.0.0.0 address.");

				//
				// The code should handle this fine, but why is WinSock doing
				// this to us?
				//
				DNASSERT(FALSE);
			}

			ppinaddr++;
		}


		//
		// If there aren't any addresses, we must fail.  WinSock 1 ought to
		// report the loopback address at least.
		//
		if (dwNumAddresses == 0)
		{
			DPFX(DPFPREP, 0, "WinSock 1 did not report any valid addresses!");
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		DPFX(DPFPREP, 7, "WinSock 1 method returned %u valid addresses:", dwNumAddresses);

		painaddrAddresses = (IN_ADDR*) DNMalloc(dwNumAddresses * sizeof(IN_ADDR));
		if (painaddrAddresses == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		//
		// Now copy all the addresses.
		//
		ppinaddr = (IN_ADDR**) phostent->h_addr_list;
		
		dwTemp = 0;
		while ((*ppinaddr) != NULL)
		{
			//
			// Ignore 0.0.0.0 addresses again.
			//
			if ((*ppinaddr)->S_un.S_addr != INADDR_NONE)
			{
				painaddrAddresses[dwTemp].S_un.S_addr = (*ppinaddr)->S_un.S_addr;
				
				DPFX(DPFPREP, 7, "\t%u- %u.%u.%u.%u",
					dwTemp,
					painaddrAddresses[dwTemp].S_un.S_un_b.s_b1,
					painaddrAddresses[dwTemp].S_un.S_un_b.s_b2,
					painaddrAddresses[dwTemp].S_un.S_un_b.s_b3,
					painaddrAddresses[dwTemp].S_un.S_un_b.s_b4);

				dwTemp++;
			}

			ppinaddr++;
		}
				
		DNASSERT(dwTemp == dwNumAddresses);
	}
	/*
	else
	{
		//
		// Already have addresses array.
		//
	}
	*/


	//
	// Make sure that all of the devices we currently know about are still
	// around.
	//
	pBilinkDevice = this->m_blDevices.GetNext();
	while (pBilinkDevice != &this->m_blDevices)
	{
		DNASSERT(! pBilinkDevice->IsEmpty());
		pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
		pBilinkDevice = pBilinkDevice->GetNext();

		fFound = FALSE;
		for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
		{
			if (painaddrAddresses[dwTemp].S_un.S_addr == pDevice->GetLocalAddressV4())
			{
				fFound = TRUE;
				break;
			}
		}

		if (fFound)
		{
			//
			// It may be time for this device to use a different port...
			//
			dwTemp = pDevice->GetFirstUPnPDiscoveryTime();
			if ((dwTemp != 0) && ((GETTIMESTAMP() - dwTemp) > g_dwReusePortTime))
			{
				ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
				saddrinTemp.sin_family				= AF_INET;
				saddrinTemp.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();

				sTemp = this->CreateSocket(&saddrinTemp, SOCK_DGRAM, IPPROTO_UDP);
				if (sTemp != INVALID_SOCKET)
				{
					//
					// Sanity check that we didn't lose the device address.
					//
					DNASSERT(saddrinTemp.sin_addr.S_un.S_addr == pDevice->GetLocalAddressV4());

					DPFX(DPFPREP, 4, "Device 0x%p UPnP discovery socket 0x%p (%u.%u.%u.%u:%u) created to replace port %u.",
						pDevice,
						sTemp,
						saddrinTemp.sin_addr.S_un.S_un_b.s_b1,
						saddrinTemp.sin_addr.S_un.S_un_b.s_b2,
						saddrinTemp.sin_addr.S_un.S_un_b.s_b3,
						saddrinTemp.sin_addr.S_un.S_un_b.s_b4,
						NTOHS(saddrinTemp.sin_port),
						NTOHS(pDevice->GetUPnPDiscoverySocketPort()));

#ifndef DPNBUILD_NOHNETFWAPI
					//
					// If we used the HomeNet firewall API to open a hole for UPnP
					// discovery multicasts, close it.
					//
					if (pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall())
					{
						hr = this->CloseDevicesUPnPDiscoveryPort(pDevice, NULL);
						if (hr != DPNH_OK)
						{
							DPFX(DPFPREP, 0, "Couldn't close device 0x%p's previous UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring.",
								pDevice, hr);

							//
							// Continue...
							//
							pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();
							hr = DPNH_OK;
						}
					}
#endif // ! DPNBUILD_NOHNETFWAPI

					pDevice->SetUPnPDiscoverySocketPort(saddrinTemp.sin_port);
					pDevice->SetFirstUPnPDiscoveryTime(0);

					//
					// Close the existing socket.
					//
					this->m_pfnclosesocket(pDevice->GetUPnPDiscoverySocket());

					//
					// Transfer ownership of the new socket to the device.
					//
					pDevice->SetUPnPDiscoverySocket(sTemp);
					sTemp = INVALID_SOCKET;

					DPFX(DPFPREP, 8, "Device 0x%p got re-assigned UPnP socket 0x%p.",
						pDevice, pDevice->GetUPnPDiscoverySocket());

					//
					// We'll let the normal "check for firewall" code detect
					// the fact that the discovery socket is not mapped on the
					// firewall and try to do so there (if it even needs to be
					// mapped).  See UpdateServerStatus.
					//
				}
				else
				{
					DPFX(DPFPREP, 0, "Couldn't create a replacement UPnP discovery socket for device 0x%p!  Using existing port %u.",
						pDevice, NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
				}
			}
		}
		else
		{
			//
			// Didn't find this device in the returned list, forget about
			// it.
			//
#ifdef DBG
			{
				IN_ADDR		inaddrTemp;


				inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();
				DPFX(DPFPREP, 1, "Device 0x%p no longer exists, removing (address was %u.%u.%u.%u).",
					pDevice,
					inaddrTemp.S_un.S_un_b.s_b1,
					inaddrTemp.S_un.S_un_b.s_b2,
					inaddrTemp.S_un.S_un_b.s_b3,
					inaddrTemp.S_un.S_un_b.s_b4);
			}

			this->m_dwNumDeviceRemoves++;
#endif // DBG


			//
			// Override the minimum UpdateServerStatus interval so that we can
			// get information on any local public address changes due to the
			// possible loss of a server on this interface.
			//
			this->m_dwFlags |= NATHELPUPNPOBJ_DEVICECHANGED;

			//
			// Since there was a change in the network, go back to polling
			// relatively quickly.
			//
			this->ResetNextPollInterval();


			//
			// Forcefully mark the UPnP gateway device as disconnected.
			//
			if (pDevice->GetUPnPDevice() != NULL)
			{
				this->ClearDevicesUPnPDevice(pDevice);
			}
			

			//
			// Mark all ports that were registered to this device as unowned
			// by putting them into the wildcard list.  First unmap them from
			// the firewall.
			//
			pBilinkRegPort = pDevice->m_blOwnedRegPorts.GetNext();
			while (pBilinkRegPort != &pDevice->m_blOwnedRegPorts)
			{
				DNASSERT(! pBilinkRegPort->IsEmpty());
				pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegPort);
				pBilinkRegPort = pBilinkRegPort->GetNext();

				DPFX(DPFPREP, 1, "Registered port 0x%p's device went away, marking as unowned.",
					pRegisteredPort);


#ifndef DPNBUILD_NOHNETFWAPI
				//
				// Even though the device is gone, we can still remove the
				// firewall mapping.
				//
				if (pRegisteredPort->IsMappedOnHNetFirewall())
				{
					//
					// Unmap the port.
					//
					// Alert the user since this is unexpected.
					//
					hr = this->UnmapPortOnLocalHNetFirewall(pRegisteredPort,
															TRUE,
															TRUE);
					if (hr != DPNH_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't unmap registered port 0x%p from device 0x%p's firewall (err = 0x%lx)!  Ignoring.",
							pRegisteredPort, pDevice, hr);

						pRegisteredPort->NoteNotMappedOnHNetFirewall();
						pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

						//
						// Continue anyway.
						//
						hr = DPNH_OK;
					}
				}
				
				pRegisteredPort->NoteNotHNetFirewallPortUnavailable();
#endif // ! DPNBUILD_NOHNETFWAPI

				DNASSERT(! pRegisteredPort->HasUPnPPublicAddresses());
				DNASSERT(! pRegisteredPort->IsUPnPPortUnavailable());

				pRegisteredPort->ClearDeviceOwner();
				pRegisteredPort->m_blDeviceList.RemoveFromList();
				pRegisteredPort->m_blDeviceList.InsertBefore(&this->m_blUnownedPorts);

				//
				// The user doesn't directly need to be informed.  If the ports
				// previously had public addresses, the ADDRESSESCHANGED flag
				// would have already been set by ClearDevicesUPnPDevice. If
				// they didn't have ports with public addresses, then the user
				// won't see any difference and thus ADDRESSESCHANGED wouldn't
				// need to be set.
				//
			}


#ifndef DPNBUILD_NOHNETFWAPI
			//
			// If we used the HomeNet firewall API to open a hole for UPnP
			// discovery multicasts, close it.
			//
			if (pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall())
			{
				hr = this->CloseDevicesUPnPDiscoveryPort(pDevice, NULL);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't close device 0x%p's UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring.",
						pDevice, hr);

					//
					// Continue...
					//
					pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();
					hr = DPNH_OK;
				}
			}
#endif // ! DPNBUILD_NOHNETFWAPI


			pDevice->m_blList.RemoveFromList();


			//
			// Close the socket, if we had one.
			//
			if (this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP)
			{
				this->m_pfnclosesocket(pDevice->GetUPnPDiscoverySocket());
				pDevice->SetUPnPDiscoverySocket(INVALID_SOCKET);
			}

			delete pDevice;
		}
	}


	//
	// Search for all returned devices in our existing list, and add new
	// entries for each one that we didn't already know about.
	//
	for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
	{
		fFound = FALSE;

		pBilinkDevice = this->m_blDevices.GetNext();
		while (pBilinkDevice != &this->m_blDevices)
		{
			DNASSERT(! pBilinkDevice->IsEmpty());
			pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
			pBilinkDevice = pBilinkDevice->GetNext();

			if (pDevice->GetLocalAddressV4() == painaddrAddresses[dwTemp].S_un.S_addr)
			{
				fFound = TRUE;
				break;
			}
		}

		if (! fFound)
		{
			//
			// We didn't know about this device.  Create a new object.
			//
			pDevice = new CDevice(painaddrAddresses[dwTemp].S_un.S_addr);
			if (pDevice == NULL)
			{
				hr = DPNHERR_OUTOFMEMORY;
				goto Failure;
			}

			fDeviceCreated = TRUE;


#ifdef DBG
			DPFX(DPFPREP, 1, "Found new device %u.%u.%u.%u, (object = 0x%p).",
				painaddrAddresses[dwTemp].S_un.S_un_b.s_b1,
				painaddrAddresses[dwTemp].S_un.S_un_b.s_b2,
				painaddrAddresses[dwTemp].S_un.S_un_b.s_b3,
				painaddrAddresses[dwTemp].S_un.S_un_b.s_b4,
				pDevice);

			this->m_dwNumDeviceAdds++;
#endif // DBG


			//
			// Override the minimum UpdateServerStatus interval so that we can
			// get information on this new device.
			//
			this->m_dwFlags |= NATHELPUPNPOBJ_DEVICECHANGED;

			//
			// Since there was a change in the network, go back to polling
			// relatively quickly.
			//
			this->ResetNextPollInterval();


			//
			// Create the UPnP discovery socket, if we're allowed.
			//
			if (this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP)
			{
				ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
				saddrinTemp.sin_family				= AF_INET;
				saddrinTemp.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();

				sTemp = this->CreateSocket(&saddrinTemp, SOCK_DGRAM, IPPROTO_UDP);
				if (sTemp == INVALID_SOCKET)
				{
					DPFX(DPFPREP, 0, "Couldn't create a UPnP discovery socket!  Ignoring address (and destroying device 0x%p).",
						pDevice);

					//
					// Get rid of the device.
					//
					delete pDevice;
					pDevice = NULL;


					//
					// Forget about device in case of failure later.
					//
					fDeviceCreated = FALSE;


					//
					// Move to next address.
					//
					continue;
				}

				//
				// Sanity check that we didn't lose the device address.
				//
				DNASSERT(saddrinTemp.sin_addr.S_un.S_addr == pDevice->GetLocalAddressV4());

				DPFX(DPFPREP, 4, "Device 0x%p UPnP discovery socket 0x%p (%u.%u.%u.%u:%u) created.",
					pDevice,
					sTemp,
					saddrinTemp.sin_addr.S_un.S_un_b.s_b1,
					saddrinTemp.sin_addr.S_un.S_un_b.s_b2,
					saddrinTemp.sin_addr.S_un.S_un_b.s_b3,
					saddrinTemp.sin_addr.S_un.S_un_b.s_b4,
					NTOHS(saddrinTemp.sin_port));

				pDevice->SetUPnPDiscoverySocketPort(saddrinTemp.sin_port);

				//
				// Transfer ownership of the socket to the device.
				//
				pDevice->SetUPnPDiscoverySocket(sTemp);
				sTemp = INVALID_SOCKET;

				DPFX(DPFPREP, 8, "Device 0x%p got assigned UPnP socket 0x%p.",
					pDevice, pDevice->GetUPnPDiscoverySocket());
			}


#ifndef DPNBUILD_NOHNETFWAPI
			if (this->m_dwFlags & NATHELPUPNPOBJ_USEHNETFWAPI)
			{
				//
				// Check if the local firewall is enabled.
				//
				hr = this->CheckForLocalHNetFirewallAndMapPorts(pDevice, NULL);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't check for local HNet firewall and map ports (err = 0x%lx)!  Continuing.",
						hr);
					DNASSERT(! pDevice->IsHNetFirewalled());
					hr = DPNH_OK;
				}
			}
			else
			{
				//
				// Not using firewall traversal.
				//
			}
#endif // ! DPNBUILD_NOHNETFWAPI


			//
			// Add the device to our known list.
			//
			pDevice->m_blList.InsertBefore(&this->m_blDevices);


			//
			// Inform the caller if they care.
			//
			if (pfFoundNewDevices != NULL)
			{
				(*pfFoundNewDevices) = TRUE;
			}


			//
			// Forget about device in case of failure later.
			//
			fDeviceCreated = FALSE;
		}
	}


	//
	// If we got some very weird failures and ended up here without any
	// devices, complain to management (or the caller of this function, that's
	// probably more convenient).
	//
	if (this->m_blDevices.IsEmpty())
	{
		DPFX(DPFPREP, 0, "No usable devices, cannot proceed!", 0);
		DNASSERTX(! "No usable devices!", 2);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


Exit:

	if (painaddrAddresses != NULL)
	{
		DNFree(painaddrAddresses);
		painaddrAddresses = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (sTemp != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(sTemp);
		sTemp = INVALID_SOCKET;
	}

	if (fDeviceCreated)
	{
		delete pDevice;
	}

	goto Exit;
} // CNATHelpUPnP::CheckForNewDevices




#ifndef DPNBUILD_NOHNETFWAPI



#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CheckForLocalHNetFirewallAndMapPorts"
//=============================================================================
// CNATHelpUPnP::CheckForLocalHNetFirewallAndMapPorts
//-----------------------------------------------------------------------------
//
// Description:    Looks for a local HomeNet API aware firewall, and ensures
//				there are mappings for each of the device's registered ports,
//				if a firewall is found.
//
//				   If any registered port (except pDontAlertRegisteredPort if
//				not NULL) gets mapped, then it will trigger an address update
//				alert the next time the user calls GetCaps.
//
//				   The main object lock is assumed to be held.  It will be
//				converted into the long lock for the duration of this function.
//
// Arguments:
//	CDevice * pDevice							- Pointer to device to check.
//	CRegisteredPort * pDontAlertRegisteredPort	- Pointer to registered port
//													that should not trigger an
//													address update alert, or
//													NULL.
//
// Returns: HRESULT
//	DPNH_OK				- Search completed successfully.  There may or may not
//							be a firewall.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CheckForLocalHNetFirewallAndMapPorts(CDevice * const pDevice,
														CRegisteredPort * const pDontAlertRegisteredPort)
{
	HRESULT				hr = DPNH_OK;
	BOOL				fSwitchedToLongLock = FALSE;
	BOOL				fUninitializeCOM = FALSE;
	IHNetCfgMgr *		pHNetCfgMgr = NULL;
	IHNetConnection *	pHNetConnection = NULL;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pDevice, pDontAlertRegisteredPort);


	//
	// If this is the loopback address, don't bother trying to map anything.
	//
	if (pDevice->GetLocalAddressV4() == NETWORKBYTEORDER_INADDR_LOOPBACK)
	{
		DPFX(DPFPREP, 7, "No firewall behavior necessary with loopback device 0x%p.",
			pDevice);
		goto Exit;
	}
	

	//
	// If we don't have IPHLPAPI or RASAPI32, we can't do anything (and
	// shouldn't need to).
	//
	if ((this->m_hIpHlpApiDLL == NULL) || (this->m_hRasApi32DLL == NULL))
	{
		DPFX(DPFPREP, 7, "Didn't load IPHLPAPI and/or RASAPI32, not getting HNet interfaces for device 0x%p.",
			pDevice);
		goto Exit;
	}


	//
	// Using the HomeNet API (particularly the out-of-proc COM calls) during
	// stress is really, really, painfully slow.  Since we have one global lock
	// the controls everything, other threads may be sitting for an equally
	// long time... so long, in fact, that the critical section timeout fires
	// and we get a false stress hit.  So we have a sneaky workaround to
	// prevent that from happening while still maintaining ownership of the
	// object.
	//
	this->SwitchToLongLock();
	fSwitchedToLongLock = TRUE;


	//
	// Try to initialize COM if we weren't instantiated through COM.  It may
	// have already been initialized in a different mode, which is okay.  As
	// long as it has been initialized somehow, we're fine.
	//
	if (this->m_dwFlags & NATHELPUPNPOBJ_NOTCREATEDWITHCOM)
	{
		hr = CoInitializeEx(NULL, (COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE));
		switch (hr)
		{
			case S_OK:
			{
				//
				// Success, that's good.  Cleanup when we're done.
				//
				DPFX(DPFPREP, 8, "Successfully initialized COM.");
				fUninitializeCOM = TRUE;
				break;
			}

			case S_FALSE:
			{
				//
				// Someone else already initialized COM, but that's okay.
				// Cleanup when we're done.
				//
				DPFX(DPFPREP, 8, "Initialized COM (again).");
				fUninitializeCOM = TRUE;
				break;
			}

			case RPC_E_CHANGED_MODE:
			{
				//
				// Someone else already initialized COM in a different mode.
				// It should be okay, but we don't have to balance the CoInit
				// call with a CoUninit.
				//
				DPFX(DPFPREP, 8, "Didn't initialize COM, already initialized in a different mode.");
				break;
			}

			default:
			{
				//
				// Hmm, something else is going on.  We can't handle that.
				//
				DPFX(DPFPREP, 0, "Initializing COM failed (err = 0x%lx)!", hr);
				goto Failure;
				break;
			}
		}
	}
	else
	{
		DPFX(DPFPREP, 8, "Object was instantiated through COM, no need to initialize COM.");
	}


	//
	// Try creating the main HNet manager object.
	//
	hr = CoCreateInstance(CLSID_HNetCfgMgr, NULL, CLSCTX_INPROC_SERVER,
						IID_IHNetCfgMgr, (PVOID*) (&pHNetCfgMgr));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 1, "Couldn't create IHNetCfgMgr interface for device 0x%p (err = 0x%lx), assuming firewall control interface unavailable.",
			pDevice, hr);
		hr = DPNH_OK;
		goto Exit;
	}


	//
	// We created the IHNetCfgMgr object as in-proc, so there's no proxy that
	// requires security settings.
	//
	//SETDEFAULTPROXYBLANKET(pHNetCfgMgr);



	//
	// Get the HNetConnection object for this device.
	//
	hr = this->GetIHNetConnectionForDeviceIfFirewalled(pDevice,
														pHNetCfgMgr,
														&pHNetConnection);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 1, "Couldn't get IHNetConnection interface for device 0x%p (err = 0x%lx), assuming firewall not enabled.",
			pDevice, hr);


		//
		// If the device was previously firewalled, we need to clear our info.
		//
		if (pDevice->IsHNetFirewalled())
		{
			DPFX(DPFPREP, 2, "Firewall is no longer enabled for device 0x%p.",
				pDevice);

			//
			// Since there was a change in the network, go back to polling
			// relatively quickly.
			//
			this->ResetNextPollInterval();


			DNASSERT(pDevice->HasCheckedForFirewallAvailability());


			pBilink = pDevice->m_blOwnedRegPorts.GetNext();
			while (pBilink != &pDevice->m_blOwnedRegPorts)
			{
				DNASSERT(! pBilink->IsEmpty());
				pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);

				//
				// Unmap items mapped on the firewall.
				//
				if (pRegisteredPort->IsMappedOnHNetFirewall())
				{
					DPFX(DPFPREP, 1, "Unmapping registered port 0x%p from device 0x%p's disappearing firewall.",
						pRegisteredPort, pDevice);


					hr = this->UnmapPortOnLocalHNetFirewallInternal(pRegisteredPort,
																	TRUE,
																	pHNetCfgMgr);
					if (hr != DPNH_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't unmap registered port 0x%p from device 0x%p's firewall (err = 0x%lx)!  Ignoring.",
							pRegisteredPort, pDevice, hr);

						pRegisteredPort->NoteNotMappedOnHNetFirewall();
						pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

						//
						// Continue anyway.
						//
						hr = DPNH_OK;
					}


					//
					// Alert the user.
					//
					this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;
				}
				else
				{
					DPFX(DPFPREP, 1, "Registered port 0x%p was not mapped on device 0x%p's disappearing firewall, assuming being called within RegisterPorts.",
						pRegisteredPort, pDevice);
				}


				//
				// Go to next port.
				//
				pBilink = pBilink->GetNext();
			}


			//
			// If we used the HomeNet firewall API to open a hole for UPnP
			// discovery multicasts, unmap that, too.
			//
			if (pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall())
			{
				DPFX(DPFPREP, 0, "Device 0x%p's UPnP discovery socket's forcefully unmapped from disappearing firewall.",
					pDevice);

				hr = this->CloseDevicesUPnPDiscoveryPort(pDevice, pHNetCfgMgr);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't close device 0x%p's UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring.",
						pDevice, hr);

					//
					// Continue...
					//
					pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();
					hr = DPNH_OK;
				}
			}


			//
			// Turn off the flag now that all registered ports have been
			// removed.
			//
			pDevice->NoteNotHNetFirewalled();
		}
		else
		{
			if (! pDevice->HasCheckedForFirewallAvailability())
			{
				//
				// The firewall is not enabled.
				//

				DPFX(DPFPREP, 2, "Firewall is not enabled for device 0x%p.",
					pDevice);

				pDevice->NoteCheckedForFirewallAvailability();


				//
				// Since it is possible to remove mappings even without the
				// firewall enabled, we can be courteous and unmap any stale
				// entries left by previous app crashes when the firewall was
				// still enabled.
				//

				//
				// Pretend that it currently had been firewalled.
				//
				pDevice->NoteHNetFirewalled();


				//
				// Cleanup the mappings.
				//
				hr = this->CleanupInactiveFirewallMappings(pDevice, pHNetCfgMgr);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Failed cleaning up inactive firewall mappings with device 0x%p (firewall not initially enabled)!",
						pDevice);
					goto Failure;
				}


				//
				// Turn off the flag we temporarily enabled while clearing
				// the mappings.
				//
				pDevice->NoteNotHNetFirewalled();
			}
			else
			{
				//
				// The firewall is still not enabled.
				//
				DPFX(DPFPREP, 2, "Firewall is still not enabled for device 0x%p.",
					pDevice);
			}
		}
		
		hr = DPNH_OK;
		goto Exit;
	}


	//
	// If firewalling is enabled now, and wasn't before, we need to map all the
	// existing ports.  If it had been, we're fine.
	//
	if (! pDevice->IsHNetFirewalled())
	{
		DPFX(DPFPREP, 2, "Firewall is now enabled for device 0x%p.",
			pDevice);

		pDevice->NoteCheckedForFirewallAvailability();
		pDevice->NoteHNetFirewalled();

		//
		// Since there was a change in the network, go back to polling
		// relatively quickly.
		//
		this->ResetNextPollInterval();


		//
		// If we're allowed, we need to try opening a hole so that we can
		// receive responses from device discovery multicasts.  We'll
		// ignore failures, since this is only to support the funky case of
		// enabling firewall behind a NAT.
		//
		if ((g_fMapUPnPDiscoverySocket) &&
			(pDevice->GetLocalAddressV4() != NETWORKBYTEORDER_INADDR_LOOPBACK) &&
			(this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP))
		{
			hr = this->OpenDevicesUPnPDiscoveryPort(pDevice,
													pHNetCfgMgr,
													pHNetConnection);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't open device 0x%p's UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring, NAT may be undetectable.",
					pDevice, hr);
				hr = DPNH_OK;

				//
				// Continue...
				//
			}
		}
		else
		{
			DPFX(DPFPREP, 3, "Not opening device 0x%p's UPnP discovery port (domap = %i, loopback = %i, upnp = %i).",
				pDevice,
				g_fMapUPnPDiscoverySocket,
				((pDevice->GetLocalAddressV4() != NETWORKBYTEORDER_INADDR_LOOPBACK) ? FALSE : TRUE),
				((this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP) ? TRUE : FALSE));
		}


		//
		// Try to remove any mappings that were not freed earlier because
		// we crashed.
		//
		hr = this->CleanupInactiveFirewallMappings(pDevice, pHNetCfgMgr);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed cleaning up inactive firewall mappings with device 0x%p's new firewall!",
				pDevice);
			goto Failure;
		}
	}
	else
	{
		DPFX(DPFPREP, 2, "Firewall is still enabled for device 0x%p.",
			pDevice);

		DNASSERT(pDevice->HasCheckedForFirewallAvailability());

		//
		// Try to map the discovery socket if it hasn't been (and we're allowed
		// & supposed to).
		//
		if ((g_fMapUPnPDiscoverySocket) &&
			(! pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall()) &&
			(pDevice->GetLocalAddressV4() != NETWORKBYTEORDER_INADDR_LOOPBACK) &&
			(this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP))
		{
			hr = this->OpenDevicesUPnPDiscoveryPort(pDevice,
													pHNetCfgMgr,
													pHNetConnection);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't open device 0x%p's UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring, NAT may be undetectable.",
					pDevice, hr);
				hr = DPNH_OK;

				//
				// Continue...
				//
			}
		}
		else
		{
			DPFX(DPFPREP, 3, "Not opening device 0x%p's UPnP discovery port (domap = %i, already = %i, loopback = %i, upnp = %i).",
				pDevice,
				g_fMapUPnPDiscoverySocket,
				pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall(),
				((pDevice->GetLocalAddressV4() != NETWORKBYTEORDER_INADDR_LOOPBACK) ? FALSE : TRUE),
				((this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP) ? TRUE : FALSE));
		}
	}


	//
	// Map all the ports that haven't been yet.
	//
	hr = this->MapUnmappedPortsOnLocalHNetFirewall(pDevice,
													pHNetCfgMgr,
													pHNetConnection,
													pDontAlertRegisteredPort);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't map ports on device 0x%p's new firewall (err = 0x%lx)!",
			pDevice, hr);
		goto Failure;
	}


	DNASSERT(hr == DPNH_OK);


Exit:

	if (pHNetConnection != NULL)
	{
		pHNetConnection->Release();
		pHNetConnection = NULL;
	}

	if (pHNetCfgMgr != NULL)
	{
		pHNetCfgMgr->Release();
		pHNetCfgMgr = NULL;
	}

	if (fUninitializeCOM)
	{
		DPFX(DPFPREP, 8, "Uninitializing COM.");
		CoUninitialize();
		fUninitializeCOM = FALSE;
	}

	if (fSwitchedToLongLock)
	{
		this->SwitchFromLongLock();
		fSwitchedToLongLock = FALSE;
	}


	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// Ensure that the device is not considered to be firewalled.
	//
	pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();
	pDevice->NoteNotHNetFirewalled();


	//
	// Make sure no registered ports are marked as firewalled either.
	//
	pBilink = pDevice->m_blOwnedRegPorts.GetNext();
	while (pBilink != &pDevice->m_blOwnedRegPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);

		if (pRegisteredPort->IsMappedOnHNetFirewall())
		{
			DPFX(DPFPREP, 1, "Registered port 0x%p forcefully marked as not mapped on HomeNet firewall.",
				pRegisteredPort);

			pRegisteredPort->NoteNotMappedOnHNetFirewall();
			pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
		}

		pBilink = pBilink->GetNext();
	}

	goto Exit;
} // CNATHelpUPnP::CheckForLocalHNetFirewallAndMapPorts






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetIHNetConnectionForDeviceIfFirewalled"
//=============================================================================
// CNATHelpUPnP::GetIHNetConnectionForDeviceIfFirewalled
//-----------------------------------------------------------------------------
//
// Description:    Returns an IHNetConnection interface for the given device.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice						- Pointer to device whose
//												IHNetConnection interface
//												should be retrieved.
//	IHNetCfgMgr * pHNetCfgMgr				- IHNetCfgMgr interface to use.
//	IHNetConnection ** ppHNetConnection		- Place to store IHetConnection
//												interface retrieved.
//
// Returns: HRESULT
//	DPNH_OK				- Interface retrieved successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::GetIHNetConnectionForDeviceIfFirewalled(CDevice * const pDevice,
															IHNetCfgMgr * const pHNetCfgMgr,
															IHNetConnection ** const ppHNetConnection)
{
	HRESULT								hr;
	DWORD								dwError;
	IHNetFirewallSettings *				pHNetFirewallSettings = NULL;
	IEnumHNetFirewalledConnections *	pEnumHNetFirewalledConnections = NULL;
	IHNetFirewalledConnection *			pHNetFirewalledConnection = NULL;
	ULONG								ulNumFound;
	IHNetConnection *					pHNetConnection = NULL;
	HNET_CONN_PROPERTIES *				pHNetConnProperties;
	BOOL								fLanConnection;
	IN_ADDR								inaddrTemp;
	TCHAR								tszDeviceIPAddress[16];	// "nnn.nnn.nnn.nnn" + NULL termination
	BOOL								fHaveDeviceGUID = FALSE;
	TCHAR								tszGuidDevice[GUID_STRING_LENGTH + 1];	// include NULL termination
	TCHAR								tszGuidHNetConnection[GUID_STRING_LENGTH + 1];	// include NULL termination
	GUID *								pguidHNetConnection = NULL;
	WCHAR *								pwszPhonebookPath = NULL;
	WCHAR *								pwszName = NULL;
	HRASCONN							hrasconn;
	RASPPPIP							raspppip;
	DWORD								dwSize;


	DPFX(DPFPREP, 6, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p)",
		this, pDevice, pHNetCfgMgr, ppHNetConnection);


	//
	// Convert the IP address right away.  We use it frequently so there's no
	// sense in continually regenerating it.
	//
	inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();
	wsprintf(tszDeviceIPAddress, _T("%u.%u.%u.%u"),
			inaddrTemp.S_un.S_un_b.s_b1,
			inaddrTemp.S_un.S_un_b.s_b2,
			inaddrTemp.S_un.S_un_b.s_b3,
			inaddrTemp.S_un.S_un_b.s_b4);


	//
	// Here is what we're going to do in this function:
	//
	//	IHNetCfgMgr::QueryInterface for IHNetFirewallSettings
	//	IHNetFirewallSettings::EnumFirewalledConnections
	//		IHNetFirewalledConnection::QueryInterface for IHNetConnection
	//		get the IHNetConnection's HNET_CONN_PROPERTIES
	//		if HNET_CONN_PROPERTIES.fLanConnection
	//			IHNetConnection::GetGuid()
	//			if GUID matches IPHLPAPI GUID
	//					We've got the one we want, we're done
	//			else
	//				Keep looping
	//		else
	//			IHNetConnection::GetRasPhonebookPath and IHNetConnection::GetName to pass into RasGetEntryHrasconnW as pszPhonebook and pszEntry, respectively
	//			if got HRASCONN
	//				RasGetProjectionInfo
	//				if IP matches the IP we're looking for
	//					We've got the one we want, we're done
	//				else
	//					Keep looping
	//			else
	//				RAS entry is not dialed, keep looping
	//	if didn't find object
	//		it's not firewalled
	//


	//
	// Get the firewall settings object.
	//
	hr = pHNetCfgMgr->QueryInterface(IID_IHNetFirewallSettings,
									(PVOID*) (&pHNetFirewallSettings));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't query for IHNetFirewallSettings interface (err = 0x%lx)!",
			hr);
		goto Failure;
	}


	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pHNetFirewallSettings);


	//
	// Get the firewalled connections enumeration via IHNetFirewallSettings.
	//
	hr = pHNetFirewallSettings->EnumFirewalledConnections(&pEnumHNetFirewalledConnections);
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't query for IHNetFirewallSettings interface (err = 0x%lx)!",
			hr);

		//
		// Make sure we don't try to release a bogus pointer in case it got
		// set.
		//
		pEnumHNetFirewalledConnections = NULL;

		goto Failure;
	}


	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pEnumHNetFirewalledConnections);


	//
	// Don't need the IHNetFirewallSettings interface anymore.
	//
	pHNetFirewallSettings->Release();
	pHNetFirewallSettings = NULL;


	//
	// Keep looping until we find the item or run out of items.
	//
	do
	{
		hr = pEnumHNetFirewalledConnections->Next(1,
												&pHNetFirewalledConnection,
												&ulNumFound);
		if (FAILED(hr))
		{
			DPFX(DPFPREP, 0, "Couldn't get next connection (err = 0x%lx)!",
				hr);
			goto Failure;
		}


		//
		// If there aren't any more items, bail.
		//
		if (ulNumFound == 0)
		{
			//
			// pEnumHNetFirewalledConnections->Next might have returned
			// S_FALSE.
			//
			hr = DPNH_OK;
			break;
		}


		//
		// The HNetxxx objects appear to not be proxied...
		//
		//SETDEFAULTPROXYBLANKET(pHNetFirewalledConnection);


		//
		// Get the IHNetConnection interface.
		//
		hr = pHNetFirewalledConnection->QueryInterface(IID_IHNetConnection,
														(PVOID*) (&pHNetConnection));
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't query for IHNetConnection interface (err = 0x%lx)!",
				hr);
			goto Failure;
		}


		//
		// The HNetxxx objects appear to not be proxied...
		//
		//SETDEFAULTPROXYBLANKET(pHNetConnection);


		//
		// We don't need the firewalled connection object anymore.
		//
		pHNetFirewalledConnection->Release();
		pHNetFirewalledConnection = NULL;


		//
		// Get the internal properties for this adapter.
		//
		hr = pHNetConnection->GetProperties(&pHNetConnProperties);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't get home net connection properties (err = 0x%lx)!",
				hr);
			goto Failure;
		}

		//
		// Be somewhat picky about whether adapters returned by
		// IEnumHNetFirewalledConnections actually be firewalled.
		//
		DNASSERTX(pHNetConnProperties->fFirewalled, 2);


		fLanConnection = pHNetConnProperties->fLanConnection;


		//
		// Free the properties buffer.
		//
		CoTaskMemFree(pHNetConnProperties);
		//pHNetConnProperties = NULL;


		//
		// Now if it's a LAN connection, see if the GUID matches the one
		// returned by IPHLPAPI.
		// If it's a RAS connection, see if this phonebook entry is dialed and
		// has the right IP address.
		//
		if (fLanConnection)
		{
			//
			// LAN case.  If we haven't already retrieved the device's GUID, do
			// so now.
			//
			if (! fHaveDeviceGUID)
			{
				hr = this->GetIPAddressGuidString(tszDeviceIPAddress, tszGuidDevice);
				if (hr != S_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't get device 0x%p's GUID (err = 0x%lx)!",
						hr);
					goto Failure;
				}

				fHaveDeviceGUID = TRUE;
			}


			//
			// Get the HNetConnection object's GUID.
			//
			hr = pHNetConnection->GetGuid(&pguidHNetConnection);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get HNetConnection 0x%p's GUID (err = 0x%lx)!",
					pHNetConnection, hr);
				goto Failure;
			}


			//
			// Convert the GUID into a string.
			//
			wsprintf(tszGuidHNetConnection,
					_T("{%-08.8X-%-04.4X-%-04.4X-%02.2X%02.2X-%02.2X%02.2X%02.2X%02.2X%02.2X%02.2X}"),
					pguidHNetConnection->Data1,
					pguidHNetConnection->Data2,
					pguidHNetConnection->Data3,
					pguidHNetConnection->Data4[0],
					pguidHNetConnection->Data4[1],
					pguidHNetConnection->Data4[2],
					pguidHNetConnection->Data4[3],
					pguidHNetConnection->Data4[4],
					pguidHNetConnection->Data4[5],
					pguidHNetConnection->Data4[6],
					pguidHNetConnection->Data4[7]);


			CoTaskMemFree(pguidHNetConnection);
			pguidHNetConnection = NULL;


#ifdef DBG
			//
			// Attempt to get the HNetConnection object's name for debugging
			// purposes.
			//
			hr = pHNetConnection->GetName(&pwszName);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get HNetConnection 0x%p name (err = 0x%lx)!",
					pHNetConnection, hr);
				goto Failure;
			}
#endif // DBG


			//
			// See if we found the object we need.
			//
			if (_tcsicmp(tszGuidHNetConnection, tszGuidDevice) == 0)
			{
				DPFX(DPFPREP, 7, "Matched IHNetConnection object 0x%p \"%ls\" to device 0x%p (LAN GUID %s).",
					pHNetConnection, pwszName, pDevice, tszGuidHNetConnection);

				//
				// Transfer reference to caller.
				//
				(*ppHNetConnection) = pHNetConnection;
				pHNetConnection = NULL;

#ifdef DBG
				CoTaskMemFree(pwszName);
				pwszName = NULL;
#endif // DBG

				//
				// We're done here.
				//
				hr = DPNH_OK;
				goto Exit;
			}

			
			DPFX(DPFPREP, 7, "Non-matching IHNetConnection 0x%p \"%ls\"",
				pHNetConnection, pwszName);
			DPFX(DPFPREP, 7, "\t(LAN GUID %s <> %s).",
				tszGuidHNetConnection, tszGuidDevice);

#ifdef DBG
			CoTaskMemFree(pwszName);
			pwszName = NULL;
#endif // DBG
		}
		else
		{
			//
			// RAS case.
			//
			DNASSERT(this->m_hRasApi32DLL != NULL);

			
			//
			// Get the HNetConnection object's phonebook path.
			//
			hr = pHNetConnection->GetRasPhonebookPath(&pwszPhonebookPath);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get HNetConnection's RAS phonebook path (err = 0x%lx)!",
					hr);
				goto Failure;
			}


			//
			// Get the HNetConnection object's name.
			//
			hr = pHNetConnection->GetName(&pwszName);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get HNetConnection's name (err = 0x%lx)!",
					hr);
				goto Failure;
			}


			//
			// Look for an active RAS connection from that phonebook with that
			// name.
			//
			dwError = this->m_pfnRasGetEntryHrasconnW(pwszPhonebookPath, pwszName, &hrasconn);
			if (dwError != 0)
			{
				//
				// It's probably ERROR_NO_CONNECTION (668).
				//
				DPFX(DPFPREP, 1, "Couldn't get entry's active RAS connection (err = %u), assuming not dialed",
					dwError);
				DPFX(DPFPREP, 1, "\tname \"%ls\", phonebook \"%ls\".",
					pwszName, pwszPhonebookPath);
			}
			else
			{
				//
				// Get the IP address.
				//

				ZeroMemory(&raspppip, sizeof(raspppip));
				raspppip.dwSize = sizeof(raspppip);
				dwSize = sizeof(raspppip);

				dwError = this->m_pfnRasGetProjectionInfo(hrasconn, RASP_PppIp, &raspppip, &dwSize);
				if (dwError != 0)
				{
					DPFX(DPFPREP, 0, "Couldn't get RAS connection's IP information (err = %u)!",
						dwError);
					hr = DPNHERR_GENERIC;
					goto Failure;
				}


				//
				// See if we found the object we need.
				//
				if (_tcsicmp(raspppip.szIpAddress, tszDeviceIPAddress) == 0)
				{
					DPFX(DPFPREP, 7, "Matched IHNetConnection object 0x%p to device 0x%p (RAS IP %s)",
						pHNetConnection, pDevice, raspppip.szIpAddress);
					DPFX(DPFPREP, 7, "\tname \"%ls\", phonebook \"%ls\".",
						pwszName, pwszPhonebookPath);

					//
					// Transfer reference to caller.
					//
					(*ppHNetConnection) = pHNetConnection;
					pHNetConnection = NULL;

					//
					// We're done here.
					//
					hr = DPNH_OK;
					goto Exit;
				}

				
				DPFX(DPFPREP, 7, "Non-matching IHNetConnection 0x%p (RAS IP %s != %s)",
					pHNetConnection, raspppip.szIpAddress, tszDeviceIPAddress);
				DPFX(DPFPREP, 7, "\tname \"%ls\", phonebook \"%ls\").",
					pwszName, pwszPhonebookPath);
			}


			CoTaskMemFree(pwszPhonebookPath);
			pwszPhonebookPath = NULL;

			CoTaskMemFree(pwszName);
			pwszName = NULL;
		}


		//
		// If we're here, we pHNetConnection is not the one we're looking for.
		//
		pHNetConnection->Release();
		pHNetConnection = NULL;
	}
	while (TRUE);


	//
	// If we're here, then we didn't find a matching firewall connection.
	//
	DPFX(DPFPREP, 3, "Didn't find device 0x%p in list of firewalled connections.",
		pDevice);
	hr = DPNHERR_GENERIC;


Exit:

	if (pEnumHNetFirewalledConnections != NULL)
	{
		pEnumHNetFirewalledConnections->Release();
		pEnumHNetFirewalledConnections = NULL;
	}

	DPFX(DPFPREP, 6, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pwszName != NULL)
	{
		CoTaskMemFree(pwszName);
		pwszName = NULL;
	}
	
	if (pwszPhonebookPath == NULL)
	{
		CoTaskMemFree(pwszPhonebookPath);
		pwszPhonebookPath = NULL;
	}

	if (pHNetConnection != NULL)
	{
		pHNetConnection->Release();
		pHNetConnection = NULL;
	}

	if (pHNetFirewalledConnection != NULL)
	{
		pHNetFirewalledConnection->Release();
		pHNetFirewalledConnection = NULL;
	}

	if (pHNetFirewallSettings != NULL)
	{
		pHNetFirewallSettings->Release();
		pHNetFirewallSettings = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::GetIHNetConnectionForDeviceIfFirewalled





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetIPAddressGuidString"
//=============================================================================
// CNATHelpUPnP::GetIPAddressGuidString
//-----------------------------------------------------------------------------
//
// Description:    Retrieves the IPHLPAPI assigned GUID (in string format) for
//				the given IP address string.  ptszGuidString must be able to
//				hold GUID_STRING_LENGTH + 1 characters.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	TCHAR * tszDeviceIPAddress	- IP address string to lookup.
//	TCHAR * ptszGuidString		- Place to store device's GUID string.
//
// Returns: HRESULT
//	DPNH_OK				- Interface retrieved successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::GetIPAddressGuidString(const TCHAR * const tszDeviceIPAddress,
											TCHAR * const ptszGuidString)
{
	HRESULT				hr = DPNH_OK;
	DWORD				dwError;
	PIP_ADAPTER_INFO	pAdaptersBuffer = NULL;
	ULONG				ulSize;
	PIP_ADAPTER_INFO	pAdapterInfo;
	PIP_ADDR_STRING		pIPAddrString;
	char *				pszAdapterGuid = NULL;
#ifdef UNICODE
	char				szDeviceIPAddress[16];	// "nnn.nnn.nnn.nnn" + NULL termination
#endif // UNICODE
#ifdef DBG
	char				szIPList[256];
	char *				pszCurrentIP;
#endif // DBG


	DPFX(DPFPREP, 6, "(0x%p) Parameters: (\"%s\", 0x%p)",
		this, tszDeviceIPAddress, ptszGuidString);


	DNASSERT(this->m_hIpHlpApiDLL != NULL);


	//
	// Keep trying to get the list of adapters until we get ERROR_SUCCESS or a
	// legitimate error (other than ERROR_BUFFER_OVERFLOW or
	// ERROR_INSUFFICIENT_BUFFER).
	//
	ulSize = 0;
	do
	{
		dwError = this->m_pfnGetAdaptersInfo(pAdaptersBuffer, &ulSize);
		if (dwError == ERROR_SUCCESS)
		{
			//
			// We succeeded, we should be set.  But make sure there are
			// adapters for us to use.
			//
			if (ulSize < sizeof(IP_ADAPTER_INFO))
			{
				DPFX(DPFPREP, 0, "Getting adapters info succeeded but didn't return any valid adapters (%u < %u)!",
					ulSize, sizeof(IP_ADAPTER_INFO));
				hr = DPNHERR_GENERIC;
				goto Failure;
			}

			break;
		}

		if ((dwError != ERROR_BUFFER_OVERFLOW) &&
			(dwError != ERROR_INSUFFICIENT_BUFFER))
		{
			DPFX(DPFPREP, 0, "Unable to get adapters info (error = 0x%lx)!",
				dwError);
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		//
		// We need more adapter space.  Make sure there are adapters for us to
		// use.
		//
		if (ulSize < sizeof(IP_ADAPTER_INFO))
		{
			DPFX(DPFPREP, 0, "Getting adapters info didn't return any valid adapters (%u < %u)!",
				ulSize, sizeof(IP_ADAPTER_INFO));
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		//
		// If we previously had a buffer, free it.
		//
		if (pAdaptersBuffer != NULL)
		{
			DNFree(pAdaptersBuffer);
		}

		//
		// Allocate the buffer.
		//
		pAdaptersBuffer = (PIP_ADAPTER_INFO) DNMalloc(ulSize);
		if (pAdaptersBuffer == NULL)
		{
			DPFX(DPFPREP, 0, "Unable to allocate memory for adapters info!");
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}
	}
	while (TRUE);


#ifdef UNICODE
	STR_jkWideToAnsi(szDeviceIPAddress,
					tszDeviceIPAddress,
					16);
	szDeviceIPAddress[15] = 0; // ensure it's NULL terminated
#endif // UNICODE


	//
	// Now find the device in the adapter list returned.  Loop through all
	// adapters.
	//
	pAdapterInfo = pAdaptersBuffer;
	while (pAdapterInfo != NULL)
	{
#ifdef DBG
		//
		// Initialize IP address list string.
		//
		szIPList[0] = '\0';
		pszCurrentIP = szIPList;
#endif // DBG

		//
		// Loop through all addresses for this adapter looking for the one for
		// the device we have bound.
		//
		pIPAddrString = &pAdapterInfo->IpAddressList;
		while (pIPAddrString != NULL)
		{
#ifdef DBG
			int		iStrLen;


			//
			// Copy the IP address string (if there's enough room), then tack
			// on a space and NULL terminator.
			//
			iStrLen = strlen(pIPAddrString->IpAddress.String);
			if ((pszCurrentIP + iStrLen + 2) < (szIPList + sizeof(szIPList)))
			{
				memcpy(pszCurrentIP, pIPAddrString->IpAddress.String, iStrLen);
				pszCurrentIP += iStrLen;
				(*pszCurrentIP) = ' ';
				pszCurrentIP++;
				(*pszCurrentIP) = '\0';
				pszCurrentIP++;
			}
#endif // DBG

#ifdef UNICODE
			if (strcmp(pIPAddrString->IpAddress.String, szDeviceIPAddress) == 0)
#else // ! UNICODE
			if (strcmp(pIPAddrString->IpAddress.String, tszDeviceIPAddress) == 0)
#endif // ! UNICODE
			{
				DPFX(DPFPREP, 8, "Found %s under adapter index %u (\"%hs\").",
					tszDeviceIPAddress, pAdapterInfo->Index, pAdapterInfo->Description);

				DNASSERT(pszAdapterGuid == NULL);
				pszAdapterGuid = pAdapterInfo->AdapterName;


				//
				// Drop out of the loop in retail, keep going in debug.
				//
#ifndef DBG
				break;
#endif // ! DBG
			}

			pIPAddrString = pIPAddrString->Next;
		}


		//
		// Drop out of the loop in retail, print this entry and keep going in
		// debug.
		//
#ifdef DBG
		DPFX(DPFPREP, 7, "Adapter index %u IPs = %hs, %hs, \"%hs\".",
			pAdapterInfo->Index,
			szIPList,
			pAdapterInfo->AdapterName,
			pAdapterInfo->Description);
#else // ! DBG
		if (pszAdapterGuid != NULL)
		{
			break;
		}
#endif // ! DBG

		pAdapterInfo = pAdapterInfo->Next;
	}


	//
	// pszAdapterGuid will be NULL if we never found the device.
	//
	if (pszAdapterGuid == NULL)
	{
		DPFX(DPFPREP, 0, "Did not find adapter with matching address for address %s!",
			tszDeviceIPAddress);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Copy the adapter GUID string to the buffer supplied.
	//
#ifdef UNICODE
	STR_jkAnsiToWide(ptszGuidString,
					pszAdapterGuid,
					(GUID_STRING_LENGTH + 1));
#else // ! UNICODE
	strncpy(ptszGuidString, pszAdapterGuid, (GUID_STRING_LENGTH + 1));
#endif // ! UNICODE
	ptszGuidString[GUID_STRING_LENGTH] = 0;	// ensure it's NULL terminated


Exit:

	if (pAdaptersBuffer != NULL)
	{
		DNFree(pAdaptersBuffer);
		pAdaptersBuffer = NULL;
	}

	DPFX(DPFPREP, 6, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::GetIPAddressGuidString





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::OpenDevicesUPnPDiscoveryPort"
//=============================================================================
// CNATHelpUPnP::OpenDevicesUPnPDiscoveryPort
//-----------------------------------------------------------------------------
//
// Description:    Maps the UPnP discovery socket's port if a firewall is
//				found.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice					- Pointer to device whose port should
//											be opened.
//	IHNetCfgMgr * pHNetCfgMgr			- Pointer to IHNetCfgMgr interface to
//											use.
//	IHNetConnection * pHNetConnection	- Pointer to IHNetConnection interface
//											for the given device.
//
// Returns: HRESULT
//	DPNH_OK				- Mapping completed successfully.  There may or may not
//							be a firewall.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::OpenDevicesUPnPDiscoveryPort(CDevice * const pDevice,
													IHNetCfgMgr * const pHNetCfgMgr,
													IHNetConnection * const pHNetConnection)
{
	HRESULT				hr = DPNH_OK;
	CRegisteredPort *	pRegisteredPort = NULL;
	SOCKADDR_IN			saddrinTemp;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p)",
		this, pDevice, pHNetCfgMgr, pHNetConnection);


	DNASSERT(pDevice->IsHNetFirewalled());



	//
	// Create a fake UDP registered port to map.
	//
	pRegisteredPort = new CRegisteredPort(0, 0);
	if (pRegisteredPort == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	pRegisteredPort->MakeDeviceOwner(pDevice);


	ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
	saddrinTemp.sin_family				= AF_INET;
	saddrinTemp.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();
	saddrinTemp.sin_port				= pDevice->GetUPnPDiscoverySocketPort();
	DNASSERT(saddrinTemp.sin_port != 0);

	hr = pRegisteredPort->SetPrivateAddresses(&saddrinTemp, 1);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't set registered port 0x%p's private addresses (err = 0x%lx)!",
			pRegisteredPort, hr);
		goto Failure;
	}


	//
	// Map the port.
	//
	hr = this->MapPortOnLocalHNetFirewall(pRegisteredPort,
										pHNetCfgMgr,
										pHNetConnection,
										FALSE);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't map UPnP discovery socket port (temp regport = 0x%p) on device 0x%p's initial firewall (err = 0x%lx)!",
			pRegisteredPort, pDevice, hr);
		goto Failure;
	}


	//
	// If the port was unavailable, we have to give up on supporting the
	// scenario (firewall enabled behind a NAT).  Otherwise, remember the fact
	// that we mapped the port, and then delete the registered port object.  We
	// will unmap it when we shut down the device.
	//
	if (! pRegisteredPort->IsHNetFirewallPortUnavailable())
	{
		DPFX(DPFPREP, 3, "Mapped UPnP discovery socket for device 0x%p on firewall (removing temp regport 0x%p).",
			pDevice, pRegisteredPort);


		pDevice->NoteUPnPDiscoverySocketMappedOnHNetFirewall();

		//
		// Clear this to prevent an assert.
		//
		pRegisteredPort->NoteNotMappedOnHNetFirewall();
		pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
	}
	else
	{
		DPFX(DPFPREP, 1, "Could not map UPnP discovery socket on firewall for device 0x%p, unable to support an upstream NAT.",
			pDevice);
	}

	pRegisteredPort->ClearPrivateAddresses();
	pRegisteredPort->ClearDeviceOwner();


	//
	// Delete the item.
	//
	delete pRegisteredPort;
	pRegisteredPort = NULL;


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pRegisteredPort != NULL)
	{
		//
		// Clear any settings that might cause an assert.
		//
		pRegisteredPort->NoteNotMappedOnHNetFirewall();
		pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
		pRegisteredPort->ClearPrivateAddresses();
		pRegisteredPort->ClearDeviceOwner();


		//
		// Delete the item.
		//
		delete pRegisteredPort;
		pRegisteredPort = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::OpenDevicesUPnPDiscoveryPort





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CloseDevicesUPnPDiscoveryPort"
//=============================================================================
// CNATHelpUPnP::CloseDevicesUPnPDiscoveryPort
//-----------------------------------------------------------------------------
//
// Description:    Unmaps the UPnP discovery socket's port from the firewall.
//				pHNetCfgMgr can be NULL if it has not previously been obtained.
//
//				   COM is assumed to have been initialized if pHNetCfgMgr is
//				not NULL.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice			- Pointer to device whose port should be
//									close.
//	IHNetCfgMgr * pHNetCfgMgr	- Pointer to IHNetCfgMgr interface to use, or
//									NULL if not previously obtained.
//
// Returns: HRESULT
//	DPNH_OK				- Unmapping completed successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CloseDevicesUPnPDiscoveryPort(CDevice * const pDevice,
													IHNetCfgMgr * const pHNetCfgMgr)
{
	HRESULT				hr = DPNH_OK;
	CRegisteredPort *	pRegisteredPort = NULL;
	SOCKADDR_IN			saddrinTemp;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pDevice, pHNetCfgMgr);


	//
	// Create a fake UDP registered port to unmap.
	//
	pRegisteredPort = new CRegisteredPort(0, 0);
	if (pRegisteredPort == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	pRegisteredPort->MakeDeviceOwner(pDevice);
	pRegisteredPort->NoteMappedOnHNetFirewall();


	ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
	saddrinTemp.sin_family				= AF_INET;
	saddrinTemp.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();
	saddrinTemp.sin_port				= pDevice->GetUPnPDiscoverySocketPort();
	DNASSERT(saddrinTemp.sin_port != 0);

	hr = pRegisteredPort->SetPrivateAddresses(&saddrinTemp, 1);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't set registered port 0x%p's private addresses (err = 0x%lx)!",
			pRegisteredPort, hr);
		goto Failure;
	}


	//
	// Unmap the port using the internal method if possible.
	//
	if (pHNetCfgMgr != NULL)
	{
		hr = this->UnmapPortOnLocalHNetFirewallInternal(pRegisteredPort, TRUE, pHNetCfgMgr);
	}
	else
	{
		//
		// Don't alert the user since he/she doesn't know about this port.
		//
		hr = this->UnmapPortOnLocalHNetFirewall(pRegisteredPort, TRUE, FALSE);
	}
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't unmap UPnP discovery socket port (temp regport = 0x%p) on device 0x%p's firewall (err = 0x%lx)!",
			pRegisteredPort, pDevice, hr);
		goto Failure;
	}


	//
	// Destroy the registered port object (note that the port mapping still
	// exists).  We will unmap when we shut down the device.
	//
	pRegisteredPort->ClearPrivateAddresses();
	pRegisteredPort->ClearDeviceOwner();


	//
	// Delete the item.
	//
	delete pRegisteredPort;
	pRegisteredPort = NULL;


	pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pRegisteredPort != NULL)
	{
		//
		// Clear any settings that might cause an assert.
		//
		pRegisteredPort->NoteNotMappedOnHNetFirewall();
		pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
		pRegisteredPort->ClearPrivateAddresses();
		pRegisteredPort->ClearDeviceOwner();


		//
		// Delete the item.
		//
		delete pRegisteredPort;
		pRegisteredPort = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::CloseDevicesUPnPDiscoveryPort





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::MapUnmappedPortsOnLocalHNetFirewall"
//=============================================================================
// CNATHelpUPnP::MapUnmappedPortsOnLocalHNetFirewall
//-----------------------------------------------------------------------------
//
// Description:    Maps any ports associated with the given device that have
//				not been mapped with the local firewall yet.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice							- Device with (new) firewall.
//	IHNetCfgMgr * pHNetCfgMgr					- Pointer to IHNetCfgMgr
//													interface to use.
//	IHNetConnection * pHNetConnection			- Pointer to IHNetConnection
//													interface for the given
//													device.
//	CRegisteredPort * pDontAlertRegisteredPort	- Pointer to registered port
//													that should not trigger an
//													address update alert, or
//													NULL.
//
// Returns: HRESULT
//	DPNH_OK				- Mapping completed successfully.  Note that the ports
//							may be marked as unavailable.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::MapUnmappedPortsOnLocalHNetFirewall(CDevice * const pDevice,
														IHNetCfgMgr * const pHNetCfgMgr,
														IHNetConnection * const pHNetConnection,
														CRegisteredPort * const pDontAlertRegisteredPort)
{
	HRESULT				hr = DPNH_OK;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, 0x%p)",
		this, pDevice, pHNetCfgMgr, pHNetConnection, pDontAlertRegisteredPort);


	DNASSERT(pDevice->IsHNetFirewalled());



	//
	// Loop through all the registered ports associated with the device.
	//
	pBilink = pDevice->m_blOwnedRegPorts.GetNext();
	while (pBilink != &pDevice->m_blOwnedRegPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
		pBilink = pBilink->GetNext();


		//
		// If this port has already been mapped, we can skip it.
		//
		if (pRegisteredPort->IsMappedOnHNetFirewall())
		{
			DPFX(DPFPREP, 7, "Registered port 0x%p has already been mapped on the firewall for device 0x%p.",
				pRegisteredPort, pDevice);
			continue;
		}


		//
		// If this port has already been determined to be unavailable, we can
		// skip it.
		//
		if (pRegisteredPort->IsHNetFirewallPortUnavailable())
		{
			DPFX(DPFPREP, 7, "Registered port 0x%p has already been determined to be unavailable on the firewall for device 0x%p.",
				pRegisteredPort, pDevice);
			continue;
		}


		DPFX(DPFPREP, 3, "Mapping registered port 0x%p on firewall for device 0x%p.",
			pRegisteredPort, pDevice);
		

		hr = this->MapPortOnLocalHNetFirewall(pRegisteredPort,
											pHNetCfgMgr,
											pHNetConnection,
											((pRegisteredPort == pDontAlertRegisteredPort) ? FALSE : TRUE));
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 7, "Failed mapping registered port 0x%p on firewall for device 0x%p.",
				pRegisteredPort, pDevice);
			goto Failure;
		}


		//
		// Go to next registered port.
		//
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::MapUnmappedPortsOnLocalHNetFirewall





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::MapPortOnLocalHNetFirewall"
//=============================================================================
// CNATHelpUPnP::MapPortOnLocalHNetFirewall
//-----------------------------------------------------------------------------
//
// Description:    Maps the given port with the corresponding firewall.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CRegisteredPort * pRegisteredPort	- Port to map.
//	IHNetCfgMgr * pHNetCfgMgr			- Pointer to IHNetCfgMgr interface to
//											use.
//	IHNetConnection * pHNetConnection	- Pointer to IHNetConnection interface
//											for the given device.
//	BOOL fNoteAddressChange				- Whether to alert the user of the
//											address change or not.
//
// Returns: HRESULT
//	DPNH_OK				- Mapping completed successfully.  Note that the ports
//							may be marked as unavailable.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::MapPortOnLocalHNetFirewall(CRegisteredPort * const pRegisteredPort,
												IHNetCfgMgr * const pHNetCfgMgr,
												IHNetConnection * const pHNetConnection,
												const BOOL fNoteAddressChange)
{
	HRESULT								hr = DPNH_OK;
	CDevice *							pDevice;
	SOCKADDR_IN *						pasaddrinPrivate;
	UCHAR								ucProtocolToMatch;
	ULONG								ulNumFound;
	BOOLEAN								fTemp;
	IHNetProtocolSettings *				pHNetProtocolSettings = NULL;
	IEnumHNetPortMappingProtocols *		pEnumHNetPortMappingProtocols = NULL;
	IHNetPortMappingProtocol **			papHNetPortMappingProtocol = NULL;
	DWORD								dwTemp;
	BOOL								fCreatedCurrentPortMappingProtocol = FALSE;
	IHNetPortMappingBinding *			pHNetPortMappingBinding = NULL;
	DWORD								dwTargetAddressV4;
	WORD								wPort;
	UCHAR								ucProtocol;
	DWORD								dwDescriptionLength;
	TCHAR								tszPort[32];
	CRegistry							RegObject;
	WCHAR								wszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DPNHACTIVEFIREWALLMAPPING			dpnhafm;
	BOOLEAN								fBuiltIn = FALSE;
	WCHAR *								pwszPortMappingProtocolName = NULL;
#ifdef UNICODE
	TCHAR *								ptszDescription = wszDescription;
#else // ! UNICODE
	char								szDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	TCHAR *								ptszDescription = szDescription;
#endif // ! UNICODE


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, %i)",
		this, pRegisteredPort, pHNetCfgMgr, pHNetConnection, fNoteAddressChange);


	DNASSERT(! pRegisteredPort->IsMappedOnHNetFirewall());
	DNASSERT(! pRegisteredPort->IsHNetFirewallPortUnavailable());


	pDevice = pRegisteredPort->GetOwningDevice();
	DNASSERT(pDevice != NULL);
	DNASSERT(pDevice->IsHNetFirewalled());


	//
	// Get a protocol settings interface.
	//
	hr = pHNetCfgMgr->QueryInterface(IID_IHNetProtocolSettings,
									(PVOID*) (&pHNetProtocolSettings));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't get IHNetProtocolSettings interface from IHNetCfgMgr 0x%p (err = 0x%lx)!",
			pHNetCfgMgr, hr);
		goto Failure;
	}

	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pHNetProtocolSettings);


	//
	// Get ready to enumerate the existing mappings.
	//

	hr = pHNetProtocolSettings->EnumPortMappingProtocols(&pEnumHNetPortMappingProtocols);
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't enumerate port mapping protocols (err = 0x%lx)!",
			hr);
		goto Failure;
	}

	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pEnumHNetPortMappingProtocols);


	//
	// Allocate an array to keep track of previous ports in case of failure.
	//
	papHNetPortMappingProtocol = (IHNetPortMappingProtocol**) DNMalloc(DPNH_MAX_SIMULTANEOUS_PORTS * sizeof(IHNetPortMappingProtocol*));
	if (papHNetPortMappingProtocol == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}



	pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

	if (pRegisteredPort->IsTCP())
	{
		ucProtocolToMatch = PORTMAPPINGPROTOCOL_TCP;
	}
	else
	{
		ucProtocolToMatch = PORTMAPPINGPROTOCOL_UDP;
	}


	//
	// Map each individual address associated with the port.
	//
	for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
	{
		DNASSERT(pasaddrinPrivate[dwTemp].sin_port != 0);


		//
		// Loop until we find a duplicate item or run out of items.
		//
		do
		{
			hr = pEnumHNetPortMappingProtocols->Next(1,
													&papHNetPortMappingProtocol[dwTemp],
													&ulNumFound);
			if (FAILED(hr))
			{
				DPFX(DPFPREP, 0, "Couldn't get next port mapping protocol (err = 0x%lx)!",
					hr);
				goto Failure;
			}


			//
			// If there aren't any more items, bail.
			//
			if (ulNumFound == 0)
			{
				//
				// pEnumHNetPortMappingProtocols->Next might have returned
				// S_FALSE.
				//
				hr = DPNH_OK;
				break;
			}


			//
			// The HNetxxx objects appear to not be proxied...
			//
			//SETDEFAULTPROXYBLANKET(papHNetPortMappingProtocol[dwTemp]);


			//
			// Get the port.
			//
			hr = papHNetPortMappingProtocol[dwTemp]->GetPort(&wPort);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get port mapping protocol 0x%p's port (err = 0x%lx)!",
					papHNetPortMappingProtocol[dwTemp], hr);

				DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetPort!"), 2);

				goto Failure;
			}


			//
			// Get the protocol.
			//
			hr = papHNetPortMappingProtocol[dwTemp]->GetIPProtocol(&ucProtocol);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get port mapping protocol 0x%p's IP protocol (err = 0x%lx)!",
					papHNetPortMappingProtocol[dwTemp], hr);

				DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetIPProtocol!"), 2);

				goto Failure;
			}


#ifdef DBG
			hr = papHNetPortMappingProtocol[dwTemp]->GetName(&pwszPortMappingProtocolName);
			if (hr == S_OK)
			{
				DPFX(DPFPREP, 7, "Found %s port mapping protocol 0x%p (\"%ls\") for port %u.",
					(((wPort == pasaddrinPrivate[dwTemp].sin_port) && (ucProtocol == ucProtocolToMatch)) ? _T("matching") : _T("non-matching")),
					papHNetPortMappingProtocol[dwTemp],
					pwszPortMappingProtocolName,
					NTOHS(wPort));

				CoTaskMemFree(pwszPortMappingProtocolName);
				pwszPortMappingProtocolName = NULL;
			}
			else
			{
				DPFX(DPFPREP, 7, "Found %s port mapping protocol 0x%p for port %u, (unable to retrieve name, err = %0lx).",
					(((wPort == pasaddrinPrivate[dwTemp].sin_port) && (ucProtocol == ucProtocolToMatch)) ? _T("matching") : _T("non-matching")),
					NTOHS(wPort),
					papHNetPortMappingProtocol[dwTemp],
					hr);
			}
#endif // DBG

			//
			// See if we found the object we need.
			//
			if ((wPort == pasaddrinPrivate[dwTemp].sin_port) &&
				(ucProtocol == ucProtocolToMatch))
			{
				break;
			}


			//
			// Get ready for the next object.
			//
			papHNetPortMappingProtocol[dwTemp]->Release();
			papHNetPortMappingProtocol[dwTemp] = NULL;
		}
		while (TRUE);


		//
		// Generate a description for this mapping.  The format is:
		//
		//     [executable_name] nnnnn {"TCP" | "UDP"}
		//
		// unless it's shared, in which case it's
		//
		//     [executable_name] (255.255.255.255:nnnnn) nnnnn {"TCP" | "UDP"}
		//
		// That way nothing needs to be localized.
		//

		wsprintf(tszPort, _T("%u"),
				NTOHS(pasaddrinPrivate[dwTemp].sin_port));

		dwDescriptionLength = GetModuleFileName(NULL,
												ptszDescription,
												(MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1));
		if (dwDescriptionLength != 0)
		{
			//
			// Be paranoid and make sure the description string is valid.
			//
			ptszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1] = 0;

			//
			// Get just the executable name from the path.
			//
#ifdef WINCE
			GetExeName(ptszDescription);
#else // ! WINCE
#ifdef UNICODE
			_wsplitpath(ptszDescription, NULL, NULL, ptszDescription, NULL);
#else // ! UNICODE
			_splitpath(ptszDescription, NULL, NULL, ptszDescription, NULL);
#endif // ! UNICODE
#endif // ! WINCE


			if (pRegisteredPort->IsSharedPort())
			{
				dwDescriptionLength = _tcslen(ptszDescription)		// executable name
									+ strlen(" (255.255.255.255:")	// " (255.255.255.255:"
									+ _tcslen(tszPort)				// port
									+ strlen(") ")					// ") "
									+ _tcslen(tszPort)				// port
									+ 4;							// " TCP" | " UDP"
			}
			else
			{
				dwDescriptionLength = _tcslen(ptszDescription)	// executable name
									+ 1							// " "
									+_tcslen(tszPort)			// port
									+ 4;						// " TCP" | " UDP"
			}

			//
			// Make sure the long string will fit.  If not, use the
			// abbreviated version.
			//
			if (dwDescriptionLength > MAX_UPNP_MAPPING_DESCRIPTION_SIZE)
			{
				dwDescriptionLength = 0;
			}
		}

		if (dwDescriptionLength == 0)
		{
			//
			// Use the abbreviated version we know will fit.
			//
			if (pRegisteredPort->IsSharedPort())
			{
				wsprintf(ptszDescription,
						_T("(255.255.255.255:%s) %s %s"),
						tszPort,
						tszPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}
			else
			{
				wsprintf(ptszDescription,
						_T("%s %s"),
						tszPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}
		}
		else
		{
			//
			// There's enough room, tack on the rest of the description.
			//
			if (pRegisteredPort->IsSharedPort())
			{
				wsprintf((ptszDescription + _tcslen(ptszDescription)),
						_T(" (255.255.255.255:%s) %s %s"),
						tszPort,
						tszPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}
			else
			{
				wsprintf((ptszDescription + _tcslen(ptszDescription)),
						_T(" %s %s"),
						tszPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}
		}

#ifndef UNICODE
		dwDescriptionLength = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
		hr = STR_AnsiToWide(szDescription, -1, wszDescription, &dwDescriptionLength);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't convert NAT mapping description to Unicode (err = 0x%lx)!",
				hr);
			goto Failure;
		}
#endif // ! UNICODE



		//
		// If there wasn't a port mapping already, create it.  Otherwise make
		// sure it's not already in use by some other client.
		//
		if (papHNetPortMappingProtocol[dwTemp] == NULL)
		{
			DPFX(DPFPREP, 7, "Creating new port mapping protocol \"%ls\".",
				wszDescription);


			//
			// Create a new port mapping protocol.
			//
			DPFX(DPFPREP, 9, "++ pHNetProtocolSettings(0x%p)->CreatePortMappingProtocol(\"%ls\", %u, 0x%lx, 0x%p)", pHNetProtocolSettings, wszDescription, ucProtocolToMatch, pasaddrinPrivate[dwTemp].sin_port, &papHNetPortMappingProtocol[dwTemp]);
			hr = pHNetProtocolSettings->CreatePortMappingProtocol(wszDescription,
																ucProtocolToMatch,
																pasaddrinPrivate[dwTemp].sin_port,
																&papHNetPortMappingProtocol[dwTemp]);
			DPFX(DPFPREP, 9, "-- pHNetProtocolSettings(0x%p)->CreatePortMappingProtocol = 0x%lx", pHNetProtocolSettings, hr);
			if (hr != S_OK)
			{
				//
				// This might be WBEM_E_ACCESSDENIED (0x80041003), which means
				// the current user doesn't have permissions to open holes in
				// the firewall.
				//

				DPFX(DPFPREP, 0, "Couldn't create new port mapping protocol (err = 0x%lx)!",
					hr);

				goto Failure;
			}


			//
			// The HNetxxx objects appear to not be proxied...
			//
			//SETDEFAULTPROXYBLANKET(papHNetPortMappingProtocol[dwTemp]);


			fCreatedCurrentPortMappingProtocol = TRUE;



			//
			// Retrieve its binding.
			//
			DPFX(DPFPREP, 9, "++ pHNetConnection(0x%p)->GetBindingForPortMappingProtocol(0x%p, 0x%p)", pHNetConnection, papHNetPortMappingProtocol[dwTemp], &pHNetPortMappingBinding);
			hr = pHNetConnection->GetBindingForPortMappingProtocol(papHNetPortMappingProtocol[dwTemp],
																&pHNetPortMappingBinding);
			DPFX(DPFPREP, 9, "-- pHNetConnection(0x%p)->GetBindingForPortMappingProtocol = 0x%lx", pHNetConnection, hr);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get binding for port mapping protocol 0x%p (err = 0x%lx)!",
					papHNetPortMappingProtocol[dwTemp], hr);
				goto Failure;
			}


			//
			// The HNetxxx objects appear to not be proxied...
			//
			//SETDEFAULTPROXYBLANKET(pHNetPortMappingBinding);


			//
			// Make sure it refers to the local device (or the broadcast
			// address, if shared).  Although shared ports are a strange
			// concept on a firewall, Microsoft's firewall implementation
			// shares mappings with the NAT, so we'd rather be safe than sorry.
			// Mapping it to the broadcast address makes it behave the same if
			// the firewalled adapter also happens to be shared.
			//
			if (pRegisteredPort->IsSharedPort())
			{
				DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress((broadcast) 0x%lx)", pHNetPortMappingBinding, INADDR_BROADCAST);
				hr = pHNetPortMappingBinding->SetTargetComputerAddress(INADDR_BROADCAST);
				DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress = 0x%lx", pHNetPortMappingBinding, hr);
			}
			else
			{
				DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress(0x%lx)", pHNetPortMappingBinding, pDevice->GetLocalAddressV4());
				hr = pHNetPortMappingBinding->SetTargetComputerAddress(pDevice->GetLocalAddressV4());
				DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress = 0x%lx", pHNetPortMappingBinding, hr);
			}
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't set binding 0x%p's target computer address (err = 0x%lx)!",
					pHNetPortMappingBinding, hr);
				goto Failure;
			}
		}
		else
		{
			//
			// Retrieve the existing binding.
			//
			DPFX(DPFPREP, 9, "++ pHNetConnection(0x%p)->GetBindingForPortMappingProtocol(0x%p, 0x%p)", pHNetConnection, papHNetPortMappingProtocol[dwTemp], &pHNetPortMappingBinding);
			hr = pHNetConnection->GetBindingForPortMappingProtocol(papHNetPortMappingProtocol[dwTemp],
																&pHNetPortMappingBinding);
			DPFX(DPFPREP, 9, "-- pHNetConnection(0x%p)->GetBindingForPortMappingProtocol = 0x%lx", pHNetConnection, hr);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get binding for port mapping protocol 0x%p (err = 0x%lx)!",
					papHNetPortMappingProtocol[dwTemp], hr);
				goto Failure;
			}


			//
			// The HNetxxx objects appear to not be proxied...
			//
			//SETDEFAULTPROXYBLANKET(pHNetPortMappingBinding);


			//
			// Find out where this mapping goes.
			//
			DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->GetTargetComputerAddress(0x%p)", pHNetPortMappingBinding, &dwTargetAddressV4);
			hr = pHNetPortMappingBinding->GetTargetComputerAddress(&dwTargetAddressV4);
			DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->GetTargetComputerAddress = 0x%lx", pHNetPortMappingBinding, hr);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get binding 0x%p's target computer address (err = 0x%lx)!",
					pHNetPortMappingBinding, hr);
				goto Failure;
			}


			//
			// If it's not for the local device, we may have to leave it alone.
			//
			if ((dwTargetAddressV4 != pDevice->GetLocalAddressV4()) &&
				((! pRegisteredPort->IsSharedPort()) ||
				(dwTargetAddressV4 != INADDR_BROADCAST)))
			{
				//
				// Find out if it's turned on.
				//
				DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->GetEnabled(0x%p)", pHNetPortMappingBinding, &fTemp);
				hr = pHNetPortMappingBinding->GetEnabled(&fTemp);
				DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->GetEnabled = 0x%lx", pHNetPortMappingBinding, hr);
				if (hr != S_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't get binding 0x%p's target computer address (err = 0x%lx)!",
						pHNetPortMappingBinding, hr);
					goto Failure;
				}


				//
				// If it's currently active, it's better to be safe than sorry.
				// Don't attempt to replace it.
				//
				if (fTemp)
				{
					DPFX(DPFPREP, 1, "Existing active binding points to different target %u.%u.%u.%u, can't reuse for device 0x%p.",
						((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b1,
						((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b2,
						((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b3,
						((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b4,
						pDevice);
					
					//
					// Mark this port as unavailable.
					//
					pRegisteredPort->NoteHNetFirewallPortUnavailable();


					//
					// Cleanup this port mapping.
					//

					pHNetPortMappingBinding->Release();
					pHNetPortMappingBinding = NULL;

					papHNetPortMappingProtocol[dwTemp]->Release();
					papHNetPortMappingProtocol[dwTemp] = NULL;


					//
					// Reset for next port.
					//
					DPFX(DPFPREP, 9, "++ pEnumHNetPortMappingProtocols(0x%p)->Reset()", pEnumHNetPortMappingProtocols);
					hr = pEnumHNetPortMappingProtocols->Reset();
					DPFX(DPFPREP, 9, "-- pEnumHNetPortMappingProtocols(0x%p)->Reset = 0x%lx", pEnumHNetPortMappingProtocols, hr);
					if (hr != S_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't reset port mapping protocol enumeration 0x%p (err = 0x%lx)!",
							pEnumHNetPortMappingProtocols, hr);
						goto Failure;
					}


					//
					// Get out of the loop.
					//
					break;
				}


				//
				// It's inactive.
				//
				DPFX(DPFPREP, 7, "Modifying inactive port mapping protocol (target was %u.%u.%u.%u) for device 0x%p (new name = \"%ls\").",
					((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b1,
					((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b2,
					((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b3,
					((IN_ADDR*) (&dwTargetAddressV4))->S_un.S_un_b.s_b4,
					pDevice,
					wszDescription);
			}
			else
			{
				//
				// It matches the local device, or we're mapping a shared port
				// and the mapping pointed to the broadcast address.
				// Assume it's okay to replace.
				//
				DPFX(DPFPREP, 7, "Modifying existing port mapping protocol (device = 0x%p, new name = \"%ls\" unless built-in).",
					pDevice,
					wszDescription);
			}


			//
			// Otherwise, it's safe to change it.
			//


			//
			// Make sure it refers to the local device (or the broadcast
			// address, if shared).  Although shared ports are a strange
			// concept on a firewall, Microsoft's firewall implementation
			// shares mappings with the NAT, so we'd rather be safe than sorry.
			// Mapping it to the broadcast address makes it behave the same if
			// the firewalled adapter also happens to be shared.
			//
			if (pRegisteredPort->IsSharedPort())
			{
				DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress((broadcast) 0x%lx)", pHNetPortMappingBinding, INADDR_BROADCAST);
				hr = pHNetPortMappingBinding->SetTargetComputerAddress(INADDR_BROADCAST);
				DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress = 0x%lx", pHNetPortMappingBinding, hr);
			}
			else
			{
				DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress(0x%lx)", pHNetPortMappingBinding, pDevice->GetLocalAddressV4());
				hr = pHNetPortMappingBinding->SetTargetComputerAddress(pDevice->GetLocalAddressV4());
				DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->SetTargetComputerAddress = 0x%lx", pHNetPortMappingBinding, hr);
			}

			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't set binding 0x%p's target computer address (err = 0x%lx)!",
					pHNetPortMappingBinding, hr);
				goto Failure;
			}


			//
			// See if this protocol is built-in.
			//
			DPFX(DPFPREP, 9, "++ papHNetPortMappingProtocol[%u](0x%p)->GetBuiltIn(0x%p)", dwTemp, papHNetPortMappingProtocol[dwTemp], &fBuiltIn);
			hr = papHNetPortMappingProtocol[dwTemp]->GetBuiltIn(&fBuiltIn);
			DPFX(DPFPREP, 9, "-- papHNetPortMappingProtocol[%u](0x%p)->GetBuiltIn = 0x%lx", dwTemp, papHNetPortMappingProtocol[dwTemp], hr);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't get protocol 0x%p's built-in status (err = 0x%lx)!",
					papHNetPortMappingProtocol[dwTemp], hr);
				goto Failure;
			}


			//
			// If it's not built-in, we can change the name.
			//
			if (! fBuiltIn)
			{
				//
				// Update the description.
				//
				DPFX(DPFPREP, 9, "++ papHNetPortMappingProtocol[%u](0x%p)->SetName(\"%ls\")", dwTemp, papHNetPortMappingProtocol[dwTemp], wszDescription);
				hr = papHNetPortMappingProtocol[dwTemp]->SetName(wszDescription);
				DPFX(DPFPREP, 9, "-- papHNetPortMappingProtocol[%u](0x%p)->SetName = 0x%lx", dwTemp, papHNetPortMappingProtocol[dwTemp], hr);
				if (hr != S_OK)
				{
					//
					// This might be WBEM_E_ACCESSDENIED (0x80041003), which
					// means the current user doesn't truly have permissions to
					// open holes in the firewall (even though the
					// SetTargetComputerAddress call above succeeded).
					//

					DPFX(DPFPREP, 0, "Couldn't rename existing port mapping protocol 0x%p (err = 0x%lx)!",
						papHNetPortMappingProtocol[dwTemp], hr);
					goto Failure;
				}
			}
			else
			{
				pRegisteredPort->NoteHNetFirewallMappingBuiltIn();


				DPFX(DPFPREP, 9, "++ papHNetPortMappingProtocol[%u](0x%p)->GetName(0x%p)", dwTemp, papHNetPortMappingProtocol[dwTemp], &pwszPortMappingProtocolName);
				hr = papHNetPortMappingProtocol[dwTemp]->GetName(&pwszPortMappingProtocolName);
				DPFX(DPFPREP, 9, "-- papHNetPortMappingProtocol[%u](0x%p)->GetName = 0x%lx", dwTemp, papHNetPortMappingProtocol[dwTemp], hr);
				if (hr != S_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't get built-in port mapping protocol 0x%p's name (err = 0x%lx)!",
						papHNetPortMappingProtocol[dwTemp], hr);
					goto Failure;
				}


				DPFX(DPFPREP, 1, "Re-using built in port mapping protocol \"%ls\" (can't rename to \"%ls\").",
					pwszPortMappingProtocolName, wszDescription);
			}
		} // end else (found port mapping protocol)


		//
		// Enable the binding.
		//
		DPFX(DPFPREP, 9, "++ pHNetPortMappingBinding(0x%p)->SetEnabled(TRUE)", pHNetPortMappingBinding);
		hr = pHNetPortMappingBinding->SetEnabled(TRUE);
		DPFX(DPFPREP, 9, "-- pHNetPortMappingBinding(0x%p)->SetEnabled = 0x%lx", pHNetPortMappingBinding, hr);
		if (hr != S_OK)
		{
			//
			// This might be WBEM_E_ACCESSDENIED (0x80041003), which means the
			// current user doesn't truly have permissions to open holes in the
			// firewall (even though the SetTargetComputerAddress call above
			// succeeded).
			//

			DPFX(DPFPREP, 0, "Couldn't enable binding 0x%p (err = 0x%lx)!",
				pHNetPortMappingBinding, hr);
			goto Failure;
		}


		//
		// Remember this firewall mapping, in case we crash before cleaning it
		// up in this session.  That we can clean it up next time we launch.
		// Don't do this if the port is shared, since we can't tell when it's
		// no longer in use.
		//
		if (! pRegisteredPort->IsSharedPort())
		{
			if (fBuiltIn)
			{
				DPFX(DPFPREP, 7, "Remembering built-in firewall mapping \"%ls\" (a.k.a. \"%ls\") in case of crash.",
					pwszPortMappingProtocolName, wszDescription);
			}
			else
			{
				DPFX(DPFPREP, 7, "Remembering regular firewall mapping \"%ls\" in case of crash.",
					wszDescription);
			}

			if (! RegObject.Open(HKEY_LOCAL_MACHINE,
								DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVEFIREWALLMAPPINGS,
								FALSE,
								TRUE,
								TRUE,
								DPN_KEY_ALL_ACCESS))
			{
				DPFX(DPFPREP, 0, "Couldn't open active firewall mapping key, unable to save in case of crash!");
			}
			else
			{
				DNASSERT(this->m_dwInstanceKey != 0);


				ZeroMemory(&dpnhafm, sizeof(dpnhafm));
				dpnhafm.dwVersion		= ACTIVE_MAPPING_VERSION;
				dpnhafm.dwInstanceKey	= this->m_dwInstanceKey;
				dpnhafm.dwFlags			= pRegisteredPort->GetFlags();
				dpnhafm.dwAddressV4		= pDevice->GetLocalAddressV4();
				dpnhafm.wPort			= pasaddrinPrivate[dwTemp].sin_port;


				//
				// If it's built-in, use its existing name since it couldn't be
				// renamed.  This allows the unmapping code to find it in the
				// registry again.  See UnmapPortOnLocalHNetFirewallInternal.
				//
				RegObject.WriteBlob(((fBuiltIn) ? pwszPortMappingProtocolName : wszDescription),
									(LPBYTE) (&dpnhafm),
									sizeof(dpnhafm));

				RegObject.Close();
			}
		}
		else
		{
			DPFX(DPFPREP, 7, "Not remembering shared port firewall mapping \"%ls\".",
				wszDescription);
		}


		//
		// Cleanup from this port mapping, and get ready for the next one.
		//

		if (fBuiltIn)
		{
			CoTaskMemFree(pwszPortMappingProtocolName);
			pwszPortMappingProtocolName = NULL;
		}

		pHNetPortMappingBinding->Release();
		pHNetPortMappingBinding = NULL;


		fCreatedCurrentPortMappingProtocol = FALSE;


		hr = pEnumHNetPortMappingProtocols->Reset();
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't reset port mapping protocol enumeration 0x%p (err = 0x%lx)!",
				pEnumHNetPortMappingProtocols, hr);
			goto Failure;
		}


		//
		// Alert the user to the change the next time GetCaps is called, if
		// requested.
		//
		if (fNoteAddressChange)
		{
			DPFX(DPFPREP, 8, "Noting that addresses changed (for registered port 0x%p).",
				pRegisteredPort);
			this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;
		}


		//
		// Go on to the next port.
		//
	}


	//
	// dwTemp == pRegisteredPort->GetNumAddresses() if everything succeeded, or
	// or the index of the item that was unavailable if not.
	//

	//
	// Free all the port mapping protocol objects.  If we successfully bound
	// all of them, that's all we need to do.  If the port was unavailable, we
	// have to unmap any ports that were successful up to the one that failed.
	//
	while (dwTemp > 0)
	{
		dwTemp--;

		//
		// If we failed to map all ports, delete this previous mapping.
		//
		if (pRegisteredPort->IsHNetFirewallPortUnavailable())
		{
			papHNetPortMappingProtocol[dwTemp]->Delete();	// ignore error
		}

		//
		// Free the object.
		// 
		papHNetPortMappingProtocol[dwTemp]->Release();
		papHNetPortMappingProtocol[dwTemp] = NULL;
	}


	//
	// If we succeeded, mark the registered port as mapped.
	//
	if (! pRegisteredPort->IsHNetFirewallPortUnavailable())
	{
		pRegisteredPort->NoteMappedOnHNetFirewall();
	}



	DNFree(papHNetPortMappingProtocol);
	papHNetPortMappingProtocol = NULL;


	DNASSERT(hr == DPNH_OK);


Exit:

	if (pEnumHNetPortMappingProtocols != NULL)
	{
		pEnumHNetPortMappingProtocols->Release();
		pEnumHNetPortMappingProtocols = NULL;
	}

	if (pHNetProtocolSettings != NULL)
	{
		pHNetProtocolSettings->Release();
		pHNetProtocolSettings = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pwszPortMappingProtocolName != NULL)
	{
		CoTaskMemFree(pwszPortMappingProtocolName);
		pwszPortMappingProtocolName = NULL;
	}

	//
	// If we have an array, then we need to clean it up.  dwTemp will still
	// hold the index of the item we were working on.
	//
	if (papHNetPortMappingProtocol != NULL)
	{
		//
		// Delete the one we were working on, if we created it.
		//
		if (papHNetPortMappingProtocol[dwTemp] != NULL)
		{
			if (fCreatedCurrentPortMappingProtocol)
			{
				papHNetPortMappingProtocol[dwTemp]->Delete();	// ignore error
			}

			papHNetPortMappingProtocol[dwTemp]->Release();
			papHNetPortMappingProtocol[dwTemp] = NULL;
		}


		//
		// Delete all the mappings we successfully made up to the last one.
		//
		while (dwTemp > 0)
		{
			dwTemp--;


			DNASSERT(papHNetPortMappingProtocol[dwTemp] != NULL);

			papHNetPortMappingProtocol[dwTemp]->Delete();	// ignore error

			papHNetPortMappingProtocol[dwTemp]->Release();
			papHNetPortMappingProtocol[dwTemp] = NULL;
		}

		DNFree(papHNetPortMappingProtocol);
		papHNetPortMappingProtocol = NULL;
	}

	if (pHNetPortMappingBinding != NULL)
	{
		pHNetPortMappingBinding->Release();
		pHNetPortMappingBinding = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::MapPortOnLocalHNetFirewall





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UnmapPortOnLocalHNetFirewall"
//=============================================================================
// CNATHelpUPnP::UnmapPortOnLocalHNetFirewall
//-----------------------------------------------------------------------------
//
// Description:    Removes the mappings for the given ports from the local
//				firewall.
//
//				   The main object lock is assumed to be held.  It will be
//				converted into the long lock for the duration of this function.
//
// Arguments:
//	CRegisteredPort * pRegisteredPort	- Pointer to port to be opened on the
//											firewall.
//	BOOL fNeedToDeleteRegValue			- Whether the corresponding crash
//											recovery registry value needs to
//											be deleted as well.
//	BOOL fNoteAddressChange				- Whether to alert the user of the
//											address change or not.
//
// Returns: HRESULT
//	DPNH_OK				- Unmapping completed successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::UnmapPortOnLocalHNetFirewall(CRegisteredPort * const pRegisteredPort,
												const BOOL fNeedToDeleteRegValue,
												const BOOL fNoteAddressChange)
{
	HRESULT			hr = DPNH_OK;
	BOOL			fSwitchedToLongLock = FALSE;
	BOOL			fUninitializeCOM = FALSE;
	IHNetCfgMgr *	pHNetCfgMgr = NULL;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i, %i)",
		this, pRegisteredPort, fNeedToDeleteRegValue, fNoteAddressChange);


	DNASSERT(pRegisteredPort->IsMappedOnHNetFirewall());



	//
	// If the port is shared, leave it mapped since we can't tell when the
	// last person using it is done with it.
	//
	if (pRegisteredPort->IsSharedPort())
	{
		DPFX(DPFPREP, 2, "Leaving shared registered port 0x%p mapped.",
			pRegisteredPort);

		//
		// Pretend like we unmapped it, though.
		//
		pRegisteredPort->NoteNotMappedOnHNetFirewall();
		pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

		goto Exit;
	}


	//
	// Using the HomeNet API (particularly the out-of-proc COM calls) during
	// stress is really, really, painfully slow.  Since we have one global lock
	// the controls everything, other threads may be sitting for an equally
	// long time... so long, in fact, that the critical section timeout fires
	// and we get a false stress hit.  So we have a sneaky workaround to
	// prevent that from happening while still maintaining ownership of the
	// object.
	//
	this->SwitchToLongLock();
	fSwitchedToLongLock = TRUE;


	//
	// Try to initialize COM if we weren't instantiated through COM.  It may
	// have already been initialized in a different mode, which is okay.  As
	// long as it has been initialized somehow, we're fine.
	//
	if (this->m_dwFlags & NATHELPUPNPOBJ_NOTCREATEDWITHCOM)
	{
		hr = CoInitializeEx(NULL, (COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE));
		switch (hr)
		{
			case S_OK:
			{
				//
				// Success, that's good.  Cleanup when we're done.
				//
				DPFX(DPFPREP, 8, "Successfully initialized COM.");
				fUninitializeCOM = TRUE;
				break;
			}

			case S_FALSE:
			{
				//
				// Someone else already initialized COM, but that's okay.
				// Cleanup when we're done.
				//
				DPFX(DPFPREP, 8, "Initialized COM (again).");
				fUninitializeCOM = TRUE;
				break;
			}

			case RPC_E_CHANGED_MODE:
			{
				//
				// Someone else already initialized COM in a different mode.
				// It should be okay, but we don't have to balance the CoInit
				// call with a CoUninit.
				//
				DPFX(DPFPREP, 8, "Didn't initialize COM, already initialized in a different mode.");
				break;
			}

			default:
			{
				//
				// Hmm, something else is going on.  We can't handle that.
				//
				DPFX(DPFPREP, 0, "Initializing COM failed (err = 0x%lx)!", hr);
				goto Failure;
				break;
			}
		}
	}
	else
	{
		DPFX(DPFPREP, 8, "Object was instantiated through COM, no need to initialize COM.");
	}


	//
	// Create the main HNet manager object.
	//
	hr = CoCreateInstance(CLSID_HNetCfgMgr, NULL, CLSCTX_INPROC_SERVER,
						IID_IHNetCfgMgr, (PVOID*) (&pHNetCfgMgr));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 1, "Couldn't create IHNetCfgMgr interface (err = 0x%lx)!",
			hr);
		goto Failure;
	}


	//
	// We created the IHNetCfgMgr object as in-proc, so there's no proxy that
	// requires security settings.
	//
	//SETDEFAULTPROXYBLANKET(pHNetCfgMgr);


	//
	// Actually unmap the port(s).
	//
	hr = this->UnmapPortOnLocalHNetFirewallInternal(pRegisteredPort,
													fNeedToDeleteRegValue,
													pHNetCfgMgr);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't unmap ports from local HNet firewall (err = 0x%lx)!",
			hr);
		goto Failure;
	}

	
	//
	// Alert the user to the change the next time GetCaps is called, if requested.
	//
	if (fNoteAddressChange)
	{
		DPFX(DPFPREP, 8, "Noting that addresses changed (for registered port 0x%p).",
			pRegisteredPort);
		this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;
	}



Exit:

	if (pHNetCfgMgr != NULL)
	{
		pHNetCfgMgr->Release();
		pHNetCfgMgr = NULL;
	}

	if (fUninitializeCOM)
	{
		DPFX(DPFPREP, 8, "Uninitializing COM.");
		CoUninitialize();
		fUninitializeCOM = FALSE;
	}

	if (fSwitchedToLongLock)
	{
		this->SwitchFromLongLock();
		fSwitchedToLongLock = FALSE;
	}


	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::UnmapPortOnLocalHNetFirewall





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UnmapPortOnLocalHNetFirewallInternal"
//=============================================================================
// CNATHelpUPnP::UnmapPortOnLocalHNetFirewallInternal
//-----------------------------------------------------------------------------
//
// Description:    Removes the mappings for the given ports from the local
//				firewall.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CRegisteredPort * pRegisteredPort	- Pointer to port to be opened on the
//											firewall.
//	BOOL fNeedToDeleteRegValue			- Whether the corresponding crash
//											recovery registry value needs to
//											be deleted as well.
//	IHNetCfgMgr * pHNetCfgMgr			- Pointer to IHNetCfgMgr interface to
//											use.
//
// Returns: HRESULT
//	DPNH_OK				- Unmapping completed successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::UnmapPortOnLocalHNetFirewallInternal(CRegisteredPort * const pRegisteredPort,
															const BOOL fNeedToDeleteRegValue,
															IHNetCfgMgr * const pHNetCfgMgr)
{
	HRESULT								hr = DPNH_OK;
	CDevice *							pDevice;
	DWORD								dwAttempts = 0;
	IHNetProtocolSettings *				pHNetProtocolSettings = NULL;
	IEnumHNetPortMappingProtocols *		pEnumHNetPortMappingProtocols = NULL;
	SOCKADDR_IN *						pasaddrinPrivate;
	UCHAR								ucProtocolToMatch;
	IHNetPortMappingProtocol *			pHNetPortMappingProtocol = NULL;
	DWORD								dwStartingPort = 0;
	DWORD								dwTemp;
	ULONG								ulNumFound;
	WORD								wPort;
	UCHAR								ucProtocol;
	WCHAR *								pwszName = NULL;
	BOOLEAN								fBuiltIn;
	CRegistry							RegObject;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i, 0x%p)",
		this, pRegisteredPort, fNeedToDeleteRegValue, pHNetCfgMgr);


	DNASSERT(pRegisteredPort->IsMappedOnHNetFirewall());


	pDevice = pRegisteredPort->GetOwningDevice();
	DNASSERT(pDevice != NULL);
	DNASSERT(pDevice->IsHNetFirewalled());


	DNASSERT(this->m_hIpHlpApiDLL != NULL);



Restart:


	//
	// Get a protocol settings interface.
	//
	hr = pHNetCfgMgr->QueryInterface(IID_IHNetProtocolSettings,
									(PVOID*) (&pHNetProtocolSettings));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't get IHNetProtocolSettings interface from IHNetCfgMgr 0x%p (err = 0x%lx)!",
			pHNetCfgMgr, hr);
		goto Failure;
	}


	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pHNetProtocolSettings);


	//
	// Get ready to enumerate the existing mappings.
	//

	hr = pHNetProtocolSettings->EnumPortMappingProtocols(&pEnumHNetPortMappingProtocols);
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't enumerate port mapping protocols (err = 0x%lx)!",
			hr);
		goto Failure;
	}


	//
	// The HNetxxx objects appear to not be proxied...
	//
	//SETDEFAULTPROXYBLANKET(pEnumHNetPortMappingProtocols);


	pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

	if (pRegisteredPort->IsTCP())
	{
		ucProtocolToMatch = PORTMAPPINGPROTOCOL_TCP;
	}
	else
	{
		ucProtocolToMatch = PORTMAPPINGPROTOCOL_UDP;
	}



	//
	// Loop through all the ports (that we haven't successfully unmapped yet).
	//
	for(dwTemp = dwStartingPort; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
	{
		//
		// Loop until we find a duplicate item or run out of items.
		//
		do
		{
			hr = pEnumHNetPortMappingProtocols->Next(1,
													&pHNetPortMappingProtocol,
													&ulNumFound);
			if (FAILED(hr))
			{
				dwAttempts++;
				if (dwAttempts < MAX_NUM_HOMENETUNMAP_ATTEMPTS)
				{
					DPFX(DPFPREP, 0, "Couldn't get next port mapping protocol (err = 0x%lx)!  Trying again after %u ms.",
						hr, (dwAttempts * HOMENETUNMAP_SLEEP_FACTOR));

					//
					// Dump the object pointers we currently have.
					//

					pEnumHNetPortMappingProtocols->Release();
					pEnumHNetPortMappingProtocols = NULL;

					pHNetProtocolSettings->Release();
					pHNetProtocolSettings = NULL;


					//
					// Sleep, then go back to the top and try again.
					//
					Sleep(dwAttempts * HOMENETUNMAP_SLEEP_FACTOR);
					goto Restart;
				}


				DPFX(DPFPREP, 0, "Couldn't get next port mapping protocol (err = 0x%lx)!",
					hr);
				goto Failure;
			}


			//
			// If there aren't any more items, bail.
			//
			if (ulNumFound == 0)
			{
				//
				// Be sure that IEnumHNetPortMappingProtocols::Next returned
				// the right thing, for PREfix's sake.
				//
				if (pHNetPortMappingProtocol != NULL)
				{
					pHNetPortMappingProtocol->Release();
					pHNetPortMappingProtocol = NULL;
				}


				//
				// pEnumHNetPortMappingProtocols->Next might have returned
				// S_FALSE.
				//
				hr = DPNH_OK;
				break;
			}


			//
			// The HNetxxx objects appear to not be proxied...
			//
			//SETDEFAULTPROXYBLANKET(pHNetPortMappingProtocol);


			//
			// Get the port.
			//
			hr = pHNetPortMappingProtocol->GetPort(&wPort);
			if (hr != S_OK)
			{
				DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetPort!"), 2);


				//
				// Dump the unusable mapping object.
				//
				pHNetPortMappingProtocol->Release();
				pHNetPortMappingProtocol = NULL;


				dwAttempts++;
				if (dwAttempts < MAX_NUM_HOMENETUNMAP_ATTEMPTS)
				{
					DPFX(DPFPREP, 0, "Couldn't get port mapping protocol port (err = 0x%lx)!  Trying again after %u ms.",
						hr, (dwAttempts * HOMENETUNMAP_SLEEP_FACTOR));

					//
					// Dump the object pointers we currently have.
					//

					pEnumHNetPortMappingProtocols->Release();
					pEnumHNetPortMappingProtocols = NULL;

					pHNetProtocolSettings->Release();
					pHNetProtocolSettings = NULL;


					//
					// Sleep, then go back to the top and try again.
					//
					Sleep(dwAttempts * HOMENETUNMAP_SLEEP_FACTOR);
					goto Restart;
				}


				//
				// Break out of the search loop, but continue.
				//
				DPFX(DPFPREP, 0, "Couldn't get port mapping protocol port (err = 0x%lx)!",
					hr);
				break;
			}


			//
			// Get the protocol.
			//
			hr = pHNetPortMappingProtocol->GetIPProtocol(&ucProtocol);
			if (hr != S_OK)
			{
				DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetIPProtocol!"), 2);


				//
				// Dump the unusable mapping object.
				//
				pHNetPortMappingProtocol->Release();
				pHNetPortMappingProtocol = NULL;


				dwAttempts++;
				if (dwAttempts < MAX_NUM_HOMENETUNMAP_ATTEMPTS)
				{
					DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's IP protocol (err = 0x%lx)!  Trying again after %u ms.",
						hr, (dwAttempts * HOMENETUNMAP_SLEEP_FACTOR));

					//
					// Dump the object pointers we currently have.
					//

					pEnumHNetPortMappingProtocols->Release();
					pEnumHNetPortMappingProtocols = NULL;

					pHNetProtocolSettings->Release();
					pHNetProtocolSettings = NULL;


					//
					// Sleep, then go back to the top and try again.
					//
					Sleep(dwAttempts * HOMENETUNMAP_SLEEP_FACTOR);
					goto Restart;
				}


				//
				// Break out of the search loop, but continue.
				//
				DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's IP protocol (err = 0x%lx)!",
					hr);
				break;
			}


			//
			// See if we found the object we need.  Note that we don't verify
			// the target address for simplicity (neither does UPnP).
			//
			if ((wPort == pasaddrinPrivate[dwTemp].sin_port) &&
				(ucProtocol == ucProtocolToMatch))
			{
				//
				// Retrieve the mapping name.
				//
				hr = pHNetPortMappingProtocol->GetName(&pwszName);
				if (hr != S_OK)
				{
					DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetName!"), 2);


					//
					// Dump the unusable mapping object.
					//
					pHNetPortMappingProtocol->Release();
					pHNetPortMappingProtocol = NULL;


					dwAttempts++;
					if (dwAttempts < MAX_NUM_HOMENETUNMAP_ATTEMPTS)
					{
						DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's name (err = 0x%lx)!  Trying again after %u ms.",
							hr, (dwAttempts * HOMENETUNMAP_SLEEP_FACTOR));

						//
						// Dump the object pointers we currently have.
						//

						pEnumHNetPortMappingProtocols->Release();
						pEnumHNetPortMappingProtocols = NULL;

						pHNetProtocolSettings->Release();
						pHNetProtocolSettings = NULL;


						//
						// Sleep, then go back to the top and try again.
						//
						Sleep(dwAttempts * HOMENETUNMAP_SLEEP_FACTOR);
						goto Restart;
					}


					//
					// Break out of the search loop, but continue.
					//
					DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's name (err = 0x%lx)!",
						hr);
					break;
				}

				DPFX(DPFPREP, 8, "Found port mapping protocol 0x%p (\"%ls\").",
					pHNetPortMappingProtocol, pwszName);

				//
				// See if this protocol is built-in.
				//
				hr = pHNetPortMappingProtocol->GetBuiltIn(&fBuiltIn);
				if (hr != S_OK)
				{
					DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetBuiltIn!"), 2);


					//
					// Dump the unusable mapping object and its name.
					//
					pHNetPortMappingProtocol->Release();
					pHNetPortMappingProtocol = NULL;

					CoTaskMemFree(pwszName);
					pwszName = NULL;


					dwAttempts++;
					if (dwAttempts < MAX_NUM_HOMENETUNMAP_ATTEMPTS)
					{
						DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's built-in status (err = 0x%lx)!  Trying again after %u ms.",
							hr, (dwAttempts * HOMENETUNMAP_SLEEP_FACTOR));

						//
						// Dump the object pointers we currently have.
						//

						pEnumHNetPortMappingProtocols->Release();
						pEnumHNetPortMappingProtocols = NULL;

						pHNetProtocolSettings->Release();
						pHNetProtocolSettings = NULL;


						//
						// Sleep, then go back to the top and try again.
						//
						Sleep(dwAttempts * HOMENETUNMAP_SLEEP_FACTOR);
						goto Restart;
					}


					//
					// Break out of the search loop, but continue.
					//
					DPFX(DPFPREP, 0, "Couldn't get port mapping protocol's built-in status (err = 0x%lx)!",
						hr);
					break;
				}


				break;
			}
#ifdef DBG
			else
			{
				//
				// Try to retrieve the mapping name for informational purposes.
				//
				hr = pHNetPortMappingProtocol->GetName(&pwszName);
				if (hr != S_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't get port mapping protocol 0x%p's name (err = 0x%lx)!",
						pHNetPortMappingProtocol, hr);


					DNASSERTX((! "Got unexpected error executing IHNetPortMappingProtocol::GetName!"), 2);

					//
					// Ignore error...
					//
				}
				else
				{
					DPFX(DPFPREP, 7, "Skipping non-matching port mapping protocol 0x%p (\"%ls\").",
						pHNetPortMappingProtocol, pwszName);

					CoTaskMemFree(pwszName);
					pwszName = NULL;
				}
			}
#endif // DBG


			//
			// Get ready for the next object.
			//
			pHNetPortMappingProtocol->Release();
			pHNetPortMappingProtocol = NULL;
		}
		while (TRUE);


		//
		// Remove the mapping (if we found it).
		//
		if (pHNetPortMappingProtocol != NULL)
		{
			//
			// If the mapping is built-in we can't delete it.  Disabling it is
			// the best we can do.
			//
			if (fBuiltIn)
			{
				DPFX(DPFPREP, 7, "Disabling built-in port mapping protocol \"%ls\".", pwszName);

				DNASSERT(pRegisteredPort->IsHNetFirewallMappingBuiltIn());

				hr = this->DisableAllBindingsForHNetPortMappingProtocol(pHNetPortMappingProtocol,
																		pHNetCfgMgr);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't disable all bindings for built-in port mapping protocol \"%ls\" (err = 0x%lx)!",
						pwszName, hr);
					goto Failure;
				}
			}
			else
			{
				DPFX(DPFPREP, 7, "Deleting port mapping protocol \"%ls\".", pwszName);

				DNASSERT(! pRegisteredPort->IsHNetFirewallMappingBuiltIn());


				hr = pHNetPortMappingProtocol->Delete();
				if (hr != S_OK)
				{
					//
					// This might be WBEM_E_ACCESSDENIED (0x80041003), which
					// means the current user doesn't have permissions to
					// modify firewall mappings.
					//

					DPFX(DPFPREP, 0, "Couldn't delete port mapping protocol (err = 0x%lx)!",
						hr);
					goto Failure;
				}
			}


			if (fNeedToDeleteRegValue)
			{
				//
				// Delete the crash cleanup registry entry.  The mapping
				// description/name will match the registry key name even in
				// the case of built-in mappings with names we didn't generate.
				// See MapPortOnLocalHNetFirewall.
				//
				if (! RegObject.Open(HKEY_LOCAL_MACHINE,
									DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVEFIREWALLMAPPINGS,
									FALSE,
									TRUE,
									TRUE,
									DPN_KEY_ALL_ACCESS))
				{
					DPFX(DPFPREP, 0, "Couldn't open active firewall mapping key, unable to remove crash cleanup reference!");
				}
				else
				{
					BOOL	fResult;


					//
					// Ignore error.
					//
					fResult = RegObject.DeleteValue(pwszName);
					if (! fResult)
					{
						DPFX(DPFPREP, 0, "Couldn't delete firewall mapping value \"%ls\"!  Continuing.",
							pwszName);
					}

					RegObject.Close();
				}
			}
			else
			{
				DPFX(DPFPREP, 6, "No need to delete firewall crash cleanup registry key \"%ls\".", pwszName);
			}


			//
			// Cleanup pointers we accumulated.
			//

			CoTaskMemFree(pwszName);
			pwszName = NULL;

			pHNetPortMappingProtocol->Release();
			pHNetPortMappingProtocol = NULL;
		}
		else
		{
			//
			// We didn't find the mapping.
			//
			DPFX(DPFPREP, 0, "Didn't find port mapping protocol for port %u %s!  Continuing.",
				NTOHS(pasaddrinPrivate[dwTemp].sin_port),
				((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
		}



		//
		// Cleanup from this port mapping, and get ready for the next one.
		//

		hr = pEnumHNetPortMappingProtocols->Reset();
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't reset port mapping protocol enumeration 0x%p (err = 0x%lx)!",
				pEnumHNetPortMappingProtocols, hr);
			goto Failure;
		}


		//
		// Go on to the next port, and update the starting counter in case we
		// encounter a failure next time.
		//
		dwStartingPort++;
	}


	pRegisteredPort->NoteNotMappedOnHNetFirewall();
	pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

	
	DNASSERT(hr == DPNH_OK);


Exit:

	if (pHNetPortMappingProtocol != NULL)
	{
		pHNetPortMappingProtocol->Release();
		pHNetPortMappingProtocol = NULL;
	}

	if (pEnumHNetPortMappingProtocols != NULL)
	{
		pEnumHNetPortMappingProtocols->Release();
		pEnumHNetPortMappingProtocols = NULL;
	}

	if (pHNetProtocolSettings != NULL)
	{
		pHNetProtocolSettings->Release();
		pHNetProtocolSettings = NULL;
	}


	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pwszName != NULL)
	{
		CoTaskMemFree(pwszName);
		pwszName = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::UnmapPortOnLocalHNetFirewallInternal





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DisableAllBindingsForHNetPortMappingProtocol"
//=============================================================================
// CNATHelpUPnP::DisableAllBindingsForHNetPortMappingProtocol
//-----------------------------------------------------------------------------
//
// Description:    Disables all HNetPortMappingBindings on all HNetConnection
//				interfaces for the given port mapping protocol object.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	IHNetPortMappingProtocol * pHNetPortMappingProtocol		- Pointer to port
//																mapping
//																protocol to
//																disable on all
//																connections.
//	IHNetCfgMgr * pHNetCfgMgr								- Pointer to
//																IHNetCfgMgr
//																interface to
//																use.
//
// Returns: HRESULT
//	DPNH_OK							- Disabling was successful.
//	DPNHERR_GENERIC					- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::DisableAllBindingsForHNetPortMappingProtocol(IHNetPortMappingProtocol * const pHNetPortMappingProtocol,
																IHNetCfgMgr * const pHNetCfgMgr)
{
	HRESULT						hr;
	INetConnectionManager *		pNetConnectionManager = NULL;
	IEnumNetConnection *		pEnumNetConnections = NULL;
	ULONG						ulNumFound;
	INetConnection *			pNetConnection = NULL;
	IHNetConnection *			pHNetConnection = NULL;
	IHNetPortMappingBinding *	pHNetPortMappingBinding = NULL;
#ifdef DBG
	WCHAR *						pwszName = NULL;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pHNetPortMappingProtocol, pHNetCfgMgr);


	//
	// Try creating the base connection object.
	//
	hr = CoCreateInstance(CLSID_ConnectionManager,
						NULL,
						CLSCTX_SERVER,
						IID_INetConnectionManager,
						(PVOID*) (&pNetConnectionManager));
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't create INetConnectionManager interface (err = 0x%lx)!",
			hr);
		goto Failure;
	}

	SETDEFAULTPROXYBLANKET(pNetConnectionManager);


	DPFX(DPFPREP, 7, "Successfully created net connection manager object 0x%p.",
		pNetConnectionManager);


	//
	// Get the net connection enumeration object.
	//
	hr = pNetConnectionManager->EnumConnections(NCME_DEFAULT, &pEnumNetConnections);
	if (hr != S_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't enum connections (err = 0x%lx)!",
			hr);
		goto Failure;
	}

	SETDEFAULTPROXYBLANKET(pEnumNetConnections);


	//
	// We don't need the base object anymore.
	//
	pNetConnectionManager->Release();
	pNetConnectionManager = NULL;


	//
	// Keep looping until we find the item or run out of items.
	//
	do
	{
		hr = pEnumNetConnections->Next(1, &pNetConnection, &ulNumFound);
		if (FAILED(hr))
		{
			DPFX(DPFPREP, 0, "Couldn't get next connection (err = 0x%lx)!",
				hr);
			goto Failure;
		}


		//
		// If there aren't any more items, bail.
		//
		if (ulNumFound == 0)
		{
			//
			// pEnumNetConnections->Next might have returned S_FALSE.
			//
			hr = DPNH_OK;
			break;
		}


		SETDEFAULTPROXYBLANKET(pNetConnection);


		//
		// Get the HNetConnection object for this NetConnection.
		//
		hr = pHNetCfgMgr->GetIHNetConnectionForINetConnection(pNetConnection,
															&pHNetConnection);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't get IHNetConnection interface for INetConnection 0x%p (err = 0x%lx)!",
				pNetConnection, hr);
			goto Failure;
		}


		//
		// The HNetxxx objects appear to not be proxied...
		//
		//SETDEFAULTPROXYBLANKET(pHNetConnection);


		//
		// Don't need the INetConnection interface anymore.
		//
		pNetConnection->Release();
		pNetConnection = NULL;


#ifdef DBG
		//
		// Retrieve the connection name, for debug printing purposes.
		//
		hr = pHNetConnection->GetName(&pwszName);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't get name of HNetConnection 0x%p (err = 0x%lx)!",
				pHNetConnection, hr);
			goto Failure;
		}
#endif // DBG


		//
		// Retrieve the existing binding.
		//
		hr = pHNetConnection->GetBindingForPortMappingProtocol(pHNetPortMappingProtocol,
															&pHNetPortMappingBinding);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't get binding for port mapping protocol 0x%p (err = 0x%lx)!",
				pHNetPortMappingProtocol, hr);
			goto Failure;
		}


		//
		// The HNetxxx objects appear to not be proxied...
		//
		//SETDEFAULTPROXYBLANKET(pHNetPortMappingBinding);


		//
		// Don't need the HomeNet Connection object anymore.
		//
		pHNetConnection->Release();
		pHNetConnection = NULL;


		DPFX(DPFPREP, 6, "Disabling binding 0x%p on connection \"%ls\".",
			pHNetPortMappingBinding, pwszName);

		
		//
		// Disable it.
		//
		hr = pHNetPortMappingBinding->SetEnabled(FALSE);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't disable port mapping binding 0x%p (err = 0x%lx)!",
				pHNetPortMappingBinding, hr);
			goto Failure;
		}

		pHNetPortMappingBinding->Release();
		pHNetPortMappingBinding = NULL;


		//
		// Go to the next mapping.
		//
#ifdef DBG
		CoTaskMemFree(pwszName);
		pwszName = NULL;
#endif // DBG
	}
	while (TRUE);


	//
	// If we're here, we made it through unscathed.
	//
	hr = DPNH_OK;


Exit:

	if (pEnumNetConnections != NULL)
	{
		pEnumNetConnections->Release();
		pEnumNetConnections = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pHNetPortMappingBinding != NULL)
	{
		pHNetPortMappingBinding->Release();
		pHNetPortMappingBinding = NULL;
	}

#ifdef DBG
	if (pwszName != NULL)
	{
		CoTaskMemFree(pwszName);
		pwszName = NULL;
	}
#endif // DBG

	if (pHNetConnection != NULL)
	{
		pHNetConnection->Release();
		pHNetConnection = NULL;
	}

	if (pNetConnection != NULL)
	{
		pNetConnection->Release();
		pNetConnection = NULL;
	}

	if (pNetConnectionManager != NULL)
	{
		pNetConnectionManager->Release();
		pNetConnectionManager = NULL;
	}

	goto Exit;
} // CNATHelpUPnP::DisableAllBindingsForHNetPortMappingProtocol





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CleanupInactiveFirewallMappings"
//=============================================================================
// CNATHelpUPnP::CleanupInactiveFirewallMappings
//-----------------------------------------------------------------------------
//
// Description:    Looks for any mappings previously made by other DPNATHLP
//				instances that are no longer active (because of a crash), and
//				unmaps them.
//
//				   COM is assumed to have been initialized.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice					- Pointer to device to use.
//	IHNetCfgMgr * pHNetCfgMgr			- Pointer to IHNetCfgMgr interface to
//											use.
//
// Returns: HRESULT
//	DPNH_OK							- The cleanup was successful.
//	DPNHERR_GENERIC					- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CleanupInactiveFirewallMappings(CDevice * const pDevice,
													IHNetCfgMgr * const pHNetCfgMgr)
{
	HRESULT						hr = DPNH_OK;
	CRegistry					RegObject;
	BOOL						fOpenedRegistry = FALSE;
	DWORD						dwIndex;
	WCHAR						wszValueName[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DWORD						dwValueNameSize;
	DPNHACTIVEFIREWALLMAPPING	dpnhafm;
	DWORD						dwValueSize;
	TCHAR						tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	DNHANDLE					hNamedObject = NULL;
	CRegisteredPort *			pRegisteredPort = NULL;
	BOOL						fSetPrivateAddresses = FALSE;
	SOCKADDR_IN					saddrinPrivate;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pDevice, pHNetCfgMgr);


	DNASSERT(pDevice != NULL);
	DNASSERT(pDevice->IsHNetFirewalled());


	if (! RegObject.Open(HKEY_LOCAL_MACHINE,
						DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVEFIREWALLMAPPINGS,
						FALSE,
						TRUE,
						TRUE,
						DPN_KEY_ALL_ACCESS))
	{
		DPFX(DPFPREP, 1, "Couldn't open active firewall mapping key, not performing crash cleanup.");
		DNASSERT(hr == DPNH_OK);
		goto Exit;
	}

	fOpenedRegistry = TRUE;


	//
	// Walk the list of active mappings.
	//
	dwIndex = 0;
	do
	{
		dwValueNameSize = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
		if (! RegObject.EnumValues(wszValueName, &dwValueNameSize, dwIndex))
		{
			//
			// There was an error or there aren't any more keys.  We're done.
			//
			break;
		}


		//
		// Try reading that mapping's data.
		//
		dwValueSize = sizeof(dpnhafm);
		if (! RegObject.ReadBlob(wszValueName, (LPBYTE) (&dpnhafm), &dwValueSize))
		{
			//
			// We don't have a lock protecting the registry, so some other
			// instance could have deleted the key between when we enumerated
			// it and now.  We'll stop trying (and hopefully that other
			// instance will cover the rest of the items).
			//
			DPFX(DPFPREP, 0, "Couldn't read \"%ls\" mapping value!  Done with cleanup.",
				wszValueName);

			DNASSERT(hr == DPNH_OK);
			goto Exit;
		}

		//
		// Validate the data read.
		//
		if ((dwValueSize != sizeof(dpnhafm)) ||
			(dpnhafm.dwVersion != ACTIVE_MAPPING_VERSION))
		{
			DPFX(DPFPREP, 0, "The \"%ls\" mapping value is invalid!  Done with cleanup.",
				wszValueName);

			//
			// Move to next item.
			//
			dwIndex++;
			continue;
		}


		//
		// See if that DPNHUPNP instance is still around.
		//

		if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
		{
			wsprintf(tszObjectName, _T("Global\\") INSTANCENAMEDOBJECT_FORMATSTRING, dpnhafm.dwInstanceKey);
		}
		else
		{
			wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, dpnhafm.dwInstanceKey);
		}

		hNamedObject = DNOpenEvent(SYNCHRONIZE, FALSE, tszObjectName);
		if (hNamedObject != NULL)
		{
			//
			// This is still an active mapping.
			//

			DPFX(DPFPREP, 4, "Firewall mapping \"%ls\" belongs to instance %u, which is still active.",
				wszValueName, dpnhafm.dwInstanceKey);

			DNCloseHandle(hNamedObject);
			hNamedObject = NULL;

			//
			// Move to next item.
			//
			dwIndex++;
			continue;
		}


		DPFX(DPFPREP, 4, "Firewall mapping \"%ls\" belongs to instance %u, which no longer exists.",
			wszValueName, dpnhafm.dwInstanceKey);

		//
		// Delete the value now that we have the information we need.
		//
		if (! RegObject.DeleteValue(wszValueName))
		{
			//
			// See ReadBlob comments.  Stop trying to cleanup.
			//
			DPFX(DPFPREP, 0, "Couldn't delete \"%ls\"!  Done with cleanup.",
				wszValueName);

			DNASSERT(hr == DPNH_OK);
			goto Exit;
		}


		//
		// Create a fake registered port that we will deregister.  Ignore the
		// NAT state flags.
		//
		pRegisteredPort = new CRegisteredPort(0, (dpnhafm.dwFlags & REGPORTOBJMASK_HNETFWAPI));
		if (pRegisteredPort == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		//
		// Assert that the other information/state flags are correct.
		//
		DNASSERT(! pRegisteredPort->IsHNetFirewallPortUnavailable());
		DNASSERT(! pRegisteredPort->IsRemovingUPnPLease());


		//
		// Temporarily associate the registered port with the device.
		//
		pRegisteredPort->MakeDeviceOwner(pDevice);


		
		ZeroMemory(&saddrinPrivate, sizeof(saddrinPrivate));
		saddrinPrivate.sin_family				= AF_INET;
		saddrinPrivate.sin_addr.S_un.S_addr		= dpnhafm.dwAddressV4;
		saddrinPrivate.sin_port					= dpnhafm.wPort;


		//
		// Store the private address.
		//
		hr = pRegisteredPort->SetPrivateAddresses(&saddrinPrivate, 1);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed creating UPnP address array!");
			goto Failure;
		}

		fSetPrivateAddresses = TRUE;


		//
		// Pretend it has been mapped on the local firewall.  Note that this
		// flag shouldn't have been set at the time it was stored in registry
		// but we masked it out if it had been.
		//
		pRegisteredPort->NoteMappedOnHNetFirewall();


		//
		// Actually free the port.
		//
		hr = this->UnmapPortOnLocalHNetFirewallInternal(pRegisteredPort,
														FALSE,
														pHNetCfgMgr);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed deleting temporary HNet firewall port (err = 0x%lx)!  Ignoring.",
				hr);

			//
			// Jump to the failure cleanup case, but don't actually return a
			// failure.
			//
			hr = DPNH_OK;
			goto Failure;
		}


		pRegisteredPort->ClearPrivateAddresses();
		fSetPrivateAddresses = FALSE;

		pRegisteredPort->ClearDeviceOwner();

		delete pRegisteredPort;
		pRegisteredPort = NULL;


		//
		// Move to the next mapping.  Don't increment index since we just
		// deleted the previous entry and everything shifts down one.
		//
	}
	while (TRUE);


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pRegisteredPort != NULL)
	{
		pRegisteredPort->NoteNotMappedOnHNetFirewall();
		pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();

		if (fSetPrivateAddresses)
		{
			pRegisteredPort->ClearPrivateAddresses();
			fSetPrivateAddresses = FALSE;
		}

		pRegisteredPort->ClearDeviceOwner();

		delete pRegisteredPort;
		pRegisteredPort = NULL;
	}

	if (fOpenedRegistry)
	{
		RegObject.Close();
	}

	goto Exit;
} // CNATHelpUPnP::CleanupInactiveFirewallMappings




#endif // ! DPNBUILD_NOHNETFWAPI





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::RemoveAllItems"
//=============================================================================
// CNATHelpUPnP::RemoveAllItems
//-----------------------------------------------------------------------------
//
// Description:    Removes all devices (de-registering with Internet gateways
//				if necessary).  This removes all registered port mapping
//				objects and UPnP device objects, as well.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::RemoveAllItems(void)
{
	HRESULT				hr;
	CBilink *			pBilinkDevice;
	CDevice *			pDevice;
	CBilink *			pBilinkRegisteredPort;
	CRegisteredPort *	pRegisteredPort;
	CUPnPDevice *		pUPnPDevice;


	DPFX(DPFPREP, 7, "(0x%p) Enter", this);


	pBilinkDevice = this->m_blDevices.GetNext();
	while (pBilinkDevice != &this->m_blDevices)
	{
		DNASSERT(! pBilinkDevice->IsEmpty());
		pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
		pBilinkDevice = pBilinkDevice->GetNext();


		DPFX(DPFPREP, 5, "Destroying device 0x%p.",
			pDevice);


		pDevice->m_blList.RemoveFromList();


		//
		// All of the device's registered ports are implicitly freed.
		//

		pBilinkRegisteredPort = pDevice->m_blOwnedRegPorts.GetNext();

		while (pBilinkRegisteredPort != &pDevice->m_blOwnedRegPorts)
		{
			DNASSERT(! pBilinkRegisteredPort->IsEmpty());
			pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
			pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();


			DPFX(DPFPREP, 5, "Destroying registered port 0x%p (under device 0x%p).",
				pRegisteredPort, pDevice);


			//
			// Unmap on UPnP server if necessary.
			//
			if (pRegisteredPort->HasUPnPPublicAddresses())
			{
				hr = this->UnmapUPnPPort(pRegisteredPort,
										pRegisteredPort->GetNumAddresses(),	// free all ports
										TRUE);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't delete UPnP registered port 0x%p mapping (err = 0x%lx)!  Ignoring.",
						pRegisteredPort, hr);
					
					//
					// Continue anyway, so we can finish cleaning up the object.
					//
				}

				DNASSERT(! pRegisteredPort->HasUPnPPublicAddresses());

				pRegisteredPort->NoteNotPermanentUPnPLease();
				pRegisteredPort->NoteNotUPnPPortUnavailable();
			}


#ifndef DPNBUILD_NOHNETFWAPI
			//
			// Then unmap from the local firewall, if necessary.
			//
			if (pRegisteredPort->IsMappedOnHNetFirewall())
			{
				//
				// Unmap the port.
				//
				// Alert the user since this is unexpected.
				//
				hr = this->UnmapPortOnLocalHNetFirewall(pRegisteredPort,
														TRUE,
														TRUE);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Failed unmapping registered port 0x%p on local HomeNet firewall (err = 0x%lx)!  Ignoring.",
						pRegisteredPort, hr);

					pRegisteredPort->NoteNotMappedOnHNetFirewall();
					pRegisteredPort->NoteNotHNetFirewallMappingBuiltIn();
					
					//
					// Continue anyway, so we can finish cleaning up the object.
					//
				}
			}
#endif // ! DPNBUILD_NOHNETFWAPI


			pRegisteredPort->ClearDeviceOwner();
			DNASSERT(pRegisteredPort->m_blGlobalList.IsListMember(&this->m_blRegisteredPorts));
			pRegisteredPort->m_blGlobalList.RemoveFromList();

			pRegisteredPort->ClearPrivateAddresses();


			//
			// The user implicitly released this port.
			//
			pRegisteredPort->ClearAllUserRefs();

			delete pRegisteredPort;
		}


		//
		// The device's UPnP gateway is implicitly removed.
		//

		pUPnPDevice = pDevice->GetUPnPDevice();
		if (pUPnPDevice != NULL)
		{
			if ((pUPnPDevice->IsConnecting()) || (pUPnPDevice->IsConnected()))
			{
				if (this->m_pfnshutdown(pUPnPDevice->GetControlSocket(), 0) != 0)
				{
#ifdef DBG
					int		iError;


					iError = this->m_pfnWSAGetLastError();
					DPFX(DPFPREP, 0, "Failed shutting down UPnP device 0x%p's control socket (err = %u)!  Ignoring.",
						pUPnPDevice, iError);
#endif // DBG
				}
			}

			pUPnPDevice->ClearDeviceOwner();
			DNASSERT(pUPnPDevice->m_blList.IsListMember(&this->m_blUPnPDevices));
			pUPnPDevice->m_blList.RemoveFromList();
			//
			// Transfer list reference to our pointer, since GetUPnPDevice did
			// not give us one.
			//

			this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
			pUPnPDevice->SetControlSocket(INVALID_SOCKET);

			pUPnPDevice->ClearLocationURL();
			pUPnPDevice->ClearUSN();
			pUPnPDevice->ClearServiceControlURL();
			pUPnPDevice->DestroyReceiveBuffer();
			pUPnPDevice->RemoveAllCachedMappings();

			pUPnPDevice->DecRef();
			pUPnPDevice = NULL;
		}


#ifndef DPNBUILD_NOHNETFWAPI
		//
		// If we used the HomeNet firewall API to open a hole for UPnP
		// discovery multicasts, close it.
		//
		if (pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall())
		{
			hr = this->CloseDevicesUPnPDiscoveryPort(pDevice, NULL);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't close device 0x%p's UPnP discovery socket's port on firewall (err = 0x%lx)!  Ignoring.",
					pDevice, hr);

				//
				// Continue...
				//
				pDevice->NoteNotUPnPDiscoverySocketMappedOnHNetFirewall();
				hr = DPNH_OK;
			}
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		//
		// Close the socket.
		//
		if (this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP)
		{
			this->m_pfnclosesocket(pDevice->GetUPnPDiscoverySocket());
			pDevice->SetUPnPDiscoverySocket(INVALID_SOCKET);
		}


		//
		// Now we can dump the device object.
		//
		delete pDevice;
	}


	//
	// Removing all the devices normally removes all the registered ports, but
	// there may still be more wildcard ports that were never associated with
	// any device.
	//

	pBilinkRegisteredPort = this->m_blUnownedPorts.GetNext();
	while (pBilinkRegisteredPort != &this->m_blUnownedPorts)
	{
		DNASSERT(! pBilinkRegisteredPort->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
		pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();


		DPFX(DPFPREP, 5, "Destroying unowned registered port 0x%p.",
			pRegisteredPort);


		pRegisteredPort->m_blDeviceList.RemoveFromList();
		DNASSERT(pRegisteredPort->m_blGlobalList.IsListMember(&this->m_blRegisteredPorts));
		pRegisteredPort->m_blGlobalList.RemoveFromList();

		pRegisteredPort->ClearPrivateAddresses();

#ifndef DPNBUILD_NOHNETFWAPI
		DNASSERT(! pRegisteredPort->IsMappedOnHNetFirewall());
		DNASSERT(! pRegisteredPort->IsHNetFirewallPortUnavailable());
#endif // ! DPNBUILD_NOHNETFWAPI

		DNASSERT(! pRegisteredPort->HasUPnPPublicAddresses());
		DNASSERT(! pRegisteredPort->IsUPnPPortUnavailable());

		//
		// The user implicitly released this port.
		//
		pRegisteredPort->ClearAllUserRefs();

		delete pRegisteredPort;
	}


#ifdef DBG
	DNASSERT(this->m_blRegisteredPorts.IsEmpty());
	DNASSERT(this->m_blUPnPDevices.IsEmpty());


	//
	// Print all items still in the registry.
	//
#ifndef DPNBUILD_NOHNETFWAPI
	this->DebugPrintActiveFirewallMappings();
#endif // ! DPNBUILD_NOHNETFWAPI
	this->DebugPrintActiveNATMappings();
#endif // DBG




	DPFX(DPFPREP, 7, "(0x%p) Leave", this);
} // CNATHelpUPnP::RemoveAllItems





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::FindMatchingDevice"
//=============================================================================
// CNATHelpUPnP::FindMatchingDevice
//-----------------------------------------------------------------------------
//
// Description:    Searches the list of devices for the object matching the
//				given address, or NULL if one could not be found.  If the
//				address is INADDR_ANY, then the first device with a remote NAT
//				is selected.  If none exist, then the first device with a local
//				firewall is selected.
//
//				   If fUseAllInfoSources is TRUE, the list of registered ports
//				associated with devices is searched first for an exact match to
//				the address passed in.  If that fails, then devices are
//				searched as above.  In addition, if the address is INADDR_ANY,
///				the first device with a local NAT can be selected.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	SOCKADDR_IN * psaddrinMatch		- Pointer to address to look up.
//	BOOL fUseAllInfoSources			- Whether all possible sources of
//										information should be considered.
//
// Returns: CDevice
//	NULL if no match, valid object otherwise.
//=============================================================================
CDevice * CNATHelpUPnP::FindMatchingDevice(const SOCKADDR_IN * const psaddrinMatch,
											const BOOL fUseAllInfoSources)
{
	HRESULT				hr;
	BOOL				fUpdatedDeviceList = FALSE;
	CDevice *			pDeviceUPnPGateway = NULL;
#ifndef DPNBUILD_NOHNETFWAPI
	CDevice *			pDeviceLocalHNetFirewall = NULL;
#endif // ! DPNBUILD_NOHNETFWAPI
	SOCKADDR_IN *		pasaddrinTemp;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;
	CDevice *			pDevice;
	DWORD				dwTemp;


	do
	{
		//
		// First, make sure there are devices to choose from.
		//
		if (this->m_blDevices.IsEmpty())
		{
			DPFX(DPFPREP, 0, "No devices, can't match address %u.%u.%u.%u!",
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b4);
			pDevice = NULL;
			goto Exit;
		}


		//
		// It's possible that the address we're trying to match is an already
		// registered port.  Look through all owned port mappings for this
		// address, if we're allowed.
		//
		if (fUseAllInfoSources)
		{
			pBilink = this->m_blRegisteredPorts.GetNext();
			while (pBilink != &this->m_blRegisteredPorts)
			{
				DNASSERT(! pBilink->IsEmpty());
				pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);

				//
				// Only check this registered port if it has an owning device.
				//
				pDevice = pRegisteredPort->GetOwningDevice();
				if (pDevice != NULL)
				{
					//
					// Check each port in the array.
					//
					pasaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
					for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
					{
						//
						// If the address matches, we have a winner.
						//
						if ((pasaddrinTemp[dwTemp].sin_addr.S_un.S_addr == psaddrinMatch->sin_addr.S_un.S_addr) &&
							(pasaddrinTemp[dwTemp].sin_port == psaddrinMatch->sin_port))
						{
							DPFX(DPFPREP, 7, "Registered port 0x%p index %u matches address %u.%u.%u.%u:%u, returning owning device 0x%p.",
								pRegisteredPort,
								dwTemp,
								psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
								psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
								psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
								psaddrinMatch->sin_addr.S_un.S_un_b.s_b4,
								NTOHS(psaddrinMatch->sin_port),
								pDevice);
							goto Exit;
						}
					}
				}

				pBilink = pBilink->GetNext();
			}
		}


		//
		// Darn, the address is not already registered.  Well, match it up with
		// a device as best as possible.
		//

		pBilink = this->m_blDevices.GetNext();

		do
		{
			DNASSERT(! pBilink->IsEmpty());
			pDevice = DEVICE_FROM_BILINK(pBilink);
			
			if ((pDevice->GetLocalAddressV4() == psaddrinMatch->sin_addr.S_un.S_addr))
			{
				DPFX(DPFPREP, 7, "Device 0x%p matches address %u.%u.%u.%u.",
					pDevice,
					psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
					psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
					psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
					psaddrinMatch->sin_addr.S_un.S_un_b.s_b4);
				goto Exit;
			}


			//
			// Remember this device if it has the first remote UPnP gateway
			// device we've seen.
			//
			if ((pDevice->GetUPnPDevice() != NULL) &&
				((! pDevice->GetUPnPDevice()->IsLocal()) || (fUseAllInfoSources)) &&
				(pDeviceUPnPGateway == NULL))
			{
				pDeviceUPnPGateway = pDevice;
			}


#ifndef DPNBUILD_NOHNETFWAPI
			//
			// Remember this device if it has the first HomeNet firewall we've
			// seen.
			//
			if ((pDevice->IsHNetFirewalled()) &&
				(pDeviceLocalHNetFirewall == NULL))
			{
				pDeviceLocalHNetFirewall = pDevice;
			}
#endif // ! DPNBUILD_NOHNETFWAPI


			DPFX(DPFPREP, 7, "Device 0x%p does not match address %u.%u.%u.%u.",
				pDevice,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
				psaddrinMatch->sin_addr.S_un.S_un_b.s_b4);

			pBilink = pBilink->GetNext();
		}
		while (pBilink != &this->m_blDevices);


		//
		// If we got here, there's no matching device.  It might be because the
		// caller detected an address change faster than we did.  Try updating
		// our device list and searching again (if we haven't already).
		//

		if (fUpdatedDeviceList)
		{
			break;
		}


		//
		// Don't bother updating the list to match INADDR_ANY, we know that
		// will never match anything.
		//
		if (psaddrinMatch->sin_addr.S_un.S_addr == INADDR_ANY)
		{
			DPFX(DPFPREP, 7, "Couldn't find matching device for INADDR_ANY, as expected.");
			break;
		}


		DPFX(DPFPREP, 5, "Couldn't find matching device for %u.%u.%u.%u, updating device list and searching again.",
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b4);


		hr = this->CheckForNewDevices(&fUpdatedDeviceList);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't check for new devices (0x%lx), continuing.",
				hr);
			//
			// Hmm, we have to treat it as non-fatal. Don't search again,
			// though.
			//
			break;
		}

		//
		// If we didn't actually get any new devices, don't bother searching
		// again.
		//
		if (! fUpdatedDeviceList)
		{
			break;
		}

		//
		// fUpdatedDeviceList is set to TRUE so we'll only loop one more time.
		//
	}
	while (TRUE);


	//
	// If we got here, there's still no matching device.  If it's the wildcard
	// value, that's to be expected, but we need to pick a device in the
	// following order:
	//    1. device has an Internet gateway
	//    2. device has a firewall
	// If none of those exists or it's not the wildcard value, we have to give
	// up.
	//
	if (psaddrinMatch->sin_addr.S_un.S_addr == INADDR_ANY)
	{
		if (pDeviceUPnPGateway != NULL)
		{
			pDevice = pDeviceUPnPGateway;

			DPFX(DPFPREP, 1, "Picking device 0x%p with UPnP gateway device to match INADDR_ANY.",
				pDevice);
		}
#ifndef DPNBUILD_NOHNETFWAPI
		else if (pDeviceLocalHNetFirewall != NULL)
		{
			pDevice = pDeviceLocalHNetFirewall;

			DPFX(DPFPREP, 1, "Picking device 0x%p with local HomeNet firewall to match INADDR_ANY.",
				pDevice);
		}
#endif // ! DPNBUILD_NOHNETFWAPI
		else
		{
			pDevice = NULL;

			DPFX(DPFPREP, 1, "No suitable device to match INADDR_ANY.");
		}
	}
	else
	{
		pDevice = NULL;

		DPFX(DPFPREP, 7, "No devices match address %u.%u.%u.%u.",
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b1,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b2,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b3,
			psaddrinMatch->sin_addr.S_un.S_un_b.s_b4);
	}


Exit:

	return pDevice;
} // CNATHelpUPnP::FindMatchingDevice







#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ExtendAllExpiringLeases"
//=============================================================================
// CNATHelpUPnP::ExtendAllExpiringLeases
//-----------------------------------------------------------------------------
//
// Description:    Renews any port leases that are close to expiring (within 2
//				minutes of expiration time).
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: HRESULT
//	DPNH_OK				- Lease extension was successful.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ExtendAllExpiringLeases(void)
{
	HRESULT				hr = DPNH_OK;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;
	CDevice *			pDevice;
	DWORD				dwLeaseTimeRemaining;


	DPFX(DPFPREP, 5, "Enter");


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);


	//
	// Walk the list of all registered ports and check for leases that need to
	// be extended.
	// The lock is already held.
	//

	pBilink = this->m_blRegisteredPorts.GetNext();

	while (pBilink != (&this->m_blRegisteredPorts))
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);

		pDevice = pRegisteredPort->GetOwningDevice();


		//
		// If the port is registered with the UPnP device, extend that lease,
		// if necessary.
		//
		if ((pRegisteredPort->HasUPnPPublicAddresses()) &&
			(! pRegisteredPort->HasPermanentUPnPLease()))
		{
			DNASSERT(pDevice != NULL);


			dwLeaseTimeRemaining = pRegisteredPort->GetUPnPLeaseExpiration() - GETTIMESTAMP();

			if (dwLeaseTimeRemaining < LEASE_RENEW_TIME)
			{
				hr = this->ExtendUPnPLease(pRegisteredPort);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on remote UPnP device (0x%lx)!  Ignoring.", hr);

					//
					// We'll treat this as non-fatal, but we have to dump the
					// server.  This may have already been done, but doing it
					// twice shouldn't be harmful.
					//
					this->ClearDevicesUPnPDevice(pDevice);
					hr = DPNH_OK;
				}
			}
		}


		//
		// The local firewall never uses leases, no need to extend.
		//


		pBilink = pBilink->GetNext();
	}


	DNASSERT(hr == DPNH_OK);

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;
} // CNATHelpUPnP::ExtendAllExpiringLeases





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UpdateServerStatus"
//=============================================================================
// CNATHelpUPnP::UpdateServerStatus
//-----------------------------------------------------------------------------
//
// Description:    Checks to see if any Internet gateways have stopped
//				responding or are now available.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: HRESULT
//	DPNH_OK				- The update was successful.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::UpdateServerStatus(void)
{
	HRESULT				hr = DPNH_OK;
	DWORD				dwMinUpdateServerStatusInterval;
	DWORD				dwCurrentTime;
	CBilink *			pBilink;
	CDevice *			pDevice;
	CUPnPDevice *		pUPnPDevice = NULL;
	CDevice *			pDeviceRemoteUPnPGateway = NULL;
#ifndef DPNBUILD_NOHNETFWAPI
	CDevice *			pDeviceLocalHNetFirewall = NULL;
#endif // ! DPNBUILD_NOHNETFWAPI
	BOOL				fSendRemoteGatewayDiscovery;


	DPFX(DPFPREP, 5, "Enter");


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);


	//
	// Cache the current value of the global.  This should be atomic so no need
	// to take the globals lock.
	//
	dwMinUpdateServerStatusInterval = g_dwMinUpdateServerStatusInterval;


	//
	// Capture the current time.
	//
	dwCurrentTime = GETTIMESTAMP();


	//
	// If this isn't the first time to update server status, but it hasn't been
	// very long since we last checked, don't.  This will prevent unnecessary
	// network traffic if GetCaps is called frequently (in response to many
	// alert events, for example).
	//
	// However, if we just found a new device, update the status anyway.
	//
	if (this->m_dwLastUpdateServerStatusTime != 0)
	{
		if ((dwCurrentTime - this->m_dwLastUpdateServerStatusTime) < dwMinUpdateServerStatusInterval)
		{
			if (! (this->m_dwFlags & NATHELPUPNPOBJ_DEVICECHANGED))
			{
				DPFX(DPFPREP, 5, "Server status was just updated at %u, not updating again (time = %u, min interval = %u).",
					this->m_dwLastUpdateServerStatusTime,
					dwCurrentTime,
					dwMinUpdateServerStatusInterval);

				//
				// hr == DPNH_OK
				//
				goto Exit;
			}


			DPFX(DPFPREP, 5, "Server status was just updated at %u (time = %u, min interval = %u), but there was a device change that may affect things.",
				this->m_dwLastUpdateServerStatusTime,
				dwCurrentTime,
				dwMinUpdateServerStatusInterval);

			//
			// Continue...
			//
		}


		//
		// If we're allowed to keep polling for remote gateways after startup,
		// do so.  Otherwise, only do it if a device has changed or a port has
		// been registered since our last check.
		//
		if ((g_fKeepPollingForRemoteGateway) ||
			(this->m_dwFlags & NATHELPUPNPOBJ_DEVICECHANGED) ||
			(this->m_dwFlags & NATHELPUPNPOBJ_PORTREGISTERED))
		{
			fSendRemoteGatewayDiscovery = TRUE;
		}
		else
		{
			fSendRemoteGatewayDiscovery = FALSE;
		}
	}
	else
	{
		//
		// We always poll for new remote gateways during startup.
		//
		fSendRemoteGatewayDiscovery = TRUE;
	}


	//
	// Prevent the timer from landing exactly on 0.
	//
	if (dwCurrentTime == 0)
	{
		dwCurrentTime = 1;
	}
	this->m_dwLastUpdateServerStatusTime = dwCurrentTime;


	//
	// Turn off the 'device changed' and 'port registered' flags, if they were
	// on.
	//
	this->m_dwFlags &= ~(NATHELPUPNPOBJ_DEVICECHANGED | NATHELPUPNPOBJ_PORTREGISTERED);


	//
	// Locate any new UPnP devices.
	//
	if (this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP)
	{
		//
		// We're not listening on the UPnP multicast address and can't hear
		// unsolicited new device announcements.  In order to detect new
		// devices, we need to resend the discovery request periodically so
		// that responses get sent directly to our listening socket.
		//
		hr = this->CheckForUPnPAnnouncements(g_dwUPnPAnnounceResponseWaitTime,
											fSendRemoteGatewayDiscovery);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't check for UPnP announcements!");
			goto Failure;
		}
	}
	else
	{
		//
		// Not using UPnP.
		//
	}


	//
	// Loop through all the devices.
	//
	pBilink = this->m_blDevices.GetNext();
	while (pBilink != &this->m_blDevices)
	{
		DNASSERT(! pBilink->IsEmpty());
		pDevice = DEVICE_FROM_BILINK(pBilink);


		//
		// This might be a new device, so register any ports with this address
		// that were previously unowned (because this device's address was
		// unknown at the time).
		//
		hr = this->RegisterPreviouslyUnownedPortsWithDevice(pDevice, FALSE);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't register previously unowned ports with device 0x%p!.",
				pDevice);
			goto Failure;
		}


#ifndef DPNBUILD_NOHNETFWAPI
		if (this->m_dwFlags & NATHELPUPNPOBJ_USEHNETFWAPI)
		{
			//
			// See if the local firewall state has changed.
			//
			hr = this->CheckForLocalHNetFirewallAndMapPorts(pDevice, NULL);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't check for local HNet firewall and map ports (err = 0x%lx)!  Ignoring.",
					hr);
				DNASSERT(! pDevice->IsHNetFirewalled());
				hr = DPNH_OK;
			}


			//
			// If there's a local firewall, remember the device if it's the
			// first one we've found.
			//
			if ((pDevice->IsHNetFirewalled()) &&
				(pDeviceLocalHNetFirewall == NULL))
			{
				pDeviceLocalHNetFirewall = pDevice;
			}
		}
		else
		{
			//
			// Not using firewall traversal.
			//
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		if (this->m_dwFlags & NATHELPUPNPOBJ_USEUPNP)
		{
			pUPnPDevice = pDevice->GetUPnPDevice();
			if (pUPnPDevice != NULL)
			{
				//
				// GetUPnPDevice did not add a reference to pUPnPDevice for us.
				//
				pUPnPDevice->AddRef();


				//
				// Update the public addresses for the UPnP device, if any.
				//
				hr = this->UpdateUPnPExternalAddress(pUPnPDevice, TRUE);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Failed updating UPnP device external address!");

					//
					// It may have been cleared already, but doing it twice
					// shouldn't be harmful.
					//
					this->ClearDevicesUPnPDevice(pDevice);

					hr = DPNH_OK;
				}
				else
				{
					//
					// Save this UPnP device, if it's the first one we've
					// found and it's not local.
					//
					if ((pDeviceRemoteUPnPGateway == NULL) &&
						(! pUPnPDevice->IsLocal()))
					{
						pDeviceRemoteUPnPGateway = pDevice;
					}
				}

				pUPnPDevice->DecRef();
				pUPnPDevice = NULL;
			}
			else
			{
				//
				// No UPnP device.
				//
			}
		}
		else
		{
			//
			// Not using UPnP.
			//
		}

		pBilink = pBilink->GetNext();
	}


	//
	// Some new servers may have come online.  If so, we can now map wildcard
	// ports that were registered previously.  Figure out which device that is.
	//
	if (pDeviceRemoteUPnPGateway != NULL)
	{
		pDevice = pDeviceRemoteUPnPGateway;
	}
#ifndef DPNBUILD_NOHNETFWAPI
	else if (pDeviceLocalHNetFirewall != NULL)
	{
		pDevice = pDeviceLocalHNetFirewall;
	}
#endif // ! DPNBUILD_NOHNETFWAPI
	else
	{
		pDevice = NULL;
	}

	if (pDevice != NULL)
	{
		//
		// Register any wildcard ports that are unowned with this best device.
		//
		hr = this->RegisterPreviouslyUnownedPortsWithDevice(pDevice, TRUE);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't register unowned wildcard ports with device 0x%p!.",
				pDevice);
			goto Failure;
		}
	}
#ifdef DBG
	else
	{
		DPFX(DPFPREP, 7, "No devices have a UPnP gateway device or a local HomeNet firewall.");
	}
#endif // DBG


	DPFX(DPFPREP, 7, "Spent %u ms updating server status, starting at %u.",
		(GETTIMESTAMP() - dwCurrentTime), dwCurrentTime);


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::UpdateServerStatus





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::RegisterPreviouslyUnownedPortsWithDevice"
//=============================================================================
// CNATHelpUPnP::RegisterPreviouslyUnownedPortsWithDevice
//-----------------------------------------------------------------------------
//
// Description:    Associates unknown ports with the given device, and
//				registers them with the device's UPnP device or firewall.
//
//				   If fWildcardToo is FALSE, only previously unowned ports that
//				match the device's address are associated.  If TRUE, unowned
//				INADDR_ANY ports are associated as well.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice	- Pointer to device to take ownership of ports.
//	BOOL fAll			- Whether all ports should be associated.
//
// Returns: HRESULT
//	DPNH_OK				- The extension was successful.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::RegisterPreviouslyUnownedPortsWithDevice(CDevice * const pDevice,
																const BOOL fWildcardToo)
{
	HRESULT				hr = DPNH_OK;
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;
	SOCKADDR_IN *		pasaddrinPrivate;
	CUPnPDevice *		pUPnPDevice;
#ifdef DBG
	BOOL				fAssignedPort = FALSE;
	IN_ADDR				inaddrTemp;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
		this, pDevice, fWildcardToo);


	//
	// Loop through all unowned ports, assign them to the device if
	// appropriate, then register them.
	//
	pBilink = this->m_blUnownedPorts.GetNext();
	while (pBilink != &this->m_blUnownedPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
		pBilink = pBilink->GetNext();

		//
		// The registered port must match the device's address in order to
		// associate them.  If wildcards are allowed, then INADDR_ANY
		// registrations can be associated, too.
		//
		//
		// All addresses should be same (if there are more than one), so just
		// compare the first one in the array.
		//
		pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

		if (pasaddrinPrivate[0].sin_addr.S_un.S_addr != pDevice->GetLocalAddressV4())
		{
			if (pasaddrinPrivate[0].sin_addr.S_un.S_addr != INADDR_ANY)
			{
				DPFX(DPFPREP, 7, "Unowned registered port 0x%p private address %u.%u.%u.%u doesn't match device 0x%p's, skipping.",
					pRegisteredPort,
					pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b1,
					pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b2,
					pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b3,
					pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b4,
					pDevice);
				continue;
			}
			
#ifdef DBG
			inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();
#endif // DBG

			if (! fWildcardToo)
			{
#ifdef DBG
				DPFX(DPFPREP, 7, "Unowned registered port 0x%p (INADDR_ANY) not allowed to be associated with device 0x%p (address %u.%u.%u.%u), skipping.",
					pRegisteredPort,
					pDevice,
					inaddrTemp.S_un.S_un_b.s_b1,
					inaddrTemp.S_un.S_un_b.s_b2,
					inaddrTemp.S_un.S_un_b.s_b3,
					inaddrTemp.S_un.S_un_b.s_b4);
#endif // DBG

				continue;
			}

#ifdef DBG
			DPFX(DPFPREP, 7, "Unowned registered port 0x%p (INADDR_ANY) becoming associated with device 0x%p (address %u.%u.%u.%u).",
				pRegisteredPort,
				pDevice,
				inaddrTemp.S_un.S_un_b.s_b1,
				inaddrTemp.S_un.S_un_b.s_b2,
				inaddrTemp.S_un.S_un_b.s_b3,
				inaddrTemp.S_un.S_un_b.s_b4);
#endif // DBG
		}
		else
		{
			DPFX(DPFPREP, 7, "Unowned registered port 0x%p private address %u.%u.%u.%u matches device 0x%p's, associating.",
				pRegisteredPort,
				pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b1,
				pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b2,
				pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b3,
				pasaddrinPrivate[0].sin_addr.S_un.S_un_b.s_b4,
				pDevice);

			//
			// The way it's currently implemented, all non-wildcard ports
			// should be registered before we even try to register the wildcard
			// ones.
			//
			DNASSERT(! fWildcardToo);
		}


		//
		// If we made it here, we can associate the port with the device.
		//


		pRegisteredPort->m_blDeviceList.RemoveFromList();
		pRegisteredPort->MakeDeviceOwner(pDevice);



#ifndef DPNBUILD_NOHNETFWAPI
		//
		// Start by automatically mapping with the local firewall, if there is
		// one and we're allowed.
		//
		if (this->m_dwFlags & NATHELPUPNPOBJ_USEHNETFWAPI)
		{
			hr = this->CheckForLocalHNetFirewallAndMapPorts(pDevice, NULL);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't check for local HNet firewall and map ports (err = 0x%lx)!  Ignoring.",
					hr);
				DNASSERT(! pDevice->IsHNetFirewalled());
				hr = DPNH_OK;
			}
		}
		else
		{
			//
			// Not using firewall traversal.
			//
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		//
		// Attempt to automatically map it with the (new) UPnP gateway device,
		// if present.
		//
		pUPnPDevice = pDevice->GetUPnPDevice();
		if (pUPnPDevice != NULL)
		{
			//
			// GetUPnPDevice did not add a reference to pUPnPDevice for us.
			//
			pUPnPDevice->AddRef();


			DNASSERT(pUPnPDevice->IsReady());


			hr = this->MapPortsOnUPnPDevice(pUPnPDevice, pRegisteredPort);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't map existing ports on UPnP device 0x%p!",
					pUPnPDevice);

				//
				// It may have been cleared already, but doing it twice
				// shouldn't be harmful.
				//
				this->ClearDevicesUPnPDevice(pDevice);

				hr = DPNH_OK;
			}

			pUPnPDevice->DecRef();
			pUPnPDevice = NULL;
		}
	}


#ifdef DBG
	if (! fAssignedPort)
	{
		DPFX(DPFPREP, 1, "No unowned ports were bound to device object 0x%p.",
			pDevice);
	}
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;
} // CNATHelpUPnP::RegisterPreviouslyUnownedPortsWithDevice




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SendUPnPSearchMessagesForDevice"
//=============================================================================
// CNATHelpUPnP::SendUPnPSearchMessagesForDevice
//-----------------------------------------------------------------------------
//
// Description:    Sends one UPnP search message via the given device locally
//				and if fRemoteAllowed is TRUE, to the multicast or gateway
//				address.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice		- Pointer to device to use.
//	BOOL fRemoteAllowed		- Whether we can search remotely or not.
//
// Returns: HRESULT
//	DPNH_OK				- The messages were sent successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::SendUPnPSearchMessagesForDevice(CDevice * const pDevice,
													const BOOL fRemoteAllowed)
{
	HRESULT			hr = DPNH_OK;
	SOCKADDR_IN		saddrinRemote;
	SOCKADDR_IN		saddrinLocal;
	BOOL			fTryRemote;
	int				iWANIPConnectionMsgSize;
	int				iWANPPPConnectionMsgSize;
	int				iReturn;
	SOCKET			sTemp = INVALID_SOCKET;
#ifdef DBG
	DWORD			dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)", this, pDevice, fRemoteAllowed);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);
	DNASSERT(pDevice->GetUPnPDiscoverySocket() != INVALID_SOCKET);


	ZeroMemory(&saddrinRemote, sizeof(saddrinRemote));
	saddrinRemote.sin_family				= AF_INET;
	//saddrinRemote.sin_addr.S_un.S_addr		= ?
	saddrinRemote.sin_port					= HTONS(UPNP_PORT);


	//
	// If we're allowed to try remotely, use the gateway's address, or the
	// multicast address, as appropriate.
	//
	if ((fRemoteAllowed) && (! pDevice->GotRemoteUPnPDiscoveryConnReset()))
	{
		if (g_fUseMulticastUPnPDiscovery)
		{
			saddrinRemote.sin_addr.S_un.S_addr	= this->m_pfninet_addr(UPNP_DISCOVERY_MULTICAST_ADDRESS);
			fTryRemote = TRUE;
		}
		else
		{
			//
			// Try to get the device's gateway's address.  This might return FALSE
			// if the device does not have a gateway.  In that case, we will ignore
			// the device.  Otherwise the address should be filled in with the
			// gateway or broadcast address.
			//
			fTryRemote = this->GetAddressToReachGateway(pDevice,
														&saddrinRemote.sin_addr);
		}
	}
	else
	{
		fTryRemote = FALSE;
	}

	ZeroMemory(&saddrinLocal, sizeof(saddrinLocal));
	saddrinLocal.sin_family					= AF_INET;
	saddrinLocal.sin_addr.S_un.S_addr		= pDevice->GetLocalAddressV4();
	saddrinLocal.sin_port					= HTONS(UPNP_PORT);


	//
	// Note that these message strings contain:
	//
	//	HOST: multicast_addr:port
	//
	// even though we send the messages to addresses other than the multicast
	// address.  It shouldn't matter.
	//
	iWANIPConnectionMsgSize = strlen(c_szUPnPMsg_Discover_Service_WANIPConnection);
	iWANPPPConnectionMsgSize = strlen(c_szUPnPMsg_Discover_Service_WANPPPConnection);


#ifdef DBG
	this->PrintUPnPTransactionToFile(c_szUPnPMsg_Discover_Service_WANIPConnection,
									iWANIPConnectionMsgSize,
									"Outbound WANIPConnection discovery messages",
									pDevice);


	this->PrintUPnPTransactionToFile(c_szUPnPMsg_Discover_Service_WANPPPConnection,
									iWANPPPConnectionMsgSize,
									"Outbound WANPPPConnection discovery messages",
									pDevice);
#endif // DBG


	DNASSERT(pDevice->GetUPnPDiscoverySocket() != INVALID_SOCKET);


	//
	// First, fire off messages to the remote gateway, if possible.
	//
	if (fTryRemote)
	{
		DPFX(DPFPREP, 7, "Sending UPnP discovery messages (WANIPConnection and WANPPPConnection) to gateway/multicast %u.%u.%u.%u:%u via device 0x%p.",
			saddrinRemote.sin_addr.S_un.S_un_b.s_b1,
			saddrinRemote.sin_addr.S_un.S_un_b.s_b2,
			saddrinRemote.sin_addr.S_un.S_un_b.s_b3,
			saddrinRemote.sin_addr.S_un.S_un_b.s_b4,
			NTOHS(saddrinRemote.sin_port),
			pDevice);


		//
		// Remember that we're trying remotely.
		//
		pDevice->NotePerformingRemoteUPnPDiscovery();

		//
		// Remember the current time, if this is the first thing we've sent
		// from this port.
		//
		if (pDevice->GetFirstUPnPDiscoveryTime() == 0)
		{
			pDevice->SetFirstUPnPDiscoveryTime(GETTIMESTAMP());
		}


		//
		// Multicast/send to gateway a WANIPConnection discovery message.
		//
		iReturn = this->m_pfnsendto(pDevice->GetUPnPDiscoverySocket(),
									c_szUPnPMsg_Discover_Service_WANIPConnection,
									iWANIPConnectionMsgSize,
									0,
									(SOCKADDR*) (&saddrinRemote),
									sizeof(saddrinRemote));

		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u when sending WANIPConnection discovery to UPnP gateway/multicast address on device 0x%p!  Ignoring.",
				dwError, pDevice);
#endif // DBG

			//
			// It's possible that we caught WinSock at a bad time,
			// particularly with WSAEADDRNOTAVAIL (10049), which seems to
			// occur if the address is going away (and we haven't detected
			// it in CheckForNewDevices yet).
			//
			// Ignore the error, we can survive.
			//
		}
		else
		{
			if (iReturn != iWANIPConnectionMsgSize)
			{
				DPFX(DPFPREP, 0, "Didn't multicast send entire WANIPConnection discovery datagram on device 0x%p (%i != %i)?!",
					pDevice, iReturn, iWANIPConnectionMsgSize);
				DNASSERT(FALSE);
				hr = DPNHERR_GENERIC;
				goto Failure;
			}
		}



		//
		// Multicast/send to gateway a WANPPPConnection discovery message.
		//
		iReturn = this->m_pfnsendto(pDevice->GetUPnPDiscoverySocket(),
									c_szUPnPMsg_Discover_Service_WANPPPConnection,
									iWANPPPConnectionMsgSize,
									0,
									(SOCKADDR*) (&saddrinRemote),
									sizeof(saddrinRemote));

		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u when sending WANPPPConnection discovery to UPnP multicast/gateway address on device 0x%p!  Ignoring.",
				dwError, pDevice);
#endif // DBG

			//
			// It's possible that we caught WinSock at a bad time,
			// particularly with WSAEADDRNOTAVAIL (10049), which seems to
			// occur if the address is going away (and we haven't detected
			// it in CheckForNewDevices yet).
			//
			// Ignore the error, we can survive.
			//
		}
		else
		{
			if (iReturn != iWANPPPConnectionMsgSize)
			{
				DPFX(DPFPREP, 0, "Didn't multicast send entire WANPPPConnection discovery datagram on device 0x%p (%i != %i)?!",
					pDevice, iReturn, iWANPPPConnectionMsgSize);
				DNASSERT(FALSE);
				hr = DPNHERR_GENERIC;
				goto Failure;
			}
		}
	}
	else
	{
		DPFX(DPFPREP, 2, "Device 0x%p should not attempt to reach a remote gateway.",
			pDevice);


		//
		// Remember that we're not trying remotely.
		//
		pDevice->NoteNotPerformingRemoteUPnPDiscovery();
	}


	//
	// If we didn't already get a CONNRESET from a previous attempt, try to
	// bind a socket locally to the UPnP discovery port.  If it's not in use,
	// then we know nobody will be listening so there's no point in trying the
	// local address.  If it is in use, then this computer might be a UPnP
	// gateway itself.
	//
	if (! pDevice->GotLocalUPnPDiscoveryConnReset())
	{
		sTemp = this->m_pfnsocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
		if (sTemp == INVALID_SOCKET)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't create temporary datagram socket, error = %u!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		if (this->m_pfnbind(sTemp,
							(SOCKADDR *) (&saddrinLocal),
							sizeof(saddrinLocal)) != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 2, "Couldn't bind socket to UPnP discovery port (%u.%u.%u.%u:%u), assuming local device (error = %u).",
				saddrinLocal.sin_addr.S_un.S_un_b.s_b1,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b2,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b3,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b4,
				NTOHS(saddrinLocal.sin_port),
				dwError);
#endif // DBG


			//
			// Remember that we're trying locally.
			//
			pDevice->NotePerformingLocalUPnPDiscovery();

			//
			// Remember the current time, if this is the first thing we've sent
			// from this port.
			//
			if (pDevice->GetFirstUPnPDiscoveryTime() == 0)
			{
				pDevice->SetFirstUPnPDiscoveryTime(GETTIMESTAMP());
			}


			//
			// Do WANIPConnection first.
			//

			DPFX(DPFPREP, 7, "Sending UPnP discovery messages (WANIPConnection and WANPPPConnection) locally to device 0x%p (address %u.%u.%u.%u:%u).",
				pDevice,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b1,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b2,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b3,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b4,
				NTOHS(saddrinLocal.sin_port));



			iReturn = this->m_pfnsendto(pDevice->GetUPnPDiscoverySocket(),
										c_szUPnPMsg_Discover_Service_WANIPConnection,
										iWANIPConnectionMsgSize,
										0,
										(SOCKADDR*) (&saddrinLocal),
										sizeof(saddrinLocal));

			if (iReturn == SOCKET_ERROR)
			{
#ifdef DBG
				dwError = this->m_pfnWSAGetLastError();
				DPFX(DPFPREP, 0, "Got sockets error %u when sending WANIPConnection discovery to local address on device 0x%p!  Ignoring.",
					dwError, pDevice);
#endif // DBG

				//
				// It's possible that we caught WinSock at a bad time,
				// particularly with WSAEADDRNOTAVAIL (10049), which seems to
				// occur if the address is going away (and we haven't detected
				// it in CheckForNewDevices yet).
				//
				// Ignore the error, we can survive.
				//
			}
			else
			{
				if (iReturn != iWANIPConnectionMsgSize)
				{
					DPFX(DPFPREP, 0, "Didn't send entire WANIPConnection discovery datagram locally on device 0x%p (%i != %i)?!",
						pDevice, iReturn, iWANIPConnectionMsgSize);
					DNASSERT(FALSE);
					hr = DPNHERR_GENERIC;
					goto Failure;
				}
			}


			//
			// Now send WANPPPConnection discovery message locally.
			//
			iReturn = this->m_pfnsendto(pDevice->GetUPnPDiscoverySocket(),
										c_szUPnPMsg_Discover_Service_WANPPPConnection,
										iWANPPPConnectionMsgSize,
										0,
										(SOCKADDR*) (&saddrinLocal),
										sizeof(saddrinLocal));

			if (iReturn == SOCKET_ERROR)
			{
#ifdef DBG
				dwError = this->m_pfnWSAGetLastError();
				DPFX(DPFPREP, 0, "Got sockets error %u when sending WANPPPConnection discovery to local address on device 0x%p!  Ignoring.",
					dwError, pDevice);
#endif // DBG

				//
				// It's possible that we caught WinSock at a bad time,
				// particularly with WSAEADDRNOTAVAIL (10049), which seems to
				// occur if the address is going away (and we haven't detected
				// it in CheckForNewDevices yet).
				//
				// Ignore the error, we can survive.
				//
			}
			else
			{
				if (iReturn != iWANPPPConnectionMsgSize)
				{
					DPFX(DPFPREP, 0, "Didn't send entire WANPPPConnection discovery datagram locally on device 0x%p (%i != %i)?!",
						pDevice, iReturn, iWANPPPConnectionMsgSize);
					DNASSERT(FALSE);
					hr = DPNHERR_GENERIC;
					goto Failure;
				}
			}
		}
		else
		{
			DPFX(DPFPREP, 2, "Successfully bound socket to UPnP discovery port (%u.%u.%u.%u:%u), assuming no local UPnP device.",
				saddrinLocal.sin_addr.S_un.S_un_b.s_b1,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b2,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b3,
				saddrinLocal.sin_addr.S_un.S_un_b.s_b4,
				NTOHS(saddrinLocal.sin_port));

			//
			// Remember that we're not trying locally.
			//
			pDevice->NoteNotPerformingLocalUPnPDiscovery();
		}
	}
	else
	{
		//
		// We got a CONNRESET last time.
		//
	}


Exit:

	if (sTemp != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(sTemp);
		sTemp = INVALID_SOCKET;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::SendUPnPSearchMessagesForDevice





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::SendUPnPDescriptionRequest"
//=============================================================================
// CNATHelpUPnP::SendUPnPDescriptionRequest
//-----------------------------------------------------------------------------
//
// Description:    Requests a description from the given UPnP device.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device to use.
//
// Returns: HRESULT
//	DPNH_OK				- The message was sent successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::SendUPnPDescriptionRequest(CUPnPDevice * const pUPnPDevice)
{
	HRESULT			hr = DPNH_OK;
	SOCKADDR_IN *	psaddrinHost;
	TCHAR			tszHost[22]; // "xxx.xxx.xxx.xxx:xxxxx" + NULL termination
	char *			pszMessage = NULL;
	int				iMsgSize;
	int				iReturn;
#ifdef DBG
	DWORD			dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pUPnPDevice);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);
	DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);
	DNASSERT(pUPnPDevice->IsConnected());
	DNASSERT(pUPnPDevice->GetLocationURL() != NULL);


	psaddrinHost = pUPnPDevice->GetHostAddress();

	wsprintf(tszHost, _T("%u.%u.%u.%u:%u"),
		psaddrinHost->sin_addr.S_un.S_un_b.s_b1,
		psaddrinHost->sin_addr.S_un.S_un_b.s_b2,
		psaddrinHost->sin_addr.S_un.S_un_b.s_b3,
		psaddrinHost->sin_addr.S_un.S_un_b.s_b4,
		NTOHS(psaddrinHost->sin_port));

	iMsgSize = strlen("GET ") + strlen(pUPnPDevice->GetLocationURL()) + strlen(" " HTTP_VERSION EOL)
				+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
				+ strlen("ACCEPT-LANGUAGE: en" EOL)
				+ strlen(EOL);


	pszMessage = (char*) DNMalloc(iMsgSize + 1); // include room for NULL termination that isn't actually sent
	if (pszMessage == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	strcpy(pszMessage, "GET ");
	strcat(pszMessage, pUPnPDevice->GetLocationURL());
	strcat(pszMessage, " " HTTP_VERSION EOL);
	strcat(pszMessage, "HOST: ");
#ifdef UNICODE
	STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
					tszHost,
					(_tcslen(tszHost) + 1));
#else // ! UNICODE
	strcat(pszMessage, tszHost);
#endif // ! UNICODE
	strcat(pszMessage, EOL);
	strcat(pszMessage, "ACCEPT-LANGUAGE: en" EOL);
	strcat(pszMessage, EOL);


#ifdef DBG
	this->PrintUPnPTransactionToFile(pszMessage,
									iMsgSize,
									"Outbound description request",
									pUPnPDevice->GetOwningDevice());
#endif // DBG

	iReturn = this->m_pfnsend(pUPnPDevice->GetControlSocket(),
								pszMessage,
								iMsgSize,
								0);

	if (iReturn == SOCKET_ERROR)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Got sockets error %u when sending to UPnP device!", dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if (iReturn != iMsgSize)
	{
		DPFX(DPFPREP, 0, "Didn't send entire message (%i != %i)?!", iReturn, iMsgSize);
		DNASSERT(FALSE);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}



Exit:

	if (pszMessage != NULL)
	{
		DNFree(pszMessage);
		pszMessage = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::SendUPnPDescriptionRequest





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UpdateUPnPExternalAddress"
//=============================================================================
// CNATHelpUPnP::UpdateUPnPExternalAddress
//-----------------------------------------------------------------------------
//
// Description:    Retreives the current external address for the given UPnP
//				Internet Gateway Device.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device that should be
//									updated.
//	BOOL fUpdateRegisteredPorts	- TRUE if existing registered ports should be
//									updated to reflect the new address if it
//									changed, FALSE if not.
//
// Returns: HRESULT
//	DPNH_OK							- The update was successful.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_SERVERNOTRESPONDING		- The server did not respond to the
//										message.
//=============================================================================
HRESULT CNATHelpUPnP::UpdateUPnPExternalAddress(CUPnPDevice * const pUPnPDevice,
												  const BOOL fUpdateRegisteredPorts)
{
	HRESULT						hr;
	BOOL						fStartedWaitingForControlResponse = FALSE;
	CDevice *					pDevice;
	SOCKADDR_IN *				psaddrinTemp;
	int							iContentLength;
	TCHAR						tszContentLength[32];
	TCHAR						tszHost[22]; // "xxx.xxx.xxx.xxx:xxxxx" + NULL termination
	char *						pszMessage = NULL;
	int							iMsgSize;
	int							iPrevMsgSize = 0;
	int							iReturn;
	UPNP_CONTROLRESPONSE_INFO	RespInfo;
	DWORD						dwStartTime;
	DWORD						dwTimeout;
	CBilink *					pBilink;
	CRegisteredPort *			pRegisteredPort;
#ifdef DBG
	DWORD						dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
		this, pUPnPDevice, fUpdateRegisteredPorts);


	DNASSERT(pUPnPDevice != NULL);
	DNASSERT(pUPnPDevice->IsReady());

	pDevice = pUPnPDevice->GetOwningDevice();
	DNASSERT(pDevice != NULL);


	DNASSERT(this->m_dwFlags & (NATHELPUPNPOBJ_INITIALIZED | NATHELPUPNPOBJ_USEUPNP));

	DNASSERT(pUPnPDevice->GetServiceControlURL() != NULL);

	//
	// If the control socket got disconnected after the last message, then
	// reconnect.
	//
	if (! pUPnPDevice->IsConnected())
	{
		hr = this->ReconnectUPnPControlSocket(pUPnPDevice);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't reconnect UPnP control socket!");
			goto Failure;
		}
	}

	DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);



	psaddrinTemp = pUPnPDevice->GetHostAddress();
	wsprintf(tszHost, _T("%u.%u.%u.%u:%u"),
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b1,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b2,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b3,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(psaddrinTemp->sin_port));


	/*
	iContentLength = strlen("<s:Envelope" EOL)
					+ strlen("    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL)
					+ strlen("    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL)
					+ strlen("  <s:Body>" EOL)
					+ strlen("    <u:" CONTROL_QUERYSTATEVARIABLE_A " xmlns:u=\"" URI_CONTROL_A "\">" EOL)
					+ strlen("      <u:" ARG_CONTROL_VARNAME_A ">" VAR_EXTERNALIPADDRESS_A "</u:" ARG_CONTROL_VARNAME_A ">" EOL)
					+ strlen("    </u:" CONTROL_QUERYSTATEVARIABLE_A ">" EOL)
					+ strlen("  </s:Body>" EOL)
					+ strlen("</s:Envelope>" EOL)
					+ strlen(EOL);

	wsprintf(tszContentLength, _T("%i"), iContentLength);

	iMsgSize = strlen("POST ") + strlen(pUPnPDevice->GetServiceControlURL()) + strlen(" " HTTP_VERSION EOL)
				+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
				+ strlen("CONTENT-LENGTH: ") + strlen(szContentLength) + strlen(EOL)
				+ strlen("CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL)
				+ strlen("SOAPACTION: " URI_CONTROL_A "#" CONTROL_QUERYSTATEVARIABLE_A "" EOL)
				+ strlen(EOL)
				+ iContentLength;
	*/
	iContentLength = strlen("<s:Envelope" EOL)
					+ strlen("    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL)
					+ strlen("    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL)
					+ strlen("  <s:Body>" EOL)
					+ strlen("    <u:" ACTION_GETEXTERNALIPADDRESS_A " xmlns:u=\"") + pUPnPDevice->GetStaticServiceURILength() + strlen("\">" EOL)
					+ strlen("    </u:" ACTION_GETEXTERNALIPADDRESS_A ">" EOL)
					+ strlen("  </s:Body>" EOL)
					+ strlen("</s:Envelope>" EOL)
					+ strlen(EOL);

	wsprintf(tszContentLength, _T("%i"), iContentLength);

	iMsgSize = strlen("POST ") + strlen(pUPnPDevice->GetServiceControlURL()) + strlen(" " HTTP_VERSION EOL)
				+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
				+ strlen("CONTENT-LENGTH: ") + _tcslen(tszContentLength) + strlen(EOL)
				+ strlen("CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL)
				+ strlen("SOAPACTION: ") + pUPnPDevice->GetStaticServiceURILength() + strlen("#" ACTION_GETEXTERNALIPADDRESS_A EOL)
				+ strlen(EOL)
				+ iContentLength;


	//
	// Allocate (or reallocate) the message buffer.
	//
	if (iMsgSize > iPrevMsgSize)
	{
		if (pszMessage != NULL)
		{
			DNFree(pszMessage);
			pszMessage = NULL;
		}

		pszMessage = (char*) DNMalloc(iMsgSize + 1); // include room for NULL termination that isn't actually sent
		if (pszMessage == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		iPrevMsgSize = iMsgSize;
	}

	/*
	strcpy(pszMessage, "POST ");
	strcat(pszMessage, pUPnPDevice->GetServiceControlURL());
	strcat(pszMessage, " " HTTP_VERSION EOL);
	strcat(pszMessage, "HOST: ");
#ifdef UNICODE
	STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
					tszHost,
					(_tcslen(tszHost) + 1));
#else // ! UNICODE
	strcat(pszMessage, tszHost);
#endif // ! UNICODE
	strcat(pszMessage, EOL);
	strcat(pszMessage, "CONTENT-LENGTH: ");
#ifdef UNICODE
	STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
					tszContentLength,
					(_tcslen(tszContentLength) + 1));
#else // ! UNICODE
	strcat(pszMessage, tszContentLength);
#endif // ! UNICODE
	strcat(pszMessage, EOL);
	strcat(pszMessage, "CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL);
	strcat(pszMessage, "SOAPACTION: " URI_CONTROL_A "#" CONTROL_QUERYSTATEVARIABLE_A "" EOL);
	strcat(pszMessage, EOL);


	strcat(pszMessage, "<s:Envelope" EOL);
	strcat(pszMessage, "    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL);
	strcat(pszMessage, "    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL);
	strcat(pszMessage, "  <s:Body>" EOL);
	strcat(pszMessage, "    <u:" CONTROL_QUERYSTATEVARIABLE_A " xmlns:u=\"" URI_CONTROL_A "\">" EOL);
	strcat(pszMessage, "      <u:" ARG_CONTROL_VARNAME_A ">" VAR_EXTERNALIPADDRESS_A "</u:" ARG_CONTROL_VARNAME_A ">" EOL);
	strcat(pszMessage, "    </u:" CONTROL_QUERYSTATEVARIABLE_A ">" EOL);
	strcat(pszMessage, "  </s:Body>" EOL);
	strcat(pszMessage, "</s:Envelope>" EOL);
	strcat(pszMessage, EOL);
	*/
	strcpy(pszMessage, "POST ");
	strcat(pszMessage, pUPnPDevice->GetServiceControlURL());
	strcat(pszMessage, " " HTTP_VERSION EOL);
	strcat(pszMessage, "HOST: ");
#ifdef UNICODE
	STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
					tszHost,
					(_tcslen(tszHost) + 1));
#else // ! UNICODE
	strcat(pszMessage, tszHost);
#endif // ! UNICODE
	strcat(pszMessage, EOL);
	strcat(pszMessage, "CONTENT-LENGTH: ");
#ifdef UNICODE
	STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
					tszContentLength,
					(_tcslen(tszContentLength) + 1));
#else // ! UNICODE
	strcat(pszMessage, tszContentLength);
#endif // ! UNICODE
	strcat(pszMessage, EOL);
	strcat(pszMessage, "CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL);
	strcat(pszMessage, "SOAPACTION: ");
	strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
	strcat(pszMessage, "#" ACTION_GETEXTERNALIPADDRESS_A EOL);
	strcat(pszMessage, EOL);


	strcat(pszMessage, "<s:Envelope" EOL);
	strcat(pszMessage, "    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL);
	strcat(pszMessage, "    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL);
	strcat(pszMessage, "  <s:Body>" EOL);
	strcat(pszMessage, "    <u:" ACTION_GETEXTERNALIPADDRESS_A " xmlns:u=\"");
	strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
	strcat(pszMessage, "\">" EOL);
	strcat(pszMessage, "    </u:" ACTION_GETEXTERNALIPADDRESS_A ">" EOL);
	strcat(pszMessage, "  </s:Body>" EOL);
	strcat(pszMessage, "</s:Envelope>" EOL);
	strcat(pszMessage, EOL);


#ifdef DBG
	this->PrintUPnPTransactionToFile(pszMessage,
									iMsgSize,
									//"Outbound query external IP address",
									"Outbound get external IP address",
									pDevice);
#endif // DBG

	iReturn = this->m_pfnsend(pUPnPDevice->GetControlSocket(),
								pszMessage,
								iMsgSize,
								0);

	if (iReturn == SOCKET_ERROR)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Got sockets error %u when sending control request to UPnP device!", dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	if (iReturn != iMsgSize)
	{
		DPFX(DPFPREP, 0, "Didn't send entire message (%i != %i)?!", iReturn, iMsgSize);
		DNASSERT(FALSE);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}

	//
	// We have the lock so no one could have tried to receive data from the
	// control socket yet.  Mark the device as waiting for a response.
	//
	ZeroMemory(&RespInfo, sizeof(RespInfo));
	//pUPnPDevice->StartWaitingForControlResponse(CONTROLRESPONSETYPE_QUERYSTATEVARIABLE_EXTERNALIPADDRESS,
	pUPnPDevice->StartWaitingForControlResponse(CONTROLRESPONSETYPE_GETEXTERNALIPADDRESS,
												&RespInfo);
	fStartedWaitingForControlResponse = TRUE;


	//
	// Actually wait for the response.
	//
	dwStartTime = GETTIMESTAMP();
	dwTimeout = g_dwUPnPResponseTimeout;
	do
	{
		hr = this->CheckForReceivedUPnPMsgsOnDevice(pUPnPDevice, dwTimeout);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed receiving UPnP messages!");
			goto Failure;
		}

		//
		// We either timed out or got some data.  Check if we got a
		// response of some type.
		//
		if (! pUPnPDevice->IsWaitingForControlResponse())
		{
			break;
		}


		//
		// Make sure our device is still connected.
		//
		if (! pUPnPDevice->IsConnected())
		{
			DPFX(DPFPREP, 0, "UPnP device 0x%p disconnected while retrieving external IP address!",
				pUPnPDevice);
				
			pUPnPDevice->StopWaitingForControlResponse();
				
			hr = DPNHERR_SERVERNOTRESPONDING;
			goto Failure;
		}


		//
		// Calculate how long we have left to wait.  If the calculation
		// goes negative, it means we're done.
		//
		dwTimeout = g_dwUPnPResponseTimeout - (GETTIMESTAMP() - dwStartTime);
	}
	while (((int) dwTimeout > 0));


	//
	// If we never got the response, stop waiting for it.
	//
	if (pUPnPDevice->IsWaitingForControlResponse())
	{
		pUPnPDevice->StopWaitingForControlResponse();

		DPFX(DPFPREP, 0, "Server didn't respond in time!");
		hr = DPNHERR_SERVERNOTRESPONDING;
		goto Failure;
	}


	//
	// If we're here, then we've gotten a valid response from the server.
	//
	if (RespInfo.hrErrorCode != DPNH_OK)
	{
		DPFX(DPFPREP, 1, "Server returned failure response 0x%lx when retrieving external IP address.",
			RespInfo.hrErrorCode);

		hr = RespInfo.hrErrorCode;
		goto Failure;
	}


	DPFX(DPFPREP, 1, "Server returned external IP address \"%u.%u.%u.%u\".",
		((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b1,
		((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b2,
		((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b3,
		((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b4);


	//
	// Convert the loopback address to the device address.
	//
	if (RespInfo.dwExternalIPAddressV4 == NETWORKBYTEORDER_INADDR_LOOPBACK)
	{
		RespInfo.dwExternalIPAddressV4 = pDevice->GetLocalAddressV4();

		DPFX(DPFPREP, 0, "Converted private loopback address to device address (%u.%u.%u.%u)!",
			((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b1,
			((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b2,
			((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b3,
			((IN_ADDR*) (&RespInfo.dwExternalIPAddressV4))->S_un.S_un_b.s_b4);

		DNASSERTX(! "Got loopback address as external IP address!", 2);
	}


#ifdef DBG
	//
	// If this is a local UPnP gateway, print out the device corresponding to
	// the public address.
	//
	if (pUPnPDevice->IsLocal())
	{
		if (RespInfo.dwExternalIPAddressV4 != 0)
		{
			CDevice *		pPublicDevice;


			//
			// Loop through every device.
			//
			pBilink = this->m_blDevices.GetNext();
			while (pBilink != &this->m_blDevices)
			{
				pPublicDevice = DEVICE_FROM_BILINK(pBilink);

				if (pPublicDevice->GetLocalAddressV4() == RespInfo.dwExternalIPAddressV4)
				{
					DPFX(DPFPREP, 7, "Local UPnP gateway 0x%p for device 0x%p's public address is device 0x%p.",
						pUPnPDevice, pDevice, pPublicDevice);
					break;
				}

				pBilink = pBilink->GetNext();
			}

			//
			// If we made it through the entire list without matching the device,
			// that's odd.  It's possible we're slow in detecting new devices, so
			// don't get bent out of shape.
			//
			if (pBilink == &this->m_blDevices)
			{
				DPFX(DPFPREP, 0, "Couldn't match up local UPnP gateway 0x%p (device 0x%p)'s public address to a device!",
					pUPnPDevice, pDevice);
				DNASSERTX(! "Couldn't match up local UPnP gateway public address to a device!", 2);
			}
		}
		else
		{
			DPFX(DPFPREP, 4, "Local UPnP gateway 0x%p (device 0x%p) does not have a valid public address.",
				pUPnPDevice, pDevice);
		}
	}
#endif // DBG


	//
	// If the public address has changed, update all the existing mappings.
	//
	if (RespInfo.dwExternalIPAddressV4 != pUPnPDevice->GetExternalIPAddressV4())
	{
		DPFX(DPFPREP, 1, "UPnP Internet Gateway Device (0x%p) external address changed.",
			pUPnPDevice);

		//
		// Since there was a change in the network, go back to polling
		// relatively quickly.
		//
		this->ResetNextPollInterval();


		//
		// Loop through all the existing registered ports and update their
		// public addresses, if allowed.
		//
		if (fUpdateRegisteredPorts)
		{
			pBilink = pDevice->m_blOwnedRegPorts.GetNext();
			while (pBilink != &pDevice->m_blOwnedRegPorts)
			{
				DNASSERT(! pBilink->IsEmpty());
				pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);

				if (! pRegisteredPort->IsUPnPPortUnavailable())
				{
					DPFX(DPFPREP, 7, "Updating registered port 0x%p's public address.",
						pRegisteredPort);
					
					pRegisteredPort->UpdateUPnPPublicV4Addresses(RespInfo.dwExternalIPAddressV4);

					//
					// The user should call GetCaps to detect the address change.
					//
					this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;
				}
				else
				{
					DPFX(DPFPREP, 7, "Not updating registered port 0x%p's public address because the port is unavailable.",
						pRegisteredPort);
				}

				pBilink = pBilink->GetNext();
			}
		}


		//
		// Store the new public address.
		//
		pUPnPDevice->SetExternalIPAddressV4(RespInfo.dwExternalIPAddressV4);
	}


Exit:

	if (pszMessage != NULL)
	{
		DNFree(pszMessage);
		pszMessage = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// If we started waiting for a response, clear that.
	//
	if (fStartedWaitingForControlResponse)
	{
		pUPnPDevice->StopWaitingForControlResponse();
	}

	goto Exit;
} // CNATHelpUPnP::UpdateUPnPExternalAddress





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::MapPortsOnUPnPDevice"
//=============================================================================
// CNATHelpUPnP::MapPortsOnUPnPDevice
//-----------------------------------------------------------------------------
//
// Description:    Maps the given ports on the given UPnP device.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice			- Pointer to UPnP device to use.
//	CRegisteredPort * pRegisteredPort	- Pointer to ports to register.
//
// Returns: HRESULT
//	DPNH_OK							- The message was sent successfully.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_SERVERNOTRESPONDING		- A response didn't arrive in time.
//=============================================================================
HRESULT CNATHelpUPnP::MapPortsOnUPnPDevice(CUPnPDevice * const pUPnPDevice,
											CRegisteredPort * const pRegisteredPort)
{
	HRESULT						hr = DPNH_OK;
	HRESULT						temphr;
	BOOL						fStartedWaitingForControlResponse = FALSE;
	CDevice *					pDevice;
	DWORD						dwLeaseExpiration;
	IN_ADDR						inaddrTemp;
	SOCKADDR_IN *				psaddrinTemp;
	WORD						wOriginalExternalPortHostOrder = 0;
	WORD						wExternalPortHostOrder;
	TCHAR						tszInternalPort[32];
	TCHAR						tszExternalPort[32];
	TCHAR						tszInternalClient[16]; // "xxx.xxx.xxx.xxx" + NULL termination
	TCHAR						tszLeaseDuration[32];
	TCHAR						tszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	int							iContentLength;
	TCHAR						tszContentLength[32];
	TCHAR						tszHost[22]; // "xxx.xxx.xxx.xxx:xxxxx" + NULL termination
	char *						pszMessage = NULL;
	int							iMsgSize;
	int							iPrevMsgSize = 0;
	int							iReturn;
	DWORD						dwTemp = 0;
	UPNP_CONTROLRESPONSE_INFO	RespInfo;
	DWORD						dwStartTime;
	DWORD						dwTimeout;
	BOOL						fFirstLease;
	DWORD						dwDescriptionLength;
#ifndef DPNBUILD_NOWINSOCK2
	BOOL						fResult;
#endif // ! DPNBUILD_NOWINSOCK2
#ifdef DBG
	DWORD						dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pUPnPDevice);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);
	DNASSERT(pUPnPDevice->IsReady());

	pDevice = pRegisteredPort->GetOwningDevice();

	DNASSERT(pDevice != NULL);
	DNASSERT(pUPnPDevice->GetOwningDevice() == pDevice);


	//
	// Set up variables we'll need.
	//
	DNASSERT(pUPnPDevice->GetServiceControlURL() != NULL);


	//
	// If the port is shared, register the broadcast address instead of the
	// local device address.
	//
	if (pRegisteredPort->IsSharedPort())
	{
		_tcscpy(tszInternalClient, _T("255.255.255.255"));
	}
	else
	{
		//
		// Note that the device address is not necessarily the same as the
		// address the user originally registered, particularly the 0.0.0.0
		// wildcard address will get remapped.
		//
		inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();
		wsprintf(tszInternalClient, _T("%u.%u.%u.%u"),
				inaddrTemp.S_un.S_un_b.s_b1,
				inaddrTemp.S_un.S_un_b.s_b2,
				inaddrTemp.S_un.S_un_b.s_b3,
				inaddrTemp.S_un.S_un_b.s_b4);
	}


	//
	// The current Microsoft UPnP Internet Gateway Device implementation--
	// and most others-- do not support lease durations that are not set
	// for INFINITE time, so we will almost certainly fail.  Because of
	// that, and since there's no server to test against anyway, we will
	// not even attempt to use non-INFINITE leases.  However, you can use
	// the registry key to take a shot at it if you like living on the
	// edge.
	// Note that there's no way to detect whether a given UPnP
	// implementation will allow non-INFINITE lease durations ahead of time,
	// so we have to try it first, and fall back to the infinite lease
	// behavior if it doesn't work.  Ugh.
	//
	if ((! pUPnPDevice->DoesNotSupportLeaseDurations()) && (g_fUseLeaseDurations))
	{
		wsprintf(tszLeaseDuration, _T("%u"),
				(pRegisteredPort->GetRequestedLeaseTime() / 1000));
	}
	else
	{
		_tcscpy(tszLeaseDuration, _T("0"));
		pRegisteredPort->NotePermanentUPnPLease();
	}

	psaddrinTemp = pUPnPDevice->GetHostAddress();
	wsprintf(tszHost, _T("%u.%u.%u.%u:%u"),
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b1,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b2,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b3,
			psaddrinTemp->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(psaddrinTemp->sin_port));


	//
	// Create the array to hold the resulting public addresses.
	//
	hr = pRegisteredPort->CreateUPnPPublicAddressesArray();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't create UPnP public addresses array!");
		goto Failure;
	}


	//
	// Note whether this was the first lease or not.
	//
	fFirstLease = (this->m_dwNumLeases == 0) ? TRUE : FALSE;
	this->m_dwNumLeases++;

	DPFX(DPFPREP, 7, "UPnP lease for 0x%p added, total num leases = %u.",
		pRegisteredPort, this->m_dwNumLeases);


	//
	// Assuming all goes well, the first port lease will expire approximately
	// GetRequestedLeaseTime() ms from now.
	// See above note about whether this lease will actually be used, though.
	//
	dwLeaseExpiration = GETTIMESTAMP() + pRegisteredPort->GetRequestedLeaseTime();



	//
	// Get a pointer to the addresses we're mapping.  We don't have to worry
	// about whether it's mapped on a local firewall since the HomeNet API will
	// always map it to the same port.
	//
	psaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();


	//
	// Loop through each port and map it.
	//
	for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
	{
		//
		// Determine the public port number to register.
		//
		if (! pRegisteredPort->IsFixedPort())
		{
			//
			// UPnP does not support wildcard ports (where the gateway
			// device picks an unused public port number for us).  We must
			// select a port ahead of time to try mapping on the server.
			//
			// Worse, UPnP does not require the device support selecting a
			// public port that is different from the client's private port
			// (a.k.a. asymmetric, x to y, or floating port mappings). 
			// This means that even non fixed ports will act that way.  To
			// top it all off, there's no way to detect whether a given
			// UPnP implementation will allow the ports to differ ahead of
			// time, so we have to try it first, and fall back to the fixed
			// port behavior if it doesn't work.  Ugh.
			//

			if (pUPnPDevice->DoesNotSupportAsymmetricMappings())
			{
				//
				// We are forced to use the client's private port.
				//
				wExternalPortHostOrder = NTOHS(psaddrinTemp[dwTemp].sin_port);
			}
			else
			{
				if (wOriginalExternalPortHostOrder == 0)
				{
					DNASSERT(dwTemp == 0);

					//
					// Ideally we would pick a random port that isn't in
					// the reserved range (i.e. is greater than 1024).
					// However, truly random ports cause problems with the
					// Windows XP ICS implementation in a fairly obscure
					// manner:
					//
					//	1. DPlay application starts hosting behind ICS on
					//		port 2302.
					//	2. Port 2302 gets mapped to random port x.
					//	3. External DPlay client is told to connect to x.
					//	4. ICS detects inbound traffic to x, sees mapping
					//		for internal_ip:2302, and creates a virtual
					//		connection.
					//	5. Internal client removes 2302<->x mapping and
					//		closes socket.
					//	6. Internal DPlay application begins hosting on
					//		port 2302 again.
					//	7. Port 2302 gets mapped to random port y.
					//	8. External DPlay client is told to connect to y.
					//	9. ICS detects inbound traffic to y, sees mapping
					//		for internal_ip:2302, but can't create virtual
					//		connection because the 2302<->x connection
					//		still exists.
					//
					// Windows XP ICS keeps the virtual connections around
					// and cleans them up every 60 seconds.  If the
					// reconnect occurs within (up to) 2 minutes, the
					// packets might get dropped due to the mapping
					// collision.
					//
					// This causes all sorts of heartache with automated
					// NAT tests that bring up and tear down connections
					// between the same two machines across the NAT over
					// and over.
					//
					// So, to avoid that, we need to make mappings
					// deterministic, such that if the same internal client
					// tries to map the same internal port, it should ask
					// for the same external port every time.  That way, if
					// there happens to be a virtual connection hanging
					// around from a previous attempt, we'll reuse it
					// instead of clashing and getting the packet dropped.
					//
					// Our actual algorithm:
					//	1. start with the internal client IP.
					//	2. combine in the internal port being mapped.
					//	3. add 1025 if necessary to get it out of the
					//		reserved range.
					//

					inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();

					wOriginalExternalPortHostOrder = inaddrTemp.S_un.S_un_w.s_w1;
					wOriginalExternalPortHostOrder ^= inaddrTemp.S_un.S_un_w.s_w2;
					wOriginalExternalPortHostOrder ^= psaddrinTemp[dwTemp].sin_port;
					
					if (wOriginalExternalPortHostOrder <= MAX_RESERVED_PORT)
					{
						wOriginalExternalPortHostOrder += MAX_RESERVED_PORT + 1;
					}


					//
					// This is the starting point, we'll increment by one
					// as we go.
					//
					wExternalPortHostOrder = wOriginalExternalPortHostOrder;
				}
				else
				{
					//
					// Go to the next sequential port.  If we've wrapped
					// around to 0, move to the first non reserved range
					// port.
					//
					wExternalPortHostOrder++;
					if (wExternalPortHostOrder == 0)
					{
						wExternalPortHostOrder = MAX_RESERVED_PORT + 1;
					}


					//
					// If we wrapped all the way back around to the first
					// port we tried, we have to fail.
					//
					if (wExternalPortHostOrder == wOriginalExternalPortHostOrder)
					{
						DPFX(DPFPREP, 0, "All ports were exhausted (before index %u), marking port as unavailable.",
							dwTemp);


						//
						// Delete all mappings successfully made up until
						// now.
						//
						DNASSERT(dwTemp > 0);

						hr = this->UnmapUPnPPort(pRegisteredPort, dwTemp, TRUE);
						if (hr != DPNH_OK)
						{
							DPFX(DPFPREP, 0, "Failed deleting %u previously mapped ports after getting failure response 0x%lx!",
								dwTemp, RespInfo.hrErrorCode);
							goto Failure;
						}


						//
						// The port is unavailable.
						//
						pRegisteredPort->NoteUPnPPortUnavailable();


						//
						// We're done here.  Ideally we would goto Exit, but
						// we want to execute the public address array
						// cleanup code.  hr will == DPNH_OK.
						//
						goto Failure;
					}
				} // end if (haven't selected first port yet)
			}
		}
		else
		{
			//
			// Use the fixed port.
			//
			wExternalPortHostOrder = NTOHS(psaddrinTemp[dwTemp].sin_port);
		}

		wsprintf(tszInternalPort, _T("%u"),
				NTOHS(psaddrinTemp[dwTemp].sin_port));


Retry:

		//
		// Because the UPnP spec allows a device to overwrite existing
		// mappings if they are for the same client, we have to make sure
		// that no local DPNHUPNP instances, including this one, have an
		// active mapping for that public port.
		// Rather than having the retry code in multiple places, I'll use
		// the somewhat ugly 'goto' to jump straight to the existing port
		// unavailable handling.
		//
		if (this->IsNATPublicPortInUseLocally(wExternalPortHostOrder))
		{
			DPFX(DPFPREP, 1, "Port %u is already in use locally.");
			RespInfo.hrErrorCode = DPNHERR_PORTUNAVAILABLE;
			goto PortUnavailable;
		}


		//
		// If the control socket got disconnected after the last message,
		// then reconnect.
		//
		if (! pUPnPDevice->IsConnected())
		{
			hr = this->ReconnectUPnPControlSocket(pUPnPDevice);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't reconnect UPnP control socket!");
				goto Failure;
			}
		}

		DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


		wsprintf(tszExternalPort, _T("%u"), wExternalPortHostOrder);



		//
		// Generate a description for this mapping.  The format is:
		//
		//     [executable_name] (nnn.nnn.nnn.nnn:nnnnn) nnnnn {"TCP" | "UDP"}
		//
		// That way nothing needs to be localized.
		//

		dwDescriptionLength = GetModuleFileName(NULL,
												tszDescription,
												(MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1));
		if (dwDescriptionLength != 0)
		{
			//
			// Be paranoid and make sure the description string is valid.
			//
			tszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1] = 0;

			//
			// Get just the executable name from the path.
			//
#ifdef WINCE
			GetExeName(tszDescription);
#else // ! WINCE
#ifdef UNICODE
			_wsplitpath(tszDescription, NULL, NULL, tszDescription, NULL);
#else // ! UNICODE
			_splitpath(tszDescription, NULL, NULL, tszDescription, NULL);
#endif // ! UNICODE
#endif // ! WINCE


			dwDescriptionLength = _tcslen(tszDescription)		// executable name
								+ 2								// " ("
								+ _tcslen(tszInternalClient)	// private IP address
								+ 1								// ":"
								+ _tcslen(tszInternalPort)		// private port
								+ 2								// ") "
								+ _tcslen(tszExternalPort)		// public port
								+ 4;							// " TCP" | " UDP"

			//
			// Make sure the long string will fit.  If not, use the
			// abbreviated version.
			//
			if (dwDescriptionLength > MAX_UPNP_MAPPING_DESCRIPTION_SIZE)
			{
				dwDescriptionLength = 0;
			}
		}

		if (dwDescriptionLength == 0)
		{
			//
			// Use the abbreviated version we know will fit.
			//
			wsprintf(tszDescription,
					_T("(%s:%s) %s %s"),
					tszInternalClient,
					tszInternalPort,
					tszExternalPort,
					((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
		}
		else
		{
			//
			// There's enough room, tack on the rest of the description.
			//
			wsprintf((tszDescription + _tcslen(tszDescription)),
					_T(" (%s:%s) %s %s"),
					tszInternalClient,
					tszInternalPort,
					tszExternalPort,
					((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
		}


		DPFX(DPFPREP, 6, "Requesting mapping \"%s\".", tszDescription);


		iContentLength = strlen("<s:Envelope" EOL)
						+ strlen("    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL)
						+ strlen("    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL)
						+ strlen("  <s:Body>" EOL)
						+ strlen("    <u:" ACTION_ADDPORTMAPPING_A " xmlns:u=\"") + pUPnPDevice->GetStaticServiceURILength() + strlen("\">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_ADDPORTMAPPING_NEWREMOTEHOST_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWEXTERNALPORT_A ">") + _tcslen(tszExternalPort) + strlen("</" ARG_ADDPORTMAPPING_NEWEXTERNALPORT_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWPROTOCOL_A ">") + 3 + strlen("</" ARG_ADDPORTMAPPING_NEWPROTOCOL_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWINTERNALPORT_A ">") + _tcslen(tszInternalPort) + strlen("</" ARG_ADDPORTMAPPING_NEWINTERNALPORT_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWINTERNALCLIENT_A ">") + _tcslen(tszInternalClient) + strlen("</" ARG_ADDPORTMAPPING_NEWINTERNALCLIENT_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWENABLED_A ">" UPNP_BOOLEAN_TRUE "</" ARG_ADDPORTMAPPING_NEWENABLED_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWPORTMAPPINGDESCRIPTION_A ">") + _tcslen(tszDescription) + strlen("</" ARG_ADDPORTMAPPING_NEWPORTMAPPINGDESCRIPTION_A ">" EOL)
						+ strlen("      <" ARG_ADDPORTMAPPING_NEWLEASEDURATION_A ">") + _tcslen(tszLeaseDuration) + strlen("</" ARG_ADDPORTMAPPING_NEWLEASEDURATION_A ">" EOL)
						+ strlen("    </u:" ACTION_ADDPORTMAPPING_A ">" EOL)
						+ strlen("  </s:Body>" EOL)
						+ strlen("</s:Envelope>" EOL)
						+ strlen(EOL);

		wsprintf(tszContentLength, _T("%i"), iContentLength);

		iMsgSize = strlen("POST ") + strlen(pUPnPDevice->GetServiceControlURL()) + strlen(" " HTTP_VERSION EOL)
					+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
					+ strlen("CONTENT-LENGTH: ") + _tcslen(tszContentLength) + strlen(EOL)
					+ strlen("CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL)
					+ strlen("SOAPACTION: ") + pUPnPDevice->GetStaticServiceURILength() + strlen("#" ACTION_ADDPORTMAPPING_A EOL)
					+ strlen(EOL)
					+ iContentLength;


		//
		// Allocate (or reallocate) the message buffer.
		//
		if (iMsgSize > iPrevMsgSize)
		{
			if (pszMessage != NULL)
			{
				DNFree(pszMessage);
				pszMessage = NULL;
			}

			pszMessage = (char*) DNMalloc(iMsgSize + 1); // include room for NULL termination that isn't actually sent
			if (pszMessage == NULL)
			{
				hr = DPNHERR_OUTOFMEMORY;
				goto Failure;
			}

			iPrevMsgSize = iMsgSize;
		}

		strcpy(pszMessage, "POST ");
		strcat(pszMessage, pUPnPDevice->GetServiceControlURL());
		strcat(pszMessage, " " HTTP_VERSION EOL);
		strcat(pszMessage, "HOST: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszHost,
						(_tcslen(tszHost) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszHost);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-LENGTH: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszContentLength,
						(_tcslen(tszContentLength) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszContentLength);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL);
		strcat(pszMessage, "SOAPACTION: ");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "#" ACTION_ADDPORTMAPPING_A EOL);
		strcat(pszMessage, EOL);


		strcat(pszMessage, "<s:Envelope" EOL);
		strcat(pszMessage, "    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL);
		strcat(pszMessage, "    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL);
		strcat(pszMessage, "  <s:Body>" EOL);
		strcat(pszMessage, "    <u:" ACTION_ADDPORTMAPPING_A " xmlns:u=\"");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "\">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_ADDPORTMAPPING_NEWREMOTEHOST_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWEXTERNALPORT_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszExternalPort,
						(_tcslen(tszExternalPort) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszExternalPort);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWEXTERNALPORT_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWPROTOCOL_A ">");
		strcat(pszMessage, ((pRegisteredPort->IsTCP()) ? "TCP" : "UDP"));
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWPROTOCOL_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWINTERNALPORT_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszInternalPort,
						(_tcslen(tszInternalPort) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszInternalPort);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWINTERNALPORT_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWINTERNALCLIENT_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszInternalClient,
						(_tcslen(tszInternalClient) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszInternalClient);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWINTERNALCLIENT_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWENABLED_A ">" UPNP_BOOLEAN_TRUE "</" ARG_ADDPORTMAPPING_NEWENABLED_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWPORTMAPPINGDESCRIPTION_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszDescription,
						(_tcslen(tszDescription) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszDescription);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWPORTMAPPINGDESCRIPTION_A ">" EOL);

		strcat(pszMessage, "      <" ARG_ADDPORTMAPPING_NEWLEASEDURATION_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszLeaseDuration,
						(_tcslen(tszLeaseDuration) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszLeaseDuration);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_ADDPORTMAPPING_NEWLEASEDURATION_A ">" EOL);

		strcat(pszMessage, "    </u:" ACTION_ADDPORTMAPPING_A ">" EOL);
		strcat(pszMessage, "  </s:Body>" EOL);
		strcat(pszMessage, "</s:Envelope>" EOL);
		strcat(pszMessage, EOL);


#ifdef DBG
		this->PrintUPnPTransactionToFile(pszMessage,
										iMsgSize,
										"Outbound add port mapping request",
										pDevice);
#endif // DBG

		iReturn = this->m_pfnsend(pUPnPDevice->GetControlSocket(),
									pszMessage,
									iMsgSize,
									0);

		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u when sending control request to UPnP device!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		if (iReturn != iMsgSize)
		{
			DPFX(DPFPREP, 0, "Didn't send entire message (%i != %i)?!", iReturn, iMsgSize);
			DNASSERT(FALSE);
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// We have the lock so no one could have tried to receive data from
		// the control socket yet.  Mark the device as waiting for a
		// response.
		//
		ZeroMemory(&RespInfo, sizeof(RespInfo));
		pUPnPDevice->StartWaitingForControlResponse(CONTROLRESPONSETYPE_ADDPORTMAPPING,
													&RespInfo);
		fStartedWaitingForControlResponse = TRUE;


		//
		// Actually wait for the response.
		//
		dwStartTime = GETTIMESTAMP();
		dwTimeout = g_dwUPnPResponseTimeout;
		do
		{
			hr = this->CheckForReceivedUPnPMsgsOnDevice(pUPnPDevice, dwTimeout);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed receiving UPnP messages!");
				goto Failure;
			}

			//
			// We either timed out or got some data.  Check if we got the
			// response we need.
			//
			if (! pUPnPDevice->IsWaitingForControlResponse())
			{
				if (RespInfo.hrErrorCode != DPNH_OK)
				{
					//
					// Make sure it's not the "I can't handle asymmetric
					// mappings" error.  If it is, note the fact that this
					// device is going to force us to have worse behavior
					// and try again.
					//
					if (RespInfo.hrErrorCode == (HRESULT) UPNPERR_IGD_SAMEPORTVALUESREQUIRED)
					{
						DPFX(DPFPREP, 1, "UPnP device 0x%p does not support asymmetric mappings.",
							pUPnPDevice);

						//
						// Make sure we're not getting this error from a bad
						// device.  Otherwise we might get caught in a loop.
						//
						if ((! pUPnPDevice->DoesNotSupportAsymmetricMappings()) &&
							(! pRegisteredPort->IsFixedPort()) &&
							(dwTemp == 0))
						{
							//
							// Remember that this device is unfriendly.
							//
							pUPnPDevice->NoteDoesNotSupportAsymmetricMappings();

							//
							// Use the same port externally next time.
							//
							DNASSERT(wExternalPortHostOrder != NTOHS(psaddrinTemp[dwTemp].sin_port));
							wExternalPortHostOrder = NTOHS(psaddrinTemp[dwTemp].sin_port);

							//
							// Try again.
							//
							goto Retry;
						}

						DPFX(DPFPREP, 1, "DoesNotSupportAsymmetricMappings = %i, fixed port = %i, port index = %u",
							pUPnPDevice->DoesNotSupportAsymmetricMappings(),
							pRegisteredPort->IsFixedPort(),
							dwTemp);
						DNASSERTX(! "Getting UPNPERR_IGD_SAMEPORTVALUESREQUIRED from bad device!", 2);

						//
						// Continue through to failure case...
						//
					}


					//
					// Make sure it's not the "I can't handle lease times"
					// error.  If it is, note the fact that this device is
					// going to force us to have worse behavior and try
					// again.
					//
					if (RespInfo.hrErrorCode == (HRESULT) UPNPERR_IGD_ONLYPERMANENTLEASESSUPPORTED)
					{
						DPFX(DPFPREP, 1, "UPnP device 0x%p does not support non-INFINITE lease durations.",
							pUPnPDevice);

						//
						// Make sure we're not getting this error from a bad
						// device.  Otherwise we might get caught in a loop.
						//
						if ((! pUPnPDevice->DoesNotSupportLeaseDurations()) &&
							(dwTemp == 0))
						{
							//
							// Remember that this device is unfriendly.
							//
							pUPnPDevice->NoteDoesNotSupportLeaseDurations();

							//
							// Use an INFINITE lease next time around.
							//
							DNASSERT(_tcscmp(tszLeaseDuration, _T("0")) != 0);
							_tcscpy(tszLeaseDuration, _T("0"));
							pRegisteredPort->NotePermanentUPnPLease();

							//
							// Try again.
							//
							goto Retry;
						}

						DPFX(DPFPREP, 1, "DoesNotSupportLeaseDurations = %i, port index = %u",
							pUPnPDevice->DoesNotSupportLeaseDurations(), dwTemp);
						DNASSERTX(! "Getting UPNPERR_IGD_ONLYPERMANENTLEASESSUPPORTED from bad device!", 2);

						//
						// Continue through to failure case...
						//
					}


#ifdef DBG
					if (RespInfo.hrErrorCode == DPNHERR_PORTUNAVAILABLE)
					{
						DPFX(DPFPREP, 2, "Port %u (for address index %u) is reportedly unavailable.",
							wExternalPortHostOrder, dwTemp);
					}
#endif // DBG


PortUnavailable:

					//
					// If it's the port-unavailable error but we're able to
					// try a different port, go for it.
					//
					if ((RespInfo.hrErrorCode == DPNHERR_PORTUNAVAILABLE) &&
						(! pRegisteredPort->IsFixedPort()) &&
						(! pUPnPDevice->DoesNotSupportAsymmetricMappings()))
					{
						//
						// Go to the next sequential port.  If we've wrapped
						// around to 0, move to the first non reserved range
						// port.
						//
						wExternalPortHostOrder++;
						if (wExternalPortHostOrder == 0)
						{
							wExternalPortHostOrder = MAX_RESERVED_PORT + 1;
						}


						//
						// If we haven't wrapped all the way back around to
						// the first port we tried, try again.
						//
						if (wExternalPortHostOrder != wOriginalExternalPortHostOrder)
						{
							DPFX(DPFPREP, 2, "Retrying next port (%u) for index %u.",
								wExternalPortHostOrder, dwTemp);
							goto Retry;
						}


						DPFX(DPFPREP, 0, "All ports were exhausted (after index %u), marking port as unavailable.",
							dwTemp);
					}


					//
					// If it's not the port-unavailable error, it's
					// serious.  Bail.
					//
					if (RespInfo.hrErrorCode != DPNHERR_PORTUNAVAILABLE)
					{
						DPFX(DPFPREP, 1, "Port index %u got failure response 0x%lx.",
							dwTemp, RespInfo.hrErrorCode);

						hr = DPNHERR_SERVERNOTRESPONDING;
						goto Failure;
					}


					//
					// The port is unavailable.
					//
					pRegisteredPort->NoteUPnPPortUnavailable();


					//
					// We're done here.  Ideally we would goto Exit, but we
					// want to execute the public address array cleanup
					// code.  hr should == DPNH_OK.
					//
					DNASSERT(hr == DPNH_OK);
					goto Failure;
				}


				//
				// If we got here, we successfully registered this port.
				//


				//
				// UPnP Internet Gateway Device mapping protocol doesn't
				// hand you the external IP address in the success response
				// message.  We had to have known it through other means
				// (querying the ExternalIPAddress variable).
				//

				DPFX(DPFPREP, 2, "Port index %u got success response.", dwTemp);

				pRegisteredPort->SetUPnPPublicV4Address(dwTemp,
														pUPnPDevice->GetExternalIPAddressV4(),
														HTONS(wExternalPortHostOrder));


				//
				// If the lease is permanent and it's not for a shared
				// port, we need to remember it, in case we crash before
				// cleaning it up in this session.  That we can clean it up
				// next time we launch.
				//
				if ((pRegisteredPort->HasPermanentUPnPLease()) &&
					(! pRegisteredPort->IsSharedPort()))
				{
					CRegistry				RegObject;
					DPNHACTIVENATMAPPING	dpnhanm;
#ifndef UNICODE
					WCHAR					wszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
#endif // ! UNICODE


					DPFX(DPFPREP, 7, "Remembering NAT lease \"%s\" in case of crash.",
						tszDescription);

					if (! RegObject.Open(HKEY_LOCAL_MACHINE,
										DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVENATMAPPINGS,
										FALSE,
										TRUE,
										TRUE,
										DPN_KEY_ALL_ACCESS))
					{
						DPFX(DPFPREP, 0, "Couldn't open active NAT mapping key, unable to save in case of crash!");
					}
					else
					{
#ifndef UNICODE
						dwDescriptionLength = strlen(tszDescription) + 1;
						hr = STR_jkAnsiToWide(wszDescription, tszDescription, dwDescriptionLength);
						if (hr != S_OK)
						{
							DPFX(DPFPREP, 0, "Couldn't convert NAT mapping description to Unicode (err = 0x%lx), unable to save in case of crash!",
								hr);

							//
							// Ignore error and continue.
							//
							hr = S_OK;
						}
						else
#endif // ! UNICODE
						{
							DNASSERT(this->m_dwInstanceKey != 0);


							ZeroMemory(&dpnhanm, sizeof(dpnhanm));
							dpnhanm.dwVersion				= ACTIVE_MAPPING_VERSION;
							dpnhanm.dwInstanceKey			= this->m_dwInstanceKey;
							dpnhanm.dwUPnPDeviceID			= pUPnPDevice->GetID();
							dpnhanm.dwFlags					= pRegisteredPort->GetFlags();
							dpnhanm.dwInternalAddressV4		= pDevice->GetLocalAddressV4();
							dpnhanm.wInternalPort			= psaddrinTemp[dwTemp].sin_port;
							dpnhanm.dwExternalAddressV4		= pUPnPDevice->GetExternalIPAddressV4();
							dpnhanm.wExternalPort			= HTONS(wExternalPortHostOrder);


#ifdef UNICODE
							RegObject.WriteBlob(tszDescription,
#else // ! UNICODE
							RegObject.WriteBlob(wszDescription,
#endif // ! UNICODE
												(LPBYTE) (&dpnhanm),
												sizeof(dpnhanm));
						}

						RegObject.Close();
					}
				}


				//
				// Break out of the wait loop.
				//
				break;
			}


			//
			// Make sure our device is still connected.
			//
			if (! pUPnPDevice->IsConnected())
			{
				DPFX(DPFPREP, 0, "UPnP device 0x%p disconnected while adding port index %u!",
					pUPnPDevice, dwTemp);
				
				pUPnPDevice->StopWaitingForControlResponse();
				
				hr = DPNHERR_SERVERNOTRESPONDING;
				goto Failure;
			}


			//
			// Calculate how long we have left to wait.  If the calculation
			// goes negative, it means we're done.
			//
			dwTimeout = g_dwUPnPResponseTimeout - (GETTIMESTAMP() - dwStartTime);
		}
		while (((int) dwTimeout > 0));


		//
		// If we never got the response, stop waiting for it.
		//
		if (pUPnPDevice->IsWaitingForControlResponse())
		{
			pUPnPDevice->StopWaitingForControlResponse();

			DPFX(DPFPREP, 0, "Port index %u didn't get response in time!", dwTemp);
			hr = DPNHERR_SERVERNOTRESPONDING;
			goto Failure;
		}

		//
		// Continue on to the next port.
		//
	}


	//
	// If we're here, all ports were successfully registered.
	//

	if (pRegisteredPort->HasPermanentUPnPLease())
	{
		DPFX(DPFPREP, 3, "All %u ports successfully registered with UPnP device (no expiration).",
			dwTemp);
	}
	else
	{
		pRegisteredPort->SetUPnPLeaseExpiration(dwLeaseExpiration);

		DPFX(DPFPREP, 3, "All %u ports successfully registered with UPnP device, expiration = %u.",
			dwTemp, dwLeaseExpiration);


		//
		// Remember this expiration time if it's the one that's going to expire
		// soonest.
		//
		if ((fFirstLease) ||
			((int) (dwLeaseExpiration - this->m_dwEarliestLeaseExpirationTime) < 0))
		{
			if (fFirstLease)
			{
				DPFX(DPFPREP, 1, "Registered port 0x%p's UPnP lease is the first lease (expires at %u).",
					pRegisteredPort, dwLeaseExpiration);
			}
			else
			{
				DPFX(DPFPREP, 1, "Registered port 0x%p's UPnP lease expires at %u which is earlier than the next earliest lease expiration (%u).",
					pRegisteredPort,
					dwLeaseExpiration,
					this->m_dwEarliestLeaseExpirationTime);
			}

			this->m_dwEarliestLeaseExpirationTime = dwLeaseExpiration;


#ifndef DPNBUILD_NOWINSOCK2
			//
			// Ping the event if there is one so that the user's GetCaps
			// interval doesn't miss this new, shorter lease.
			//
			if (this->m_hAlertEvent != NULL)
			{
				fResult = SetEvent(this->m_hAlertEvent);
#ifdef DBG
				if (! fResult)
				{
					dwError = GetLastError();
					DPFX(DPFPREP, 0, "Couldn't set alert event 0x%p!  err = %u",
						this->m_hAlertEvent, dwError);

					//
					// Ignore failure...
					//
				}
#endif // DBG
			}


			//
			// Ping the I/O completion port if there is one so that the user's
			// GetCaps interval doesn't miss this new, shorter lease.
			//
			if (this->m_hAlertIOCompletionPort != NULL)
			{
				fResult = PostQueuedCompletionStatus(this->m_hAlertIOCompletionPort,
													0,
													this->m_dwAlertCompletionKey,
													NULL);
#ifdef DBG
				if (! fResult)
				{
					dwError = GetLastError();
					DPFX(DPFPREP, 0, "Couldn't queue key %u on alert IO completion port 0x%p!  err = %u",
						this->m_dwAlertCompletionKey,
						this->m_hAlertIOCompletionPort,
						dwError);

					//
					// Ignore failure...
					//
				}
#endif // DBG
			}
#endif // ! DPNBUILD_NOWINSOCK2
		}
		else
		{
			//
			// Not first or shortest lease.
			//
		}
	} // end if (not permanent UPnP lease)


Exit:

	if (pszMessage != NULL)
	{
		DNFree(pszMessage);
		pszMessage = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// If we allocated the array, clean it up.
	//
	if (pRegisteredPort->HasUPnPPublicAddresses())
	{
		//
		// If we started waiting for a response, clear that.
		//
		if (fStartedWaitingForControlResponse)
		{
			pUPnPDevice->StopWaitingForControlResponse();
		}


		//
		// Delete all mappings successfully made up until now.
		//
		if (dwTemp > 0)
		{
			temphr = this->UnmapUPnPPort(pRegisteredPort, dwTemp, TRUE);
			if (temphr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed deleting %u previously mapped ports!  Err = 0x%lx",
					dwTemp, temphr);

				if (hr == DPNH_OK)
				{
					hr = temphr;
				}
			}
		}
		else
		{
			//
			// Remove the addresses array we created.
			//
			pRegisteredPort->DestroyUPnPPublicAddressesArray();


			//
			// Remove the lease counter.
			//
			DNASSERT(this->m_dwNumLeases > 0);
			this->m_dwNumLeases--;

			DPFX(DPFPREP, 7, "UPnP lease for 0x%p removed, total num leases = %u.",
				pRegisteredPort, this->m_dwNumLeases);
		}
	}

	//
	// Turn off the permanent lease flag we may have turned on at the top of
	// this function.
	//
	pRegisteredPort->NoteNotPermanentUPnPLease();


	goto Exit;
} // CNATHelpUPnP::MapPortsOnUPnPDevice





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::InternalUPnPQueryAddress"
//=============================================================================
// CNATHelpUPnP::InternalUPnPQueryAddress
//-----------------------------------------------------------------------------
//
// Description:    Queries a port mapping with a UPnP device.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice				- Pointer to UPnP device that
//												should be queried.
//	SOCKADDR_IN * psaddrinQueryAddress		- Address to look up.
//	SOCKADDR_IN * psaddrinResponseAddress	- Place to store public address, if
//												one exists.
//	DWORD dwFlags							- Flags to use when querying.
//
// Returns: HRESULT
//	DPNH_OK							- The query was successful.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_NOMAPPING				- The server did not have a mapping for the
//										given address.
//	DPNHERR_NOMAPPINGBUTPRIVATE		- The server indicated that no mapping was
//										found, but it is a private address.
//	DPNHERR_SERVERNOTRESPONDING		- The server did not respond to the
//										message.
//=============================================================================
HRESULT CNATHelpUPnP::InternalUPnPQueryAddress(CUPnPDevice * const pUPnPDevice,
												const SOCKADDR_IN * const psaddrinQueryAddress,
												SOCKADDR_IN * const psaddrinResponseAddress,
												const DWORD dwFlags)
{
	HRESULT						hr;
	BOOL						fStartedWaitingForControlResponse = FALSE;
	BOOL						fNoPortMapping = FALSE;
	CDevice *					pDevice;
	CBilink *					pblCachedMaps;
	DWORD						dwCurrentTime;
	CBilink *					pBilink;
	CCacheMap *					pCacheMap;
	SOCKADDR_IN *				psaddrinTemp;
	TCHAR						tszExternalPort[32];
	int							iContentLength;
	TCHAR						tszContentLength[32];
	TCHAR						tszHost[22]; // "xxx.xxx.xxx.xxx:xxxxx" + NULL termination
	char *						pszMessage = NULL;
	int							iMsgSize;
	int							iPrevMsgSize = 0;
	int							iReturn;
	UPNP_CONTROLRESPONSE_INFO	RespInfo;
	DWORD						dwStartTime;
	DWORD						dwTimeout;
	DWORD						dwCacheMapFlags;
#ifdef DBG
	DWORD						dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, 0x%lx)",
		this, pUPnPDevice, psaddrinQueryAddress, psaddrinResponseAddress, dwFlags);


	DNASSERT(pUPnPDevice != NULL);

	pDevice = pUPnPDevice->GetOwningDevice();
	DNASSERT(pDevice != NULL);

	DNASSERT(pUPnPDevice->IsReady());
	DNASSERT(psaddrinQueryAddress != NULL);
	DNASSERT(psaddrinResponseAddress != NULL);

	DNASSERT(this->m_dwFlags & (NATHELPUPNPOBJ_INITIALIZED | NATHELPUPNPOBJ_USEUPNP));


	DPFX(DPFPREP, 7, "Querying for address %u.%u.%u.%u:%u %hs.",
		psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b1,
		psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b2,
		psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b3,
		psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b4,
		NTOHS(psaddrinQueryAddress->sin_port),
		((dwFlags & DPNHQUERYADDRESS_TCP) ? "TCP" : "UDP"));


	//
	// First, check if we've looked this address up recently and already have
	// the result cached.
	// The lock is already held.
	//
	pblCachedMaps = pUPnPDevice->GetCachedMaps();
	dwCurrentTime = GETTIMESTAMP();

	pBilink = pblCachedMaps->GetNext();
	while (pBilink != pblCachedMaps)
	{
		DNASSERT(! pBilink->IsEmpty());
		pCacheMap = CACHEMAP_FROM_BILINK(pBilink);
		pBilink = pBilink->GetNext();


		//
		// Make sure this cached mapping hasn't expired.
		//
		if ((int) (pCacheMap->GetExpirationTime() - dwCurrentTime) < 0)
		{
			DPFX(DPFPREP, 5, "Cached mapping 0x%p has expired.", pCacheMap);

			pCacheMap->m_blList.RemoveFromList();
			delete pCacheMap;
		}
		else
		{
			//
			// If this mapping is for the right address and type of address,
			// then we've already got our answer.
			//
			if (pCacheMap->DoesMatchQuery(psaddrinQueryAddress, dwFlags))
			{
				if (pCacheMap->IsNotFound())
				{
					if ((dwFlags & DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED) &&
						(pCacheMap->IsPrivateButUnmapped()))
					{
						DPFX(DPFPREP, 5, "Address was already determined to not have a mapping but still be private.");
						hr = DPNHERR_NOMAPPINGBUTPRIVATE;
					}
					else
					{
						DPFX(DPFPREP, 5, "Address was already determined to not have a mapping.");
						hr = DPNHERR_NOMAPPING;
					}
				}
				else
				{
					pCacheMap->GetResponseAddressV4(psaddrinResponseAddress);

					DPFX(DPFPREP, 5, "Address was already determined to have a mapping.");
					hr = DPNH_OK;
				}

				goto Exit;
			}
		}
	}


	//
	// If the address we're querying isn't the NAT's public address, it can't
	// possibly be mapped.  So only perform the actual query if it's
	// appropriate.
	//
	if (psaddrinQueryAddress->sin_addr.S_un.S_addr == pUPnPDevice->GetExternalIPAddressV4())
	{
		//
		// If we're here, we haven't already cached the answer.  Query the UPnP
		// device.
		//
	
		DNASSERT(pUPnPDevice->GetServiceControlURL() != NULL);

		//
		// If the control socket got disconnected after the last message,
		// then reconnect.
		//
		if (! pUPnPDevice->IsConnected())
		{
			hr = this->ReconnectUPnPControlSocket(pUPnPDevice);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't reconnect UPnP control socket!");
				goto Failure;
			}
		}

		DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


		wsprintf(tszExternalPort, _T("%u"),
				NTOHS(psaddrinQueryAddress->sin_port));
		
		psaddrinTemp = pUPnPDevice->GetHostAddress();
		wsprintf(tszHost, _T("%u.%u.%u.%u:%u"),
				psaddrinTemp->sin_addr.S_un.S_un_b.s_b1,
				psaddrinTemp->sin_addr.S_un.S_un_b.s_b2,
				psaddrinTemp->sin_addr.S_un.S_un_b.s_b3,
				psaddrinTemp->sin_addr.S_un.S_un_b.s_b4,
				NTOHS(psaddrinTemp->sin_port));



		iContentLength = strlen("<s:Envelope" EOL)
						+ strlen("    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL)
						+ strlen("    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL)
						+ strlen("  <s:Body>" EOL)
						+ strlen("    <u:" ACTION_GETSPECIFICPORTMAPPINGENTRY_A " xmlns:u=\"") + pUPnPDevice->GetStaticServiceURILength() + strlen("\">" EOL)
						+ strlen("      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWREMOTEHOST_A ">" EOL)
						+ strlen("      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWEXTERNALPORT_A ">") + _tcslen(tszExternalPort) + strlen("</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWEXTERNALPORT_A ">" EOL)
						+ strlen("      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPROTOCOL_A ">") + 3 + strlen("</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPROTOCOL_A ">" EOL)
						+ strlen("    </u:" ACTION_GETSPECIFICPORTMAPPINGENTRY_A ">" EOL)
						+ strlen("  </s:Body>" EOL)
						+ strlen("</s:Envelope>" EOL)
						+ strlen(EOL);

		wsprintf(tszContentLength, _T("%i"), iContentLength);

		iMsgSize = strlen("POST ") + strlen(pUPnPDevice->GetServiceControlURL()) + strlen(" " HTTP_VERSION EOL)
					+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
					+ strlen("CONTENT-LENGTH: ") + _tcslen(tszContentLength) + strlen(EOL)
					+ strlen("CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL)
					+ strlen("SOAPACTION: ") + pUPnPDevice->GetStaticServiceURILength() + strlen("#" ACTION_GETSPECIFICPORTMAPPINGENTRY_A EOL)
					+ strlen(EOL)
					+ iContentLength;


		//
		// Allocate (or reallocate) the message buffer.
		//
		if (iMsgSize > iPrevMsgSize)
		{
			if (pszMessage != NULL)
			{
				DNFree(pszMessage);
				pszMessage = NULL;
			}

			pszMessage = (char*) DNMalloc(iMsgSize + 1); // include room for NULL termination that isn't actually sent
			if (pszMessage == NULL)
			{
				hr = DPNHERR_OUTOFMEMORY;
				goto Failure;
			}

			iPrevMsgSize = iMsgSize;
		}

		strcpy(pszMessage, "POST ");
		strcat(pszMessage, pUPnPDevice->GetServiceControlURL());
		strcat(pszMessage, " " HTTP_VERSION EOL);
		strcat(pszMessage, "HOST: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszHost,
						(_tcslen(tszHost) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszHost);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-LENGTH: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszContentLength,
						(_tcslen(tszContentLength) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszContentLength);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL);
		strcat(pszMessage, "SOAPACTION: ");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "#" ACTION_GETSPECIFICPORTMAPPINGENTRY_A EOL);
		strcat(pszMessage, EOL);


		strcat(pszMessage, "<s:Envelope" EOL);
		strcat(pszMessage, "    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL);
		strcat(pszMessage, "    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL);
		strcat(pszMessage, "  <s:Body>" EOL);
		strcat(pszMessage, "    <u:" ACTION_GETSPECIFICPORTMAPPINGENTRY_A " xmlns:u=\"");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "\">" EOL);
		
		strcat(pszMessage, "      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWREMOTEHOST_A ">" EOL);

		strcat(pszMessage, "      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWEXTERNALPORT_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszExternalPort,
						(_tcslen(tszExternalPort) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszExternalPort);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWEXTERNALPORT_A ">" EOL);

		strcat(pszMessage, "      <" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPROTOCOL_A ">");
		strcat(pszMessage, ((dwFlags & DPNHQUERYADDRESS_TCP) ? "TCP" : "UDP"));
		strcat(pszMessage, "</" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPROTOCOL_A ">" EOL);

		strcat(pszMessage, "    </u:" ACTION_GETSPECIFICPORTMAPPINGENTRY_A ">" EOL);
		strcat(pszMessage, "  </s:Body>" EOL);
		strcat(pszMessage, "</s:Envelope>" EOL);
		strcat(pszMessage, EOL);


#ifdef DBG
		this->PrintUPnPTransactionToFile(pszMessage,
										iMsgSize,
										"Outbound get port mapping request",
										pDevice);
#endif // DBG

		iReturn = this->m_pfnsend(pUPnPDevice->GetControlSocket(),
									pszMessage,
									iMsgSize,
									0);

		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u when sending control request to UPnP device!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		if (iReturn != iMsgSize)
		{
			DPFX(DPFPREP, 0, "Didn't send entire message (%i != %i)?!", iReturn, iMsgSize);
			DNASSERT(FALSE);
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		//
		// We have the lock so no one could have tried to receive data from
		// the control socket yet.  Mark the device as waiting for a response.
		//
		ZeroMemory(&RespInfo, sizeof(RespInfo));
		pUPnPDevice->StartWaitingForControlResponse(CONTROLRESPONSETYPE_GETSPECIFICPORTMAPPINGENTRY,
													&RespInfo);
		fStartedWaitingForControlResponse = TRUE;


		//
		// Actually wait for the response.
		//
		dwStartTime = GETTIMESTAMP();
		dwTimeout = g_dwUPnPResponseTimeout;
		do
		{
			hr = this->CheckForReceivedUPnPMsgsOnDevice(pUPnPDevice, dwTimeout);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed receiving UPnP messages!");
				goto Failure;
			}

			//
			// We either timed out or got some data.  Check if we got a
			// response of some type.
			//
			if (! pUPnPDevice->IsWaitingForControlResponse())
			{
				break;
			}


			//
			// Make sure our device is still connected.
			//
			if (! pUPnPDevice->IsConnected())
			{
				DPFX(DPFPREP, 0, "UPnP device 0x%p disconnected while querying port!",
					pUPnPDevice);
				
				pUPnPDevice->StopWaitingForControlResponse();
				
				hr = DPNHERR_SERVERNOTRESPONDING;
				goto Failure;
			}


			//
			// Calculate how long we have left to wait.  If the calculation
			// goes negative, it means we're done.
			//
			dwTimeout = g_dwUPnPResponseTimeout - (GETTIMESTAMP() - dwStartTime);
		}
		while (((int) dwTimeout > 0));


		//
		// If we never got the response, stop waiting for it.
		//
		if (pUPnPDevice->IsWaitingForControlResponse())
		{
			pUPnPDevice->StopWaitingForControlResponse();

			DPFX(DPFPREP, 0, "Server didn't respond in time!");
			hr = DPNHERR_SERVERNOTRESPONDING;
			goto Failure;
		}


		//
		// If we're here, then we've gotten a valid response from the server.
		//

		if (RespInfo.hrErrorCode != DPNH_OK)
		{
			DPFX(DPFPREP, 1, "Server returned failure response 0x%lx, assuming no port mapping.",
				RespInfo.hrErrorCode);
			fNoPortMapping = TRUE;
		}
	}
	else
	{
		DPFX(DPFPREP, 1, "Address %u.%u.%u.%u doesn't match NAT's external IP address, not querying.",
			psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinQueryAddress->sin_addr.S_un.S_un_b.s_b4);

		fNoPortMapping = TRUE;
	}


	dwCacheMapFlags = QUERYFLAGSMASK(dwFlags);


	//
	// Determine address locality (if requested) and cache the no-mapping
	// result.
	//
	if (fNoPortMapping)
	{
		//
		// Try determining if the address is local, if allowed.
		//
		if (dwFlags & DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED)
		{
			if (this->IsAddressLocal(pDevice, psaddrinQueryAddress))
			{
				DPFX(DPFPREP, 5, "Address appears to be local, returning NOMAPPINGBUTPRIVATE.");

				dwCacheMapFlags |= CACHEMAPOBJ_PRIVATEBUTUNMAPPED;

				hr = DPNHERR_NOMAPPINGBUTPRIVATE;
			}
			else
			{
				DPFX(DPFPREP, 5, "Address does not appear to be local, returning NOMAPPING.");

				hr = DPNHERR_NOMAPPING;
			}
		}
		else
		{
			hr = DPNHERR_NOMAPPING;
		}


		//
		// Cache the fact that we could not determine a mapping for that
		// address, if allowed.
		//
		if (dwFlags & DPNHQUERYADDRESS_CACHENOTFOUND)
		{
			pCacheMap = new CCacheMap(psaddrinQueryAddress,
									(GETTIMESTAMP() + g_dwCacheLifeNotFound),
									(dwCacheMapFlags | CACHEMAPOBJ_NOTFOUND));
			if (pCacheMap == NULL)
			{
				hr = DPNHERR_OUTOFMEMORY;
				goto Failure;
			}

			pCacheMap->m_blList.InsertBefore(pblCachedMaps);
		}

		goto Failure;
	}


	DPFX(DPFPREP, 1, "Server returned a private mapping (%u.%u.%u.%u:%u).",
		((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b1,
		((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b2,
		((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b3,
		((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b4,
		NTOHS(RespInfo.wInternalPort));


	//
	// Convert the loopback address to the device address.
	//
	if (RespInfo.dwInternalClientV4 == NETWORKBYTEORDER_INADDR_LOOPBACK)
	{
		RespInfo.dwInternalClientV4 = pDevice->GetLocalAddressV4();

		DPFX(DPFPREP, 1, "Converted private loopback address to device address (%u.%u.%u.%u).",
			((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b1,
			((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b2,
			((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b3,
			((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b4);
	}

	//
	// If the UPnP device doesn't support asymmetric mappings and thus didn't
	// return a port, or it did return one but it's the bogus port 0, assume
	// the internal port is the same port as the external one.
	//
	if (RespInfo.wInternalPort == 0)
	{
		RespInfo.wInternalPort = psaddrinQueryAddress->sin_port;

		DPFX(DPFPREP, 2, "Converted invalid internal port to the query address public port (%u).",
			NTOHS(psaddrinQueryAddress->sin_port));
	}


	//
	// Ensure that we're not getting something bogus.
	//
	SOCKADDR_IN		saddrinTemp;
	saddrinTemp.sin_addr.S_un.S_addr = RespInfo.dwInternalClientV4;
	if ((RespInfo.dwInternalClientV4 == 0) ||
		(! this->IsAddressLocal(pDevice, &saddrinTemp)))
	{
		//
		// If the returned address is the same as the NAT's public address,
		// it's probably Windows ICS returning an ICF mapping.  We still treat
		// it as an invalid mapping, but we will cache the results since there
		// are legimitate cases where we can see this.
		//
		if (RespInfo.dwInternalClientV4 == pUPnPDevice->GetExternalIPAddressV4())
		{
			DPFX(DPFPREP, 1, "UPnP device returned its public address as the private address (%u.%u.%u.%u:%u).  Probably ICS + ICF, but treating as no mapping.",
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b1,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b2,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b3,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b4,
				NTOHS(RespInfo.wInternalPort));
			DNASSERTX(! "UPnP device returned public address as the private address!", 3);
		
			//
			// Cache the fact that we did not get a valid mapping for that
			// address, if allowed.
			//
			if (dwFlags & DPNHQUERYADDRESS_CACHENOTFOUND)
			{
				pCacheMap = new CCacheMap(psaddrinQueryAddress,
										(GETTIMESTAMP() + g_dwCacheLifeNotFound),
										(dwCacheMapFlags | CACHEMAPOBJ_NOTFOUND));
				if (pCacheMap == NULL)
				{
					hr = DPNHERR_OUTOFMEMORY;
					goto Failure;
				}

				pCacheMap->m_blList.InsertBefore(pblCachedMaps);
			}
		}
		else
		{
			DPFX(DPFPREP, 0, "UPnP device returned an invalid private address (%u.%u.%u.%u:%u)!  Assuming no mapping.",
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b1,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b2,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b3,
				((IN_ADDR*) (&RespInfo.dwInternalClientV4))->S_un.S_un_b.s_b4,
				NTOHS(RespInfo.wInternalPort));
			DNASSERTX(! "Why is UPnP device returning invalid private address?", 2);
		}
		
		hr = DPNHERR_NOMAPPING;
		goto Failure;
	}


	//
	// Return the address mapping to our caller.
	//
	ZeroMemory(psaddrinResponseAddress, sizeof(SOCKADDR_IN));
	psaddrinResponseAddress->sin_family			= AF_INET;
	psaddrinResponseAddress->sin_addr.s_addr	= RespInfo.dwInternalClientV4;
	psaddrinResponseAddress->sin_port			= RespInfo.wInternalPort;


	//
	// Cache the fact that we found a mapping for that address, if allowed.
	//
	if (dwFlags & DPNHQUERYADDRESS_CACHEFOUND)
	{
		pCacheMap = new CCacheMap(psaddrinQueryAddress,
								(GETTIMESTAMP() + g_dwCacheLifeFound),
								dwCacheMapFlags);
		if (pCacheMap == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		pCacheMap->SetResponseAddressV4(psaddrinResponseAddress->sin_addr.S_un.S_addr,
										psaddrinResponseAddress->sin_port);

		pCacheMap->m_blList.InsertBefore(pblCachedMaps);
	}


Exit:

	if (pszMessage != NULL)
	{
		DNFree(pszMessage);
		pszMessage = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// If we started waiting for a response, clear that.
	//
	if (fStartedWaitingForControlResponse)
	{
		pUPnPDevice->StopWaitingForControlResponse();
	}

	goto Exit;
} // CNATHelpUPnP::InternalUPnPQueryAddress




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ExtendUPnPLease"
//=============================================================================
// CNATHelpUPnP::ExtendUPnPLease
//-----------------------------------------------------------------------------
//
// Description:    Asks the UPnP server to extend a port mapping lease.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference if it's using the
//				pointer.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CRegisteredPort * pRegisteredPort	- Pointer to port object mapping to
//											extend.
//
// Returns: HRESULT
//	DPNH_OK							- The extension was successful.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_SERVERNOTRESPONDING		- The server did not respond to the
//										message.
//=============================================================================
HRESULT CNATHelpUPnP::ExtendUPnPLease(CRegisteredPort * const pRegisteredPort)
{
	HRESULT			hr;
	CDevice *		pDevice;
	CUPnPDevice *	pUPnPDevice;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pRegisteredPort);


	DNASSERT(pRegisteredPort != NULL);

	pDevice = pRegisteredPort->GetOwningDevice();
	DNASSERT(pDevice != NULL);

	pUPnPDevice = pDevice->GetUPnPDevice();
	DNASSERT(pUPnPDevice != NULL);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);
	DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);

#ifdef DBG
	if (pRegisteredPort->HasPermanentUPnPLease())
	{
		DPFX(DPFPREP, 1, "Extending already permanent UPnP lease for registered port 0x%p.",
			pRegisteredPort);
	}
#endif // DBG


	//
	// UPnP devices don't have port extension per se, you just reregister the
	// mapping.
	//
	hr = this->MapPortsOnUPnPDevice(pUPnPDevice, pRegisteredPort);


	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;
} // CNATHelpUPnP::ExtendUPnPLease





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::UnmapUPnPPort"
//=============================================================================
// CNATHelpUPnP::UnmapUPnPPort
//-----------------------------------------------------------------------------
//
// Description:    Asks the UPnP server to release a port mapping.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference if it's using the
//				device.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CRegisteredPort * pRegisteredPort	- Pointer to port object mapping to
//											release.
//	DWORD dwMaxValidPort				- Highest address index in array to
//											try freeing.  This may be one more
//											than the actual number to indicate
//											all should be freed.
//	BOOL fNeedToDeleteRegValue			- Whether the corresponding crash
//											recovery registry value needs to
//											be deleted as well.
//
// Returns: HRESULT
//	DPNH_OK							- The extension was successful.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_SERVERNOTRESPONDING		- The server did not respond to the
//										message.
//=============================================================================
HRESULT CNATHelpUPnP::UnmapUPnPPort(CRegisteredPort * const pRegisteredPort,
									const DWORD dwMaxValidPort,
									const BOOL fNeedToDeleteRegValue)
{
	HRESULT						hr = DPNH_OK;
	BOOL						fStartedWaitingForControlResponse = FALSE;
	CDevice *					pDevice;
	CUPnPDevice *				pUPnPDevice;
	SOCKADDR_IN *				psaddrinPublic;
	SOCKADDR_IN *				psaddrinPrivate;
	TCHAR						tszExternalPort[32];
	int							iContentLength;
	TCHAR						tszContentLength[32];
	TCHAR						tszHost[22]; // "xxx.xxx.xxx.xxx:xxxxx" + NULL termination
	char *						pszMessage = NULL;
	int							iMsgSize;
	int							iPrevMsgSize = 0;
	int							iReturn;
	DWORD						dwTemp;
	UPNP_CONTROLRESPONSE_INFO	RespInfo;
	DWORD						dwStartTime;
	DWORD						dwTimeout;
	SOCKADDR_IN *				psaddrinHostAddress;
#ifdef DBG
	DWORD						dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i, %i)",
		this, pRegisteredPort, ((int) dwMaxValidPort), fNeedToDeleteRegValue);


	DNASSERT(pRegisteredPort != NULL);
	DNASSERT(dwMaxValidPort != 0); 
	DNASSERT(dwMaxValidPort <= pRegisteredPort->GetNumAddresses());

	pDevice = pRegisteredPort->GetOwningDevice();
	DNASSERT(pDevice != NULL);

	pUPnPDevice = pDevice->GetUPnPDevice();
	DNASSERT(pUPnPDevice != NULL);
	//
	// GetUPnPDevice did not add a reference to pUPnPDevice for us.
	//
	pUPnPDevice->AddRef();

	DNASSERT(pUPnPDevice->IsReady());


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);



	//
	// Prevent trying to remove the lease twice.
	//
	pRegisteredPort->NoteRemovingUPnPLease();


	if (dwMaxValidPort == pRegisteredPort->GetNumAddresses())
	{
		DPFX(DPFPREP, 7, "Unmapping all %u addresses for registered port 0x%p on UPnP device 0x%p.",
			dwMaxValidPort, pRegisteredPort, pUPnPDevice);
	}
	else
	{
		DPFX(DPFPREP, 7, "Error cleanup code, only unmapping first %u addresses (of %u possible) for registered port 0x%p on UPnP device 0x%p.",
			dwMaxValidPort, pRegisteredPort->GetNumAddresses(),
			pRegisteredPort, pUPnPDevice);
	}


	//
	// Set up variables we'll need.
	//
	DNASSERT(pUPnPDevice->GetServiceControlURL() != NULL);

	psaddrinHostAddress = pUPnPDevice->GetHostAddress();
	wsprintf(tszHost, _T("%u.%u.%u.%u:%u"),
			psaddrinHostAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinHostAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinHostAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinHostAddress->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(psaddrinHostAddress->sin_port));


	//
	// Get the array of ports we're releasing.
	//
	psaddrinPublic = pRegisteredPort->GetUPnPPublicAddressesArray();
	psaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();


	//
	// Loop through each port that we're unmapping.
	//
	for(dwTemp = 0; dwTemp < dwMaxValidPort; dwTemp++)
	{
		//
		// The UPnP Internet Gateway Device spec does not require reference
		// counting for mapped ports.  If you register something that had
		// already been registered, it will succeed silently.
		//
		// This means that we will never be able to tell which NAT client was
		// the last person to use a given shared port.  You could try detecting
		// any other users at the app level (above DPNATHLP), but there is
		// always a race condition.  You could also have a concept of shared-
		// port owner, but then you'd have to implement owner migration a la
		// DPlay host migration.  That is sooo not worth it.
		//
		// The other option is to just never unmap shared ports.  You can
		// probably imagine the implications of this solution, but it's what we
		// have to do.
		//

		if (pRegisteredPort->IsSharedPort())
		{
			DPFX(DPFPREP, 1, "Registered port 0x%p address index %u (private address %u.%u.%u.%u:%u) is shared, not unmapping.",
				pRegisteredPort, dwTemp,
				psaddrinPublic[dwTemp].sin_addr.S_un.S_un_b.s_b1,
				psaddrinPublic[dwTemp].sin_addr.S_un.S_un_b.s_b2,
				psaddrinPublic[dwTemp].sin_addr.S_un.S_un_b.s_b3,
				psaddrinPublic[dwTemp].sin_addr.S_un.S_un_b.s_b4,
				NTOHS(psaddrinPublic[dwTemp].sin_port));
			continue;
		}


		//
		// If the control socket got disconnected after the last message,
		// then reconnect.
		//
		if (! pUPnPDevice->IsConnected())
		{
			hr = this->ReconnectUPnPControlSocket(pUPnPDevice);
			if (hr != S_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't reconnect UPnP control socket!");
				goto Failure;
			}
		}

		DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


		wsprintf(tszExternalPort, _T("%u"),
				NTOHS(psaddrinPublic[dwTemp].sin_port));


		iContentLength = strlen("<s:Envelope" EOL)
						+ strlen("    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL)
						+ strlen("    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL)
						+ strlen("  <s:Body>" EOL)
						+ strlen("    <u:" ACTION_DELETEPORTMAPPING_A " xmlns:u=\"") + pUPnPDevice->GetStaticServiceURILength() + strlen("\">" EOL)
						+ strlen("      <" ARG_DELETEPORTMAPPING_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_DELETEPORTMAPPING_NEWREMOTEHOST_A ">" EOL)
						+ strlen("      <" ARG_DELETEPORTMAPPING_NEWEXTERNALPORT_A ">") + _tcslen(tszExternalPort) + strlen("</" ARG_DELETEPORTMAPPING_NEWEXTERNALPORT_A ">" EOL)
						+ strlen("      <" ARG_DELETEPORTMAPPING_NEWPROTOCOL_A ">") + 3 + strlen("</" ARG_DELETEPORTMAPPING_NEWPROTOCOL_A ">" EOL)
						+ strlen("    </u:" ACTION_DELETEPORTMAPPING_A ">" EOL)
						+ strlen("  </s:Body>" EOL)
						+ strlen("</s:Envelope>" EOL)
						+ strlen(EOL);

		wsprintf(tszContentLength, _T("%i"), iContentLength);

		iMsgSize = strlen("POST ") + strlen(pUPnPDevice->GetServiceControlURL()) + strlen(" " HTTP_VERSION EOL)
					+ strlen("HOST: ") + _tcslen(tszHost) + strlen(EOL)
					+ strlen("CONTENT-LENGTH: ") + _tcslen(tszContentLength) + strlen(EOL)
					+ strlen("CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL)
					+ strlen("SOAPACTION: ") + pUPnPDevice->GetStaticServiceURILength() + strlen("#" ACTION_DELETEPORTMAPPING_A EOL)
					+ strlen(EOL)
					+ iContentLength;


		//
		// Allocate (or reallocate) the message buffer.
		//
		if (iMsgSize > iPrevMsgSize)
		{
			if (pszMessage != NULL)
			{
				DNFree(pszMessage);
				pszMessage = NULL;
			}

			pszMessage = (char*) DNMalloc(iMsgSize + 1); // include room for NULL termination that isn't actually sent
			if (pszMessage == NULL)
			{
				hr = DPNHERR_OUTOFMEMORY;
				goto Failure;
			}

			iPrevMsgSize = iMsgSize;
		}

		strcpy(pszMessage, "POST ");
		strcat(pszMessage, pUPnPDevice->GetServiceControlURL());
		strcat(pszMessage, " " HTTP_VERSION EOL);
		strcat(pszMessage, "HOST: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszHost,
						(_tcslen(tszHost) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszHost);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-LENGTH: ");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszContentLength,
						(_tcslen(tszContentLength) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszContentLength);
#endif // ! UNICODE
		strcat(pszMessage, EOL);
		strcat(pszMessage, "CONTENT-TYPE: text/xml; charset=\"utf-8\"" EOL);
		strcat(pszMessage, "SOAPACTION: ");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "#" ACTION_DELETEPORTMAPPING_A EOL);
		strcat(pszMessage, EOL);

		strcat(pszMessage, "<s:Envelope" EOL);
		strcat(pszMessage, "    xmlns:s=\"" URL_SOAPENVELOPE_A "\"" EOL);
		strcat(pszMessage, "    s:encodingStyle=\"" URL_SOAPENCODING_A "\">" EOL);
		strcat(pszMessage, "  <s:Body>" EOL);
		strcat(pszMessage, "    <u:" ACTION_DELETEPORTMAPPING_A " xmlns:u=\"");
		strcat(pszMessage, pUPnPDevice->GetStaticServiceURI());
		strcat(pszMessage, "\">" EOL);

		strcat(pszMessage, "      <" ARG_DELETEPORTMAPPING_NEWREMOTEHOST_A ">" UPNP_WILDCARD "</" ARG_DELETEPORTMAPPING_NEWREMOTEHOST_A ">" EOL);

		strcat(pszMessage, "      <" ARG_DELETEPORTMAPPING_NEWEXTERNALPORT_A ">");
#ifdef UNICODE
		STR_jkWideToAnsi((pszMessage + strlen(pszMessage)),
						tszExternalPort,
						(_tcslen(tszExternalPort) + 1));
#else // ! UNICODE
		strcat(pszMessage, tszExternalPort);
#endif // ! UNICODE
		strcat(pszMessage, "</" ARG_DELETEPORTMAPPING_NEWEXTERNALPORT_A ">" EOL);

		strcat(pszMessage, "      <" ARG_DELETEPORTMAPPING_NEWPROTOCOL_A ">");
		strcat(pszMessage, ((pRegisteredPort->IsTCP()) ? "TCP" : "UDP"));
		strcat(pszMessage, "</" ARG_DELETEPORTMAPPING_NEWPROTOCOL_A ">" EOL);

		strcat(pszMessage, "    </u:" ACTION_DELETEPORTMAPPING_A ">" EOL);
		strcat(pszMessage, "  </s:Body>" EOL);
		strcat(pszMessage, "</s:Envelope>" EOL);
		strcat(pszMessage, EOL);


#ifdef DBG
		this->PrintUPnPTransactionToFile(pszMessage,
										iMsgSize,
										"Outbound delete port mapping request",
										pDevice);
#endif // DBG

		iReturn = this->m_pfnsend(pUPnPDevice->GetControlSocket(),
									pszMessage,
									iMsgSize,
									0);

		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u when sending control request to UPnP device!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}

		if (iReturn != iMsgSize)
		{
			DPFX(DPFPREP, 0, "Didn't send entire message (%i != %i)?!", iReturn, iMsgSize);
			DNASSERT(FALSE);
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// We have the lock so no one could have tried to receive data from
		// the control socket yet.  Mark the device as waiting for a
		// response.
		//
		ZeroMemory(&RespInfo, sizeof(RespInfo));
		pUPnPDevice->StartWaitingForControlResponse(CONTROLRESPONSETYPE_DELETEPORTMAPPING,
													&RespInfo);
		fStartedWaitingForControlResponse = TRUE;


		//
		// Actually wait for the response.
		//
		dwStartTime = GETTIMESTAMP();
		dwTimeout = g_dwUPnPResponseTimeout;
		do
		{
			hr = this->CheckForReceivedUPnPMsgsOnDevice(pUPnPDevice, dwTimeout);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed receiving UPnP messages!");
				goto Failure;
			}

			//
			// We either timed out or got some data.  Check if we got a
			// response of some type.
			//
			if (! pUPnPDevice->IsWaitingForControlResponse())
			{
				break;
			}


			//
			// Make sure our device is still connected.
			//
			if (! pUPnPDevice->IsConnected())
			{
				DPFX(DPFPREP, 0, "UPnP device 0x%p disconnected while deleting port index %u!",
					pUPnPDevice, dwTemp);
				
				pUPnPDevice->StopWaitingForControlResponse();
				
				hr = DPNHERR_SERVERNOTRESPONDING;
				goto Failure;
			}


			//
			// Calculate how long we have left to wait.  If the calculation
			// goes negative, it means we're done.
			//
			dwTimeout = g_dwUPnPResponseTimeout - (GETTIMESTAMP() - dwStartTime);
		}
		while (((int) dwTimeout > 0));


		//
		// If we never got the response, stop waiting for it.
		//
		if (pUPnPDevice->IsWaitingForControlResponse())
		{
			pUPnPDevice->StopWaitingForControlResponse();

			DPFX(DPFPREP, 0, "Server didn't respond in time for port index %u!",
				dwTemp);
			hr = DPNHERR_SERVERNOTRESPONDING;
			goto Failure;
		}


		//
		// If we're here, then we've gotten a valid response (success or
		// failure) from the server.  If it's a failure, print out a note
		// but continue.
		//
#ifdef DBG
		switch (RespInfo.hrErrorCode)
		{
			case DPNH_OK:
			{
				//
				// Succeeded.
				//
				break;
			}

			case DPNHERR_NOMAPPING:
			{
				//
				// UPnP device didn't know what we were talking about.
				//
				DPFX(DPFPREP, 1, "Server didn't recognize mapping for port index %u, continuing.",
					dwTemp);
				break;
			}

			default:
			{
				//
				// Something else happened.
				//
				DPFX(DPFPREP, 0, "Server returned failure response 0x%lx for port index %u!  Ignoring.",
					RespInfo.hrErrorCode, dwTemp);
				break;
			}
		}
#endif // DBG


		//
		// If the lease is permanent, we need to remove the reference from
		// the registry.
		//
		if (pRegisteredPort->HasPermanentUPnPLease())
		{
			IN_ADDR		inaddrTemp;
			TCHAR		tszInternalClient[16]; // "xxx.xxx.xxx.xxx" + NULL termination
			TCHAR		tszInternalPort[32];
			DWORD		dwDescriptionLength;
			CRegistry	RegObject;
			WCHAR		wszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
#ifdef UNICODE
			TCHAR *		ptszDescription = wszDescription;
#else // ! UNICODE
			char		szDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
			TCHAR *		ptszDescription = szDescription;
#endif // ! UNICODE


			//
			// Note that the device address is not necessarily the same as
			// the address the user originally registered, particularly the
			// 0.0.0.0 wildcard address will get remapped.
			//
			inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();
			wsprintf(tszInternalClient, _T("%u.%u.%u.%u"),
					inaddrTemp.S_un.S_un_b.s_b1,
					inaddrTemp.S_un.S_un_b.s_b2,
					inaddrTemp.S_un.S_un_b.s_b3,
					inaddrTemp.S_un.S_un_b.s_b4);

			wsprintf(tszInternalPort, _T("%u"),
					NTOHS(psaddrinPrivate[dwTemp].sin_port));


			//
			// Generate a description for this mapping.  The format is:
			//
			//     [executable_name] (nnn.nnn.nnn.nnn:nnnnn) nnnnn {"TCP" | "UDP"}
			//
			// That way nothing needs to be localized.
			//

			dwDescriptionLength = GetModuleFileName(NULL,
													ptszDescription,
													(MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1));
			if (dwDescriptionLength != 0)
			{
				//
				// Be paranoid and make sure the description string is valid.
				//
				ptszDescription[MAX_UPNP_MAPPING_DESCRIPTION_SIZE - 1] = 0;

				//
				// Get just the executable name from the path.
				//
#ifdef WINCE
				GetExeName(ptszDescription);
#else // ! WINCE
#ifdef UNICODE
				_wsplitpath(ptszDescription, NULL, NULL, ptszDescription, NULL);
#else // ! UNICODE
				_splitpath(ptszDescription, NULL, NULL, ptszDescription, NULL);
#endif // ! UNICODE
#endif // ! WINCE


				dwDescriptionLength = _tcslen(ptszDescription)		// executable name
									+ 2								// " ("
									+ _tcslen(tszInternalClient)	// private IP address
									+ 1								// ":"
									+ _tcslen(tszInternalPort)		// private port
									+ 2								// ") "
									+ _tcslen(tszExternalPort)		// public port
									+ 4;							// " TCP" | " UDP"

				//
				// Make sure the long string will fit.  If not, use the
				// abbreviated version.
				//
				if (dwDescriptionLength > MAX_UPNP_MAPPING_DESCRIPTION_SIZE)
				{
					dwDescriptionLength = 0;
				}
			}

			if (dwDescriptionLength == 0)
			{
				//
				// Use the abbreviated version we know will fit.
				//
				wsprintf(ptszDescription,
						_T("(%s:%s) %s %s"),
						tszInternalClient,
						tszInternalPort,
						tszExternalPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}
			else
			{
				//
				// There's enough room, tack on the rest of the
				// description.
				//
				wsprintf((ptszDescription + _tcslen(ptszDescription)),
						_T(" (%s:%s) %s %s"),
						tszInternalClient,
						tszInternalPort,
						tszExternalPort,
						((pRegisteredPort->IsTCP()) ? _T("TCP") : _T("UDP")));
			}



			if (fNeedToDeleteRegValue)
			{
				DPFX(DPFPREP, 7, "Removing NAT lease \"%s\" crash cleanup registry entry.",
					ptszDescription);


				if (! RegObject.Open(HKEY_LOCAL_MACHINE,
									DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVENATMAPPINGS,
									FALSE,
									TRUE,
									TRUE,
									DPN_KEY_ALL_ACCESS))
				{
					DPFX(DPFPREP, 0, "Couldn't open active NAT mapping key, unable to remove crash cleanup reference!");
				}
				else
				{
#ifndef UNICODE
					dwDescriptionLength = strlen(szDescription) + 1;
					hr = STR_jkAnsiToWide(wszDescription, szDescription, dwDescriptionLength);
					if (hr != S_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't convert NAT mapping description to Unicode (err = 0x%lx), unable to remove crash cleanup reference!",
							hr);

						//
						// Ignore error and continue.
						//
						hr = S_OK;
					}
					else
#endif // ! UNICODE
					{
						BOOL	fResult;


						//
						// Ignore error.
						//
						fResult = RegObject.DeleteValue(wszDescription);
						if (! fResult)
						{
							DPFX(DPFPREP, 0, "Couldn't delete NAT mapping value \"%s\"!  Continuing.",
								ptszDescription);
						}
					}

					RegObject.Close();
				}
			}
			else
			{
				DPFX(DPFPREP, 6, "No need to remove NAT lease \"%s\" crash cleanup registry entry.",
					ptszDescription);
			}
		}
		else
		{
			//
			// Registered port doesn't have a permanent UPnP lease.
			//
		}

		//
		// Move on to next port.
		//
	}

	
	//
	// If we're here, everything was successful.
	//

	DPFX(DPFPREP, 8, "Registered port 0x%p mapping successfully deleted from UPnP device (0x%p).",
		pRegisteredPort, pUPnPDevice);


Exit:

	if (pszMessage != NULL)
	{
		DNFree(pszMessage);
		pszMessage = NULL;
	}

	//
	// No matter whether we succeeded or failed, remove the UPnP public addresses
	// array and decrement the total lease count.
	//
	pRegisteredPort->DestroyUPnPPublicAddressesArray();

	DNASSERT(this->m_dwNumLeases > 0);
	this->m_dwNumLeases--;

	DPFX(DPFPREP, 7, "UPnP lease for 0x%p removed, total num leases = %u.",
		pRegisteredPort, this->m_dwNumLeases);

	
	pRegisteredPort->NoteNotPermanentUPnPLease();

	pRegisteredPort->NoteNotRemovingUPnPLease();



	pUPnPDevice->DecRef();

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// If we started waiting for a response, clear that.
	//
	if (fStartedWaitingForControlResponse)
	{
		pUPnPDevice->StopWaitingForControlResponse();
	}

	goto Exit;
} // CNATHelpUPnP::UnmapUPnPPort





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CleanupInactiveNATMappings"
//=============================================================================
// CNATHelpUPnP::CleanupInactiveNATMappings
//-----------------------------------------------------------------------------
//
// Description:    Looks for any mappings previously made by other DPNHUPNP
//				instances that are no longer active (because of a crash), and
//				unmaps them.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference if it's using the
//				device.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device to use.
//
// Returns: HRESULT
//	DPNH_OK							- The extension was successful.
//	DPNHERR_GENERIC					- An error occurred.
//	DPNHERR_SERVERNOTRESPONDING		- The server did not respond to the
//										message.
//=============================================================================
HRESULT CNATHelpUPnP::CleanupInactiveNATMappings(CUPnPDevice * const pUPnPDevice)
{
	HRESULT					hr = DPNH_OK;
	CDevice *				pDevice;
	CRegistry				RegObject;
	BOOL					fOpenedRegistry = FALSE;
	DWORD					dwIndex;
	WCHAR					wszValueName[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DWORD					dwValueNameSize;
	DPNHACTIVENATMAPPING	dpnhanm;
	DWORD					dwValueSize;
	CBilink *				pBilink;
	CUPnPDevice *			pUPnPDeviceTemp = NULL;	// NULLed out because PREfast has been hassling me for a while, even though the code is safe
	TCHAR					tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	DNHANDLE				hNamedObject = NULL;
	CRegisteredPort *		pRegisteredPort = NULL;
	BOOL					fSetPrivateAddresses = FALSE;
	SOCKADDR_IN				saddrinPrivate;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pUPnPDevice);


	DNASSERT(pUPnPDevice != NULL);

	pDevice = pUPnPDevice->GetOwningDevice();
	DNASSERT(pDevice != NULL);



	if (! RegObject.Open(HKEY_LOCAL_MACHINE,
						DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVENATMAPPINGS,
						FALSE,
						TRUE,
						TRUE,
						DPN_KEY_ALL_ACCESS))
	{
		DPFX(DPFPREP, 1, "Couldn't open active NAT mapping key, not performing crash cleanup.");
		DNASSERT(hr == DPNH_OK);
		goto Exit;
	}

	fOpenedRegistry = TRUE;


	//
	// Walk the list of active mappings.
	//
	dwIndex = 0;
	do
	{
		dwValueNameSize = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
		if (! RegObject.EnumValues(wszValueName, &dwValueNameSize, dwIndex))
		{
			//
			// There was an error or there aren't any more keys.  We're done.
			//
			break;
		}


		//
		// Try reading that mapping's data.
		//
		dwValueSize = sizeof(dpnhanm);
		if (! RegObject.ReadBlob(wszValueName, (LPBYTE) (&dpnhanm), &dwValueSize))
		{
			//
			// We don't have a lock protecting the registry, so some other
			// instance could have deleted the key between when we enumerated
			// it and now.  We'll stop trying (and hopefully that other
			// instance will cover the rest of the items).
			//
			DPFX(DPFPREP, 0, "Couldn't read \"%ls\" mapping value!  Done with cleanup.",
				wszValueName);

			DNASSERT(hr == DPNH_OK);
			goto Exit;
		}

		//
		// Validate the data read.
		//
		if ((dwValueSize != sizeof(dpnhanm)) ||
			(dpnhanm.dwVersion != ACTIVE_MAPPING_VERSION))
		{
			DPFX(DPFPREP, 0, "The \"%ls\" mapping value is invalid!  Done with cleanup.",
				wszValueName);

			//
			// Move to next item.
			//
			dwIndex++;
			continue;
		}


		//
		// See if it's owned by the local NATHelp instance.
		//
		if (dpnhanm.dwInstanceKey == this->m_dwInstanceKey)
		{
			//
			// We own(ed) it.  See if it was associated with a UPnP device
			// that's now gone.
			//
			pBilink = this->m_blUPnPDevices.GetNext();
			while (pBilink != &this->m_blUPnPDevices)
			{
				DNASSERT(! pBilink->IsEmpty());
				pUPnPDeviceTemp = UPNPDEVICE_FROM_BILINK(pBilink);

				if (pUPnPDeviceTemp->GetID() == dpnhanm.dwUPnPDeviceID)
				{
					//
					// This mapping truly is active, leave it alone.
					//
					break;
				}

				pBilink = pBilink->GetNext();
			}

			//
			// If we found the mapping, go on to the next one.
			//
			if (pBilink != &this->m_blUPnPDevices)
			{
				//
				// Note that despite what PREfast v1.0.1195 says,
				// pUPnPDeviceTemp will always be valid if we get here.
				// However, I gave in and NULLed out the pointer up top.
				//
				DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to current instance (%u)'s UPnP device 0x%p.",
					wszValueName, dpnhanm.dwInstanceKey, pUPnPDeviceTemp);

				//
				// Move to next item.
				//
				dwIndex++;
				continue;
			}


			//
			// Otherwise, we gave up on this mapping earlier.
			//

			DNASSERT((this->m_dwNumDeviceRemoves > 0) || (this->m_dwNumServerFailures > 0));

			DPFX(DPFPREP, 4, "NAT mapping \"%ls\" was owned by current instance (%u)'s UPnP device ID %u that no longer exists.",
				wszValueName, dpnhanm.dwInstanceKey, dpnhanm.dwUPnPDeviceID);
		}
		else
		{
			//
			// See if that DPNHUPNP instance is still around.
			//

#ifndef WINCE
			if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
			{
				wsprintf(tszObjectName, _T( "Global\\" ) INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
			}
			else
#endif // ! WINCE
			{
				wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
			}

			hNamedObject = DNOpenEvent(SYNCHRONIZE, FALSE, tszObjectName);
			if (hNamedObject != NULL)
			{
				//
				// This is still an active mapping.
				//

				DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to instance %u, which is still active.",
					wszValueName, dpnhanm.dwInstanceKey);

				DNCloseHandle(hNamedObject);
				hNamedObject = NULL;

				//
				// Move to next item.
				//
				dwIndex++;
				continue;
			}


			DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to instance %u, which no longer exists.",
				wszValueName, dpnhanm.dwInstanceKey);
		}


		//
		// Delete the value now that we have the information we need.
		//
		if (! RegObject.DeleteValue(wszValueName))
		{
			//
			// See ReadBlob comments.  Stop trying to cleanup.
			//
			DPFX(DPFPREP, 0, "Couldn't delete \"%ls\"!  Done with cleanup.",
				wszValueName);

			DNASSERT(hr == DPNH_OK);
			goto Exit;
		}


		//
		// Create a fake registered port that we will deregister.  Ignore the
		// firewall state flags.
		//
		pRegisteredPort = new CRegisteredPort(0, (dpnhanm.dwFlags & REGPORTOBJMASK_UPNP));
		if (pRegisteredPort == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		//
		// Assert that the other UPnP information/state flags are not set.
		//
		DNASSERT(! pRegisteredPort->IsUPnPPortUnavailable());
		DNASSERT(! pRegisteredPort->IsRemovingUPnPLease());


		//
		// Temporarily associate the registered port with the device.
		//
		pRegisteredPort->MakeDeviceOwner(pDevice);


		
		ZeroMemory(&saddrinPrivate, sizeof(saddrinPrivate));
		saddrinPrivate.sin_family				= AF_INET;
		saddrinPrivate.sin_addr.S_un.S_addr		= dpnhanm.dwInternalAddressV4;
		saddrinPrivate.sin_port					= dpnhanm.wInternalPort;


		//
		// Store the private address.
		//
		hr = pRegisteredPort->SetPrivateAddresses(&saddrinPrivate, 1);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed creating UPnP address array!");
			goto Failure;
		}

		fSetPrivateAddresses = TRUE;
		

		//
		// Create the public address array.
		//
		hr = pRegisteredPort->CreateUPnPPublicAddressesArray();
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed creating UPnP address array!");
			goto Failure;
		}


		//
		// Fake increase the number of leases we have.  It will just get
		// decremented in UnmapUPnPPort.
		//
		DPFX(DPFPREP, 7, "Creating temporary UPnP lease 0x%p, total num leases = %u.",
			pRegisteredPort, this->m_dwNumLeases);
		this->m_dwNumLeases++;


		//
		// Store the public port.
		//
		pRegisteredPort->SetUPnPPublicV4Address(0,
												dpnhanm.dwExternalAddressV4,
												dpnhanm.wExternalPort);


		//
		// Actually free the port.
		//
		hr = this->UnmapUPnPPort(pRegisteredPort, 1, FALSE);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Failed deleting temporary UPnP port!");
			goto Failure;
		}


		pRegisteredPort->ClearPrivateAddresses();
		fSetPrivateAddresses = FALSE;

		pRegisteredPort->ClearDeviceOwner();

		delete pRegisteredPort;
		pRegisteredPort = NULL;


		//
		// Move to the next mapping.  Don't increment index since we just
		// deleted the previous entry and everything shifts down one.
		//
	}
	while (TRUE);


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pRegisteredPort != NULL)
	{
		if (pRegisteredPort->HasUPnPPublicAddresses())
		{
			pRegisteredPort->DestroyUPnPPublicAddressesArray();

			//
			// Remove the lease counter.
			//
			DNASSERT(this->m_dwNumLeases > 0);
			this->m_dwNumLeases--;

			DPFX(DPFPREP, 7, "UPnP lease for 0x%p removed, total num leases = %u.",
				pRegisteredPort, this->m_dwNumLeases);
		}

		if (fSetPrivateAddresses)
		{
			pRegisteredPort->ClearPrivateAddresses();
			fSetPrivateAddresses = FALSE;
		}

		pRegisteredPort->ClearDeviceOwner();

		delete pRegisteredPort;
		pRegisteredPort = NULL;
	}

	if (fOpenedRegistry)
	{
		RegObject.Close();
	}

	goto Exit;
} // CNATHelpUPnP::CleanupInactiveNATMappings





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::IsNATPublicPortInUseLocally"
//=============================================================================
// CNATHelpUPnP::IsNATPublicPortInUseLocally
//-----------------------------------------------------------------------------
//
// Description:    Looks for any mappings previously made by DPNHUPNP instances
//				that are still active that use the given public port.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	WORD wPortHostOrder		- Port to check, in host byte order.
//
// Returns: BOOL
//=============================================================================
BOOL CNATHelpUPnP::IsNATPublicPortInUseLocally(const WORD wPortHostOrder)
{
	BOOL					fResult = FALSE;
	WORD					wExternalPort;
	CRegistry				RegObject;
	BOOL					fOpenedRegistry = FALSE;
	DWORD					dwIndex;
	WCHAR					wszValueName[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DWORD					dwValueNameSize;
	DPNHACTIVENATMAPPING	dpnhanm;
	CBilink *				pBilink;
	CUPnPDevice *			pUPnPDevice = NULL;	// NULLed out because PREfast has been hassling me for a while, even though the code is safe
	DWORD					dwValueSize;
	TCHAR					tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	DNHANDLE				hNamedObject = NULL;


	DPFX(DPFPREP, 6, "(0x%p) Parameters: (%u)", this, wPortHostOrder);


	wExternalPort = HTONS(wPortHostOrder);


	if (! RegObject.Open(HKEY_LOCAL_MACHINE,
						DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVENATMAPPINGS,
						FALSE,
						TRUE,
						TRUE,
						DPN_KEY_ALL_ACCESS))
	{
		DPFX(DPFPREP, 1, "Couldn't open active NAT mapping key, assuming port not in use.");
		goto Exit;
	}

	fOpenedRegistry = TRUE;


	//
	// Walk the list of active mappings.
	//
	dwIndex = 0;
	do
	{
		dwValueNameSize = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
		if (! RegObject.EnumValues(wszValueName, &dwValueNameSize, dwIndex))
		{
			//
			// There was an error or there aren't any more keys.  We're done.
			//
			break;
		}


		//
		// Try reading that mapping's data.
		//
		dwValueSize = sizeof(dpnhanm);
		if (! RegObject.ReadBlob(wszValueName, (LPBYTE) (&dpnhanm), &dwValueSize))
		{
			//
			// We don't have a lock protecting the registry, so some other
			// instance could have deleted the key between when we enumerated
			// it and now.  We'll stop trying (and hopefully that other
			// instance will cover the rest of the items).
			//
			DPFX(DPFPREP, 0, "Couldn't read \"%ls\" mapping value, assuming port not in use.",
				wszValueName);
			goto Exit;
		}

		//
		// Validate the data read.
		//
		if ((dwValueSize != sizeof(dpnhanm)) ||
			(dpnhanm.dwVersion != ACTIVE_MAPPING_VERSION))
		{
			DPFX(DPFPREP, 0, "The \"%ls\" mapping value is invalid, assuming port not in use.",
				wszValueName);

			//
			// Move to next item.
			//
			dwIndex++;
			continue;
		}


		//
		// Is this the right port?
		//
		if (dpnhanm.wExternalPort == wExternalPort)
		{
			//
			// See if it's owned by the local NATHelp instance.
			//
			if (dpnhanm.dwInstanceKey == this->m_dwInstanceKey)
			{
				//
				// We own(ed) it.  See if it was associated with a UPnP device
				// that's now gone.
				//
				pBilink = this->m_blUPnPDevices.GetNext();
				while (pBilink != &this->m_blUPnPDevices)
				{
					DNASSERT(! pBilink->IsEmpty());
					pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);

					if (pUPnPDevice->GetID() == dpnhanm.dwUPnPDeviceID)
					{
						//
						// This mapping truly still active.
						//
						fResult = TRUE;
						break;
					}

					pBilink = pBilink->GetNext();
				}


				if (pBilink != &this->m_blUPnPDevices)
				{
					//
					// Note that despite what PREfast v1.0.1195 says,
					// pUPnPDevice will always be valid if we get here.
					// However, I gave in and NULLed out the pointer up top.
					//
					DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to current instance (%u)'s UPnP device 0x%p.",
						wszValueName, dpnhanm.dwInstanceKey, pUPnPDevice);
				}
				else
				{
					DPFX(DPFPREP, 4, "NAT mapping \"%ls\" was owned by current instance (%u)'s UPnP device ID %u that no longer exists.",
						wszValueName, dpnhanm.dwInstanceKey, dpnhanm.dwUPnPDeviceID);
				}
			}
			else
			{
				//
				// See if that DPNHUPNP instance is still around.
				//

#ifndef WINCE
				if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
				{
					wsprintf(tszObjectName, _T( "Global\\" ) INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
				}
				else
#endif // ! WINCE
				{
					wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
				}

				hNamedObject = DNOpenEvent(SYNCHRONIZE, FALSE, tszObjectName);
				if (hNamedObject != NULL)
				{
					//
					// This is still an active instance.  Since we can't walk
					// his list of UPnP devices, we have to assume the port is
					// still in use.
					//

					DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to instance %u, which is still active.  Assuming port in use.",
						wszValueName, dpnhanm.dwInstanceKey);

					DNCloseHandle(hNamedObject);
					hNamedObject = NULL;

					fResult = TRUE;
				}
				else
				{
					DPFX(DPFPREP, 4, "NAT mapping \"%ls\" belongs to instance %u, which no longer exists.",
						wszValueName, dpnhanm.dwInstanceKey);
				}
			}


			//
			// We found the mapping.  We have our result now.
			//
			goto Exit;
		}

		
		//
		// If we're here, this is not the external port we're looking for.
		//
		DPFX(DPFPREP, 8, "NAT mapping \"%ls\" does not use external port %u.",
			wszValueName, wPortHostOrder);


		//
		// Move to the next mapping.
		//
		dwIndex++;
	}
	while (TRUE);


	//
	// If we're here, we didn't find the mapping.
	//
	DPFX(DPFPREP, 4, "Didn't find any local NAT mappings that use external port %u.",
		wPortHostOrder);


Exit:

	if (fOpenedRegistry)
	{
		RegObject.Close();
	}

	DPFX(DPFPREP, 6, "(0x%p) Returning: [%i]", this, fResult);

	return fResult;
} // CNATHelpUPnP::IsNATPublicPortInUseLocally





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CheckForUPnPAnnouncements"
//=============================================================================
// CNATHelpUPnP::CheckForUPnPAnnouncements
//-----------------------------------------------------------------------------
//
// Description:    Receives any UPnP announcement messages sent to this control
//				point.  The entire timeout period will elapse, unless all
//				devices get responses earlier.
//
//				   This will only send discovery requests for local devices
//				unless fSendRemoteGatewayDiscovery is TRUE.  However, we may
//				still detect new ones if we got a straggling response from the
//				last time we were allowed to send remotely.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	DWORD dwTimeout						- How long to wait for messages to
//											arrive.
//	BOOL fSendRemoteGatewayDiscovery	- Whether we can search remotely or
//											not.
//
// Returns: HRESULT
//	DPNH_OK				- Messages were received successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CheckForUPnPAnnouncements(const DWORD dwTimeout,
												const BOOL fSendRemoteGatewayDiscovery)
{
	HRESULT			hr;
	DWORD			dwNumberOfTimes = 0;
	DWORD			dwCurrentTime;
	DWORD			dwEndTime;
	DWORD			dwNextSearchMessageTime;
	FD_SET			fdsRead;
	DWORD			dwNumDevicesSearchingForUPnPDevices;
	timeval			tv;
	CBilink *		pBilink;
	CDevice *		pDevice;
	int				iReturn;
	int				iRecvAddressSize;
	char			acBuffer[UPNP_DGRAM_RECV_BUFFER_SIZE];
	SOCKADDR_IN		saddrinRecvAddress;
	DWORD			dwError;
	BOOL			fInitiatedConnect = FALSE;
#ifdef DBG
	BOOL			fGotData = FALSE;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters:(%u, %i)",
		this, dwTimeout, fSendRemoteGatewayDiscovery);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);


	dwCurrentTime = GETTIMESTAMP();
	dwEndTime = dwCurrentTime + dwTimeout;
	dwNextSearchMessageTime = dwCurrentTime;

	//
	// Keep looping until the timeout elapses.
	//
	do
	{
		FD_ZERO(&fdsRead);
		dwNumDevicesSearchingForUPnPDevices = 0;


		//
		// Build an FD_SET for all the sockets and send out search messages for
		// all devices.
		//
		DNASSERT(! this->m_blDevices.IsEmpty());
		pBilink = this->m_blDevices.GetNext();
		while (pBilink != &this->m_blDevices)
		{
			DNASSERT(! pBilink->IsEmpty());
			pDevice = DEVICE_FROM_BILINK(pBilink);


			//
			// We add it to the set whether we search or not, since if we're
			// not searching, we're going to be clearing straggling messages.
			//
			DNASSERT(pDevice->GetUPnPDiscoverySocket() != INVALID_SOCKET);
			FD_SET(pDevice->GetUPnPDiscoverySocket(), &fdsRead);


			//
			// Don't send search messages if we already have a UPnP device or
			// this is the loopback adapter.
			//
			if ((pDevice->GetUPnPDevice() == NULL) &&
				(pDevice->GetLocalAddressV4() != NETWORKBYTEORDER_INADDR_LOOPBACK))
			{
				//
				// If this is the first time through the loop, clear the
				// CONNRESET warning flags.
				//
				if (dwNumberOfTimes == 0)
				{
					pDevice->NoteNotGotRemoteUPnPDiscoveryConnReset();
					pDevice->NoteNotGotLocalUPnPDiscoveryConnReset();
				}


				//
				// Send out search messages if it's time.
				//
				if ((int) (dwNextSearchMessageTime - dwCurrentTime) <= 0)
				{
					hr = this->SendUPnPSearchMessagesForDevice(pDevice,
																fSendRemoteGatewayDiscovery);
					if (hr != DPNH_OK)
					{
						DPFX(DPFPREP, 0, "Couldn't send UPnP search messages via every device!");
						goto Failure;
					}
				}
				else
				{
					//
					// Not time to send search messages.
					//
				}


				//
				// For subsequent times through the loop, make sure we didn't
				// get a CONNRESET earlier telling us not to try again.
				// The "attempt?" flags got set in
				// SendUPnPSearchMessagesForDevice, and the CONNRESET flags
				// were cleared the first time we entered here.
				//
				if ((pDevice->IsOKToPerformRemoteUPnPDiscovery()) ||
					(pDevice->IsOKToPerformLocalUPnPDiscovery()))
				{
					//
					// Remember that we're trying to detect an Internet Gateway
					// for this device.  See caveat immediately following, and
					// below for this variable's usage.
					//
					dwNumDevicesSearchingForUPnPDevices++;


					//
					// Minor optimization:
					//
					// If we're only supposed to be trying locally, and we're
					// the public address for a local gateway, assume that we
					// actually shouldn't be trying locally.  This is because
					// Windows XP ICS keeps port 1900 open even on the public
					// adapter, so we think we need to look for a local one
					// even though we won't find one.  So once the remote
					// lookup comes back with a CONNRESET, we no longer need to
					// bother trying.
					//
					// So first check if we're only trying locally.
					//
					if ((pDevice->IsOKToPerformLocalUPnPDiscovery()) &&
						(! pDevice->IsOKToPerformRemoteUPnPDiscovery()))
					{
						CBilink *		pBilinkPrivateDevice;
						CDevice *		pPrivateDevice;
						CUPnPDevice *	pUPnPDevice;


						//
						// Then loop through every device.
						//
						pBilinkPrivateDevice = this->m_blDevices.GetNext();
						while (pBilinkPrivateDevice != &this->m_blDevices)
						{
							pPrivateDevice = DEVICE_FROM_BILINK(pBilinkPrivateDevice);
							pUPnPDevice = pPrivateDevice->GetUPnPDevice();


							//
							// If it's not the device we're querying and it has
							// a ready UPnP device, dig deeper.
							//
							if ((pPrivateDevice != pDevice) &&
								(pUPnPDevice != NULL) &&
								(pUPnPDevice->IsReady()))
							{
								//
								// If its a local UPnP device and its public
								// address is this device's address, we found a
								// match.
								//
								if ((pUPnPDevice->IsLocal()) &&
									(pUPnPDevice->GetExternalIPAddressV4() == pDevice->GetLocalAddressV4()))
								{
									DPFX(DPFPREP, 4, "Device 0x%p is the public address for device 0x%p's local UPnP device 0x%p, not including in search.",
										pDevice, pPrivateDevice, pUPnPDevice);
									
									//
									// Remove the count we added above.
									//
									dwNumDevicesSearchingForUPnPDevices--;

									//
									// Stop searching.
									//
									break;
								}
								
								//
								// Otherwise keep going.
								//
								DPFX(DPFPREP, 8, "Skipping device 0x%p, UPnP device 0x%p not local (%i, control addr = %u.%u.%u.%u) or its public address doesn't match device 0x%p's address.",
									pPrivateDevice,
									pUPnPDevice,
									(! pUPnPDevice->IsLocal()),
									pUPnPDevice->GetControlAddress()->sin_addr.S_un.S_un_b.s_b1,
									pUPnPDevice->GetControlAddress()->sin_addr.S_un.S_un_b.s_b2,
									pUPnPDevice->GetControlAddress()->sin_addr.S_un.S_un_b.s_b3,
									pUPnPDevice->GetControlAddress()->sin_addr.S_un.S_un_b.s_b4,
									pDevice);
							}
							else
							{
								DPFX(DPFPREP, 8, "Skipping device 0x%p, it's the one we're looking for (matched 0x%p), it doesn't have a UPnP device (0x%p is NULL), and/or its UPnP device is not ready.",
									pPrivateDevice, pDevice, pUPnPDevice);
							}


							//
							// Go on to next device.
							//
							pBilinkPrivateDevice = pBilinkPrivateDevice->GetNext();
						}
					}
					else
					{
						//
						// Either not searching locally, or searching both
						// locally and remotely.
						//
						DPFX(DPFPREP, 8, "Device 0x%p local search OK = %i, remote search OK = %i.",
							pDevice,
							pDevice->IsOKToPerformLocalUPnPDiscovery(),
							pDevice->IsOKToPerformRemoteUPnPDiscovery());
					}
				}
				else
				{
					DPFX(DPFPREP, 3, "Device 0x%p should not perform UPnP discovery.",
						pDevice);
				}
			}
			else
			{
				DPFX(DPFPREP, 8, "Device 0x%p already has UPnP device (0x%p) or is loopback address.",
					pDevice, pDevice->GetUPnPDevice());
			}

			
			pBilink = pBilink->GetNext();
		}


		//
		// Wait for any data, unless all devices already have an Internet
		// Gateway, in which case we only want to clear the receive queue for
		// the sockets.
		//
		if (dwNumDevicesSearchingForUPnPDevices == 0)
		{
			DPFX(DPFPREP, 7, "No devices need to search for UPnP devices, clearing straggling messages from sockets.");

			tv.tv_usec		= 0;
		}
		else
		{
			//
			// Calculate the next time to send if we just sent search messages.
			//
			if ((int) (dwNextSearchMessageTime - dwCurrentTime) <= 0)
			{
				dwNextSearchMessageTime += UPNP_SEARCH_MESSAGE_INTERVAL;

				//
				// If we took way longer than expected in a previous loop
				// (because of stress or Win9x errata), the next search time
				// may have already passed.  Just search right now if that's
				// the case.
				//
				if ((int) (dwNextSearchMessageTime - dwCurrentTime) <= 0)
				{
					dwNextSearchMessageTime = dwCurrentTime;
				}
			}


			//
			// See how long we should wait for responses.  Choose the total end
			// time or the next search message time, whichever is shorter.
			//
			if ((int) (dwEndTime - dwNextSearchMessageTime) < 0)
			{
				DPFX(DPFPREP, 7, "Waiting %u ms for incoming responses.",
					(dwEndTime - dwCurrentTime));

				tv.tv_usec	= (dwEndTime - dwCurrentTime) * 1000;
			}
			else
			{
				DPFX(DPFPREP, 7, "Waiting %u ms for incoming responses, and then might send search messages again.",
					(dwNextSearchMessageTime - dwCurrentTime));

				tv.tv_usec	= (dwNextSearchMessageTime - dwCurrentTime) * 1000;
			}
		}

		tv.tv_sec			= 0;


		iReturn = this->m_pfnselect(0, &fdsRead, NULL, NULL, &tv);
		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u trying to select on UPnP discovery sockets!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// See if any sockets were selected.
		//
		if (iReturn > 0)
		{
			//
			// Loop through all devices, looking for those that have data.
			//
			pBilink = this->m_blDevices.GetNext();
			while (pBilink != &this->m_blDevices)
			{
				DNASSERT(! pBilink->IsEmpty());
				pDevice = DEVICE_FROM_BILINK(pBilink);


				//
				// If this device's socket is set there's data to read.
				//
				//if (FD_ISSET(pDevice->GetUPnPDiscoverySocket(), &fdsRead))
				if (this->m_pfn__WSAFDIsSet(pDevice->GetUPnPDiscoverySocket(), &fdsRead))
				{
#ifdef DBG
					fGotData = TRUE;
#endif // DBG


					iRecvAddressSize = sizeof(saddrinRecvAddress);

					iReturn = this->m_pfnrecvfrom(pDevice->GetUPnPDiscoverySocket(),
												acBuffer,
												(sizeof(acBuffer) - 1), // -1 to allow string termination
												0,
												(SOCKADDR*) (&saddrinRecvAddress),
												&iRecvAddressSize);

					if ((iReturn == 0) || (iReturn == SOCKET_ERROR))
					{
						dwError = this->m_pfnWSAGetLastError();


						//
						// WSAENOBUFS means WinSock is out of memory.
						//
						if (dwError == WSAENOBUFS)
						{
							DPFX(DPFPREP, 0, "WinSock returned WSAENOBUFS while receiving discovery response!");
							hr = DPNHERR_OUTOFMEMORY;
							goto Failure;
						}


						//
						// All other errors besides WSAECONNRESET are
						// unexpected and mean we should bail.
						//
						if (dwError != WSAECONNRESET)
						{
							DPFX(DPFPREP, 0, "Got sockets error %u trying to receive on device 0x%p!",
								dwError, pDevice);
							hr = DPNHERR_GENERIC;
							goto Failure;
						}


						//
						// If we're here, it must be WSAECONNRESET.  Correlate
						// it with the outbound message that generated it so we
						// don't bother waiting for a response from that
						// location.
						// Validate that it's for the port to which the message
						// should have been sent.
						//
						if (saddrinRecvAddress.sin_port == HTONS(UPNP_PORT))
						{
							if (saddrinRecvAddress.sin_addr.S_un.S_addr == pDevice->GetLocalAddressV4())
							{
								DPFX(DPFPREP, 1, "Got CONNRESET for local discovery attempt on device 0x%p (%u.%u.%u.%u:%u).",
									pDevice,
									saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b1,
									saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b2,
									saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b3,
									saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b4,
									NTOHS(saddrinRecvAddress.sin_port));

								//
								// Note the local error.
								//
								pDevice->NoteGotLocalUPnPDiscoveryConnReset();
							}
							else
							{
								if (! g_fUseMulticastUPnPDiscovery)
								{
									IN_ADDR		inaddrGateway;


									if ((! this->GetAddressToReachGateway(pDevice, &inaddrGateway)) ||
										(inaddrGateway.S_un.S_addr == INADDR_BROADCAST) ||
										(saddrinRecvAddress.sin_addr.S_un.S_addr == inaddrGateway.S_un.S_addr))
									{
										DPFX(DPFPREP, 2, "Got CONNRESET for remote discovery attempt on device 0x%p (%u.%u.%u.%u:%u).",
											pDevice,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b1,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b2,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b3,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b4,
											NTOHS(saddrinRecvAddress.sin_port));

										//
										// Note the remote error.
										//
										pDevice->NoteGotRemoteUPnPDiscoveryConnReset();
									}
									else
									{
										DPFX(DPFPREP, 1, "Ignoring CONNRESET on device 0x%p, sender %u.%u.%u.%u is not gateway %u.%u.%u.%u.",
											pDevice,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b1,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b2,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b3,
											saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b4,
											inaddrGateway.S_un.S_un_b.s_b1,
											inaddrGateway.S_un.S_un_b.s_b2,
											inaddrGateway.S_un.S_un_b.s_b3,
											inaddrGateway.S_un.S_un_b.s_b4);
									}
								}
								else
								{
									DPFX(DPFPREP, 1, "Ignoring CONNRESET on device 0x%p from sender %u.%u.%u.%u, we are using multicast discovery.",
										pDevice,
										saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b1,
										saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b2,
										saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b3,
										saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b4);
								}
							}
						}
						else
						{
							DPFX(DPFPREP, 1, "Ignoring CONNRESET on device 0x%p for invalid port (%u.%u.%u.%u:%u).",
								pDevice,
								saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b1,
								saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b2,
								saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b3,
								saddrinRecvAddress.sin_addr.S_un.S_un_b.s_b4,
								NTOHS(saddrinRecvAddress.sin_port));
						}
					}
					else
					{
						DNASSERT(iRecvAddressSize == sizeof(saddrinRecvAddress));
						DNASSERT(iReturn < sizeof(acBuffer));


						hr = this->HandleUPnPDiscoveryResponseMsg(pDevice,
																&saddrinRecvAddress,
																acBuffer,
																iReturn,
																&fInitiatedConnect);
						if (hr != DPNH_OK)
						{
							DPFX(DPFPREP, 0, "Couldn't handle UPnP discovery response message (err = 0x%lx), ignoring.",
								hr);
						}
					}
				}
				
				pBilink = pBilink->GetNext();
			}


			//
			// Make sure we actually found a socket with data.
			//
			DNASSERT(fGotData);
		}
		else
		{
			//
			// We timed out.  If we were just clearing receive buffers for the
			// socket(s), we're done.
			//
			if (dwNumDevicesSearchingForUPnPDevices == 0)
			{
				break;
			}
		}


		//
		// Increase the counter.
		//
		dwNumberOfTimes++;


		//
		// Get current time for figuring out how much longer to wait.
		//
		dwCurrentTime = GETTIMESTAMP();
	}
	while ((int) (dwEndTime - dwCurrentTime) > 0);


	hr = DPNH_OK;


	//
	// If we initiated connections to any UPnP devices, wait for them to
	// complete.
	//
	if (fInitiatedConnect)
	{
		hr = this->WaitForUPnPConnectCompletions();
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't wait for UPnP connect completions!");
			goto Failure;
		}
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::CheckForUPnPAnnouncements





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::WaitForUPnPConnectCompletions"
//=============================================================================
// CNATHelpUPnP::WaitForUPnPConnectCompletions
//-----------------------------------------------------------------------------
//
// Description:    Waits for completions for pending TCP connects to UPnP
//				Internet gateway devices.
//
//				   UPnP devices may get removed from list if a failure occurs.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: HRESULT
//	DPNH_OK				- Connects were handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::WaitForUPnPConnectCompletions(void)
{
	HRESULT			hr;
	int				iNumSockets;
	FD_SET			fdsWrite;
	FD_SET			fdsExcept;
	CBilink *		pBilink;
	CUPnPDevice *	pUPnPDevice;
	timeval			tv;
	int				iReturn;
	BOOL			fRequestedDescription = FALSE;
	DWORD			dwStartTime;
	DWORD			dwTimeout;
	CDevice *		pDevice;
#ifdef DBG
	BOOL			fFoundCompletion;
	DWORD			dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Enter", this);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);


	//
	// Loop until all sockets are connected or there's a timeout.
	//
	do
	{
		//
		// Check for any connect completions.  Start by building two FD_SETs
		// for all the sockets with pending connects.
		//

		FD_ZERO(&fdsWrite);
		FD_ZERO(&fdsExcept);
		iNumSockets = 0;

		pBilink = this->m_blUPnPDevices.GetNext();
		while (pBilink != &this->m_blUPnPDevices)
		{
			DNASSERT(! pBilink->IsEmpty());
			pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);

			if (pUPnPDevice->IsConnecting())
			{
				DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);

				FD_SET(pUPnPDevice->GetControlSocket(), &fdsWrite);
				FD_SET(pUPnPDevice->GetControlSocket(), &fdsExcept);
				iNumSockets++;
			}
			
			pBilink = pBilink->GetNext();
		}


		//
		// If there weren't any sockets that had pending connections, then
		// we're done here.
		//
		if (iNumSockets <= 0)
		{
			DPFX(DPFPREP, 7, "No more UPnP device control sockets with pending connections.");
			break;
		}


		DPFX(DPFPREP, 7, "There are %i UPnP device control sockets with pending connections.",
			iNumSockets);


		//
		// Wait for connect completions.  We don't wait for the full TCP/IP
		// timeout (which is why we made it non-blocking).
		//

		tv.tv_usec	= 0;
		tv.tv_sec	= g_dwUPnPConnectTimeout;

		iReturn = this->m_pfnselect(0, NULL, &fdsWrite, &fdsExcept, &tv);
		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u trying to select on UPnP device sockets!",
				dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// If no sockets were selected, that means the connections timed out.
		// Remove all the devices that were waiting.
		//
		if (iReturn == 0)
		{
			DPFX(DPFPREP, 3, "Select for %u seconds timed out.", g_dwUPnPConnectTimeout);

			pBilink = this->m_blUPnPDevices.GetNext();
			while (pBilink != &this->m_blUPnPDevices)
			{
				DNASSERT(! pBilink->IsEmpty());
				pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);
				pBilink = pBilink->GetNext();

				if (pUPnPDevice->IsConnecting())
				{
					DPFX(DPFPREP, 7, "UPnP device 0x%p is still connecting, removing.",
						pUPnPDevice);


					//
					// Dump this unusable UPnP device and continue.
					//

					pDevice = pUPnPDevice->GetOwningDevice();
					DNASSERT(pUPnPDevice->GetOwningDevice() != NULL);

					DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);
					this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
					pUPnPDevice->SetControlSocket(INVALID_SOCKET);


					//
					// This may cause our pUPnPDevice pointer to become
					// invalid.
					//
					this->ClearDevicesUPnPDevice(pDevice);


#ifdef DBG
					iNumSockets--;
#endif // DBG
				}
				else
				{
					DPFX(DPFPREP, 7, "UPnP device 0x%p is not trying to connect or has safely connected.",
						pUPnPDevice);
				}
			}

			//
			// We should have destroyed the same number of devices that were
			// waiting.
			//
			DNASSERT(iNumSockets == 0);

			//
			// Continue on to handling any sockets succeeded previously.
			//
			break;
		}


		//
		// If we're here, some sockets were signalled.
		//

#ifdef DBG
		DPFX(DPFPREP, 7, "There are %i sockets with connect activity.", iReturn);
		fFoundCompletion = FALSE;
#endif // DBG

		pBilink = this->m_blUPnPDevices.GetNext();
		while (pBilink != &this->m_blUPnPDevices)
		{
			DNASSERT(! pBilink->IsEmpty());
			pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);
			pBilink = pBilink->GetNext();

			if (pUPnPDevice->IsConnecting())
			{
				DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


				//
				// If this UPnP device's socket is in the write set it
				// connected successfully.
				//
				//if (FD_ISSET(pUPnPDevice->GetControlSocket(), &fdsWrite))
				if (this->m_pfn__WSAFDIsSet(pUPnPDevice->GetControlSocket(), &fdsWrite))
				{
					pUPnPDevice->NoteConnected();

#ifdef DBG
					fFoundCompletion = TRUE;
#endif // DBG

					if (! pUPnPDevice->IsReady())
					{
						DPFX(DPFPREP, 2, "UPnP device object 0x%p now connected to Internet gateway device.",
							pUPnPDevice);

						hr = this->SendUPnPDescriptionRequest(pUPnPDevice);
						if (hr != DPNH_OK)
						{
							DPFX(DPFPREP, 0, "Couldn't send UPnP description request to device object 0x%p!  Disconnecting.",
								pUPnPDevice);


							//
							// Dump this unusable UPnP device and continue.
							//

							pDevice = pUPnPDevice->GetOwningDevice();
							DNASSERT(pUPnPDevice->GetOwningDevice() != NULL);

							//
							// This may cause our pUPnPDevice pointer to become
							// invalid.
							//
							this->ClearDevicesUPnPDevice(pDevice);
						}
						else
						{
							fRequestedDescription = TRUE;
						}
					}
					else
					{
						DPFX(DPFPREP, 2, "UPnP device object 0x%p successfully reconnected to Internet gateway device.",
							pUPnPDevice);
					}
				}
				else
				{
					//
					// If this UPnP device's socket is in the except set it
					// failed to connect.
					//
					//if (FD_ISSET(pUPnPDevice->GetControlSocket(), &fdsExcept))
					if (this->m_pfn__WSAFDIsSet(pUPnPDevice->GetControlSocket(), &fdsExcept))
					{
#ifdef DBG
						int		iError;
						int		iErrorSize;


						fFoundCompletion = TRUE;

						//
						// Print out the reason why it couldn't connect.
						// Ignore the direct return code from getsockopt.
						//
						iError = 0;
						iErrorSize = sizeof(iError);
						this->m_pfngetsockopt(pUPnPDevice->GetControlSocket(),
											SOL_SOCKET,
											SO_ERROR,
											(char*) (&iError),
											&iErrorSize);
						DPFX(DPFPREP, 1, "Connecting to UPnP device object 0x%p failed with error %i, removing from list.",
							pUPnPDevice, iError);
#endif // DBG

						//
						// This UPnP device is useless if it doesn't respond.
						// Throw it out.
						//

						pDevice = pUPnPDevice->GetOwningDevice();
						DNASSERT(pUPnPDevice->GetOwningDevice() != NULL);

						this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
						pUPnPDevice->SetControlSocket(INVALID_SOCKET);

						//
						// This may cause our pUPnPDevice pointer to become
						// invalid.
						//
						this->ClearDevicesUPnPDevice(pDevice);
					}
					else
					{
						//
						// Socket is still connecting.
						//
					}
				}
			}
			else
			{
				//
				// This socket is already connected.
				//
			}
		}


		//
		// Make sure we actually found a socket with a connect completion this
		// time through.
		//
		DNASSERT(fFoundCompletion);
	}
	while (TRUE);


	//
	// If we're here, all UPnP devices are connected or have since been
	// destroyed.
	//
	if (fRequestedDescription)
	{
		//
		// Wait for the description responses to come back.
		//
		dwStartTime = GETTIMESTAMP();
		dwTimeout = g_dwUPnPResponseTimeout;
		do
		{
			hr = this->CheckForReceivedUPnPMsgsOnAllDevices(dwTimeout);
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Failed receiving UPnP messages!");
				goto Failure;
			}

			//
			// We either timed out or got some data.  Check if we got the
			// response(s) we need.  Reuse the fRequestedDescription
			// boolean.
			//

			fRequestedDescription = FALSE;

			pBilink = this->m_blUPnPDevices.GetNext();
			while (pBilink != &this->m_blUPnPDevices)
			{
				DNASSERT(! pBilink->IsEmpty());
				pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);

				if (! pUPnPDevice->IsReady())
				{
					if (pUPnPDevice->IsConnected())
					{
						DPFX(DPFPREP, 7, "UPnP device 0x%p is not ready yet.",
							pUPnPDevice);
						fRequestedDescription = TRUE;
					}
					else
					{
						DPFX(DPFPREP, 4, "UPnP device 0x%p got disconnected before receiving description response.",
							pUPnPDevice);
					}

					break;
				}

				pBilink = pBilink->GetNext();
			}

			if (! fRequestedDescription)
			{
				DPFX(DPFPREP, 6, "All UPnP devices are ready or disconnected now.");

				//
				// Break out of the wait loop.
				//
				break;
			}


			//
			// Calculate how long we have left to wait.  If the calculation
			// goes negative, it means we're done.
			//
			dwTimeout = g_dwUPnPResponseTimeout - (GETTIMESTAMP() - dwStartTime);
		}
		while (((int) dwTimeout > 0));


		//
		// Any devices that still aren't ready yet were either disconnected or
		// are taking too long and should be removed.
		//
		pBilink = this->m_blUPnPDevices.GetNext();
		while (pBilink != &this->m_blUPnPDevices)
		{
			DNASSERT(! pBilink->IsEmpty());
			pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);
			pBilink = pBilink->GetNext();

			if (! pUPnPDevice->IsReady())
			{
				DPFX(DPFPREP, 1, "UPnP device 0x%p got disconnected or took too long to get ready, removing.",
					pUPnPDevice);


				pDevice = pUPnPDevice->GetOwningDevice();
				DNASSERT(pUPnPDevice->GetOwningDevice() != NULL);

				//
				// This may cause our pUPnPDevice pointer to become
				// invalid.
				//
				this->ClearDevicesUPnPDevice(pDevice);
			}
		}
	}
	else
	{
		DPFX(DPFPREP, 7, "Did not request any descriptions.");
	}


	//
	// If we're here, everything is successful and we're done.
	//
	hr = DPNH_OK;


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::WaitForUPnPConnectCompletions





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CheckForReceivedUPnPMsgsOnAllDevices"
//=============================================================================
// CNATHelpUPnP::CheckForReceivedUPnPMsgsOnAllDevices
//-----------------------------------------------------------------------------
//
// Description:    Handles any incoming data on the TCP sockets connect to UPnP
//				Internet gateway devices.
//
//				   UPnP devices with failures may get removed from the list.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	DWORD dwTimeout		- How long to wait for messages to arrive, or 0 to just
//							poll.
//
// Returns: HRESULT
//	DPNH_OK				- Messages were handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CheckForReceivedUPnPMsgsOnAllDevices(const DWORD dwTimeout)
{
	HRESULT			hr;
	int				iNumSockets;
	FD_SET			fdsRead;
	CBilink *		pBilink;
	CUPnPDevice *	pUPnPDevice;
	timeval			tv;
	int				iReturn;
#ifdef DBG
	BOOL			fFoundData = FALSE;
	DWORD			dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (%u)", this, dwTimeout);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);


Rewait:

	iNumSockets = 0;


	//
	// Check for any data.  Start by building an FD_SET for all the sockets
	// with completed connections.
	//

	FD_ZERO(&fdsRead);

	pBilink = this->m_blUPnPDevices.GetNext();
	while (pBilink != &this->m_blUPnPDevices)
	{
		DNASSERT(! pBilink->IsEmpty());
		pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);

		if (pUPnPDevice->IsConnected())
		{
			DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);

			FD_SET(pUPnPDevice->GetControlSocket(), &fdsRead);
			iNumSockets++;
		}
		
		pBilink = pBilink->GetNext();
	}


	//
	// If there weren't any sockets that were connected, then we're done here.
	//
	if (iNumSockets <= 0)
	{
		DPFX(DPFPREP, 7, "No connected UPnP device control sockets.");
		hr = DPNH_OK;
		goto Exit;
	}


	DPFX(DPFPREP, 7, "There are %i connected UPnP device control sockets.",
		iNumSockets);


	//
	// Wait for received data.
	//

	tv.tv_usec	= dwTimeout * 1000;
	tv.tv_sec	= 0;

	iReturn = this->m_pfnselect(0, &fdsRead, NULL, NULL, &tv);
	if (iReturn == SOCKET_ERROR)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Got sockets error %u trying to select on UPnP device sockets!",
			dwError);
#endif // DBG
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// If no sockets were selected, we're done.
	//
	if (iReturn == 0)
	{
		DPFX(DPFPREP, 7, "Timed out waiting for data on %i sockets.",
			iNumSockets);
		hr = DPNH_OK;
		goto Exit;
	}


	//
	// If we're here, some sockets were signalled.
	//

	pBilink = this->m_blUPnPDevices.GetNext();
	while (pBilink != &this->m_blUPnPDevices)
	{
		DNASSERT(! pBilink->IsEmpty());
		pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilink);
		pBilink = pBilink->GetNext();

		if (pUPnPDevice->IsConnected())
		{
			DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


			//
			// If this UPnP device's socket is in the read set it has data.
			//
			//if (FD_ISSET(pUPnPDevice->GetControlSocket(), &fdsRead))
			if (this->m_pfn__WSAFDIsSet(pUPnPDevice->GetControlSocket(), &fdsRead))
			{
#ifdef DBG
				fFoundData = TRUE;
#endif // DBG

				//
				// Grab a reference, since ReceiveUPnPDataStream may clear the
				// device.
				//
				pUPnPDevice->AddRef();


				hr = this->ReceiveUPnPDataStream(pUPnPDevice);
				if (hr != DPNH_OK)
				{
					DPFX(DPFPREP, 0, "Couldn't receive UPnP stream from device object 0x%p (err = 0x%lx)!  Disconnecting.",
						pUPnPDevice, hr);

					//
					// Dump this unusable UPnP device and continue.
					//
					if (pUPnPDevice->GetOwningDevice() != NULL)
					{
						this->ClearDevicesUPnPDevice(pUPnPDevice->GetOwningDevice());
					}
					else
					{
						DPFX(DPFPREP, 1, "UPnP device 0x%p's has already been removed from owning device.",
							pUPnPDevice);
					}

					hr = DPNH_OK;
				}

				//
				// Remove the reference we added.
				//
				pUPnPDevice->DecRef();
			}
			else
			{
				//
				// Socket does not have any data.
				//
				DPFX(DPFPREP, 8, "Skipping UPnP device 0x%p because it does not have any data.",
					pUPnPDevice);
			}
		}
		else
		{
			//
			// This socket is not connected yet/anymore.
			//
			DPFX(DPFPREP, 7, "Skipping unconnected UPnP device 0x%p.", pUPnPDevice);
		}
	}


	//
	// Make sure we actually found a socket with data.
	//
	DNASSERT(fFoundData);


	//
	// We found data, so see if there's more.  Connection should be closed
	// after responses.
	//
	DPFX(DPFPREP, 7, "Waiting for more data on the sockets.");
	goto Rewait;



Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::CheckForReceivedUPnPMsgsOnAllDevices





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CheckForReceivedUPnPMsgsOnDevice"
//=============================================================================
// CNATHelpUPnP::CheckForReceivedUPnPMsgsOnDevice
//-----------------------------------------------------------------------------
//
// Description:    Handles any incoming data on the TCP socket for the given
//				UPnP device.
//
//				   If the UPnP device encounters a failure, it may get removed
//				from the list.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device to receive data.
//	DWORD dwTimeout				- How long to wait for messages to arrive, or 0
//									to just poll.
//
// Returns: HRESULT
//	DPNH_OK				- Messages were handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::CheckForReceivedUPnPMsgsOnDevice(CUPnPDevice * const pUPnPDevice,
														const DWORD dwTimeout)
{
	HRESULT			hr;
	FD_SET			fdsRead;
	timeval			tv;
	int				iReturn;
#ifdef DBG
	DWORD			dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %u)", this, pUPnPDevice, dwTimeout);


	DNASSERT(this->m_dwFlags & NATHELPUPNPOBJ_INITIALIZED);
	DNASSERT(pUPnPDevice != NULL);
	DNASSERT(pUPnPDevice->IsConnected());
	DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);


	do
	{
		//
		// Create an FD_SET for the socket in question.
		//

		FD_ZERO(&fdsRead);
		FD_SET(pUPnPDevice->GetControlSocket(), &fdsRead);


		//
		// Wait for received data.
		//

		tv.tv_usec	= dwTimeout * 1000;
		tv.tv_sec	= 0;

		iReturn = this->m_pfnselect(0, &fdsRead, NULL, NULL, &tv);
		if (iReturn == SOCKET_ERROR)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Got sockets error %u trying to select on UPnP device sockets!",
				dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}


		//
		// If no sockets were selected, we're done.
		//
		if (iReturn == 0)
		{
			DPFX(DPFPREP, 7, "Timed out waiting for data on UPnP device 0x%p's socket.",
				pUPnPDevice);
			break;
		}


		DNASSERT(iReturn == 1);
		//DNASSERT(FD_ISSET(pUPnPDevice->GetControlSocket(), &fdsRead));
		DNASSERT(this->m_pfn__WSAFDIsSet(pUPnPDevice->GetControlSocket(), &fdsRead));


		hr = this->ReceiveUPnPDataStream(pUPnPDevice);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't receive UPnP stream from device object 0x%p!  Disconnecting.",
				pUPnPDevice);

			//
			// Dump this unusable UPnP device and continue.
			//
			if (pUPnPDevice->GetOwningDevice() != NULL)
			{
				this->ClearDevicesUPnPDevice(pUPnPDevice->GetOwningDevice());
			}
			else
			{
				DPFX(DPFPREP, 1, "UPnP device 0x%p's has already been removed from owning device.",
					pUPnPDevice);
			}

			break;
		}

		//
		// If the UPnP device is no longer connected, we're done.
		//
		if (! pUPnPDevice->IsConnected())
		{
			DPFX(DPFPREP, 7, "UPnP device 0x%p no longer connected.", pUPnPDevice);
			break;
		}
		

		//
		// We found data, so see if there's more.  Connection should be closed
		// after responses.
		//
		DPFX(DPFPREP, 7, "Waiting for more data on the UPnP device 0x%p's socket.", pUPnPDevice);
	}
	while (TRUE);


	//
	// If we're here, we're no worse for wear.
	//
	hr = DPNH_OK;


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::CheckForReceivedUPnPMsgsOnDevice





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::HandleUPnPDiscoveryResponseMsg"
//=============================================================================
// CNATHelpUPnP::HandleUPnPDiscoveryResponseMsg
//-----------------------------------------------------------------------------
//
// Description:    Handles a UPnP discovery response message sent to this
//				control point.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice				- Pointer to device which received message.
//	SOCKADDR_IN * psaddrinSource	- Pointer to address that sent the response
//										message.
//	char * pcMsg					- Pointer to buffer containing the UPnP
//										message.  It will be modified.
//	int iMsgSize					- Size of message buffer in bytes.  There
//										must be an extra byte after the end of
//										the message.
//	BOOL * pfInitiatedConnect		- Pointer to boolean to set to TRUE if a
//										new UPnP device was found and a
//										connection to it was begun.
//
// Returns: HRESULT
//	DPNH_OK				- Message was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::HandleUPnPDiscoveryResponseMsg(CDevice * const pDevice,
													const SOCKADDR_IN * const psaddrinSource,
													char * const pcMsg,
													const int iMsgSize,
													BOOL * const pfInitiatedConnect)
{
	HRESULT				hr = DPNH_OK;
	char *				pszToken;
	UPNP_HEADER_INFO	HeaderInfo;
	SOCKADDR_IN			saddrinHost;
	char *				pszRelativePath;
	SOCKET				sTemp = INVALID_SOCKET;
	SOCKADDR_IN			saddrinLocal;
	CUPnPDevice *		pUPnPDevice = NULL;
	DWORD				dwError;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, %i, 0x%p)",
		this, pDevice, psaddrinSource, pcMsg, iMsgSize, pfInitiatedConnect);


#ifdef DBG
	//
	// Log the message.
	//
	this->PrintUPnPTransactionToFile(pcMsg,
									iMsgSize,
									"Inbound UPnP datagram headers",
									pDevice);
#endif // DBG


	//
	// Any errors we get while analyzing the message will cause us to jump to
	// the Exit label with hr == DPNH_OK.  Once we start trying to connect to
	// the UPnP device, that will change.  See below.
	//


	//
	// First of all, if this device already has a UPnP device, then we'll just
	// ignore this response.  Either it's a duplicate of an earlier response,
	// a cache-refresh, or it's from a different device.  Duplicates we should
	// ignore.  Cache-refresh is essentially a duplicate.  We can't handle any
	// information changes, so ignore those too.  And finally, we don't handle
	// multiple Internet gateway UPnP devices, so ignore those, too.
	//
	pUPnPDevice = pDevice->GetUPnPDevice();
	if (pUPnPDevice != NULL)
	{
		DPFX(DPFPREP, 6, "Already have UPnP device (0x%p) ignoring message.",
			pUPnPDevice);

		//
		// GetUPnPDevice did not add a reference to pUPnPDevice.
		//

		goto Exit;
	}

	//
	// Make sure the sender of this response is valid.  It should be either
	// the local device address, or the address of the gateway.  If we
	// broadcasted or multicasted, we'll need to be more lenient.  We'll just
	// ensure that the response came from someone local (it doesn't make sense
	// that in order to make mappings for our private network we would need to
	// contact something outside).
	//
	if (psaddrinSource->sin_addr.S_un.S_addr != pDevice->GetLocalAddressV4())
	{
		if (g_fUseMulticastUPnPDiscovery)
		{
			if (! this->IsAddressLocal(pDevice, psaddrinSource))
			{
				DPFX(DPFPREP, 1, "Multicast search responding device (%u.%u.%u.%u:%u) is not local, ignoring message.",
					psaddrinSource->sin_addr.S_un.S_un_b.s_b1,
					psaddrinSource->sin_addr.S_un.S_un_b.s_b2,
					psaddrinSource->sin_addr.S_un.S_un_b.s_b3,
					psaddrinSource->sin_addr.S_un.S_un_b.s_b4,
					NTOHS(psaddrinSource->sin_port));
				goto Exit;
			}
		}
		else
		{
			//
			// Retrieve the gateway's address (using saddrinHost as a temporary
			// variable.  If that fails or returns the broadcast address, just
			// make sure the address is local.  Otherwise, expect an exact
			// match.
			//
			if ((! this->GetAddressToReachGateway(pDevice, &saddrinHost.sin_addr)) ||
				(saddrinHost.sin_addr.S_un.S_addr == INADDR_BROADCAST))
			{
				if (! this->IsAddressLocal(pDevice, psaddrinSource))
				{
					DPFX(DPFPREP, 1, "No gateway/broadcast search responding device (%u.%u.%u.%u:%u) is not local, ignoring message.",
						psaddrinSource->sin_addr.S_un.S_un_b.s_b1,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b2,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b3,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b4,
						NTOHS(psaddrinSource->sin_port));
					goto Exit;
				}
			}
			else
			{
				if (psaddrinSource->sin_addr.S_un.S_addr != saddrinHost.sin_addr.S_un.S_addr)
				{
					DPFX(DPFPREP, 1, "Unicast search responding device (%u.%u.%u.%u:%u) is not gateway (%u.%u.%u.%u), ignoring message.",
						psaddrinSource->sin_addr.S_un.S_un_b.s_b1,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b2,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b3,
						psaddrinSource->sin_addr.S_un.S_un_b.s_b4,
						NTOHS(psaddrinSource->sin_port),
						saddrinHost.sin_addr.S_un.S_un_b.s_b1,
						saddrinHost.sin_addr.S_un.S_un_b.s_b2,
						saddrinHost.sin_addr.S_un.S_un_b.s_b3,
						saddrinHost.sin_addr.S_un.S_un_b.s_b4);
					goto Exit;
				}
			}
		} // end else (not multicasting search)
	}
	else
	{
		//
		// Response was from the local device.
		//
	}


	//
	// Ensure the buffer is NULL terminated to prevent buffer overruns when
	// using the string routines.
	//
	pcMsg[iMsgSize] = '\0';



	//
	// Find the version string.
	//
	pszToken = strtok(pcMsg, " \t\n");
	if (pszToken == NULL)
	{
		DPFX(DPFPREP, 9, "Could not locate first white-space separator.");
		goto Exit;
	}


	//
	// Check the version string, case insensitive.
	//
	if ((_stricmp(pszToken, HTTP_VERSION) != 0) &&
		(_stricmp(pszToken, HTTP_VERSION_ALT) != 0))
	{
		DPFX(DPFPREP, 1, "The version specified in the response message is not \"" HTTP_VERSION "\" or \"" HTTP_VERSION_ALT "\" (it's \"%hs\").",
			pszToken);
		goto Exit;
	}


	//
	// Find the response code string.
	//
	pszToken = strtok(NULL, " ");
	if (pszToken == NULL)
	{
		DPFX(DPFPREP, 1, "Could not find the response code space.");
		goto Exit;
	}

	//
	// Make sure it's the success result, case insensitive.
	//
	if (_stricmp(pszToken, "200") != 0)
	{
		DPFX(DPFPREP, 1, "The response code specified is not \"200\" (it's \"%hs\").",
			pszToken);
		goto Exit;
	}


	//
	// Find the response code message.
	//
	pszToken = strtok(NULL, " \t\r");
	if (pszToken == NULL)
	{
		DPFX(DPFPREP, 9, "Could not locate response code message white-space separator.");
		goto Exit;
	}

	//
	// Make sure it's the right string, case insensitive.
	//
	if (_stricmp(pszToken, "OK") != 0)
	{
		DPFX(DPFPREP, 1, "The response code message specified is not \"OK\" (it's \"%hs\").",
			pszToken);
		goto Exit;
	}


	//
	// Parse the header information.
	//
	ZeroMemory(&HeaderInfo, sizeof(HeaderInfo));
	this->ParseUPnPHeaders((pszToken + strlen(pszToken) + 1),
							&HeaderInfo);


	//
	// Skip responses which don't include the required headers.
	//
	if ((HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CACHECONTROL] == NULL) ||
		(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_EXT] == NULL) ||
		(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_LOCATION] == NULL) ||
		(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_SERVER] == NULL) ||
		(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_ST] == NULL) ||
		(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_USN] == NULL))
	{
		DPFX(DPFPREP, 1, "One of the expected headers was not specified, ignoring message.");
		goto Exit;
	}


	//
	// Make sure the service type is correct.
	//
	if ((_stricmp(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_ST], URI_SERVICE_WANIPCONNECTION_A) != 0) &&
		(_stricmp(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_ST], URI_SERVICE_WANPPPCONNECTION_A) != 0))
	{
		DPFX(DPFPREP, 1, "Service type \"%hs\" is not desired \"" URI_SERVICE_WANIPCONNECTION_A "\" or \"" URI_SERVICE_WANPPPCONNECTION_A "\", ignoring message.",
			HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_ST]);
		goto Exit;
	}


	//
	// Parse the location header into an address and port.
	//
	hr = this->GetAddressFromURL(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_LOCATION],
								&saddrinHost,
								&pszRelativePath);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 1, "Couldn't get address from URL (err = 0x%lx), ignoring message.",
			hr);
		hr = DPNH_OK;
		goto Exit;
	}


	//
	// Don't accept responses that refer to addresses other than the one that
	// sent this response.
	//
	if (psaddrinSource->sin_addr.S_un.S_addr != saddrinHost.sin_addr.S_un.S_addr)
	{
		DPFX(DPFPREP, 1, "Host IP address designated (%u.%u.%u.%u:%u) is not the same as source of response (%u.%u.%u.%u:%u), ignoring message.",
			saddrinHost.sin_addr.S_un.S_un_b.s_b1,
			saddrinHost.sin_addr.S_un.S_un_b.s_b2,
			saddrinHost.sin_addr.S_un.S_un_b.s_b3,
			saddrinHost.sin_addr.S_un.S_un_b.s_b4,
			NTOHS(saddrinHost.sin_port),
			psaddrinSource->sin_addr.S_un.S_un_b.s_b1,
			psaddrinSource->sin_addr.S_un.S_un_b.s_b2,
			psaddrinSource->sin_addr.S_un.S_un_b.s_b3,
			psaddrinSource->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(psaddrinSource->sin_port));
		hr = DPNH_OK;
		goto Exit;
	}


	//
	// Don't accept responses that refer to ports in the reserved range (less
	// than or equal to 1024), other than the standard HTTP port.
	//
	if ((NTOHS(saddrinHost.sin_port) <= MAX_RESERVED_PORT) &&
		(saddrinHost.sin_port != HTONS(HTTP_PORT)))
	{
		DPFX(DPFPREP, 1, "Host address designated invalid port %u, ignoring message.",
			NTOHS(saddrinHost.sin_port));
		hr = DPNH_OK;
		goto Exit;
	}

	
	//
	// Any errors we get from here on out will cause us to jump to the Failure
	// label, instead of going straight to Exit.
	//


	//
	// Create a socket to connect to that address.
	//

	ZeroMemory(&saddrinLocal, sizeof(saddrinLocal));
	saddrinLocal.sin_family				= AF_INET;
	saddrinLocal.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();

	sTemp = this->CreateSocket(&saddrinLocal, SOCK_STREAM, 0);
	if (sTemp == INVALID_SOCKET)
	{
		DPFX(DPFPREP, 0, "Couldn't create stream socket!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Initiate the connection to the UPnP device.  It is expected that connect
	// will return WSAEWOULDBLOCK.
	//
	if (this->m_pfnconnect(sTemp,
							(SOCKADDR*) (&saddrinHost),
							sizeof(saddrinHost)) != 0)
	{
		dwError = this->m_pfnWSAGetLastError();

		if (dwError != WSAEWOULDBLOCK)
		{
#ifdef DBG
			DPFX(DPFPREP, 0, "Couldn't connect socket, error = %u!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}
	}
	else
	{
		//
		// connect() on non-blocking sockets is explicitly documented as
		// always returning WSAEWOULDBLOCK, but CE seems to do it anyway.
		//
		DPFX(DPFPREP, 8, "Socket connected right away.");
	}


	//
	// Create a new object to represent the UPnP device to which we're trying
	// to connect.
	//
	pUPnPDevice = new CUPnPDevice(this->m_dwCurrentUPnPDeviceID++);
	if (pUPnPDevice == NULL)
	{
		hr = DPNHERR_OUTOFMEMORY;
		goto Failure;
	}

	hr = pUPnPDevice->SetLocationURL(pszRelativePath);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't set UPnP device's location URL!");
		goto Failure;
	}

	pUPnPDevice->SetHostAddress(&saddrinHost);

	hr = pUPnPDevice->SetUSN(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_USN]);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't set UPnP device's USN!");
		goto Failure;
	}

	hr = pUPnPDevice->CreateReceiveBuffer(UPNP_STREAM_RECV_BUFFER_INITIAL_SIZE);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't create UPnP device's receive buffer!");
		goto Failure;
	}


	DPFX(DPFPREP, 7, "Created new UPnP device object 0x%p ID %u.",
		pUPnPDevice, pUPnPDevice->GetID());


	//
	// It's connecting...
	//
	pUPnPDevice->NoteConnecting();


	//
	// See if we need to avoid trying asymmetric port mappings.
	//
	if (g_fNoAsymmetricMappings)
	{
		DPFX(DPFPREP, 1, "Preventing asymmetric port mappings on new UPnP device 0x%p.",
			pUPnPDevice);
		pUPnPDevice->NoteDoesNotSupportAsymmetricMappings();
	}


	//
	// Transfer ownership of the socket to the object.
	//
	pUPnPDevice->SetControlSocket(sTemp);


	//
	// Associate it with the device.
	//
	pUPnPDevice->MakeDeviceOwner(pDevice);

	//
	// Add it to the global list, and transfer ownership of the reference.
	//
	pUPnPDevice->m_blList.InsertBefore(&this->m_blUPnPDevices);
	pUPnPDevice = NULL;


	//
	// Inform the caller that there's a new connection pending.
	//
	(*pfInitiatedConnect) = TRUE;


	//
	// Clear the device's discovery flags, now that we have a device, we're not
	// going to be searching anymore.
	//
	pDevice->NoteNotPerformingRemoteUPnPDiscovery();
	pDevice->NoteNotPerformingLocalUPnPDiscovery();


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (pUPnPDevice != NULL)
	{
		//pUPnPDevice->DestroyReceiveBuffer();
		pUPnPDevice->ClearUSN();
		pUPnPDevice->ClearLocationURL();

		pUPnPDevice->DecRef();
	}

	if (sTemp != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(sTemp);
		sTemp = INVALID_SOCKET;
	}

	goto Exit;
} // CNATHelpUPnP::HandleUPnPDiscoveryResponseMsg





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ReconnectUPnPControlSocket"
//=============================================================================
// CNATHelpUPnP::ReconnectUPnPControlSocket
//-----------------------------------------------------------------------------
//
// Description:    Re-establishes a UPnP device TCP/IP connection.
//
//				   UPnP devices may get removed from list if a failure occurs.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device to reconnect.
//
// Returns: HRESULT
//	DPNH_OK				- Message was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ReconnectUPnPControlSocket(CUPnPDevice * const pUPnPDevice)
{
	HRESULT			hr = DPNH_OK;
	SOCKET			sTemp = INVALID_SOCKET;
	CDevice *		pDevice;
	SOCKADDR_IN		saddrinLocal;
	DWORD			dwError;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pUPnPDevice);


	DNASSERT(pUPnPDevice->GetControlSocket() == INVALID_SOCKET);


	//
	// Create a socket to connect to that address.
	//

	pDevice = pUPnPDevice->GetOwningDevice();
	DNASSERT(pDevice != NULL);

	ZeroMemory(&saddrinLocal, sizeof(saddrinLocal));
	saddrinLocal.sin_family				= AF_INET;
	saddrinLocal.sin_addr.S_un.S_addr	= pDevice->GetLocalAddressV4();

	sTemp = this->CreateSocket(&saddrinLocal, SOCK_STREAM, 0);
	if (sTemp == INVALID_SOCKET)
	{
		DPFX(DPFPREP, 0, "Couldn't create stream socket!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// Initiate the connection to the UPnP device.  It is expected that connect
	// will return WSAEWOULDBLOCK.
	//
	if (this->m_pfnconnect(sTemp,
							(SOCKADDR*) (pUPnPDevice->GetControlAddress()),
							sizeof(SOCKADDR_IN)) != 0)
	{
		dwError = this->m_pfnWSAGetLastError();

		if (dwError != WSAEWOULDBLOCK)
		{
#ifdef DBG
			DPFX(DPFPREP, 0, "Couldn't connect socket, error = %u!", dwError);
#endif // DBG
			hr = DPNHERR_GENERIC;
			goto Failure;
		}
	}
	else
	{
		//
		// connect() on non-blocking sockets is explicitly documented as
		// always returning WSAEWOULDBLOCK, but CE seems to do it anyway.
		//
		DPFX(DPFPREP, 8, "Socket connected right away.");
	}


	//
	// It's reconnecting...
	//
	pUPnPDevice->NoteConnecting();


	//
	// Transfer ownership of the socket to the object.
	//
	pUPnPDevice->SetControlSocket(sTemp);
	sTemp = INVALID_SOCKET;


	//
	// Wait for the connect to complete.
	//
	hr = this->WaitForUPnPConnectCompletions();
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't wait for UPnP connect completions!");
		goto Failure;
	}

	//
	// Make sure the connect completed successfully.
	//
	if (! pUPnPDevice->IsConnected())
	{
		DPFX(DPFPREP, 0, "UPnP device 0x%p failed reconnecting!", pUPnPDevice);

		//
		// Note that the device is cleaned up and is not in any lists anymore.
		//
		hr = DPNHERR_SERVERNOTRESPONDING;
		goto Exit;
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	if (sTemp != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(sTemp);
		sTemp = INVALID_SOCKET;
	}

	goto Exit;
} // CNATHelpUPnP::ReconnectUPnPControlSocket





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ReceiveUPnPDataStream"
//=============================================================================
// CNATHelpUPnP::ReceiveUPnPDataStream
//-----------------------------------------------------------------------------
//
// Description:    Receives incoming data from a UPnP TCP connection.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device with data to receive.
//
// Returns: HRESULT
//	DPNH_OK				- Data was received successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ReceiveUPnPDataStream(CUPnPDevice * const pUPnPDevice)
{
	HRESULT				hr = DPNH_OK;
	char *				pszDeChunkedBuffer = NULL;
	int					iReturn;
	DWORD				dwError;
	char *				pszCurrent;
	char *				pszEndOfBuffer;
	UPNP_HEADER_INFO	HeaderInfo;
	DWORD				dwContentLength;
	char *				pszToken;
	DWORD				dwHTTPResponseCode;
	int					iHeaderLength;
	DWORD				dwBufferRemaining;
	char *				pszChunkData;
	DWORD				dwChunkSize;
	char *				pszDestination;
#ifdef DBG
	char *				pszPrintIfFailed = NULL;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pUPnPDevice);

	
	do
	{
		//
		// Make sure there's room in the buffer to actually get the data.
		//
		if (pUPnPDevice->GetRemainingReceiveBufferSize() == 0)
		{
			DPFX(DPFPREP, 7, "Increasing receive buffer size prior to receiving.");

			hr = pUPnPDevice->IncreaseReceiveBufferSize();
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't increase receive buffer size prior to receiving!");
				goto Failure;
			}
		}


		//
		// Actually get the data that was indicated.
		//

		iReturn = this->m_pfnrecv(pUPnPDevice->GetControlSocket(),
								pUPnPDevice->GetCurrentReceiveBufferPtr(),
								pUPnPDevice->GetRemainingReceiveBufferSize(),
								0);
		switch (iReturn)
		{
			case 0:
			{
				//
				// Since the connection has been broken, shutdown the socket.
				//
				this->m_pfnshutdown(pUPnPDevice->GetControlSocket(), 0); // ignore error
				this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
				pUPnPDevice->SetControlSocket(INVALID_SOCKET);


				//
				// Mark the socket as not connected.
				//
				pUPnPDevice->NoteNotConnected();

				
				//
				// There may have been HTTP success/error information sent
				// before the connection was closed.
				//
				if (pUPnPDevice->GetUsedReceiveBufferSize() == 0)
				{
					DPFX(DPFPREP, 3, "UPnP device 0x%p shut down connection (no more data).",
						pUPnPDevice);

					//
					// Hopefully we got what we needed, but we're done now.
					//
					goto Exit;
				}


				DPFX(DPFPREP, 3, "UPnP device 0x%p gracefully closed connection after sending data.",
					pUPnPDevice);


				//
				// Continue through and parse what data we have.
				//
				break;
			}

			case SOCKET_ERROR:
			{
				dwError = this->m_pfnWSAGetLastError();
				switch (dwError)
				{
					case WSAEMSGSIZE:
					{
						//
						// There's not enough room in the buffer.  Double the
						// buffer and try again.
						//

						DPFX(DPFPREP, 7, "Increasing receive buffer size after WSAEMSGSIZE error.");

						hr = pUPnPDevice->IncreaseReceiveBufferSize();
						if (hr != DPNH_OK)
						{
							DPFX(DPFPREP, 0, "Couldn't increase receive buffer size!");
							goto Failure;
						}

						break;
					}

					case WSAECONNABORTED:
					case WSAECONNRESET:
					{
						DPFX(DPFPREP, 1, "UPnP device shutdown connection (err = %u).", dwError);

						//
						// Our caller should remove this device.
						//

						hr = DPNHERR_GENERIC;
						goto Failure;
						break;
					}

					case WSAENOBUFS:
					{
						DPFX(DPFPREP, 0, "WinSock returned WSAENOBUFS while receiving!");

						//
						// Our caller should remove this device.
						//

						hr = DPNHERR_OUTOFMEMORY;
						goto Failure;
						break;
					}

					default:
					{
						DPFX(DPFPREP, 0, "Got unknown sockets error %u while receiving data!", dwError);
						hr = DPNHERR_GENERIC;
						goto Failure;
						break;
					}
				}
				break;
			}

			default:
			{
				DPFX(DPFPREP, 2, "Received %i bytes of data from UPnP device 0%p.",
					iReturn, pUPnPDevice);

				pUPnPDevice->UpdateUsedReceiveBufferSize(iReturn);

				//
				// We'll also break out of the do-while loop below.
				//
				break;
			}
		}
	}
	while (iReturn == SOCKET_ERROR);


	//
	// If we're here, we've gotten the data that has currently arrived.
	//

	//
	// If we have all the headers, specifically the content length header, we
	// can tell whether we have the whole message or not.  If not, we can't do
	// anything until the rest of the data comes in.
	//
	if (pUPnPDevice->IsWaitingForContent())
	{
		dwContentLength = pUPnPDevice->GetExpectedContentSize();

		if (dwContentLength == -1)
		{
			//
			// We have all the headers, but a faulty server implementation did
			// not send a content-length header.  We're going to wait until the
			// socket is closed by the other side, and then consider all of the
			// data received at that time to be the content.  NOTE: It is
			// expected that there will be a higher level timeout preventing us
			// from waiting forever.
			//
			// So if the device is still connected, keep waiting.
			//
			// If we're using chunked transfer we won't get a content-length
			// header or a total size legitimately.  We will know the sizes of
			// individual chunks, but that doesn't help us much.  We basically
			// need to scan for the "last chunk" indicator (or socket
			// shutdown).
			//
			if (pUPnPDevice->IsConnected())
			{
				//
				// If we're using chunked transfer, see if we have enough
				// information already to determine if we're done.
				//
				if (pUPnPDevice->IsUsingChunkedTransferEncoding())
				{
					//
					// Walk all of the chunks we have so far to see if we have
					// the last one (the zero terminator).
					//
					pszCurrent = pUPnPDevice->GetReceiveBufferStart();
					dwBufferRemaining = pUPnPDevice->GetUsedReceiveBufferSize();
					do
					{
						if (! this->GetNextChunk(pszCurrent,
												dwBufferRemaining,
												&pszChunkData,
												&dwChunkSize,
												&pszCurrent,
												&dwBufferRemaining))
						{
							DPFX(DPFPREP, 1, "Body contains invalid chunk (at offset %u)!  Disconnecting.",
								(DWORD_PTR) (pszCurrent - pUPnPDevice->GetReceiveBufferStart()));
							goto Failure;
						}

						if (pszChunkData == NULL)
						{
							DPFX(DPFPREP, 1, "Did not receive end of chunked data (%u bytes received so far), continuing to waiting for data.",
								pUPnPDevice->GetUsedReceiveBufferSize());
							goto Exit;
						}
					}
					while (dwChunkSize != 0);
				}
				else
				{
					DPFX(DPFPREP, 1, "Waiting for connection to be shutdown (%u bytes received).",
						pUPnPDevice->GetUsedReceiveBufferSize());
					goto Exit;
				}
			}


			DPFX(DPFPREP, 1, "Socket closed with %u bytes received, parsing.",
				pUPnPDevice->GetUsedReceiveBufferSize());
		}
		else
		{
			if (dwContentLength > pUPnPDevice->GetUsedReceiveBufferSize())
			{
				//
				// We still haven't received all the data yet.  Keep waiting
				// (unless the socket is closed).
				//
				if (pUPnPDevice->IsConnected())
				{
					DPFX(DPFPREP, 1, "Still waiting for all content (%u bytes of %u total received).",
						pUPnPDevice->GetUsedReceiveBufferSize(), dwContentLength);
					goto Exit;
				}

				DPFX(DPFPREP, 1, "Socket closed before all content received (%u bytes of %u total), parsing anyway.",
					pUPnPDevice->GetUsedReceiveBufferSize(), dwContentLength);

				//
				// Try parsing it anyway.
				//
			}
		}


		//
		// Retrieve the HTTP response code stored earlier.
		//
		dwHTTPResponseCode = pUPnPDevice->GetHTTPResponseCode();


		//
		// All of the content that's going to arrive, has.
		//
		pUPnPDevice->NoteNotWaitingForContent();


		//
		// Make sure the buffer is NULL terminated.  But first ensure the
		// buffer can hold a new NULL termination character.
		//
		if (pUPnPDevice->GetRemainingReceiveBufferSize() == 0)
		{
			DPFX(DPFPREP, 7, "Increasing receive buffer size to hold NULL termination (for content).");

			hr = pUPnPDevice->IncreaseReceiveBufferSize();
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't increase receive buffer size to accommodate NULL termination (for content)!");
				goto Failure;
			}
		}


		//
		// Move to the end of the buffer and NULL terminate it for string ops.
		//
		pszEndOfBuffer = pUPnPDevice->GetReceiveBufferStart()
						+ pUPnPDevice->GetUsedReceiveBufferSize();
		(*pszEndOfBuffer) = '\0';


#ifdef DBG
		//
		// Print from the start of the buffer if we fail.
		//
		pszPrintIfFailed = pUPnPDevice->GetReceiveBufferStart();
#endif // DBG


		//
		// We now have all the data in a string buffer.  Continue...
		//
	}
	else
	{
		//
		// We haven't already received the headers.  The data we just got
		// should be those headers.
		//
		pszCurrent = pUPnPDevice->GetReceiveBufferStart();

		//
		// Quick check to make sure the buffer starts with something reasonable
		// in hopes of catching completely bogus responses earlier.  Note that
		// the buffer is not necessarily NULL terminated or completely
		// available yet.
		//
		if ((pUPnPDevice->GetUsedReceiveBufferSize() >= strlen(HTTP_PREFIX)) &&
			(_strnicmp(pszCurrent, HTTP_PREFIX, strlen(HTTP_PREFIX)) != 0))
		{
			DPFX(DPFPREP, 1, "Headers do not begin with \"" HTTP_PREFIX "\"!  Disconnecting.");
			goto Failure;
		}

		//
		// We don't want to walk off the end of the buffer, so only search up
		// to the last possible location for the sequence, which is the end of
		// the buffer minus the double EOL sequence.
		//
		pszEndOfBuffer = pszCurrent
						+ pUPnPDevice->GetUsedReceiveBufferSize()
						- strlen(EOL EOL);
		while (pszCurrent < pszEndOfBuffer)
		{
			if (_strnicmp(pszCurrent, EOL EOL, strlen(EOL EOL)) == 0)
			{
				//
				// Found end of headers.
				//

				//
				// Possible loss of data on 64-bit is okay, we're just saving
				// this for logging purposes.
				//
				iHeaderLength = (int) ((INT_PTR) (pszCurrent - pUPnPDevice->GetReceiveBufferStart()));
				break;
			}

			pszCurrent++;
		}

		//
		// If we didn't find the end of the headers, we're done (for now).
		//
		if (pszCurrent >= pszEndOfBuffer)
		{
			//
			// We still haven't received all the data yet.  Keep waiting
			// (unless the socket is closed).
			//
			if (pUPnPDevice->IsConnected())
			{
				//
				// Make sure the length is still within reason.
				//
				if (pUPnPDevice->GetUsedReceiveBufferSize() > MAX_UPNP_HEADER_LENGTH)
				{
					DPFX(DPFPREP, 1, "Headers are too large (%u > %u)!  Disconnecting.",
						pUPnPDevice->GetUsedReceiveBufferSize(), MAX_UPNP_HEADER_LENGTH);
					goto Failure;
				}
				
				DPFX(DPFPREP, 1, "Have not detected end of headers yet (%u bytes received).",
					pUPnPDevice->GetUsedReceiveBufferSize());
				goto Exit;
			}

			DPFX(DPFPREP, 1, "Socket closed before end of headers detected (%u bytes received), parsing anyway.",
				pUPnPDevice->GetUsedReceiveBufferSize());


			//
			// Consider the whole buffer the headers length.
			//
			iHeaderLength = pUPnPDevice->GetUsedReceiveBufferSize();


			//
			// Try parsing it anyway.
			//
		}


#ifdef DBG
		//
		// Log the headers.
		//
		this->PrintUPnPTransactionToFile(pUPnPDevice->GetReceiveBufferStart(),
										iHeaderLength,
										"Inbound UPnP stream headers",
										pUPnPDevice->GetOwningDevice());
#endif // DBG


		//
		// Make sure the buffer is NULL terminated.  But first ensure the
		// buffer can hold a new NULL termination character.
		//
		if (pUPnPDevice->GetRemainingReceiveBufferSize() == 0)
		{
			DPFX(DPFPREP, 7, "Increasing receive buffer size to hold NULL termination (for headers).");

			hr = pUPnPDevice->IncreaseReceiveBufferSize();
			if (hr != DPNH_OK)
			{
				DPFX(DPFPREP, 0, "Couldn't increase receive buffer size to accommodate NULL termination (for headers)!");
				goto Failure;
			}

			//
			// Find the end of the new buffer, and make sure it's NULL
			// terminated for string ops.
			//
			pszEndOfBuffer = pUPnPDevice->GetReceiveBufferStart()
							+ pUPnPDevice->GetUsedReceiveBufferSize();
		}
		else
		{
			//
			// Move to the end of the buffer and NULL terminate it for string
			// ops.
			//
			pszEndOfBuffer += strlen(EOL EOL);
		}

		(*pszEndOfBuffer) = '\0';



		//
		// Make sure the buffer is a valid response.  Find the version string.
		//
		pszToken = strtok(pUPnPDevice->GetReceiveBufferStart(), " \t\n");
		if (pszToken == NULL)
		{
			DPFX(DPFPREP, 1, "Could not locate first white-space separator!  Disconnecting.");
			goto Failure;
		}


		//
		// Check the version string, case insensitive.
		//
		if ((_stricmp(pszToken, HTTP_VERSION) != 0) &&
			(_stricmp(pszToken, HTTP_VERSION_ALT) != 0))
		{
			DPFX(DPFPREP, 1, "The version specified in the response message is not \"" HTTP_VERSION "\" or \"" HTTP_VERSION_ALT "\" (it's \"%hs\")!  Disconnecting.",
				pszToken);
			goto Failure;
		}


		//
		// Find the response code number string.
		//
		pszToken = strtok(NULL, " ");
		if (pszToken == NULL)
		{
			DPFX(DPFPREP, 1, "Could not find the response code number space!  Disconnecting.");
			goto Failure;
		}


		//
		// Retrieve the success/failure code value.
		//
		dwHTTPResponseCode = atoi(pszToken);


		//
		// Find the response code message.
		//
		pszToken = strtok(NULL, "\t\r");
		if (pszToken == NULL)
		{
			DPFX(DPFPREP, 1, "Could not locate response code message white-space separator!  Disconnecting.");
			goto Failure;
		}


		DPFX(DPFPREP, 1, "Received HTTP response %u \"%hs\".",
			dwHTTPResponseCode, pszToken);


		
		//
		// Try parsing the headers (after the response status line).
		//
		ZeroMemory(&HeaderInfo, sizeof(HeaderInfo));
		this->ParseUPnPHeaders((pszToken + strlen(pszToken) + 1),
								&HeaderInfo);


#ifdef DBG
		//
		// Print from the start of the message body if we fail.
		//
		pszPrintIfFailed = HeaderInfo.pszMsgBody;
#endif // DBG


		if ((HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_TRANSFERENCODING] != NULL) &&
			(_strnicmp(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_TRANSFERENCODING], "chunked", strlen("chunked")) == 0))
		{
			pUPnPDevice->NoteUsingChunkedTransferEncoding();
		}


		//
		// We're pretty lenient about missing headers...
		//
		if (HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTLENGTH] == NULL)
		{
			DPFX(DPFPREP, 1, "Content-length header was not specified in response (chunked = %i).",
				pUPnPDevice->IsUsingChunkedTransferEncoding());

			//
			// May be because we're using chunked transfer encoding, or it
			// could be a bad device.  Either way, we'll continue...
			//
			dwContentLength = -1;
		}
		else
		{
			dwContentLength = atoi(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTLENGTH]);
#ifdef DBG
			if (dwContentLength == 0)
			{
				DPFX(DPFPREP, 1, "Content length (\"%hs\") is zero.",
					HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTLENGTH]);
			}
#endif // DBG


			if (HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTTYPE] == NULL)
			{
				DPFX(DPFPREP, 1, "Expected content-type header was not specified in response, continuing.");
			}
			else
			{
				if (_strnicmp(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTTYPE], "text/xml", strlen("text/xml")) != 0)
				{
					DPFX(DPFPREP, 1, "Content type does not start with \"text/xml\" (it's \"%hs\")!  Disconnecting.",
						HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTTYPE]);
					goto Failure;
				}


#ifdef DBG
				//
				// Note whether the content type is qualified with
				// "charset=utf-8" or not.
				//
				if (_stricmp(HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTTYPE], "text/xml; charset=\"utf-8\"") != 0)
				{
					DPFX(DPFPREP, 1, "Content type is xml, but it's not \"text/xml; charset=\"utf-8\"\" (it's \"%hs\"), continuing.",
						HeaderInfo.apszHeaderStrings[RESPONSEHEADERINDEX_CONTENTTYPE]);

					//
					// The check was just for information purposes, continue.
					//
				}
#endif // DBG
			}
		}


		//
		// Content length may be valid, or the special value -1 at this
		// point.
		//


		DPFX(DPFPREP, 7, "Moving past 0x%p bytes of header.",
			HeaderInfo.pszMsgBody - pUPnPDevice->GetReceiveBufferStart());


		//
		// Forget about all the headers, we only care about data now.
		//
		pUPnPDevice->UpdateReceiveBufferStart(HeaderInfo.pszMsgBody);


		//
		// The buffer has been destroyed up to the end of the headers (meaning
		// that calling ParseUPnPHeaders won't work on the same buffer again),
		// so if we don't have all the content yet, we need to save the
		// response code, remember the fact that we're not done yet, and
		// continue waiting for the rest of the data.
		// Of course, if there wasn't a content-length header, we have to wait
		// for the socket to shutdown before we can parse.
		//
		// Also, if we're using chunked transfer we won't get a content-length
		// header or a total size legitimately.  We will know the sizes of
		// individual chunks, but that doesn't help us much.  We basically need
		// to scan for the "last chunk" indicator (or socket shutdown).
		//
		if (dwContentLength == -1)
		{
			if (pUPnPDevice->IsConnected())
			{
				//
				// If we're using chunked transfer, see if we have enough
				// information already to determine if we're done.
				//
				if (pUPnPDevice->IsUsingChunkedTransferEncoding())
				{
					//
					// Walk all of the chunks we have so far to see if we have
					// the last one (the zero terminator).
					//
					pszCurrent = pUPnPDevice->GetReceiveBufferStart();
					dwBufferRemaining = pUPnPDevice->GetUsedReceiveBufferSize();
					do
					{
						if (! this->GetNextChunk(pszCurrent,
												dwBufferRemaining,
												&pszChunkData,
												&dwChunkSize,
												&pszCurrent,
												&dwBufferRemaining))
						{
							DPFX(DPFPREP, 1, "Body contains invalid chunk (at offset %u)!  Disconnecting.",
								(DWORD_PTR) (pszCurrent - pUPnPDevice->GetReceiveBufferStart()));
							goto Failure;
						}

						if (pszChunkData == NULL)
						{
							DPFX(DPFPREP, 1, "Did not receive end of chunked data (%u bytes received so far), continuing to waiting for data.",
								pUPnPDevice->GetUsedReceiveBufferSize());

							pUPnPDevice->NoteWaitingForContent(dwContentLength, dwHTTPResponseCode);

							goto Exit;
						}
					}
					while (dwChunkSize != 0);
				}
				else
				{
					DPFX(DPFPREP, 1, "Unknown content length (%u bytes received so far), waiting for connection to close before parsing.",
						pUPnPDevice->GetUsedReceiveBufferSize());

					pUPnPDevice->NoteWaitingForContent(dwContentLength, dwHTTPResponseCode);

					goto Exit;
				}
			}
		}
		else
		{
			if ((pUPnPDevice->IsConnected()) &&
				(dwContentLength > pUPnPDevice->GetUsedReceiveBufferSize()))
			{
				DPFX(DPFPREP, 1, "Not all content has been received (%u bytes of %u total), waiting for remainder of message.",
					pUPnPDevice->GetUsedReceiveBufferSize(), dwContentLength);

				pUPnPDevice->NoteWaitingForContent(dwContentLength, dwHTTPResponseCode);

				goto Exit;
			}
		}


		//
		// We have all the data already (and it's in string form).
		// Continue...
		//
	}


	//
	// If we got here, it means we have all the data that we're expecting.
	// Shutdown the socket if it hasn't been already.
	//
	if (pUPnPDevice->IsConnected())
	{
		DPFX(DPFPREP, 7, "Forcing UPnP device 0x%p socket disconnection.",
			pUPnPDevice);

		DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);

		this->m_pfnshutdown(pUPnPDevice->GetControlSocket(), 0); // ignore error
		this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
		pUPnPDevice->SetControlSocket(INVALID_SOCKET);

		pUPnPDevice->NoteNotConnected();
	}
	else
	{
		DNASSERT(pUPnPDevice->GetControlSocket() == INVALID_SOCKET);
	}


	//
	// If the sender used chunked-transfer encoding, copy each of the chunks
	// into a contiguous "dechunked" buffer.
	//
	if (pUPnPDevice->IsUsingChunkedTransferEncoding())
	{
		//
		// Prepare a dechunked buffer.
		//
		pszDeChunkedBuffer = (char*) DNMalloc(pUPnPDevice->GetUsedReceiveBufferSize());
		if (pszDeChunkedBuffer == NULL)
		{
			hr = DPNHERR_OUTOFMEMORY;
			goto Failure;
		}

		pszDestination = pszDeChunkedBuffer;


		//
		// Walk all of the chunks.
		//
		pszCurrent = pUPnPDevice->GetReceiveBufferStart();
		dwBufferRemaining = pUPnPDevice->GetUsedReceiveBufferSize();
		do
		{
			if (! this->GetNextChunk(pszCurrent,
									dwBufferRemaining,
									&pszChunkData,
									&dwChunkSize,
									&pszCurrent,
									&dwBufferRemaining))
			{
				DPFX(DPFPREP, 1, "Body contains invalid chunk (at offset %u)!",
					(DWORD_PTR) (pszCurrent - pUPnPDevice->GetReceiveBufferStart()));
				goto Failure;
			}

			//
			// If this chunk is unfinished, bail.
			//
			if (pszChunkData == NULL)
			{
				DPFX(DPFPREP, 1, "Did not receive complete chunked data!",
					pUPnPDevice->GetUsedReceiveBufferSize());
				goto Failure;
			}

			//
			// If this is the last chunk, terminate the string here and stop.
			//
			if (dwChunkSize == 0)
			{
				(*pszDestination) = '\0';
				break;
			}

			//
			// Otherwise copy the chunk data to the dechunked buffer.
			//
			memcpy(pszDestination, pszChunkData, dwChunkSize);
			pszDestination += dwChunkSize;
		}
		while (TRUE);

		//
		// Turn off the flag since it's no longer relevant.
		//
		pUPnPDevice->NoteNotUsingChunkedTransferEncoding();

		//
		// Parse the dechunked version of the message.
		//
		pszCurrent = pszDeChunkedBuffer;
	}
	else
	{
		//
		// Get a pointer to the start of the message body.
		//
		pszCurrent = pUPnPDevice->GetReceiveBufferStart();
	}


	//
	// Clear the buffer for the next message.  Note that this does not
	// invalidate the pszMessageBody pointer we just retrieved because
	// ClearReceiveBuffer just resets the pointers back to the beginning (it
	// does not zero out the buffer).  We need to reset the buffer because the
	// handler we're about to call may try to receive data as well.  The buffer
	// must be "empty" (reset) at that time.  Of course, if the handler does do
	// that, then it had better have saved off copies of any strings it needs
	// because they will get overwritten once receiving starts.
	//
	// Content length of -1 means we never detected a valid CONTENT-LENGTH
	// header, so we will assume the rest of the data that has been received up
	// to now is (all of) the content.
	//

#ifdef DBG
	if ((dwContentLength != -1) &&
		(dwContentLength < pUPnPDevice->GetUsedReceiveBufferSize()))
	{
		//
		// The string was terminated before this data, so the handler will
		// never even see it.
		//
		DPFX(DPFPREP, 1, "Ignoring %u bytes of extra data after response from UPnP device 0x%p.",
			(pUPnPDevice->GetUsedReceiveBufferSize() - dwContentLength),
			pUPnPDevice);
	}

	//
	// HandleUPnPControlResponseBody or HandleUPnPDescriptionResponseBody might
	// print out the body or overwrite the data, so we can't print it out if
	// they fail.
	//
	pszPrintIfFailed = NULL;
#endif // DBG

	pUPnPDevice->ClearReceiveBuffer();



	if (pUPnPDevice->IsWaitingForControlResponse())
	{
		//
		// It looks like it's a control response, because someone is waiting
		// for one.
		//
		hr = this->HandleUPnPControlResponseBody(pUPnPDevice,
												dwHTTPResponseCode,
												pszCurrent);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't handle control response!", hr);
			goto Failure;
		}
	}
	else
	{
		//
		// Not waiting for a control response, assume it's a description
		// response.
		//
		hr = this->HandleUPnPDescriptionResponseBody(pUPnPDevice,
													dwHTTPResponseCode,
													pszCurrent);
		if (hr != DPNH_OK)
		{
			//
			// UPnP device may have been removed from list.
			//

			DPFX(DPFPREP, 0, "Couldn't handle description response!", hr);
			goto Failure;
		}
	}


Exit:

	if (pszDeChunkedBuffer != NULL)
	{
		DNFree(pszDeChunkedBuffer);
		pszDeChunkedBuffer = NULL;
	}

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	//
	// Something went wrong, break the connection if it exists.
	//
	if (pUPnPDevice->IsConnected())
	{
		this->m_pfnshutdown(pUPnPDevice->GetControlSocket(), 0); // ignore error
		this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
		pUPnPDevice->SetControlSocket(INVALID_SOCKET);


		//
		// Mark the socket as not connected.
		//
		pUPnPDevice->NoteNotConnected();
	}


#ifdef DBG
	if (pszPrintIfFailed != NULL)
	{
		this->PrintUPnPTransactionToFile(pszPrintIfFailed,
										strlen(pszPrintIfFailed),
										"Inbound ignored data",
										pUPnPDevice->GetOwningDevice());
	}
#endif // DBG


	//
	// Forget all data received.
	//
	pUPnPDevice->ClearReceiveBuffer();

	goto Exit;
} // CNATHelpUPnP::ReceiveUPnPDataStream





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ParseUPnPHeaders"
//=============================================================================
// CNATHelpUPnP::ParseUPnPHeaders
//-----------------------------------------------------------------------------
//
// Description:    Parses UPnP header information out of a message buffer.
//
// Arguments:
//	char * pszMsg					- Pointer to string containing the UPnP
//										message.  It will be modified.
//	UPNP_HEADER_INFO * pHeaderInfo	- Structure used to return parsing results.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::ParseUPnPHeaders(char * const pszMsg,
									UPNP_HEADER_INFO * pHeaderInfo)
{
	char *	pszCurrent;
	char *	pszLineStart;
	char *	pszHeaderDelimiter;
	int		i;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pszMsg, pHeaderInfo);


	//
	// Loop until we reach the last SSDP header (indicated by a blank line).
	//
	pszCurrent = pszMsg;
	pszLineStart = pszMsg;
	do
	{
		//
		// Find the end of the current line (CR LF).
		//
		while ((*pszCurrent) != '\n')
		{
			if ((*pszCurrent) == '\0')
			{
				//
				// We hit the end of the buffer.  Bail.
				//
				DPFX(DPFPREP, 1, "Hit end of buffer, parsing terminated.");
				return;
			}

			pszCurrent++;
		}


		//
		// Assuming this is the last header line, update the message body
		// pointer to be after this line.
		//
		pHeaderInfo->pszMsgBody = pszCurrent + 1;


		//
		// If it's a valid line, then a CR will precede the LF we just found.
		// If so, truncate the string there.  If not, we'll just continue.  The
		// wacky newline in the middle of nowhere will probably just be
		// ignored.
		//
		if ((pszCurrent > (pszMsg + 1)) &&
			(*(pszCurrent - 1)) == '\r')
		{
			//
			// Truncate the string at the effective end of the line (i.e.
			// replace the CR with NULL terminator).
			//
			*(pszCurrent - 1) = '\0';


			//
			// If this is the empty line denoting the end of the headers, we're
			// done here.
			//
			if (strlen(pszLineStart) == 0)
			{
				//
				// Stop looping.
				//
				break;
			}
		}
		else
		{
			//
			// Truncate the string here.
			//
			(*pszCurrent) = '\0';

			DPFX(DPFPREP, 9, "Line has a newline in it (offset 0x%p) that isn't preceded by a carriage return.",
				(pszCurrent - pszMsg));
		}
	

		//
		// Whitespace means continuation of previous line, so if this line
		// starts that way, erase the termination for the previous line (unless
		// this is the first line).
		//
		if (((*pszLineStart) == ' ') || ((*pszLineStart) == '\t'))
		{
			if (pszLineStart >= (pszMsg + 2))
			{
				//
				// The previous line should have ended with {CR, LF}, which
				// gets modified to {NULL termination, LF}.
				//
				if ((*(pszLineStart - 2) != '\0') ||
					(*(pszLineStart - 1) != '\n'))
				{
					DPFX(DPFPREP, 7, "Ignoring line \"%hs\" because previous character sequence was not {NULL terminator, LF}.",
						pszLineStart);
				}
				else
				{
					DPFX(DPFPREP, 7, "Appending line \"%hs\" to previous line.",
						pszLineStart);

					//
					// Replace the NULL terminator/LF pair with spaces so
					// future parsing sees the previous line and this one as
					// one string.
					//
					*(pszLineStart - 2) = ' ';
					*(pszLineStart - 1) = ' ';
				}
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring initial line \"%hs\" that starts with whitespace.",
					pszLineStart);
			}
		}


		//
		// Find the colon separating the header.
		//
		pszHeaderDelimiter = strchr(pszLineStart, ':');
		if (pszHeaderDelimiter != NULL)
		{
			//
			// Truncate the string at the end of the header.
			//
			(*pszHeaderDelimiter) = '\0';


			//
			// Remove the white space surrounding the header name.
			//
			strtrim(&pszLineStart);


			//
			// Parse the header type.
			//
			for(i = 0; i < NUM_RESPONSE_HEADERS; i++)
			{
				if (_stricmp(c_szResponseHeaders[i], pszLineStart) == 0)
				{
					//
					// Found the header.  Save it if it's not a duplicate.
					//
					if (pHeaderInfo->apszHeaderStrings[i] == NULL)
					{
						char *	pszTrimmedValue;


						//
						// Skip leading and trailing whitespace in the value.
						//
						pszTrimmedValue = pszHeaderDelimiter + 1;
						strtrim(&pszTrimmedValue);

						pHeaderInfo->apszHeaderStrings[i] = pszTrimmedValue;


						DPFX(DPFPREP, 7, "Recognized header %i:\"%hs\", data = \"%hs\".",
							i, pszLineStart, pHeaderInfo->apszHeaderStrings[i]);
					}
					else
					{
						DPFX(DPFPREP, 7, "Ignoring duplicate header %i:\"%hs\", data = \"%hs\".",
							i, pszLineStart, (pszHeaderDelimiter + 1));
					}

					break;
				}
			}

#ifdef DBG
			//
			// Print unrecognized headers. 
			//
			if (i >= NUM_RESPONSE_HEADERS)
			{
				DPFX(DPFPREP, 7, "Ignoring unrecognized header \"%hs\", data = \"%hs\".",
					pszLineStart, (pszHeaderDelimiter + 1));
			}
#endif // DBG
		}
		else
		{
			DPFX(DPFPREP, 7, "Ignoring line \"%hs\", no header delimiter.",
				pszLineStart);
		}


		//
		// Go to the next UPnP header (if any).
		//
		pszCurrent++;
		pszLineStart = pszCurrent;
	}
	while (TRUE);


	//
	// At this point pHeaderInfo->apszHeaderStrings should contain pointers to
	// the data for all the headers that were found, and
	// pHeaderInfo->pszMsgBody should point to the end of the headers.
	//
} // CNATHelpUPnP::ParseUPnPHeaders





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetAddressFromURL"
//=============================================================================
// CNATHelpUPnP::GetAddressFromURL
//-----------------------------------------------------------------------------
//
// Description: Parses a UPnP URL into a SOCKADDR_IN structure.  Only "http://"
//				URLs are parsed.  The string passed in may be temporarily
//				modified.
//
// Arguments:
//	char * pszLocation				- Pointer to buffer containing the Location
//										header.  It will be modified.
//	SOCKADDR_IN * psaddrinLocation	- Place to store address contained in
//										header string.
//	char ** ppszRelativePath		- Place to store pointer to rest of path
//										(stuff after hostname and optional
//										port).
//
// Returns: HRESULT
//	DPNH_OK				- String was parsed successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::GetAddressFromURL(char * const pszLocation,
										SOCKADDR_IN * psaddrinLocation,
										char ** ppszRelativePath)
{
	HRESULT		hr;
	BOOL		fModifiedDelimiterChar = FALSE;
	char *		pszStart;
	char *		pszDelimiter;
	char		cTempChar;
	PHOSTENT	phostent;


	//
	// Initialize the address.  Default to the standard HTTP port.
	//
	ZeroMemory(psaddrinLocation, sizeof(SOCKADDR_IN));
	psaddrinLocation->sin_family = AF_INET;
	psaddrinLocation->sin_port = HTONS(HTTP_PORT);


	//
	// Clear the relative path pointer.
	//
	(*ppszRelativePath) = NULL;


	//
	// Skip past "http://".  If it's not "http://", then fail.
	//
	if (_strnicmp(pszLocation, "http://", strlen("http://")) != 0)
	{
		DPFX(DPFPREP, 1, "Location URL (\"%hs\") does not start with \"http://\".",
			pszLocation);
		hr = DPNHERR_GENERIC;
		goto Exit;
	}

	pszStart = pszLocation + strlen("http://");

	//
	// See if there's a port specified or any extraneous junk after an IP
	// address or hostname to figure out the string to use.  Search from the
	// start of the string until we hit the end of the string or a reserved URL
	// character.
	//

	pszDelimiter = pszStart + 1;

	while (((*pszDelimiter) != '\0') &&
			((*pszDelimiter) != '/') &&
			((*pszDelimiter) != '?') &&
			((*pszDelimiter) != '=') &&
			((*pszDelimiter) != '#'))
	{
		if ((*pszDelimiter) == ':')
		{
			char *	pszPortEnd;


			//
			// We found the start of a port, search for the end.  It must
			// contain only numeric characters.
			//
			pszPortEnd = pszDelimiter + 1;
			while (((*pszPortEnd) >= '0') && ((*pszPortEnd) <= '9'))
			{
				pszPortEnd++;
			}


			//
			// Temporarily truncate the string.
			//
			cTempChar = (*pszPortEnd);
			(*pszPortEnd) = '\0';


			DPFX(DPFPREP, 7, "Found port \"%hs\".", (pszDelimiter + 1));

			psaddrinLocation->sin_port = HTONS((u_short) atoi(pszDelimiter + 1));


			//
			// Restore the character.
			//
			(*pszPortEnd) = cTempChar;


			//
			// Save the relative path
			//
			(*ppszRelativePath) = pszPortEnd;

			break;
		}

		pszDelimiter++;
	}


	//
	// Remember the character that stopped the search, and then temporarily
	// truncate the string.
	//
	cTempChar = (*pszDelimiter);
	(*pszDelimiter) = '\0';
	fModifiedDelimiterChar = TRUE;


	//
	// Save the relative path if we haven't already (because of a port).
	//
	if ((*ppszRelativePath) == NULL)
	{
		(*ppszRelativePath) = pszDelimiter;
	}

	DPFX(DPFPREP, 7, "Relative path = \"%hs\".", (*ppszRelativePath));


	
	//
	// Convert the hostname.
	//
	psaddrinLocation->sin_addr.S_un.S_addr = this->m_pfninet_addr(pszStart);

	//
	// If it's bogus, give up.
	//
	if (psaddrinLocation->sin_addr.S_un.S_addr == INADDR_ANY)
	{
		DPFX(DPFPREP, 0, "Host name \"%hs\" is invalid!",
			pszStart);
		hr = DPNHERR_GENERIC;
		goto Exit;
	}

	if (psaddrinLocation->sin_addr.S_un.S_addr == INADDR_NONE)
	{
		//
		// It's not a straight IP address.  Lookup the hostname.
		//
		phostent = this->m_pfngethostbyname(pszStart);
		if (phostent == NULL)
		{
			DPFX(DPFPREP, 0, "Couldn't lookup host name \"%hs\"!",
				pszStart);
			hr = DPNHERR_GENERIC;
			goto Exit;
		}

		if (phostent->h_addr_list[0] == NULL)
		{
			DPFX(DPFPREP, 0, "Host name \"%hs\" has no address entries!",
				pszStart);
			hr = DPNHERR_GENERIC;
			goto Exit;
		}


		//
		// Pick the first address returned.
		//

#ifdef DBG
		{
			IN_ADDR **	ppinaddr;
			DWORD		dwNumAddrs;


			ppinaddr = (IN_ADDR**) phostent->h_addr_list;
			dwNumAddrs = 0;

			while ((*ppinaddr) != NULL)
			{
				ppinaddr++;
				dwNumAddrs++;
			}

			DPFX(DPFPREP, 7, "Picking first (of %u IP addresses) for \"%hs\".",
				dwNumAddrs, pszStart);
		}
#endif // DBG

		psaddrinLocation->sin_addr.S_un.S_addr = ((IN_ADDR*) phostent->h_addr_list[0])->S_un.S_addr;
	}
	else
	{
		DPFX(DPFPREP, 7, "Successfully converted IP address \"%hs\".", pszStart);
	}


	hr = DPNH_OK;


Exit:


	//
	// If we found a port, restore the string.  If not, use the default port.
	//
	if (fModifiedDelimiterChar)
	{
		//
		// Note that PREfast reported this as being used before being
		// initialized for a while.  For some reason it didn't notice that I
		// key off of fModifiedDelimiterChar.  This appeared to get fixed, but
		// PREfast is still giving me a false hit for a similar reason
		// elsewhere.
		//
		(*pszDelimiter) = cTempChar;
	}


	DPFX(DPFPREP, 8, "Returning %u.%u.%u.%u:%u, hr = 0x%lx.",
		psaddrinLocation->sin_addr.S_un.S_un_b.s_b1,
		psaddrinLocation->sin_addr.S_un.S_un_b.s_b2,
		psaddrinLocation->sin_addr.S_un.S_un_b.s_b3,
		psaddrinLocation->sin_addr.S_un.S_un_b.s_b4,
		NTOHS(psaddrinLocation->sin_port),
		hr);


	return hr;
} // CNATHelpUPnP::GetAddressFromURL





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::HandleUPnPDescriptionResponseBody"
//=============================================================================
// CNATHelpUPnP::HandleUPnPDescriptionResponseBody
//-----------------------------------------------------------------------------
//
// Description:    Handles a UPnP device description response.  The string will
//				be modified.
//
//				   The UPnP device may get removed from list if a failure
//				occurs, the caller needs to have a reference.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice	- Pointer to UPnP device being described.
//	DWORD dwHTTPResponseCode	- HTTP header response code.
//	char * pszDescriptionXML	- UPnP device description XML string.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::HandleUPnPDescriptionResponseBody(CUPnPDevice * const pUPnPDevice,
														const DWORD dwHTTPResponseCode,
														char * const pszDescriptionXML)
{
	HRESULT					hr;
	PARSEXML_SUBELEMENT		aSubElements[MAX_NUM_DESCRIPTION_XML_SUBELEMENTS];
	PARSEXML_ELEMENT		ParseElement;
	CDevice *				pDevice;
	CBilink *				pBilink;
	CRegisteredPort *		pRegisteredPort;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %u, 0x%p)",
		this, pUPnPDevice, dwHTTPResponseCode, pszDescriptionXML);


	//
	// Make sure it was the success result.
	//
	if (dwHTTPResponseCode != 200)
	{
		DPFX(DPFPREP, 0, "Got error response %u from UPnP description request!",
			 dwHTTPResponseCode);
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	ZeroMemory(aSubElements, sizeof(aSubElements));
	
	ZeroMemory(&ParseElement, sizeof(ParseElement));
	ParseElement.papszElementStack				= (char**) (&c_szElementStack_service);
	ParseElement.dwElementStackDepth			= sizeof(c_szElementStack_service) / sizeof(char*);
	ParseElement.paSubElements					= (PARSEXML_SUBELEMENT*) (aSubElements);
	ParseElement.dwMaxNumSubElements			= MAX_NUM_DESCRIPTION_XML_SUBELEMENTS;
	//ParseElement.dwNumSubElements				= 0;
	//ParseElement.fFoundMatchingElement			= FALSE;

	hr = this->ParseXML(pszDescriptionXML,
						&ParseElement,
						PARSECALLBACK_DESCRIPTIONRESPONSE,
						pUPnPDevice);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't parse XML!");
		goto Failure;
	}


	//
	// If we did not find a WANIPConnection or WANPPPConnection service, then
	// this response was not valid.
	//
	if (pUPnPDevice->GetServiceControlURL() == NULL)
	{
		DPFX(DPFPREP, 0, "Couldn't find WANIPConnection or WANPPPConnection service in XML description!");
		hr = DPNHERR_GENERIC;
		goto Failure;
	}


	//
	// The UPnP device is now controllable.
	//
	pUPnPDevice->NoteReady();



	//
	// Find out what the device's external IP address is.  Note that calling
	// UpdateUPnPExternalAddress will overwrite the buffer containing the
	// pszDescriptionXML string.  That's fine, because we've saved all the
	// stuff in there that we need already.
	//
	hr = this->UpdateUPnPExternalAddress(pUPnPDevice, FALSE);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't update new UPnP device 0x%p's external address!",
			pUPnPDevice);
		goto Failure;
	}


	//
	// Map existing registered ports with this new UPnP device.
	//
	pDevice = pUPnPDevice->GetOwningDevice();
	DNASSERT(pDevice != NULL);

	pBilink = pDevice->m_blOwnedRegPorts.GetNext();
	while (pBilink != &pDevice->m_blOwnedRegPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);

		//
		// Note that calling MapPortsOnUPnPDevice will overwrite the buffer
		// containing the pszDescriptionXML string.  That's fine, because
		// we've saved all the stuff in there that we need already.
		//
		hr = this->MapPortsOnUPnPDevice(pUPnPDevice, pRegisteredPort);
		if (hr != DPNH_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't map existing ports on new UPnP device 0x%p!",
				pUPnPDevice);
			goto Failure;
		}


		//
		// Let the user know the addresses changed next time GetCaps is
		// called.
		//
		DPFX(DPFPREP, 8, "Noting that addresses changed (for registered port 0x%p).",
			pRegisteredPort);
		this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;


		pBilink = pBilink->GetNext();
	}


	//
	// Try to remove any mappings that were not freed earlier because we
	// crashed.
	//
	hr = this->CleanupInactiveNATMappings(pUPnPDevice);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Failed cleaning up inactive mappings with new UPnP device 0x%p!",
			pUPnPDevice);
		goto Failure;
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::HandleUPnPDescriptionResponseBody





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::HandleUPnPControlResponseBody"
//=============================================================================
// CNATHelpUPnP::HandleUPnPControlResponseBody
//-----------------------------------------------------------------------------
//
// Description:    Handles a UPnP control response.  The string will be
//				modified.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CUPnPDevice * pUPnPDevice		- Pointer to UPnP device being described.
//	DWORD dwHTTPResponseCode		- HTTP header response code.
//	char * pszControlResponseSOAP	- UPnP device response SOAP XML string.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::HandleUPnPControlResponseBody(CUPnPDevice * const pUPnPDevice,
													const DWORD dwHTTPResponseCode,
													char * const pszControlResponseSOAP)
{
	HRESULT							hr = DPNH_OK;
	CONTROLRESPONSEPARSECONTEXT		crpc;
	PARSEXML_SUBELEMENT				aSubElements[MAX_NUM_UPNPCONTROLOUTARGS];
	PARSEXML_ELEMENT				ParseElement;


	DNASSERT(pUPnPDevice->IsWaitingForControlResponse());


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %u, 0x%p)",
		this, pUPnPDevice, dwHTTPResponseCode, pszControlResponseSOAP);



	ZeroMemory(&crpc, sizeof(crpc));
	crpc.ControlResponseType	= pUPnPDevice->GetControlResponseType();
	crpc.pUPnPDevice			= pUPnPDevice;
	crpc.dwHTTPResponseCode		= dwHTTPResponseCode;
	crpc.pControlResponseInfo	= pUPnPDevice->GetControlResponseInfo();



	ZeroMemory(aSubElements, sizeof(aSubElements));
	

	ZeroMemory(&ParseElement, sizeof(ParseElement));

	if (dwHTTPResponseCode == 200)
	{
		switch (crpc.ControlResponseType)
		{
			/*
			case CONTROLRESPONSETYPE_QUERYSTATEVARIABLE_EXTERNALIPADDRESS:
			{
				ParseElement.papszElementStack			= (char**) (&c_szElementStack_QueryStateVariableResponse);
				ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_QueryStateVariableResponse) / sizeof(char*);
				break;
			}
			*/
			case CONTROLRESPONSETYPE_GETEXTERNALIPADDRESS:
			{
				ParseElement.papszElementStack			= (char**) (&c_szElementStack_GetExternalIPAddressResponse);
				ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_GetExternalIPAddressResponse) / sizeof(char*);
				break;
			}

			case CONTROLRESPONSETYPE_ADDPORTMAPPING:
			{
				ParseElement.papszElementStack			= (char**) (&c_szElementStack_AddPortMappingResponse);
				ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_AddPortMappingResponse) / sizeof(char*);
				break;
			}

			case CONTROLRESPONSETYPE_GETSPECIFICPORTMAPPINGENTRY:
			{
				ParseElement.papszElementStack			= (char**) (&c_szElementStack_GetSpecificPortMappingEntryResponse);
				ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_GetSpecificPortMappingEntryResponse) / sizeof(char*);
				break;
			}

			case CONTROLRESPONSETYPE_DELETEPORTMAPPING:
			{
				ParseElement.papszElementStack			= (char**) (&c_szElementStack_DeletePortMappingResponse);
				ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_DeletePortMappingResponse) / sizeof(char*);
				break;
			}

			default:
			{
				DNASSERT(FALSE);
				hr = DPNHERR_GENERIC;
				goto Failure;
				break;
			}
		}
	}
	else
	{
		ParseElement.papszElementStack			= (char**) (&c_szElementStack_ControlResponseFailure);
		ParseElement.dwElementStackDepth		= sizeof(c_szElementStack_ControlResponseFailure) / sizeof(char*);
	}

	ParseElement.paSubElements				= (PARSEXML_SUBELEMENT*) (aSubElements);
	ParseElement.dwMaxNumSubElements		= MAX_NUM_UPNPCONTROLOUTARGS;
	//ParseElement.dwNumSubElements			= 0;
	//ParseElement.fFoundMatchingElement	= FALSE;

	hr = this->ParseXML(pszControlResponseSOAP,
						&ParseElement,
						PARSECALLBACK_CONTROLRESPONSE,
						&crpc);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't parse XML!");
		goto Failure;
	}


	//
	// If we didn't a matching item, map it to a generic failure.
	//
	if (! ParseElement.fFoundMatchingElement)
	{
		if (dwHTTPResponseCode == 200)
		{
			DPFX(DPFPREP, 1, "Didn't find XML items in success response, mapping to generic failure.");
		}
		else
		{
			DPFX(DPFPREP, 1, "Didn't find failure XML items, using generic failure.");
		}

		crpc.pControlResponseInfo->hrErrorCode = DPNHERR_GENERIC;
	}


	pUPnPDevice->StopWaitingForControlResponse();



Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::HandleUPnPControlResponseBody





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ParseXML"
//=============================================================================
// CNATHelpUPnP::ParseXML
//-----------------------------------------------------------------------------
//
// Description:    Parses an XML string for a specific element, and calls a
//				helper function for each instance found.
//
//				   Subelement values cannot themselves contain subelements.  If
//				they do, the sub-subelements will be ignored.
//
//				   The string buffer is modified.
//
// Arguments:
//	char * pszXML						- XML string to parse.
//	PARSEXML_ELEMENT * pParseElement	- Pointer to element whose sub element
//											values should be retrieved.
//	PARSECALLBACK ParseCallback			- Enum indicating what helper function
//											to use.
//	PVOID pvContext						- Pointer to context value to pass to
//											helper function.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ParseXML(char * const pszXML,
								PARSEXML_ELEMENT * const pParseElement,
								const PARSECALLBACK ParseCallback,
								PVOID pvContext)
{
	HRESULT					hr = DPNH_OK;
	PARSEXML_STACKENTRY		aElementStack[MAX_XMLELEMENT_DEPTH];
	DWORD					dwCurrentElementDepth = 0;
	char *					pszElementTagStart = NULL;
	BOOL					fInElement = FALSE;
	BOOL					fEmptyElement = FALSE;
	char *					pszCurrent;
	DWORD					dwStackDepth;
	PARSEXML_SUBELEMENT *	pSubElement;



	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p)",
		this, pszXML, pParseElement);


	//
	// Need room for entire stack + at least one subelement level.
	//
	DNASSERT(pParseElement->dwElementStackDepth < MAX_XMLELEMENT_DEPTH);


#ifdef DBG
	this->PrintUPnPTransactionToFile(pszXML,
									strlen(pszXML),
									"Inbound XML Body",
									NULL);
#endif // DBG


	//
	// Loop through the XML looking for the given elements.
	//
	pszCurrent = pszXML;
	while ((*pszCurrent) != '\0')
	{
		switch (*pszCurrent)
		{
			case '<':
			{
				//
				// If we're in an element tag already, this is bogus XML or a
				// CDATA section (which we don't handle).  Fail.
				//
				if (pszElementTagStart != NULL)
				{
					DPFX(DPFPREP, 0, "Encountered '<' character in element tag, XML parsing failed.");
					goto Failure;
				}

				//
				// Truncate the string here in case this is the start of an
				// element end tag.  This delimits a value string.
				//
				(*pszCurrent) = '\0';


				pszElementTagStart = pszCurrent + 1;
				if ((*pszElementTagStart) == '\0')
				{
					DPFX(DPFPREP, 0, "Encountered '<' character at end of string, XML parsing failed.");
					goto Failure;
				}

				break;
			}

			case '>':
			{
				//
				// If we're not in an element tag, this is bogus XML or a CDATA
				// section (which we don't handle).  Fail.
				//
				if (pszElementTagStart == NULL)
				{
					DPFX(DPFPREP, 0, "Encountered '>' character outside of element tag, XML parsing failed.");
					goto Failure;
				}

				//
				// Truncate the string here.
				//
				(*pszCurrent) = '\0';

				//
				// This could either be a start or an end tag.  If the first
				// character of the tag is '/', then it's an end tag.
				//
				// Note that empty element tags begin by being parsed like a
				// start tag, but then jump into the end tag clause.
				//
				if ((*pszElementTagStart) == '/')
				{
					pszElementTagStart++;


					//
					// Make sure the element tag stack is valid.  The name of
					// this end tag should match the start tag at the top of
					// the stack.  XML elements are case sensitive.
					//
					if (dwCurrentElementDepth == 0)
					{
						DPFX(DPFPREP, 0, "Encountered extra element end tag \"%hs\", XML parsing failed.",
							pszElementTagStart);
						goto Failure;
					}

					if (strcmp(pszElementTagStart, aElementStack[dwCurrentElementDepth - 1].pszName) != 0)
					{
						DPFX(DPFPREP, 0, "Encountered non-matching element end tag (\"%hs\" != \"%hs\"), XML parsing failed.",
							pszElementTagStart,
							aElementStack[dwCurrentElementDepth - 1].pszName);
						goto Failure;
					}

TagEnd:

					//
					// If we're here, then we have a complete element.  If we
					// were in the element, then it's either:
					//	the end of a sub-sub element,
					//	the end of a sub element, or
					//	the end of the element itself.
					//
					if (fInElement)
					{
						switch (dwCurrentElementDepth - pParseElement->dwElementStackDepth)
						{
							case 0:
							{
								//
								// It's the end of the element.  Call the
								// helper function.  Reuse fInElement as the
								// fContinueParsing BOOL.
								//

								switch (ParseCallback)
								{
									case PARSECALLBACK_DESCRIPTIONRESPONSE:
									{
										hr = this->ParseXMLCallback_DescriptionResponse(pParseElement,
																						pvContext,
																						aElementStack,
																						&fInElement);
										if (hr != DPNH_OK)
										{
											DPFX(DPFPREP, 0, "Description response parse helper function failed!");
											goto Failure;
										}
										break;
									}

									case PARSECALLBACK_CONTROLRESPONSE:
									{
										hr = this->ParseXMLCallback_ControlResponse(pParseElement,
																					pvContext,
																					aElementStack,
																					&fInElement);
										if (hr != DPNH_OK)
										{
											DPFX(DPFPREP, 0, "Control response parse helper function failed!");
											goto Failure;
										}
										break;
									}

									default:
									{
										DNASSERT(FALSE);
										break;
									}
								}

								if (! fInElement)
								{
									DPFX(DPFPREP, 1, "Parse callback function discontinued parsing.");
									goto Exit;
								}

								//
								// Keep parsing, but we're no longer in the
								// element.  Reset the sub element counter in
								// case we found entries.
								//
								fInElement = FALSE;
								pParseElement->dwNumSubElements = 0;
								break;
							}

							case 1:
							{
								//
								// It's the end of a subelement.  Complete this
								// instance, if there's room.
								//
								if (pParseElement->dwNumSubElements < pParseElement->dwMaxNumSubElements)
								{
									pSubElement = &pParseElement->paSubElements[pParseElement->dwNumSubElements];



									pSubElement->pszNameFound = pszElementTagStart;


									pSubElement->dwNumAttributes = aElementStack[dwCurrentElementDepth - 1].dwNumAttributes;
									if (pSubElement->dwNumAttributes > 0)
									{
										memcpy(pSubElement->apszAttributeNames,
												aElementStack[dwCurrentElementDepth - 1].apszAttributeNames,
												(pSubElement->dwNumAttributes * sizeof(char*)));

										memcpy(pSubElement->apszAttributeValues,
												aElementStack[dwCurrentElementDepth - 1].apszAttributeValues,
												(pSubElement->dwNumAttributes * sizeof(char*)));
									}


									pSubElement->pszValueFound = aElementStack[dwCurrentElementDepth - 1].pszValue;



									pParseElement->dwNumSubElements++;

									DPFX(DPFPREP, 7, "Completed subelement instance #%u, name = \"%hs\", %u attributes, value = \"%hs\".",
										pParseElement->dwNumSubElements,
										pSubElement->pszNameFound,
										pSubElement->dwNumAttributes,
										pSubElement->pszValueFound);
								}
								else
								{
									DPFX(DPFPREP, 0, "Ignoring subelement instance \"%hs\" (%u attributes, value = \"%hs\"), no room in array.",
										pszElementTagStart,
										aElementStack[dwCurrentElementDepth - 1].dwNumAttributes,
										aElementStack[dwCurrentElementDepth - 1].pszValue);
								}
								break;
							}
							
							default:
							{
								//
								// It's the end of a sub-subelement.
								//
								DPFX(DPFPREP, 1, "Ignoring sub-sub element \"%hs\" (%u attributes, value = \"%hs\").",
									pszElementTagStart,
									aElementStack[dwCurrentElementDepth - 1].dwNumAttributes,
									aElementStack[dwCurrentElementDepth - 1].pszValue);
								break;
							}
						}
					}

					//
					// Pop the element off the stack.
					//
					dwCurrentElementDepth--;
				}
				else
				{
					//
					// It's not an end tag, but it might be an empty element
					// (i.e. "<tag/>").
					//
					if (*(pszCurrent - 1) == '/')
					{
						//
						// Truncate the string early.
						//
						*(pszCurrent - 1) = '\0';

						//
						// Remember this state so we can parse it properly.
						//
						fEmptyElement = TRUE;

						DPFX(DPFPREP, 7, "XML element \"%hs\" is empty (i.e. is both a start and end tag).",
							pszElementTagStart);
					}

					//
					// Push the element on the tag stack, if there's room.
					//
					if (dwCurrentElementDepth >= MAX_XMLELEMENT_DEPTH)
					{
						DPFX(DPFPREP, 0, "Too many nested element tags (%u), XML parsing failed.",
							dwCurrentElementDepth);
						goto Failure;
					}

					aElementStack[dwCurrentElementDepth].pszName = pszElementTagStart;

					//
					// If there are attributes to this element, separate them
					// into a different array.  They will not be parsed,
					// though.
					// Attributes are delimited by whitespace.
					//
					while ((*pszElementTagStart) != '\0')
					{
						pszElementTagStart++;

						//
						// If it's whitespace, that's the end of the element
						// name.  Truncate the string and break out of the
						// loops.
						//
						if (((*pszElementTagStart) == ' ') ||
							((*pszElementTagStart) == '\t') ||
							((*pszElementTagStart) == '\r') ||
							((*pszElementTagStart) == '\n'))
						{
							(*pszElementTagStart) = '\0';
							pszElementTagStart++;

							DPFX(DPFPREP, 8, "Attribute whitespace found at offset 0x%p, string length = %i.",
								(pszElementTagStart - aElementStack[dwCurrentElementDepth].pszName),
								strlen(pszElementTagStart));

							break;
						}
					}

					//
					// If there weren't any attributes, pszElementTagStart will
					// just point to an empty (but not NULL) string.
					//
					// So save the start of the value string.
					//
					aElementStack[dwCurrentElementDepth].pszValue = pszElementTagStart + strlen(pszElementTagStart) + 1;


					//
					// Then parse out the attributes.
					//
					this->ParseXMLAttributes(pszElementTagStart,
											aElementStack[dwCurrentElementDepth].apszAttributeNames,
											aElementStack[dwCurrentElementDepth].apszAttributeValues,
											MAX_XMLNAMESPACES_PER_ELEMENT,
											&(aElementStack[dwCurrentElementDepth].dwNumAttributes));


					//
					// The <?xml> tag is considered optional by this parser,
					// and will be ignored.
					//
					if (_stricmp(aElementStack[dwCurrentElementDepth].pszName, "?xml") != 0)
					{
						//
						// Bump the stack pointer.
						//
						dwCurrentElementDepth++;


						//
						// See if this the right element.  If the stack depth
						// isn't right, it can't be the desired item.
						// Otherwise, make sure the stack matches.
						//
						if (dwCurrentElementDepth == pParseElement->dwElementStackDepth)
						{
							//
							// Work through the entire element stack, making
							// sure each name matches.
							//
							for(dwStackDepth = 0; dwStackDepth < dwCurrentElementDepth; dwStackDepth++)
							{
								if (! this->MatchesXMLStringWithoutNamespace(aElementStack[dwStackDepth].pszName,
																			pParseElement->papszElementStack[dwStackDepth],
																			aElementStack,
																			NULL,
																			(dwStackDepth + 1)))
								{
									//
									// It didn't match.  Stop looping.
									//
									break;
								}
							}

							//
							// If they all matched, we found the value desired.
							//
							if (dwStackDepth == dwCurrentElementDepth)
							{
								fInElement = TRUE;

								DPFX(DPFPREP, 7, "Found requested element \"%hs\" at depth %u, has %u attributes.",
									aElementStack[dwCurrentElementDepth - 1].pszName,
									dwCurrentElementDepth,
									aElementStack[dwCurrentElementDepth - 1].dwNumAttributes);
							}
						}
					}
					else
					{
						DPFX(DPFPREP, 7, "Ignoring element \"%hs\" at depth %u that has %u attributes.",
							aElementStack[dwCurrentElementDepth].pszName,
							dwCurrentElementDepth,
							aElementStack[dwCurrentElementDepth].dwNumAttributes);

						//
						// If this assertion fails and it is an empty element,
						// dwCurrentElementDepth will be off by -1 when we jump
						// to TagEnd.
						//
						DNASSERT(! fInElement);
					}


					//
					// If this is an empty element, go immediately to handling
					// the tag closure.
					//
					if (fEmptyElement)
					{
						fEmptyElement = FALSE;
						goto TagEnd;
					}
				}


				//
				// Search for another element tag.
				//
				pszElementTagStart = NULL;
				break;
			}

			default:
			{
				//
				// Ordinary character, continue.
				//
				break;
			}
		}

		//
		// Move to the next character
		//
		pszCurrent++;
	}

Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	hr = DPNHERR_GENERIC;

	goto Exit;
} // CNATHelpUPnP::ParseXML






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ParseXMLAttributes"
//=============================================================================
// CNATHelpUPnP::ParseXMLAttributes
//-----------------------------------------------------------------------------
//
// Description: Parses any XML attributes out of the given string.  The input
//				string buffer will be modified.
//
// Arguments:
//	char * pszString				- Pointer to attributes string to parse.
//										This will be modified.
//	char ** apszAttributeNames		- Array in which to store attribute name
//										string pointers.
//	char ** apszAttributeValues		- Matching array in which to store cor-
//										responding attribute value strings.
//	DWORD dwMaxNumAttributes		- Maximum number of entries allowed in
//										previous arrays.
//	DWORD * pdwNumAttributes		- Place to store number of attributes that
//										were found.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
void CNATHelpUPnP::ParseXMLAttributes(char * const pszString,
									char ** const apszAttributeNames,
									char ** const apszAttributeValues,
									const DWORD dwMaxNumAttributes,
									DWORD * const pdwNumAttributes)
{
	char *	pszStart;
	char *	pszCurrent;
	char *	pszEndOfString;
	BOOL	fInValueString = FALSE;
	BOOL	fInQuotes = FALSE;
	BOOL	fEmptyString = FALSE;


#ifdef EXTRA_PARSING_SPEW
	DPFX(DPFPREP, 8, "(0x%p) Parameters: (\"%hs\", 0x%p, 0x%p, %u, 0x%p)",
		this, pszString, apszAttributeNames, apszAttributeValues,
		dwMaxNumAttributes, pdwNumAttributes);
#endif // EXTRA_PARSING_SPEW


	//
	// Start at the beginning with no entries.
	//
	(*pdwNumAttributes) = 0;
	pszStart = pszString;
	pszCurrent = pszStart;
	pszEndOfString = pszString + strlen(pszString);


	//
	// Skip empty strings.
	//
	if (pszEndOfString == pszStart)
	{
		return;
	}


	//
	// Loop through the entire string.
	//
	while (pszCurrent <= pszEndOfString)
	{
		switch (*pszCurrent)
		{
			case '=':
			{
				//
				// If we're not in quotes or a value string, this is the end of
				// the attribute name and the start of a value string.
				//
				if ((! fInQuotes) && (! fInValueString))
				{
					(*pszCurrent) = '\0';
					apszAttributeNames[(*pdwNumAttributes)] = pszStart;
					pszStart = pszCurrent + 1;
					fInValueString = TRUE;
				}
				break;
			}

			case '\0':
			case ' ':
			case '\t':
			case '\r':
			case '\n':
			{
				//
				// Whitespace or the end of the string.  If we're not in
				// quotes, that means it's the end of an attribute.  Of course
				// if it's the end of the string, then we force the end of the
				// attribute/value.
				//
				if ((! fInQuotes) || ((*pszCurrent) == '\0'))
				{
					(*pszCurrent) = '\0';

					if (fInValueString)
					{
						//
						// End of the value string.
						//

						apszAttributeValues[(*pdwNumAttributes)] = pszStart;
						fInValueString = FALSE;

						DPFX(DPFPREP, 7, "Found attribute \"%hs\" with value \"%hs\".",
							apszAttributeNames[(*pdwNumAttributes)],
							apszAttributeValues[(*pdwNumAttributes)]);
					}
					else
					{
						//
						// This may be another whitespace character immediately
						// following a previous one.  If so, ignore it.  If
						// not, save the attribute.
						//
						if (pszCurrent == pszStart)
						{
							fEmptyString = TRUE;

#ifdef EXTRA_PARSING_SPEW
							DPFX(DPFPREP, 9, "Ignoring extra whitespace at offset 0x%p.",
								(pszCurrent - pszString));
#endif // EXTRA_PARSING_SPEW
						}
						else
						{
							//
							// End of the attribute.  Force an empty value string.
							//

							apszAttributeNames[(*pdwNumAttributes)] = pszStart;
							apszAttributeValues[(*pdwNumAttributes)] = pszCurrent;

							DPFX(DPFPREP, 7, "Found attribute \"%hs\" with no value string.",
								apszAttributeNames[(*pdwNumAttributes)]);
						}
					}


					//
					// Update the pointer for the start of the next attribute.
					//
					pszStart = pszCurrent + 1;


					//
					// Move to next attribute storage location, if this is not
					// an empty string.  If that was the last storage slot,
					// we're done here.
					//
					if (fEmptyString)
					{
						fEmptyString = FALSE;
					}
					else
					{
						(*pdwNumAttributes)++;
						if ((*pdwNumAttributes) >= dwMaxNumAttributes)
						{
							DPFX(DPFPREP, 1, "Maximum number of attributes reached, discontinuing attribute parsing.");
							pszCurrent = pszEndOfString;
						}
					}
				}
				break;
			}

			case '"':
			{
				//
				// Make sure it's not an escaped quote character.
				//
				if ((pszCurrent == pszString) || (*(pszCurrent - 1) != '\\'))
				{
					//
					// Toggle the quote state.
					//
					if (fInQuotes)
					{
						//
						// Force the string to terminate here so we skip the
						// trailing quote character.
						//
						fInQuotes = FALSE;
						(*pszCurrent) = '\0';
					}
					else
					{
						fInQuotes = TRUE;

						//
						// This should be the start of a (value) string.  Skip
						// this quote character.
						//
						if (pszCurrent == pszStart)
						{
							pszStart++;
						}
						else
						{
							DPFX(DPFPREP, 1, "Found starting quote that wasn't at the beginning of the string!  Continuing.");
						}
					}
				}
				else
				{
					//
					// It's an escaped quote character.
					//
				}
				break;
			}

			default:
			{
				//
				// Ignore the character and move on.
				//
				break;
			}
		}
		

		//
		// Move to next character.
		//
		pszCurrent++;
	}


#ifdef EXTRA_PARSING_SPEW
	DPFX(DPFPREP, 8, "(0x%p) Leave (found %u items)", this, (*pdwNumAttributes));
#endif // EXTRA_PARSING_SPEW
} // CNATHelpUPnP::ParseXMLNamespaceAttributes






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::MatchesXMLStringWithoutNamespace"
//=============================================================================
// CNATHelpUPnP::MatchesXMLStringWithoutNamespace
//-----------------------------------------------------------------------------
//
// Description: Determines whether the szCompareString matches szMatchString
//				when all namespace prefixes in szCompareString are ignored.
//				TRUE is returned if they do match, FALSE if not.
//
// Arguments:
//	char * szCompareString				- String that may contain namespace
//											prefixes to be ignored.
//	char * szMatchString				- Shortened string without any
//											namespace prefixes to be matched.
//	PARSEXML_STACKENTRY * aElementStack	- Array of nested elements whose
//											attributes may define XML namespace
//											aliases.
//	PARSEXML_SUBELEMENT * pSubElement	- Optional subelement entry with
//											additional attributes to check.
//	DWORD dwElementStackDepth			- Number of entries in previous array.
//
// Returns: BOOL
//=============================================================================
BOOL CNATHelpUPnP::MatchesXMLStringWithoutNamespace(const char * const szCompareString,
													const char * const szMatchString,
													const PARSEXML_STACKENTRY * const aElementStack,
													const PARSEXML_SUBELEMENT * const pSubElement,
													const DWORD dwElementStackDepth)
{
	BOOL	fResult;
	char *	pszCompareStringNoNamespace;


	//
	// First, do a straight-forward string comparison.
	//
	if (_stricmp(szCompareString, szMatchString) == 0)
	{
		DPFX(DPFPREP, 7, "\"%hs\" exactly matches the short string.",
			szCompareString);

		fResult = TRUE;
	}
	else
	{
		//
		// Skip past any namespace prefixes.
		//
		pszCompareStringNoNamespace = this->GetStringWithoutNamespacePrefix(szCompareString,
																			aElementStack,
																			pSubElement,
																			dwElementStackDepth);
		DNASSERT((pszCompareStringNoNamespace >= szCompareString) && (pszCompareStringNoNamespace <= (szCompareString + strlen(szCompareString))));


		//
		// Now try comparing again, if we found any prefixes.
		//
		if (pszCompareStringNoNamespace > szCompareString)
		{
			if (_stricmp(pszCompareStringNoNamespace, szMatchString) == 0)
			{
				DPFX(DPFPREP, 7, "\"%hs\" matches the short string \"%hs\" starting at offset 0x%p.",
					szCompareString, szMatchString,
					(pszCompareStringNoNamespace - szCompareString));

				fResult = TRUE;
			}
			else
			{
				DPFX(DPFPREP, 8, "\"%hs\" does not match the short string \"%hs\" (starting at offset 0x%p).",
					szCompareString, szMatchString,
					(pszCompareStringNoNamespace - szCompareString));

				fResult = FALSE;
			}
		}
		else
		{
			DPFX(DPFPREP, 8, "\"%hs\" does not have any namespace prefixes and does not match \"%hs\".",
				szCompareString, szMatchString);

			fResult = FALSE;
		}
	}

	return fResult;
} // CNATHelpUPnP::MatchesXMLStringWithoutNamespace






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetStringWithoutNamespacePrefix"
//=============================================================================
// CNATHelpUPnP::GetStringWithoutNamespacePrefix
//-----------------------------------------------------------------------------
//
// Description: Returns a pointer to the first part of the string after any
//				prefixes found.  This will be the start of the string if none
//				are found.
//
// Arguments:
//	char * szString						- String that may contain namespace
//											prefixes to be skipped.
//	PARSEXML_STACKENTRY * aElementStack	- Array of nested elements whose
//											attributes may define XML namespace
//											aliases.
//	PARSEXML_SUBELEMENT * pSubElement	- Optional subelement entry with
//											additional attributes to check.
//	DWORD dwElementStackDepth			- Number of entries in previous array.
//
// Returns: char *
//=============================================================================
char * CNATHelpUPnP::GetStringWithoutNamespacePrefix(const char * const szString,
													const PARSEXML_STACKENTRY * const aElementStack,
													const PARSEXML_SUBELEMENT * const pSubElement,
													const DWORD dwElementStackDepth)
{
	char *	pszResult;
	UINT	uiXMLNSPrefixLength;
	DWORD	dwAttribute;
	UINT	uiNamespaceNameLength;
	UINT	uiNamespaceValueLength;
	DWORD	dwStackDepth;



	//
	// Store the prefix value since we use it frequently in this function.
	//
	uiXMLNSPrefixLength = strlen(XML_NAMESPACEDEFINITIONPREFIX);


	//
	// Search the stack for an XML namespace definition that matches.  Start at
	// the bottom and work up, since later definitions take precendence over
	// earlier ones.
	//
	// In fact, if this is a subelement, there are attributes associated with
	// this item that need to be checked, too.  Do that first.
	//
	if (pSubElement != NULL)
	{
		//
		// Search each attribute
		//
		for(dwAttribute = 0; dwAttribute < pSubElement->dwNumAttributes; dwAttribute++)
		{
			//
			// Work with this attribute if it's a valid XML namespace
			// definition.  It needs to start with the prefix, plus have one
			// extra character for the actual name.
			//
			uiNamespaceNameLength = strlen(pSubElement->apszAttributeNames[dwAttribute]);
			if ((uiNamespaceNameLength >= (uiXMLNSPrefixLength + 1)) &&
				(_strnicmp(pSubElement->apszAttributeNames[dwAttribute], XML_NAMESPACEDEFINITIONPREFIX, uiXMLNSPrefixLength) == 0))
			{
				uiNamespaceNameLength -= uiXMLNSPrefixLength;

				//
				// Only work with the item's value if it's valid.
				//
				uiNamespaceValueLength = strlen(pSubElement->apszAttributeValues[dwAttribute]);
				if (uiNamespaceValueLength > 0)
				{
					//
					// Okay, here's an item.  See if the name prefixes the
					// passed in string.
					//
					if (_strnicmp(szString, (pSubElement->apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength), uiNamespaceNameLength) == 0)
					{
						DPFX(DPFPREP, 8, "\"%hs\" begins with prefix \"%hs\" (subelement).",
							szString,
							(pSubElement->apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength));

						//
						// Cast to lose the const.
						//
						pszResult = ((char*) szString) + uiNamespaceNameLength;

						//
						// Skip the colon delimiter.
						//
						if ((*pszResult) == ':')
						{
							pszResult++;
						}
						else
						{
							DPFX(DPFPREP, 1, "\"%hs\" begins with prefix \"%hs\" but does not have colon separator (subelement)!  Continuing.",
								szString,
								(pSubElement->apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength));
						}

						goto Exit;
					}

					//
					// Namespace doesn't match
					//
#ifdef EXTRA_PARSING_SPEW
					DPFX(DPFPREP, 9, "\"%hs\" does not begin with prefix \"%hs\" (subelement).",
						szString,
						(pSubElement->apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength));
#endif // EXTRA_PARSING_SPEW
				}
				else
				{
					//
					// Namespace value is bogus, ignore it.
					//
					DPFX(DPFPREP, 1, "Ignoring namespace definition \"%hs\" with empty value string (subelement).",
						pSubElement->apszAttributeNames[dwAttribute]);
				}
			}
			else
			{
				//
				// Not an XML namespace definition.
				//

#ifdef EXTRA_PARSING_SPEW
				DPFX(DPFPREP, 9, "Attribute \"%hs\" is not a valid namespace definition (subelement).",
					pSubElement->apszAttributeNames[dwAttribute]);
#endif // EXTRA_PARSING_SPEW
			}
		} // end for (each attribute)
	}
	else
	{
		//
		// No subelement to check.
		//
	}


	//
	// Do the same thing for the all items above this one.
	//
	dwStackDepth = dwElementStackDepth;
	while (dwStackDepth > 0)
	{
		dwStackDepth--;

		//
		// Search each attribute
		//
		for(dwAttribute = 0; dwAttribute < aElementStack[dwStackDepth].dwNumAttributes; dwAttribute++)
		{
			//
			// Work with this attribute if it's a valid XML namespace
			// definition.  It needs to start with the prefix, plus have one
			// extra character for the actual name.
			//
			uiNamespaceNameLength = strlen(aElementStack[dwStackDepth].apszAttributeNames[dwAttribute]);
			if ((uiNamespaceNameLength >= (uiXMLNSPrefixLength + 1)) &&
				(_strnicmp(aElementStack[dwStackDepth].apszAttributeNames[dwAttribute], XML_NAMESPACEDEFINITIONPREFIX, uiXMLNSPrefixLength) == 0))
			{
				uiNamespaceNameLength -= uiXMLNSPrefixLength;

				//
				// Only work with the item's value if it's valid.
				//
				uiNamespaceValueLength = strlen(aElementStack[dwStackDepth].apszAttributeValues[dwAttribute]);
				if (uiNamespaceValueLength > 0)
				{
					//
					// Okay, here's an item.  See if the value prefixes the
					// passed in string.
					//
					if (_strnicmp(szString, (aElementStack[dwStackDepth].apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength), uiNamespaceNameLength) == 0)
					{
						DPFX(DPFPREP, 8, "\"%hs\" begins with prefix \"%hs\" (stack depth %u).",
							szString,
							(aElementStack[dwStackDepth].apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength),
							dwStackDepth);

						//
						// Cast to lose the const.
						//
						pszResult = ((char*) szString) + uiNamespaceNameLength;

						//
						// Skip the colon delimiter.
						//
						if ((*pszResult) == ':')
						{
							pszResult++;
						}
						else
						{
							DPFX(DPFPREP, 1, "\"%hs\" begins with prefix \"%hs\" but does not have colon separator (stack depth %u)!  Continuing.",
								szString,
								(aElementStack[dwStackDepth].apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength),
								dwStackDepth);
						}

						goto Exit;
					}

					//
					// Namespace doesn't match
					//
#ifdef EXTRA_PARSING_SPEW
					DPFX(DPFPREP, 9, "\"%hs\" does not begin with prefix \"%hs\" (stack depth %u).",
						szString,
						(aElementStack[dwStackDepth].apszAttributeNames[dwAttribute] + uiXMLNSPrefixLength),
						dwStackDepth);
#endif // EXTRA_PARSING_SPEW
				}
				else
				{
					//
					// Namespace value is bogus, ignore it.
					//
					DPFX(DPFPREP, 1, "Ignoring namespace definition \"%hs\" with empty value string (stack depth %u).",
						aElementStack[dwStackDepth].apszAttributeNames[dwAttribute],
						dwStackDepth);
				}
			}
			else
			{
				//
				// Not an XML namespace definition.
				//

#ifdef EXTRA_PARSING_SPEW
				DPFX(DPFPREP, 9, "Attribute \"%hs\" is not a valid namespace definition (stack depth %u).",
					aElementStack[dwStackDepth].apszAttributeNames[dwAttribute],
					dwStackDepth);
#endif // EXTRA_PARSING_SPEW
			}
		} // end for (each attribute)
	}


	//
	// If we're here, it didn't match, even with namespace expansion.
	//

	DPFX(DPFPREP, 8, "\"%hs\" does not contain any namespace prefixes.",
		szString);

	//
	// Cast to lose the const.
	//
	pszResult = (char*) szString;


Exit:

	return pszResult;
} // CNATHelpUPnP::GetStringWithoutNamespacePrefix






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetNextChunk"
//=============================================================================
// CNATHelpUPnP::GetNextChunk
//-----------------------------------------------------------------------------
//
// Description:    Attempts to parse the next chunk out of a message buffer.
//				If invalid data is encountered, this function returns FALSE.
//				If not enough data has been received to complete the chunk,
//				TRUE is returned, but NULL is returned in ppszChunkData.
//				Otherwise, a pointer to the start of the chunk data is placed
//				in ppszChunkData, the size of the chunk is placed in
//				pdwChunkSize, ppszBufferRemaining is set to the start of the
//				next potential chunk, and pdwBufferSizeRemaining is set to the
//				amount of the buffer remaining starting at the returned
//				ppszBufferRemaining value.
//
//				   Note that the chunk size may be zero, in which case the
//				pointer in ppszChunkData & ppszBufferRemaining will be non-
//				NULL, but useless.
//
// Arguments:
//	char * pszBuffer				- Pointer to string containing the message
//										received so far.
//	DWORD dwBufferSize				- Size of the message buffer.
//	char ** ppszChunkData			- Place to store pointer to chunk data, or
//										NULL if full chunk is not available.
//	DWORD * pdwChunkSize			- Place to store size of chunk.
//	char ** ppszBufferRemaining		- Place to store pointer to end of chunk
//										if full chunk is available.
//	DWORD * pdwBufferSizeRemaining	- Place to store size of buffer remaining
//										after returned chunk.
//
// Returns: None.
//=============================================================================
BOOL CNATHelpUPnP::GetNextChunk(char * const pszBuffer,
								const DWORD dwBufferSize,
								char ** const ppszChunkData,
								DWORD * const pdwChunkSize,
								char ** const ppszBufferRemaining,
								DWORD * const pdwBufferSizeRemaining)
{
	BOOL	fReturn = TRUE;
	char *	pszCurrent;
	char *	pszEndOfBuffer;
	BOOL	fFoundChunkSizeEnd;
	BOOL	fExtensions;
	BOOL	fInQuotedString;


	DPFX(DPFPREP, 8, "(0x%p) Parameters: (0x%p, %u, 0x%p, 0x%p, 0x%p, 0x%p)",
		this, pszBuffer, dwBufferSize, ppszChunkData, pdwChunkSize,
		ppszBufferRemaining, pdwBufferSizeRemaining);


	pszCurrent = pszBuffer;
	pszEndOfBuffer = pszCurrent + dwBufferSize;
	fFoundChunkSizeEnd = FALSE;
	fExtensions = FALSE;
	fInQuotedString = FALSE;
	(*ppszChunkData) = NULL;
	(*pdwChunkSize) = 0;


	//
	// The buffer must be large enough to hold 1 hex digit, CR LF chunk size
	// terminator, and CR LF chunk trailer.
	//
	if (dwBufferSize < 5)
	{
		DPFX(DPFPREP, 3, "Buffer is not large enough (%u bytes) to hold one valid chunk.",
			dwBufferSize);
		goto Exit;
	}

	//
	// Be paranoid to make sure we're not going to having wrap problems.
	//
	if (pszEndOfBuffer < pszCurrent)
	{
		DPFX(DPFPREP, 0, "Buffer pointer 0x%p cannot have size %u!",
			pszBuffer, dwBufferSize);
		goto Failure;
	}

	while (pszCurrent < pszEndOfBuffer)
	{
		//
		// Make sure we have a valid hex chunk size string and convert it
		// as we go.
		//
		if (((*pszCurrent) >= '0') && ((*pszCurrent) <= '9'))
		{
			(*pdwChunkSize) = ((*pdwChunkSize) * 16) + ((*pszCurrent) - '0');
		}
		else if (((*pszCurrent) >= 'a') && ((*pszCurrent) <= 'f'))
		{
			(*pdwChunkSize) = ((*pdwChunkSize) * 16) + ((*pszCurrent) - 'a' + 10);
		}
		else if (((*pszCurrent) >= 'A') && ((*pszCurrent) <= 'F'))
		{
			(*pdwChunkSize) = ((*pdwChunkSize) * 16) + ((*pszCurrent) - 'A' + 10);
		}
		else if ((*pszCurrent) == '\r')
		{
			//
			// This should be the end of the chunk size string.
			//
			fFoundChunkSizeEnd = TRUE;
			break;
		}
		else if ((*pszCurrent) == ';')
		{
			//
			// This should be the end of the chunk size string, and the
			// beginning of extensions.  Loop until we find the true end.
			//
			while ((*pszCurrent) != '\r')
			{
				pszCurrent++;
				if (pszCurrent >= pszEndOfBuffer)
				{
					DPFX(DPFPREP, 5, "Buffer stops in middle of chunk extension.");
					goto Exit;
				}

				//
				// We do not support quoted extension value strings that
				// theoretically contain CR characters...
				//
			}

			fFoundChunkSizeEnd = TRUE;
			break;
		}
		else
		{
			//
			// There's a bogus character.  This can't be a validly encoded
			// message.
			//
			DPFX(DPFPREP, 1, "Chunk size string contains invalid character 0x%x at offset %u!",
				(*pszCurrent), (DWORD_PTR) (pszCurrent - pszBuffer));
			goto Failure;
		}

		//
		// Validate the chunk size we have so far.
		//
		if ((*pdwChunkSize) > MAX_RECEIVE_BUFFER_SIZE)
		{
			DPFX(DPFPREP, 1, "Chunk size %u is too large!",
				(*pdwChunkSize));
			goto Failure;
		}

		pszCurrent++;
	}

	//
	// If we're here, see if we found the end of the chunk size string.
	// Make sure we've received enough data, and then validate that the CR
	// stopping character is followed by the LF character.
	//
	if (fFoundChunkSizeEnd)
	{
		pszCurrent++;
		if (pszCurrent < pszEndOfBuffer)
		{
			if ((*pszCurrent) != '\n')
			{
				DPFX(DPFPREP, 1, "Chunk size string did not end with CRLF sequence (offset %u)!",
					(DWORD_PTR) (pszCurrent - pszBuffer));
				goto Failure;
			}

			//
			// Otherwise we got a complete chunk size string.
			//
			pszCurrent++;

			//
			// If we have received all of the chunk already, make sure we have
			// the trailing CR LF sequence before returning the pointer to the
			// caller.
			if (((*pdwChunkSize) + 2) <= ((DWORD_PTR) (pszEndOfBuffer - pszCurrent)))
			{
				if ((*(pszCurrent + (*pdwChunkSize)) != '\r') ||
					(*(pszCurrent + (*pdwChunkSize) + 1) != '\n'))
				{
					DPFX(DPFPREP, 1, "Chunk data did not end with CRLF sequence (offset %u)!",
						(DWORD_PTR) (pszCurrent - pszBuffer + (*pdwChunkSize)));
					goto Failure;
				}

				//
				// Return the data pointers to the caller.  In the case of the
				// zero size terminating chunk, the ppszChunkData pointer will
				// actually be useless, but the caller should recognize that.
				//
				(*ppszChunkData) = pszCurrent;
				(*ppszBufferRemaining) = pszCurrent + ((*pdwChunkSize) + 2);
				(*pdwBufferSizeRemaining) = (DWORD) ((DWORD_PTR) (pszEndOfBuffer - (*ppszBufferRemaining)));
			}
		}
	}

	//
	// If we're here, we didn't encounter invalid data.
	//

Exit:

	DPFX(DPFPREP, 8, "(0x%p) Returning: [%i]", this, fReturn);

	return fReturn;


Failure:

	fReturn = FALSE;

	goto Exit;
} // CNATHelpUPnP::GetNextChunk





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ParseXMLCallback_DescriptionResponse"
//=============================================================================
// CNATHelpUPnP::ParseXMLCallback_DescriptionResponse
//-----------------------------------------------------------------------------
//
// Description: Handles a completed parsed element in the description response
//				XML.
//
// Arguments:
//	PARSEXML_ELEMENT * pParseElement	- Pointer to element which was found.
//	PVOID pvContext						- Pointer to parsing context.
//	PARSEXML_STACKENTRY * aElementStack	- Array of parent elements containing
//											the completed element. 
//	BOOL * pfContinueParsing			- Pointer to BOOL that should be set
//											to FALSE if the calling function
//											should stop parsing the XML.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ParseXMLCallback_DescriptionResponse(PARSEXML_ELEMENT * const pParseElement,
															PVOID pvContext,
															PARSEXML_STACKENTRY * const aElementStack,
															BOOL * const pfContinueParsing)
{
	HRESULT					hr = DPNH_OK;
	CUPnPDevice *			pUPnPDevice;
	char *					pszServiceType = NULL;
	char *					pszServiceId = NULL;
	char *					pszControlURL = NULL;
	DWORD					dwSubElement;
	PARSEXML_SUBELEMENT *	pSubElement;
	SOCKADDR_IN				saddrinControl;
	SOCKADDR_IN	*			psaddrinHost;
	char *					pszRelativePath;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p,  0x%p, 0x%p)",
		this, pParseElement, pvContext, aElementStack, pfContinueParsing);


	pUPnPDevice = (CUPnPDevice *) pvContext;


	DNASSERT(pUPnPDevice != NULL);
	DNASSERT(pParseElement->papszElementStack == (char **) (&c_szElementStack_service));


	//
	// Look for the subelements we want.
	//
	for(dwSubElement = 0; dwSubElement < pParseElement->dwNumSubElements; dwSubElement++)
	{
		pSubElement = &pParseElement->paSubElements[dwSubElement];

		if (_stricmp(pSubElement->pszNameFound, XML_DEVICEDESCRIPTION_SERVICETYPE) == 0)
		{
			if (pszServiceType == NULL)
			{
				pszServiceType = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" XML_DEVICEDESCRIPTION_SERVICETYPE "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (_stricmp(pSubElement->pszNameFound, XML_DEVICEDESCRIPTION_SERVICEID) == 0)
		{
			if (pszServiceId == NULL)
			{
				pszServiceId = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" XML_DEVICEDESCRIPTION_SERVICEID "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (_stricmp(pSubElement->pszNameFound, XML_DEVICEDESCRIPTION_CONTROLURL) == 0)
		{
			if (pszControlURL == NULL)
			{
				pszControlURL = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" XML_DEVICEDESCRIPTION_CONTROLURL "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else
		{
			DPFX(DPFPREP, 7, "Ignoring subelement \"%hs\" (value = \"%hs\").",
				pSubElement->pszNameFound, pSubElement->pszValueFound);
		}
	}


	//
	// If one of those elements was not specified, then this element is not
	// helpful.
	//
	if ((pszServiceType == NULL) || (pszServiceId == NULL) || (pszControlURL == NULL))
	{
		DPFX(DPFPREP, 1, "Couldn't find either \"" XML_DEVICEDESCRIPTION_SERVICETYPE "\", \"" XML_DEVICEDESCRIPTION_SERVICEID "\", or \"" XML_DEVICEDESCRIPTION_CONTROLURL "\" in XML description, ignoring element.");
		goto Exit;
	}


	//
	// If the service type is not one of the ones we want, ignore the element.
	//
	if (_stricmp(pszServiceType, URI_SERVICE_WANIPCONNECTION_A) == 0)
	{
		DPFX(DPFPREP, 7, "Found \"" URI_SERVICE_WANIPCONNECTION_A "\".");

		DNASSERT(! pUPnPDevice->IsWANPPPConnection());
	}
	else if (_stricmp(pszServiceType, URI_SERVICE_WANPPPCONNECTION_A) == 0)
	{
		DPFX(DPFPREP, 7, "Found \"" URI_SERVICE_WANPPPCONNECTION_A "\".");

		pUPnPDevice->NoteWANPPPConnection();
	}
	else
	{
		DPFX(DPFPREP, 1, "Ignoring unknown service type \"%hs\".", pszServiceType);
		goto Exit;
	}
	

	pParseElement->fFoundMatchingElement = TRUE;
	(*pfContinueParsing) = FALSE;



	//
	// Validate and store the service control URL.
	//

	hr = this->GetAddressFromURL(pszControlURL,
								&saddrinControl,
								&pszRelativePath);
	if (hr != DPNH_OK)
	{
		psaddrinHost = pUPnPDevice->GetHostAddress();

		DPFX(DPFPREP, 1, "No control address in URL, using host address %u.%u.%u.%u:%u and full URL as relative path (\"%hs\").",
			psaddrinHost->sin_addr.S_un.S_un_b.s_b1,
			psaddrinHost->sin_addr.S_un.S_un_b.s_b2,
			psaddrinHost->sin_addr.S_un.S_un_b.s_b3,
			psaddrinHost->sin_addr.S_un.S_un_b.s_b4,
			NTOHS(psaddrinHost->sin_port),
			pszControlURL);

		memcpy(&saddrinControl, psaddrinHost, sizeof(SOCKADDR_IN));
		pszRelativePath = pszControlURL;
	}
	else
	{
#if 0
		//
		// Ensure that the address to use is local.  It doesn't make sense that
		// in order to make mappings for our private network we would need to
		// contact something outside.
		//
		if (! this->IsAddressLocal(pUPnPDevice->GetOwningDevice(), &saddrinControl))
		{
			DPFX(DPFPREP, 1, "Control address designated (%u.%u.%u.%u:%u) is not local, ignoring message.",
				saddrinControl.sin_addr.S_un.S_un_b.s_b1,
				saddrinControl.sin_addr.S_un.S_un_b.s_b2,
				saddrinControl.sin_addr.S_un.S_un_b.s_b3,
				saddrinControl.sin_addr.S_un.S_un_b.s_b4,
				NTOHS(saddrinControl.sin_port));
			goto Exit;
		}
#else
		psaddrinHost = pUPnPDevice->GetHostAddress();

		//
		// Don't accept responses that refer to addresses other than the one
		// that sent this response.
		//
		if (saddrinControl.sin_addr.S_un.S_addr != psaddrinHost->sin_addr.S_un.S_addr)
		{
			DPFX(DPFPREP, 1, "Control IP address designated (%u.%u.%u.%u:%u) is not the same as host IP address (%u.%u.%u.%u:%u), ignoring message.",
				saddrinControl.sin_addr.S_un.S_un_b.s_b1,
				saddrinControl.sin_addr.S_un.S_un_b.s_b2,
				saddrinControl.sin_addr.S_un.S_un_b.s_b3,
				saddrinControl.sin_addr.S_un.S_un_b.s_b4,
				NTOHS(saddrinControl.sin_port),
				psaddrinHost->sin_addr.S_un.S_un_b.s_b1,
				psaddrinHost->sin_addr.S_un.S_un_b.s_b2,
				psaddrinHost->sin_addr.S_un.S_un_b.s_b3,
				psaddrinHost->sin_addr.S_un.S_un_b.s_b4,
				NTOHS(psaddrinHost->sin_port));
			goto Exit;
		}
#endif

		//
		// Don't accept responses that refer to ports in the reserved range
		// (less than or equal to 1024) other than the standard HTTP port.
		//
		if ((NTOHS(saddrinControl.sin_port) <= MAX_RESERVED_PORT) &&
			(saddrinControl.sin_port != HTONS(HTTP_PORT)))
		{
			DPFX(DPFPREP, 1, "Control address designated invalid port %u, ignoring message.",
				NTOHS(saddrinControl.sin_port));
			goto Exit;
		}
	}

	pUPnPDevice->SetControlAddress(&saddrinControl);


	//
	// Save the service control URL.
	//
	hr = pUPnPDevice->SetServiceControlURL(pszRelativePath);
	if (hr != DPNH_OK)
	{
		DPFX(DPFPREP, 0, "Couldn't store service control URL!");
		goto Failure;
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	hr = DPNHERR_GENERIC;

	goto Exit;
} // CNATHelpUPnP::ParseXMLCallback_DescriptionResponse





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ParseXMLCallback_ControlResponse"
//=============================================================================
// CNATHelpUPnP::ParseXMLCallback_ControlResponse
//-----------------------------------------------------------------------------
//
// Description: Handles a completed parsed element in a control SOAP response.
//
// Arguments:
//	PARSEXML_ELEMENT * pParseElement	- Pointer to element which was found.
//	PVOID pvContext						- Pointer to parsing context.
//	PARSEXML_STACKENTRY * aElementStack	- Array of parent elements containing
//											the completed element. 
//	BOOL * pfContinueParsing			- Pointer to BOOL that should be set
//											to FALSE if the calling function
//											should stop parsing the XML.
//
// Returns: HRESULT
//	DPNH_OK				- Description response was handled successfully.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::ParseXMLCallback_ControlResponse(PARSEXML_ELEMENT * const pParseElement,
														PVOID pvContext,
														PARSEXML_STACKENTRY * const aElementStack,
														BOOL * const pfContinueParsing)
{
	HRESULT							hr = DPNH_OK;
	PCONTROLRESPONSEPARSECONTEXT	pContext;
	//char *							pszReturn = NULL;
	char *							pszExternalIPAddress = NULL;
	char *							pszInternalPort = NULL;
	char *							pszInternalClient = NULL;
	char *							pszEnabled = NULL;
	char *							pszPortMappingDescription = NULL;
	char *							pszLeaseDuration = NULL;
	char *							pszErrorCode = NULL;
	char *							pszErrorDescription = NULL;
	DWORD							dwSubElement;
	PARSEXML_SUBELEMENT *			pSubElement;
	int								iErrorCode;


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, 0x%p)",
		this, pParseElement, pvContext, aElementStack, pfContinueParsing);


	pContext = (PCONTROLRESPONSEPARSECONTEXT) pvContext;


	DNASSERT(pContext != NULL);
	DNASSERT(pContext->pUPnPDevice != NULL);


	//
	// Look for the subelements we want.
	//
	for(dwSubElement = 0; dwSubElement < pParseElement->dwNumSubElements; dwSubElement++)
	{
		pSubElement = &pParseElement->paSubElements[dwSubElement];


		/*
		if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
													ARG_CONTROL_RETURN_A,
													aElementStack,
													pSubElement,
													pParseElement->dwElementStackDepth))
		{
			if (pszReturn == NULL)
			{
				pszReturn = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_CONTROL_RETURN_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		*/
		if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
													ARG_GETEXTERNALIPADDRESS_NEWEXTERNALIPADDRESS_A,
													aElementStack,
													pSubElement,
													pParseElement->dwElementStackDepth))
		{
			if (pszExternalIPAddress == NULL)
			{
				pszExternalIPAddress = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETEXTERNALIPADDRESS_NEWEXTERNALIPADDRESS_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALPORT_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszInternalPort == NULL)
			{
				pszInternalPort = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALPORT_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALCLIENT_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszInternalClient == NULL)
			{
				pszInternalClient = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALCLIENT_A "\" subelement (value = \"%hs\").",
					 pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_GETSPECIFICPORTMAPPINGENTRY_NEWENABLED_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszEnabled == NULL)
			{
				pszEnabled = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWENABLED_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPORTMAPPINGDESCRIPTION_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszPortMappingDescription == NULL)
			{
				pszPortMappingDescription = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWPORTMAPPINGDESCRIPTION_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_GETSPECIFICPORTMAPPINGENTRY_NEWLEASEDURATION_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszLeaseDuration == NULL)
			{
				pszLeaseDuration = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWLEASEDURATION_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_CONTROL_ERROR_ERRORCODE_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszErrorCode == NULL)
			{
				pszErrorCode = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_CONTROL_ERROR_ERRORCODE_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else if (this->MatchesXMLStringWithoutNamespace(pSubElement->pszNameFound,
														ARG_CONTROL_ERROR_ERRORDESCRIPTION_A,
														aElementStack,
														pSubElement,
														pParseElement->dwElementStackDepth))
		{
			if (pszErrorDescription == NULL)
			{
				pszErrorDescription = pSubElement->pszValueFound;
			}
			else
			{
				DPFX(DPFPREP, 7, "Ignoring duplicate \"" ARG_CONTROL_ERROR_ERRORDESCRIPTION_A "\" subelement (value = \"%hs\").",
					pSubElement->pszValueFound);
			}
		}
		else
		{
			DPFX(DPFPREP, 7, "Ignoring subelement \"%hs\" (value = \"%hs\").",
				pSubElement->pszNameFound, pSubElement->pszValueFound);
		}
	} // end for (each sub element)


	if (pContext->dwHTTPResponseCode == 200)
	{
		//
		// The action succeeded.
		//

		switch (pContext->ControlResponseType)
		{
			/*
			case CONTROLRESPONSETYPE_QUERYSTATEVARIABLE_EXTERNALIPADDRESS:
			{
				if (pszReturn == NULL)
				{
					DPFX(DPFPREP, 1, "Couldn't find \"" ARG_CONTROL_RETURN_A "\" in SOAP response, ignoring element.");
					goto Exit;
				}

				DPFX(DPFPREP, 2, "QueryStateVariable returned \"%hs\".",
					pszReturn);


				/ *
				//
				// Key off of the variable we were querying.
				//
				switch (pContext->ControlResponseType)
				{
					case CONTROLRESPONSETYPE_QUERYSTATEVARIABLE_EXTERNALIPADDRESS:
					{
				* /
						pContext->pControlResponseInfo->dwExternalIPAddressV4 = this->m_pfninet_addr(pszReturn);
						if (pContext->pControlResponseInfo->dwExternalIPAddressV4 == INADDR_NONE)
						{
							DPFX(DPFPREP, 1, "External IP address string \"%hs\" is invalid, using INADDR_ANY.");
							pContext->pControlResponseInfo->dwExternalIPAddressV4 = INADDR_ANY;
						}
				/ *
						break;
					}
				}
				* /

				break;
			}
			*/
			case CONTROLRESPONSETYPE_GETEXTERNALIPADDRESS:
			{
				if (pszExternalIPAddress == NULL)
				{
					DPFX(DPFPREP, 1, "Couldn't find \"" ARG_GETEXTERNALIPADDRESS_NEWEXTERNALIPADDRESS_A "\" in SOAP response, ignoring element.");
					goto Exit;
				}

				DPFX(DPFPREP, 2, "GetExternalIPAddress returned \"%hs\".",
					pszExternalIPAddress);


				pContext->pControlResponseInfo->dwExternalIPAddressV4 = this->m_pfninet_addr(pszExternalIPAddress);
				if ((pContext->pControlResponseInfo->dwExternalIPAddressV4 == INADDR_NONE) ||
					(IS_CLASSD_IPV4_ADDRESS(pContext->pControlResponseInfo->dwExternalIPAddressV4)))
				{
					DPFX(DPFPREP, 1, "External IP address string \"%hs\" is invalid, using INADDR_ANY.");
					pContext->pControlResponseInfo->dwExternalIPAddressV4 = INADDR_ANY;
				}

				break;
			}

			case CONTROLRESPONSETYPE_ADDPORTMAPPING:
			{
				DPFX(DPFPREP, 2, "AddPortMapping got success response.");
				break;
			}

			case CONTROLRESPONSETYPE_GETSPECIFICPORTMAPPINGENTRY:
			{
				/*
				if ((pszInternalPort == NULL) ||
					(pszInternalClient == NULL) ||
					(pszEnabled == NULL) ||
					(pszPortMappingDescription == NULL) ||
					(pszLeaseDuration == NULL))
				*/
				if (pszInternalClient == NULL)
				{
					DPFX(DPFPREP, 1, "Couldn't find \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALCLIENT_A "\" in SOAP response, ignoring element.");
					goto Exit;
				}

				if (pszInternalPort == NULL)
				{
					DPFX(DPFPREP, 1, "Couldn't find \"" ARG_GETSPECIFICPORTMAPPINGENTRY_NEWINTERNALPORT_A "\" in SOAP response, assuming asymmetric mappings are not supported.");
					pszInternalPort = "0";
				}


				DPFX(DPFPREP, 2, "GetPortMappingPrivateIP returned \"%hs:%hs\".",
					pszInternalClient, pszInternalPort);

				pContext->pControlResponseInfo->dwInternalClientV4 = this->m_pfninet_addr(pszInternalClient);
				if (pContext->pControlResponseInfo->dwInternalClientV4 == INADDR_ANY)
				{
					DPFX(DPFPREP, 0, "Internal client address is INADDR_ANY!");
					hr = DPNHERR_GENERIC;
					goto Failure;
				}
				
				pContext->pControlResponseInfo->wInternalPort = HTONS((WORD) atoi(pszInternalPort));

				break;
			}

			case CONTROLRESPONSETYPE_DELETEPORTMAPPING:
			{
				DPFX(DPFPREP, 2, "DeletePortMapping got success response.");
				break;
			}

			default:
			{
				DNASSERT(FALSE);
				hr = DPNHERR_GENERIC;
				goto Failure;
				break;
			}
		}


		//
		// The action completed successfully.
		//
		pContext->pControlResponseInfo->hrErrorCode = DPNH_OK;
	}
	else
	{
		//
		// The action failed.
		//

		//
		// See if we found an error description that we can print for
		// informational purposes.
		//
		if ((pszErrorCode != NULL) && (pszErrorDescription != NULL))
		{
			iErrorCode = atoi(pszErrorCode);
			
			switch (iErrorCode)
			{
				case UPNPERR_IGD_NOSUCHENTRYINARRAY:
				{
					DPFX(DPFPREP, 1, "Control action was rejected with NoSuchEntryInArray error %hs (description = \"%hs\").",
						pszErrorCode, pszErrorDescription);

					pContext->pControlResponseInfo->hrErrorCode = DPNHERR_NOMAPPING;
					break;
				}

				case UPNPERR_IGD_CONFLICTINMAPPINGENTRY:
				{
					DPFX(DPFPREP, 1, "Control action was rejected with ConflictInMappingEntry error %hs (description = \"%hs\").",
						pszErrorCode, pszErrorDescription);

					pContext->pControlResponseInfo->hrErrorCode = DPNHERR_PORTUNAVAILABLE;
					break;
				}

				case UPNPERR_IGD_SAMEPORTVALUESREQUIRED:
				{
					DPFX(DPFPREP, 1, "Control action was rejected with SamePortValuesRequired error %hs (description = \"%hs\").",
						pszErrorCode, pszErrorDescription);

					pContext->pControlResponseInfo->hrErrorCode = (HRESULT) UPNPERR_IGD_SAMEPORTVALUESREQUIRED;
					break;
				}

				case UPNPERR_IGD_ONLYPERMANENTLEASESSUPPORTED:
				{
					DPFX(DPFPREP, 1, "Control action was rejected with OnlyPermanentLeasesSupported error %hs (description = \"%hs\").",
						pszErrorCode, pszErrorDescription);

					pContext->pControlResponseInfo->hrErrorCode = (HRESULT) UPNPERR_IGD_ONLYPERMANENTLEASESSUPPORTED;
					break;
				}

				default:
				{
					DPFX(DPFPREP, 1, "Control action was rejected with unknown error \"%hs\", \"%hs\", assuming generic failure.",
						pszErrorCode, pszErrorDescription);

					pContext->pControlResponseInfo->hrErrorCode = DPNHERR_GENERIC;
					break;
				}
			}
		}
		else
		{
			DPFX(DPFPREP, 1, "Couldn't find either \"" ARG_CONTROL_ERROR_ERRORCODE_A "\", or \"" ARG_CONTROL_ERROR_ERRORDESCRIPTION_A "\" in SOAP response, assuming generic failure.");
			pContext->pControlResponseInfo->hrErrorCode = DPNHERR_GENERIC;
		}
	}


	//
	// If we got here, we got the information we needed.
	//
	pParseElement->fFoundMatchingElement = TRUE;
	(*pfContinueParsing) = FALSE;


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::ParseXMLCallback_ControlResponse





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ClearDevicesUPnPDevice"
//=============================================================================
// CNATHelpUPnP::ClearDevicesUPnPDevice
//-----------------------------------------------------------------------------
//
// Description:    Forcefully simulates de-registration with a UPnP device
///				without actually going to the network.  This clears all bind
//				IDs, public addresses, and cached mappings for a given device's
//				local or remote server, and should only be called after the
//				server appears to have died.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice	- Pointer to device whose UPnP device should be
//							removed.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::ClearDevicesUPnPDevice(CDevice * const pDevice)
{
	CUPnPDevice *	pUPnPDevice;


	DNASSERT(pDevice != NULL);


	pUPnPDevice = pDevice->GetUPnPDevice();
	if (pUPnPDevice != NULL)
	{
#ifdef DBG
		DPFX(DPFPREP, 1, "Clearing device 0x%p's UPnP device (0x%p).",
			pDevice, pUPnPDevice);

		pDevice->IncrementUPnPDeviceFailures();
		this->m_dwNumServerFailures++;
#endif // DBG

		//
		// Since there was a change in the network, go back to polling
		// relatively quickly.
		//
		this->ResetNextPollInterval();


		pUPnPDevice->ClearDeviceOwner();
		DNASSERT(pUPnPDevice->m_blList.IsListMember(&this->m_blUPnPDevices));
		pUPnPDevice->m_blList.RemoveFromList();

		//
		// Transfer list reference to our pointer, since GetUPnPDevice did not give
		// us one.
		//


		if (pUPnPDevice->IsConnected())
		{
			DNASSERT(pUPnPDevice->GetControlSocket() != INVALID_SOCKET);

			this->m_pfnshutdown(pUPnPDevice->GetControlSocket(), 0); // ignore error
			this->m_pfnclosesocket(pUPnPDevice->GetControlSocket());
			pUPnPDevice->SetControlSocket(INVALID_SOCKET);
		}
		else
		{
			DNASSERT(pUPnPDevice->GetControlSocket() == INVALID_SOCKET);
		}


		this->ClearAllUPnPRegisteredPorts(pDevice);

		pUPnPDevice->ClearLocationURL();
		pUPnPDevice->ClearUSN();
		pUPnPDevice->ClearServiceControlURL();
		pUPnPDevice->DestroyReceiveBuffer();
		pUPnPDevice->RemoveAllCachedMappings();

		pUPnPDevice->DecRef();
	}
	else
	{
		DPFX(DPFPREP, 1, "Can't clear device 0x%p's UPnP device, it doesn't exist.",
			pDevice);
	}
} // CNATHelpUPnP::ClearDevicesUPnPDevice




#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ClearAllUPnPRegisteredPorts"
//=============================================================================
// CNATHelpUPnP::ClearAllUPnPRegisteredPorts
//-----------------------------------------------------------------------------
//
// Description:    Clears all bind IDs and public addresses for a given
//				device's UPnP Internet gateway.  This should only be called
//				after the UPnP device dies.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	CDevice * pDevice	- Pointer to device whose ports should be unbound.
//	BOOL fRemote		- TRUE if clearing remote server, FALSE if clearing
//							local server.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::ClearAllUPnPRegisteredPorts(CDevice * const pDevice)
{
	CBilink *			pBilink;
	CRegisteredPort *	pRegisteredPort;


	DNASSERT(pDevice != NULL);


	pBilink = pDevice->m_blOwnedRegPorts.GetNext();
	while (pBilink != &pDevice->m_blOwnedRegPorts)
	{
		DNASSERT(! pBilink->IsEmpty());
		pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);

		if (pRegisteredPort->HasUPnPPublicAddresses())
		{
			if (! pRegisteredPort->IsRemovingUPnPLease())
			{
				DPFX(DPFPREP, 1, "Registered port 0x%p losing UPnP public address.",
					pRegisteredPort);

				//
				// Let the user know the next time GetCaps is called.
				//
				this->m_dwFlags |= NATHELPUPNPOBJ_ADDRESSESCHANGED;


				//
				// Note that this means the crash recovery entry will be left
				// in the registry for the next person to come along and clean
				// up.  That should be okay, since we should only be doing this
				// if we had a problem talking to the UPnP device (either it
				// went AWOL, or we lost the local network interface).  In
				// either case, we can't really clean it up now, so we have to
				// leave it for someone else to do.
				//

				pRegisteredPort->DestroyUPnPPublicAddressesArray();
				pRegisteredPort->NoteNotPermanentUPnPLease();

				DNASSERT(this->m_dwNumLeases > 0);
				this->m_dwNumLeases--;

				DPFX(DPFPREP, 7, "UPnP lease for 0x%p cleared, total num leases = %u.",
					pRegisteredPort, this->m_dwNumLeases);
			}
			else
			{
				DPFX(DPFPREP, 1, "Registered port 0x%p already has had UPnP public address removed, skipping.",
					pRegisteredPort);
			}
		}
		else
		{
			//
			// Port no longer unavailable (if it had been).
			//
			pRegisteredPort->NoteNotUPnPPortUnavailable();
		}

		pBilink = pBilink->GetNext();
	}
} // CNATHelpUPnP::ClearAllUPnPRegisteredPorts






#ifndef DPNBUILD_NOWINSOCK2


#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::RequestLocalAddressListChangeNotification"
//=============================================================================
// CNATHelpUPnP::RequestLocalAddressListChangeNotification
//-----------------------------------------------------------------------------
//
// Description:    Attempts to request asynchronous notification (via the
//				user's alert event or I/O completion port) when the local
//				address list changes.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: HRESULT
//	DPNH_OK				- The notification request was successfully submitted.
//	DPNHERR_GENERIC		- An error occurred.
//=============================================================================
HRESULT CNATHelpUPnP::RequestLocalAddressListChangeNotification(void)
{
	HRESULT		hr;
	DWORD		dwTemp;
	int			iReturn;


	DPFX(DPFPREP, 5, "(0x%p) Enter", this);


	DNASSERT(! (this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1));
	DNASSERT(this->m_sIoctls != INVALID_SOCKET);
	DNASSERT(this->m_pfnWSAIoctl != NULL);
	DNASSERT((this->m_hAlertEvent != NULL) || (this->m_hAlertIOCompletionPort != NULL));
	DNASSERT(this->m_polAddressListChange != NULL);


	do
	{
		iReturn = this->m_pfnWSAIoctl(this->m_sIoctls,				// use the special Ioctl socket
									SIO_ADDRESS_LIST_CHANGE,		//
									NULL,							// no input data
									0,								// no input data
									NULL,							// no output data
									0,								// no output data
									&dwTemp,						// ignore bytes returned
									this->m_polAddressListChange,	// overlapped structure
									NULL);							// no completion routine

		if (iReturn != 0)
		{
			dwTemp = this->m_pfnWSAGetLastError();
			if (dwTemp != WSA_IO_PENDING)
			{
				DPFX(DPFPREP, 0, "Submitting address list change notification request failed (err = %u)!", dwTemp);
				hr = DPNHERR_GENERIC;
				goto Failure;
			}


			//
			// Pending is what we want, we're set.
			//
			hr = DPNH_OK;
			break;
		}


		//
		// Address list changed right away?
		//
		DPFX(DPFPREP, 1, "Address list changed right away somehow, submitting again.");
	}
	while (TRUE);



Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);

	return hr;


Failure:

	goto Exit;
} // CNATHelpUPnP::RequestLocalAddressListChangeNotification


#endif // ! DPNBUILD_NOWINSOCK2





#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::CreateSocket"
//=============================================================================
// CNATHelpUPnP::CreateSocket
//-----------------------------------------------------------------------------
//
// Description:    Creates a UPnP discovery socket bound to a new random port
//				on the specified IP interface.  Completely random (but non-
//				reserved) port numbers are chosen first, but if those ports are
//				in use, WinSock is allowed to choose.  The port actually
//				selected will be returned in psaddrinAddress.
//
// Arguments:
//	SOCKADDR_IN * psaddrinAddress	- Pointer to base address to use when
//										binding.  The port will be modified.
//
// Returns: SOCKET
//=============================================================================
SOCKET CNATHelpUPnP::CreateSocket(SOCKADDR_IN * const psaddrinAddress,
								int iType,
								int iProtocol)
{
	SOCKET	sTemp;
	DWORD	dwTry;
	int		iTemp;
	BOOL	fTemp;
	ULONG	ulEnable;
#ifdef DBG
	DWORD	dwError;
#endif // DBG


	DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i, %i)",
		this, psaddrinAddress, iType, iProtocol);


	//
	// Create the socket.
	//
	sTemp = this->m_pfnsocket(AF_INET, iType, iProtocol);
	if (sTemp == INVALID_SOCKET)
	{
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 0, "Couldn't create datagram socket, error = %u!", dwError);
#endif // DBG
		goto Failure;
	}


	//
	// Try binding the socket to a completely random port a few times.
	//
	for(dwTry = 0; dwTry < MAX_NUM_RANDOM_PORT_TRIES; dwTry++)
	{
		//
		// Pick a completely random port.  For the moment, the value is stored
		// in host byte order while we make sure it's not a reserved value.
		//
		do
		{
			psaddrinAddress->sin_port = (WORD) GetGlobalRand();
		}
		while ((psaddrinAddress->sin_port <= MAX_RESERVED_PORT) ||
				(psaddrinAddress->sin_port == 1900) ||	// SSDP
				(psaddrinAddress->sin_port == 2234) ||	// PAST
				(psaddrinAddress->sin_port == 6073) ||	// DPNSVR
				(psaddrinAddress->sin_port == 47624));	// DPLAYSVR

		//
		// Now try binding to the port (in network byte order).
		//
		psaddrinAddress->sin_port = HTONS(psaddrinAddress->sin_port);
		if (this->m_pfnbind(sTemp, (SOCKADDR*) psaddrinAddress, sizeof(SOCKADDR_IN)) == 0)
		{
			//
			// We successfully bound to the port.
			//
			break;
		}

		//
		// Assume that the port is in use.
		//
#ifdef DBG
		dwError = this->m_pfnWSAGetLastError();
		DPFX(DPFPREP, 2, "Couldn't bind to port %u (err = %u), continuing.",
			NTOHS(psaddrinAddress->sin_port), dwError);
#endif // DBG

		psaddrinAddress->sin_port = 0;
	}


	//
	// If we ran out of completely random port attempts, just let WinSock
	// choose it.
	//
	if (psaddrinAddress->sin_port == 0)
	{
		if (this->m_pfnbind(sTemp, (SOCKADDR*) psaddrinAddress, sizeof(SOCKADDR_IN)) != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Failed binding to any port (err = %u)!",
				dwError);
#endif // DBG
			goto Failure;
		}


		//
		// Find out what port WinSock chose.
		//
		iTemp = sizeof(SOCKADDR_IN);
		if (this->m_pfngetsockname(sTemp,
								(SOCKADDR *) psaddrinAddress,
								&iTemp) != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't get the socket's address, error = %u!",
				dwError);
#endif // DBG
			goto Failure;
		}
		DNASSERT(psaddrinAddress->sin_port != 0);
	}


	//
	// Set the unicast TTL, if requested.  Use the appropriate constant for the
	// version of WinSock we're using.
	//
	if (g_iUnicastTTL != 0)
	{
		iTemp = this->m_pfnsetsockopt(sTemp,
									IPPROTO_IP,
#ifdef DPNBUILD_NOWINSOCK2
									IP_TTL,
#else // ! DPNBUILD_NOWINSOCK2
									((this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1) ? IP_TTL_WINSOCK1 : IP_TTL),
#endif // ! DPNBUILD_NOWINSOCK2
									(char *) (&g_iUnicastTTL),
									sizeof(g_iUnicastTTL));
		if (iTemp != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't set unicast TTL socket option, error = %u!  Ignoring.",
				dwError);
#endif // DBG

			//
			// Continue...
			//
		}
	}


	if (iType == SOCK_DGRAM)
	{
		if (g_fUseMulticastUPnPDiscovery)
		{
			//
			// Set the multicast interface.  Use the appropriate constant for
			// the version of WinSock we're using.
			//
			iTemp = this->m_pfnsetsockopt(sTemp,
										IPPROTO_IP,
#ifdef DPNBUILD_NOWINSOCK2
										IP_MULTICAST_IF,
#else // ! DPNBUILD_NOWINSOCK2
										((this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1) ? IP_MULTICAST_IF_WINSOCK1 : IP_MULTICAST_IF),
#endif // ! DPNBUILD_NOWINSOCK2
										(char *) (&psaddrinAddress->sin_addr.S_un.S_addr),
										sizeof(psaddrinAddress->sin_addr.S_un.S_addr));
			if (iTemp != 0)
			{
#ifdef DBG
				dwError = this->m_pfnWSAGetLastError();
				DPFX(DPFPREP, 1, "Couldn't set multicast interface socket option, error = %u, ignoring.",
					dwError);
#endif // DBG

				//
				// Continue...
				//
			}


			//
			// Set the multicast TTL, if requested.  Use the appropriate
			// constant for the version of WinSock we're using.
			//
			if (g_iMulticastTTL != 0)
			{
				iTemp = this->m_pfnsetsockopt(sTemp,
											IPPROTO_IP,
#ifdef DPNBUILD_NOWINSOCK2
											IP_MULTICAST_TTL,
#else // ! DPNBUILD_NOWINSOCK2
											((this->m_dwFlags & NATHELPUPNPOBJ_WINSOCK1) ? IP_MULTICAST_TTL_WINSOCK1 : IP_MULTICAST_TTL),
#endif // ! DPNBUILD_NOWINSOCK2
											(char *) (&g_iMulticastTTL),
											sizeof(g_iMulticastTTL));
				if (iTemp != 0)
				{
#ifdef DBG
					dwError = this->m_pfnWSAGetLastError();
					DPFX(DPFPREP, 0, "Couldn't set multicast TTL socket option, error = %u!  Ignoring.",
						dwError);
#endif // DBG

					//
					// Continue...
					//
				}
			}
		}
		else
		{
			//
			// Not using multicast.  Set the socket up to allow broadcasts in
			// case we can't determine the gateway.
			//
			fTemp = TRUE;
			if (this->m_pfnsetsockopt(sTemp,
									SOL_SOCKET,
									SO_BROADCAST,
									(char *) (&fTemp),
									sizeof(fTemp)) != 0)
			{
#ifdef DBG
				dwError = this->m_pfnWSAGetLastError();
				DPFX(DPFPREP, 0, "Couldn't set broadcast socket option, error = %u!", dwError);
#endif // DBG
				goto Failure;
			}
		}
	}
	else
	{
		//
		// Make the socket non-blocking.
		//
		ulEnable = 1;
		if (this->m_pfnioctlsocket(sTemp, FIONBIO, &ulEnable) != 0)
		{
#ifdef DBG
			dwError = this->m_pfnWSAGetLastError();
			DPFX(DPFPREP, 0, "Couldn't make socket non-blocking, error = %u!", dwError);
#endif // DBG
			goto Failure;
		}
	}


Exit:

	DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%x]", this, sTemp);

	return sTemp;


Failure:

	if (sTemp != INVALID_SOCKET)
	{
		this->m_pfnclosesocket(sTemp);
		sTemp = INVALID_SOCKET;
	}

	goto Exit;
} // CNATHelpUPnP::CreateSocket







#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::GetAddressToReachGateway"
//=============================================================================
// CNATHelpUPnP::GetAddressToReachGateway
//-----------------------------------------------------------------------------
//
// Description:    Retrieves the address of the gateway for the given device,
//				or the broadcast address if unable to be determined.
//
//				   This will return TRUE if the gateway's address was found, or
//				the IPHLPAPI DLL could not be used (Win95).  FALSE is returned
//				if IPHLPAPI reported that there was no gateway (ICS private
//				side adapter).
//
// Arguments:
//	CDevice * pDevice	- Pointer to device whose gateway should be retrieved.
//	IN_ADDR * pinaddr	- Place to store gateway or broadcast address.
//
// Returns: BOOL
//	TRUE	- Gateway address was found or had to use broadcast.
//	FALSE	- There is no gateway, do not attempt to use the address.
//=============================================================================
BOOL CNATHelpUPnP::GetAddressToReachGateway(CDevice * const pDevice,
											IN_ADDR * const pinaddr)
{
#ifdef DPNBUILD_NOWINSOCK2
	//
	// Fill in the default address.  This should be atomic, so don't worry
	// about locking the globals.
	//
	pinaddr->S_un.S_addr = g_dwDefaultGatewayV4;

	return TRUE;
#else // ! DPNBUILD_NOWINSOCK2
	DWORD					dwError;
	BOOL					fResult = TRUE;
	ULONG					ulSize;
	PIP_ADAPTER_INFO		pAdaptersBuffer = NULL;
	PIP_ADAPTER_INFO		pAdapterInfo;
	PIP_ADDR_STRING			pIPAddrString;
	DWORD					dwAdapterIndex;
	PMIB_IPFORWARDTABLE		pIPForwardTableBuffer = NULL;
	DWORD					dwTemp;
	PMIB_IPFORWARDROW 		pIPForwardRow;



	//
	// Fill in the default address.  This should be atomic, so don't worry
	// about locking the globals.
	//
	pinaddr->S_un.S_addr = g_dwDefaultGatewayV4;

#ifdef DBG
	pDevice->ClearGatewayFlags();
#endif // DBG


	//
	// If this is the loopback address, then don't bother looking for a
	// gateway, we won't find one.
	//
	if (pDevice->GetLocalAddressV4() == NETWORKBYTEORDER_INADDR_LOOPBACK)
	{
		DPFX(DPFPREP, 8, "No gateway for loopback address (device = 0x%p).",
			pDevice);

		//
		// No gateway.
		//
#ifdef DBG
		pDevice->NoteNoGateway();
#endif // DBG
		fResult = FALSE;
		goto Exit;
	}


	//
	// If we didn't load the IP helper DLL, we can't do our fancy gateway
	// tricks.
	//
	if (this->m_hIpHlpApiDLL == NULL)
	{
		DPFX(DPFPREP, 4, "Didn't load \"iphlpapi.dll\", returning default address for device 0x%p.",
			pDevice);
		goto Exit;
	}


	//
	// Keep trying to get the list of adapters until we get ERROR_SUCCESS or a
	// legitimate error (other than ERROR_BUFFER_OVERFLOW or
	// ERROR_INSUFFICIENT_BUFFER).
	//
	ulSize = 0;
	do
	{
		dwError = this->m_pfnGetAdaptersInfo(pAdaptersBuffer, &ulSize);
		if (dwError == ERROR_SUCCESS)
		{
			//
			// We succeeded, we should be set.  But make sure there are
			// adapters for us to use.
			//
			if (ulSize < sizeof(IP_ADAPTER_INFO))
			{
				DPFX(DPFPREP, 0, "Getting adapters info succeeded but didn't return any valid adapters (%u < %u), returning default address for device 0x%p.",
					ulSize, sizeof(IP_ADAPTER_INFO), pDevice);
				goto Exit;
			}

			break;
		}

		if ((dwError != ERROR_BUFFER_OVERFLOW) &&
			(dwError != ERROR_INSUFFICIENT_BUFFER))
		{
			DPFX(DPFPREP, 0, "Unable to get adapters info (error = 0x%lx), returning default address for device 0x%p.",
				dwError, pDevice);
			goto Exit;
		}

		//
		// We need more adapter space.  Make sure there are adapters for us to
		// use.
		//
		if (ulSize < sizeof(IP_ADAPTER_INFO))
		{
			DPFX(DPFPREP, 0, "Getting adapters info didn't return any valid adapters (%u < %u), returning default address for device 0x%p.",
				ulSize, sizeof(IP_ADAPTER_INFO), pDevice);
			goto Exit;
		}

		//
		// If we previously had a buffer, free it.
		//
		if (pAdaptersBuffer != NULL)
		{
			DNFree(pAdaptersBuffer);
		}

		//
		// Allocate the buffer.
		//
		pAdaptersBuffer = (PIP_ADAPTER_INFO) DNMalloc(ulSize);
		if (pAdaptersBuffer == NULL)
		{
			DPFX(DPFPREP, 0, "Unable to allocate memory for adapters info, returning default address for device 0x%p.",
				pDevice);
			goto Exit;
		}
	}
	while (TRUE);


	//
	// Now find the device in the adapter list returned.  Loop through all
	// adapters.
	//
	pAdapterInfo = pAdaptersBuffer;
	while (pAdapterInfo != NULL)
	{
		//
		// Loop through all addresses for this adapter looking for the one for
		// the device we have bound.
		//
		pIPAddrString = &pAdapterInfo->IpAddressList;
		while (pIPAddrString != NULL)
		{
			if (this->m_pfninet_addr(pIPAddrString->IpAddress.String) == pDevice->GetLocalAddressV4())
			{
				pinaddr->S_un.S_addr = this->m_pfninet_addr(pAdapterInfo->GatewayList.IpAddress.String);
				if ((pinaddr->S_un.S_addr == INADDR_ANY) ||
					(pinaddr->S_un.S_addr == INADDR_NONE))
				{
					DPFX(DPFPREP, 8, "Found address for device 0x%p under adapter index %u (\"%hs\") but there is no gateway.",
						pDevice, pAdapterInfo->Index, pAdapterInfo->Description);

					//
					// Although this isn't reporting a gateway, we may still
					// want to use this adapter.  That's because this could be
					// a multihomed machine with multiple NICs on the same
					// network, where this one isn't the "default" adapter.
					// So save the index so we can search for it later.
					//
					dwAdapterIndex = pAdapterInfo->Index;

					goto CheckRouteTable;
				}


				//
				// Make sure the address doesn't match the local device.
				//
				if (pinaddr->S_un.S_addr == pDevice->GetLocalAddressV4())
				{
					DPFX(DPFPREP, 1, "Gateway address for device 0x%p (adapter index %u, \"%hs\") matches device IP address %hs!  Forcing no gateway.",
						pDevice, pAdapterInfo->Index, pAdapterInfo->Description,
						pAdapterInfo->GatewayList.IpAddress.String);

					//
					// Pretend there's no gateway, since the one we received is
					// bogus.
					//
#ifdef DBG
					pDevice->NoteNoGateway();
#endif // DBG
					fResult = FALSE;
				}
				else
				{
					DPFX(DPFPREP, 7, "Found address for device 0x%p under adapter index %u (\"%hs\"), gateway = %hs.",
						pDevice, pAdapterInfo->Index, pAdapterInfo->Description,
						pAdapterInfo->GatewayList.IpAddress.String);

#ifdef DBG
					pDevice->NotePrimaryDevice();
#endif // DBG
				}

				goto Exit;
			}

			pIPAddrString = pIPAddrString->Next;
		}

		if (! fResult)
		{
			break;
		}

		pAdapterInfo = pAdapterInfo->Next;
	}


	//
	// If we got here, then we didn't find the address.  fResult will still be
	// TRUE.
	//
	DPFX(DPFPREP, 0, "Did not find adapter with matching address, returning default address for device 0x%p.",
		pDevice);
	goto Exit;


CheckRouteTable:

	//
	// The adapter info structure said that the device doesn't have a gateway.
	// However for some reason the gateway is only reported for the "default"
	// device when multiple NICs can reach the same network.  Check the routing
	// table to determine if there's a gateway for secondary devices.
	//

	//
	// Keep trying to get the routing table until we get ERROR_SUCCESS or a
	// legitimate error (other than ERROR_BUFFER_OVERFLOW or
	// ERROR_INSUFFICIENT_BUFFER).
	//
	ulSize = 0;
	do
	{
		dwError = this->m_pfnGetIpForwardTable(pIPForwardTableBuffer, &ulSize, TRUE);
		if (dwError == ERROR_SUCCESS)
		{
			//
			// We succeeded, we should be set.  But make sure the size is
			// valid.
			//
			if (ulSize < sizeof(MIB_IPFORWARDTABLE))
			{
				DPFX(DPFPREP, 0, "Getting IP forward table succeeded but didn't return a valid buffer (%u < %u), returning \"no gateway\" indication for device 0x%p.",
					ulSize, sizeof(MIB_IPFORWARDTABLE), pDevice);
				fResult = FALSE;
				goto Exit;
			}

			break;
		}

		if ((dwError != ERROR_BUFFER_OVERFLOW) &&
			(dwError != ERROR_INSUFFICIENT_BUFFER))
		{
			DPFX(DPFPREP, 0, "Unable to get IP forward table (error = 0x%lx), returning \"no gateway\" indication for device 0x%p.",
				dwError, pDevice);
			fResult = FALSE;
			goto Exit;
		}

		//
		// We need more table space.  Make sure there are adapters for us to
		// use.
		//
		if (ulSize < sizeof(MIB_IPFORWARDTABLE))
		{
			DPFX(DPFPREP, 0, "Getting IP forward table didn't return any valid adapters (%u < %u), returning \"no gateway\" indication for device 0x%p.",
				ulSize, sizeof(MIB_IPFORWARDTABLE), pDevice);
			fResult = FALSE;
			goto Exit;
		}

		//
		// If we previously had a buffer, free it.
		//
		if (pIPForwardTableBuffer != NULL)
		{
			DNFree(pIPForwardTableBuffer);
		}

		//
		// Allocate the buffer.
		//
		pIPForwardTableBuffer = (PMIB_IPFORWARDTABLE) DNMalloc(ulSize);
		if (pIPForwardTableBuffer == NULL)
		{
			DPFX(DPFPREP, 0, "Unable to allocate memory for IP forward table, returning \"no gateway\" indication for device 0x%p.",
				pDevice);
			fResult = FALSE;
			goto Exit;
		}
	}
	while (TRUE);
	
	
	//
	// Now find the interface.  Note that we don't look it up as a destination
	// address.  Instead, we look for it as the interface to use for a 0.0.0.0
	// network destination.
	//
	// We're looking for a route entry:
	//
	//	Network Destination		Netmask		Gateway				Interface			Metric
	//	0.0.0.0					0.0.0.0		xxx.xxx.xxx.xxx		yyy.yyy.yyy.yyy		1
	//
	// We have yyy.yyy.yyy.yyy, we're trying to get xxx.xxx.xxx.xxx
	//
	pIPForwardRow = pIPForwardTableBuffer->table;
	for(dwTemp = 0; dwTemp < pIPForwardTableBuffer->dwNumEntries; dwTemp++)
	{
		//
		// Is this a 0.0.0.0 network destination?
		//
		if (pIPForwardRow->dwForwardDest == INADDR_ANY)
		{
			DNASSERT(pIPForwardRow->dwForwardMask == INADDR_ANY);


			//
			// Is this the right interface?
			//
			if (pIPForwardRow->dwForwardIfIndex == dwAdapterIndex)
			{
				if (pIPForwardRow->dwForwardNextHop == INADDR_ANY)
				{
					DPFX(DPFPREP, 8, "Found route table entry, but it didn't have a gateway (device = 0x%p).",
						pDevice);

					//
					// No gateway.
					//
#ifdef DBG
					pDevice->NoteNoGateway();
#endif // DBG
					fResult = FALSE;
				}
				else
				{
					//
					// Make sure the address doesn't match the local device.
					//
					if (pinaddr->S_un.S_addr == pDevice->GetLocalAddressV4())
					{
						DPFX(DPFPREP, 1, "Route table gateway for device 0x%p matches device's IP address %u.%u.%u.%u!  Forcing no gateway.",
							pDevice,
							pinaddr->S_un.S_un_b.s_b1,
							pinaddr->S_un.S_un_b.s_b2,
							pinaddr->S_un.S_un_b.s_b3,
							pinaddr->S_un.S_un_b.s_b4);

						//
						// Pretend there's no gateway, since the one we
						// received is bogus.
						//
#ifdef DBG
						pDevice->NoteNoGateway();
#endif // DBG
						fResult = FALSE;
					}
					else
					{
						pinaddr->S_un.S_addr = pIPForwardRow->dwForwardNextHop;

						DPFX(DPFPREP, 8, "Found route table entry, gateway = %u.%u.%u.%u (device = 0x%p).",
							pinaddr->S_un.S_un_b.s_b1,
							pinaddr->S_un.S_un_b.s_b2,
							pinaddr->S_un.S_un_b.s_b3,
							pinaddr->S_un.S_un_b.s_b4,
							pDevice);

						//
						// We found a gateway after all, fResult == TRUE.
						//
#ifdef DBG
						pDevice->NoteSecondaryDevice();
#endif // DBG
					}
				}

				//
				// We're done here.
				//
				goto Exit;
			}
		}

		//
		// Move to next row.
		//
		pIPForwardRow++;
	}

	
	//
	// If we got here, then we couldn't find an appropriate entry in the
	// routing table.
	//
	DPFX(DPFPREP, 1, "Did not find adapter in routing table, returning \"no gateway\" indication for device 0x%p.",
		pDevice);
#ifdef DBG
	pDevice->NoteNoGateway();
#endif // DBG
	fResult = FALSE;


Exit:

	if (pAdaptersBuffer != NULL)
	{
		DNFree(pAdaptersBuffer);
		pAdaptersBuffer = NULL;
	}

	if (pIPForwardTableBuffer != NULL)
	{
		DNFree(pIPForwardTableBuffer);
		pIPForwardTableBuffer = NULL;
	}

	return fResult;
#endif // ! DPNBUILD_NOWINSOCK2
} // CNATHelpUPnP::GetAddressToReachGateway







#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::IsAddressLocal"
//=============================================================================
// CNATHelpUPnP::IsAddressLocal
//-----------------------------------------------------------------------------
//
// Description:    Returns TRUE if the given address is local to the given
//				device; that is, if the device can send to the address directly
//				without having to go through the gateway.
//
//				   Note that if IPHLPAPI is not available (Win95), this
//				function will make an educated guess using a reasonable subnet
//				mask.
//
// Arguments:
//	CDevice * pDevice				- Pointer to device to use.
//	SOCKADDR_IN * psaddrinAddress	- Address whose locality is in question.
//
// Returns: BOOL
//	TRUE	- Address is behind the same gateway as the device.
//	FALSE	- Address is not behind the same gateway as the device.
//=============================================================================
BOOL CNATHelpUPnP::IsAddressLocal(CDevice * const pDevice,
								const SOCKADDR_IN * const psaddrinAddress)
{
	BOOL				fResult;
	DWORD				dwSubnetMaskV4;
#ifndef DPNBUILD_NOWINSOCK2
	DWORD				dwError;
	MIB_IPFORWARDROW	IPForwardRow;
#endif // ! DPNBUILD_NOWINSOCK2


	//
	// If the address to query matches the device's local address exactly, then
	// of course it's local.
	//
	if (psaddrinAddress->sin_addr.S_un.S_addr == pDevice->GetLocalAddressV4())
	{
		DPFX(DPFPREP, 6, "The address %u.%u.%u.%u matches device 0x%p's local address exactly.",
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
			pDevice);
		fResult = TRUE;
		goto Exit;
	}

	//
	// If it's a multicast address, then it should not be considered local.
	//
	if (IS_CLASSD_IPV4_ADDRESS(psaddrinAddress->sin_addr.S_un.S_addr))
	{
		DPFX(DPFPREP, 6, "Address %u.%u.%u.%u is multicast, not considered local for device 0x%p.",
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
			pDevice);
		fResult = FALSE;
		goto Exit;
	}
	

#ifndef DPNBUILD_NOWINSOCK2
	//
	// If we didn't load the IP helper DLL, we will have to guess.
	//
	if (this->m_hIpHlpApiDLL == NULL)
	{
		goto EducatedGuess;
	}


	//
	// Figure out what IPHLPAPI says about how to get there.
	//
	
	ZeroMemory(&IPForwardRow, sizeof(IPForwardRow));

	dwError = this->m_pfnGetBestRoute(psaddrinAddress->sin_addr.S_un.S_addr,
									pDevice->GetLocalAddressV4(),
									&IPForwardRow);
	if (dwError != ERROR_SUCCESS)
	{
		DPFX(DPFPREP, 0, "Unable to get best route to %u.%u.%u.%u via device 0x%p (error = 0x%lx)!  Using subnet mask.",
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
			pDevice,
			dwError);
		goto EducatedGuess;
	}


	//
	// Key off what IPHLPAPI returned.
	//
	switch (IPForwardRow.dwForwardType)
	{
		case 1:
		{
			//
			// Other.
			//
			DPFX(DPFPREP, 6, "The route from device 0x%p to %u.%u.%u.%u is unknown.",
				pDevice,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b4);
			fResult = FALSE;
			break;
		}

		case 2:
		{
			//
			// The route is invalid.
			//
			DPFX(DPFPREP, 6, "The route from device 0x%p to %u.%u.%u.%u is invalid.",
				pDevice,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b4);
			fResult = FALSE;
			break;
		}

		case 3:
		{
			//
			// The next hop is the final destination (local route).
			// Unfortunately, on multi-NIC machines querying an address
			// reachable by another device returns success... not sure why, but
			// if that's the case we need to further qualify this result.  We
			// do that by making sure the next hop address is actually the
			// device with which we're querying.
			//
			if (IPForwardRow.dwForwardNextHop == pDevice->GetLocalAddressV4())
			{
				DPFX(DPFPREP, 6, "Device 0x%p can reach %u.%u.%u.%u directly, it's local.",
					pDevice,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b4);

				fResult = TRUE;
			}
			else
			{
				DPFX(DPFPREP, 6, "Device 0x%p can reach %u.%u.%u.%u but it would be routed via another device (%u.%u.%u.%u).",
					pDevice,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
					psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
					((IN_ADDR*) (&IPForwardRow.dwForwardNextHop))->S_un.S_un_b.s_b1,
					((IN_ADDR*) (&IPForwardRow.dwForwardNextHop))->S_un.S_un_b.s_b2,
					((IN_ADDR*) (&IPForwardRow.dwForwardNextHop))->S_un.S_un_b.s_b3,
					((IN_ADDR*) (&IPForwardRow.dwForwardNextHop))->S_un.S_un_b.s_b4);

				fResult = FALSE;
			}
			break;
		}

		case 4:
		{
			//
			// The next hop is not the final destination (remote route).
			//
			DPFX(DPFPREP, 6, "Device 0x%p cannot reach %u.%u.%u.%u directly.",
				pDevice,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b4);
			fResult = FALSE;
			break;
		}

		default:
		{
			//
			// What?
			//
			DPFX(DPFPREP, 0, "Unexpected forward type %u for device 0x%p and address %u.%u.%u.%u!",
				IPForwardRow.dwForwardType,
				pDevice,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
				psaddrinAddress->sin_addr.S_un.S_un_b.s_b4);
			fResult = FALSE;
			break;
		}
	}

	goto Exit;


EducatedGuess:
#endif // ! DPNBUILD_NOWINSOCK2


	//
	// This should be atomic, so don't worry about locking.
	//
	dwSubnetMaskV4 = g_dwSubnetMaskV4;

	if ((pDevice->GetLocalAddressV4() & dwSubnetMaskV4) == (psaddrinAddress->sin_addr.S_un.S_addr & dwSubnetMaskV4))
	{
		DPFX(DPFPREP, 4, "Didn't load \"iphlpapi.dll\", guessing that device 0x%p can reach %u.%u.%u.%u (using subnet mask 0x%08x).",
			pDevice,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
			dwSubnetMaskV4);
		fResult = TRUE;
	}
	else
	{
		DPFX(DPFPREP, 4, "Didn't load \"iphlpapi.dll\", guessing that device 0x%p cannot reach %u.%u.%u.%u (using subnet mask 0x%08x).",
			pDevice,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b1,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b2,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b3,
			psaddrinAddress->sin_addr.S_un.S_un_b.s_b4,
			dwSubnetMaskV4);
		fResult = FALSE;
	}


Exit:

	return fResult;
} // CNATHelpUPnP::IsAddressLocal






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::ExpireOldCachedMappings"
//=============================================================================
// CNATHelpUPnP::ExpireOldCachedMappings
//-----------------------------------------------------------------------------
//
// Description:    Removes any cached mappings for any device which has
//				expired.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::ExpireOldCachedMappings(void)
{
	DWORD			dwCurrentTime;
	CBilink *		pBilinkUPnPDevice;
	CBilink *		pCachedMaps;
	CBilink *		pBilinkCacheMap;
	CCacheMap *		pCacheMap;
	CUPnPDevice *	pUPnPDevice;


	DPFX(DPFPREP, 7, "(0x%p) Enter", this);


	dwCurrentTime = GETTIMESTAMP();


	//
	// Check the UPnP device cached mappings.
	//
	pBilinkUPnPDevice = this->m_blUPnPDevices.GetNext();
	while (pBilinkUPnPDevice != &this->m_blUPnPDevices)
	{
		DNASSERT(! pBilinkUPnPDevice->IsEmpty());
		pUPnPDevice = UPNPDEVICE_FROM_BILINK(pBilinkUPnPDevice);


		//
		// Check the actual cached mappings.
		//
		pCachedMaps = pUPnPDevice->GetCachedMaps();
		pBilinkCacheMap = pCachedMaps->GetNext();
		while (pBilinkCacheMap != pCachedMaps)
		{
			DNASSERT(! pBilinkCacheMap->IsEmpty());
			pCacheMap = CACHEMAP_FROM_BILINK(pBilinkCacheMap);
			pBilinkCacheMap = pBilinkCacheMap->GetNext();

			if ((int) (pCacheMap->GetExpirationTime() - dwCurrentTime) < 0)
			{
				DPFX(DPFPREP, 5, "UPnP device 0x%p cached mapping 0x%p has expired.",
					pUPnPDevice, pCacheMap);

				pCacheMap->m_blList.RemoveFromList();
				delete pCacheMap;
			}
		}

		pBilinkUPnPDevice = pBilinkUPnPDevice->GetNext();
	}


	DPFX(DPFPREP, 7, "(0x%p) Leave", this);
} // CNATHelpUPnP::ExpireOldCachedMappings





#ifdef WINNT

#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::IsUPnPServiceDisabled"
//=============================================================================
// CNATHelpUPnP::IsUPnPServiceDisabled
//-----------------------------------------------------------------------------
//
// Description:    Returns TRUE if at least one UPnP related service is
//				disabled, FALSE if no UPnP related services are disabled.
//
// Arguments:
//	char * szString			- Pointer to string to print.
//	int iStringLength		- Length of string to print.
//	char * szDescription	- Description header for the transaction.
//	CDevice * pDevice		- Device handling transaction, or NULL if not
//								known.
//
// Returns: BOOL
//	TRUE	- A UPnP related service was disabled.
//	FALSE	- No UPnP related services were disabled.
//=============================================================================
BOOL CNATHelpUPnP::IsUPnPServiceDisabled(void)
{
	BOOL					fResult = FALSE;
	SC_HANDLE				schSCManager = NULL;
	DWORD					dwTemp;
	SC_HANDLE				schService = NULL;
	QUERY_SERVICE_CONFIG *	pQueryServiceConfig = NULL;
	DWORD					dwQueryServiceConfigSize = 0;
	DWORD					dwError;


	schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_CONNECT);
	if (schSCManager == NULL)
	{
#ifdef DBG
		dwError = GetLastError();
		DPFX(DPFPREP, 0, "Couldn't open SC Manager (err = %u)!", dwError);
#endif // DBG
		goto Exit;
	}


	//
	// Loop through each relevant service.
	//
	for(dwTemp = 0; dwTemp < (sizeof(c_tszUPnPServices) / sizeof(TCHAR*)); dwTemp++)
	{
		schService = OpenService(schSCManager, c_tszUPnPServices[dwTemp], SERVICE_QUERY_CONFIG);
		if (schService != NULL)
		{
			do
			{
				if (QueryServiceConfig(schService,
										pQueryServiceConfig,
										dwQueryServiceConfigSize,
										&dwQueryServiceConfigSize))
				{
					//
					// Make sure the size written is valid.
					//
					if (dwQueryServiceConfigSize < sizeof(QUERY_SERVICE_CONFIG))
					{
						DPFX(DPFPREP, 0, "Got invalid service config size for \"%s\" (%u < %u)!",
							c_tszUPnPServices[dwTemp], dwQueryServiceConfigSize, sizeof(QUERY_SERVICE_CONFIG));
						goto Exit;
					}

					break;
				}
				
				
				//
				// Otherwise, we failed.  Make sure it's because our buffer was
				// too small.
				//
				dwError = GetLastError();
				if (dwError != ERROR_INSUFFICIENT_BUFFER)
				{
					DPFX(DPFPREP, 0, "Couldn't query \"%s\" service config (err = %u)!",
						c_tszUPnPServices[dwTemp], dwError);
					goto Exit;
				}


				//
				// Make sure the size needed is valid.
				//
				if (dwQueryServiceConfigSize < sizeof(QUERY_SERVICE_CONFIG))
				{
					DPFX(DPFPREP, 0, "Got invalid service config size for \"%s\" (%u < %u)!",
						c_tszUPnPServices[dwTemp], dwQueryServiceConfigSize, sizeof(QUERY_SERVICE_CONFIG));
					goto Exit;
				}


				//
				// (Re)-allocate the buffer.
				//

				if (pQueryServiceConfig != NULL)
				{
					DNFree(pQueryServiceConfig);
				}

				pQueryServiceConfig = (QUERY_SERVICE_CONFIG*) DNMalloc(dwQueryServiceConfigSize);
				if (pQueryServiceConfig == NULL)
				{
					DPFX(DPFPREP, 0, "Couldn't allocate memory to query service config.");
					goto Exit;
				}
			}
			while (TRUE);


			//
			// If the service was disabled, we're done here.
			//
			if (pQueryServiceConfig->dwStartType == SERVICE_DISABLED)
			{
				DPFX(DPFPREP, 1, "The \"%s\" service has been disabled.",
					c_tszUPnPServices[dwTemp]);
				fResult = TRUE;
				goto Exit;
			}

			DPFX(DPFPREP, 7, "The \"%s\" service is not disabled (start type = %u).",
				c_tszUPnPServices[dwTemp], pQueryServiceConfig->dwStartType);
		}
		else
		{
			//
			// Win2K doesn't have these services, so it will always fail.
			//
#ifdef DBG
			dwError = GetLastError();
			DPFX(DPFPREP, 1, "Couldn't open \"%s\" service (err = %u), continuing.",
				c_tszUPnPServices[dwTemp], dwError);
#endif // DBG
		}
	}


Exit:

	if (pQueryServiceConfig != NULL)
	{
		DNFree(pQueryServiceConfig);
		pQueryServiceConfig = NULL;
	}

	if (schService != NULL)
	{
		CloseServiceHandle(schService);
		schService = NULL;
	}

	if (schSCManager != NULL)
	{
		CloseServiceHandle(schSCManager);
		schSCManager = NULL;
	}

	return fResult;
} // CNATHelpUPnP::IsUPnPServiceDisabled

#endif // WINNT





#ifdef DBG

#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::PrintUPnPTransactionToFile"
//=============================================================================
// CNATHelpUPnP::PrintUPnPTransactionToFile
//-----------------------------------------------------------------------------
//
// Description:    Prints a given UPnP transaction to the file if logging is
//				enabled.
//
//				   The object lock is assumed to be held.
//
// Arguments:
//	char * szString			- Pointer to string to print.
//	int iStringLength		- Length of string to print.
//	char * szDescription	- Description header for the transaction.
//	CDevice * pDevice		- Device handling transaction, or NULL if not
//								known.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::PrintUPnPTransactionToFile(const char * const szString,
											const int iStringLength,
											const char * const szDescription,
											CDevice * const pDevice)
{
	DNHANDLE	hFile;
	DWORD		dwNumBytesWritten;
	TCHAR		tszHeaderPrefix[256];
	DWORD		dwError;
#ifdef UNICODE
	char		szHeaderPrefix[256];
#endif // UNICODE


	//
	// Lock the globals so nobody touches the string while we use it.
	//
	DNEnterCriticalSection(&g_csGlobalsLock);


	//
	// Only print it if UPnP transaction logging is turned on.
	//
	if (wcslen(g_wszUPnPTransactionLog) > 0)
	{
#ifndef UNICODE
		HRESULT		hr;
		char		szUPnPTransactionLog[sizeof(g_wszUPnPTransactionLog) / sizeof(WCHAR)];
		DWORD		dwLength;


		//
		// Convert the Unicode file name/path into ANSI.
		//

		dwLength = sizeof(szUPnPTransactionLog) / sizeof(char);

		hr = STR_WideToAnsi(g_wszUPnPTransactionLog,
							-1,								// NULL terminated
							szUPnPTransactionLog,
							&dwLength);
		if (hr != S_OK)
		{
			DPFX(DPFPREP, 0, "Couldn't convert UPnP transaction log file string from Unicode to ANSI (err = 0x%lx)!",
				hr);
			hFile = DNINVALID_HANDLE_VALUE;
		}
		else
		{
			//
			// Open the file if it exists, or create a new one if it doesn't.
			//
			hFile = DNCreateFile(szUPnPTransactionLog,
								(GENERIC_READ | GENERIC_WRITE),
								FILE_SHARE_READ,
								NULL,
								OPEN_ALWAYS,
								0,
								NULL);
		}
#else // UNICODE
		//
		// Open the file if it exists, or create a new one if it doesn't.
		//
		hFile = DNCreateFile(g_wszUPnPTransactionLog,
						(GENERIC_READ | GENERIC_WRITE),
						FILE_SHARE_READ,
						NULL,
						OPEN_ALWAYS,
						0,
						NULL);
#endif // UNICODE

		if (hFile == DNINVALID_HANDLE_VALUE)
		{
			dwError = GetLastError();
			DPFX(DPFPREP, 0, "Couldn't open UPnP transaction log file, err = %u!",
				dwError);
		}
		else
		{
			//
			// Move the write pointer to the end of the file unless the file
			// has exceeded the maximum size, in which case just start over.
			// Ignore error.
			//
			if (GetFileSize(HANDLE_FROM_DNHANDLE(hFile), NULL) >= MAX_TRANSACTION_LOG_SIZE)
			{
				DPFX(DPFPREP, 0, "Transaction log maximum size exceeded, overwriting existing contents!");
				SetFilePointer(HANDLE_FROM_DNHANDLE(hFile), 0, NULL, FILE_BEGIN);
			}
			else
			{
				SetFilePointer(HANDLE_FROM_DNHANDLE(hFile), 0, NULL, FILE_END);
			}


			//
			// Write the descriptive header.  Ignore errors.
			//

			if (pDevice != NULL)
			{
				IN_ADDR		inaddr;


				inaddr.S_un.S_addr = pDevice->GetLocalAddressV4();

				wsprintf(tszHeaderPrefix,
						_T("%u\t0x%lx\t0x%lx\t(0x%p, %u.%u.%u.%u) UPnP transaction \""),
						GETTIMESTAMP(),
						GetCurrentProcessId(),
						GetCurrentThreadId(),
						pDevice,
						inaddr.S_un.S_un_b.s_b1,
						inaddr.S_un.S_un_b.s_b2,
						inaddr.S_un.S_un_b.s_b3,
						inaddr.S_un.S_un_b.s_b4);
			}
			else
			{
				wsprintf(tszHeaderPrefix,
						_T("%u\t0x%lx\t0x%lx\t(no device) UPnP transaction \""),
						GETTIMESTAMP(),
						GetCurrentProcessId(),
						GetCurrentThreadId());
			}

#ifdef UNICODE
			STR_jkWideToAnsi(szHeaderPrefix,
							tszHeaderPrefix,
							(_tcslen(tszHeaderPrefix) + 1));
			WriteFile(HANDLE_FROM_DNHANDLE(hFile), szHeaderPrefix, strlen(szHeaderPrefix), &dwNumBytesWritten, NULL);
#else // ! UNICODE
			WriteFile(HANDLE_FROM_DNHANDLE(hFile), tszHeaderPrefix, _tcslen(tszHeaderPrefix), &dwNumBytesWritten, NULL);
#endif // ! UNICODE

			WriteFile(HANDLE_FROM_DNHANDLE(hFile), szDescription, strlen(szDescription), &dwNumBytesWritten, NULL);

			WriteFile(HANDLE_FROM_DNHANDLE(hFile), "\"\r\n", strlen("\"\r\n"), &dwNumBytesWritten, NULL);


			//
			// Write the transaction.  Ignore error.
			//
			WriteFile(HANDLE_FROM_DNHANDLE(hFile), szString, iStringLength, &dwNumBytesWritten, NULL);


			//
			// Add blank space.  Ignore error.
			//
			WriteFile(HANDLE_FROM_DNHANDLE(hFile), "\r\n\r\n", strlen("\r\n\r\n"), &dwNumBytesWritten, NULL);


			//
			// Truncate the log at this point in case we are overwriting
			// existing contents.  Ignore error.
			//
			SetEndOfFile(HANDLE_FROM_DNHANDLE(hFile));

			//
			// Close the file.
			//
			DNCloseHandle(hFile);
		}
	}


	//
	// Drop the globals lock.
	//
	DNLeaveCriticalSection(&g_csGlobalsLock);

} // CNATHelpUPnP::PrintUPnPTransactionToFile






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DebugPrintCurrentStatus"
//=============================================================================
// CNATHelpUPnP::DebugPrintCurrentStatus
//-----------------------------------------------------------------------------
//
// Description:    Prints all the devices and mappings to the debug log
//				routines.
//
//				   The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::DebugPrintCurrentStatus(void)
{
	CBilink *			pBilinkDevice;
	CBilink *			pBilinkRegisteredPort;
	CDevice *			pDevice;
	CRegisteredPort *	pRegisteredPort;
	IN_ADDR				inaddrTemp;
	DWORD				dwTemp;
	SOCKADDR_IN *		pasaddrinTemp;
	SOCKADDR_IN *		pasaddrinPrivate;
	CUPnPDevice *		pUPnPDevice;
	SOCKADDR_IN *		pasaddrinUPnPPublic;


	DPFX(DPFPREP, 3, "Object flags = 0x%08x", this->m_dwFlags);

	pBilinkDevice = this->m_blDevices.GetNext();
	while (pBilinkDevice != &this->m_blDevices)
	{
		DNASSERT(! pBilinkDevice->IsEmpty());
		pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
			
		inaddrTemp.S_un.S_addr = pDevice->GetLocalAddressV4();

		DPFX(DPFPREP, 3, "Device 0x%p (%u.%u.%u.%u):",
			pDevice,
			inaddrTemp.S_un.S_un_b.s_b1,
			inaddrTemp.S_un.S_un_b.s_b2,
			inaddrTemp.S_un.S_un_b.s_b3,
			inaddrTemp.S_un.S_un_b.s_b4);


		//
		// Print the search information.  We should have detected it by now.
		//

		if (pDevice->IsPerformingRemoteUPnPDiscovery())
		{
			if (pDevice->GotRemoteUPnPDiscoveryConnReset())
			{
				DPFX(DPFPREP, 3, "     Performed remote UPnP discovery (from port %u), but got conn reset.",
					NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
			}
			else
			{
				DPFX(DPFPREP, 3, "     Performed remote UPnP discovery (from port %u).",
					NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
			}
		}
		else
		{
			//DPFX(DPFPREP, 3, "     Didn't perform remote UPnP discovery (from port %u).",
			//	NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
		}

		if (pDevice->IsPerformingLocalUPnPDiscovery())
		{
			if (pDevice->GotLocalUPnPDiscoveryConnReset())
			{
				DPFX(DPFPREP, 3, "     Performed local UPnP discovery (from port %u), but got conn reset.",
					NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
			}
			else
			{
				DPFX(DPFPREP, 3, "     Performed local UPnP discovery (from port %u).",
					NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
			}
		}
		else
		{
			//DPFX(DPFPREP, 3, "     Didn't perform local UPnP discovery (from port %u).",
			//	NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
		}


#ifndef DPNBUILD_NOWINSOCK2
		//
		// Print the gateway information.  We may not have detected it yet,
		// that's okay.
		//
		if (pDevice->IsPrimaryDevice())
		{
			DPFX(DPFPREP, 3, "     Primary device.");
		}
		else if (pDevice->IsSecondaryDevice())
		{
			DPFX(DPFPREP, 3, "     Secondary device.");
		}
		else if (pDevice->HasNoGateway())
		{
			DPFX(DPFPREP, 3, "     Has no gateway.");
		}
		else
		{
			DPFX(DPFPREP, 3, "     No gateway information known.");
		}
#endif // ! DPNBUILD_NOWINSOCK2


#ifndef DPNBUILD_NOHNETFWAPI
		if (pDevice->IsHNetFirewalled())
		{
			DPFX(DPFPREP, 3, "     HNet firewalled.");
		}
		else
		{
			DNASSERT(! pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall());
		}

		if (pDevice->IsUPnPDiscoverySocketMappedOnHNetFirewall())
		{
			DNASSERT(pDevice->IsHNetFirewalled());
			DPFX(DPFPREP, 3, "     UPnP discovery socket (port %u) mapped on HNet firewall.",
				NTOHS(pDevice->GetUPnPDiscoverySocketPort()));
		}
#endif // ! DPNBUILD_NOHNETFWAPI


		pUPnPDevice = pDevice->GetUPnPDevice();
		if (pUPnPDevice != NULL)
		{
			pasaddrinTemp = pUPnPDevice->GetControlAddress();

			DPFX(DPFPREP, 3, "     UPnP device (0x%p, ID = %u, control = %u.%u.%u.%u:%u).",
				pUPnPDevice, pUPnPDevice->GetID(),
				pasaddrinTemp->sin_addr.S_un.S_un_b.s_b1,
				pasaddrinTemp->sin_addr.S_un.S_un_b.s_b2,
				pasaddrinTemp->sin_addr.S_un.S_un_b.s_b3,
				pasaddrinTemp->sin_addr.S_un.S_un_b.s_b4,
				NTOHS(pasaddrinTemp->sin_port));

			if (pasaddrinTemp->sin_addr.S_un.S_addr == pDevice->GetLocalAddressV4())
			{
				DPFX(DPFPREP, 3, "          Is local.");
			}


			DNASSERT(pUPnPDevice->IsReady());

			if (pUPnPDevice->IsConnected())
			{
				DPFX(DPFPREP, 3, "          Is connected.");
			}

			if (pUPnPDevice->DoesNotSupportAsymmetricMappings())
			{
				DPFX(DPFPREP, 3, "          Does not support asymmetric mappings.");
			}

			if (pUPnPDevice->DoesNotSupportLeaseDurations())
			{
				DPFX(DPFPREP, 3, "          Does not support lease durations.");
			}

			inaddrTemp.S_un.S_addr = pUPnPDevice->GetExternalIPAddressV4();
			if (pUPnPDevice->GetExternalIPAddressV4() == 0)
			{
				DPFX(DPFPREP, 3, "          Does not have a valid external IP address.");
			}
			else
			{
				DPFX(DPFPREP, 3, "          Has external IP %u.%u.%u.%u.",
					inaddrTemp.S_un.S_un_b.s_b1,
					inaddrTemp.S_un.S_un_b.s_b2,
					inaddrTemp.S_un.S_un_b.s_b3,
					inaddrTemp.S_un.S_un_b.s_b4);
			}
		}


		if (pDevice->m_blOwnedRegPorts.IsEmpty())
		{
			DPFX(DPFPREP, 3, "     No registered port mappings.");
		}
		else
		{
			DPFX(DPFPREP, 3, "     Registered port mappings:");


			pBilinkRegisteredPort = pDevice->m_blOwnedRegPorts.GetNext();
			while (pBilinkRegisteredPort != &pDevice->m_blOwnedRegPorts)
			{
				DNASSERT(! pBilinkRegisteredPort->IsEmpty());
				pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
					
				pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

				if ((pDevice->GetUPnPDevice() != NULL) &&
					(! pRegisteredPort->IsUPnPPortUnavailable()))
				{
					if (pRegisteredPort->HasUPnPPublicAddresses())
					{
						pasaddrinUPnPPublic = pRegisteredPort->GetUPnPPublicAddressesArray();
					}
					else
					{
						pasaddrinUPnPPublic = NULL;
					}
				}
				else
				{
					pasaddrinUPnPPublic = NULL;
				}


				DPFX(DPFPREP, 3, "          Registered port 0x%p:",
					pRegisteredPort);

				for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
				{
					//
					// Print private address.
					//
					DPFX(DPFPREP, 3, "               %u-\tPrivate       = %u.%u.%u.%u:%u",
						dwTemp,
						pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b1,
						pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b2,
						pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b3,
						pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b4,
						NTOHS(pasaddrinPrivate[dwTemp].sin_port));

					//
					// Print flags.
					//
					DPFX(DPFPREP, 3, "                \tFlags         = 0x%lx",
						pRegisteredPort->GetFlags());

					//
					// Print UPnP information.
					//
					if (pasaddrinUPnPPublic != NULL)
					{
						if (pRegisteredPort->HasPermanentUPnPLease())
						{
							DPFX(DPFPREP, 3, "                \tUPnP          = %u.%u.%u.%u:%u, permanently leased",
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b1,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b2,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b3,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b4,
								NTOHS(pasaddrinUPnPPublic[dwTemp].sin_port));
						}
						else
						{
							DPFX(DPFPREP, 3, "                \tUPnP          = %u.%u.%u.%u:%u, lease expires at %u",
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b1,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b2,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b3,
								pasaddrinUPnPPublic[dwTemp].sin_addr.S_un.S_un_b.s_b4,
								NTOHS(pasaddrinUPnPPublic[dwTemp].sin_port),
								pRegisteredPort->GetUPnPLeaseExpiration());
						}
					}
					else if (pRegisteredPort->IsUPnPPortUnavailable())
					{
						DPFX(DPFPREP, 3, "                \tUPnP          = port unavailable");
					}
					else if (pDevice->GetUPnPDevice() != NULL)
					{
						DPFX(DPFPREP, 3, "                \tUPnP          = not registered");
					}
					else
					{
						//
						// No UPnP gateway device.
						//
					}


#ifndef DPNBUILD_NOHNETFWAPI
					//
					// Print firewall status.
					//
					if (pRegisteredPort->IsMappedOnHNetFirewall())
					{
						DNASSERT(pDevice->IsHNetFirewalled());

						if (pRegisteredPort->IsHNetFirewallMappingBuiltIn())
						{
							DPFX(DPFPREP, 3, "                \tHNet firewall = built-in mapping");
						}
						else
						{
							DPFX(DPFPREP, 3, "                \tHNet firewall = mapped");
						}
					}
					else if (pRegisteredPort->IsHNetFirewallPortUnavailable())
					{
						DNASSERT(! pRegisteredPort->IsMappedOnHNetFirewall());

						DPFX(DPFPREP, 3, "                \tHNet firewall = port unavailable");
					}
					else
					{
						//
						// It is not mapped on the firewall.
						//
						DNASSERT(! pDevice->IsHNetFirewalled());
						DNASSERT(! pRegisteredPort->IsMappedOnHNetFirewall());
						DNASSERT(! pRegisteredPort->IsHNetFirewallMappingBuiltIn());
					}
#endif // ! DPNBUILD_NOHNETFWAPI
				}

				pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();
			}
		}


		pBilinkDevice = pBilinkDevice->GetNext();
	}



	if (this->m_blUnownedPorts.IsEmpty())
	{
		DPFX(DPFPREP, 3, "No unowned registered port mappings.");
	}
	else
	{
		DPFX(DPFPREP, 3, "Unowned registered port mappings:");


		pBilinkRegisteredPort = this->m_blUnownedPorts.GetNext();
		while (pBilinkRegisteredPort != &this->m_blUnownedPorts)
		{
			DNASSERT(! pBilinkRegisteredPort->IsEmpty());
			pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
				
			pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();

			DNASSERT(pRegisteredPort->GetOwningDevice() == NULL);
			DNASSERT(! (pRegisteredPort->HasUPnPPublicAddresses()));
#ifndef DPNBUILD_NOHNETFWAPI
			DNASSERT(! (pRegisteredPort->IsMappedOnHNetFirewall()));
#endif // ! DPNBUILD_NOHNETFWAPI


			DPFX(DPFPREP, 3, "     Registered port 0x%p:", pRegisteredPort);

			for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
			{
				//
				// Print private address.
				//
				DPFX(DPFPREP, 3, "          %u-\tPrivate = %u.%u.%u.%u:%u",
					dwTemp,
					pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b1,
					pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b2,
					pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b3,
					pasaddrinPrivate[dwTemp].sin_addr.S_un.S_un_b.s_b4,
					NTOHS(pasaddrinPrivate[dwTemp].sin_port));

				//
				// Print flags.
				//
				DPFX(DPFPREP, 3, "           \tFlags   = 0x%lx",
					pRegisteredPort->GetFlags());
			}

			pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();
		}
	}
} // CNATHelpUPnP::DebugPrintCurrentStatus





#ifndef DPNBUILD_NOHNETFWAPI


#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DebugPrintActiveFirewallMappings"
//=============================================================================
// CNATHelpUPnP::DebugPrintActiveFirewallMappings
//-----------------------------------------------------------------------------
//
// Description:    Prints all the active firewall mapping registry entries to
//				the debug log routines.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::DebugPrintActiveFirewallMappings(void)
{
	HRESULT						hr = DPNH_OK;
	CRegistry					RegObject;
	DWORD						dwIndex;
	WCHAR						wszValueName[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DWORD						dwValueNameSize;
	DPNHACTIVEFIREWALLMAPPING	dpnhafm;
	DWORD						dwValueSize;
	TCHAR						tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	DNHANDLE					hNamedObject = NULL;


	if (! RegObject.Open(HKEY_LOCAL_MACHINE,
						DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVEFIREWALLMAPPINGS,
						FALSE,
						TRUE,
						TRUE,
						DPN_KEY_ALL_ACCESS))
	{
		DPFX(DPFPREP, 1, "Couldn't open active firewall mapping key, not dumping entries (local instance = %u).",
			this->m_dwInstanceKey);
	}
	else
	{
		//
		// Walk the list of active mappings.
		//
		dwIndex = 0;
		do
		{
			dwValueNameSize = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
			if (! RegObject.EnumValues(wszValueName, &dwValueNameSize, dwIndex))
			{
				//
				// There was an error or there aren't any more keys.  We're done.
				//
				break;
			}


			//
			// Try reading that mapping's data.
			//
			dwValueSize = sizeof(dpnhafm);
			if ((! RegObject.ReadBlob(wszValueName, (LPBYTE) (&dpnhafm), &dwValueSize)) ||
				(dwValueSize != sizeof(dpnhafm)) ||
				(dpnhafm.dwVersion != ACTIVE_MAPPING_VERSION))
			{
				DPFX(DPFPREP, 1, "Couldn't read \"%ls\" mapping value (index %u) or it was invalid!  Ignoring.",
					wszValueName, dwIndex);
			}
			else
			{
				//
				// See if that DPNHUPNP instance is still around.
				//

#ifndef WINCE
				if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
				{
					wsprintf(tszObjectName, _T( "Global\\" ) INSTANCENAMEDOBJECT_FORMATSTRING, dpnhafm.dwInstanceKey);
				}
				else
#endif // ! WINCE
				{
					wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, dpnhafm.dwInstanceKey);
				}

				hNamedObject = DNOpenEvent(SYNCHRONIZE, FALSE, tszObjectName);
				if (hNamedObject != NULL)
				{
					//
					// This is still an active mapping.
					//

					DPFX(DPFPREP, 5, "%u: Firewall mapping \"%ls\" belongs to instance %u (local instance = %u), which is still active.",
						dwIndex, wszValueName, dpnhafm.dwInstanceKey,
						this->m_dwInstanceKey);

					DNCloseHandle(hNamedObject);
					hNamedObject = NULL;
				}
				else
				{
					DPFX(DPFPREP, 5, "%u: Firewall mapping \"%ls\" belongs to instance %u (local instance = %u), which no longer exists.",
						dwIndex, wszValueName, dpnhafm.dwInstanceKey,
						this->m_dwInstanceKey);
				}
			}

			//
			// Move to next item.
			//
			dwIndex++;
		}
		while (TRUE);


		//
		// Close the registry object.
		//
		RegObject.Close();


		DPFX(DPFPREP, 5, "Done reading %u registry entries (local instance = %u).",
			dwIndex, this->m_dwInstanceKey);
	}
} // CNATHelpUPnP::DebugPrintActiveFirewallMappings

#endif // ! DPNBUILD_NOHNETFWAPI






#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpUPnP::DebugPrintActiveNATMappings"
//=============================================================================
// CNATHelpUPnP::DebugPrintActiveNATMappings
//-----------------------------------------------------------------------------
//
// Description:    Prints all the active NAT mapping registry entries to the
//				debug log routines.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpUPnP::DebugPrintActiveNATMappings(void)
{
	HRESULT					hr = DPNH_OK;
	CRegistry				RegObject;
	DWORD					dwIndex;
	WCHAR					wszValueName[MAX_UPNP_MAPPING_DESCRIPTION_SIZE];
	DWORD					dwValueNameSize;
	DPNHACTIVENATMAPPING	dpnhanm;
	DWORD					dwValueSize;
	TCHAR					tszObjectName[MAX_INSTANCENAMEDOBJECT_SIZE];
	DNHANDLE				hNamedObject = NULL;


	if (! RegObject.Open(HKEY_LOCAL_MACHINE,
						DIRECTPLAYNATHELP_REGKEY L"\\" REGKEY_COMPONENTSUBKEY L"\\" REGKEY_ACTIVENATMAPPINGS,
						FALSE,
						TRUE,
						TRUE,
						DPN_KEY_ALL_ACCESS))
	{
		DPFX(DPFPREP, 1, "Couldn't open active NAT mapping key, not dumping entries (local instance = %u).",
			this->m_dwInstanceKey);
	}
	else
	{
		//
		// Walk the list of active mappings.
		//
		dwIndex = 0;
		do
		{
			dwValueNameSize = MAX_UPNP_MAPPING_DESCRIPTION_SIZE;
			if (! RegObject.EnumValues(wszValueName, &dwValueNameSize, dwIndex))
			{
				//
				// There was an error or there aren't any more keys.  We're done.
				//
				break;
			}


			//
			// Try reading that mapping's data.
			//
			dwValueSize = sizeof(dpnhanm);
			if ((! RegObject.ReadBlob(wszValueName, (LPBYTE) (&dpnhanm), &dwValueSize)) ||
				(dwValueSize != sizeof(dpnhanm)) ||
				(dpnhanm.dwVersion != ACTIVE_MAPPING_VERSION))
			{
				DPFX(DPFPREP, 1, "Couldn't read \"%ls\" mapping value (index %u) or it was invalid!  Ignoring.",
					wszValueName, dwIndex);
			}
			else
			{
				//
				// See if that DPNHUPNP instance is still around.
				//

#ifndef WINCE
				if (this->m_dwFlags & NATHELPUPNPOBJ_USEGLOBALNAMESPACEPREFIX)
				{
					wsprintf(tszObjectName, _T( "Global\\" ) INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
				}
				else
#endif // ! WINCE
				{
					wsprintf(tszObjectName, INSTANCENAMEDOBJECT_FORMATSTRING, dpnhanm.dwInstanceKey);
				}

				hNamedObject = DNOpenEvent(SYNCHRONIZE, FALSE, tszObjectName);
				if (hNamedObject != NULL)
				{
					//
					// This is still an active mapping.
					//

					DPFX(DPFPREP, 5, "%u: NAT mapping \"%ls\" belongs to instance %u UPnP device %u (local instance = %u), which is still active.",
						dwIndex, wszValueName, dpnhanm.dwInstanceKey,
						dpnhanm.dwUPnPDeviceID, this->m_dwInstanceKey);

					DNCloseHandle(hNamedObject);
					hNamedObject = NULL;
				}
				else
				{
					DPFX(DPFPREP, 5, "%u: NAT mapping \"%ls\" belongs to instance %u UPnP device %u (local instance = %u), which no longer exists.",
						dwIndex, wszValueName, dpnhanm.dwInstanceKey,
						dpnhanm.dwUPnPDeviceID, this->m_dwInstanceKey);
				}
			}

			//
			// Move to next item.
			//
			dwIndex++;
		}
		while (TRUE);


		//
		// Close the registry object.
		//
		RegObject.Close();


		DPFX(DPFPREP, 5, "Done reading %u registry entries (local instance = %u).",
			dwIndex, this->m_dwInstanceKey);
	}
} // CNATHelpUPnP::DebugPrintActiveNATMappings

#endif // DBG





#undef DPF_MODNAME
#define DPF_MODNAME "strtrim"
//=============================================================================
// strtrim
//-----------------------------------------------------------------------------
//
// Description: Removes surrounding white space from the given string.  Taken
//				from \nt\net\upnp\ssdp\common\ssdpparser\parser.cpp (author
//				TingCai).
//
// Arguments:
//	CHAR ** pszStr	- Pointer to input string, and place to store resulting
//						pointer.
//
// Returns: None.
//=============================================================================
VOID strtrim(CHAR ** pszStr)
{

    CHAR *end;
    CHAR *begin;

    // Empty string. Nothing to do.
    //
    if (!(**pszStr))
    {
        return;
    }

    begin = *pszStr;
    end = begin + strlen(*pszStr) - 1;

    while (*begin == ' ' || *begin == '\t')
    {
        begin++;
    }

    *pszStr = begin;

    while (*end == ' ' || *end == '\t')
    {
        end--;
    }

    *(end+1) = '\0';
} // strtrim




#ifdef WINCE


#undef DPF_MODNAME
#define DPF_MODNAME "GetExeName"
//=============================================================================
// GetExeName
//-----------------------------------------------------------------------------
//
// Description: Updates a path string to hold only the executable name
//				contained in the path.
//
// Arguments:
//	WCHAR * wszPath		- Input path string, and place to store resulting
//							string.
//
// Returns: None.
//=============================================================================
void GetExeName(WCHAR * wszPath)
{
	WCHAR *	pCurrent;


	pCurrent = wszPath + wcslen(wszPath);
	while (pCurrent > wszPath)
	{
		if ((*pCurrent) == L'\\')
		{
			break;
		}

		pCurrent--;
	}

	if (pCurrent != wszPath)
	{
		memcpy(wszPath, (pCurrent + 1), ((wcslen(pCurrent) + 1) * sizeof(WCHAR)));
	}
} // GetExeName


#endif // WINCE