able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/dplay/dpnathlp/dpnhpast/dpnhpastintfobj.cpp

12628 lines
329 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/***************************************************************************
*
* Copyright (C) 2001-2002 Microsoft Corporation. All Rights Reserved.
*
* File: dpnhpastintfobj.cpp
*
* Content: DPNHPAST main interface object class.
*
* History:
* Date By Reason
* ======== ======== =========
* 04/16/01 VanceO Split DPNATHLP into DPNHUPNP and DPNHPAST.
*
***************************************************************************/
#include "dpnhpasti.h"
//=============================================================================
// Definitions
//=============================================================================
#define DEFAULT_INITIAL_PAST_RETRY_TIMEOUT 25000 // start retry timer at 25 ms
#define PAST_CONNECT_RETRY_INTERVAL_MS 250 // 250 ms
#define PAST_CONNECT_RETRY_INTERVAL_US (PAST_CONNECT_RETRY_INTERVAL_MS * 1000)
#define MAX_NUM_PAST_TRIES_CONNECT 2 // how many times to send a registration request message, in case of packet loss
#define MAX_PAST_RETRY_TIME_US 250000 // max retry interval is 250 ms
#define MAX_NUM_PAST_TRIES 5
#define PAST_RESPONSE_BUFFER_SIZE 150
#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_RESERVED_PORT 1024
#define MAX_NUM_RANDOM_PORT_TRIES 5
#ifndef DPNBUILD_NOWINSOCK2
//=============================================================================
// WinSock 1 version of IP options
//=============================================================================
#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
//=============================================================================
// Local static variables
//=============================================================================
static timeval s_tv0 = {0, 0};
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::CNATHelpPAST"
//=============================================================================
// CNATHelpPAST constructor
//-----------------------------------------------------------------------------
//
// Description: Initializes the new CNATHelpPAST object.
//
// Arguments:
// BOOL fNotCreatedWithCOM - TRUE if this object is being instantiated
// without COM, FALSE if it is through COM.
//
// Returns: None (the object).
//=============================================================================
CNATHelpPAST::CNATHelpPAST(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 = NATHELPPASTOBJ_NOTCREATEDWITHCOM;
}
else
{
this->m_dwFlags = 0;
}
this->m_dwLockThreadID = 0;
this->m_hAlertEvent = NULL;
this->m_hAlertIOCompletionPort = NULL;
this->m_dwAlertCompletionKey = 0;
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_hIpHlpApiDLL = NULL;
this->m_pfnGetAdaptersInfo = NULL;
this->m_pfnGetIpForwardTable = NULL;
this->m_pfnGetBestRoute = NULL;
this->m_sIoctls = INVALID_SOCKET;
this->m_wIoctlSocketPort = 0;
this->m_polAddressListChange = NULL;
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;
#ifdef DBG
this->m_dwNumDeviceAdds = 0;
this->m_dwNumDeviceRemoves = 0;
this->m_dwNumServerFailures = 0;
#endif // DBG
} // CNATHelpPAST::CNATHelpPAST
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::~CNATHelpPAST"
//=============================================================================
// CNATHelpPAST destructor
//-----------------------------------------------------------------------------
//
// Description: Frees the CNATHelpPAST object.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
CNATHelpPAST::~CNATHelpPAST(void)
{
DPFX(DPFPREP, 7, "(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 & ~NATHELPPASTOBJ_NOTCREATEDWITHCOM) == 0);
DNASSERT(this->m_dwLockThreadID == 0);
DNASSERT(this->m_hAlertEvent == NULL);
DNASSERT(this->m_hAlertIOCompletionPort == NULL);
DNASSERT(this->m_blDevices.IsEmpty());
DNASSERT(this->m_blRegisteredPorts.IsEmpty());
DNASSERT(this->m_blUnownedPorts.IsEmpty());
DNASSERT(this->m_dwNumLeases == 0);
DNASSERT(this->m_hIpHlpApiDLL == NULL);
DNASSERT(this->m_hWinSockDLL == NULL);
DNASSERT(this->m_sIoctls == INVALID_SOCKET);
DNASSERT(this->m_polAddressListChange == NULL);
//
// For grins, change the signature before deleting the object.
//
this->m_Sig[3] = 'h';
} // CNATHelpPAST::~CNATHelpPAST
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::QueryInterface"
//=============================================================================
// CNATHelpPAST::QueryInterface
//-----------------------------------------------------------------------------
//
// Description: Retrieves a new reference for an interfaces supported by this
// CNATHelpPAST 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 CNATHelpPAST::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 CNATHelpPAST 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;
} // CNATHelpPAST::QueryInterface
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::AddRef"
//=============================================================================
// CNATHelpPAST::AddRef
//-----------------------------------------------------------------------------
//
// Description: Adds a reference to this CNATHelpPAST object.
//
// Arguments: None.
//
// Returns: New refcount.
//=============================================================================
STDMETHODIMP_(ULONG) CNATHelpPAST::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;
} // CNATHelpPAST::AddRef
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::Release"
//=============================================================================
// CNATHelpPAST::Release
//-----------------------------------------------------------------------------
//
// Description: Removes a reference to this CNATHelpPAST 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) CNATHelpPAST::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 & NATHELPPASTOBJ_INITIALIZED)
{
//
// Assert so that the user can fix his/her broken code!
//
DNASSERT(! "DirectPlayNATHelpPAST 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;
} // CNATHelpPAST::Release
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::Initialize"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::Initialize(const DWORD dwFlags)
{
HRESULT hr;
BOOL fHaveLock = FALSE;
BOOL fSetFlags = FALSE;
BOOL fWinSockStarted = FALSE;
WSADATA wsadata;
int iError;
SOCKADDR_IN saddrinTemp;
int iAddressSize;
#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;
//
// 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 & ~NATHELPPASTOBJ_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 |= NATHELPPASTOBJ_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 |= NATHELPPASTOBJ_USEPASTICS;
}
if (dwFlags & DPNHINITIALIZE_DISABLELOCALFIREWALLSUPPORT)
{
DPFX(DPFPREP, 1, "User requested that local PAST PFW not be supported.");
}
else
{
this->m_dwFlags |= NATHELPPASTOBJ_USEPASTPFW;
}
//
// Take into account the registry override settings.
//
switch (g_dwPASTICSMode)
{
case OVERRIDEMODE_FORCEON:
{
//
// Force PAST ICS on.
//
DPFX(DPFPREP, 1, "Forcing PAST ICS support on.");
this->m_dwFlags |= NATHELPPASTOBJ_USEPASTICS;
break;
}
case OVERRIDEMODE_FORCEOFF:
{
//
// Force PAST ICS off.
//
DPFX(DPFPREP, 1, "Forcing PAST ICS support off.");
this->m_dwFlags &= ~NATHELPPASTOBJ_USEPASTICS;
break;
}
default:
{
//
// Leave PAST ICS settings alone.
//
break;
}
}
switch (g_dwPASTPFWMode)
{
case OVERRIDEMODE_FORCEON:
{
//
// Force PAST PFW on.
//
DPFX(DPFPREP, 1, "Forcing PAST PFW support on.");
this->m_dwFlags |= NATHELPPASTOBJ_USEPASTPFW;
break;
}
case OVERRIDEMODE_FORCEOFF:
{
//
// Force PAST PFW off.
//
DPFX(DPFPREP, 1, "Forcing PAST PFW support off.");
this->m_dwFlags &= ~NATHELPPASTOBJ_USEPASTPFW;
break;
}
default:
{
//
// Leave PAST PFW settings alone.
//
break;
}
}
//
// 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,
"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,
"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,
"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;
}
}
//
// Load WinSock, we always need it.
//
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 |= NATHELPPASTOBJ_WINSOCK1;
}
else
{
DPFX(DPFPREP, 1, "Loaded \"ws2_32.dll\", using WinSock 2 functionality.");
}
//
// 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 using the event or I/O completion port handles for notification.
//
ZeroMemory(&wsadata, sizeof(wsadata));
if (this->m_dwFlags & NATHELPPASTOBJ_WINSOCK1)
{
iError = this->m_pfnWSAStartup(MAKEWORD(1, 1), &wsadata);
}
else
{
iError = this->m_pfnWSAStartup(MAKEWORD(2, 2), &wsadata);
}
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));
//
// 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;
}
//
// Get the address + port tuple actually bound.
//
iAddressSize = sizeof(saddrinTemp);
if (this->m_pfngetsockname(this->m_sIoctls,
(SOCKADDR*) (&saddrinTemp),
&iAddressSize) != 0)
{
#ifdef DBG
dwError = this->m_pfnWSAGetLastError();
DPFX(DPFPREP, 0, "Couldn't get socket name, error = %u!", dwError);
#endif // DBG
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// WinSock needs to have bound to all adapters (because we told it to).
//
DNASSERT(saddrinTemp.sin_addr.S_un.S_addr == INADDR_ANY);
this->m_wIoctlSocketPort = saddrinTemp.sin_port;
DPFX(DPFPREP, 8, "Bound Ioctl socket to port %u.",
NTOHS(this->m_wIoctlSocketPort));
//
// 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 PAST servers 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:
this->RemoveAllItems();
if (this->m_sIoctls != INVALID_SOCKET)
{
this->m_pfnclosesocket(this->m_sIoctls); // ignore error
this->m_sIoctls = INVALID_SOCKET;
}
if (fWinSockStarted)
{
this->m_pfnWSACleanup(); // ignore error
}
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_dwFlags &= ~NATHELPPASTOBJ_WINSOCK1;
FreeLibrary(this->m_hWinSockDLL);
this->m_hWinSockDLL = 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;
}
if (fSetFlags)
{
this->m_dwFlags &= ~(NATHELPPASTOBJ_INITIALIZED |
NATHELPPASTOBJ_USEPASTICS |
NATHELPPASTOBJ_USEPASTPFW |
NATHELPPASTOBJ_DEVICECHANGED);
}
goto Exit;
} // CNATHelpPAST::Initialize
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::Close"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::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 & NATHELPPASTOBJ_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 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)!.",
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)!",
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;
}
//
// 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;
this->m_pfnWSASocketA = NULL;
this->m_pfnWSAIoctl = NULL;
this->m_pfnWSAGetOverlappedResult = NULL;
FreeLibrary(this->m_hWinSockDLL);
this->m_hWinSockDLL = 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;
}
//
// Turn off flags which should reset it back to 0 or just the
// NOTCREATEDWITHCOM flag.
//
this->m_dwFlags &= ~(NATHELPPASTOBJ_INITIALIZED |
NATHELPPASTOBJ_USEPASTICS |
NATHELPPASTOBJ_USEPASTPFW |
NATHELPPASTOBJ_WINSOCK1 |
NATHELPPASTOBJ_DEVICECHANGED |
NATHELPPASTOBJ_ADDRESSESCHANGED |
NATHELPPASTOBJ_PORTREGISTERED);
DNASSERT((this->m_dwFlags & ~NATHELPPASTOBJ_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;
} // CNATHelpPAST::Close
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::GetCaps"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::GetCaps(DPNHCAPS * const pdpnhcaps,
const DWORD dwFlags)
{
HRESULT hr;
BOOL fHaveLock = FALSE;
DWORD dwCurrentTime;
DWORD dwLeaseTimeRemaining;
CBilink * pBilink;
CRegisteredPort * pRegisteredPort;
CDevice * pDevice;
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 & NATHELPPASTOBJ_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 & NATHELPPASTOBJ_ADDRESSESCHANGED)
{
hr = DPNHSUCCESS_ADDRESSESCHANGED;
this->m_dwFlags &= ~NATHELPPASTOBJ_ADDRESSESCHANGED;
}
#ifdef DBG
//
// This flag should have been turned off by now if it ever got turned
// on.
//
DNASSERT(! (this->m_dwFlags & NATHELPPASTOBJ_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))
{
pDevice = DEVICE_FROM_BILINK(pBilink);
if (pDevice->GetPASTClientID(TRUE) != 0)
{
//
// PAST servers do not actively notify you of address changes.
//
pdpnhcaps->dwFlags |= DPNHCAPSFLAG_GATEWAYPRESENT | DPNHCAPSFLAG_NOTALLSUPPORTACTIVENOTIFY;
if (pDevice->IsPASTPublicAddressAvailable(TRUE))
{
pdpnhcaps->dwFlags |= DPNHCAPSFLAG_PUBLICADDRESSAVAILABLE;
}
}
if (pDevice->GetPASTClientID(FALSE) != 0)
{
if (pDevice->HasLocalPFWOnlyPASTServer())
{
//
// PAST servers do not actively notify you of address changes.
//
pdpnhcaps->dwFlags |= DPNHCAPSFLAG_LOCALFIREWALLPRESENT | DPNHCAPSFLAG_NOTALLSUPPORTACTIVENOTIFY;
DNASSERT(pDevice->IsPASTPublicAddressAvailable(FALSE));
}
else
{
//
// PAST servers do not actively notify you of address changes.
//
pdpnhcaps->dwFlags |= DPNHCAPSFLAG_GATEWAYPRESENT | DPNHCAPSFLAG_GATEWAYISLOCAL | DPNHCAPSFLAG_NOTALLSUPPORTACTIVENOTIFY;
if (pDevice->IsPASTPublicAddressAvailable(FALSE))
{
pdpnhcaps->dwFlags |= DPNHCAPSFLAG_PUBLICADDRESSAVAILABLE;
}
}
}
pBilink = pBilink->GetNext();
}
//
// Loop through all registered ports, counting them.
// We have the appropriate lock.
//
pBilink = this->m_blRegisteredPorts.GetNext();
dwCurrentTime = timeGetTime();
while (pBilink != (&this->m_blRegisteredPorts))
{
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 PAST servers and also calculate
// the minimum lease time remaining.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
dwLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(FALSE) - dwCurrentTime;
if (dwLeaseTimeRemaining < pdpnhcaps->dwMinLeaseTimeRemaining)
{
//
// Temporarily store how much time remains.
//
pdpnhcaps->dwMinLeaseTimeRemaining = dwLeaseTimeRemaining;
}
}
if (pDevice->GetPASTClientID(TRUE) != 0)
{
dwLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(TRUE) - 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 & NATHELPPASTOBJ_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;
} // CNATHelpPAST::GetCaps
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RegisterPorts"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::RegisterPorts(const SOCKADDR * const aLocalAddresses,
const DWORD dwAddressesSize,
const DWORD dwNumAddresses,
const DWORD dwLeaseTime,
DPNHHANDLE * const phRegisteredPorts,
const DWORD dwFlags)
{
HRESULT hr;
HRESULT temphr;
ULONG ulFirstAddress;
DWORD dwTemp;
DWORD dwMatch;
BOOL fHaveLock = FALSE;
BOOL fGotLocalPASTMapping = FALSE;
BOOL fGotRemotePASTMapping = FALSE;
CRegisteredPort * pRegisteredPort = NULL;
CDevice * pDevice = NULL;
CBilink * pBilink;
SOCKADDR_IN * psaddrinTemp;
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 & NATHELPPASTOBJ_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)
{
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))
{
psaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
for(dwTemp = 0; dwTemp < dwNumAddresses; dwTemp++)
{
//
// If the addresses don't match, stop looping.
//
if ((psaddrinTemp[dwTemp].sin_port != ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_port) ||
(psaddrinTemp[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)
{
pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);
psaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
for(dwMatch = 0; dwMatch < pRegisteredPort->GetNumAddresses(); dwMatch++)
{
//
// If the addresses match, then we can't map these ports.
//
if ((psaddrinTemp[dwMatch].sin_port == ((SOCKADDR_IN*) (&aLocalAddresses[dwTemp]))->sin_port) &&
(psaddrinTemp[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,
psaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b1,
psaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b2,
psaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b3,
psaddrinTemp[dwMatch].sin_addr.S_un.S_un_b.s_b4,
NTOHS(psaddrinTemp[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);
//
// If we have a client ID, that means the server is available. So if
// there's either a local or remote PAST server, we can request the
// mapping right now.
// Start with the local PAST server.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
hr = this->AssignOrListenPASTPort(pRegisteredPort, FALSE);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_PORTUNAVAILABLE)
{
DPFX(DPFPREP, 0, "Couldn't assign port mapping with local PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the
// server.
//
this->ClearDevicesPASTServer(pDevice, FALSE);
}
else
{
DPFX(DPFPREP, 1, "Local PAST server indicated that the port was unavailable.");
pRegisteredPort->NotePASTPortUnavailable(FALSE);
}
hr = DPNH_OK;
}
else
{
fGotLocalPASTMapping = TRUE;
}
}
else
{
//
// No local PAST server.
//
}
//
// Check remote PAST server, too.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
hr = this->AssignOrListenPASTPort(pRegisteredPort, TRUE);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_PORTUNAVAILABLE)
{
DPFX(DPFPREP, 0, "Couldn't assign port mapping with remote PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the
// server.
//
this->ClearDevicesPASTServer(pDevice, TRUE);
}
else
{
DPFX(DPFPREP, 1, "Remote PAST server indicated that the port was unavailable.");
pRegisteredPort->NotePASTPortUnavailable(TRUE);
}
hr = DPNH_OK;
}
else
{
fGotRemotePASTMapping = TRUE;
}
}
else
{
//
// No remote PAST server.
//
}
}
//
// 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 |= NATHELPPASTOBJ_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 (fGotRemotePASTMapping)
{
temphr = this->FreePASTPort(pRegisteredPort, TRUE);
if (temphr != DPNH_OK)
{
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pRegisteredPort->GetOwningDevice(), TRUE);
}
}
if (fGotLocalPASTMapping)
{
temphr = this->FreePASTPort(pRegisteredPort, FALSE);
if (temphr != DPNH_OK)
{
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pRegisteredPort->GetOwningDevice(), FALSE);
}
}
if (pRegisteredPort != NULL)
{
if (pDevice != NULL)
{
pRegisteredPort->ClearDeviceOwner();
}
pRegisteredPort->ClearPrivateAddresses();
delete pRegisteredPort;
}
if (fHaveLock)
{
this->DropLock();
fHaveLock = FALSE;
}
goto Exit;
} // CNATHelpPAST::RegisterPorts
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::GetRegisteredAddresses"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::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 & NATHELPPASTOBJ_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 = timeGetTime();
if (! (dwFlags & DPNHGETREGISTEREDADDRESSES_LOCALFIREWALLREMAPONLY))
{
//
// Check for a mapping on a remote PAST server.
//
if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
DNASSERT(pDevice != NULL);
//
// There's a bind ID, so there must be a public address array.
//
DNASSERT(pRegisteredPort->HasPASTPublicAddressesArray(TRUE));
fRegisteredWithServer = TRUE;
//
// Make sure the remote PAST server is currently giving out a valid
// public address. If so, hand it out.
//
if (pDevice->IsPASTPublicAddressAvailable(TRUE))
{
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->CopyPASTPublicAddresses((SOCKADDR_IN*) paPublicAddresses,
TRUE);
}
}
else
{
//
// Not using address buffer.
//
}
fFoundValidMapping = TRUE;
}
else
{
DPFX(DPFPREP, 8, "The remote PAST server is not currently handing out valid public address mappings.");
}
//
// Add in the flag indicating that there's a remote ICS server.
//
dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY;
//
// Get the relative remote PAST server lease time remaining.
//
dwTempLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(TRUE) - dwCurrentTime;
if (((int) dwTempLeaseTimeRemaining) < 0)
{
DPFX(DPFPREP, 1, "Registered port mapping's remote PAST server lease has already expired, returning 0 for lease time remaining.");
dwLeaseTimeRemaining = 0;
}
else
{
//
// The values are relative, so we don't have to worry about
// wraparound.
//
//if (dwTempLeaseTimeRemaining < dwLeaseTimeRemaining)
//{
dwLeaseTimeRemaining = dwTempLeaseTimeRemaining;
//}
}
}
else
{
//
// No bind ID, no public address array.
//
DNASSERT(! pRegisteredPort->HasPASTPublicAddressesArray(TRUE));
if (pRegisteredPort->IsPASTPortUnavailable(TRUE))
{
DNASSERT(pDevice != NULL);
fRegisteredWithServer = TRUE;
fPortIsUnavailable = TRUE;
DPFX(DPFPREP, 8, "The remote PAST server indicates the port(s) are unavailable.");
//
// Add in the flag indicating that there's a remote ICS server.
//
dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY;
}
#ifdef DBG
else
{
//
// No remote PAST server or it's an unowned port.
//
if (pDevice != NULL)
{
DNASSERT(pDevice->GetPASTClientID(TRUE) == 0);
}
else
{
DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts));
}
}
#endif // DBG
}
}
else
{
//
// We're not allowed to return the remote PAST mapping.
//
DPFX(DPFPREP, 8, "Ignoring any Internet gateway mappings, LOCALFIREWALLREMAPONLY was specified.");
}
//
// Finally, check for a mapping on a local PAST server.
//
if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
DNASSERT(pDevice != NULL);
//
// There's a bind ID, so there must be a public address array.
//
DNASSERT(pRegisteredPort->HasPASTPublicAddressesArray(FALSE));
fRegisteredWithServer = TRUE;
//
// If we didn't already get a remote mapping, return this local one.
//
if (! fFoundValidMapping)
{
//
// Make sure the local PAST server is currently giving out a valid
// public address. If so, hand it out.
//
if (pDevice->IsPASTPublicAddressAvailable(FALSE))
{
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->CopyPASTPublicAddresses((SOCKADDR_IN*) paPublicAddresses,
FALSE);
}
}
else
{
//
// Not using address buffer.
//
}
fFoundValidMapping = TRUE;
}
else
{
DPFX(DPFPREP, 8, "The local PAST server is not currently handing out valid public address mappings.");
}
}
else
{
DPFX(DPFPREP, 6, "Ignoring possible local PAST server mapping due to remote PAST server mapping.");
}
//
// Add in the flag indicating whether this is a PFW only or ICS server.
//
if (pDevice->HasLocalPFWOnlyPASTServer())
{
dwAddressTypeFlags |= DPNHADDRESSTYPE_LOCALFIREWALL;
}
else
{
dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY | DPNHADDRESSTYPE_GATEWAYISLOCAL;
}
//
// Get the relative time remaining.
//
dwTempLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(FALSE) - dwCurrentTime;
if (((int) dwTempLeaseTimeRemaining) < 0)
{
DPFX(DPFPREP, 1, "Registered port mapping's local PAST server lease has already expired, returning 0 for lease time remaining.");
dwLeaseTimeRemaining = 0;
}
else
{
//
// If that time remaining is less than the remote PAST server lease
// time (if any), overwrite it with the shorter time. The values
// are relative, so we don't have to worry about wraparound.
//
if (dwTempLeaseTimeRemaining < dwLeaseTimeRemaining)
{
dwLeaseTimeRemaining = dwTempLeaseTimeRemaining;
}
}
}
else
{
//
// No bind ID, no public address array.
//
DNASSERT(! pRegisteredPort->HasPASTPublicAddressesArray(FALSE));
if (pRegisteredPort->IsPASTPortUnavailable(FALSE))
{
DNASSERT(pDevice != NULL);
fRegisteredWithServer = TRUE;
fPortIsUnavailable = TRUE;
DPFX(DPFPREP, 8, "The local PAST server indicates the port(s) are unavailable.");
//
// Add in the flag indicating whether this is a PFW only or ICS server.
//
if (pDevice->HasLocalPFWOnlyPASTServer())
{
dwAddressTypeFlags |= DPNHADDRESSTYPE_LOCALFIREWALL;
}
else
{
dwAddressTypeFlags |= DPNHADDRESSTYPE_GATEWAY | DPNHADDRESSTYPE_GATEWAYISLOCAL;
}
}
#ifdef DBG
else
{
//
// No local PAST server or it's an unowned port.
//
if (pDevice != NULL)
{
DNASSERT(pDevice->GetPASTClientID(FALSE) == 0);
}
else
{
DNASSERT(pRegisteredPort->m_blDeviceList.IsListMember(&this->m_blUnownedPorts));
}
}
#endif // DBG
}
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;
} // CNATHelpPAST::GetRegisteredAddresses
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::DeregisterPorts"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::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 & NATHELPPASTOBJ_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 remote PAST server, if necessary.
//
if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
DNASSERT(pRegisteredPort->GetOwningDevice() != NULL);
//
// Free the port.
//
hr = this->FreePASTPort(pRegisteredPort, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't free port mapping with remote PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pRegisteredPort->GetOwningDevice(), TRUE);
hr = DPNH_OK;
}
}
//
// Then unmap from local PAST server, if necessary.
//
if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
DNASSERT(pRegisteredPort->GetOwningDevice() != NULL);
//
// Free the port.
//
hr = this->FreePASTPort(pRegisteredPort, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't free port mapping with local PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pRegisteredPort->GetOwningDevice(), FALSE);
hr = DPNH_OK;
}
}
//
// Pull the item out of the lists.
// We have the appropriate lock.
//
pRegisteredPort->m_blGlobalList.RemoveFromList();
if (pRegisteredPort->GetOwningDevice() != NULL)
{
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;
} // CNATHelpPAST::DeregisterPorts
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::QueryAddress"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::QueryAddress(const SOCKADDR * const pSourceAddress,
const SOCKADDR * const pQueryAddress,
SOCKADDR * const pResponseAddress,
const int iAddressesSize,
const DWORD dwFlags)
{
HRESULT hr;
HRESULT temphr;
BOOL fHaveLock = FALSE;
CDevice * pDevice;
SOCKADDR_IN * psaddrinNextServerQueryAddress = 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 & NATHELPPASTOBJ_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 appropriate owning device for given source address, returning SERVERNOTAVAILABLE.");
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 servers, then no need to check.
//
if ((pDevice->GetPASTClientID(TRUE) == 0) &&
(pDevice->GetPASTClientID(FALSE) == 0))
{
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;
}
//
// First try to query the remote PAST server, if there is one.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
hr = this->InternalPASTQueryAddress(pDevice,
psaddrinNextServerQueryAddress,
(SOCKADDR_IN*) pResponseAddress,
dwFlags,
TRUE);
switch (hr)
{
case DPNH_OK:
{
//
// If there is a local PAST server, we want to query it for the
// public address we were just returned. This technically
// would allow us to chain more than one level of Internet
// gateways, however it really won't work. I'm just doing it
// because it doesn't hurt.
//
// Handing the same buffer to InternalPASTQueryAddress for both
// the query and response addresses is okay.
//
psaddrinNextServerQueryAddress = (SOCKADDR_IN*) pResponseAddress;
break;
}
case DPNHERR_NOMAPPING:
{
//
// There's no mapping, continue to the local PAST server query.
//
break;
}
case DPNHERR_NOMAPPINGBUTPRIVATE:
{
//
// There's no mapping although the address is private, continue
// to the local PAST server query.
//
break;
}
case DPNHERR_SERVERNOTRESPONDING:
{
//
// The server stopped responding, but treat that as non-fatal.
// It will be detected properly the next time GetCaps is
// called. We set the return code to DPNHERR_NOMAPPING in case
// there is no local PAST server to override the value.
//
DPFX(DPFPREP, 1, "Remote PAST server stopped responding while querying port mapping.");
hr = DPNHERR_NOMAPPING;
//
// Continue through to querying the local server.
//
break;
}
default:
{
DPFX(DPFPREP, 0, "Querying remote PAST server for port mapping failed!");
goto Failure;
break;
}
}
}
else
{
//
// No remote PAST server.
//
}
//
// Then try to query the local PAST server, if there is one.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
temphr = this->InternalPASTQueryAddress(pDevice,
psaddrinNextServerQueryAddress,
(SOCKADDR_IN*) pResponseAddress,
dwFlags,
FALSE);
switch (temphr)
{
case DPNH_OK:
{
//
// Success!
//
hr = DPNH_OK;
break;
}
case DPNHERR_NOMAPPING:
{
//
// There's no mapping. Overwrite the return value if we didn't
// have a remote PAST server to query.
//
if (hr == DPNHERR_SERVERNOTAVAILABLE)
{
hr = DPNHERR_NOMAPPING;
}
break;
}
case DPNHERR_NOMAPPINGBUTPRIVATE:
{
//
// There's no mapping although the address is private.
// Overwrite the return value if we didn't have a remote PAST
// server to query.
//
if (hr == DPNHERR_SERVERNOTAVAILABLE)
{
hr = DPNHERR_NOMAPPINGBUTPRIVATE;
}
break;
}
case DPNHERR_SERVERNOTRESPONDING:
{
//
// The server stopped responding, but treat that as non-fatal.
// It will be detected properly the next time GetCaps is
// called.
//
DPFX(DPFPREP, 1, "Local PAST server stopped responding while querying port mapping.");
//
// Overwrite the return value if we didn't have a remote PAST
// server to query.
//
if (hr == DPNHERR_SERVERNOTAVAILABLE)
{
hr = DPNHERR_NOMAPPING;
}
break;
}
default:
{
DPFX(DPFPREP, 0, "Querying local PAST server for port mapping failed!");
goto Failure;
break;
}
}
}
else
{
//
// No local PAST server.
//
}
//
// 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:
goto Exit;
} // CNATHelpPAST::QueryAddress
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::SetAlertEvent"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::SetAlertEvent(const HANDLE hEvent,
const DWORD dwFlags)
{
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 & NATHELPPASTOBJ_INITIALIZED))
{
DPFX(DPFPREP, 0, "Object not initialized!");
hr = DPNHERR_NOTINITIALIZED;
goto Failure;
}
if (this->m_dwFlags & NATHELPPASTOBJ_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;
} // CNATHelpPAST::SetAlertEvent
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::SetAlertIOCompletionPort"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::SetAlertIOCompletionPort(const HANDLE hIOCompletionPort,
const DWORD dwCompletionKey,
const DWORD dwNumConcurrentThreads,
const DWORD dwFlags)
{
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 & NATHELPPASTOBJ_INITIALIZED))
{
DPFX(DPFPREP, 0, "Object not initialized!");
hr = DPNHERR_NOTINITIALIZED;
goto Failure;
}
if (this->m_dwFlags & NATHELPPASTOBJ_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;
} // CNATHelpPAST::SetAlertIOCompletionPort
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ExtendRegisteredPortsLease"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::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 & NATHELPPASTOBJ_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 ports are mapped on a remote PAST servers, extend that lease.
//
if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
DNASSERT(pDevice != NULL);
hr = this->ExtendPASTLease(pRegisteredPort, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on remote PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pDevice, TRUE);
hr = DPNH_OK;
}
}
else
{
DPFX(DPFPREP, 2, "Port mapping not registered with remote PAST server.");
}
//
// Next extend the mappings on the local PAST server, if possible.
//
if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
DNASSERT(pDevice != NULL);
hr = this->ExtendPASTLease(pRegisteredPort, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on local PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pDevice, FALSE);
hr = DPNH_OK;
}
}
else
{
DPFX(DPFPREP, 2, "Port mapping not registered with local PAST server.");
}
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;
} // CNATHelpPAST::ExtendRegisteredPortsLease
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::InitializeObject"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::InitializeObject(void)
{
HRESULT hr;
DPFX(DPFPREP, 5, "(0x%p) Enter", this);
DNASSERT(this->IsValidObject());
//
// Create the lock.
//
if (! DNInitializeCriticalSection(&this->m_csLock))
{
hr = E_OUTOFMEMORY;
goto Failure;
}
//
// Don't allow critical section reentry.
//
DebugSetCriticalSectionRecursionCount(&this->m_csLock, 0);
hr = S_OK;
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::InitializeObject
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::UninitializeObject"
//=============================================================================
// CNATHelpPAST::UninitializeObject
//-----------------------------------------------------------------------------
//
// Description: Cleans up the object like the destructor, mostly to balance
// InitializeObject.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpPAST::UninitializeObject(void)
{
DPFX(DPFPREP, 5, "(0x%p) Enter", this);
DNASSERT(this->IsValidObject());
DNDeleteCriticalSection(&this->m_csLock);
DPFX(DPFPREP, 5, "(0x%p) Leave", this);
} // CNATHelpPAST::UninitializeObject
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::TakeLock"
//=============================================================================
// CNATHelpPAST::TakeLock
//-----------------------------------------------------------------------------
//
// Description: Takes the main object lock.
//
// Arguments: None.
//
// Returns: DPNH_OK if lock was taken successfully, DPNHERR_REENTRANT if lock
// was re-entered.
//=============================================================================
HRESULT CNATHelpPAST::TakeLock(void)
{
HRESULT hr = DPNH_OK;
#ifdef DBG
DWORD dwStartTime;
dwStartTime = timeGetTime();
#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;
}
#ifdef DBG
DPFX(DPFPREP, 8, "Took main object lock, elapsed time = %u ms.",
(timeGetTime() - 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;
} // CNATHelpPAST::TakeLock
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::DropLock"
//=============================================================================
// CNATHelpPAST::DropLock
//-----------------------------------------------------------------------------
//
// Description: Drops the main object lock.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpPAST::DropLock(void)
{
DNASSERT(this->m_dwLockThreadID == GetCurrentThreadId());
this->m_dwLockThreadID = 0;
DNLeaveCriticalSection(&this->m_csLock);
DPFX(DPFPREP, 8, "Dropped main object lock.");
} // CNATHelpPAST::DropLock
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::LoadWinSockFunctionPointers"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::LoadWinSockFunctionPointers(void)
{
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
#ifdef DBG
#define PRINTERRORIFDEBUG(name) \
{\
dwError = GetLastError();\
DPFX(DPFPREP, 0, "Couldn't get \"%hs\" function! 0x%lx", name, dwError);\
}
#else
#define PRINTERRORIFDEBUG(name)
#endif // DBG
#define LOADWINSOCKFUNCTION(var, proctype, name) \
{\
var = (##proctype) GetProcAddress(this->m_hWinSockDLL, 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");
LOADWINSOCKFUNCTION(this->m_pfnWSAGetLastError, LPFN_WSAGETLASTERROR, "WSAGetLastError");
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");
if (! (this->m_dwFlags & NATHELPPASTOBJ_WINSOCK1))
{
LOADWINSOCKFUNCTION(this->m_pfnWSASocketA, LPFN_WSASOCKETA, "WSASocketA");
LOADWINSOCKFUNCTION(this->m_pfnWSAIoctl, LPFN_WSAIOCTL, "WSAIoctl");
LOADWINSOCKFUNCTION(this->m_pfnWSAGetOverlappedResult, LPFN_WSAGETOVERLAPPEDRESULT, "WSAGetOverlappedResult");
}
Exit:
return hr;
Failure:
hr = DPNHERR_GENERIC;
goto Exit;
} // CNATHelpPAST::LoadWinSockFunctionPointers
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::CheckForNewDevices"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::CheckForNewDevices(BOOL * const pfFoundNewDevices)
{
HRESULT hr = DPNH_OK;
DWORD dwError;
int iReturn;
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;
//int iAddressSize;
BOOL fTemp;
DWORD dwTemp;
SOCKET_ADDRESS * paSocketAddresses;
DPFX(DPFPREP, 5, "(0x%p) Enter", this);
//
// 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 & NATHELPPASTOBJ_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, 0, "Retrieving address list failed (err = %u)!", 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)
{
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)
{
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->GetFirstPASTDiscoveryTime();
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->CreatePASTSocket(&saddrinTemp);
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 PAST socket 0x%p (%u.%u.%u.%u:%u) created to replace existing one.",
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->SetFirstPASTDiscoveryTime(0);
//
// Close the existing socket.
//
this->m_pfnclosesocket(pDevice->GetPASTSocket());
//
// Transfer ownership of the new socket to the device.
//
pDevice->SetPASTSocket(sTemp);
sTemp = INVALID_SOCKET;
DPFX(DPFPREP, 8, "Device 0x%p got re-assigned PAST socket 0x%p.",
pDevice, pDevice->GetPASTSocket());
}
else
{
DPFX(DPFPREP, 0, "Couldn't create a replacement PAST socket for device 0x%p! Using existing one.",
pDevice);
}
}
}
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 |= NATHELPPASTOBJ_DEVICECHANGED;
//
// Since there was a change in the network, go back to polling
// relatively quickly.
//
this->ResetNextPollInterval();
//
// Forcefully mark the PAST servers as disconnected.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
this->ClearDevicesPASTServer(pDevice, TRUE);
}
if (pDevice->GetPASTClientID(FALSE) != 0)
{
this->ClearDevicesPASTServer(pDevice, FALSE);
}
//
// Mark all ports that were registered to this device as unowned
// by putting them into the wildcard list.
//
pBilinkRegPort = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilinkRegPort != &pDevice->m_blOwnedRegPorts)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegPort);
pBilinkRegPort = pBilinkRegPort->GetNext();
DPFX(DPFPREP, 1, "Registered port 0x%p's device went away, marking as unowned.",
pRegisteredPort);
DNASSERT(pRegisteredPort->GetPASTBindID(TRUE) == 0);
DNASSERT(pRegisteredPort->GetPASTBindID(FALSE) == 0);
DNASSERT(! pRegisteredPort->HasPASTPublicAddressesArray(TRUE));
DNASSERT(! pRegisteredPort->HasPASTPublicAddressesArray(FALSE));
DNASSERT(! pRegisteredPort->IsPASTPortUnavailable(TRUE));
DNASSERT(! pRegisteredPort->IsPASTPortUnavailable(FALSE));
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 ClearDevicesPASTServer. 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.
//
}
pDevice->m_blList.RemoveFromList();
//
// Close the sockets.
//
this->m_pfnclosesocket(pDevice->GetPASTSocket());
pDevice->SetPASTSocket(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)
{
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 |= NATHELPPASTOBJ_DEVICECHANGED;
//
// Since there was a change in the network, go back to polling
// relatively quickly.
//
this->ResetNextPollInterval();
//
// Create the PAST socket.
//
ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
saddrinTemp.sin_family = AF_INET;
saddrinTemp.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
sTemp = this->CreatePASTSocket(&saddrinTemp);
if (sTemp == INVALID_SOCKET)
{
DPFX(DPFPREP, 0, "Couldn't create PAST 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 PAST 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));
//
// Transfer ownership of the socket to the device.
//
pDevice->SetPASTSocket(sTemp);
sTemp = INVALID_SOCKET;
DPFX(DPFPREP, 8, "Device 0x%p got assigned PAST socket 0x%p.",
pDevice, pDevice->GetPASTSocket());
//
// 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;
} // CNATHelpPAST::CheckForNewDevices
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::CheckForLocalPASTServerAndRegister"
//=============================================================================
// CNATHelpPAST::CheckForLocalPASTServerAndRegister
//-----------------------------------------------------------------------------
//
// Description: Checks for a local PAST server on the given device. If one
// is found, a new client is registered.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Pointer to device to check.
//
// Returns: HRESULT
// DPNH_OK - The check was successful (may not be a server,
// though).
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::CheckForLocalPASTServerAndRegister(CDevice * const pDevice)
{
HRESULT hr = DPNH_OK;
DWORD dwError;
SOCKET sTemp = INVALID_SOCKET;
SOCKADDR_IN saddrinTemp;
BOOL fAddressAlreadyChanged;
DWORD dwOriginalNextPollInterval;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pDevice);
//
// Open a datagram socket on this device.
//
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 datagram socket, error = %u!", dwError);
#endif // DBG
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Try binding it to the PAST port first to see if there's a local PAST
// server on the device.
//
// We could just go ahead and try to register with a server, but if one
// doesn't exist, the registration code would block during the timeout. By
// simply checking if the port is in use, we can avoid that timeout. The
// only slight cost is if two PASTHelps happened to be trying this at the
// exact same time, one could be tricked by the other into thinking that
// the port was in use. In that case, it would falsely try to register...
// but then timeout. Not a big deal, that's treated as non-fatal below.
//
ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
saddrinTemp.sin_family = AF_INET;
saddrinTemp.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
saddrinTemp.sin_port = HTONS(PAST_HOST_PORT);
if (this->m_pfnbind(sTemp,
(SOCKADDR *) (&saddrinTemp),
sizeof(saddrinTemp)) != 0)
{
//
// The bind failed. We'll print the exact error, but assume it was
// because the port was in use.
//
#ifdef DBG
dwError = this->m_pfnWSAGetLastError();
DPFX(DPFPREP, 1, "Couldn't bind datagram socket %u.%u.%u.%u:%u to PAST server port, assuming because there's a local PAST server (error = %u).",
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),
dwError);
#endif // DBG
//
// Save the current poll interval in case we need to restore it.
//
dwOriginalNextPollInterval = this->m_dwNextPollInterval;
//
// We should register with this local PAST server right now.
// This might reset the poll interval.
//
hr = this->RegisterWithLocalPASTServer(pDevice);
if (hr != DPNH_OK)
{
if (hr == DPNHERR_SERVERNOTRESPONDING)
{
//
// If the server isn't responding, we'll treat it as non-fatal,
// but obviously we can't use the server.
//
DPFX(DPFPREP, 1, "Local PAST server does not respond to registrations, ignoring.");
}
else
{
//
// Some other failure. Annoying, but ignore it.
//
DPFX(DPFPREP, 0, "Couldn't register with local PAST server (err = 0x%lx)! Ignoring.",
hr);
}
hr = DPNH_OK;
//
// Drop through.
//
}
else
{
fAddressAlreadyChanged = (this->m_dwFlags & NATHELPPASTOBJ_ADDRESSESCHANGED) ? TRUE : FALSE;
//
// We need to bind a temporary port to detect ICS vs. FW-only.
// UpdatePASTPublicAddressValidity does this in addition to
// checking public address validity like the function name
// says.
//
hr = this->UpdatePASTPublicAddressValidity(pDevice, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't update new local PAST server public address validity!", hr);
goto Failure;
}
//
// If we encountered an error that caused the PAST server to be
// removed, then we shouldn't (and can't) try registering any
// existing ports.
//
// Otherwise, make sure we're allowed to work with the type of PAST
// server found. If we aren't de-register. If we are, bind any
// ports already associated with this device.
//
if ((pDevice->GetPASTClientID(FALSE) == 0) ||
((pDevice->HasLocalICSPASTServer()) && (! (this->m_dwFlags & NATHELPPASTOBJ_USEPASTICS))) ||
((pDevice->HasLocalPFWOnlyPASTServer()) && (! (this->m_dwFlags & NATHELPPASTOBJ_USEPASTPFW))))
{
if (pDevice->GetPASTClientID(FALSE) != 0)
{
DPFX(DPFPREP, 2, "Not allowed to use local %s PAST server, de-registering.",
((pDevice->HasLocalICSPASTServer()) ? _T("ICS") : _T("PFW only")));
hr = this->DeregisterWithPASTServer(pDevice, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't de-register with local PAST server (err = 0x%lx)! Ignoring.",
hr);
//
// Consider ourselves de-registered.
//
pDevice->SetPASTClientID(0, FALSE);
//
// Continue anyway...
//
hr = DPNH_OK;
}
this->ClearAllPASTServerRegisteredPorts(pDevice, FALSE);
this->RemoveAllPASTCachedMappings(pDevice, FALSE);
pDevice->NoteNoPASTPublicAddressAvailable(FALSE);
pDevice->NoteNoLocalPASTServer();
}
else
{
DPFX(DPFPREP, 1, "Local PAST server was removed while trying to update public address validity.");
}
//
// Prevent the user from thinking the addresses changed unless
// something else caused the address change notification.
//
if (! fAddressAlreadyChanged)
{
this->m_dwFlags &= ~NATHELPPASTOBJ_ADDRESSESCHANGED;
}
//
// Go back to the previous poll interval.
//
this->m_dwNextPollInterval = dwOriginalNextPollInterval;
}
else
{
if (! pDevice->m_blOwnedRegPorts.IsEmpty())
{
DPFX(DPFPREP, 2, "Local PAST server now available, registering existing ports.");
hr = this->RegisterAllPortsWithPAST(pDevice, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't register existing ports with new local PAST server!", hr);
goto Failure;
}
#ifdef DBG
//
// If we didn't encounter an error that caused the PAST
// server to be removed, then the
// NATHELPPASTOBJ_ADDRESSESCHANGED flag must have been set
// by the AssignOrListenPorts function.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_ADDRESSESCHANGED);
}
else
{
DPFX(DPFPREP, 1, "Local PAST server was removed while trying to register existing ports.");
}
#endif // DBG
}
else
{
DPFX(DPFPREP, 2, "Local PAST server now available, but no previously registered ports.");
}
}
} // end else (successfully registered with local PAST server)
}
else
{
//
// The bind succeeded. Doesn't look like there's a local PAST server.
//
DPFX(DPFPREP, 7, "Bound datagram socket %u.%u.%u.%u:%u, no local PAST server present.",
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));
}
Exit:
if (sTemp != INVALID_SOCKET)
{
this->m_pfnclosesocket(sTemp);
}
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::CheckForLocalPASTServerAndRegister
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RemoveAllItems"
//=============================================================================
// CNATHelpPAST::RemoveAllItems
//-----------------------------------------------------------------------------
//
// Description: Removes all devices (de-registering with Internet gateways
// if necessary). This removes all registered port mapping
// objects, as well.
//
// The object lock is assumed to be held.
//
// Arguments: None.
//
// Returns: None.
//=============================================================================
void CNATHelpPAST::RemoveAllItems(void)
{
HRESULT hr;
CBilink * pBilinkDevice;
CDevice * pDevice;
CBilink * pBilinkRegisteredPort;
CRegisteredPort * pRegisteredPort;
DPFX(DPFPREP, 7, "(0x%p) Enter", this);
pBilinkDevice = this->m_blDevices.GetNext();
while (pBilinkDevice != &this->m_blDevices)
{
pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
pBilinkDevice = pBilinkDevice->GetNext();
DPFX(DPFPREP, 5, "Destroying device 0x%p.",
pDevice);
pDevice->m_blList.RemoveFromList();
//
// De-register from remote PAST server if necessary.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
hr = this->DeregisterWithPASTServer(pDevice, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't de-register with remote PAST server (err = 0x%lx)! Ignoring.",
hr);
//
// Consider ourselves de-registered.
//
pDevice->SetPASTClientID(0, TRUE);
//
// Continue anyway, so we can finish cleaning up the object.
//
}
this->ClearAllPASTServerRegisteredPorts(pDevice, TRUE);
this->RemoveAllPASTCachedMappings(pDevice, TRUE);
pDevice->NoteNoPASTPublicAddressAvailable(TRUE);
}
//
// De-register from local PAST server if necessary.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
hr = this->DeregisterWithPASTServer(pDevice, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't de-register with local PAST server (err = 0x%lx)! Ignoring.",
hr);
//
// Consider ourselves de-registered.
//
pDevice->SetPASTClientID(0, FALSE);
//
// Continue anyway, so we can finish cleaning up the object.
//
}
this->ClearAllPASTServerRegisteredPorts(pDevice, FALSE);
this->RemoveAllPASTCachedMappings(pDevice, FALSE);
pDevice->NoteNoPASTPublicAddressAvailable(FALSE);
}
//
// All of the device's registered ports are implicitly freed.
//
pBilinkRegisteredPort = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilinkRegisteredPort != &pDevice->m_blOwnedRegPorts)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();
DPFX(DPFPREP, 5, "Destroying registered port 0x%p (under device 0x%p).",
pRegisteredPort, pDevice);
pRegisteredPort->ClearDeviceOwner();
pRegisteredPort->m_blGlobalList.RemoveFromList();
if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
pRegisteredPort->SetPASTBindID(0, TRUE);
pRegisteredPort->ClearPASTPublicAddresses(TRUE);
DNASSERT(this->m_dwNumLeases > 0);
this->m_dwNumLeases--;
DPFX(DPFPREP, 7, "Remote PAST lease for 0x%p cleared, total num leases = %u.",
pRegisteredPort, this->m_dwNumLeases);
}
if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
pRegisteredPort->SetPASTBindID(0, FALSE);
pRegisteredPort->ClearPASTPublicAddresses(FALSE);
DNASSERT(this->m_dwNumLeases > 0);
this->m_dwNumLeases--;
DPFX(DPFPREP, 7, "Local PAST lease for 0x%p cleared, total num leases = %u.",
pRegisteredPort, this->m_dwNumLeases);
}
pRegisteredPort->ClearPrivateAddresses();
//
// The user implicitly released this port.
//
pRegisteredPort->ClearAllUserRefs();
delete pRegisteredPort;
}
//
// Close the socket.
//
this->m_pfnclosesocket(pDevice->GetPASTSocket());
pDevice->SetPASTSocket(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)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
pBilinkRegisteredPort = pBilinkRegisteredPort->GetNext();
DPFX(DPFPREP, 5, "Destroying unowned registered port 0x%p.",
pRegisteredPort);
pRegisteredPort->m_blDeviceList.RemoveFromList();
pRegisteredPort->m_blGlobalList.RemoveFromList();
pRegisteredPort->ClearPrivateAddresses();
DNASSERT(pRegisteredPort->GetPASTBindID(TRUE) == 0);
DNASSERT(pRegisteredPort->GetPASTBindID(FALSE) == 0);
//
// The user implicitly released this port.
//
pRegisteredPort->ClearAllUserRefs();
delete pRegisteredPort;
}
DNASSERT(this->m_blRegisteredPorts.IsEmpty());
DPFX(DPFPREP, 7, "(0x%p) Leave", this);
} // CNATHelpPAST::RemoveAllItems
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::FindMatchingDevice"
//=============================================================================
// CNATHelpPAST::FindMatchingDevice
//-----------------------------------------------------------------------------
//
// Description: Searches the list of devices for the object matching the
// given address, or NULL if one could not be found.
//
// If fMatchRegPort is TRUE, the list of registered ports
// associated with devices is searched first for an exact match to
// the address passed in.
//
// The object lock is assumed to be held.
//
// Arguments:
// SOCKADDR_IN * psaddrinMatch - Pointer to address to look up.
// BOOL fMatchRegPort - Whether existing registered ports should
// be checked for an exact match first.
//
// Returns: CDevice
// NULL if no match, valid object otherwise.
//=============================================================================
CDevice * CNATHelpPAST::FindMatchingDevice(const SOCKADDR_IN * const psaddrinMatch,
const BOOL fMatchRegPort)
{
HRESULT hr;
BOOL fUpdatedDeviceList = FALSE;
CDevice * pDeviceRemoteICSServer = NULL;
CDevice * pDeviceLocalICSServer = NULL;
CDevice * pDeviceLocalPFWOnlyServer = NULL;
SOCKADDR_IN * psaddrinTemp;
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 (fMatchRegPort)
{
pBilink = this->m_blRegisteredPorts.GetNext();
while (pBilink != &this->m_blRegisteredPorts)
{
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.
//
psaddrinTemp = pRegisteredPort->GetPrivateAddressesArray();
for(dwTemp = 0; dwTemp < pRegisteredPort->GetNumAddresses(); dwTemp++)
{
//
// If the address matches, we have a winner.
//
if ((psaddrinTemp[dwTemp].sin_addr.S_un.S_addr == psaddrinMatch->sin_addr.S_un.S_addr) &&
(psaddrinTemp[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
{
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 ICS server we've
// seen.
//
if ((pDevice->GetPASTClientID(TRUE) != 0) &&
(pDeviceRemoteICSServer == NULL))
{
pDeviceRemoteICSServer = pDevice;
}
//
// Remember this device if it has the first local ICS or firewall
// only server we've seen.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
if ((pDevice->HasLocalICSPASTServer()) &&
(pDeviceLocalICSServer == NULL))
{
pDeviceLocalICSServer = pDevice;
}
else if ((pDevice->HasLocalPFWOnlyPASTServer()) &&
(pDeviceLocalPFWOnlyServer == NULL))
{
pDeviceLocalPFWOnlyServer = pDevice;
}
}
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, 7, "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 (pDeviceRemoteICSServer != NULL)
{
pDevice = pDeviceRemoteICSServer;
DPFX(DPFPREP, 1, "Picking device 0x%p with remote ICS server to match INADDR_ANY.",
pDevice);
}
else if (pDeviceLocalICSServer != NULL)
{
pDevice = pDeviceLocalICSServer;
DPFX(DPFPREP, 1, "Picking device 0x%p with local ICS server to match INADDR_ANY.",
pDevice);
}
else if (pDeviceLocalPFWOnlyServer != NULL)
{
pDevice = pDeviceLocalPFWOnlyServer;
DPFX(DPFPREP, 1, "Picking device 0x%p with local PFW-only server to match INADDR_ANY.",
pDevice);
}
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;
} // CNATHelpPAST::FindMatchingDevice
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RegisterWithLocalPASTServer"
//=============================================================================
// CNATHelpPAST::RegisterWithLocalPASTServer
//-----------------------------------------------------------------------------
//
// Description: Attempts to register with a local PAST server.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Device to use when registering.
//
// Returns: HRESULT
// DPNH_OK - The registration attempt completed
// without error.
// DPNHERR_SERVERNOTRESPONDING - No server responded to the registration
// attempt.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::RegisterWithLocalPASTServer(CDevice * const pDevice)
{
HRESULT hr;
SOCKADDR_IN saddrinServerAddress;
DWORD dwMsgID;
PAST_MSG_REGISTER RegisterReq;
PAST_RESPONSE_INFO RespInfo;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, pDevice);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
//
// Create a SOCKADDR to address the PAST service.
//
// Also initialize the message sequencing. Each message response pair is
// numbered sequentially to allow differentiation from retries over UDP.
//
// And finally, reset the current retry timeout (even though it doesn't
// affect this special case Register message).
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
DNASSERT(pDevice->GetPASTClientID(FALSE) == 0);
pDevice->ResetLocalPASTMsgIDAndRetryTimeout(DEFAULT_INITIAL_PAST_RETRY_TIMEOUT);
dwMsgID = pDevice->GetNextLocalPASTMsgID();
DNASSERT(dwMsgID == 0);
//
// Remember the current time, if this is the first thing we've sent from
// this port.
//
if (pDevice->GetFirstPASTDiscoveryTime() == 0)
{
pDevice->SetFirstPASTDiscoveryTime(GETTIMESTAMP());
}
//
// Build the request message.
//
ZeroMemory(&RegisterReq, sizeof(RegisterReq));
RegisterReq.version = PAST_VERSION;
RegisterReq.command = PAST_MSGID_REGISTER_REQUEST;
RegisterReq.msgid.code = PAST_PARAMID_MESSAGEID;
RegisterReq.msgid.len = sizeof(RegisterReq.msgid) - sizeof(PAST_PARAM);
RegisterReq.msgid.msgid = dwMsgID;
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) &RegisterReq,
sizeof(RegisterReq),
dwMsgID,
NULL,
&RespInfo);
if (hr != DPNH_OK)
{
//
// If exchanging the registration attempt failed, see if it was because
// the server wasn't responding.
//
if (hr != DPNHERR_SERVERNOTRESPONDING)
{
DPFX(DPFPREP, 0, "Registering with a PAST server failed!");
goto Failure;
}
//
// Server non-existence is considered non-fatal, but it still means
// we're done here.
//
DPFX(DPFPREP, 1, "No PAST server responded, registration was not successful.");
goto Exit;
}
if (RespInfo.cMsgType != PAST_MSGID_REGISTER_RESPONSE)
{
DPFX(DPFPREP, 0, "Unexpected response type %u, failing registration!", RespInfo.cMsgType);
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// If we got here, then we successfully registered with a server.
//
pDevice->SetPASTClientID(RespInfo.dwClientID, FALSE);
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::RegisterWithLocalPASTServer
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::DeregisterWithPASTServer"
//=============================================================================
// CNATHelpPAST::DeregisterWithPASTServer
//-----------------------------------------------------------------------------
//
// Description: Attempts to deregister with the PAST server (local or
// remote, as determined by fRemote).
//
// All port assignments are implicitly freed.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Device to use when deregistering.
// BOOL fRemote - TRUE if should attempt to deregister with remote
// server, FALSE if deregistering with local server.
//
// Returns: HRESULT
// DPNH_OK - The deregistration completed successfully.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::DeregisterWithPASTServer(CDevice * const pDevice,
const BOOL fRemote)
{
HRESULT hr = DPNH_OK;
SOCKADDR_IN saddrinServerAddress;
DWORD dwClientID;
DWORD dwMsgID;
DWORD * ptuRetry;
PAST_MSG_DEREGISTER_REQUEST DeregisterReq;
PAST_RESPONSE_INFO RespInfo;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)", this, pDevice, fRemote);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
//
// Create a SOCKADDR to address the PAST service, and get the appropriate
// client ID, initial retry timeout, and next message ID to use.
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
if (fRemote)
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
dwMsgID = pDevice->GetNextRemotePASTMsgID();
ptuRetry = pDevice->GetRemotePASTRetryTimeoutPtr();
}
else
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
dwMsgID = pDevice->GetNextLocalPASTMsgID();
ptuRetry = pDevice->GetLocalPASTRetryTimeoutPtr();
}
dwClientID = pDevice->GetPASTClientID(fRemote);
DNASSERT(dwClientID != 0);
//
// Build the request message.
//
ZeroMemory(&DeregisterReq, sizeof(DeregisterReq));
DeregisterReq.version = PAST_VERSION;
DeregisterReq.command = PAST_MSGID_DEREGISTER_REQUEST;
DeregisterReq.clientid.code = PAST_PARAMID_CLIENTID;
DeregisterReq.clientid.len = sizeof(DeregisterReq.clientid) - sizeof(PAST_PARAM);
DeregisterReq.clientid.clientid = dwClientID;
DeregisterReq.msgid.code = PAST_PARAMID_MESSAGEID;
DeregisterReq.msgid.len = sizeof(DeregisterReq.msgid) - sizeof(PAST_PARAM);
DeregisterReq.msgid.msgid = dwMsgID;
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) &DeregisterReq,
sizeof(DeregisterReq),
dwMsgID,
ptuRetry,
&RespInfo);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_SERVERNOTRESPONDING)
{
DPFX(DPFPREP, 0, "De-registering with server failed!");
goto Failure;
}
//
// Server stopped responding, but who cares, we were de-registering
// anyway.
//
DPFX(DPFPREP, 1, "Server stopped responding while de-registering! Ignoring.");
hr = DPNH_OK;
}
else
{
if (RespInfo.cMsgType != PAST_MSGID_DEREGISTER_RESPONSE)
{
DPFX(DPFPREP, 0, "Got unexpected response type %u, failed de-registering!", RespInfo.cMsgType);
hr = DPNHERR_GENERIC;
goto Failure;
}
}
pDevice->SetPASTClientID(0, fRemote);
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::DeregisterWithPASTServer
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ExtendAllExpiringLeases"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::ExtendAllExpiringLeases(void)
{
HRESULT hr = DPNH_OK;
CBilink * pBilink;
CRegisteredPort * pRegisteredPort;
CDevice * pDevice;
DWORD dwLeaseTimeRemaining;
DPFX(DPFPREP, 5, "Enter");
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_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))
{
pRegisteredPort = REGPORT_FROM_GLOBAL_BILINK(pBilink);
pDevice = pRegisteredPort->GetOwningDevice();
//
// If the port is registered remotely, extend that lease, if necessary.
//
if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
DNASSERT(pDevice != NULL);
dwLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(TRUE) - timeGetTime();
if (dwLeaseTimeRemaining < LEASE_RENEW_TIME)
{
hr = this->ExtendPASTLease(pRegisteredPort, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on remote PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pDevice, TRUE);
hr = DPNH_OK;
}
}
}
//
// If the port is registered locally, extend that lease, if necessary.
//
if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
DNASSERT(pDevice != NULL);
dwLeaseTimeRemaining = pRegisteredPort->GetPASTLeaseExpiration(FALSE) - timeGetTime();
if (dwLeaseTimeRemaining < LEASE_RENEW_TIME)
{
hr = this->ExtendPASTLease(pRegisteredPort, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't extend port mapping lease on local PAST server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pDevice, FALSE);
hr = DPNH_OK;
}
}
}
pBilink = pBilink->GetNext();
}
DNASSERT(hr == DPNH_OK);
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
} // CNATHelpPAST::ExtendAllExpiringLeases
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::UpdateServerStatus"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::UpdateServerStatus(void)
{
HRESULT hr = DPNH_OK;
CBilink blNoRemotePASTList;
DWORD dwMinUpdateServerStatusInterval;
DWORD dwCurrentTime;
CBilink * pBilink;
CDevice * pDevice;
CDevice * pDeviceRemoteICSServer = NULL;
CDevice * pDeviceLocalICSServer = NULL;
CDevice * pDeviceLocalPFWOnlyServer = NULL;
BOOL fSendRemoteGatewayDiscovery;
DPFX(DPFPREP, 5, "Enter");
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
blNoRemotePASTList.Initialize();
//
// 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 = timeGetTime();
//
// 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 & NATHELPPASTOBJ_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 & NATHELPPASTOBJ_DEVICECHANGED) ||
(this->m_dwFlags & NATHELPPASTOBJ_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 &= ~(NATHELPPASTOBJ_DEVICECHANGED | NATHELPPASTOBJ_PORTREGISTERED);
//
// Loop through all the devices.
//
pBilink = this->m_blDevices.GetNext();
while (pBilink != &this->m_blDevices)
{
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;
}
if (pDevice->GetPASTClientID(FALSE) == 0)
{
//
// The device did not previously have a local PAST server. See if
// one came online.
//
DNASSERT((pDevice->GetPASTCachedMaps(FALSE))->IsEmpty());
hr = this->CheckForLocalPASTServerAndRegister(pDevice);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't check for local PAST server (and register with it) on device 0x%p!",
pDevice);
goto Failure;
}
if (pDevice->GetPASTClientID(FALSE) != 0)
{
//
// Wow, a local PAST server is now available.
//
//
// Remember the device if it has the first local ICS or PFW
// PAST server we've seen.
//
if ((pDevice->HasLocalICSPASTServer()) &&
(pDeviceLocalICSServer == NULL))
{
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_USEPASTICS);
pDeviceLocalICSServer = pDevice;
}
else if ((pDevice->HasLocalPFWOnlyPASTServer()) &&
(pDeviceLocalPFWOnlyServer == NULL))
{
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_USEPASTPFW);
pDeviceLocalPFWOnlyServer = pDevice;
}
//
// We don't need to register all the existing mappings
// associated with the device that the user has already
// requested. CheckForLocalPASTServerAndRegister took care of
// that for us.
//
}
else
{
DPFX(DPFPREP, 7, "Still no local PAST server on device 0x%p.",
pDevice);
}
}
else
{
//
// The device previously had a local PAST server.
//
//
// Make sure the server is still alive and see whether it's handing
// out valid public addresses or not.
//
hr = this->UpdatePASTPublicAddressValidity(pDevice, FALSE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't update local PAST server public address validity on device 0x%p!",
pDevice);
goto Failure;
}
//
// If there's still a PAST server, remember the device if it's the
// first local ICS or PFW PAST server we've seen.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
if ((pDevice->HasLocalICSPASTServer()) &&
(pDeviceLocalICSServer == NULL))
{
pDeviceLocalICSServer = pDevice;
}
else if ((pDevice->HasLocalPFWOnlyPASTServer()) &&
(pDeviceLocalPFWOnlyServer == NULL))
{
pDeviceLocalPFWOnlyServer = pDevice;
}
}
}
if (this->m_dwFlags & NATHELPPASTOBJ_USEPASTICS)
{
if (pDevice->GetPASTClientID(TRUE) == 0)
{
//
// The device did not previously have a remote PAST server.
// Remember it so we can check if one came online below,
// unless we're not allowed to perform remote gateway
// discovery.
//
DNASSERT((pDevice->GetPASTCachedMaps(TRUE))->IsEmpty());
if (fSendRemoteGatewayDiscovery)
{
pDevice->m_blTempList.InsertBefore(&blNoRemotePASTList);
}
}
else
{
//
// The device previously had a remote PAST server.
//
//
// Make sure the server is still alive and see whether it's
// handing out valid public addresses or not.
//
hr = this->UpdatePASTPublicAddressValidity(pDevice, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't update remote PAST server public address validity on device 0x%p!",
pDevice);
goto Failure;
}
//
// If there's still a PAST server, remember the device if it's
// the first remote PAST server we've seen.
//
if ((pDevice->GetPASTClientID(TRUE) != 0) &&
(pDeviceRemoteICSServer == NULL))
{
pDeviceRemoteICSServer = pDevice;
}
}
}
else
{
//
// Not using PAST for ICS NAT traversal.
//
}
pBilink = pBilink->GetNext();
}
//
// Update any devices that don't currently have remote PAST servers.
//
if (! blNoRemotePASTList.IsEmpty())
{
DNASSERT(fSendRemoteGatewayDiscovery);
hr = this->RegisterMultipleDevicesWithRemotePAST(&blNoRemotePASTList,
&pDeviceRemoteICSServer);
if (hr != S_OK)
{
DPFX(DPFPREP, 0, "Couldn't register multiple devices with remote PAST servers!");
goto Failure;
}
}
//
// 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 (pDeviceRemoteICSServer != NULL)
{
pDevice = pDeviceRemoteICSServer;
}
else if (pDeviceLocalICSServer != NULL)
{
pDevice = pDeviceLocalICSServer;
}
else if (pDeviceLocalPFWOnlyServer != NULL)
{
pDevice = pDeviceLocalPFWOnlyServer;
}
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 remote or local PAST server.");
}
#endif // DBG
DPFX(DPFPREP, 7, "Spent %u ms updating server status, starting at %u.",
(timeGetTime() - dwCurrentTime), dwCurrentTime);
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
//
// Remove any items still in the temp list.
//
pBilink = blNoRemotePASTList.GetNext();
while (pBilink != &blNoRemotePASTList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
pBilink = pBilink->GetNext();
pDevice->m_blTempList.RemoveFromList();
}
goto Exit;
} // CNATHelpPAST::UpdateServerStatus
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::AssignOrListenPASTPort"
//=============================================================================
// CNATHelpPAST::AssignOrListenPASTPort
//-----------------------------------------------------------------------------
//
// Description: Attempts to assign a port mapping with the PAST server.
// This may detect a change in server address.
//
// The object lock is assumed to be held.
//
// Arguments:
// CRegisteredPort * pRegisteredPort - Pointer to port object mapping to
// assign.
// BOOL fRemote - TRUE if should assign with remote
// server, FALSE if assign with local
// server.
//
// Returns: HRESULT
// DPNH_OK - The assignment was successful.
// DPNHERR_GENERIC - An error occurred.
// DPNHERR_PORTUNAVAILABLE - The server could not bind one of the
// ports.
// DPNHERR_SERVERNOTRESPONDING - The server did not respond to the
// message.
//=============================================================================
HRESULT CNATHelpPAST::AssignOrListenPASTPort(CRegisteredPort * const pRegisteredPort,
const BOOL fRemote)
{
HRESULT hr = DPNH_OK;
CDevice * pDevice;
SOCKADDR_IN saddrinServerAddress;
DWORD dwClientID;
DWORD dwMsgID;
DWORD * ptuRetry;
BOOL fListenRequest;
BOOL fSharedUDPListener;
CHAR cNumPorts;
DWORD dwLeaseTimeInSecs;
SOCKADDR_IN * pasaddrinAddressesToAssign;
DWORD dwMsgSize;
PVOID pvRequest = NULL;
PBYTE pbCurrent;
CHAR cTemp;
PAST_RESPONSE_INFO RespInfo;
CBilink * pBilink;
CRegisteredPort * pTempRegisteredPort;
BOOL fResult;
BOOL fFirstLease;
HRESULT temphr;
#ifdef DBG
DWORD dwError;
#endif // DBG
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
this, pRegisteredPort, fRemote);
DNASSERT(pRegisteredPort != NULL);
pDevice = pRegisteredPort->GetOwningDevice();
DNASSERT(pDevice != NULL);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
//
// Create a SOCKADDR to address the PAST service, and get the appropriate
// client ID, initial retry timeout, and next message ID to use.
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
if (fRemote)
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
dwMsgID = pDevice->GetNextRemotePASTMsgID();
ptuRetry = pDevice->GetRemotePASTRetryTimeoutPtr();
}
else
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
dwMsgID = pDevice->GetNextLocalPASTMsgID();
ptuRetry = pDevice->GetLocalPASTRetryTimeoutPtr();
}
dwClientID = pDevice->GetPASTClientID(fRemote);
DNASSERT(dwClientID != 0);
fListenRequest = pRegisteredPort->IsFixedPort();
fSharedUDPListener = pRegisteredPort->IsSharedPort();
pasaddrinAddressesToAssign = pRegisteredPort->GetPrivateAddressesArray();
cNumPorts = (CHAR) pRegisteredPort->GetNumAddresses(); // the possible loss of data is okay, capped at DPNH_MAX_SIMULTANEOUS_PORTS anyway
DNASSERT(cNumPorts > 0);
dwLeaseTimeInSecs = pRegisteredPort->GetRequestedLeaseTime() / 1000;
//
// If this is a remote attempt and it was already mapped with a local
// Personal Firewall PAST server, be sure to use those addresses. The
// PFW PAST server will give different port values, and if there's a NAT
// upstream we need to map the ports that are actually reachable
// externally. Yes, you could consider it user error to have a firewall
// enabled when you're behind a NAT: why wouldn't they just enable firewall
// behavior on the NAT? However, we'll support that.
//
if ((fRemote) &&
(pDevice->HasLocalPFWOnlyPASTServer()) &&
(pDevice->IsPASTPublicAddressAvailable(FALSE)) &&
(! pRegisteredPort->IsPASTPortUnavailable(FALSE)))
{
DNASSERT(pDevice->GetPASTClientID(FALSE) != 0);
DNASSERT(pRegisteredPort->GetPASTBindID(FALSE) != 0);
DPFX(DPFPREP, 2, "Using public addresses previously returned by local Personal Firewall-only PAST server.");
pasaddrinAddressesToAssign = pRegisteredPort->GetPASTPublicAddressesArray(FALSE);
}
DNASSERT(pasaddrinAddressesToAssign != NULL);
DPFX(DPFPREP, 7, "Sending %s%sfor %u ports (first = %u.%u.%u.%u:%u), requesting %u second lease.",
((fListenRequest) ? _T("LISTEN_REQUEST") : _T("ASSIGN_REQUEST_RSAP_IP")),
((fSharedUDPListener) ? _T(" (with SHARED UDP LISTENER vendor code) ") : _T(" ")),
cNumPorts,
pasaddrinAddressesToAssign[0].sin_addr.S_un.S_un_b.s_b1,
pasaddrinAddressesToAssign[0].sin_addr.S_un.S_un_b.s_b2,
pasaddrinAddressesToAssign[0].sin_addr.S_un.S_un_b.s_b3,
pasaddrinAddressesToAssign[0].sin_addr.S_un.S_un_b.s_b4,
NTOHS(pasaddrinAddressesToAssign[0].sin_port),
dwLeaseTimeInSecs);
//
// Build the request message. We take advantage of the fact that both the
// ASSIGN_REQUEST, LISTEN_REQUEST, and SHAREDLISTEN_REQUEST messages look
// almost identical, except SHAREDLISTEN_REQUESTs have an extra vendor
// option.
//
dwMsgSize = (sizeof(PAST_MSG_ASSIGNORLISTEN_REQUEST) + ((cNumPorts - 1) * sizeof(WORD) * 2));
if (! fSharedUDPListener)
{
dwMsgSize -= sizeof(PAST_PARAM_MSVENDOR_CODE);
}
pvRequest = DNMalloc(dwMsgSize);
if (pvRequest == NULL)
{
hr = DPNHERR_OUTOFMEMORY;
goto Failure;
}
pbCurrent = (PBYTE) pvRequest;
(*pbCurrent++) = PAST_VERSION;
(*pbCurrent++) = (fListenRequest) ? PAST_MSGID_LISTEN_REQUEST : PAST_MSGID_ASSIGN_REQUEST_RSAP_IP;
((PAST_PARAM_CLIENTID*) pbCurrent)->code = PAST_PARAMID_CLIENTID;
((PAST_PARAM_CLIENTID*) pbCurrent)->len = sizeof(PAST_PARAM_CLIENTID) - sizeof(PAST_PARAM);
((PAST_PARAM_CLIENTID*) pbCurrent)->clientid = dwClientID;
pbCurrent += sizeof (PAST_PARAM_CLIENTID);
//
// Local Address (will be returned by PAST server, use don't-care value).
//
((PAST_PARAM_ADDRESS*) pbCurrent)->code = PAST_PARAMID_ADDRESS;
((PAST_PARAM_ADDRESS*) pbCurrent)->len = sizeof(PAST_PARAM_ADDRESS) - sizeof(PAST_PARAM);
((PAST_PARAM_ADDRESS*) pbCurrent)->version = PAST_ADDRESSTYPE_IPV4;
((PAST_PARAM_ADDRESS*) pbCurrent)->addr = PAST_ANY_ADDRESS;
pbCurrent += sizeof (PAST_PARAM_ADDRESS);
//
// Local Port, this is the port the user has opened for which we are
// assigning a global alias.
//
// NOTE: Ports appeared to be transferred in x86 format, contrary to the
// spec, which says network byte order.
//
(*pbCurrent++) = PAST_PARAMID_PORTS;
*((WORD*) pbCurrent) = sizeof(CHAR) + (sizeof(WORD) * cNumPorts);
pbCurrent += 2;
(*pbCurrent++) = cNumPorts;
for(cTemp = 0; cTemp < cNumPorts; cTemp++)
{
*((WORD*) pbCurrent) = NTOHS(pasaddrinAddressesToAssign[cTemp].sin_port);
pbCurrent += 2;
}
//
// Remote Address (not used with our flow control policy and reserved for
// future use, use don't-care value)
//
((PAST_PARAM_ADDRESS*) pbCurrent)->code = PAST_PARAMID_ADDRESS;
((PAST_PARAM_ADDRESS*) pbCurrent)->len = sizeof(PAST_PARAM_ADDRESS) - sizeof(PAST_PARAM);
((PAST_PARAM_ADDRESS*) pbCurrent)->version = PAST_ADDRESSTYPE_IPV4;
((PAST_PARAM_ADDRESS*) pbCurrent)->addr = PAST_ANY_ADDRESS;
pbCurrent += sizeof (PAST_PARAM_ADDRESS);
(*pbCurrent++) = PAST_PARAMID_PORTS;
*((WORD*) pbCurrent) = sizeof(CHAR) + (sizeof(WORD) * cNumPorts);
pbCurrent += 2;
(*pbCurrent++) = cNumPorts;
//for(cTemp = 0; cTemp < cNumPorts; cTemp++)
//{
// *((WORD*) pbCurrent) = NTOHS(PAST_ANY_PORT);
// pbCurrent += 2;
//}
pbCurrent += cNumPorts * sizeof(WORD);
//
// The following parameters are optional according to PAST spec.
//
//
// Lease code, ask for what the user wants, but they shouldn't count on
// getting that.
//
((PAST_PARAM_LEASE*) pbCurrent)->code = PAST_PARAMID_LEASE;
((PAST_PARAM_LEASE*) pbCurrent)->len = sizeof(PAST_PARAM_LEASE) - sizeof(PAST_PARAM);
((PAST_PARAM_LEASE*) pbCurrent)->leasetime = dwLeaseTimeInSecs;
pbCurrent += sizeof (PAST_PARAM_LEASE);
//
// Tunnel Type is IP-IP (PAST currently ignores it, actually).
//
((PAST_PARAM_TUNNELTYPE*) pbCurrent)->code = PAST_PARAMID_TUNNELTYPE;
((PAST_PARAM_TUNNELTYPE*) pbCurrent)->len = sizeof(PAST_PARAM_TUNNELTYPE) - sizeof(PAST_PARAM);
((PAST_PARAM_TUNNELTYPE*) pbCurrent)->tunneltype = PAST_TUNNEL_IP_IP;
pbCurrent += sizeof (PAST_PARAM_TUNNELTYPE);
//
// Message ID is optional, but we use it since we use UDP for a transport
// it is required.
//
((PAST_PARAM_MESSAGEID*) pbCurrent)->code = PAST_PARAMID_MESSAGEID;
((PAST_PARAM_MESSAGEID*) pbCurrent)->len = sizeof(PAST_PARAM_MESSAGEID) - sizeof(PAST_PARAM);
((PAST_PARAM_MESSAGEID*) pbCurrent)->msgid = dwMsgID;
pbCurrent += sizeof (PAST_PARAM_MESSAGEID);
//
// The following parameters are vendor specific options.
//
//
// Specify port type MS vendor option.
//
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->code = PAST_PARAMID_VENDOR;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->len = sizeof(PAST_PARAM_MSVENDOR_CODE) - sizeof(PAST_PARAM);
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->vendorid = PAST_MS_VENDOR_ID;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->option = (pRegisteredPort->IsTCP()) ? PAST_VC_MS_TCP_PORT : PAST_VC_MS_UDP_PORT;
pbCurrent += sizeof (PAST_PARAM_MSVENDOR_CODE);
//
// Specify no-tunneling MS vendor option.
//
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->code = PAST_PARAMID_VENDOR;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->len = sizeof(PAST_PARAM_MSVENDOR_CODE) - sizeof(PAST_PARAM);
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->vendorid = PAST_MS_VENDOR_ID;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->option = PAST_VC_MS_NO_TUNNEL;
pbCurrent += sizeof (PAST_PARAM_MSVENDOR_CODE);
//
// A shared UDP port listen type has an extra vendor option.
//
if (fSharedUDPListener)
{
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->code = PAST_PARAMID_VENDOR;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->len = sizeof(PAST_PARAM_MSVENDOR_CODE) - sizeof(PAST_PARAM);
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->vendorid = PAST_MS_VENDOR_ID;
((PAST_PARAM_MSVENDOR_CODE*) pbCurrent)->option = PAST_VC_MS_SHARED_UDP_LISTENER;
pbCurrent += sizeof (PAST_PARAM_MSVENDOR_CODE);
}
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) pvRequest,
dwMsgSize,
dwMsgID,
ptuRetry,
&RespInfo);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Sending Assign/Listen Port request to server failed (err = 0x%lx)!", hr);
goto Failure;
}
if ((RespInfo.cMsgType == PAST_MSGID_ERROR_RESPONSE) &&
(RespInfo.wError == PASTERR_PORTUNAVAILABLE))
{
DPFX(DPFPREP, 1, "Couldn't assign/listen, port was unavailable.");
hr = DPNHERR_PORTUNAVAILABLE;
goto Failure;
}
if (((fListenRequest) && (RespInfo.cMsgType != PAST_MSGID_LISTEN_RESPONSE)) ||
((! fListenRequest) && (RespInfo.cMsgType != PAST_MSGID_ASSIGN_RESPONSE_RSAP_IP)))
{
DPFX(DPFPREP, 0, "Got unexpected response type %u, failed assign/listen!", RespInfo.cMsgType);
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Make sure the port count is valid.
//
if (RespInfo.cNumLocalPorts != cNumPorts)
{
DPFX(DPFPREP, 0, "PAST server returned an invalid number of local ports with success message (%u != %u)! Assuming port unavailable.",
RespInfo.cNumLocalPorts, cNumPorts);
DNASSERTX(! "Why is PAST server returning bogus number of ports?", 2);
hr = DPNHERR_PORTUNAVAILABLE;
goto Failure;
}
//
// Store the public address for the registered port, even if it's the
// no-public-address address (0.0.0.0).
//
hr = pRegisteredPort->SetPASTPublicV4Addresses(RespInfo.dwLocalAddressV4,
RespInfo.awLocalPorts,
RespInfo.cNumLocalPorts,
fRemote);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't set requested mapping's public addresses!");
goto Failure;
}
//
// Remember the bind ID, actual lease time (convert back to milliseconds),
// and address we were given.
//
pRegisteredPort->SetPASTBindID(RespInfo.dwBindID, fRemote);
pRegisteredPort->SetPASTLeaseExpiration((timeGetTime() + (RespInfo.dwLeaseTime * 1000)),
fRemote);
//
// Note whether this was the first lease or not.
//
fFirstLease = (this->m_dwNumLeases == 0) ? TRUE : FALSE;
this->m_dwNumLeases++;
DPFX(DPFPREP, 7, "%s PAST lease for 0x%p added, total num leases = %u.",
((fRemote) ? _T("Remote") : _T("Local")), pRegisteredPort, this->m_dwNumLeases);
//
// We have different behavior whether the address is valid or not.
//
if (RespInfo.dwLocalAddressV4 == 0)
{
DPFX(DPFPREP, 1, "PAST server gave 0x%p an invalid address mapping for %u seconds (expires at %u).",
pRegisteredPort, RespInfo.dwLeaseTime,
pRegisteredPort->GetPASTLeaseExpiration(fRemote));
//
// If the mapping's IP address was zero, then we can't go handing it
// around.
//
// Further, if any other ports were registered with the server, their
// addresses are now all bogus as well, since it is assumed that the
// server will always hand out the same address for all assignments.
//
if (pDevice->IsPASTPublicAddressAvailable(fRemote))
{
pDevice->NoteNoPASTPublicAddressAvailable(fRemote);
//
// Since there was a change in the network, go back to polling
// relatively quickly.
//
this->ResetNextPollInterval();
//
// Any cached mappings could now be invalid. Force future
// re-queries to hit the network.
//
this->RemoveAllPASTCachedMappings(pDevice, fRemote);
//
// Loop through the existing registered port mappings and clear the
// addresses.
// We have the appropriate lock.
//
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pTempRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
if (pTempRegisteredPort != pRegisteredPort)
{
if (pTempRegisteredPort->GetPASTBindID(fRemote) != 0)
{
DPFX(DPFPREP, 3, "Existing registered port mapping 0x%p is no longer valid.",
pTempRegisteredPort);
DNASSERT(! pTempRegisteredPort->IsPASTPortUnavailable(fRemote));
DNASSERT(pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
DNASSERT(pTempRegisteredPort->IsFirstPASTPublicV4AddressDifferent(0, fRemote));
//
// Sorry, the address is gone.
//
pTempRegisteredPort->UpdatePASTPublicV4Addresses(RespInfo.dwLocalAddressV4,
fRemote);
//
// The user should call GetCaps to detect the address
// change. Note that GetRegisteredAddresses will already be
// returning NOMAPPING now, though.
//
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
}
else
{
DNASSERT(! pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
}
}
else
{
//
// Skip the port we just registered.
//
}
pBilink = pBilink->GetNext();
}
}
#ifdef DBG
else
{
DPFX(DPFPREP, 7, "Still no public address for any ports.");
//
// Loop through the existing registered port mappings and make sure
// they don't have addresses (debug only).
// We have the appropriate lock.
//
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pTempRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
if (pTempRegisteredPort->IsPASTPortUnavailable(fRemote))
{
DNASSERT(pTempRegisteredPort->GetPASTBindID(fRemote) == 0);
DNASSERT(! pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
}
else
{
//
// Can't assert these things because we may not have tried
// mapping this port yet.
//
/*
DNASSERT(pTempRegisteredPort->GetPASTBindID(fRemote) != 0);
DNASSERT(pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
DNASSERT(! (pTempRegisteredPort->IsFirstPASTPublicV4AddressDifferent(RespInfo.dwLocalAddressV4, fRemote)));
*/
}
pBilink = pBilink->GetNext();
}
}
#endif // DBG
}
else
{
DPFX(DPFPREP, 2, "PAST server gave 0x%p a valid address mapping for %u seconds (expires at %u).",
pRegisteredPort, RespInfo.dwLeaseTime,
pRegisteredPort->GetPASTLeaseExpiration(fRemote));
//
// The server may have previously been handing back invalid mappings.
// If any other ports were registered with the server that didn't get
// mapped, those addresses are now valid as well, since it is assumed
// that the server will will always hand out the same address for all
// assignments.
//
if (! pDevice->IsPASTPublicAddressAvailable(fRemote))
{
pDevice->NotePASTPublicAddressAvailable(fRemote);
//
// Since there was a change in the network, go back to polling
// relatively quickly.
//
this->ResetNextPollInterval();
//
// Any cached mappings could now be invalid. Force future
// re-queries to hit the network.
//
this->RemoveAllPASTCachedMappings(pDevice, fRemote);
//
// Loop through the existing registered port mappings and set the
// addresses.
// We have the appropriate lock.
//
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pTempRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
if (pTempRegisteredPort != pRegisteredPort)
{
if (pTempRegisteredPort->GetPASTBindID(fRemote) != 0)
{
DPFX(DPFPREP, 3, "Existing registered port mapping 0x%p now has an address.",
pTempRegisteredPort);
DNASSERT(! pTempRegisteredPort->IsPASTPortUnavailable(fRemote));
DNASSERT(pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
//
// Woohoo, there's an address now.
//
pTempRegisteredPort->UpdatePASTPublicV4Addresses(RespInfo.dwLocalAddressV4,
fRemote);
//
// The user should call GetCaps to detect the address
// change. Note that GetRegisteredAddresses will already be
// returning the new addresses now, though.
//
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
}
else
{
DNASSERT(! pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
}
}
else
{
//
// Skip the port we just registered.
//
}
pBilink = pBilink->GetNext();
}
}
else
{
//
// We assume that the server will always hand out the same address
// to every mapping. Double check that if there's something in the
// list already then it has the same IP address. If not, the
// address has changed. Loop through the existing registered port
// mappings and convert them to use the same address as was just
// handed out.
// We have the appropriate lock.
//
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pTempRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
if (pTempRegisteredPort != pRegisteredPort)
{
if (pTempRegisteredPort->GetPASTBindID(fRemote) != 0)
{
DNASSERT(! pTempRegisteredPort->IsPASTPortUnavailable(fRemote));
DNASSERT(pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
DNASSERT(pTempRegisteredPort->IsFirstPASTPublicV4AddressDifferent(0, fRemote));
if (pTempRegisteredPort->IsFirstPASTPublicV4AddressDifferent(RespInfo.dwLocalAddressV4, fRemote))
{
DPFX(DPFPREP, 3, "Existing registered port mapping 0x%p differs from address just returned from PAST server.",
pTempRegisteredPort);
pTempRegisteredPort->UpdatePASTPublicV4Addresses(RespInfo.dwLocalAddressV4, fRemote);
//
// The user should call GetCaps to detect the address
// change. Note that GetRegisteredAddresses will already be
// returning the new addresses now, though.
//
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
}
else
{
//
// Address is same.
//
}
}
else
{
DNASSERT(! pTempRegisteredPort->HasPASTPublicAddressesArray(fRemote));
}
}
else
{
//
// Skip the port we just registered.
//
}
pBilink = pBilink->GetNext();
}
}
}
//
// Remember this expiration time if it's the one that's going to expire
// soonest.
//
if ((fFirstLease) ||
((int) (pRegisteredPort->GetPASTLeaseExpiration(fRemote) - this->m_dwEarliestLeaseExpirationTime) < 0))
{
if (fFirstLease)
{
DPFX(DPFPREP, 1, "Registered port 0x%p's %s PAST lease is the first lease (expires at %u).",
pRegisteredPort,
((fRemote) ? _T("remote") : _T("local")),
pRegisteredPort->GetPASTLeaseExpiration(fRemote));
}
else
{
DPFX(DPFPREP, 1, "Registered port 0x%p's %s PAST lease expires at %u which is earlier than the next earliest lease expiration (%u).",
pRegisteredPort,
((fRemote) ? _T("remote") : _T("local")),
pRegisteredPort->GetPASTLeaseExpiration(fRemote),
this->m_dwEarliestLeaseExpirationTime);
}
this->m_dwEarliestLeaseExpirationTime = pRegisteredPort->GetPASTLeaseExpiration(fRemote);
//
// 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
}
}
Exit:
if (pvRequest != NULL)
{
DNFree(pvRequest);
pvRequest = NULL;
}
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
//
// If we registered the port, de-register it.
//
if (pRegisteredPort->GetPASTBindID(fRemote) != 0)
{
temphr = this->FreePASTPort(pRegisteredPort, fRemote);
if (temphr != DPNH_OK)
{
//
// We'll treat this as non-fatal, but we have to dump the server.
//
this->ClearDevicesPASTServer(pRegisteredPort->GetOwningDevice(), fRemote);
}
}
goto Exit;
} // CNATHelpPAST::AssignOrListenPASTPort
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::FreePASTPort"
//=============================================================================
// CNATHelpPAST::FreePASTPort
//-----------------------------------------------------------------------------
//
// Description: Release a port mapping with the PAST server.
//
// The object lock is assumed to be held.
//
// Arguments:
// CRegisteredPort * pRegisteredPort - Pointer to port object mapping to
// release.
// BOOL fRemote - TRUE if should free from remote
// server, FALSE if freeing from local
// server.
//
// Returns: HRESULT
// DPNH_OK - The release was successful.
// DPNHERR_GENERIC - An error occurred.
// DPNHERR_SERVERNOTRESPONDING - The server did not respond to the
// message.
//=============================================================================
HRESULT CNATHelpPAST::FreePASTPort(CRegisteredPort * const pRegisteredPort,
const BOOL fRemote)
{
HRESULT hr = DPNH_OK;
CDevice * pDevice;
SOCKADDR_IN saddrinServerAddress;
DWORD dwClientID;
DWORD dwMsgID;
DWORD * ptuRetry;
PAST_MSG_FREE_REQUEST FreeReq;
PAST_RESPONSE_INFO RespInfo;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
this, pRegisteredPort, fRemote);
DNASSERT(pRegisteredPort != NULL);
pDevice = pRegisteredPort->GetOwningDevice();
DNASSERT(pDevice != NULL);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
//
// Create a SOCKADDR to address the PAST service, and get the appropriate
// client ID, initial retry timeout, and next message ID to use.
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
if (fRemote)
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
dwMsgID = pDevice->GetNextRemotePASTMsgID();
ptuRetry = pDevice->GetRemotePASTRetryTimeoutPtr();
}
else
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
dwMsgID = pDevice->GetNextLocalPASTMsgID();
ptuRetry = pDevice->GetLocalPASTRetryTimeoutPtr();
}
dwClientID = pDevice->GetPASTClientID(fRemote);
DNASSERT(dwClientID != 0);
//
// Build the request message.
//
ZeroMemory(&FreeReq, sizeof(FreeReq));
FreeReq.version = PAST_VERSION;
FreeReq.command = PAST_MSGID_FREE_REQUEST;
FreeReq.clientid.code = PAST_PARAMID_CLIENTID;
FreeReq.clientid.len = sizeof(FreeReq.clientid) - sizeof(PAST_PARAM);
FreeReq.clientid.clientid = dwClientID;
FreeReq.bindid.code = PAST_PARAMID_BINDID;
FreeReq.bindid.len = sizeof(FreeReq.bindid) - sizeof(PAST_PARAM);
FreeReq.bindid.bindid = pRegisteredPort->GetPASTBindID(fRemote);
FreeReq.msgid.code = PAST_PARAMID_MESSAGEID;
FreeReq.msgid.len = sizeof(FreeReq.msgid) - sizeof(PAST_PARAM);
FreeReq.msgid.msgid = dwMsgID;
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) &FreeReq,
sizeof(FreeReq),
dwMsgID,
ptuRetry,
&RespInfo);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Freeing port mapping failed!");
goto Failure;
}
if (RespInfo.cMsgType != PAST_MSGID_FREE_RESPONSE)
{
DPFX(DPFPREP, 0, "Got unexpected response type %u, failed freeing port mapping!", RespInfo.cMsgType);
hr = DPNHERR_GENERIC;
goto Failure;
}
pRegisteredPort->SetPASTBindID(0, fRemote);
pRegisteredPort->ClearPASTPublicAddresses(fRemote);
//
// One more lease is gone.
//
DNASSERT(this->m_dwNumLeases > 0);
this->m_dwNumLeases--;
DPFX(DPFPREP, 7, "%s PAST lease for 0x%p removed, total num leases = %u.",
((fRemote) ? _T("Remote") : _T("Local")), pRegisteredPort, this->m_dwNumLeases);
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::FreePASTPort
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::InternalPASTQueryAddress"
//=============================================================================
// CNATHelpPAST::InternalPASTQueryAddress
//-----------------------------------------------------------------------------
//
// Description: Queries a port mapping with the PAST server.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Pointer to device whose PAST
// server 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.
// BOOL fRemote - TRUE if querying remote, FALSE
// querying local server.
//
// 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
// exists, but the address is private.
// DPNHERR_SERVERNOTRESPONDING - The server did not respond to the
// message.
//=============================================================================
HRESULT CNATHelpPAST::InternalPASTQueryAddress(CDevice * const pDevice,
const SOCKADDR_IN * const psaddrinQueryAddress,
SOCKADDR_IN * const psaddrinResponseAddress,
const DWORD dwFlags,
const BOOL fRemote)
{
HRESULT hr;
CBilink * pblCachedMaps;
DWORD dwCurrentTime;
CBilink * pBilink;
CCacheMap * pCacheMap;
SOCKADDR_IN saddrinServerAddress;
DWORD dwClientID;
DWORD dwMsgID;
DWORD * ptuRetry;
PAST_MSG_QUERY_REQUEST_PORTS QueryReq;
PAST_RESPONSE_INFO RespInfo;
DWORD dwCacheMapFlags;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, 0x%p, 0x%lx, %i)",
this, pDevice, psaddrinQueryAddress, psaddrinResponseAddress,
dwFlags, fRemote);
DNASSERT(pDevice != NULL);
DNASSERT(psaddrinQueryAddress != NULL);
DNASSERT(psaddrinResponseAddress != NULL);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
DPFX(DPFPREP, 7, "Querying for address %u.%u.%u.%u:%u %s.",
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) ? _T("TCP") : _T("UDP")));
//
// First, check if we've looked this address up recently and already have
// the result cached.
// The lock is already held.
//
pblCachedMaps = pDevice->GetPASTCachedMaps(fRemote);
dwCurrentTime = timeGetTime();
pBilink = pblCachedMaps->GetNext();
while (pBilink != pblCachedMaps)
{
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;
}
}
}
dwCacheMapFlags = QUERYFLAGSMASK(dwFlags);
//
// If we're here, we haven't already cached the answer.
//
// Create a SOCKADDR to address the PAST service, and get the appropriate
// client ID, initial retry timeout, and next message ID to use.
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
if (fRemote)
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
dwMsgID = pDevice->GetNextRemotePASTMsgID();
ptuRetry = pDevice->GetRemotePASTRetryTimeoutPtr();
}
else
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
dwMsgID = pDevice->GetNextLocalPASTMsgID();
ptuRetry = pDevice->GetLocalPASTRetryTimeoutPtr();
}
dwClientID = pDevice->GetPASTClientID(fRemote);
DNASSERT(dwClientID != 0);
//
// Build the request message for asking the server.
//
ZeroMemory(&QueryReq, sizeof(QueryReq));
QueryReq.version = PAST_VERSION;
QueryReq.command = PAST_MSGID_QUERY_REQUEST;
QueryReq.clientid.code = PAST_PARAMID_CLIENTID;
QueryReq.clientid.len = sizeof(QueryReq.clientid) - sizeof(PAST_PARAM);
QueryReq.clientid.clientid = dwClientID;
QueryReq.address.code = PAST_PARAMID_ADDRESS;
QueryReq.address.len = sizeof(QueryReq.address) - sizeof(PAST_PARAM);
QueryReq.address.version = PAST_ADDRESSTYPE_IPV4;
QueryReq.address.addr = psaddrinQueryAddress->sin_addr.s_addr;
//
// NOTE: Ports appeared to be transferred in x86 format, contrary to
// the spec, which says network byte order.
//
QueryReq.port.code = PAST_PARAMID_PORTS;
QueryReq.port.len = sizeof(QueryReq.port) - sizeof(PAST_PARAM);
QueryReq.port.nports = 1;
QueryReq.port.port = NTOHS(psaddrinQueryAddress->sin_port);
QueryReq.porttype.code = PAST_PARAMID_VENDOR;
QueryReq.porttype.len = sizeof(QueryReq.porttype) - sizeof(PAST_PARAM);
QueryReq.porttype.vendorid = PAST_MS_VENDOR_ID;
QueryReq.porttype.option = (dwFlags & DPNHQUERYADDRESS_TCP) ? PAST_VC_MS_TCP_PORT : PAST_VC_MS_UDP_PORT;
QueryReq.querytype.code = PAST_PARAMID_VENDOR;
QueryReq.querytype.len = sizeof(QueryReq.querytype) - sizeof(PAST_PARAM);
QueryReq.querytype.vendorid = PAST_MS_VENDOR_ID;
QueryReq.querytype.option = PAST_VC_MS_QUERY_MAPPING;
QueryReq.msgid.code = PAST_PARAMID_MESSAGEID;
QueryReq.msgid.len = sizeof(QueryReq.msgid) - sizeof(PAST_PARAM);
QueryReq.msgid.msgid = dwMsgID;
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) &QueryReq,
sizeof(QueryReq),
dwMsgID,
ptuRetry,
&RespInfo);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Querying port mapping failed!");
goto Failure;
}
if (RespInfo.cMsgType != PAST_MSGID_QUERY_RESPONSE)
{
//
// We got something, but it's not the right response. Try determining
// if the address is local, if allowed.
//
if (dwFlags & DPNHQUERYADDRESS_CHECKFORPRIVATEBUTUNMAPPED)
{
//
// If Personal Firewall is enabled, don't bother checking if the
// address is local. Anything on the other side of the firewall is
// considered non-local.
//
if ((pDevice->GetPASTClientID(FALSE) == 0) ||
(! pDevice->HasLocalPFWOnlyPASTServer()))
{
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
{
DPFX(DPFPREP, 5, "Device 0x%p has Personal Firewall enabled, not checking address locality and returning NOMAPPING.");
hr = DPNHERR_NOMAPPING;
}
}
else
{
DPFX(DPFPREP, 1, "Got non-success response type %u while querying port mapping, assuming does not exist.", RespInfo.cMsgType);
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;
}
//
// Make sure the port count is valid.
//
if (RespInfo.cNumLocalPorts != 1)
{
DPFX(DPFPREP, 0, "PAST server returned an invalid number of local ports with success message (%u)! Assuming no mapping.",
RespInfo.cNumLocalPorts);
DNASSERTX(! "Why is PAST server returning bogus number of ports?", 2);
hr = DPNHERR_NOMAPPING;
goto Failure;
}
//
// Convert the loopback address to the device address.
//
if (RespInfo.dwLocalAddressV4 == NETWORKBYTEORDER_INADDR_LOOPBACK)
{
RespInfo.dwLocalAddressV4 = pDevice->GetLocalAddressV4();
DPFX(DPFPREP, 1, "Converted loopback address to device address (%u.%u.%u.%u).",
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b1,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b2,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b3,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b4);
}
//
// Ensure that we're not getting something bogus. Use saddrinServerAddress
// as a temporary variable.
//
saddrinServerAddress.sin_addr.S_un.S_addr = RespInfo.dwLocalAddressV4;
if ((RespInfo.dwLocalAddressV4 == 0) ||
(RespInfo.awLocalPorts[0] == 0) ||
(! this->IsAddressLocal(pDevice, &saddrinServerAddress)))
{
DPFX(DPFPREP, 0, "PAST server returned an invalid private address (%u.%u.%u.%u:%u)! Assuming no mapping.",
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b1,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b2,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b3,
((IN_ADDR*) (&RespInfo.dwLocalAddressV4))->S_un.S_un_b.s_b4,
NTOHS(RespInfo.awLocalPorts[0]));
DNASSERTX(! "Why is PAST server 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.dwLocalAddressV4;
psaddrinResponseAddress->sin_port = RespInfo.awLocalPorts[0];
//
// 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(RespInfo.dwLocalAddressV4,
RespInfo.awLocalPorts[0]);
pCacheMap->m_blList.InsertBefore(pblCachedMaps);
}
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::InternalPASTQueryAddress
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ExtendPASTLease"
//=============================================================================
// CNATHelpPAST::ExtendPASTLease
//-----------------------------------------------------------------------------
//
// Description: Asks the PAST server to extend a port mapping lease.
//
// The object lock is assumed to be held.
//
// Arguments:
// CRegisteredPort * pRegisteredPort - Pointer to port object mapping to
// extend.
// BOOL fRemote - TRUE if extending on remote server,
// FALSE if extending on local server.
//
// Returns: HRESULT
// DPNH_OK - The extension was successful.
// DPNHERR_GENERIC - An error occurred.
// DPNHERR_SERVERNOTRESPONDING - The server did not respond to the
// message.
//=============================================================================
HRESULT CNATHelpPAST::ExtendPASTLease(CRegisteredPort * const pRegisteredPort,
const BOOL fRemote)
{
HRESULT hr = DPNH_OK;
CDevice * pDevice;
SOCKADDR_IN saddrinServerAddress;
DWORD dwClientID;
DWORD dwMsgID;
DWORD * ptuRetry;
PAST_MSG_EXTEND_REQUEST ExtendReq;
PAST_RESPONSE_INFO RespInfo;
BOOL fResult;
#ifdef DBG
DWORD dwError;
#endif // DBG
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
this, pRegisteredPort, fRemote);
DNASSERT(pRegisteredPort != NULL);
pDevice = pRegisteredPort->GetOwningDevice();
DNASSERT(pDevice != NULL);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
//
// Create a SOCKADDR to address the PAST service, and get the appropriate
// client ID, initial retry timeout, and next message ID to use.
//
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
if (fRemote)
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
dwMsgID = pDevice->GetNextRemotePASTMsgID();
ptuRetry = pDevice->GetRemotePASTRetryTimeoutPtr();
}
else
{
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
dwMsgID = pDevice->GetNextLocalPASTMsgID();
ptuRetry = pDevice->GetLocalPASTRetryTimeoutPtr();
}
dwClientID = pDevice->GetPASTClientID(fRemote);
DNASSERT(dwClientID != 0);
//
// Build the request message.
//
ZeroMemory(&ExtendReq, sizeof(ExtendReq));
ExtendReq.version = PAST_VERSION;
ExtendReq.command = PAST_MSGID_EXTEND_REQUEST;
ExtendReq.clientid.code = PAST_PARAMID_CLIENTID;
ExtendReq.clientid.len = sizeof(ExtendReq.clientid) - sizeof(PAST_PARAM);
ExtendReq.clientid.clientid = dwClientID;
ExtendReq.bindid.code = PAST_PARAMID_BINDID;
ExtendReq.bindid.len = sizeof(DWORD);
ExtendReq.bindid.bindid = pRegisteredPort->GetPASTBindID(fRemote);
//
// Lease code, ask for what the user wants, but they shouldn't count on
// getting that.
// Convert the request (in milliseconds) to PAST's time unit (in seconds).
//
ExtendReq.lease.code = PAST_PARAMID_LEASE;
ExtendReq.lease.len = sizeof(ExtendReq.lease) - sizeof(PAST_PARAM);
ExtendReq.lease.leasetime = pRegisteredPort->GetRequestedLeaseTime() / 1000;
ExtendReq.msgid.code = PAST_PARAMID_MESSAGEID;
ExtendReq.msgid.len = sizeof(ExtendReq.msgid) - sizeof(PAST_PARAM);
ExtendReq.msgid.msgid = dwMsgID;
//
// Send the message and get the reply.
//
hr = this->ExchangeAndParsePAST(pDevice->GetPASTSocket(),
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress),
(char *) &ExtendReq,
sizeof(ExtendReq),
dwMsgID,
ptuRetry,
&RespInfo);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Sending port lease extension request to server failed!");
goto Failure;
}
if (RespInfo.cMsgType != PAST_MSGID_EXTEND_RESPONSE)
{
DPFX(DPFPREP, 0, "Got unexpected response type %u, failed port lease extension!", RespInfo.cMsgType);
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Note the lease time extension (which is in seconds). It had better be
// longer than our auto-extension rate. We use it to extend the current
// lease expiration (which is in milliseconds).
//
DNASSERT((RespInfo.dwLeaseTime * 1000) > LEASE_RENEW_TIME);
pRegisteredPort->SetPASTLeaseExpiration((timeGetTime() + (RespInfo.dwLeaseTime * 1000)),
fRemote);
DPFX(DPFPREP, 8, "Extended lease (registered port = 0x%p) to %u seconds from now, expires at %u.",
pRegisteredPort, RespInfo.dwLeaseTime,
pRegisteredPort->GetPASTLeaseExpiration(fRemote));
//
// Remember this expiration time if it's the one that's going to expire
// soonest.
//
DNASSERT(this->m_dwNumLeases > 0);
if ((int) (pRegisteredPort->GetPASTLeaseExpiration(fRemote) - this->m_dwEarliestLeaseExpirationTime) < 0)
{
DPFX(DPFPREP, 1, "Registered port 0x%p's %s PAST lease expires at %u which is earlier than the next earliest lease expiration (%u).",
pRegisteredPort,
((fRemote) ? _T("remote") : _T("local")),
pRegisteredPort->GetPASTLeaseExpiration(fRemote),
this->m_dwEarliestLeaseExpirationTime);
this->m_dwEarliestLeaseExpirationTime = pRegisteredPort->GetPASTLeaseExpiration(fRemote);
//
// 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
}
}
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::ExtendPASTLease
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::UpdatePASTPublicAddressValidity"
//=============================================================================
// CNATHelpPAST::UpdatePASTPublicAddressValidity
//-----------------------------------------------------------------------------
//
// Description: Checks to see if the given device's PAST server is handing
// out valid public addresses or not.
//
// The PAST server information might be cleared if a failure
// occurs.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Pointer to device that should be checked.
// BOOL fRemote - Whether the local or remote PAST server should be
// checked.
//
// Returns: HRESULT
// DPNH_OK - The update was successful.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::UpdatePASTPublicAddressValidity(CDevice * const pDevice,
const BOOL fRemote)
{
HRESULT hr;
SOCKADDR_IN saddrinTemp;
CRegisteredPort * pTempRegisteredPort = NULL;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
this, pDevice, fRemote);
//
// Create a temporary port mapping object. We mark it as "local PAST port
// unavailable" when checking remove PAST servers because we have not and
// will not attempt to map the local port when there is a local PAST
// server. Since AssignOrListenPASTPort assumes the local port will have
// been mapped first, we need to prevent it from trying to use that address
// and crashing.
//
pTempRegisteredPort = new CRegisteredPort(FAKE_PORT_LEASE_TIME,
((fRemote) ? REGPORTOBJ_PORTUNAVAILABLE_PAST_LOCAL : 0));
if (pTempRegisteredPort == NULL)
{
hr = DPNHERR_OUTOFMEMORY;
goto Failure;
}
pTempRegisteredPort->MakeDeviceOwner(pDevice);
//
// Pick an arbitrary port value to map. In this case, we should just use
// the socket we're using for Ioctl communication, since that port is
// guaranteed to be unique by WinSock (so no multi-PASTHelp-instance race
// conditions like if we had used a hardcoded temporary port).
// One difference: the Ioctl socket is bound to INADDR_ANY, but we'll use
// the specific device address so our ICS vs. PFW-only address comparison
// below works correctly. This shouldn't make a difference, since a port
// in use by INADDR_ANY should be the same as the same port in use on each
// of the adapters.
//
ZeroMemory(&saddrinTemp, sizeof(saddrinTemp));
saddrinTemp.sin_family = AF_INET;
saddrinTemp.sin_addr.S_un.S_addr = pDevice->GetLocalAddressV4();
saddrinTemp.sin_port = this->m_wIoctlSocketPort;
//
// Assign it the communication socket's address.
//
hr = pTempRegisteredPort->SetPrivateAddresses(&saddrinTemp, 1);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't set temporary private addresses!");
goto Failure;
}
DPFX(DPFPREP, 7, "Temporarily assigning port %u.%u.%u.%u:%u to check server status.",
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(this->m_wIoctlSocketPort));
//
// Attempt to map it. AssignOrListenPASTPort will handle the actual logic
// of changing addresses.
//
hr = this->AssignOrListenPASTPort(pTempRegisteredPort, fRemote);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't assign temporary port mapping with server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we'll dump the server.
//
this->ClearDevicesPASTServer(pDevice, fRemote);
hr = DPNH_OK;
}
else
{
//
// If we're checking the local server, determine whether it's a local ICS
// server or it's Personal Firewall only.
//
if (! fRemote)
{
//
// If public address is the same, it's PFW only, if it's different,
// it's ICS (although that could be PFWed, too). If there's no
// public address, then we can't really tell. It should be safe to
// assume that it's ICS, since this device must have an address or
// else it wouldn't exist.
//
if ((! pDevice->IsPASTPublicAddressAvailable(FALSE)) ||
(pTempRegisteredPort->IsFirstPASTPublicV4AddressDifferent(saddrinTemp.sin_addr.S_un.S_addr, FALSE)))
{
#ifdef DBG
if (! pDevice->IsPASTPublicAddressAvailable(FALSE))
{
DPFX(DPFPREP, 2, "Device %u.%u.%u.%u (object = 0x%p) doesn't have public address, assuming ICS.",
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,
pDevice);
}
else
{
SOCKADDR_IN * pasaddrinPublic;
pasaddrinPublic = pTempRegisteredPort->GetPASTPublicAddressesArray(FALSE);
DPFX(DPFPREP, 2, "Device %u.%u.%u.%u (object = 0x%p) has different public address (%u.%u.%u.%u), appears to be ICS.",
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,
pDevice,
pasaddrinPublic[0].sin_addr.S_un.S_un_b.s_b1,
pasaddrinPublic[0].sin_addr.S_un.S_un_b.s_b2,
pasaddrinPublic[0].sin_addr.S_un.S_un_b.s_b3,
pasaddrinPublic[0].sin_addr.S_un.S_un_b.s_b4);
}
#endif // DBG
pDevice->NoteLocalPASTServerIsICS();
}
else
{
DPFX(DPFPREP, 2, "Device %u.%u.%u.%u (object = 0x%p) has same public address, appears to be firewall only.",
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,
pDevice);
pDevice->NoteLocalPASTServerIsPFWOnly();
}
}
else
{
//
// A remote PAST server.
//
}
//
// Free the temporary port, because we don't need it.
//
hr = this->FreePASTPort(pTempRegisteredPort, fRemote);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't free temporary port mapping (0x%lx)!", hr);
//
// We'll treat this as non-fatal, but we have to drop the PAST
// server.
//
this->ClearDevicesPASTServer(pDevice, fRemote);
hr = DPNH_OK;
}
}
//
// If we're here we either never mapped the temporary port, explicitly
// freed the port, or deregistered (which implies freeing the port). So
// we're done with the object.
//
pTempRegisteredPort->ClearDeviceOwner();
pTempRegisteredPort->ClearPrivateAddresses();
delete pTempRegisteredPort;
pTempRegisteredPort = NULL;
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
if (pTempRegisteredPort != NULL)
{
delete pTempRegisteredPort;
}
goto Exit;
} // CNATHelpPAST::UpdatePASTPublicAddressValidity
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RegisterAllPortsWithPAST"
//=============================================================================
// CNATHelpPAST::RegisterAllPortsWithPAST
//-----------------------------------------------------------------------------
//
// Description: Registers all ports owned by the given device with the PAST
// server.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Pointer to device whose ports should be registered.
// BOOL fRemote - TRUE if registering on remote server, FALSE if
// registering on local server.
//
// Returns: HRESULT
// DPNH_OK - The extension was successful.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::RegisterAllPortsWithPAST(CDevice * const pDevice,
const BOOL fRemote)
{
HRESULT hr = DPNH_OK;
CBilink * pBilink;
CRegisteredPort * pRegisteredPort;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i)",
this, pDevice, fRemote);
DNASSERT(pDevice != NULL);
DNASSERT(pDevice->GetPASTSocket() != INVALID_SOCKET);
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
DNASSERT(pRegisteredPort->GetPASTBindID(fRemote) == 0);
hr = this->AssignOrListenPASTPort(pRegisteredPort, fRemote);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_PORTUNAVAILABLE)
{
DPFX(DPFPREP, 0, "Couldn't assign port mapping with server (0x%lx)! Ignoring.", hr);
//
// We'll treat this as non-fatal, but we have to dump the
// server and bail out of here.
//
this->ClearDevicesPASTServer(pDevice, fRemote);
hr = DPNH_OK;
goto Exit;
}
//
// Uh oh, the server couldn't register one of the ports! We don't
// have a way of directly informing the user now. We'll have to
// mark the port and continue.
//
DPFX(DPFPREP, 1, "Server indicated that the port was unavailable.");
pRegisteredPort->NotePASTPortUnavailable(fRemote);
hr = DPNH_OK;
}
else
{
//
// Hey, this now has an address.
//
DPFX(DPFPREP, 2, "Previously registered port 0x%p now has a %s PAST server public address.",
pRegisteredPort, ((fRemote) ? _T("remote") : _T("local")));
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
}
pBilink = pBilink->GetNext();
}
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
} // CNATHelpPAST::RegisterAllPortsWithPAST
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RegisterPreviouslyUnownedPortsWithDevice"
//=============================================================================
// CNATHelpPAST::RegisterPreviouslyUnownedPortsWithDevice
//-----------------------------------------------------------------------------
//
// Description: Associates unknown ports with the given device, and
// registers them with the device's PAST server(s).
//
// 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 CNATHelpPAST::RegisterPreviouslyUnownedPortsWithDevice(CDevice * const pDevice,
const BOOL fWildcardToo)
{
HRESULT hr = DPNH_OK;
CBilink * pBilink;
CRegisteredPort * pRegisteredPort;
SOCKADDR_IN * pasaddrinPrivate;
#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)
{
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);
//
// Attempt to automatically map it with the (new) local server, if
// present.
//
if (pDevice->GetPASTClientID(FALSE) != 0)
{
hr = this->AssignOrListenPASTPort(pRegisteredPort, FALSE);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_PORTUNAVAILABLE)
{
DPFX(DPFPREP, 0, "Couldn't assign port mapping 0x%p with local server (0x%lx)! Ignoring.",
pRegisteredPort, hr);
//
// We'll treat this as non-fatal, but we have to dump the
// server.
//
this->ClearDevicesPASTServer(pDevice, FALSE);
}
else
{
//
// Uh oh, the server couldn't register one of the ports!
// We don't have a way of directly informing the user now.
// We'll have to mark the port and continue.
//
DPFX(DPFPREP, 1, "Local PAST server indicated that the port (0x%p) was unavailable.",
pRegisteredPort);
pRegisteredPort->NotePASTPortUnavailable(FALSE);
}
hr = DPNH_OK;
}
else
{
//
// Ta da, user needs to note address mapping changes.
//
DPFX(DPFPREP, 1, "Previously unowned port 0x%p now bound to device object 0x%p and mapped locally.",
pRegisteredPort, pDevice);
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
#ifdef DBG
fAssignedPort = TRUE;
#endif // DBG
}
}
//
// Attempt to automatically map it with the (new) remote PAST server,
// if present.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
hr = this->AssignOrListenPASTPort(pRegisteredPort, TRUE);
if (hr != DPNH_OK)
{
if (hr != DPNHERR_PORTUNAVAILABLE)
{
DPFX(DPFPREP, 0, "Couldn't assign port mapping 0x%p with remote PAST server (0x%lx)! Ignoring.",
pRegisteredPort, hr);
//
// We'll treat this as non-fatal, but we have to dump the
// server.
//
this->ClearDevicesPASTServer(pDevice, TRUE);
}
else
{
//
// Uh oh, the server couldn't register one of the ports!
// We don't have a way of directly informing the user now.
// We'll have to mark the port and continue.
//
DPFX(DPFPREP, 1, "Remote PAST server indicated that the port (0x%p) was unavailable.",
pRegisteredPort);
pRegisteredPort->NotePASTPortUnavailable(TRUE);
}
hr = DPNH_OK;
}
else
{
//
// Ta da, user needs to note address mapping changes.
//
DPFX(DPFPREP, 1, "Previously unowned port 0x%p now bound to device object 0x%p and mapped remotely.",
pRegisteredPort, pDevice);
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
#ifdef DBG
fAssignedPort = TRUE;
#endif // DBG
}
}
}
#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;
} // CNATHelpPAST::RegisterPreviouslyUnownedPortsWithDevice
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ExchangeAndParsePAST"
//=============================================================================
// CNATHelpPAST::ExchangeAndParsePAST
//-----------------------------------------------------------------------------
//
// Description: Sends a message to the PAST server and waits for a response,
// which is parsed into a PAST_RESPONSE_INFO buffer. The message
// will be continually retried at the current retry interval
// unless ptuRetry == NULL, which indicates that this is the
// initial message looking for a server, in which case it will be
// tried twice over a second. If there is no response,
// DPNHERR_SERVERNOTRESPONDING is returned.
//
// Since there is almost no scenario where we don't immediately
// need to know the response, there is no point in doing this
// asynchronously. The assumption is that a PAST server is
// sufficiently local that long retries are not necessary.
//
// Arguments:
// SOCKET sSocket - Socket to use when sending.
// SOCKADDR * psaddrServerAddress - Pointer to address of server.
// int iAddressesSize - Size of psaddrServerAddress and
// psaddrRecvAddress.
// char * pcRequestBuffer - Pointer to request message to send.
// int iRequestBufferSize - Size of request message.
// DWORD dwMsgID - ID of the message being sent (to
// correlate responses).
// DWORD * ptuRetry - Pointer to current retry time value
// (may be modified), or NULL if this is
// an initial registration (a different
// timer strategy is used).
// PAST_RESPONSE_INFO * pRespInfo - Pointer to structure that will be filled
// in with values from the server's
// response message.
//
// Returns: HRESULT
// DPNH_OK - The request and response were
// successfully exchanged.
// DPNHERR_GENERIC - An error occurred.
// DPNHERR_SERVERNOTRESPONDING - The server did not respond to the message.
//=============================================================================
HRESULT CNATHelpPAST::ExchangeAndParsePAST(const SOCKET sSocket,
const SOCKADDR * const psaddrServerAddress,
const int iAddressesSize,
const char * const pcRequestBuffer,
const int iRequestBufferSize,
const DWORD dwMsgID,
DWORD * const ptuRetry,
PAST_RESPONSE_INFO * const pRespInfo)
{
HRESULT hr = DPNH_OK;
char acRespBuffer[PAST_RESPONSE_BUFFER_SIZE];
timeval tv;
FD_SET fdsRead;
DWORD dwTriesRemaining;
int iReturn;
SOCKADDR_IN saddrinReceive;
int iRecvAddressSize = iAddressesSize;
DWORD dwError;
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, 0x%p, %i, 0x%p, %i, %u, 0x%p, 0x%p)",
this, sSocket, psaddrServerAddress, iAddressesSize, pcRequestBuffer,
iRequestBufferSize, dwMsgID, ptuRetry, pRespInfo);
DNASSERT(sSocket != INVALID_SOCKET);
DNASSERT(psaddrServerAddress != NULL);
DNASSERT(iAddressesSize == sizeof(SOCKADDR_IN));
DNASSERT(pcRequestBuffer != NULL);
DNASSERT(iRequestBufferSize != 0);
DNASSERT(pRespInfo != NULL);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
ZeroMemory(pRespInfo, sizeof(*pRespInfo));
#ifdef DBG
ZeroMemory(acRespBuffer, sizeof(acRespBuffer));
#endif // DBG
if (ptuRetry == NULL)
{
//
// On initial registration requests we try twice with a 250ms total
// timeout.
//
tv.tv_usec = PAST_CONNECT_RETRY_INTERVAL_US;
tv.tv_sec = 0;
dwTriesRemaining = MAX_NUM_PAST_TRIES_CONNECT;
}
else
{
//
// All normal traffic uses the current retry interval and a default
// number of tries.
//
tv.tv_usec = (*ptuRetry);
tv.tv_sec = 0;
dwTriesRemaining = MAX_NUM_PAST_TRIES;
}
FD_ZERO(&fdsRead);
FD_SET(sSocket, &fdsRead);
//
// First clear out any extraneous responses from previous communication.
//
while (this->m_pfnselect(0, &fdsRead, NULL, NULL, &s_tv0) != 0)
{
iReturn = this->m_pfnrecvfrom(sSocket,
acRespBuffer,
sizeof(acRespBuffer),
0,
(SOCKADDR*) (&saddrinReceive),
&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 clearing incoming queue!");
hr = DPNHERR_OUTOFMEMORY;
goto Failure;
}
//
// Ignore WSAECONNRESET, that's just WinSock's way of telling us
// that the target actively refused a previous message we tried to
// send. Since we don't know which send WinSock means, we can't do
// a whole lot about it.
//
if (dwError != WSAECONNRESET)
{
DPFX(DPFPREP, 0, "Got sockets error %u trying to receive (clearing incoming queue)!", dwError);
hr = DPNHERR_GENERIC;
goto Failure;
}
DPFX(DPFPREP, 2, "Ignoring CONNRESET while clearing incoming queue.");
}
else
{
//
// If we got here, that means there's a message.
//
#ifdef DBG
DPFX(DPFPREP, 2, "Found extra response from previous PAST request (sent by %u.%u.%u.%u:%u), parsing for fun.",
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port));
//
// For grins, let's see what this message is. Ignore errors.
//
this->ParsePASTMessage(acRespBuffer, iReturn, pRespInfo);
ZeroMemory(pRespInfo, sizeof(*pRespInfo));
#endif // DBG
if (ptuRetry != NULL)
{
//
// Don't re-try so quickly, since responses to our retries are
// lagging.
//
if ((*ptuRetry) < MAX_PAST_RETRY_TIME_US)
{
(*ptuRetry) *= 2;
DPFX(DPFPREP, 8, "Backing initial retry timer off to %u usec.",
(*ptuRetry));
}
}
}
DNASSERT(iRecvAddressSize == iAddressesSize);
FD_ZERO(&fdsRead);
FD_SET(sSocket, &fdsRead);
}
//
// Now do the exchange, get a response to the request (does retries too).
//
do
{
DPFX(DPFPREP, 7, "Sending PAST request type %u (%i bytes, msg id = %u) to server (%u.%u.%u.%u:%u).",
((PPAST_MSG) pcRequestBuffer)->msgtype, iRequestBufferSize, dwMsgID,
((SOCKADDR_IN*) psaddrServerAddress)->sin_addr.S_un.S_un_b.s_b1,
((SOCKADDR_IN*) psaddrServerAddress)->sin_addr.S_un.S_un_b.s_b2,
((SOCKADDR_IN*) psaddrServerAddress)->sin_addr.S_un.S_un_b.s_b3,
((SOCKADDR_IN*) psaddrServerAddress)->sin_addr.S_un.S_un_b.s_b4,
NTOHS(((SOCKADDR_IN*) psaddrServerAddress)->sin_port));
//
// First, send off the request.
//
iReturn = this->m_pfnsendto(sSocket,
pcRequestBuffer,
iRequestBufferSize,
0,
psaddrServerAddress,
iAddressesSize);
if (iReturn == SOCKET_ERROR)
{
#ifdef DBG
dwError = this->m_pfnWSAGetLastError();
DPFX(DPFPREP, 0, "Got sockets error %u when sending to PAST gateway!", dwError);
#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).
//
// Break out of the receive loop, which should result in the
// DPNHERR_SERVERNOTRESPONDING error.
//
break;
}
if (iReturn != iRequestBufferSize)
{
DPFX(DPFPREP, 0, "Didn't send entire datagram (%i != %i)?!", iReturn, iRequestBufferSize);
DNASSERT(FALSE);
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Now see if we get a response.
//
Wait:
FD_ZERO(&fdsRead);
FD_SET(sSocket, &fdsRead);
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 PAST socket!", dwError);
#endif // DBG
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// If our socket was signalled, there's data to read.
//
//if (FD_ISSET(sSocket, &fdsRead))
if (this->m_pfn__WSAFDIsSet(sSocket, &fdsRead))
{
iReturn = this->m_pfnrecvfrom(sSocket,
acRespBuffer,
sizeof(acRespBuffer),
0,
(SOCKADDR*) (&saddrinReceive),
&iRecvAddressSize);
if ((iReturn == 0) || (iReturn == SOCKET_ERROR))
{
dwError = this->m_pfnWSAGetLastError();
//
// If we get WSAECONNRESET here, we can probably assume that
// it's because of the message we just sent. That means that
// there's no PAST server on the gateway.
//
if (dwError == WSAECONNRESET)
{
if (ptuRetry == NULL)
{
DPFX(DPFPREP, 2, "Got CONNRESET while waiting for initial registration response, assuming no PAST server.");
}
else
{
DPFX(DPFPREP, 0, "Got CONNRESET while waiting for PAST server response!");
}
//
// Break out of the loop, it should result in the
// DPNHERR_SERVERNOTRESPONDING error code.
//
break;
}
//
// WSAENOBUFS means WinSock is out of memory.
//
if (dwError == WSAENOBUFS)
{
DPFX(DPFPREP, 0, "WinSock returned WSAENOBUFS when waiting for response!");
hr = DPNHERR_OUTOFMEMORY;
}
else
{
DPFX(DPFPREP, 0, "Got sockets error %u trying to receive (waiting for response)!", dwError);
hr = DPNHERR_GENERIC;
}
goto Failure;
}
//
// We got some data.
//
DNASSERT(iRecvAddressSize == iAddressesSize);
hr = this->ParsePASTMessage(acRespBuffer, iReturn, pRespInfo);
if (hr != DPNH_OK)
{
//
// We couldn't handle the response, try again (without touching
// the remaining tries or backoff timer).
//
DPFX(DPFPREP, 0, "Failed parsing message from %u.%u.%u.%u:%u (err = %lx), ignoring.",
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port),
hr);
goto Wait;
}
if (saddrinReceive.sin_addr.S_un.S_addr != ((SOCKADDR_IN*) psaddrServerAddress)->sin_addr.S_un.S_addr)
{
//
// This message is not from the server to which we sent the
// request. Ignore it.
//
DPFX(DPFPREP, 0, "Got message from unexpected source (%u.%u.%u.%u:%u), ignoring %i byte message.",
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port),
iReturn);
goto Wait;
}
if (pRespInfo->dwMsgID != dwMsgID)
{
//
// We got a response to a different message, try again
// (without touching the remaining tries or backoff timer).
//
DPFX(DPFPREP, 0, "Got messageid %u, expecting messageid %u, ignoring %i byte message.",
pRespInfo->dwMsgID, dwMsgID, iReturn);
goto Wait;
}
//
// If we got here, then it looks like we got the response we want.
// We're done.
//
DPFX(DPFPREP, 8, "Received expected messageid %u from %u.%u.%u.%u:%u, it's %i bytes.",
pRespInfo->dwMsgID,
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port),
iReturn);
goto Exit;
}
//
// The initial registration attempt is a special case since we don't
// know if the server exists or not. Once we're registered, we expect
// the server to be available, so we'll retry more times and
// temporarily back off further each time.
//
if (ptuRetry != NULL)
{
tv.tv_usec *= 2; // exponential backoff.
DPFX(DPFPREP, 7, "Didn't get response, increasing temporary timeout value to %u.", tv.tv_usec);
}
dwTriesRemaining--;
}
while (dwTriesRemaining > 0);
//
// If we got here, it means we didn't get a response.
//
hr = DPNHERR_SERVERNOTRESPONDING;
//goto Failure;
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::ExchangeAndParsePAST
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RegisterMultipleDevicesWithRemotePAST"
//=============================================================================
// CNATHelpPAST::RegisterMultipleDevicesWithRemotePAST
//-----------------------------------------------------------------------------
//
// Description: Sends a registration message to the remote PAST server for
// all the devices in the temporary pSourceList simultaneously
// and waits for replies. A pointer to the first device that
// successfully registers with a remote PAST server will be placed
// in ppFirstDeviceWithRemoteServer. All devices will be removed
// removed from pSourceList.
//
// The object lock is assumed to be held.
//
// Arguments:
// CBilink * pSourceList - Temporary bilink with all
// devices to check. Will be
// emptied.
// CDevice ** ppFirstDeviceWithRemoteServer - Place to store first device
// which successfully
// registers with a remote
// PAST server
//
// Returns: HRESULT
// DPNH_OK - The devices were successfully handled.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::RegisterMultipleDevicesWithRemotePAST(CBilink * pSourceList,
CDevice ** ppFirstDeviceWithRemoteServer)
{
HRESULT hr;
CBilink * pBilink;
CDevice * pDevice;
CBilink * pBilinkSameGateway;
CDevice * pDeviceSameGateway;
char acRespBuffer[PAST_RESPONSE_BUFFER_SIZE];
timeval tv;
FD_SET fdsRead;
int iReturn;
PAST_MSG_REGISTER RegisterReq;
SOCKADDR_IN saddrinServerAddress;
int iRecvAddressSize = sizeof(SOCKADDR_IN);
PAST_RESPONSE_INFO RespInfo;
DWORD dwError;
DWORD dwTry;
DWORD dwFinishTime;
DWORD dwTimeRemaining;
SOCKADDR_IN saddrinReceive;
DPFX(DPFPREP, 5, "(0x%p) Parameters (0x%p, 0x%p)",
this, pSourceList, ppFirstDeviceWithRemoteServer);
DNASSERT(this->m_dwFlags & NATHELPPASTOBJ_INITIALIZED);
#ifdef DBG
ZeroMemory(acRespBuffer, sizeof(acRespBuffer));
#endif // DBG
//
// Loop through each device.
//
pBilink = pSourceList->GetNext();
while (pBilink != pSourceList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
pBilink = pBilink->GetNext();
DNASSERT(pDevice->GetPASTClientID(TRUE) == 0);
//
// Create the temporary set.
//
FD_ZERO(&fdsRead);
FD_SET(pDevice->GetPASTSocket(), &fdsRead);
//
// 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.
//
if (! this->GetAddressToReachGateway(pDevice,
&saddrinServerAddress.sin_addr))
{
DPFX(DPFPREP, 2, "Device 0x%p should not attempt to reach a gateway.",
pDevice);
//
// Take it out of the list, but continue.
//
pDevice->m_blTempList.RemoveFromList();
}
else
{
//
// Store the address with the device for use below.
//
pDevice->SetRemotePASTServerAddressV4(saddrinServerAddress.sin_addr.S_un.S_addr);
//
// Clear out any extraneous responses from previous communication.
//
while (this->m_pfnselect(0, &fdsRead, NULL, NULL, &s_tv0) != 0)
{
iReturn = this->m_pfnrecvfrom(pDevice->GetPASTSocket(),
acRespBuffer,
sizeof(acRespBuffer),
0,
(SOCKADDR*) (&saddrinReceive),
&iRecvAddressSize);
if ((iReturn == 0) || (iReturn == SOCKET_ERROR))
{
dwError = this->m_pfnWSAGetLastError();
//
// Ignore WSAECONNRESET, that's just WinSock's way of
// telling us that the target actively refused a previous
// message we tried to send. Since we don't know which
// send WinSock means, we can't do a whole lot about it.
//
if (dwError != WSAECONNRESET)
{
DPFX(DPFPREP, 0, "Got sockets error %u on device 0x%p trying to receive (clearing incoming queue)! Ignoring.",
dwError, pDevice);
//
// Take it out of the list, but continue.
//
pDevice->m_blTempList.RemoveFromList();
}
else
{
DPFX(DPFPREP, 2, "Ignoring CONNRESET on device 0x%p while clearing incoming queue.",
pDevice);
}
}
else
{
//
// If we got here, that means there's a message.
//
#ifdef DBG
DPFX(DPFPREP, 2, "Found extra response from previous PAST request on device 0x%p (sent by %u.%u.%u.%u:%u), parsing for fun.",
pDevice,
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port));
//
// For grins, let's see what this message is. Ignore
// errors.
//
ZeroMemory(&RespInfo, sizeof(RespInfo));
this->ParsePASTMessage(acRespBuffer, iReturn, &RespInfo);
#endif // DBG
}
DNASSERT(iRecvAddressSize == sizeof(saddrinServerAddress));
FD_ZERO(&fdsRead);
FD_SET(pDevice->GetPASTSocket(), &fdsRead);
}
} // end else (device can try to reach gateway)
}
//
// If there aren't any devices that aren't registered, we're done.
//
if (pSourceList->IsEmpty())
{
DPFX(DPFPREP, 8, "No devices remaining to be checked.");
hr = DPNH_OK;
goto Exit;
}
//
// Build the registration request message.
//
ZeroMemory(&RegisterReq, sizeof(RegisterReq));
RegisterReq.version = PAST_VERSION;
RegisterReq.command = PAST_MSGID_REGISTER_REQUEST;
RegisterReq.msgid.code = PAST_PARAMID_MESSAGEID;
RegisterReq.msgid.len = sizeof(RegisterReq.msgid) - sizeof(PAST_PARAM);
//RegisterReq.msgid.msgid = 0; // it always starts at 0 for registration
ZeroMemory(&saddrinServerAddress, sizeof(saddrinServerAddress));
saddrinServerAddress.sin_family = AF_INET;
//saddrinServerAddress.sin_addr = ? // filled in below
saddrinServerAddress.sin_port = HTONS(PAST_HOST_PORT);
//
// Now actually try to register with all the ports. Keep looping until
// either all devices are registered or we exceed the number of tries.
//
for(dwTry = 0; dwTry < MAX_NUM_PAST_TRIES_CONNECT; dwTry++)
{
//
// Send the message for all devices that aren't registered yet.
//
pBilink = pSourceList->GetNext();
while (pBilink != pSourceList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
pBilink = pBilink->GetNext();
//
// Remember the current time, if this is the first thing we've sent
// from this port.
//
if (pDevice->GetFirstPASTDiscoveryTime() == 0)
{
pDevice->SetFirstPASTDiscoveryTime(GETTIMESTAMP());
}
//
// Retrieve the gateway address we detected above.
//
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
//
// Try sending the registration message.
//
DPFX(DPFPREP, 7, "Device 0x%p sending PAST registration request (type %u, %i bytes) to server (%u.%u.%u.%u:%u).",
pDevice, RegisterReq.command, sizeof(RegisterReq),
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b1,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b2,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b3,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinServerAddress.sin_port));
iReturn = this->m_pfnsendto(pDevice->GetPASTSocket(),
(char*) (&RegisterReq),
sizeof(RegisterReq),
0,
(SOCKADDR*) (&saddrinServerAddress),
sizeof(saddrinServerAddress));
if (iReturn == SOCKET_ERROR)
{
#ifdef DBG
dwError = this->m_pfnWSAGetLastError();
DPFX(DPFPREP, 0, "Device 0x%p got sockets error %u when sending to PAST gateway!",
pDevice, dwError);
#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. Take the out of the list,
// but continue.
//
pDevice->m_blTempList.RemoveFromList();
//
// If there aren't any more devices, we can bail.
//
if (pSourceList->IsEmpty())
{
DPFX(DPFPREP, 1, "Last device got sendto error, exiting gracefully.");
hr = DPNH_OK;
goto Exit;
}
}
else
{
if (iReturn != sizeof(RegisterReq))
{
DPFX(DPFPREP, 0, "Didn't send entire datagram (%i != %i)?!",
iReturn, sizeof(RegisterReq));
DNASSERT(FALSE);
hr = DPNHERR_GENERIC;
goto Failure;
}
}
}
//
// Remember how long to wait for replies to this send attempt.
//
dwFinishTime = timeGetTime() + PAST_CONNECT_RETRY_INTERVAL_MS;
dwTimeRemaining = PAST_CONNECT_RETRY_INTERVAL_MS;
//
// Keep looping until all devices are registered or we timeout.
//
do
{
//
// Rebuild the socket set.
//
FD_ZERO(&fdsRead);
pBilink = pSourceList->GetNext();
while (pBilink != pSourceList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
DNASSERT(pDevice->GetPASTClientID(TRUE) == 0);
FD_SET(pDevice->GetPASTSocket(), &fdsRead);
//
// Move to next device
//
pBilink = pBilink->GetNext();
}
tv.tv_usec = dwTimeRemaining * 1000;
tv.tv_sec = 0;
//
// Wait for data to come in on any of the sockets.
//
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 PAST sockets!", dwError);
#endif // DBG
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Stop looping if we timed out; it's time to repeat the message
// (or exit, if no more tries left).
//
if (iReturn == 0)
{
DPFX(DPFPREP, 7, "No more sockets have data, try = %u of %u.",
(dwTry + 1), MAX_NUM_PAST_TRIES_CONNECT);
break;
}
//
// If we're here, data came in on at least one of the sockets.
// Read it and parse it.
//
pBilink = pSourceList->GetNext();
while (pBilink != pSourceList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
pBilink = pBilink->GetNext();
//
// If this device's socket is set there's data to read.
//
//if (FD_ISSET(pDevice->GetPASTSocket(), &fdsRead))
if (this->m_pfn__WSAFDIsSet(pDevice->GetPASTSocket(), &fdsRead))
{
iReturn = this->m_pfnrecvfrom(pDevice->GetPASTSocket(),
acRespBuffer,
sizeof(acRespBuffer),
0,
(SOCKADDR*) (&saddrinReceive),
&iRecvAddressSize);
if ((iReturn == 0) || (iReturn == SOCKET_ERROR))
{
#ifdef DBG
dwError = this->m_pfnWSAGetLastError();
//
// If we get WSAECONNRESET here, we can probably assume
// that it's because of the message we just sent. That
// means that there's no PAST server on the gateway.
//
if (dwError == WSAECONNRESET)
{
DPFX(DPFPREP, 2, "Got CONNRESET while waiting for registration response on device 0x%p, assuming no PAST server.",
pDevice);
}
else
{
DPFX(DPFPREP, 0, "Got sockets error %u trying to receive on device 0x%p (waiting for response)! Ignoring",
dwError);
}
#endif // DBG
//
// Take it out of the list, but continue.
//
pDevice->m_blTempList.RemoveFromList();
//
// We can also be smart and remove any other devices
// with the same gateway because they will have the
// same problem; WinSock might not even give another
// notification for the other sockets. Don't try this
// trick for the broadcast address, though.
//
if (pDevice->GetRemotePASTServerAddressV4() != INADDR_BROADCAST)
{
pBilinkSameGateway = pSourceList->GetNext();
while (pBilinkSameGateway != pSourceList)
{
pDeviceSameGateway = DEVICE_FROM_TEMP_BILINK(pBilinkSameGateway);
pBilinkSameGateway = pBilinkSameGateway->GetNext();
if (pDeviceSameGateway->GetRemotePASTServerAddressV4() == pDevice->GetRemotePASTServerAddressV4())
{
#ifdef DBG
saddrinServerAddress.sin_addr.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
DPFX(DPFPREP, 3, "Removing device 0x%p, because it shares gateway %u.%u.%u.%u with device 0x%p.",
pDeviceSameGateway,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b1,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b2,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b3,
saddrinServerAddress.sin_addr.S_un.S_un_b.s_b4,
pDevice);
#endif // DBG
//
// Before we remove this similar device,
// make sure we don't screw up the list of
// remaining devices. Otherwise, that
// outer list traversal may get caught in
// an infinite loop.
//
if ((&pDeviceSameGateway->m_blTempList) == pBilink)
{
pBilink = pBilink->GetNext();
}
pDeviceSameGateway->m_blTempList.RemoveFromList();
}
}
}
else
{
//
// Sent to broadcast address, can't optimize.
//
}
//
// If there aren't any more devices, we can bail.
//
if (pSourceList->IsEmpty())
{
DPFX(DPFPREP, 1, "Last device got recvfrom error, exiting gracefully.");
hr = DPNH_OK;
goto Exit;
}
}
else
{
//
// We got some data.
//
DNASSERT(iRecvAddressSize == sizeof(saddrinServerAddress));
ZeroMemory(&RespInfo, sizeof(RespInfo));
hr = this->ParsePASTMessage(acRespBuffer, iReturn, &RespInfo);
if (hr != DPNH_OK)
{
//
// We couldn't handle the response, try again.
//
DPFX(DPFPREP, 0, "Failed parsing message (err = %lx), ignoring.",
hr);
}
else
{
if (RespInfo.dwMsgID != 0)
{
//
// We got a response to a different message,
// try again.
//
DPFX(DPFPREP, 0, "Got messageid %u, expecting messageid 0, ignoring.",
RespInfo.dwMsgID);
}
else
{
if (RespInfo.cMsgType != PAST_MSGID_REGISTER_RESPONSE)
{
//
// We got an unxpected response type, try
// again.
//
DPFX(DPFPREP, 0, "Got message type %u, expecting %u, ignoring.",
RespInfo.cMsgType, PAST_MSGID_REGISTER_RESPONSE);
}
else
{
//
// If we got here, then it looks like we
// got the response we want.
//
//
// If we were broadcasting, accept the
// first response we receive. Otherwise,
// throw out the message if it's not from
// the address we expect.
//
if (saddrinServerAddress.sin_addr.S_un.S_addr == INADDR_BROADCAST)
{
DPFX(DPFPREP, 4, "Accepting response from PAST server %u.%u.%u.%u:%u.",
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port));
pDevice->SetRemotePASTServerAddressV4(saddrinReceive.sin_addr.S_un.S_addr);
}
if (pDevice->GetRemotePASTServerAddressV4() == saddrinReceive.sin_addr.S_un.S_addr)
{
pDevice->SetPASTClientID(RespInfo.dwClientID, TRUE);
//
// Move to the next message ID.
//
pDevice->ResetRemotePASTMsgIDAndRetryTimeout(DEFAULT_INITIAL_PAST_RETRY_TIMEOUT);
pDevice->GetNextRemotePASTMsgID();
//
// Pull this device from the list of
// remaining devices.
//
pDevice->m_blTempList.RemoveFromList();
//
// Register all the existing mappings
// associated with the device that the
// user has already requested.
//
if (! pDevice->m_blOwnedRegPorts.IsEmpty())
{
hr = this->RegisterAllPortsWithPAST(pDevice, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't register all existing ports with remote PAST server!");
goto Failure;
}
#ifdef DBG
//
// If we didn't encounter an error
// that caused the PAST server to
// be removed, then the
// NATHELPPASTOBJ_ADDRESSESCHANGED
// flag must have been set by the
// AssignOrListenPorts function.
//
if (pDevice->GetPASTClientID(TRUE) != 0)
{
if (! (this->m_dwFlags & NATHELPPASTOBJ_ADDRESSESCHANGED))
{
DPFX(DPFPREP, 1, "Successfully registered with remote PAST server, but no addresses changed; all ports should be unavailable.");
}
}
else
{
DPFX(DPFPREP, 1, "Remote PAST server was removed while trying to register existing ports.");
}
#endif // DBG
}
else
{
BOOL fAddressAlreadyChanged;
DPFX(DPFPREP, 2, "Remote PAST server now available for device 0x%p, but no ports are currently registered.",
pDevice);
fAddressAlreadyChanged = (this->m_dwFlags & NATHELPPASTOBJ_ADDRESSESCHANGED) ? TRUE : FALSE;
//
// Forcefully check if there's a
// public address available.
//
hr = this->UpdatePASTPublicAddressValidity(pDevice, TRUE);
if (hr != DPNH_OK)
{
DPFX(DPFPREP, 0, "Couldn't update remote PAST server address validity!");
goto Failure;
}
//
// Prevent the user from thinking
// the addresses changed unless
// something else already caused
// the address change notification.
//
if (! fAddressAlreadyChanged)
{
this->m_dwFlags &= ~NATHELPPASTOBJ_ADDRESSESCHANGED;
}
}
//
// Store this device, if it's the first
// one that successfully registered.
//
if ((*ppFirstDeviceWithRemoteServer) == NULL)
{
DPFX(DPFPREP, 7, "Saving device 0x%p that was just registered with new remote PAST server.",
pDevice);
(*ppFirstDeviceWithRemoteServer) = pDevice;
}
else
{
DPFX(DPFPREP, 7, "Already have device with remote PAST server 0x%p, not storing newly registered 0x%p.",
(*ppFirstDeviceWithRemoteServer), pDevice);
}
//
// If there aren't any more devices, we
// can bail.
//
if (pSourceList->IsEmpty())
{
DPFX(DPFPREP, 7, "Last device (0x%p) got registered with remote PAST server.",
pDevice);
hr = DPNH_OK;
goto Exit;
}
}
else
{
DPFX(DPFPREP, 0, "Ignoring correctly formed message from %u.%u.%u.%u:%u!",
saddrinReceive.sin_addr.S_un.S_un_b.s_b1,
saddrinReceive.sin_addr.S_un.S_un_b.s_b2,
saddrinReceive.sin_addr.S_un.S_un_b.s_b3,
saddrinReceive.sin_addr.S_un.S_un_b.s_b4,
NTOHS(saddrinReceive.sin_port));
}
} // end else (got correct message type)
} // end else (got correct message ID)
} // end else (failed parsing message)
} // end else (successfully received data)
}
else
{
//
// Socket did not receive any data.
//
}
}
//
// Calculate how much time remains. If that went negative, loop
// one extra time (with a timeout of 0). We will bail after the
// select if no data arrived while we were processing the last
// round of data.
//
dwTimeRemaining = dwFinishTime - timeGetTime();
if ((int) dwTimeRemaining < 0)
{
dwTimeRemaining = 0;
}
}
while (TRUE);
//
// Go to next attempt
//
}
//
// If we're here some devices still do not have remote PAST servers.
// There should still be items in the temp source list.
//
DNASSERT(! pSourceList->IsEmpty());
//
// Remove any remaining items from the temp source list.
//
pBilink = pSourceList->GetNext();
while (pBilink != pSourceList)
{
pDevice = DEVICE_FROM_TEMP_BILINK(pBilink);
pBilink = pBilink->GetNext();
pDevice->m_blTempList.RemoveFromList();
}
hr = DPNH_OK;
Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
Failure:
goto Exit;
} // CNATHelpPAST::RegisterMultipleDevicesWithRemotePAST
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ParsePASTMessage"
//=============================================================================
// CNATHelpPAST::ParsePASTMessage
//-----------------------------------------------------------------------------
//
// Description: Parses a PAST message and extracts the codes into fields in
// a standardized structure.
//
// This is not completely general, as we know that we will only
// operate with v4 addresses and our commands will never deal with
// more than 1 address/port at a time. PAST allows for multiple
// ports to be allocated in a single request, but we do not take
// advantage of this feature. If you need to handle such multiple
// address requests and responses, then you will need to change
// this function.
//
// Arguments:
// char * pcMsg - Pointer to buffer containing a PAST
// request or response message.
// int iMsgSize - Size of message buffer in bytes.
// PAST_RESPONSE_INFO * pRespInfo - Pointer to structure that is filled with
// the parameters from the PAST message.
//
// Returns: HRESULT
// DPNH_OK - Parsing was successful.
// DPNHERR_INVALIDPARAM - An invalid buffer was given.
// DPNHERR_GENERIC - An error occurred.
//=============================================================================
HRESULT CNATHelpPAST::ParsePASTMessage(const char * const pcMsg,
const int iMsgSize,
PAST_RESPONSE_INFO * const pRespInfo)
{
HRESULT hr = DPNH_OK;
BOOL fGotlAddress = FALSE;
BOOL fGotlPort = FALSE;
PPAST_PARAM pParam;
PPAST_PARAM pNextParam;
const char * pcEnd;
char * pcData;
char cTemp;
#ifdef DBG
char szPortList[(DPNH_MAX_SIMULTANEOUS_PORTS * 7) + 1]; // "nnnnn, " + NULL termination
char * pszTemp;
#endif // DBG
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p, %i, 0x%p)",
this, pcMsg, iMsgSize, pRespInfo);
if (iMsgSize < 2)
{
DPFX(DPFPREP, 0, "Buffer too small to be valid PAST message (%i bytes)!", iMsgSize);
DNASSERTX(! "Buffer too small to be valid PAST message!", 2);
hr = DPNHERR_INVALIDPARAM;
goto Failure;
}
pRespInfo->cVersion = ((PPAST_MSG) pcMsg)->version;
pRespInfo->cMsgType = ((PPAST_MSG) pcMsg)->msgtype;
DPFX(DPFPREP, 3, "version %u msgtype %u", pRespInfo->cVersion, pRespInfo->cMsgType);
pParam = (PPAST_PARAM) (pcMsg + sizeof(PAST_MSG));
pcEnd = pcMsg + iMsgSize;
while ((char *) (pParam + 1) < pcEnd)
{
pcData = (char *) (pParam + 1);
pNextParam = (PPAST_PARAM) (pcData + pParam->len);
if ((pParam->len > (iMsgSize - sizeof(PAST_MSG) - sizeof(PAST_PARAM))) ||
((char *) pNextParam > pcEnd))
{
break;
}
switch (pParam->code)
{
case PAST_PARAMID_ADDRESS:
{
if (pParam->len >= 1)
{
//
// Addresses are type[1]|addr[?]
//
if ((*pcData) != PAST_ADDRESSTYPE_IPV4)
{
DPFX(DPFPREP, 0, "Got unexpected PAST address code type %u!", (*pcData));
hr = DPNHERR_GENERIC;
goto Failure;
}
//
// Validate the size of the address parameter.
//
if (pParam->len == 5)
{
if (! fGotlAddress)
{
CopyMemory(&pRespInfo->dwLocalAddressV4, pcData + 1, 4);
DPFX(DPFPREP, 3, "Got local address %u.%u.%u.%u.",
((IN_ADDR *) (&pRespInfo->dwLocalAddressV4))->S_un.S_un_b.s_b1,
((IN_ADDR *) (&pRespInfo->dwLocalAddressV4))->S_un.S_un_b.s_b2,
((IN_ADDR *) (&pRespInfo->dwLocalAddressV4))->S_un.S_un_b.s_b3,
((IN_ADDR *) (&pRespInfo->dwLocalAddressV4))->S_un.S_un_b.s_b4);
if ((pRespInfo->dwLocalAddressV4 == INADDR_BROADCAST) ||
(IS_CLASSD_IPV4_ADDRESS(pRespInfo->dwLocalAddressV4)))
{
DPFX(DPFPREP, 1, "Ignoring invalid local address and using INADDR_ANY instead.");
pRespInfo->dwLocalAddressV4 = 0;
}
fGotlAddress = TRUE;
}
else
{
fGotlPort = TRUE; // just in case there wasn't a local port
CopyMemory(&pRespInfo->dwRemoteAddressV4, pcData + 1, 4);
DPFX(DPFPREP, 3, "Got remote address %u.%u.%u.%u.",
((IN_ADDR *) (&pRespInfo->dwRemoteAddressV4))->S_un.S_un_b.s_b1,
((IN_ADDR *) (&pRespInfo->dwRemoteAddressV4))->S_un.S_un_b.s_b2,
((IN_ADDR *) (&pRespInfo->dwRemoteAddressV4))->S_un.S_un_b.s_b3,
((IN_ADDR *) (&pRespInfo->dwRemoteAddressV4))->S_un.S_un_b.s_b4);
if ((pRespInfo->dwRemoteAddressV4 == INADDR_BROADCAST) ||
(IS_CLASSD_IPV4_ADDRESS(pRespInfo->dwRemoteAddressV4)))
{
DPFX(DPFPREP, 7, "Ignoring invalid remote address and using INADDR_ANY instead.");
pRespInfo->dwRemoteAddressV4 = 0;
}
}
}
else
{
DPFX(DPFPREP, 0, "Ignoring address parameter with invalid length (%u)!",
pParam->len);
}
}
else
{
DPFX(DPFPREP, 1, "Ignoring 0 byte address parameter.");
}
break;
}
case PAST_PARAMID_PORTS:
{
if (pParam->len >= 1)
{
//
// Validate the port count.
//
if ((*pcData) == 0)
{
DPFX(DPFPREP, 1, "Ignoring %u byte port parameter with 0 ports.",
pParam->len);
break;
}
//
// Validate the size of the parameter.
//
if (pParam->len < (((*pcData) * sizeof (WORD)) + 1))
{
DPFX(DPFPREP, 0, "Port parameter is %u bytes, but is reporting %u ports! Ignoring.",
pParam->len, (*pcData));
break;
}
//
// NOTE: Ports appeared to be transferred in x86 format,
// contrary to the spec, which says network byte order.
//
//
// Ports are Count[1]|Port[2]....Port[2]
//
if (! fGotlPort)
{
pRespInfo->cNumLocalPorts = (*pcData);
if (pRespInfo->cNumLocalPorts > DPNH_MAX_SIMULTANEOUS_PORTS)
{
DPFX(DPFPREP, 0, "Got %u local ports, only using first %u:",
pRespInfo->cNumLocalPorts, DPNH_MAX_SIMULTANEOUS_PORTS);
pRespInfo->cNumLocalPorts = DPNH_MAX_SIMULTANEOUS_PORTS;
}
else
{
DPFX(DPFPREP, 3, "Got %u local ports:",
pRespInfo->cNumLocalPorts);
}
//
// Copy the port array.
//
CopyMemory(pRespInfo->awLocalPorts, (pcData + 1),
(pRespInfo->cNumLocalPorts * sizeof (WORD)));
//
// Unfortunately we want the array to have ports in
// network byte order for real. Loop through each port
// and switch them.
//
#ifdef DBG
szPortList[0] = '\0'; // initialize
pszTemp = szPortList;
#endif // DBG
for(cTemp = 0; cTemp < pRespInfo->cNumLocalPorts; cTemp++)
{
#ifdef DBG
pszTemp += wsprintfA(pszTemp, "%u, ", pRespInfo->awLocalPorts[cTemp]);
#endif // DBG
pRespInfo->awLocalPorts[cTemp] = HTONS(pRespInfo->awLocalPorts[cTemp]);
}
#ifdef DBG
szPortList[strlen(szPortList) - 2] = '\0'; // chop off trailing ", "
DPFX(DPFPREP, 3, " {%hs}", szPortList);
#endif // DBG
fGotlPort = TRUE;
}
else
{
if (pRespInfo->cNumRemotePorts > 0)
{
DPFX(DPFPREP, 0, "Already received %u remote ports, ignoring %u more.",
pRespInfo->cNumRemotePorts, (*pcData));
}
else
{
pRespInfo->cNumRemotePorts = (*pcData);
if (pRespInfo->cNumRemotePorts > DPNH_MAX_SIMULTANEOUS_PORTS)
{
DPFX(DPFPREP, 0, "Got %u remote ports, only using first %u:",
pRespInfo->cNumRemotePorts, DPNH_MAX_SIMULTANEOUS_PORTS);
pRespInfo->cNumRemotePorts = DPNH_MAX_SIMULTANEOUS_PORTS;
}
else
{
DPFX(DPFPREP, 3, "Got %u remote ports:",
pRespInfo->cNumRemotePorts);
}
//
// Copy the port array.
//
CopyMemory(pRespInfo->awRemotePorts, (pcData + 1),
(pRespInfo->cNumRemotePorts * sizeof (WORD)));
//
// Unfortunately we want the array to have ports in
// network byte order for real. Loop through each
// port and switch them.
//
#ifdef DBG
szPortList[0] = '\0'; // initialize
pszTemp = szPortList;
#endif // DBG
for(cTemp = 0; cTemp < pRespInfo->cNumRemotePorts; cTemp++)
{
#ifdef DBG
pszTemp += wsprintfA(pszTemp, "%u, ", pRespInfo->awRemotePorts[cTemp]);
#endif // DBG
pRespInfo->awRemotePorts[cTemp] = HTONS(pRespInfo->awRemotePorts[cTemp]);
}
#ifdef DBG
szPortList[strlen(szPortList) - 2] = '\0'; // chop off trailing ", "
DPFX(DPFPREP, 3, " {%hs}", szPortList);
#endif // DBG
}
}
}
else
{
DPFX(DPFPREP, 1, "Ignoring 0 byte port parameter.");
}
break;
}
case PAST_PARAMID_LEASE:
{
if (pParam->len == 4)
{
CopyMemory(&pRespInfo->dwLeaseTime, pcData, 4);
DPFX(DPFPREP, 3, "Got lease of %u seconds.", pRespInfo->dwLeaseTime);
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty lease parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring lease parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_CLIENTID:
{
if (pParam->len == 4)
{
CopyMemory(&pRespInfo->dwClientID, pcData, 4);
DPFX(DPFPREP, 3, "Got client ID %u.", pRespInfo->dwClientID);
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty client ID parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring client ID parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_BINDID:
{
if (pParam->len == 4)
{
CopyMemory(&pRespInfo->dwBindID, pcData, 4);
DPFX(DPFPREP, 3, "Got bind ID %u.", pRespInfo->dwBindID);
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty bind ID parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring bind ID parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_MESSAGEID:
{
if (pParam->len == 4)
{
CopyMemory(&pRespInfo->dwMsgID, pcData, 4);
DPFX(DPFPREP, 3, "Got message ID %u.", pRespInfo->dwMsgID);
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty message ID parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring message ID parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_TUNNELTYPE:
{
if (pParam->len == 1)
{
DPFX(DPFPREP, 3, "Got tunnel type %u, ignoring.", (*pcData));
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty tunnel type parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring tunnel type parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_PASTMETHOD:
{
if (pParam->len == 1)
{
DPFX(DPFPREP, 3, "Got PAST method %u, ignoring.", (*pcData));
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty PAST method parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring PAST method parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_ERROR:
{
if (pParam->len == 2)
{
#ifdef DBG
char * pszErrorString;
#endif // DBG
CopyMemory(&pRespInfo->wError, pcData, 2);
#ifdef DBG
switch (pRespInfo->wError)
{
case PASTERR_UNKNOWNERROR:
{
pszErrorString = "UNKNOWNERROR";
break;
}
case PASTERR_BADBINDID:
{
pszErrorString = "BADBINDID";
break;
}
case PASTERR_BADCLIENTID:
{
pszErrorString = "BADCLIENTID";
break;
}
case PASTERR_MISSINGPARAM:
{
pszErrorString = "MISSINGPARAM";
break;
}
case PASTERR_DUPLICATEPARAM:
{
pszErrorString = "DUPLICATEPARAM";
break;
}
case PASTERR_ILLEGALPARAM:
{
pszErrorString = "ILLEGALPARAM";
break;
}
case PASTERR_ILLEGALMESSAGE:
{
pszErrorString = "ILLEGALMESSAGE";
break;
}
case PASTERR_REGISTERFIRST:
{
pszErrorString = "REGISTERFIRST";
break;
}
case PASTERR_BADMESSAGEID:
{
pszErrorString = "BADMESSAGEID";
break;
}
case PASTERR_ALREADYREGISTERED:
{
pszErrorString = "ALREADYREGISTERED";
break;
}
case PASTERR_ALREADYUNREGISTERED:
{
pszErrorString = "ALREADYUNREGISTERED";
break;
}
case PASTERR_BADTUNNELTYPE:
{
pszErrorString = "BADTUNNELTYPE";
break;
}
case PASTERR_ADDRUNAVAILABLE:
{
pszErrorString = "ADDRUNAVAILABLE";
break;
}
case PASTERR_PORTUNAVAILABLE:
{
pszErrorString = "PORTUNAVAILABLE";
break;
}
default:
{
pszErrorString = "? unknown ?";
break;
}
}
DPFX(DPFPREP, 1, "Got PAST error %u, %hs.",
pRespInfo->wError, pszErrorString);
#endif // DBG
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty PAST error parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring PAST error parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_FLOWPOLICY:
{
if (pParam->len == 2)
{
DPFX(DPFPREP, 3, "Got PAST flow policy local %u, remote %u; ignoring.",
(*pcData), *(pcData + 1));
}
else
{
if (pParam->len == 0)
{
DPFX(DPFPREP, 1, "Ignoring empty flow policy parameter.");
}
else
{
DPFX(DPFPREP, 0, "Ignoring flow policy parameter with invalid length (%u)!",
pParam->len);
}
}
break;
}
case PAST_PARAMID_VENDOR:
{
DPFX(DPFPREP, 1, "Got %u byte vendor code parameter, ignoring.",
pParam->len);
break;
}
default:
{
DPFX(DPFPREP, 0, "Got %u byte unknown parameter code %u, ignoring.",
pParam->len, pParam->code);
break;
}
}
pParam = pNextParam;
}
Failure:
//Exit:
DPFX(DPFPREP, 5, "(0x%p) Returning: [0x%lx]", this, hr);
return hr;
} // CNATHelpPAST::ParsePASTMessage
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RequestLocalAddressListChangeNotification"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::RequestLocalAddressListChangeNotification(void)
{
HRESULT hr;
DWORD dwTemp;
int iReturn;
DPFX(DPFPREP, 5, "(0x%p) Enter", this);
DNASSERT(! (this->m_dwFlags & NATHELPPASTOBJ_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;
} // CNATHelpPAST::RequestLocalAddressListChangeNotification
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::CreatePASTSocket"
//=============================================================================
// CNATHelpPAST::CreatePASTSocket
//-----------------------------------------------------------------------------
//
// Description: Creates a PAST communication 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 CNATHelpPAST::CreatePASTSocket(SOCKADDR_IN * const psaddrinAddress)
{
SOCKET sTemp;
DWORD dwTry;
int iTemp;
BOOL fTemp;
#ifdef DBG
DWORD dwError;
#endif // DBG
DPFX(DPFPREP, 5, "(0x%p) Parameters: (0x%p)", this, psaddrinAddress);
//
// Create the socket.
//
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 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
// 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 & NATHELPPASTOBJ_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...
//
}
}
//
// 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;
}
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;
} // CNATHelpPAST::CreatePASTSocket
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::GetAddressToReachGateway"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::GetAddressToReachGateway(CDevice * const pDevice,
IN_ADDR * const pinaddr)
{
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,
pAdapterInfo->GatewayList.IpAddress.String);
//
// 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;
} // CNATHelpPAST::GetAddressToReachGateway
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::IsAddressLocal"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::IsAddressLocal(CDevice * const pDevice,
const SOCKADDR_IN * const psaddrinAddress)
{
DWORD dwError;
BOOL fResult;
MIB_IPFORWARDROW IPForwardRow;
DWORD dwSubnetMaskV4;
//
// 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;
}
//
// 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:
//
// 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 %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*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b1,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b2,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b3,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b4);
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 %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*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b1,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b2,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b3,
((IN_ADDR*) (&dwSubnetMaskV4))->S_un.S_un_b.s_b4);
fResult = FALSE;
}
Exit:
return fResult;
} // CNATHelpPAST::IsAddressLocal
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ClearDevicesPASTServer"
//=============================================================================
// CNATHelpPAST::ClearDevicesPASTServer
//-----------------------------------------------------------------------------
//
// Description: Forcefully simulates de-registration with a PAST server
/// 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 ports should be unbound.
// BOOL fRemote - TRUE if clearing remote PAST server, FALSE if
// clearing local PAST server.
//
// Returns: None.
//=============================================================================
void CNATHelpPAST::ClearDevicesPASTServer(CDevice * const pDevice,
const BOOL fRemote)
{
#ifdef DBG
DNASSERT(pDevice->GetPASTClientID(fRemote) != 0);
DPFX(DPFPREP, 1, "Clearing PAST server, device = 0x%p, remote = %i",
pDevice, fRemote);
pDevice->IncrementPASTServerFailures(fRemote);
this->m_dwNumServerFailures++;
#endif // DBG
if (! fRemote)
{
pDevice->NoteNoLocalPASTServer();
}
pDevice->SetPASTClientID(0, fRemote);
this->ClearAllPASTServerRegisteredPorts(pDevice, fRemote);
pDevice->NoteNoPASTPublicAddressAvailable(fRemote);
this->RemoveAllPASTCachedMappings(pDevice, fRemote);
//
// Since there was a change in the network, go back to polling relatively
// quickly.
//
this->ResetNextPollInterval();
} // CNATHelpPAST::ClearDevicesPASTServer
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ClearAllPASTServerRegisteredPorts"
//=============================================================================
// CNATHelpPAST::ClearAllPASTServerRegisteredPorts
//-----------------------------------------------------------------------------
//
// Description: Clears all bind IDs and public addresses for a given
// device's local or remote PAST server. This should only be
// called after the PAST server dies because the registered ports
// remain associated with the device.
//
// 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 CNATHelpPAST::ClearAllPASTServerRegisteredPorts(CDevice * const pDevice,
const BOOL fRemote)
{
CBilink * pBilink;
CRegisteredPort * pRegisteredPort;
DPFX(DPFPREP, 7, "(0x%p) Parameters: (0x%p, %i)", this, pDevice, fRemote);
pBilink = pDevice->m_blOwnedRegPorts.GetNext();
while (pBilink != &pDevice->m_blOwnedRegPorts)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilink);
if (pRegisteredPort->GetPASTBindID(fRemote) != 0)
{
DNASSERT(pRegisteredPort->HasPASTPublicAddressesArray(fRemote));
DNASSERT(! pRegisteredPort->IsPASTPortUnavailable(fRemote));
if (pDevice->IsPASTPublicAddressAvailable(fRemote))
{
DPFX(DPFPREP, 1, "Registered port 0x%p losing %s PAST public address.",
pRegisteredPort, ((fRemote) ? _T("remote") : _T("local")));
//
// Let the user know next time GetCaps is called.
//
this->m_dwFlags |= NATHELPPASTOBJ_ADDRESSESCHANGED;
}
else
{
DPFX(DPFPREP, 1, "Registered port 0x%p losing %s PAST binding, but it didn't have a public address.",
pRegisteredPort, ((fRemote) ? _T("remote") : _T("local")));
}
pRegisteredPort->ClearPASTPublicAddresses(fRemote);
pRegisteredPort->SetPASTBindID(0, fRemote);
DNASSERT(this->m_dwNumLeases > 0);
this->m_dwNumLeases--;
DPFX(DPFPREP, 7, "%s PAST lease for 0x%p cleared, total num leases = %u.",
((fRemote) ? _T("Remote") : _T("Local")), pRegisteredPort, this->m_dwNumLeases);
}
else
{
DNASSERT(! pRegisteredPort->HasPASTPublicAddressesArray(fRemote));
//
// Port no longer unavailable (if it had been).
//
pRegisteredPort->NoteNotPASTPortUnavailable(fRemote);
}
pBilink = pBilink->GetNext();
}
DPFX(DPFPREP, 7, "(0x%p) Leave", this);
} // CNATHelpPAST::ClearAllPASTServerRegisteredPorts
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::ExpireOldCachedMappings"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::ExpireOldCachedMappings(void)
{
DWORD dwCurrentTime;
CBilink * pBilinkDevice;
CDevice * pDevice;
CBilink * pCachedMaps;
CBilink * pBilinkCacheMap;
CCacheMap * pCacheMap;
DPFX(DPFPREP, 7, "(0x%p) Enter", this);
dwCurrentTime = timeGetTime();
//
// Check the PAST cached mappings.
//
pBilinkDevice = this->m_blDevices.GetNext();
while (pBilinkDevice != &this->m_blDevices)
{
pDevice = DEVICE_FROM_BILINK(pBilinkDevice);
//
// Check the remote PAST server mappings.
//
pCachedMaps = pDevice->GetPASTCachedMaps(TRUE);
pBilinkCacheMap = pCachedMaps->GetNext();
while (pBilinkCacheMap != pCachedMaps)
{
pCacheMap = CACHEMAP_FROM_BILINK(pBilinkCacheMap);
pBilinkCacheMap = pBilinkCacheMap->GetNext();
if ((int) (pCacheMap->GetExpirationTime() - dwCurrentTime) < 0)
{
DPFX(DPFPREP, 5, "Remote PAST server cached mapping 0x%p has expired.", pCacheMap);
pCacheMap->m_blList.RemoveFromList();
delete pCacheMap;
}
}
//
// Check the local PAST server mappings.
//
pCachedMaps = pDevice->GetPASTCachedMaps(FALSE);
pBilinkCacheMap = pCachedMaps->GetNext();
while (pBilinkCacheMap != pCachedMaps)
{
pCacheMap = CACHEMAP_FROM_BILINK(pBilinkCacheMap);
pBilinkCacheMap = pBilinkCacheMap->GetNext();
if ((int) (pCacheMap->GetExpirationTime() - dwCurrentTime) < 0)
{
DPFX(DPFPREP, 5, "Local PAST server cached mapping 0x%p has expired.", pCacheMap);
pCacheMap->m_blList.RemoveFromList();
delete pCacheMap;
}
}
pBilinkDevice = pBilinkDevice->GetNext();
}
DPFX(DPFPREP, 7, "(0x%p) Leave", this);
} // CNATHelpPAST::ExpireOldCachedMappings
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::RemoveAllPASTCachedMappings"
//=============================================================================
// CNATHelpPAST::RemoveAllPASTCachedMappings
//-----------------------------------------------------------------------------
//
// Description: Removes all cached mappings for a given device's local or
// remote PAST server.
//
// The object lock is assumed to be held.
//
// Arguments:
// CDevice * pDevice - Pointer to device whose cache should be emptied.
// BOOL fRemote - TRUE if emptying remote server, FALSE if emptying
// local server.
//
// Returns: None.
//=============================================================================
void CNATHelpPAST::RemoveAllPASTCachedMappings(CDevice * const pDevice,
const BOOL fRemote)
{
CBilink * pCachedMaps;
CBilink * pBilink;
CCacheMap * pCacheMap;
pCachedMaps = pDevice->GetPASTCachedMaps(fRemote);
pBilink = pCachedMaps->GetNext();
while (pBilink != pCachedMaps)
{
pCacheMap = CACHEMAP_FROM_BILINK(pBilink);
pBilink = pBilink->GetNext();
DPFX(DPFPREP, 5, "Removing cached mapping 0x%p.", pCacheMap);
pCacheMap->m_blList.RemoveFromList();
delete pCacheMap;
}
} // CNATHelpPAST::RemoveAllPASTCachedMappings
#ifdef DBG
#undef DPF_MODNAME
#define DPF_MODNAME "CNATHelpPAST::DebugPrintCurrentStatus"
//=============================================================================
// CNATHelpPAST::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 CNATHelpPAST::DebugPrintCurrentStatus(void)
{
CBilink * pBilinkDevice;
CBilink * pBilinkRegisteredPort;
CDevice * pDevice;
CRegisteredPort * pRegisteredPort;
IN_ADDR inaddrTemp;
DWORD dwTemp;
SOCKADDR_IN * pasaddrinPrivate;
SOCKADDR_IN * pasaddrinRemotePASTPublic;
SOCKADDR_IN * pasaddrinLocalPASTPublic;
DPFX(DPFPREP, 3, "Object flags = 0x%08x", this->m_dwFlags);
pBilinkDevice = this->m_blDevices.GetNext();
while (pBilinkDevice != &this->m_blDevices)
{
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 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.");
}
if (pDevice->GetPASTClientID(TRUE) != 0)
{
inaddrTemp.S_un.S_addr = pDevice->GetRemotePASTServerAddressV4();
DPFX(DPFPREP, 3, " Remote ICS PAST server %u.%u.%u.%u, client ID is %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,
pDevice->GetPASTClientID(TRUE));
}
if (pDevice->HasLocalICSPASTServer())
{
DPFX(DPFPREP, 3, " Local ICS PAST server, client ID is %u.",
pDevice->GetPASTClientID(FALSE));
}
if (pDevice->HasLocalPFWOnlyPASTServer())
{
DPFX(DPFPREP, 3, " Local PFW-only PAST server, client ID is %u.",
pDevice->GetPASTClientID(FALSE));
}
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)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();
if ((pDevice->GetPASTClientID(TRUE) != 0) &&
(pDevice->IsPASTPublicAddressAvailable(TRUE)) &&
(! pRegisteredPort->IsPASTPortUnavailable(TRUE)))
{
if (pRegisteredPort->HasPASTPublicAddressesArray(TRUE))
{
pasaddrinRemotePASTPublic = pRegisteredPort->GetPASTPublicAddressesArray(TRUE);
}
else
{
pasaddrinRemotePASTPublic = NULL;
}
}
else
{
pasaddrinRemotePASTPublic = NULL;
}
if ((pDevice->GetPASTClientID(FALSE) != 0) &&
(pDevice->IsPASTPublicAddressAvailable(FALSE)) &&
(! pRegisteredPort->IsPASTPortUnavailable(FALSE)))
{
if (pRegisteredPort->HasPASTPublicAddressesArray(FALSE))
{
pasaddrinLocalPASTPublic = pRegisteredPort->GetPASTPublicAddressesArray(FALSE);
}
else
{
pasaddrinLocalPASTPublic = NULL;
}
}
else
{
pasaddrinLocalPASTPublic = 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 remote PAST information.
//
if (pasaddrinRemotePASTPublic != NULL)
{
DPFX(DPFPREP, 3, " \tRemote PAST = %u.%u.%u.%u:%u, lease %u expires at %u",
pasaddrinRemotePASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b1,
pasaddrinRemotePASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b2,
pasaddrinRemotePASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b3,
pasaddrinRemotePASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b4,
NTOHS(pasaddrinRemotePASTPublic[dwTemp].sin_port),
pRegisteredPort->GetPASTBindID(TRUE),
pRegisteredPort->GetPASTLeaseExpiration(TRUE));
}
else if (pRegisteredPort->GetPASTBindID(TRUE) != 0)
{
//
// We should have caught address availability up above.
//
DNASSERT(! pDevice->IsPASTPublicAddressAvailable(TRUE));
DPFX(DPFPREP, 3, " \tRemote PAST = no public address (lease %u expires at %u)",
pRegisteredPort->GetPASTBindID(TRUE),
pRegisteredPort->GetPASTLeaseExpiration(TRUE));
}
else if (pRegisteredPort->IsPASTPortUnavailable(TRUE))
{
DPFX(DPFPREP, 3, " \tRemote PAST = port unavailable");
}
else if (pDevice->GetPASTClientID(TRUE) != 0)
{
DPFX(DPFPREP, 3, " \tRemote PAST = not registered");
}
else
{
//
// No remote PAST server.
//
}
//
// Print local PAST information.
//
if (pasaddrinLocalPASTPublic != NULL)
{
DPFX(DPFPREP, 3, " \tLocal PAST = %u.%u.%u.%u:%u, lease %u expires at %u",
pasaddrinLocalPASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b1,
pasaddrinLocalPASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b2,
pasaddrinLocalPASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b3,
pasaddrinLocalPASTPublic[dwTemp].sin_addr.S_un.S_un_b.s_b4,
NTOHS(pasaddrinLocalPASTPublic[dwTemp].sin_port),
pRegisteredPort->GetPASTBindID(FALSE),
pRegisteredPort->GetPASTLeaseExpiration(FALSE));
}
else if (pRegisteredPort->GetPASTBindID(FALSE) != 0)
{
//
// We should have caught address availability up above.
//
DNASSERT(! pDevice->IsPASTPublicAddressAvailable(FALSE));
DPFX(DPFPREP, 3, " \tLocal PAST = no public address (lease %u expires at %u)",
pRegisteredPort->GetPASTBindID(FALSE),
pRegisteredPort->GetPASTLeaseExpiration(FALSE));
}
else if (pRegisteredPort->IsPASTPortUnavailable(FALSE))
{
DPFX(DPFPREP, 3, " \tLocal PAST = port unavailable");
}
else if (pDevice->GetPASTClientID(TRUE) != 0)
{
DPFX(DPFPREP, 3, " \tLocal PAST = not registered");
}
else
{
//
// No local PAST server.
//
}
}
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)
{
pRegisteredPort = REGPORT_FROM_DEVICE_BILINK(pBilinkRegisteredPort);
pasaddrinPrivate = pRegisteredPort->GetPrivateAddressesArray();
DNASSERT(pRegisteredPort->GetOwningDevice() == NULL);
DNASSERT(! (pRegisteredPort->HasPASTPublicAddressesArray(TRUE)));
DNASSERT(! (pRegisteredPort->HasPASTPublicAddressesArray(FALSE)));
DNASSERT(pRegisteredPort->GetPASTBindID(TRUE) == 0);
DNASSERT(pRegisteredPort->GetPASTBindID(FALSE) == 0);
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();
}
}
} // CNATHelpPAST::DebugPrintCurrentStatus
#endif // DBG
Reference in a new issue Copy permalink