able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/dns/dnsapi/asyncreg.c

6408 lines
158 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996-2001 Microsoft Corporation
Module Name:
asyncreg.c
Abstract:
Domain Name System (DNS) API
Client IP/PTR dynamic update.
Author:
Glenn Curtis (GlennC) Feb-16-1998
Revision History:
Jim Gilroy (jamesg) May\June 2001
- eliminate duplicate code
- simplify lines
- PTR reg only if forward successful
- alternate names
--*/
#include "local.h"
#include <netevent.h>
#define ENABLE_DEBUG_LOGGING 1
#include "logit.h"
//
// Flags for debugging for this module
//
#define DNS_DBG_DHCP DNS_DBG_UPDATE
#define DNS_DBG_DHCP2 DNS_DBG_UPDATE2
//
// Registry values
//
#define ADAPTER_NAME_CLASS "AdapterNameClass"
#define REGISTERED_ADDRS "RegisteredAddresses"
#define REGISTERED_ADDRS_COUNT "RegisteredAddressCount"
#define REGISTERED_NAME "RegisteredName"
//
// DCR_CLEANUP: tag these definitions to avoid collision
// with registry.h defs
//
#define REGISTERED_HOST_NAME "HostName"
#define REGISTERED_HOST_NAME_W L"HostName"
#define REGISTERED_DOMAIN_NAME "DomainName"
#define REGISTERED_DOMAIN_NAME_W L"DomainName"
#define SENT_UPDATE_TO_IP "SentUpdateToIp"
#define SENT_PRI_UPDATE_TO_IP "SentPriUpdateToIp"
#define REGISTERED_TTL "RegisteredTTL"
#define FLAGS "RegisteredFlags"
#define REGISTERED_SINCE_BOOT "RegisteredSinceBoot"
#define DNS_SERVER_ADDRS "DNSServerAddresses"
#define DNS_SERVER_ADDRS_COUNT "DNSServerAddressCount"
#define DEFAULT_REG_LOCATION "System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\DNSRegisteredAdapters"
#define DEFAULT_REG_LOCATION_WIN95 "System\\CurrentControlSet\\Services\\VxD\\MSTCP\\Parameters\\DNSRegisteredAdapters"
#define NT_INTERFACE_REG_LOCATION "System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\"
#define TCPIP_REG_LOCATION "System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
#define DYN_DNS_ROOT_CLASS "DynDRootClass"
#define BOOT_TIME "BootTime"
#define DHCPVER_WIN95 2
#define DHCPVER_WINNT 1
#define DHCPVER_UNINIT 0
#define FIRST_RETRY_INTERVAL 5*60 // 5 minutes
#define SECOND_RETRY_INTERVAL 10*60 // 10 minutes
#define FAILED_RETRY_INTERVAL 60*60 // 1 hour
#define ASYNC_INIT_CALLED() (g_dwVersion != DHCPVER_UNINIT)
#define CLEAR_ASYNC_INIT() g_dwVersion = DHCPVER_UNINIT ;
//
// Registry state flags
//
#define REGISTERED_FORWARD 0x00000001
#define REGISTERED_PRIMARY 0x00000002
#define REGISTERED_POINTER 0x00000004
//
// Update type
//
// Multiple types of updates for a given entry.
// These identify which type (which name) being updated.
//
typedef enum _UpType
{
UPTYPE_PRIMARY = 1,
UPTYPE_DOMAIN,
UPTYPE_ALTERNATE,
UPTYPE_PTR
}
UPTYPE, *PUPTYPE;
#define IS_UPTYPE_PRIMARY(UpType) ((UpType)==UPTYPE_PRIMARY)
#define IS_UPTYPE_DOMAIN(UpType) ((UpType)==UPTYPE_DOMAIN)
#define IS_UPTYPE_ALTERNATE(UpType) ((UpType)==UPTYPE_ALTERNATE)
#define IS_UPTYPE_PTR(UpType) ((UpType)==UPTYPE_PTR)
//
// On unjoin, deregistration wait no more than two minutes
// to clean up -- then just get outta Dodge
//
#if DBG
#define REMOVE_REGISTRATION_WAIT_LIMIT (0xffffffff)
#else
#define REMOVE_REGISTRATION_WAIT_LIMIT (120000) // 2 minutes in ms
#endif
//
// definition of client list element
//
#define DNS_SIG_TOP 0x123aa321
#define DNS_SIG_BOTTOM 0x321bb123
typedef struct _DnsUpdateEntry
{
LIST_ENTRY List;
DWORD SignatureTop;
PSTR AdapterName;
PSTR HostName;
PSTR PrimaryDomainName;
PSTR DomainName;
PSTR AlternateNames;
DWORD AlternateIndex;
DWORD HostAddrCount;
PREGISTER_HOST_ENTRY HostAddrs;
PIP_ARRAY DnsServerList;
IP_ADDRESS SentUpdateToIp;
IP_ADDRESS SentPriUpdateToIp;
DWORD TTL;
DWORD Flags;
BOOL fNewElement;
BOOL fFromRegistry;
BOOL fRemove;
BOOL fRegisteredPRI;
BOOL fRegisteredFWD;
BOOL fRegisteredALT;
BOOL fRegisteredPTR;
BOOL fDisableErrorLogging;
DWORD RetryCount;
DWORD RetryTime;
PREGISTER_HOST_STATUS pRegisterStatus;
DWORD SignatureBottom;
}
UPDATE_ENTRY, *PUPDATE_ENTRY;
//
// globals
//
//
// the behavior of the system at boot differs from when it is not at
// boot. At boot time we collect a bunch of requests and register them
// in one shot. One thread does this. After boot, we register them
// as requests come in, one at a time.
//
BOOL g_fAtBoot = TRUE;
BOOL g_fPurgeRegistrations = FALSE;
BOOL g_fPurgeRegistrationsInitiated = FALSE;
BOOL g_fRegistrationThreadRunning = FALSE;
BOOL g_fNoMoreDDNSUpdates = FALSE;
BOOL g_fShutdown = FALSE;
DWORD g_dwTime = 0; // To determine boot time or not
//
// The following global is used to eliminate multiple calls to GetVersion()
//
DWORD g_dwVersion = DHCPVER_UNINIT; // is 1 for winnt and 2 for win95
LIST_ENTRY g_RegistrationList;
HANDLE g_hStopEvent = NULL;
HANDLE g_hThreadDeadEvent = NULL;
HANDLE g_hNewItemEvent = NULL;
HANDLE g_hRegistrationThread = NULL;
BOOL g_fQuit = FALSE;
HKEY g_hKey = NULL;
DWORD g_dwBootTime = 60;
//
// Private heap
//
#define INITIAL_DDNS_HEAP (16*1024)
HANDLE g_DDNSHeap;
#define PHEAP_ALLOC_ZERO( s ) HeapAlloc( g_DDNSHeap, HEAP_ZERO_MEMORY, (s) )
#define PHEAP_ALLOC( s ) HeapAlloc( g_DDNSHeap, HEAP_ZERO_MEMORY, (s) )
#define PHEAP_FREE( p ) HeapFree( g_DDNSHeap, 0, (p) )
//
// Private protos
//
DNS_STATUS
AllocateUpdateEntry(
IN PSTR AdapterName,
IN PSTR HostName,
IN PSTR DomainName,
IN PSTR PrimaryDomainName,
IN PSTR AlternateNames,
IN DWORD HostAddrCount,
IN PREGISTER_HOST_ENTRY HostAddrs,
IN DWORD DnsServerCount,
IN PIP_ADDRESS DnsServerList,
IN IP_ADDRESS SentUpdateToIp,
IN IP_ADDRESS SentPriUpdateToIp,
IN DWORD TTL,
IN DWORD Flags,
IN DWORD RetryCount,
IN DWORD RetryTime,
IN PREGISTER_HOST_STATUS RegisterStatus,
OUT PUPDATE_ENTRY * ppUpdateEntry
);
VOID
FreeUpdateEntry(
IN OUT PUPDATE_ENTRY pUpdateEntry
);
VOID
FreeUpdateEntryList(
IN PLIST_ENTRY pUpdateEntry
);
DWORD
WINAPI
RegistrationThread(
VOID
);
VOID
WriteUpdateEntryToRegistry(
IN PUPDATE_ENTRY pUpdateEntry
);
PUPDATE_ENTRY
ReadUpdateEntryFromRegistry(
IN PSTR pszAdapterName
);
VOID
MarkAdapterAsPendingUpdate(
IN PSTR pAdapterName
);
DWORD
GetNextUpdateEntryFromList(
OUT PUPDATE_ENTRY * ppUpdateEntry,
OUT PDWORD pdwWaitTime
);
VOID
ProcessUpdateEntry(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN BOOL fPurgeMode
);
DNS_STATUS
ModifyAdapterRegistration(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN OUT PUPDATE_ENTRY pRegistryEntry,
IN PDNS_RECORD pUpdateRecord,
IN PDNS_RECORD pRegRecord,
IN BOOL fPrimaryDomain
);
VOID
ResetAdaptersInRegistry(
VOID
);
VOID
DeregisterUnusedAdapterInRegistry(
IN BOOL fPurgeMode
);
PDNS_RECORD
GetPreviousRegistrationInformation(
IN PUPDATE_ENTRY pUpdateEntry,
IN BOOL fPrimaryDomain,
OUT PIP_ADDRESS pServerIp
);
PDNS_RECORD
CreateDnsRecordSetUnion(
IN PDNS_RECORD pSet1,
IN PDNS_RECORD pSet2
);
#if 1 // DBG
VOID
LogHostEntries(
IN DWORD dwHostAddrCount,
IN PREGISTER_HOST_ENTRY pHostAddrs
);
#define DNSLOG_HOST_ENTRYS( a, b ) LogHostEntries( a, b )
#else
#define DNSLOG_HOST_ENTRYS( a, b )
#endif
#if 1 // DBG
VOID
LogPipAddress(
IN DWORD dwServerListCount,
IN PIP_ADDRESS pServers
);
#define DNSLOG_PIP_ADDRESS( a, b ) LogPipAddress( a, b )
#else
#define DNSLOG_PIP_ADDRESS( a, b )
#endif
#if 1 // DBG
VOID
LogPipArray(
IN PIP_ARRAY pServers
);
#define DNSLOG_PIP_ARRAY( a ) LogPipArray( a )
#else
#define DNSLOG_PIP_ARRAY( a )
#endif
DNS_STATUS
alertOrStartRegistrationThread(
VOID
);
VOID
registerUpdateStatus(
IN OUT PREGISTER_HOST_STATUS pRegStatus,
IN DNS_STATUS Status
);
VOID
enqueueUpdate(
IN OUT PUPDATE_ENTRY pUpdate
);
VOID
enqueueUpdateMaybe(
IN OUT PUPDATE_ENTRY pUpdate
);
PLIST_ENTRY
dequeueAndCleanupUpdate(
IN OUT PLIST_ENTRY pUpdateEntry
);
BOOL
searchForOldUpdateEntriesAndCleanUp(
IN PSTR pszAdapterName,
IN PUPDATE_ENTRY pUpdateEntry OPTIONAL,
IN BOOL fLookInRegistry
);
BOOL
compareUpdateEntries(
IN PUPDATE_ENTRY pUdapteEntry1,
IN PUPDATE_ENTRY pUpdateEntry2
);
BOOL
compareHostEntryAddrs(
IN PREGISTER_HOST_ENTRY Addrs1,
IN PREGISTER_HOST_ENTRY Addrs2,
IN DWORD Count
);
BOOL
compareServerLists(
IN PIP_ARRAY List1,
IN PIP_ARRAY List2
);
DWORD
GetRegistryValue(
HKEY KeyHandle,
PSTR ValueName,
DWORD ValueType,
LPBYTE BufferPtr
);
//
// Jim routines
//
VOID
LogRegistration(
IN PUPDATE_ENTRY pUpdateEntry,
IN DNS_STATUS Status,
IN DWORD UpType,
IN BOOL fDeregister,
IN IP4_ADDRESS DnsIp,
IN IP4_ADDRESS UpdateIp
);
VOID
AsyncLogUpdateEntry(
IN PSTR pszHeader,
IN PUPDATE_ENTRY pEntry
);
#define ASYNCREG_UPDATE_ENTRY(h,p) AsyncLogUpdateEntry(h,p)
VOID
DnsPrint_UpdateEntry(
IN PRINT_ROUTINE PrintRoutine,
IN PPRINT_CONTEXT PrintContext,
IN PSTR pszHeader,
IN PUPDATE_ENTRY pUpdateEntry
);
#if DBG
#define DnsDbg_UpdateEntry(h,p) DnsPrint_UpdateEntry(DnsPR,NULL,h,p)
#else
#define DnsDbg_UpdateEntry(h,p)
#endif
PDNS_RECORD
CreateForwardRecords(
IN PUPDATE_ENTRY pUpdateEntry,
IN BOOL fUsePrimaryName
);
PDNS_RECORD
CreatePtrRecord(
IN PSTR pszHostName,
IN PSTR pszDomainName,
IN IP4_ADDRESS Ip4Addr,
IN DWORD Ttl
);
VOID
UpdatePtrRecords(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN BOOL fAdd
);
VOID
SetUpdateStatus(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN DNS_STATUS Status,
IN BOOL fPrimary
);
//
// Public functions
//
DNS_STATUS
WINAPI
DnsAsyncRegisterInit(
IN PSTR pszRootRegKey
)
/*++
Routine Description:
Initialize asynchronous DNS registration.
Process must call (one time) before calling DnsAsyncRegisterHostAddrs.
Arguments:
None.
Return Value:
DNS or Win32 error code.
--*/
{
DWORD Status = ERROR_SUCCESS;
DWORD disposition;
DWORD disallowUpdate;
//
// Initialize debug logging funtion
//
ASYNCREG_INIT();
ASYNCREG_F1( "Inside function DnsAsyncRegisterInit" );
ASYNCREG_TIME();
ASYNCREG_F2( " pszRootRegKey value set to %s", pszRootRegKey );
//
// g_dwVersion is only set once and this function must be called exactly
// once until the corresponding TERM is called.
//
if ( ASYNC_INIT_CALLED() )
{
//
// we are calling this more than once!
//
DNS_ASSERT(FALSE) ;
return ERROR_INTERNAL_ERROR ;
}
else
{
DWORD sysVersion;
if ( g_fRegistrationThreadRunning )
{
//
// we encountered a previous problem while trying to stop
// the registration thread, do not allow any further update
// operations for this process!
//
DNS_ASSERT(FALSE) ;
return ERROR_INTERNAL_ERROR ;
}
sysVersion = GetVersion();
if ( sysVersion < 0x80000000 )
{
g_dwVersion = DHCPVER_WINNT;
}
else
{
g_dwVersion = DHCPVER_WIN95;
}
}
//
// if not supplied, use default
//
if ( !pszRootRegKey )
{
if ( g_dwVersion == DHCPVER_WINNT )
{
pszRootRegKey = DEFAULT_REG_LOCATION ;
}
else if ( g_dwVersion == DHCPVER_WIN95 )
{
pszRootRegKey = DEFAULT_REG_LOCATION_WIN95 ;
}
else
{
// we did not set g_dwVersion
DNS_ASSERT(FALSE) ;
pszRootRegKey = DEFAULT_REG_LOCATION ;
}
}
//
// Create private heap
//
g_DDNSHeap = HeapCreate( 0, INITIAL_DDNS_HEAP, 0 );
if ( g_DDNSHeap == NULL )
{
g_DDNSHeap = GetProcessHeap();
if ( g_DDNSHeap == NULL )
{
ASYNCREG_F1( "ERROR: DnsAsyncRegisterInit function failed to create heap" );
Status = DNS_ERROR_NO_MEMORY;
goto ErrorExit;
}
}
//
// get registration configuration info
// - just insure we have the latest copy
//
// DCR_FIX: when available get latest copy from resolver
// does not need to be done on init, may be done on call
//
Reg_ReadGlobalsEx( 0, NULL );
//
// Open the registry location used to store this info
//
// Note that Win95 does not support WideCharacter types
// The result is that we are forced to use RegCreateKeyExA for
// both
//
Status = RegCreateKeyExA(
HKEY_LOCAL_MACHINE,
pszRootRegKey,
0, // reserved
DYN_DNS_ROOT_CLASS,
REG_OPTION_NON_VOLATILE, // options
KEY_READ | KEY_WRITE, // desired access
NULL,
&g_hKey,
&disposition
);
if ( Status != NO_ERROR )
{
goto ErrorExit;
}
if ( !( g_hStopEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) )
{
Status = GetLastError();
goto ErrorExit;
}
if ( !( g_hThreadDeadEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) )
{
Status = GetLastError();
goto ErrorExit;
}
if ( !( g_hNewItemEvent = CreateEvent( NULL, TRUE, FALSE, NULL ) ) )
{
Status = GetLastError();
goto ErrorExit;
}
EnterCriticalSection( &g_RegistrationListCS );
InitializeListHead( &g_RegistrationList );
LeaveCriticalSection( &g_RegistrationListCS );
//
// the following call is needed for determining if we are still in
// boot time or not
//
g_dwTime = Dns_GetCurrentTimeInSeconds();
g_fQuit = FALSE;
g_fAtBoot = TRUE;
g_fPurgeRegistrations = FALSE;
g_fPurgeRegistrationsInitiated = FALSE;
g_fNoMoreDDNSUpdates = FALSE;
ResetAdaptersInRegistry();
return NO_ERROR;
ErrorExit:
if ( g_DDNSHeap &&
g_DDNSHeap != GetProcessHeap() )
{
HeapDestroy( g_DDNSHeap );
g_DDNSHeap = NULL;
}
if ( g_hStopEvent )
{
CloseHandle(g_hStopEvent);
g_hStopEvent = NULL;
}
if ( g_hThreadDeadEvent )
{
CloseHandle(g_hThreadDeadEvent);
g_hThreadDeadEvent = NULL;
}
if ( g_hNewItemEvent )
{
CloseHandle(g_hNewItemEvent);
g_hNewItemEvent = NULL;
}
if ( g_hKey )
{
RegCloseKey( g_hKey );
g_hKey = NULL;
}
CLEAR_ASYNC_INIT(); // reset this so we are no longer in use
return(Status);
}
DNS_STATUS
WINAPI
DnsAsyncRegisterTerm(
VOID
)
/*++
Routine Description:
Stop DNS registration. Shutdown DNS registration thread.
Initialization routine each process should call exactly on exit after
using DnsAsyncRegisterHostAddrs. This will signal to us that if our
thread is still trying to talk to a server, we'll stop trying.
Arguments:
None.
Return Value:
DNS or Win32 error code.
--*/
{
DWORD waitResult;
ASYNCREG_F1( "Inside function DnsAsyncRegisterTerm" );
ASYNCREG_TIME();
ASYNCREG_F1( "" );
if ( ASYNC_INIT_CALLED() )
{
if ( g_hStopEvent &&
g_fRegistrationThreadRunning )
{
SetEvent(g_hStopEvent);
waitResult = WaitForSingleObject( g_hThreadDeadEvent,
INFINITE );
switch ( waitResult )
{
case WAIT_OBJECT_0 :
ASYNCREG_F1( "DNSAPI.DLL: Registration thread signaled it was finished" );
ASYNCREG_F1( "" );
break;
case WAIT_TIMEOUT :
ASYNCREG_F1( "DNSAPI.DLL: Registration thread won't stop! " );
ASYNCREG_F1( "" );
DNS_ASSERT( FALSE );
break;
}
if ( g_fRegistrationThreadRunning )
{
ASYNCREG_F1( "DNSAPI.DLL: Registration thread wasn't stopped! " );
ASYNCREG_F1( "" );
DNS_ASSERT(FALSE) ;
CLEAR_ASYNC_INIT(); // reset this so we are no longer in use
return ERROR_INTERNAL_ERROR ;
}
}
EnterCriticalSection( &g_RegistrationThreadCS );
//
// Close the thread handles if they aren't already.
//
if ( g_hRegistrationThread )
{
CloseHandle( g_hRegistrationThread );
g_hRegistrationThread = NULL;
}
if ( g_hStopEvent )
{
CloseHandle(g_hStopEvent);
g_hStopEvent = NULL;
}
if ( g_hThreadDeadEvent )
{
CloseHandle(g_hThreadDeadEvent);
g_hThreadDeadEvent = NULL;
}
if ( g_hNewItemEvent )
{
CloseHandle(g_hNewItemEvent);
g_hNewItemEvent = NULL;
}
g_fQuit = TRUE;
if ( g_hKey )
{
RegCloseKey(g_hKey);
g_hKey = NULL;
}
LeaveCriticalSection( &g_RegistrationThreadCS );
Dns_TimeoutSecurityContextList( TRUE );
CLEAR_ASYNC_INIT(); // reset this so we are no longer in use
if ( g_DDNSHeap &&
g_DDNSHeap != GetProcessHeap() )
{
HeapDestroy( g_DDNSHeap );
g_DDNSHeap = NULL;
}
return NO_ERROR;
}
else
{
//
// This is being called more than once! Or the Init function has
// not yet been called!
//
DNS_ASSERT(FALSE) ;
return ERROR_INTERNAL_ERROR ;
}
}
DNS_STATUS
WINAPI
DnsRemoveRegistrations(
VOID
)
/*++
Routine Description:
Remove DNS host registrations for this machine.
This will be called by DHCP client on domain unjoin. Removes DNS
registrations for the box, then terminates the registration thread
to disable further registrations.
Registrations can only be reenabled by calling DnsAsyncRegisterInit()
again.
Arguments:
None.
Return Value:
ERROR_SUCCESS if successful.
ErrorCode on failure.
--*/
{
PLIST_ENTRY pListEntry;
PLIST_ENTRY pTopOfList;
ASYNCREG_F1( "Inside function DnsRemoveRegistrations" );
ASYNCREG_TIME();
DNSDBG( TRACE, ( "DnsRemoveRegistrations()\n" ));
DNS_ASSERT(ASYNC_INIT_CALLED()); // make sure init was called
if ( !ASYNC_INIT_CALLED() )
{
ASYNCREG_F1( "DnsAsyncRemoveRegistrations returning ERROR_SERVICE_NOT_ACTIVE" );
ASYNCREG_F1( "This is an error in DHCP client code, it forgot to call DnsAsyncRegisterInit()" );
return ERROR_SERVICE_NOT_ACTIVE;
}
//
// Set a global flag to disable any further adapter registration calls
//
g_fNoMoreDDNSUpdates = TRUE;
//
// Get the Registration list lock
//
EnterCriticalSection( &g_RegistrationListCS );
//
// Mark any and all adapter registration information in the registry
// as non-registered. These will be later interpreted as non-existant
// and deregistered by the RegistrationThread.
//
ResetAdaptersInRegistry();
//
// Walk the list of pending update entries and clear out the
// non-neccessary updates.
//
pTopOfList = &g_RegistrationList;
pListEntry = pTopOfList->Flink;
while ( pListEntry != pTopOfList )
{
if ( ((PUPDATE_ENTRY) pListEntry)->SignatureTop !=
DNS_SIG_TOP ||
((PUPDATE_ENTRY) pListEntry)->SignatureBottom !=
DNS_SIG_BOTTOM )
{
//
// Someone trashed our registration list!
//
DNS_ASSERT( FALSE );
//
// We'll reset it and try to move on . . .
//
InitializeListHead( &g_RegistrationList );
pTopOfList = &g_RegistrationList;
pListEntry = pTopOfList->Flink;
continue;
}
if ( !((PUPDATE_ENTRY) pListEntry)->fRemove )
{
//
// There is an update entry in the registration list
// that has not yet been processed. Since it is an
// add update, we'll blow it away.
//
pListEntry = dequeueAndCleanupUpdate( pListEntry );
continue;
}
else
{
((PUPDATE_ENTRY) pListEntry)->fNewElement = TRUE;
((PUPDATE_ENTRY) pListEntry)->fRegisteredFWD = FALSE;
((PUPDATE_ENTRY) pListEntry)->fRegisteredPRI = FALSE;
((PUPDATE_ENTRY) pListEntry)->fRegisteredPTR = FALSE;
((PUPDATE_ENTRY) pListEntry)->fDisableErrorLogging = FALSE;
((PUPDATE_ENTRY) pListEntry)->RetryCount = 2;
((PUPDATE_ENTRY) pListEntry)->RetryTime =
Dns_GetCurrentTimeInSeconds();
pListEntry = pListEntry->Flink;
}
}
LeaveCriticalSection( &g_RegistrationListCS );
g_fPurgeRegistrations = TRUE;
//
// start async registration thread if not started
//
alertOrStartRegistrationThread();
//
// wait for async registration thread to terminate
//
// however we'll bag it after a few minutes -- a robustness check
// to avoid long hang; Generally the machine will be rebooted
// so failure to cleanup the list and terminate is not critical;
// Registrations will have to be cleaned up by admin action or
// aging on the DNS server
//
#if DBG
{
DWORD waitResult;
waitResult = WaitForSingleObject(
g_hThreadDeadEvent,
REMOVE_REGISTRATION_WAIT_LIMIT );
if ( waitResult != WAIT_OBJECT_0 )
{
ASYNCREG_F1(
"ERROR: RemoveRegistration() wait expired before async thread\n"
"\ttermination!\n" );
}
}
#else
WaitForSingleObject( g_hThreadDeadEvent, REMOVE_REGISTRATION_WAIT_LIMIT );
#endif
return NO_ERROR;
}
DNS_STATUS
WINAPI
privateAsyncRegisterHostAddrs(
IN PSTR pszAdapterName,
IN PSTR pszHostName,
IN PREGISTER_HOST_ENTRY pHostAddrs,
IN DWORD dwHostAddrCount,
IN PIP4_ADDRESS pipDnsServerList,
IN DWORD dwDnsServerCount,
IN PSTR pszDomainName,
IN PREGISTER_HOST_STATUS pRegisterStatus,
IN DWORD dwTTL,
IN DWORD dwFlags
)
/*++
Routine Description:
Registers host address with DNS server.
This is called by DHCP client to register a particular IP.
This is the working UTF8 version of the
DnsAsyncRegisterHostAddrs() unicode routine actually called by
the DHCP client.
Arguments:
Return Value:
ERROR_SUCCESS if successful.
Error code on failure.
--*/
{
DWORD status = NO_ERROR;
PUPDATE_ENTRY pupEntry = NULL;
PSTR padapterDN = NULL;
PSTR pprimaryDN = NULL;
REG_UPDATE_INFO updateInfo;
BOOL fcleanupUpdateInfo = FALSE;
ASYNCREG_F1( "Inside function privateDnsAsyncRegisterHostAddrs, parameters are:" );
ASYNCREG_F2( " pszAdapterName : %s", pszAdapterName );
ASYNCREG_F2( " pszHostName : %s", pszHostName );
ASYNCREG_F2( " dwHostAddrCount : %d", dwHostAddrCount );
DNSLOG_HOST_ENTRYS( dwHostAddrCount, pHostAddrs );
ASYNCREG_F2( " dwDnsServerCount : %d", dwDnsServerCount );
if ( dwDnsServerCount && pipDnsServerList )
{
DNSLOG_PIP_ADDRESS( dwDnsServerCount, pipDnsServerList );
}
ASYNCREG_F2( " pszDomainName : %s", pszDomainName );
ASYNCREG_F2( " dwTTL : %d", dwTTL );
ASYNCREG_F2( " dwFlags : %d", dwFlags );
ASYNCREG_F1( "" );
ASYNCREG_TIME();
DNSDBG( TRACE, (
"privateAsyncRegisterHostAddrs()\n"
"\tadapter name = %s\n"
"\thost name = %s\n"
"\tadapter domain = %s\n"
"\tpHostAddrs = %p\n"
"\tAddrCount = %d\n"
"\tpDNSServers = %p\n"
"\tServerCount = %d\n"
"\tFlags = %08x\n",
pszAdapterName,
pszHostName,
pszDomainName,
pHostAddrs,
dwHostAddrCount,
pipDnsServerList,
dwDnsServerCount,
dwTTL ));
//
// first things first, need to inform underlying code that something
// has changed in the list of net adapters. Glenn is going to be called
// now so that he can re read the registry (or do any appropriate query)
// to now note the changed state.
//
if ( !(dwFlags & DYNDNS_DEL_ENTRY) )
{
DnsNotifyResolver( 0, NULL );
}
DNS_ASSERT(ASYNC_INIT_CALLED()); // make sure init was called
if ( !ASYNC_INIT_CALLED() )
{
DNSDBG( ANY, (
"ERROR: AsyncRegisterHostAddrs called before Init routine!!!\n" ));
status = ERROR_SERVICE_NOT_ACTIVE;
goto Exit;
}
if ( g_fNoMoreDDNSUpdates )
{
DNSDBG( ANY, (
"ERROR: AsyncRegisterHostAddrs called after RemoveRegistrations()!!!\n" ));
status = ERROR_SERVICE_NOT_ACTIVE;
goto Exit;
}
//
// Validate parameters
//
if ( !pszAdapterName || !(*pszAdapterName) )
{
DNSDBG( ANY, ( "ERROR: RegisterHostAddrs invalid adaptername!\n" ));
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
if ( ( !pszHostName || !(*pszHostName) ) &&
!( dwFlags & DYNDNS_DEL_ENTRY ) )
{
DNSDBG( ANY, ( "ERROR: RegisterHostAddrs invalid hostname!\n" ));
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
if ( dwHostAddrCount && !pHostAddrs )
{
DNSDBG( ANY, ( "ERROR: RegisterHostAddrs invalid host addresses!\n" ));
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
//
// get adapter update configuration
//
status = Reg_ReadUpdateInfo(
pszAdapterName,
& updateInfo );
if ( status != ERROR_SUCCESS )
{
DNSDBG( INIT, (
"Update registry read failure %d\n",
status ));
goto Exit;
}
fcleanupUpdateInfo = TRUE;
//
// skip WAN, if not doing WAN by policy
//
if ( (dwFlags & DYNDNS_REG_RAS) && !g_RegisterWanAdapters )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning NO_ERROR, because WAN adapter registrations are disabled" );
goto NoActionExit;
}
//
// policy DNS servers, override passed in list
//
if ( updateInfo.pDnsServerArray )
{
pipDnsServerList = updateInfo.pDnsServerArray->AddrArray;
dwDnsServerCount = updateInfo.pDnsServerArray->AddrCount;
}
//
// must have DNS servers to update adapter
// - don't update IP on one interface starting with DNS servers
// from another
//
if ( dwDnsServerCount && !pipDnsServerList )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning ERROR_INVALID_PARAMETER" );
ASYNCREG_F1( "ERROR_INVALID_PARAMETER reason 4" );
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
if ( ! dwDnsServerCount &&
! (dwFlags & DYNDNS_DEL_ENTRY) )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning NO_ERROR, because adapter does not have any DNS servers configured" );
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
//
// no update on adpater => delete outstanding updates
// note, we do before delete check below for event check
//
if ( !updateInfo.fRegistrationEnabled )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning NO_ERROR, because adapter is disabled" );
if ( pRegisterStatus )
{
pRegisterStatus->dwStatus = NO_ERROR;
SetEvent( pRegisterStatus->hDoneEvent );
}
if ( searchForOldUpdateEntriesAndCleanUp(
pszAdapterName,
NULL,
TRUE ) )
{
goto CheckThread;
}
status = NO_ERROR;
goto Exit;
//goto NoActionExit;
}
//
// delete update -- cleanup and delete
// - delete outstanding update in list
// - cleanup registry
// - do delete
//
if ( dwFlags & DYNDNS_DEL_ENTRY )
{
if ( searchForOldUpdateEntriesAndCleanUp(
pszAdapterName,
NULL,
TRUE ) )
{
goto CheckThread;
}
}
//
// limit IP registration count
// if doing registration and no addresses -- bail
//
if ( updateInfo.RegistrationMaxAddressCount < dwHostAddrCount )
{
dwHostAddrCount = updateInfo.RegistrationMaxAddressCount;
ASYNCREG_F2(
"Restricting adapter registration to the first %d addresses",
dwHostAddrCount );
}
if ( dwHostAddrCount == 0 )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning NO_ERROR" );
ASYNCREG_F1( "We are done, there are no addresses to register in DNS" );
goto NoActionExit;
}
//
// no\empty host name or zero IP => bogus
//
if ( !pszHostName ||
!(*pszHostName) ||
( dwHostAddrCount && ( pHostAddrs[0].Addr.ipAddr == 0 ) ) )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning ERROR_INVALID_PARAMETER" );
ASYNCREG_F1( "ERROR_INVALID_PARAMETER reason 5" );
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
//
// determine domain names to update
// - get PDN
// - adapter name
// - none if adapter name registration off
// - else check policy override
// - else name passed in
// - but treat empty as NULL
//
pprimaryDN = updateInfo.pszPrimaryDomainName;
if ( updateInfo.fRegisterAdapterName )
{
if ( updateInfo.pszAdapterDomainName )
{
padapterDN = updateInfo.pszAdapterDomainName;
}
else
{
padapterDN = pszDomainName;
}
if ( padapterDN &&
!(*padapterDN) )
{
padapterDN = NULL;
}
}
//
// no domains => nothing to register, we're done
//
if ( !padapterDN &&
!pprimaryDN )
{
ASYNCREG_F1( "privateAsyncRegisterHostAddrs returning ERROR_SUCCESS" );
ASYNCREG_F1( "no adapter name and no PDN" );
goto NoActionExit;
}
// if adapter name same as PDN -- just one update
if ( pprimaryDN &&
padapterDN &&
Dns_NameCompare_UTF8( pprimaryDN, padapterDN ) )
{
padapterDN = NULL;
}
// build update
status = AllocateUpdateEntry(
pszAdapterName,
pszHostName,
padapterDN,
pprimaryDN,
updateInfo.pmszAlternateNames,
dwHostAddrCount,
pHostAddrs,
dwDnsServerCount,
pipDnsServerList,
0, // No particular server IP at this time
0, // No particular server IP at this time
(dwTTL == 0xffffffff || dwTTL == 0)
? g_RegistrationTtl
: dwTTL,
dwFlags,
0,
Dns_GetCurrentTimeInSeconds(),
pRegisterStatus,
&pupEntry );
if ( status != NO_ERROR )
{
goto Exit;
}
//
// More WAN adapter hacks . . .
// If DDNS is not disabled for WAN adapters, then the default
// behavior for logging update events is disabled on these type
// adapters. There is a registry key that can turn on the logging
// of WAN adapter updates if such a user is interested. We configure
// those settings here.
//
if ( dwFlags & DYNDNS_REG_RAS )
{
//pupEntry->fDisableErrorLogging = !g_EnableWanDynamicUpdateEventLog;
pupEntry->fDisableErrorLogging = TRUE;
}
//
// When adding an entry to the registration list, first walk the
// list to look for any other updates for the same adapter.
// If there is already an add update in the list, blow it away.
// If there is already a delete update in the list with the same
// information, blow it away.
//
// Then put update into registration list.
//
searchForOldUpdateEntriesAndCleanUp(
pupEntry->AdapterName,
pupEntry,
FALSE );
//
// Since we are about to queue up an update entry for a given
// adapter, we need to mark any possible previous registration
// information that could be in the registry as pending. This
// marking will prevent the old data from being incorrectly
// queued as a disabled adapter if any errors are encountered
// on the update attempts. i.e failed update attempts on a given
// adapter should not be regarded as a disabled adapter that needs
// to have it's stale records cleaned up.
//
MarkAdapterAsPendingUpdate( pszAdapterName );
EnterCriticalSection( &g_RegistrationListCS );
InsertTailList( &g_RegistrationList, (PLIST_ENTRY) pupEntry );
LeaveCriticalSection( &g_RegistrationListCS );
CheckThread:
//
// DCR: do we need cleanup if thread is dead?
//
alertOrStartRegistrationThread();
status = NO_ERROR;
goto Exit;
NoActionExit:
//
// exit for no-action no-error exit
//
DNSDBG( UPDATE, (
"privateAsyncRegisterHostAddrs()\n"
"\tno-update no-error exit\n" ));
status = NO_ERROR;
if ( pRegisterStatus )
{
pRegisterStatus->dwStatus = NO_ERROR;
SetEvent( pRegisterStatus->hDoneEvent );
}
Exit:
//
// cleanup allocated update info
//
if ( fcleanupUpdateInfo )
{
Reg_FreeUpdateInfo(
&updateInfo,
FALSE // no free struct, it's on stack
);
}
DNSDBG( UPDATE, (
"Leaving privateAsyncRegisterHostAddrs()\n"
"\tstatus = %d\n",
status ));
return( status );
}
DNS_STATUS
WINAPI
DnsAsyncRegisterHostAddrs(
IN PWSTR pwsAdapterName,
IN PWSTR pwsHostName,
IN PREGISTER_HOST_ENTRY pHostAddrs,
IN DWORD dwHostAddrCount,
IN PIP_ADDRESS pipDnsServerList,
IN DWORD dwDnsServerCount,
IN PWSTR pwsDomainName,
IN PREGISTER_HOST_STATUS pRegisterStatus,
IN DWORD dwTTL,
IN DWORD dwFlags
)
/*++
Routine Description:
Registers host address with DNS server.
This is called by DHCP client to register a particular IP.
Arguments:
Return Value:
ERROR_SUCCESS if successful.
Error code on failure.
--*/
{
CHAR adapterName[2*MAX_PATH];
CHAR hostName[ DNS_MAX_LABEL_BUFFER_LENGTH ];
CHAR domainName[ DNS_MAX_NAME_BUFFER_LENGTH ];
PSTR padapterName = NULL;
PSTR phostName = NULL;
PSTR pdomainName = NULL;
DNSDBG( TRACE, (
"DnsAsyncRegisterHostAddrs()\n"
"\tadapter name = %S\n"
"\thost name = %S\n"
"\tadapter domain = %S\n"
"\tpHostAddrs = %p\n",
pwsAdapterName,
pwsHostName,
pwsDomainName,
pHostAddrs
));
//
// convert unicode strings to UTF8
//
if ( pwsAdapterName )
{
Dns_NameCopy(
adapterName,
NULL,
(PCHAR) pwsAdapterName,
0,
DnsCharSetUnicode,
DnsCharSetUtf8 );
padapterName = adapterName;
}
if ( pwsHostName )
{
Dns_NameCopy(
hostName,
NULL,
(PCHAR) pwsHostName,
0,
DnsCharSetUnicode,
DnsCharSetUtf8 );
phostName = hostName;
}
if ( pwsDomainName )
{
Dns_NameCopy(
domainName,
NULL,
(PCHAR) pwsDomainName,
0,
DnsCharSetUnicode,
DnsCharSetUtf8 );
pdomainName = domainName;
}
return privateAsyncRegisterHostAddrs(
padapterName,
phostName,
pHostAddrs,
dwHostAddrCount,
pipDnsServerList,
dwDnsServerCount,
pdomainName,
pRegisterStatus,
dwTTL,
dwFlags );
}
//
// Async registration utilities
//
PSTR
CreateNarrowStringCopy(
IN PSTR pString
)
{
PSTR pnew = NULL;
if ( pString )
{
pnew = HeapAlloc(
g_DDNSHeap,
0,
strlen(pString) + 1 );
if ( pnew )
{
strcpy( pnew, pString );
}
}
return pnew;
}
VOID
PrivateHeapFree(
IN PVOID pVal
)
{
if ( pVal )
{
HeapFree(
g_DDNSHeap,
0,
pVal );
}
}
DNS_STATUS
AllocateUpdateEntry(
IN PSTR AdapterName,
IN PSTR HostName,
IN PSTR DomainName,
IN PSTR PrimaryDomainName,
IN PSTR AlternateNames,
IN DWORD HostAddrCount,
IN PREGISTER_HOST_ENTRY HostAddrs,
IN DWORD DnsServerCount,
IN PIP_ADDRESS DnsServerList,
IN IP_ADDRESS SentUpdateToIp,
IN IP_ADDRESS SentPriUpdateToIp,
IN DWORD TTL,
IN DWORD Flags,
IN DWORD RetryCount,
IN DWORD RetryTime,
IN PREGISTER_HOST_STATUS Registerstatus,
OUT PUPDATE_ENTRY * ppUpdateEntry
)
/*++
Routine Description:
Create update info blob.
Arguments:
Return Value:
ERROR_SUCCESS if successful.
Error code on failure.
--*/
{
PUPDATE_ENTRY pupEntry = NULL;
DWORD status = ERROR_SUCCESS;
PSTR ptempDomain = DomainName;
PSTR ptempPrimaryDomain = PrimaryDomainName;
if ( ptempDomain && !(*ptempDomain) )
{
ptempDomain = NULL;
}
if ( ptempPrimaryDomain && !(*ptempPrimaryDomain) )
{
ptempPrimaryDomain = NULL;
}
if ( AdapterName && !(*AdapterName) )
{
AdapterName = NULL;
}
if ( HostName && !(*HostName) )
{
HostName = NULL;
}
DNSDBG( TRACE, ( "AllocateUpdateEntry()\n" ));
DNSDBG( DHCP, (
"AllocateUpdateEntry()\n"
"\tAdapterName = %s\n"
"\tHostName = %s\n"
"\tPrimaryDomain = %s\n"
"\tAdapterDomain = %s\n"
"\tAlternateNames = %s\n"
"\tHostAddrCount = %d\n"
"\tpHostAddrs = %p\n"
"\tTTL = %d\n"
"\tFlags = %08x\n"
"\tHostAddrCount = %d\n"
"\tTime = %d\n",
AdapterName,
HostName,
PrimaryDomainName,
DomainName,
AlternateNames,
HostAddrCount,
HostAddrs,
TTL,
Flags,
RetryTime
));
if ( !AdapterName ||
!HostName ||
!HostAddrCount )
{
ASYNCREG_F1( "AllocateUpdateEntry returing error : ERROR_INVALID_PARAMETER" );
ASYNCREG_F1( "" );
status = ERROR_INVALID_PARAMETER;
goto Exit;
}
pupEntry = PHEAP_ALLOC_ZERO( sizeof(UPDATE_ENTRY) );
if ( !pupEntry )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
InitializeListHead( &(pupEntry->List) );
pupEntry->SignatureTop = DNS_SIG_TOP;
pupEntry->SignatureBottom = DNS_SIG_BOTTOM;
//
// copy strings
//
pupEntry->AdapterName = CreateNarrowStringCopy( AdapterName );
if ( !pupEntry->AdapterName )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
if ( HostName )
{
pupEntry->HostName = CreateNarrowStringCopy( HostName );
if ( !pupEntry->HostName )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
}
if ( ptempDomain )
{
pupEntry->DomainName = CreateNarrowStringCopy( ptempDomain );
if ( !pupEntry->DomainName )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
}
if ( ptempPrimaryDomain )
{
pupEntry->PrimaryDomainName = CreateNarrowStringCopy( ptempPrimaryDomain );
if ( !pupEntry->PrimaryDomainName )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
}
if ( AlternateNames )
{
pupEntry->AlternateNames = MultiSz_Copy_A( AlternateNames );
if ( !pupEntry->AlternateNames )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
}
if ( HostAddrCount )
{
pupEntry->HostAddrs = PHEAP_ALLOC( sizeof(REGISTER_HOST_ENTRY) * HostAddrCount );
if ( !pupEntry->HostAddrs )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
memcpy(
pupEntry->HostAddrs,
HostAddrs,
sizeof(REGISTER_HOST_ENTRY) * HostAddrCount );
}
pupEntry->HostAddrCount = HostAddrCount;
if ( DnsServerCount )
{
pupEntry->DnsServerList = Dns_BuildIpArray( DnsServerCount,
DnsServerList );
if ( !pupEntry->DnsServerList )
{
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
}
pupEntry->SentUpdateToIp = SentUpdateToIp;
pupEntry->SentPriUpdateToIp = SentPriUpdateToIp;
pupEntry->pRegisterStatus = Registerstatus;
pupEntry->TTL = TTL;
pupEntry->Flags = Flags;
pupEntry->fRemove = Flags & DYNDNS_DEL_ENTRY ? TRUE : FALSE;
pupEntry->fNewElement = TRUE;
pupEntry->RetryCount = RetryCount;
pupEntry->RetryTime = RetryTime;
Exit:
if ( status!=ERROR_SUCCESS && pupEntry )
{
FreeUpdateEntry( pupEntry );
pupEntry = NULL;
}
*ppUpdateEntry = pupEntry;
return (status);
}
VOID
FreeUpdateEntry(
IN OUT PUPDATE_ENTRY pUpdateEntry
)
/*++
Routine Description:
Free update blob entry.
Arguments:
pUpdateEntry -- update entry blob to free
Return Value:
None
--*/
{
DNSDBG( TRACE, (
"FreeUpdateEntry( %p )\n",
pUpdateEntry ));
//
// deep free the update entry
//
if ( pUpdateEntry )
{
PrivateHeapFree( pUpdateEntry->AdapterName );
PrivateHeapFree( pUpdateEntry->HostName );
PrivateHeapFree( pUpdateEntry->DomainName );
PrivateHeapFree( pUpdateEntry->PrimaryDomainName );
PrivateHeapFree( pUpdateEntry->AlternateNames );
PrivateHeapFree( pUpdateEntry->HostAddrs );
// note that server list is created by Dns_BuildIpArray()
// (uses dnslib heap) so must free by Dns_Free()
Dns_Free( pUpdateEntry->DnsServerList );
PrivateHeapFree( pUpdateEntry );
}
}
VOID
FreeUpdateEntryList(
IN OUT PLIST_ENTRY pUpdateEntry
)
/*++
Routine Description:
Free all updates in update list.
Arguments:
pUpdateEntry -- update list head
Return Value:
None
--*/
{
PLIST_ENTRY pentry = NULL;
DNSDBG( TRACE, (
"FreeUpdateEntryList( %p )\n",
pUpdateEntry ));
while ( !IsListEmpty( pUpdateEntry ) )
{
pentry = RemoveHeadList( pUpdateEntry );
if ( pentry )
{
FreeUpdateEntry( (PUPDATE_ENTRY) pentry );
}
}
}
DWORD
WINAPI
RegistrationThread(
VOID
)
/*++
Routine Description:
Asynchronous registration thread.
This thread does actual updates, and stays alive until they are
completed, allowing registration API calls to return.
This thread is created at boot time as soon as the first register
request comes in. The thread simply waits for a certain amount of time
given by boot time or be signaled by DnsAsyncRegisterHostEntries.
This function collects all the requests and does the appropriate
aggregation of requests and sends off the modify/add/delete commands
to the DNS Server. When the call is successful, it makes a note of
this in the registry
Arguments:
None
Return Value:
ERROR_SUCCESS if successful.
ErrorCode on failure.
--*/
{
DWORD waitResult;
PUPDATE_ENTRY pupEntry = NULL;
HANDLE handle[2];
DWORD status = NO_ERROR;
DWORD dwWaitTime = g_dwBootTime;
DWORD rcode = 0;
if ( !g_hKey )
{
return(ERROR_INVALID_PARAMETER);
}
//
// Note that this thread is running by setting a global flag
//
g_fRegistrationThreadRunning = TRUE;
//
// for use at a subsequent WFMO
//
handle[0] = g_hStopEvent;
handle[1] = g_hNewItemEvent;
//
// Check to see this thread is at boot time or not.
// At boot time we simply wait for BOOT_TIME, otherwise move on.
// The global g_fAtBoot is not protected by critical section because
// only one thread accesses it at any time.
//
if ( !g_fAtBoot || g_fPurgeRegistrations )
{
dwWaitTime = 0;
}
dwWaitTime *= 1000;
waitResult = WaitForSingleObject( g_hStopEvent,
dwWaitTime );
switch( waitResult )
{
case WAIT_OBJECT_0 :
//
// kill event
//
goto CleanUpAndDie;
case WAIT_TIMEOUT :
//
// Means we can start processing the elements in the queue now
//
break;
}
//
// loop through update list, doing any update
// - do new updates
// - do retries that have reached retry time
// - when list empty, terminate thread
//
while ( 1 )
{
// if empty list and not-booting or purging
// => get out
EnterCriticalSection( &g_RegistrationListCS );
if ( IsListEmpty( &g_RegistrationList ) &&
! g_fAtBoot &&
! g_fPurgeRegistrations )
{
LeaveCriticalSection( &g_RegistrationListCS );
break;
}
//
// get "updateable" update from list (if any)
// 0 -- new update, or retry update ready
// 1 -- retry update, not yet ready
// -1 -- list empty
//
rcode = GetNextUpdateEntryFromList( &pupEntry,
&dwWaitTime );
if ( &g_RegistrationList == (PLIST_ENTRY) pupEntry )
{
DNS_ASSERT(&g_RegistrationList != (PLIST_ENTRY) pupEntry);
LeaveCriticalSection( &g_RegistrationListCS );
goto CleanUpAndDie;
}
LeaveCriticalSection( &g_RegistrationListCS );
//
// rcode==0 -- new update in list
//
// DCR_QUESTION: not clear that this terminates updates in the
// purging updates case
//
if ( rcode == 0 )
{
//
// See if we have been signaled to stop running . . .
//
waitResult = WaitForMultipleObjects(
2,
handle,
FALSE,
1 ); // a very small wait
switch( waitResult )
{
case WAIT_OBJECT_0 :
//
// kill event
//
FreeUpdateEntry( pupEntry );
goto CleanUpAndDie;
default :
//
// Keep going, process next item in registration list
//
break;
}
ProcessUpdateEntry( pupEntry, g_fPurgeRegistrations );
continue;
}
//
// rcode==1 -- update needs retry
//
else if ( rcode == 1 &&
! g_fAtBoot &&
! g_fPurgeRegistrations )
{
waitResult = WaitForMultipleObjects(
2,
handle,
FALSE,
dwWaitTime );
switch( waitResult )
{
case WAIT_OBJECT_0 :
//
// kill event
//
goto CleanUpAndDie;
case WAIT_OBJECT_0 + 1 :
//
// new item has been added to registration list
//
break;
case WAIT_TIMEOUT :
//
// process next item in registration list
//
break;
}
continue;
}
//
// rcode == (-1) -- list empty
// OR
// rcode == (1) -- reties, not booting or purging
//
else
{
if ( !g_fAtBoot && !g_fPurgeRegistrations )
{
goto CleanUpAndDie;
}
if ( g_fPurgeRegistrationsInitiated )
{
goto CleanUpAndDie;
}
if ( g_fPurgeRegistrations )
{
ResetAdaptersInRegistry();
}
//
// Remove any adapter configurations from the registry
// that were not processed. Do this by attempting to
// remove the related DNS records from the DNS server(s).
//
DeregisterUnusedAdapterInRegistry( g_fPurgeRegistrations );
if ( g_fPurgeRegistrations )
{
g_fPurgeRegistrationsInitiated = TRUE;
}
g_fAtBoot = FALSE;
continue;
}
}
CleanUpAndDie :
ASYNCREG_F1( "RegistrationThread - terminating" );
ASYNCREG_F1( "" );
EnterCriticalSection( &g_RegistrationThreadCS );
EnterCriticalSection( &g_RegistrationListCS );
g_fQuit = TRUE;
g_fAtBoot = FALSE;
g_fPurgeRegistrations = FALSE;
g_fPurgeRegistrationsInitiated = FALSE;
//
// Blow away the registration list
//
FreeUpdateEntryList( &g_RegistrationList );
InitializeListHead( &g_RegistrationList );
LeaveCriticalSection( &g_RegistrationListCS );
//
// Blow away any cached security handles
//
Dns_TimeoutSecurityContextList( TRUE );
//
// Close the thread handle.
//
if ( g_hRegistrationThread )
{
CloseHandle( g_hRegistrationThread );
g_hRegistrationThread = NULL;
}
//
// Note that this thread is NOT running by setting a global flag
//
g_fRegistrationThreadRunning = FALSE;
//
// Now signal that we've finished
//
ASYNCREG_F1( "RegistrationThread - Signaling ThreadDeadEvent" );
ASYNCREG_F1( "" );
// clear purge incase of later restart
//g_fPurgeRegistrations = FALSE;
// currently must go through Init routine which clears this flag
SetEvent( g_hThreadDeadEvent );
LeaveCriticalSection( &g_RegistrationThreadCS );
ASYNCREG_F1( "RegistrationThread - Finished" );
ASYNCREG_F1( "" );
return NO_ERROR;
}
VOID
WriteUpdateEntryToRegistry(
IN PUPDATE_ENTRY pUpdateEntry
)
{
HKEY hAdapterKey = NULL;
DWORD disposition;
DWORD status = ERROR_SUCCESS;
DWORD dwRegistered = 0;
DWORD dwFlags = 0;
WCHAR uName[ DNS_MAX_NAME_BUFFER_LENGTH ];
ASYNCREG_UPDATE_ENTRY(
"Inside function WriteUpdateEntryToRegistry",
pUpdateEntry );
DNSDBG( TRACE, (
"WriteUpdateEntryToRegistry( %p )\n",
pUpdateEntry ));
//
// write only add update
//
// remove's should not be non-volatile as don't know anything
// about state when come back up
//
if ( !pUpdateEntry->fRemove )
{
if ( pUpdateEntry->fRegisteredFWD )
{
dwFlags |= REGISTERED_FORWARD;
}
if ( pUpdateEntry->fRegisteredPRI )
{
dwFlags |= REGISTERED_PRIMARY;
}
if ( pUpdateEntry->fRegisteredPTR )
{
dwFlags |= REGISTERED_POINTER;
}
if ( dwFlags )
{
dwRegistered = 1;
}
status = RegCreateKeyExA ( g_hKey,
pUpdateEntry->AdapterName,
0,
ADAPTER_NAME_CLASS,
REG_OPTION_NON_VOLATILE, // options
KEY_READ | KEY_WRITE, // desired access
NULL,
&hAdapterKey,
&disposition );
if ( status )
{
goto Exit;
}
Dns_Utf8ToUnicode( pUpdateEntry->HostName,
strlen( pUpdateEntry->HostName ),
uName,
256 );
status = RegSetValueExW( hAdapterKey,
REGISTERED_HOST_NAME_W,
0,
REG_SZ,
(LPBYTE)uName,
( wcslen( uName )
+ 1 ) * sizeof(WCHAR) );
if ( status )
{
goto Exit;
}
if ( pUpdateEntry->DomainName &&
pUpdateEntry->fRegisteredFWD )
{
Dns_Utf8ToUnicode( pUpdateEntry->DomainName,
strlen( pUpdateEntry->DomainName ),
uName,
256 );
status = RegSetValueExW( hAdapterKey,
REGISTERED_DOMAIN_NAME_W,
0,
REG_SZ,
(LPBYTE)uName,
( wcslen( uName )
+ 1 ) * sizeof(WCHAR) );
if ( status )
{
goto Exit;
}
}
else
{
status = RegSetValueExA( hAdapterKey,
REGISTERED_DOMAIN_NAME,
0,
REG_SZ,
(LPBYTE)"",
( strlen( "" )
+ 1 ) * sizeof(CHAR) );
if ( status )
{
goto Exit;
}
}
if ( pUpdateEntry->PrimaryDomainName &&
pUpdateEntry->fRegisteredPRI )
{
Dns_Utf8ToUnicode( pUpdateEntry->PrimaryDomainName,
strlen( pUpdateEntry->PrimaryDomainName ),
uName,
256 );
status = RegSetValueExW( hAdapterKey,
PRIMARY_DOMAIN_NAME,
0,
REG_SZ,
(LPBYTE)uName,
( wcslen( uName )
+ 1 ) * sizeof(WCHAR) );
if ( status )
{
goto Exit;
}
}
else
{
status = RegSetValueExA( hAdapterKey,
PRIMARY_DOMAIN_NAME_A,
0,
REG_SZ,
(LPBYTE)"",
( strlen( "" )
+ 1 ) * sizeof(CHAR) );
if ( status )
{
goto Exit;
}
}
RegSetValueExA( hAdapterKey,
SENT_UPDATE_TO_IP,
0,
REG_DWORD,
(LPBYTE)&pUpdateEntry->SentUpdateToIp,
sizeof(DWORD) );
RegSetValueExA( hAdapterKey,
SENT_PRI_UPDATE_TO_IP,
0,
REG_DWORD,
(LPBYTE)&pUpdateEntry->SentPriUpdateToIp,
sizeof(DWORD) );
RegSetValueExA( hAdapterKey,
REGISTERED_TTL,
0,
REG_DWORD,
(LPBYTE)&pUpdateEntry->TTL,
sizeof(DWORD) );
RegSetValueExA( hAdapterKey,
FLAGS,
0,
REG_DWORD,
(LPBYTE)&dwFlags,
sizeof(DWORD) );
//
// ignore error on the last two. Non critical
//
status = RegSetValueExA( hAdapterKey,
REGISTERED_ADDRS,
0,
REG_BINARY,
(LPBYTE) pUpdateEntry->HostAddrs,
pUpdateEntry->HostAddrCount *
sizeof(REGISTER_HOST_ENTRY) );
if ( status )
{
goto Exit;
}
status = RegSetValueExA( hAdapterKey,
REGISTERED_ADDRS_COUNT,
0,
REG_DWORD,
(LPBYTE)&pUpdateEntry->HostAddrCount,
sizeof(DWORD) );
if ( status )
{
goto Exit;
}
status = RegSetValueExA( hAdapterKey,
REGISTERED_SINCE_BOOT,
0,
REG_DWORD,
(LPBYTE)&dwRegistered,
sizeof(DWORD) );
if ( status )
{
goto Exit;
}
if ( pUpdateEntry->DnsServerList )
{
status = RegSetValueExA( hAdapterKey,
DNS_SERVER_ADDRS,
0,
REG_BINARY,
(LPBYTE) pUpdateEntry ->
DnsServerList ->
AddrArray,
pUpdateEntry ->
DnsServerList ->
AddrCount *
sizeof(IP_ADDRESS) );
if ( status )
{
goto Exit;
}
status = RegSetValueExA( hAdapterKey,
DNS_SERVER_ADDRS_COUNT,
0,
REG_DWORD,
(LPBYTE) &pUpdateEntry ->
DnsServerList ->
AddrCount,
sizeof(DWORD) );
if ( status )
{
goto Exit;
}
}
else
{
DWORD count = 0;
status = RegSetValueExA( hAdapterKey,
DNS_SERVER_ADDRS_COUNT,
0,
REG_DWORD,
(LPBYTE) &count,
sizeof(DWORD) );
if ( status )
{
goto Exit;
}
status = RegSetValueExA( hAdapterKey,
DNS_SERVER_ADDRS,
0,
REG_BINARY,
(LPBYTE) NULL,
0 );
if ( status )
{
goto Exit;
}
}
RegCloseKey( hAdapterKey );
return;
}
Exit:
//
// remove or failure -- kill adapter key
//
RegDeleteKey( g_hKey, pUpdateEntry->AdapterName );
if ( hAdapterKey )
{
RegCloseKey( hAdapterKey );
}
}
PUPDATE_ENTRY
ReadUpdateEntryFromRegistry(
IN PSTR AdapterName
)
{
PREGISTER_HOST_ENTRY pHostAddrs = NULL;
PUPDATE_ENTRY pupEntry = NULL;
DWORD status = NO_ERROR;
PSTR pregHostName = NULL;
PSTR pregDomain = NULL;
PSTR pregPrimary = NULL;
IP_ADDRESS ipSentUpdateTo = 0;
IP_ADDRESS ipSentPriUpdateTo = 0;
DWORD dwTTL = 0;
DWORD dwFlags = 0;
DWORD dwHostAddrCount = 0;
DWORD dwServerAddrCount = 0;
PIP_ADDRESS pServerList = NULL;
PSTR pdomain;
PSTR pprimary;
HKEY hAdapterKey = NULL;
DWORD dwType;
DWORD dwBytesRead = MAX_PATH -1;
DWORD dwBufferSize = 2048;
BOOL fRegFWD = FALSE;
BOOL fRegPRI = FALSE;
BOOL fRegPTR = FALSE;
DNSDBG( TRACE, (
"ReadUpdateEntryFromRegistry( %s )\n",
AdapterName ));
//
// implementation note
//
// two different heaps here
// - g_DDNSHeap specific for this module
// - general DnsApi heap which all the stuff which is
// allocated by GetRegistryValue() is using
//
// GetRegistryValue() uses ALLOCATE_HEAP() (general dnsapi heap)
// so all the stuff it creates must be freed by FREE_HEAP()
//
pHostAddrs = (PREGISTER_HOST_ENTRY) PHEAP_ALLOC( dwBufferSize );
if ( !pHostAddrs )
{
goto Exit;
}
pServerList = (PIP_ADDRESS) PHEAP_ALLOC( dwBufferSize );
if ( !pServerList )
{
goto Exit;
}
status = RegOpenKeyEx(
g_hKey,
AdapterName,
0,
KEY_ALL_ACCESS,
&hAdapterKey );
if ( status )
{
hAdapterKey = NULL;
goto Exit;
}
//
// read each value in turn
//
// note that registry flags are not the API flags but the
// flags denoting successful registration
status = GetRegistryValue(
hAdapterKey,
FLAGS,
REG_DWORD,
(PBYTE)&dwFlags );
if ( status )
{
goto Exit;
}
fRegPRI = !!( dwFlags & REGISTERED_PRIMARY );
fRegFWD = !!( dwFlags & REGISTERED_FORWARD );
fRegPTR = !!( dwFlags & REGISTERED_POINTER );
status = GetRegistryValue(
hAdapterKey,
REGISTERED_HOST_NAME,
REG_SZ,
(PBYTE)&pregHostName );
if ( status )
{
goto Exit;
}
if ( fRegPRI )
{
status = GetRegistryValue(
hAdapterKey,
PRIMARY_DOMAIN_NAME_A,
REG_SZ,
(LPBYTE)&pregPrimary );
if ( status )
{
goto Exit;
}
}
if ( fRegFWD )
{
status = GetRegistryValue(
hAdapterKey,
REGISTERED_DOMAIN_NAME,
REG_SZ,
(LPBYTE)&pregDomain );
if ( status )
{
goto Exit;
}
}
status = GetRegistryValue(
hAdapterKey,
SENT_UPDATE_TO_IP,
REG_DWORD,
(LPBYTE)&ipSentUpdateTo );
if ( status )
{
goto Exit;
}
status = GetRegistryValue(
hAdapterKey,
SENT_PRI_UPDATE_TO_IP,
REG_DWORD,
(LPBYTE)&ipSentPriUpdateTo );
if ( status )
{
goto Exit;
}
status = GetRegistryValue(
hAdapterKey,
REGISTERED_TTL,
REG_DWORD,
(LPBYTE)&dwTTL );
if ( status )
{
goto Exit;
}
status = GetRegistryValue(
hAdapterKey,
REGISTERED_ADDRS_COUNT,
REG_DWORD,
(LPBYTE)&dwHostAddrCount );
if ( status )
{
goto Exit;
}
dwBytesRead = dwBufferSize;
status = RegQueryValueEx(
hAdapterKey,
REGISTERED_ADDRS,
0,
&dwType,
(LPBYTE)pHostAddrs,
&dwBytesRead );
if( status == ERROR_MORE_DATA )
{
PrivateHeapFree( pHostAddrs );
pHostAddrs = (PREGISTER_HOST_ENTRY) PHEAP_ALLOC( dwBytesRead );
if ( !pHostAddrs )
{
goto Exit;
}
status = RegQueryValueEx(
hAdapterKey,
REGISTERED_ADDRS,
0,
&dwType,
(LPBYTE)pHostAddrs,
&dwBytesRead );
}
if ( status )
{
goto Exit;
}
if ( dwBytesRead/sizeof(REGISTER_HOST_ENTRY) < dwHostAddrCount )
{
goto Exit;
}
status = GetRegistryValue(
hAdapterKey,
DNS_SERVER_ADDRS_COUNT,
REG_DWORD,
(LPBYTE)&dwServerAddrCount );
if ( status )
{
dwServerAddrCount = 0;
}
if ( dwServerAddrCount )
{
dwBytesRead = dwBufferSize;
status = RegQueryValueEx(
hAdapterKey,
DNS_SERVER_ADDRS,
0,
&dwType,
(LPBYTE)pServerList,
&dwBytesRead );
if ( status == ERROR_MORE_DATA )
{
PHEAP_FREE( pServerList );
pServerList = (PIP_ADDRESS) PHEAP_ALLOC( dwBytesRead );
if ( !pServerList )
{
goto Exit;
}
status = RegQueryValueEx(
hAdapterKey,
DNS_SERVER_ADDRS,
0,
&dwType,
(LPBYTE)pServerList,
&dwBytesRead );
}
if ( status )
{
goto Exit;
}
if ( dwBytesRead/sizeof(IP_ADDRESS) < dwServerAddrCount )
{
goto Exit;
}
}
else
{
pServerList = NULL;
}
//
// validate domain names non-empty
//
pdomain = pregDomain;
if ( pdomain &&
strlen( pdomain ) == 0 )
{
pdomain = NULL;
}
pprimary = pregPrimary;
if ( pprimary &&
strlen( pprimary ) == 0 )
{
pprimary = NULL;
}
status = AllocateUpdateEntry(
AdapterName,
pregHostName,
pdomain,
pprimary,
NULL, // no alternate names
dwHostAddrCount,
pHostAddrs,
dwServerAddrCount,
pServerList,
ipSentUpdateTo,
ipSentPriUpdateTo,
dwTTL,
( fRegPTR ) ? DYNDNS_REG_PTR : 0,
0,
Dns_GetCurrentTimeInSeconds(),
NULL,
&pupEntry );
if ( status )
{
DNS_ASSERT( pupEntry == NULL );
pupEntry = NULL;
goto Exit;
}
pupEntry->fFromRegistry = TRUE;
pupEntry->fRegisteredFWD = fRegFWD;
pupEntry->fRegisteredPRI = fRegPRI;
pupEntry->fRegisteredPTR = fRegPTR;
Exit:
//
// cleanup
// - close registry
// - dump local data
//
if ( hAdapterKey )
{
RegCloseKey( hAdapterKey );
}
PrivateHeapFree( pHostAddrs );
PrivateHeapFree( pServerList );
FREE_HEAP( pregHostName );
FREE_HEAP( pregDomain );
FREE_HEAP( pregPrimary );
// set return value
ASYNCREG_UPDATE_ENTRY(
"Leaving ReadUpdateEntryFromRegistry:",
pupEntry );
IF_DNSDBG( TRACE )
{
DnsDbg_UpdateEntry(
"Leave ReadUpdateEntryFromRegistry():",
pupEntry );
}
return pupEntry;
}
VOID
MarkAdapterAsPendingUpdate(
IN PSTR AdapterName
)
{
DWORD status = NO_ERROR;
DWORD dwRegistered = 1;
HKEY hAdapterKey = NULL;
DNSDBG( TRACE, (
"MarkAdapterAsPendingUpdate( %s )\n",
AdapterName ));
status = RegOpenKeyEx(
g_hKey,
AdapterName,
0,
KEY_ALL_ACCESS,
&hAdapterKey );
if ( status )
{
return;
}
RegSetValueExA(
hAdapterKey,
REGISTERED_SINCE_BOOT,
0,
REG_DWORD,
(LPBYTE) &dwRegistered,
sizeof(DWORD) );
RegCloseKey( hAdapterKey );
}
DWORD
GetNextUpdateEntryFromList(
OUT PUPDATE_ENTRY * ppUpdateEntry,
OUT PDWORD pdwWaitTime
)
/*++
Routine Description:
Dequeue update entry from update list.
//
// If a new entry is found, set ppUpdateEntry to point
// to it and return 0 (prefering deletes over adds).
//
// If there are only retry entries in the list, and one or more
// have reached their retry time interval, then set ppUpdateEntry
// to point to the one with the least retry time and return 0.
//
// If there are only retry entries in the list, but none have
// yet reached there retry time interval then set pdwWaitTime to
// the time remaining to wait for the entry with the least retry
// interval and return 1 (WAIT)
//
// If there are no more records in list, return (-1)
//
Arguments:
Return Value:
(0) -- returning entry in ppUpdateEntry
- new entry if found
- retry which is past its retry time
(1) -- list has only retries which have NOT reached retry time
- set pdwWaitTime to remaining time to first retry
(-1) -- list is empty
--*/
{
PLIST_ENTRY pentry;
PLIST_ENTRY plistHead;
PLIST_ENTRY pleastWaitEntry = NULL;
DWORD minWaitTime = 0xffffffff;
INT waitTime;
ASYNCREG_F1( "Inside function GetNextUpdateEntryFromList" );
DNSDBG( TRACE, ( "GetNextUpdateEntryFromList()" ));
if ( IsListEmpty( &g_RegistrationList ) )
{
*ppUpdateEntry = NULL;
*pdwWaitTime = 0;
ASYNCREG_F1( "GetNextUpdateEntryFromList - returning (NO_MORE_RECORDS)" );
ASYNCREG_F1( "" );
return(-1);
}
//
// Loop through list looking for a new delete related update entry.
// If so, remove it from list and return it.
//
plistHead = &g_RegistrationList;
pentry = plistHead->Flink;
while ( pentry != plistHead )
{
if ( ((PUPDATE_ENTRY) pentry)->fRemove &&
((PUPDATE_ENTRY) pentry)->fNewElement )
{
RemoveEntryList( pentry );
*ppUpdateEntry = (PUPDATE_ENTRY) pentry;
*pdwWaitTime = 0;
ASYNCREG_F1( "GetNextUpdateEntryFromList - returning new remove entry (SUCCESS)" );
ASYNCREG_F1( "" );
return 0;
}
else
{
pentry = pentry->Flink;
}
}
//
// Now loop through list looking for any new update.
// If so, remove it from list and return it.
//
plistHead = &g_RegistrationList;
pentry = plistHead->Flink;
while ( pentry != plistHead )
{
if ( ((PUPDATE_ENTRY) pentry)->fNewElement )
{
RemoveEntryList( pentry );
*ppUpdateEntry = (PUPDATE_ENTRY) pentry;
*pdwWaitTime = 0;
ASYNCREG_F1( "GetNextUpdateEntryFromList - returning new entry (SUCCESS)" );
ASYNCREG_F1( "" );
return 0;
}
else
{
pentry = pentry->Flink;
}
}
//
// There are no new update entries to process, now need to
// loop through list looking for the next possible update to
// wait on. If wait time has expired return it, otherwise
// set pdwWaitTime to time remaining and return 1.
//
plistHead = &g_RegistrationList;
pentry = plistHead->Flink;
while ( pentry != plistHead )
{
if ( ((PUPDATE_ENTRY) pentry)->RetryTime <
minWaitTime )
{
minWaitTime = ((PUPDATE_ENTRY) pentry)->RetryTime;
pleastWaitEntry = pentry;
}
pentry = pentry->Flink;
}
waitTime = (INT) ( minWaitTime - Dns_GetCurrentTimeInSeconds() );
if ( waitTime > 0 )
{
waitTime *= 1000;
*ppUpdateEntry = NULL;
*pdwWaitTime = (DWORD) waitTime;
ASYNCREG_F1( "GetNextUpdateEntryFromList - returning (WAIT)" );
ASYNCREG_F1( "" );
return 1;
}
else
{
RemoveEntryList( pleastWaitEntry );
*ppUpdateEntry = (PUPDATE_ENTRY) pleastWaitEntry;
*pdwWaitTime = 0;
ASYNCREG_F1( "GetNextUpdateEntryFromList - returning wait entry (SUCCESS)" );
ASYNCREG_F1( "" );
return 0;
}
}
//
// Update entry processing
//
DNS_STATUS
DoRemoveUpdate(
IN OUT PUPDATE_ENTRY pRemoveEntry,
IN OUT PDNS_RECORD pRemoveRecord,
IN UPTYPE UpType
)
/*++
Routine Description:
Do a remove update.
Helper routine for DoUpdate().
Routine simply avoids duplicate code as this is called
with both registry entry and with update entry.
Arguments:
pRemoveEntry -- entry to remove, from update or registry
pRemoveRecord -- record to remove
fPrimary -- TRUE for primary update; FALSE otherwise
Return Value:
DNS or Win32 error code.
--*/
{
DNS_STATUS status = NO_ERROR;
DNSDBG( TRACE, (
"DoRemoveUpdate( %p, %p, %d )\n",
pRemoveEntry,
pRemoveRecord,
UpType
));
//
// try remove
// - don't track failure, this is a one shot deal before
// adapter goes down
//
status = DnsModifyRecordsInSet_UTF8(
NULL, // no add records
pRemoveRecord, // delete records
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no context handle
(PIP4_ARRAY) pRemoveEntry->DnsServerList,
NULL // reserved
);
SetUpdateStatus(
pRemoveEntry,
status,
UpType );
if ( IS_UPTYPE_PRIMARY(UpType) )
{
LogRegistration(
pRemoveEntry,
status,
UpType,
TRUE, // deregistration
0, // default server IP
0 // default update IP
);
}
#if 0
// doing entire update entry PTR dereg at once
// in ProcessUpdate() once done
//
// deregister the PTR records
//
if ( (pRemoveEntry->Flags & DYNDNS_REG_PTR) &&
g_RegisterReverseLookup )
{
UpdatePtrRecords(
pRemoveEntry,
FALSE // remove records
);
}
#endif
return status;
}
DNS_STATUS
ModifyAdapterRegistration(
IN PUPDATE_ENTRY pUpdateEntry,
IN PUPDATE_ENTRY pRegistryEntry,
IN PDNS_RECORD pUpdateRecord,
IN PDNS_RECORD pRegRecord,
IN BOOL fPrimaryDomain
)
{
DNS_STATUS status = NO_ERROR;
PDNS_RECORD potherRecords = NULL;
PDNS_RECORD pNewUpdateRecord = NULL;
PDNS_RECORD pNewRegRecord = NULL;
IP_ADDRESS serverIp = 0;
DNSDBG( TRACE, (
"ModifyAdapterRegistration()\n"
"\tpUpdateEntry = %p\n"
"\tpUpdateRecords = %p\n"
"\tpRegistryEntry = %p\n"
"\tpRegistryRecords = %p\n"
"\tfPrimary = %d\n",
pUpdateEntry,
pRegistryEntry,
pUpdateRecord,
pRegRecord,
fPrimaryDomain ));
//
// multi-adapter registration test
//
// check other adapters for registrations on the same name
// if found, include in updates
//
potherRecords = GetPreviousRegistrationInformation(
pUpdateEntry,
fPrimaryDomain,
&serverIp );
if ( potherRecords )
{
IP_ARRAY ipArray;
DNSDBG( DHCP, (
"Have registry update data for other adapters!\n"
"\tCreating combined update record sets.\n" ));
ipArray.AddrCount = 1;
ipArray.AddrArray[0] = serverIp;
pNewUpdateRecord = CreateDnsRecordSetUnion(
pUpdateRecord,
potherRecords );
if ( pRegRecord
&&
Dns_NameCompare_UTF8(
pRegRecord->pName,
pUpdateRecord->pName )
&&
CompareMultiAdapterSOAQueries(
pUpdateRecord->pName,
pUpdateEntry->DnsServerList,
pRegistryEntry->DnsServerList ) )
{
pNewRegRecord = CreateDnsRecordSetUnion(
pRegRecord,
potherRecords );
}
else
{
if ( pRegRecord )
{
//
// The record found in the registry for this adapter
// is stale and should be deleted. Otherwise we set the
// current list of records to only that of potherRecords.
//
ASYNCREG_F1( "DoUpdateForPrimaryName - Found stale registry entry:" );
ASYNCREG_F2( " Name : %s", pRegRecord->pName );
ASYNCREG_F1( " Address :" );
DNSLOG_PIP_ADDRESS( 1, &(pRegRecord->Data.A.IpAddress) );
ASYNCREG_F1( "" );
ASYNCREG_F1( " Calling DnsRemoveRecords_UTF8 to get rid of it" );
status = DnsModifyRecordsInSet_UTF8(
NULL, // no add records
pRegRecord, // delete records
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no context handle
(PIP4_ARRAY) pRegistryEntry->DnsServerList,
NULL // reserved
);
ASYNCREG_F3( " DnsRemoveRecords_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
pNewRegRecord = potherRecords;
potherRecords = NULL;
}
if ( !pNewUpdateRecord || !pNewRegRecord )
{
DNSDBG( ANY, (
"ERROR: failed to build combined record set for update!\n" ));
status = DNS_ERROR_NO_MEMORY;
goto Exit;
}
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsModifyRecordSet_UTF8" );
ASYNCREG_F1( " (current update + previous records)" );
if ( serverIp )
{
//
// DCR: just do replace from the start
//
ASYNCREG_F1( " (sending update to specific server)" );
DNSLOG_PIP_ARRAY( &ipArray );
status = DnsModifyRecordSet_UTF8(
NULL, // no creds
pNewRegRecord, // previous set
pNewUpdateRecord, // new set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
&ipArray );
ASYNCREG_F3( " DnsModifyRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
if ( status == DNS_ERROR_RCODE_SERVER_FAILURE ||
status == ERROR_TIMEOUT )
{
goto SendUpdate1;
}
if ( status == DNS_ERROR_NOT_UNIQUE &&
g_RegistrationOverwritesInConflict )
{
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsReplaceRecordSet_UTF8" );
ASYNCREG_F1( " (current update + previous records)" );
status = DnsReplaceRecordSetUTF8(
pNewUpdateRecord, // replace set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no security context
(PIP4_ARRAY) &ipArray, // DNS servers
NULL // reserved
);
ASYNCREG_F3( " DnsReplaceRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
}
else
{
SendUpdate1 :
ASYNCREG_F1( " (sending update to adapter server list)" );
DNSLOG_PIP_ARRAY( pUpdateEntry->DnsServerList );
status = DnsModifyRecordSet_UTF8(
NULL, // no creds
pNewRegRecord, // previous set
pNewUpdateRecord, // new set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
pUpdateEntry->DnsServerList
);
ASYNCREG_F3( " DnsModifyRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
if ( status == DNS_ERROR_NOT_UNIQUE &&
g_RegistrationOverwritesInConflict )
{
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsReplaceRecordSet_UTF8" );
ASYNCREG_F1( " (current update + previous records)" );
status = DnsReplaceRecordSetUTF8(
pNewUpdateRecord, // replace set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no security context
(PIP4_ARRAY) pUpdateEntry->DnsServerList,
NULL // reserved
);
ASYNCREG_F3( " DnsReplaceRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
}
}
else
{
if ( pRegRecord
&&
Dns_NameCompare_UTF8(
pRegRecord->pName,
pUpdateRecord->pName )
&&
CompareMultiAdapterSOAQueries(
pUpdateRecord->pName,
pUpdateEntry->DnsServerList,
pRegistryEntry->DnsServerList ) )
{
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsModifyRecordSet_UTF8" );
ASYNCREG_F1( " (current update record only)" );
status = DnsModifyRecordSet_UTF8(
NULL, // no creds
pRegRecord, // previous set
pUpdateRecord, // new set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
pUpdateEntry->DnsServerList );
ASYNCREG_F3( " DnsModifyRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
else
{
if ( pRegRecord )
{
//
// The record found in the registry for this adapter
// is stale and should be deleted. Otherwise we set the
// current list of records to only that of potherRecords.
//
ASYNCREG_F1( "DoUpdateForPrimaryName - Found stale registry entry:" );
ASYNCREG_F2( " Name : %s", pRegRecord->pName );
ASYNCREG_F1( " Address :" );
DNSLOG_PIP_ADDRESS( 1, &(pRegRecord->Data.A.IpAddress) );
ASYNCREG_F1( "" );
ASYNCREG_F1( " Calling DnsRemoveRecords_UTF8 to get rid of it" );
status = DnsModifyRecordsInSet_UTF8(
NULL, // no add records
pRegRecord, // delete records
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no context handle
pRegistryEntry->DnsServerList,
NULL // reserved
);
ASYNCREG_F3( " DnsRemoveRecords_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsAddRecordSet_UTF8" );
status = DnsAddRecordSet_UTF8(
NULL, // no creds
pUpdateRecord,
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
pUpdateEntry->DnsServerList );
ASYNCREG_F3( " DnsAddRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
if ( status == DNS_ERROR_NOT_UNIQUE &&
g_RegistrationOverwritesInConflict )
{
ASYNCREG_F1( "ModifyAdapterRegistration - Calling DnsReplaceRecordSet_UTF8" );
ASYNCREG_F1( " (current update record only)" );
status = DnsReplaceRecordSetUTF8(
pUpdateRecord, // replace set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no security context
(PIP4_ARRAY) pUpdateEntry->DnsServerList,
NULL // reserved
);
ASYNCREG_F3( " DnsReplaceRecordSet_UTF8 returned: 0x%x\n\t%s",
status,
Dns_StatusString( status ) );
}
}
Exit:
Dns_RecordListFree( potherRecords );
Dns_RecordListFree( pNewUpdateRecord );
Dns_RecordListFree( pNewRegRecord );
return status;
}
DNS_STATUS
DoModifyUpdate(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN OUT PDNS_RECORD pUpdateRecord,
IN PUPDATE_ENTRY pRegistryEntry, OPTIONAL
IN OUT PDNS_RECORD pRegRecord, OPTIONAL
IN UPTYPE UpType
)
/*++
Routine Description:
Standard modify registration.
Helper routine for DoUpdate().
This handles modify for typical non-remove case.
- Forward records updated
- Old PTR removed if new address.
- New PTR added (or name modified).
Arguments:
pUpdateEntry -- update entry
pUpdateRecord -- records for update
pRegistryEntry -- registry entry
pRegRecord -- records from registry entry
fPrimary -- TRUE if update for primary domain name
FALSE for adapter domain name
Return Value:
DNS or Win32 error code.
--*/
{
DNS_STATUS status = NO_ERROR;
IP4_ADDRESS ip = 0;
BOOL fregistered = FALSE;
DNSDBG( TRACE, (
"DoModifyUpdate()\n"
"\tUpdateEntry = %p\n"
"\tUpType = %d\n",
pUpdateEntry,
UpType ));
DNS_ASSERT( pUpdateEntry != NULL );
DNS_ASSERT( pUpdateRecord != NULL );
//
// do forward registration modify
//
status = ModifyAdapterRegistration(
pUpdateEntry, // add
pRegistryEntry, // remove
pUpdateRecord,
pRegRecord,
IS_UPTYPE_PRIMARY(UpType)
);
//
// save success info
//
SetUpdateStatus(
pUpdateEntry,
status,
UpType );
//
// PTR records
//
// deregister previous PTR registration
// - registry entry indicates previous registration
// - not the same address as current (otherwise it's an update)
//
// note: adding new registration takes place in DoUpdate() once
// ALL forward updates are complete
//
if ( g_RegisterReverseLookup )
{
if ( pRegistryEntry &&
(pRegistryEntry->Flags & DYNDNS_REG_PTR) &&
!compareUpdateEntries( pRegistryEntry, pUpdateEntry ) )
{
UpdatePtrRecords(
pRegistryEntry,
FALSE // remove previous PTR
);
}
}
//
// Log registration status in EventLog
//
if ( pUpdateEntry->RetryCount == 2 ||
status == DNS_ERROR_RCODE_NOT_IMPLEMENTED ||
status == DNS_ERROR_RCODE_REFUSED )
{
LogRegistration(
pUpdateEntry,
status,
UpType,
FALSE, // registration
0, // default server IP
0 // default update IP
);
}
DNSDBG( TRACE, (
"Leave DoModifyUpdate() => %d\n",
status ));
return status;
}
DNS_STATUS
DoUpdate(
IN OUT PUPDATE_ENTRY pRegistryEntry OPTIONAL,
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN UPTYPE UpType
)
/*++
Routine Description:
Do update for a particular name.
Helper routine for ProcessUpdate().
Handles one name, called separately for AdapaterDomainName and
PrimaryDomainName.
Arguments:
pUpdateEntry -- update entry
pRegistryEntry -- registry entry
fPrimary -- TRUE if update for primary domain name
FALSE for adapter domain name
Return Value:
DNS or Win32 error code.
--*/
{
PDNS_RECORD prrRegistry = NULL;
PDNS_RECORD prrUpdate = NULL;
DNS_STATUS status = NO_ERROR;
ASYNCREG_UPDATE_ENTRY(
"DoUpdate() -- UpdateEntry:",
pUpdateEntry );
ASYNCREG_UPDATE_ENTRY(
"DoUpdate() -- RegistryEntry:",
pRegistryEntry );
IF_DNSDBG( TRACE )
{
DnsDbg_UpdateEntry(
"DoUpdate() -- UpdateEntry:",
pUpdateEntry );
DnsDbg_UpdateEntry(
"DoUpdate() -- RegistryEntry:",
pRegistryEntry );
}
DNS_ASSERT( pUpdateEntry != NULL );
//
// build records from update entrys
//
prrUpdate = CreateForwardRecords(
pUpdateEntry,
UpType
);
if ( ! prrUpdate )
{
DNSDBG( TRACE, (
"No forward records created for update entry (%p) for update type %d!",
pUpdateEntry,
UpType ));
return NO_ERROR;
}
if ( pRegistryEntry )
{
prrRegistry = CreateForwardRecords(
pRegistryEntry,
UpType
);
DNS_ASSERT( !IS_UPTYPE_ALTERNATE(UpType) || prrRegistry==NULL );
}
//
// remove?
// - remove previous registry entry if exists
// - remove update entry
//
if ( pUpdateEntry->fRemove )
{
if ( prrRegistry )
{
// we don't lookup registry entries on fRemove updates, so i
// don't see how we'd get here
DNS_ASSERT( FALSE );
DoRemoveUpdate(
pRegistryEntry,
prrRegistry,
UpType );
}
status = DoRemoveUpdate(
pUpdateEntry,
prrUpdate,
UpType );
}
//
// add\modify registration
//
else
{
status = DoModifyUpdate(
pUpdateEntry,
prrUpdate,
pRegistryEntry,
prrRegistry,
UpType
);
}
//
// cleanup records
//
Dns_RecordListFree( prrRegistry );
Dns_RecordListFree( prrUpdate );
return status;
}
BOOL
IsQuickRetryError(
IN DNS_STATUS Status
)
{
return( Status != NO_ERROR
&&
( Status == DNS_ERROR_RCODE_REFUSED ||
Status == DNS_ERROR_RCODE_SERVER_FAILURE ||
Status == DNS_ERROR_TRY_AGAIN_LATER ||
Status == DNS_ERROR_NO_DNS_SERVERS ||
Status == WSAECONNREFUSED ||
Status == WSAETIMEDOUT ||
Status == ERROR_TIMEOUT ) );
}
VOID
ProcessUpdateEntry(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN BOOL fPurgeMode
)
/*++
Routine Description:
Main routine processing an update.
Arguments:
pUpdateEntry -- update entry to execute
note: this routine frees pUpdateEntry when complete
fPurgeMode -- TRUE if purging update queue
Return Value:
DNS or Win32 error code.
--*/
{
DNS_STATUS status;
DNS_STATUS statusPri = NO_ERROR;
DNS_STATUS statusAdp = NO_ERROR;
DNS_STATUS statusAlt = NO_ERROR;
PUPDATE_ENTRY pregEntry = NULL;
DWORD retryInterval;
DNSDBG( TRACE, (
"ProcessUpdateEntry( %p, purge=%d )\n",
pUpdateEntry,
fPurgeMode ));
IF_DNSDBG( TRACE )
{
DnsDbg_UpdateEntry(
"Enter ProcessUpdateEntry():",
pUpdateEntry );
}
//
// add (not remove)
//
if ( !pUpdateEntry->fRemove )
{
// no adds during purge mode
if ( fPurgeMode )
{
goto Cleanup;
}
//
// get any prior update info from registry
//
// if hostname change, then delete on prior update
//
pregEntry = ReadUpdateEntryFromRegistry( pUpdateEntry->AdapterName );
if ( pregEntry )
{
if ( ! Dns_NameCompare_UTF8(
pregEntry->HostName,
pUpdateEntry->HostName ) )
{
DNSDBG( TRACE, (
"Prior registry data with non-matching hostname!\n"
"\tqueuing delete for prior data and doing standard add.\n" ));
//
// Create delete update entry for registry information and
// add to registration list. Clear registry in the mean time.
//
pregEntry->fRemove = TRUE;
pregEntry->Flags |= DYNDNS_DEL_ENTRY;
pregEntry->fRegisteredFWD = FALSE;
pregEntry->fRegisteredPRI = FALSE;
pregEntry->fRegisteredPTR = FALSE;
if ( fPurgeMode )
{
pregEntry->RetryCount = 2;
pregEntry->RetryTime = Dns_GetCurrentTimeInSeconds();
}
//
// Clear registry key for adapter
//
WriteUpdateEntryToRegistry( pregEntry );
//
// Put update in registration list
// - clear registry entry PTR so not used below
//
enqueueUpdate( pregEntry );
pregEntry = NULL;
// fall through to do standard add update with no prior data
}
}
}
//
// do updates
// - primary
// - adapter domain
// - alternate name
//
if ( ! pUpdateEntry->fRegisteredFWD )
{
statusAdp = DoUpdate(
pregEntry,
pUpdateEntry,
UPTYPE_DOMAIN
);
}
if ( ! pUpdateEntry->fRegisteredPRI )
{
statusPri = DoUpdate(
pregEntry,
pUpdateEntry,
UPTYPE_PRIMARY // primary update
);
}
if ( ! pUpdateEntry->fRegisteredALT )
{
PSTR pname = pUpdateEntry->AlternateNames;
DNS_STATUS statusTmp;
DWORD count = 0;
//
// update each alternate name in MULTISZ
// - must set index in update blob to use correct name in
// record building
// - any failure fails ALT names
//
statusAlt = NO_ERROR;
while ( pname )
{
pUpdateEntry->AlternateIndex = count++;
DNSDBG( DHCP, (
"Update with alternate name %s\n"
"\tindex = %d\n",
pname,
count-1 ));
statusTmp = DoUpdate(
NULL, // not saving alternate info in registry
// pregEntry,
pUpdateEntry,
UPTYPE_ALTERNATE
);
if ( statusTmp != NO_ERROR )
{
statusAlt = statusTmp;
}
pname = MultiSz_NextString_A( pname );
}
pUpdateEntry->fRegisteredALT = (statusAlt == NO_ERROR);
}
//
// update PTRs once forward done
//
// doing this outside DoUpdate() because will ONLY do PTRs
// for forwards that succeed, so want all forward updates
// completed first; but this also helps in that it combines
// the reverse updates
//
if (( pUpdateEntry->Flags & DYNDNS_REG_PTR) && g_RegisterReverseLookup)
{
UpdatePtrRecords(
pUpdateEntry,
!pUpdateEntry->fRemove // add update
);
}
//
// write completed update info to registry
//
if ( !pUpdateEntry->fRemove )
{
WriteUpdateEntryToRegistry( pUpdateEntry );
}
//
// setup retry on failure
//
if ( statusPri != NO_ERROR )
{
status = statusPri;
goto ErrorRetry;
}
else if ( statusAdp != NO_ERROR )
{
status = statusAdp;
goto ErrorRetry;
}
else if ( statusAlt != NO_ERROR )
{
status = statusAlt;
goto ErrorRetry;
}
//
// successful update
// - signal update event (if given)
// - cleanup if remove or purging
// - requeue if add
//
if ( pUpdateEntry->pRegisterStatus )
{
registerUpdateStatus( pUpdateEntry->pRegisterStatus, ERROR_SUCCESS );
}
if ( pUpdateEntry->fRemove || fPurgeMode || g_fPurgeRegistrations )
{
DNSDBG( TRACE, (
"Leaving ProcessUpdate() => successful remove\\purge.\n" ));
goto Cleanup;
}
else
{
pUpdateEntry->fNewElement = FALSE;
pUpdateEntry->fRegisteredFWD = FALSE;
pUpdateEntry->fRegisteredPRI = FALSE;
pUpdateEntry->fRegisteredPTR = FALSE;
pUpdateEntry->RetryCount = 0;
pUpdateEntry->fDisableErrorLogging = TRUE;
pUpdateEntry->RetryTime = Dns_GetCurrentTimeInSeconds() +
g_RegistrationRefreshInterval;
if ( pUpdateEntry->pRegisterStatus )
{
pUpdateEntry->pRegisterStatus = NULL;
}
enqueueUpdate( pUpdateEntry );
DNSDBG( TRACE, (
"Leaving ProcessUpdate( %p ) => successful => requeued.\n",
pUpdateEntry ));
pUpdateEntry = NULL;
goto Cleanup;
}
ErrorRetry:
// failures during purge mode are not retried
// just free entry and bail
if ( fPurgeMode || g_fPurgeRegistrations )
{
DNSDBG( TRACE, (
"Leaving ProcessUpdate() => failed purging.\n" ));
goto Cleanup;
}
//
// set retry time
//
// less than two retries and more transient errors
// => short retry
//
// third failure or longer term error code
// => push retry back to an hour
//
if ( pUpdateEntry->RetryCount < 2
&&
( IsQuickRetryError(statusAdp) ||
IsQuickRetryError(statusPri) ||
IsQuickRetryError(statusAlt) ) )
{
pUpdateEntry->RetryCount++;
retryInterval = (pUpdateEntry->RetryCount == 1)
? FIRST_RETRY_INTERVAL
: SECOND_RETRY_INTERVAL;
}
else
{
retryInterval = FAILED_RETRY_INTERVAL;
pUpdateEntry->RetryCount = 0;
pUpdateEntry->fDisableErrorLogging = TRUE;
if ( pUpdateEntry->pRegisterStatus )
{
registerUpdateStatus( pUpdateEntry->pRegisterStatus, status );
pUpdateEntry->pRegisterStatus = NULL;
}
}
pUpdateEntry->fNewElement = FALSE;
pUpdateEntry->RetryTime = Dns_GetCurrentTimeInSeconds() + retryInterval;
//
// requeue
// - entry dumped if another update for adapter already queued
//
enqueueUpdateMaybe( pUpdateEntry );
DNSDBG( TRACE, (
"Leaving ProcessUpdate( %p ) => failed => requeued.\n",
pUpdateEntry ));
pUpdateEntry = NULL;
Cleanup:
//
// cleanup
// - registry entry
// - update entry if not requeued
//
FreeUpdateEntry( pregEntry );
FreeUpdateEntry( pUpdateEntry );
}
VOID
ResetAdaptersInRegistry(
VOID
)
{
DWORD retVal = NO_ERROR;
DWORD status = NO_ERROR;
CHAR szName[ MAX_PATH ];
HKEY hAdapterKey = NULL;
DWORD dwType;
INT index;
DWORD dwBytesRead = MAX_PATH -1;
DWORD dwRegistered = 0;
ASYNCREG_F1( "Inside function ResetAdaptersInRegistry" );
ASYNCREG_F1( "" );
index = 0;
while ( !retVal )
{
dwBytesRead = MAX_PATH - 1;
retVal = RegEnumKeyEx ( g_hKey,
index,
szName,
&dwBytesRead,
NULL,
NULL,
NULL,
NULL );
if ( retVal )
{
goto Exit;
}
status = RegOpenKeyEx( g_hKey,
szName,
0,
KEY_ALL_ACCESS,
&hAdapterKey );
if ( status )
{
goto Exit;
}
//
// Found an adapter in the registry, set registered since
// boot to FALSE.
//
status = RegSetValueExA( hAdapterKey,
REGISTERED_SINCE_BOOT,
0,
REG_DWORD,
(LPBYTE)&dwRegistered, // 0 - False
sizeof(DWORD) );
if ( status )
{
goto Exit;
}
RegCloseKey( hAdapterKey );
hAdapterKey = NULL;
index++;
}
Exit :
if ( hAdapterKey )
{
RegCloseKey( hAdapterKey );
}
}
VOID
DeregisterUnusedAdapterInRegistry(
IN BOOL fPurgeMode
)
{
DWORD retVal = NO_ERROR;
DWORD status = NO_ERROR;
CHAR szName[MAX_PATH];
HKEY hAdapterKey = NULL;
INT index;
DWORD dwBytesRead = MAX_PATH -1;
DWORD dwRegistered = 0;
PUPDATE_ENTRY pregEntry = NULL;
ASYNCREG_F1( "Inside function DeregisterUnusedAdapterInRegistry" );
ASYNCREG_F1( "" );
index = 0;
while ( !retVal )
{
dwBytesRead = MAX_PATH - 1;
retVal = RegEnumKeyEx ( g_hKey,
index,
szName,
&dwBytesRead,
NULL,
NULL,
NULL,
NULL );
if ( retVal != ERROR_SUCCESS )
{
goto Exit;
}
status = RegOpenKeyEx( g_hKey,
szName,
0,
KEY_ALL_ACCESS,
&hAdapterKey );
if ( status != ERROR_SUCCESS )
{
goto Exit;
}
//
// Found an adapter in the registry, read registered since
// boot value to see if FALSE.
//
status = GetRegistryValue( hAdapterKey,
REGISTERED_SINCE_BOOT,
REG_DWORD,
(LPBYTE)&dwRegistered );
RegCloseKey( hAdapterKey );
hAdapterKey = NULL;
if ( status != ERROR_SUCCESS )
{
goto Exit;
}
if ( dwRegistered == 0 &&
(pregEntry = ReadUpdateEntryFromRegistry( szName )) )
{
if ( pregEntry->fRegisteredFWD ||
pregEntry->fRegisteredPRI ||
pregEntry->fRegisteredPTR )
{
ASYNCREG_F2( "Found unused adapter: %s", szName );
ASYNCREG_F1( "Removing entry from registry and adding" );
ASYNCREG_F1( "delete entry to registration list" );
//
// This adapter has not been configured since boot time,
// create delete update entry for registry information
// and add to registration list. Clear registry in the
// mean time.
//
pregEntry->fRemove = TRUE;
pregEntry->Flags |= DYNDNS_DEL_ENTRY;
pregEntry->fRegisteredFWD = FALSE;
pregEntry->fRegisteredPRI = FALSE;
pregEntry->fRegisteredPTR = FALSE;
if ( fPurgeMode )
{
pregEntry->RetryCount = 2;
pregEntry->RetryTime = Dns_GetCurrentTimeInSeconds();
}
//
// Clear registry key for adapter
//
WriteUpdateEntryToRegistry( pregEntry );
index--;
//
// Put update in registration list
//
enqueueUpdate( pregEntry );
PulseEvent( g_hNewItemEvent );
}
else
{
ASYNCREG_F2( "Found unused adapter: %s", szName );
ASYNCREG_F1( "This adapter is still pending an update, ignoring . . ." );
//
// We are only just starting to try to update this entry.
// Do not queue up a delete for it since the entry shows
// that no records have been registered anyhow.
//
FreeUpdateEntry( pregEntry );
pregEntry = NULL;
}
}
index++;
}
Exit :
if ( hAdapterKey )
{
RegCloseKey( hAdapterKey );
}
}
PDNS_RECORD
GetPreviousRegistrationInformation(
IN PUPDATE_ENTRY pUpdateEntry,
IN BOOL fPrimaryDomain,
OUT PIP_ADDRESS pServerIp
)
{
DWORD retVal = NO_ERROR;
DWORD status = NO_ERROR;
CHAR szName[MAX_PATH];
INT index;
DWORD dwBytesRead = MAX_PATH -1;
DWORD dwRegistered = 0;
PUPDATE_ENTRY pregEntry = NULL;
PDNS_RECORD precords = NULL;
PSTR pdomain;
DNSDBG( TRACE, (
"GetPreviousRegistrationInformation( %p )\n",
pUpdateEntry ));
//
// determine desired domain name to use
//
if ( fPrimaryDomain )
{
pdomain = pUpdateEntry->PrimaryDomainName;
}
else
{
pdomain = pUpdateEntry->DomainName;
}
if ( !pdomain )
{
goto Exit;
}
index = 0;
while ( !retVal )
{
dwBytesRead = MAX_PATH - 1;
retVal = RegEnumKeyEx(
g_hKey,
index,
szName,
&dwBytesRead,
NULL,
NULL,
NULL,
NULL );
if ( retVal )
{
goto Exit;
}
//
// Skip past registry information for the given adapter name
//
if ( !_stricmp( szName, pUpdateEntry->AdapterName ) )
{
index++;
continue;
}
//
// Found an adapter in the registry
//
pregEntry = ReadUpdateEntryFromRegistry( szName );
if ( pregEntry )
{
//
// See if registered entry is related to update entry
// ( same HostName and DomainName )
//
if ( Dns_NameCompare_UTF8(
pregEntry->HostName,
pUpdateEntry->HostName )
&&
( Dns_NameCompare_UTF8(
pregEntry->DomainName,
pdomain )
||
Dns_NameCompare_UTF8(
pregEntry->PrimaryDomainName,
pdomain ) ) )
{
BOOL fUsePrimary = TRUE;
if ( Dns_NameCompare_UTF8(
pregEntry->DomainName,
pdomain ) )
{
fUsePrimary = FALSE;
}
//
// PHASE 1 - COMPARE SOAS FROM REGISTRY AND UPDATE ENTRIES
// IF SAME, ADD TO LIST. ELSE, TOSS.
//
// PHASE 2 - COMPARE NS RECORDS FROM BOTH ENTRIES
// IF SAME ZONE AND SERVER, ADD TO LIST. ELSE, TOSS.
//
// PHASE 3 - COMPARE NS RECORDS FROM BOTH ENTRIES
// IF SAME ZONE AND THERE IS AN INTERSECTION OF
// SERVERS, ADD TO LIST. ELSE, TOSS.
// NOTE: FOR THIS PHASE, THERE HAD BETTER BE ALL
// SOAS RETURNED TO TEST INTERSECTION?
//
if ( CompareMultiAdapterSOAQueries(
pdomain,
pUpdateEntry->DnsServerList,
pregEntry->DnsServerList ) )
{
PDNS_RECORD prr;
//
// Convert registered entry to a PDNS_RECORD and
// add to current list
//
prr = CreateForwardRecords(
pregEntry,
fUsePrimary );
if ( prr )
{
precords = Dns_RecordListAppend(
precords,
prr );
if ( pServerIp &&
*pServerIp == 0 &&
pUpdateEntry->RetryCount == 0 &&
pregEntry->SentUpdateToIp )
{
*pServerIp = pregEntry->SentUpdateToIp;
}
}
}
}
FreeUpdateEntry( pregEntry );
pregEntry = NULL;
}
index++;
}
Exit:
DNSDBG( TRACE, (
"Leave GetPreviousRegistrationInformation()\n"
"\tprevious records = %p\n",
precords ));
return( precords );
}
PDNS_RECORD
CreateDnsRecordSetUnion(
IN PDNS_RECORD pSet1,
IN PDNS_RECORD pSet2
)
{
PDNS_RECORD pSet1Copy = NULL;
PDNS_RECORD pSet2Copy = NULL;
pSet1Copy = Dns_RecordSetCopyEx(
pSet1,
DnsCharSetUtf8,
DnsCharSetUtf8 );
if ( !pSet1Copy )
{
return NULL;
}
pSet2Copy = Dns_RecordSetCopyEx(
pSet2,
DnsCharSetUtf8,
DnsCharSetUtf8 );
if ( !pSet2Copy )
{
Dns_RecordListFree( pSet1Copy );
return NULL;
}
return Dns_RecordListAppend( pSet1Copy, pSet2Copy );
}
//
// Logging
//
#if 1 // DBG
VOID
LogHostEntries(
IN DWORD dwHostAddrCount,
IN PREGISTER_HOST_ENTRY pHostAddrs
)
{
DWORD iter;
for ( iter = 0; iter < dwHostAddrCount; iter++ )
{
ASYNCREG_F3( " HostAddrs[%d].dwOptions : 0x%x",
iter,
pHostAddrs[iter].dwOptions );
if ( pHostAddrs->dwOptions & REGISTER_HOST_A )
{
ASYNCREG_F6( " HostAddrs[%d].Addr.ipAddr : %d.%d.%d.%d",
iter,
((BYTE *) &pHostAddrs[iter].Addr.ipAddr)[0],
((BYTE *) &pHostAddrs[iter].Addr.ipAddr)[1],
((BYTE *) &pHostAddrs[iter].Addr.ipAddr)[2],
((BYTE *) &pHostAddrs[iter].Addr.ipAddr)[3] );
}
else if ( pHostAddrs->dwOptions & REGISTER_HOST_AAAA )
{
ASYNCREG_F6( " HostAddrs[%d].Addr.ipV6Addr : %d.%d.%d.%d",
iter,
((DWORD *) &pHostAddrs[iter].Addr.ipV6Addr)[0],
((DWORD *) &pHostAddrs[iter].Addr.ipV6Addr)[1],
((DWORD *) &pHostAddrs[iter].Addr.ipV6Addr)[2],
((DWORD *) &pHostAddrs[iter].Addr.ipV6Addr)[3] );
}
else
{
ASYNCREG_F1( "ERROR: HostAddrs[%d].Addr UNKNOWN ADDRESS TYPE!" );
}
}
}
#endif
#if 1 // DBG
VOID
LogPipAddress(
IN DWORD dwServerListCount,
IN PIP_ADDRESS pServers
)
{
DWORD iter;
for ( iter = 0; iter < dwServerListCount; iter++ )
{
ASYNCREG_F6( " Server [%d] : %d.%d.%d.%d",
iter,
((BYTE *) &pServers[iter])[0],
((BYTE *) &pServers[iter])[1],
((BYTE *) &pServers[iter])[2],
((BYTE *) &pServers[iter])[3] );
}
}
#endif
#if 1 // DBG
VOID
LogPipArray(
IN PIP_ARRAY pServers
)
{
DWORD count;
DWORD iter;
if ( pServers )
{
count = pServers->AddrCount;
}
else
{
return;
}
for ( iter = 0; iter < count; iter++ )
{
ASYNCREG_F6( " Server [%d] : %d.%d.%d.%d",
iter,
((BYTE *) &pServers->AddrArray[iter])[0],
((BYTE *) &pServers->AddrArray[iter])[1],
((BYTE *) &pServers->AddrArray[iter])[2],
((BYTE *) &pServers->AddrArray[iter])[3] );
}
}
#endif
DNS_STATUS
alertOrStartRegistrationThread(
VOID
)
/*++
Routine Description:
Alerts registration thread of new update, starting thread if necessary.
This is called in registration\deregistration functions to ensure
thread has been started.
Arguments:
None
Return Value:
ERROR_SUCCESS if successful.
Error code on failure.
--*/
{
DWORD threadId;
DNS_STATUS Status;
ASYNCREG_F1( "Inside alertOrStartRegistrationThread()\n" );
//
// must lock to avoid multiple async start
//
// DCR_PERF: use a single general CS for init protect issues
// simply check
// - done => bail
// - not done => dumb wait (sleep, check)
//
EnterCriticalSection( &g_RegistrationThreadCS );
if ( g_hRegistrationThread )
{
LeaveCriticalSection( &g_RegistrationThreadCS );
PulseEvent( g_hNewItemEvent );
return( ERROR_SUCCESS );
}
//
// if not started, fire it up
//
Status = ERROR_SUCCESS;
g_fQuit = FALSE;
g_fShutdown = FALSE;
ResetEvent( g_hStopEvent );
ResetEvent( g_hThreadDeadEvent );
g_hRegistrationThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE)
RegistrationThread,
NULL,
0,
& threadId );
if ( ! g_hRegistrationThread )
{
Status = GetLastError();
}
LeaveCriticalSection( &g_RegistrationThreadCS );
return( Status );
}
VOID
registerUpdateStatus(
IN OUT PREGISTER_HOST_STATUS pRegstatus,
IN DNS_STATUS Status
)
/*++
Routine Description:
Set Status and signal completion.
Arguments:
pRegstatus -- registration Status block to indicate
Status -- Status to indicate
Return Value:
None
--*/
{
// test for existence and event
if ( !pRegstatus || !pRegstatus->hDoneEvent )
{
return;
}
// set return Status
// signal event
pRegstatus->dwStatus = Status;
SetEvent( pRegstatus->hDoneEvent );
}
VOID
enqueueUpdate(
IN OUT PUPDATE_ENTRY pUpdate
)
/*++
Routine Description:
Queue update on registration queue.
Arguments:
pUpdate -- update completed
Return Value:
None
--*/
{
EnterCriticalSection( &g_RegistrationListCS );
InsertTailList( &g_RegistrationList, (PLIST_ENTRY)pUpdate );
LeaveCriticalSection( &g_RegistrationListCS );
}
VOID
enqueueUpdateMaybe(
IN OUT PUPDATE_ENTRY pUpdate
)
/*++
Routine Description:
Queue update on registration queue, only if there does not exist
any updates in the queue already for the given adapter.
Arguments:
pUpdate -- update completed
Return Value:
None
--*/
{
PLIST_ENTRY plistHead;
PLIST_ENTRY pentry;
BOOL fAdd = TRUE;
EnterCriticalSection( &g_RegistrationListCS );
plistHead = &g_RegistrationList;
pentry = plistHead->Flink;
while ( pentry != plistHead )
{
if ( !_stricmp( ((PUPDATE_ENTRY) pentry)->AdapterName,
pUpdate->AdapterName ) )
{
fAdd = FALSE;
break;
}
pentry = pentry->Flink;
}
if ( fAdd )
{
InsertTailList( &g_RegistrationList, (PLIST_ENTRY)pUpdate );
}
else
{
FreeUpdateEntry( pUpdate );
}
LeaveCriticalSection( &g_RegistrationListCS );
}
PLIST_ENTRY
dequeueAndCleanupUpdate(
IN OUT PLIST_ENTRY pUpdateEntry
)
/*++
Routine Description:
Dequeue and free update.
Includes any registration Status setting.
Arguments:
pUpdateEntry -- pUpdateEntry
Return Value:
Ptr to next update in queue.
--*/
{
PLIST_ENTRY pnext = pUpdateEntry->Flink;
RemoveEntryList( pUpdateEntry );
if ( ((PUPDATE_ENTRY)pUpdateEntry)->pRegisterStatus )
{
registerUpdateStatus(
((PUPDATE_ENTRY)pUpdateEntry)->pRegisterStatus,
ERROR_SUCCESS );
}
FreeUpdateEntry( (PUPDATE_ENTRY) pUpdateEntry );
return( pnext );
}
BOOL
searchForOldUpdateEntriesAndCleanUp(
IN PSTR pszAdapterName,
IN PUPDATE_ENTRY pUpdateEntry, OPTIONAL
IN BOOL fLookInRegistry
)
/*++
Routine Description:
Searches registry for any previous registrations for a given adapter
name and queues up a delete update entry for it. Then walks the update
registration list to remove any add updates for the given adapter.
Arguments:
pszAdapterName -- name of adapters that is going away (disabled for
DDNS or now removed).
Return Value:
Flag to indicate whether a delete update has been queued up ready to
be processed.
--*/
{
PUPDATE_ENTRY pregEntry = NULL;
BOOL fReturn = FALSE;
PLIST_ENTRY plistHead;
PLIST_ENTRY pentry;
//
// See if this adapter has been previously registered
//
if ( fLookInRegistry &&
(pregEntry = ReadUpdateEntryFromRegistry( pszAdapterName )) )
{
pregEntry->fRemove = TRUE;
pregEntry->Flags |= DYNDNS_DEL_ENTRY;
pregEntry->fRegisteredFWD = FALSE;
pregEntry->fRegisteredPRI = FALSE;
pregEntry->fRegisteredPTR = FALSE;
//
// Clear registry key for adapter
//
WriteUpdateEntryToRegistry( pregEntry );
//
// Put update in registration list
//
enqueueUpdate( pregEntry );
fReturn = TRUE; // We have queued a delete update to process.
}
//
// Now walk the pending update list looking for updates that should
// be removed for the given adapter name.
//
EnterCriticalSection( &g_RegistrationListCS );
plistHead = &g_RegistrationList;
pentry = plistHead->Flink;
while ( pentry != plistHead )
{
if ( !_stricmp( ((PUPDATE_ENTRY) pentry)->AdapterName,
pszAdapterName ) &&
!((PUPDATE_ENTRY) pentry)->fRemove )
{
//
// There is an update entry in the registration list
// that has the same adapter name. We need to get rid of
// this entry since the adapter is being deleted.
//
if ( pUpdateEntry &&
compareUpdateEntries( (PUPDATE_ENTRY) pentry,
pUpdateEntry ) )
{
//
// The adapter entry in the queue is the same as the
// one being being processed. i.e. All of the adapter
// information seems to be the same and we must have
// just been called to refresh the adapter info in DNS.
// Since they are the same, if we have previously tried
// an update with these settings and failed and have
// already logged an event, then there is no reason to
// repeat the error event in the retries to follow
// on the new pUpdateEntry. That said, we'll copy over
// the flag from the queued update to the new one . . .
//
pUpdateEntry->fDisableErrorLogging =
((PUPDATE_ENTRY) pentry)->fDisableErrorLogging;
}
pentry = dequeueAndCleanupUpdate( pentry );
continue;
}
else if ( !_stricmp( ((PUPDATE_ENTRY) pentry)->AdapterName,
pszAdapterName ) )
{
if ( !fLookInRegistry &&
pUpdateEntry &&
compareUpdateEntries( (PUPDATE_ENTRY) pentry,
pUpdateEntry ) )
{
//
// There is a delete update entry in the registration list
// that has the same adapter data. Get rid of this delete
// entry since the adapter is being updated again.
//
pentry = dequeueAndCleanupUpdate( pentry );
continue;
}
else
{
//
// There is a delete update entry in the registration list for
// the same adapter that contains different data, have the
// delete update set to new with a retry count of 2.
//
((PUPDATE_ENTRY) pentry)->fNewElement = TRUE;
((PUPDATE_ENTRY) pentry)->fRegisteredFWD = FALSE;
((PUPDATE_ENTRY) pentry)->fRegisteredPRI = FALSE;
((PUPDATE_ENTRY) pentry)->fRegisteredPTR = FALSE;
((PUPDATE_ENTRY) pentry)->fDisableErrorLogging = FALSE;
((PUPDATE_ENTRY) pentry)->RetryCount = 2;
((PUPDATE_ENTRY) pentry)->RetryTime =
Dns_GetCurrentTimeInSeconds();
pentry = pentry->Flink;
}
}
else
{
pentry = pentry->Flink;
}
}
LeaveCriticalSection( &g_RegistrationListCS );
return fReturn;
}
BOOL
compareHostEntryAddrs(
IN PREGISTER_HOST_ENTRY Addrs1,
IN PREGISTER_HOST_ENTRY Addrs2,
IN DWORD Count
)
{
DWORD iter;
for ( iter = 0; iter < Count; iter++ )
{
if ( ( Addrs1[iter].dwOptions & REGISTER_HOST_A ) &&
( Addrs2[iter].dwOptions & REGISTER_HOST_A ) )
{
if ( memcmp( &Addrs1[iter].Addr.ipAddr,
&Addrs2[iter].Addr.ipAddr,
sizeof( IP_ADDRESS ) ) )
{
return FALSE;
}
}
else if ( ( Addrs1[iter].dwOptions & REGISTER_HOST_AAAA ) &&
( Addrs2[iter].dwOptions & REGISTER_HOST_AAAA ) )
{
if ( memcmp( &Addrs1[iter].Addr.ipV6Addr,
&Addrs2[iter].Addr.ipV6Addr,
sizeof( IP6_ADDRESS ) ) )
{
return FALSE;
}
}
else
{
return FALSE;
}
}
return TRUE;
}
//
// Routines for update entry comparison
//
BOOL
compareServerLists(
IN PIP_ARRAY List1,
IN PIP_ARRAY List2
)
{
if ( List1 && List2 )
{
if ( List1->AddrCount != List2->AddrCount )
{
return FALSE;
}
if ( memcmp( List1->AddrArray,
List2->AddrArray,
sizeof( IP_ADDRESS ) * List1->AddrCount ) )
{
return FALSE;
}
}
return TRUE;
}
BOOL
compareUpdateEntries(
IN PUPDATE_ENTRY pUpdateEntry1,
IN PUPDATE_ENTRY pUpdateEntry2
)
/*++
Routine Description:
Compares to update entries to see if they are describing the same
adapter configuration settings. Tests the domain names, the IP
address(es), host names, and the DNS server lists.
Arguments:
pUdapteEntry1 - one of the update entries to compare against the other.
pUdapteEntry2 - one of the update entries to compare against the other.
Return Value:
Flag to indicate whether a the two updates are the same.
--*/
{
if ( !pUpdateEntry1 || !pUpdateEntry2 )
{
return FALSE;
}
if ( ( pUpdateEntry1->HostName || pUpdateEntry2->HostName ) &&
!Dns_NameCompare_UTF8( pUpdateEntry1->HostName,
pUpdateEntry2->HostName ) )
{
return FALSE;
}
if ( ( pUpdateEntry1->DomainName || pUpdateEntry2->DomainName ) &&
!Dns_NameCompare_UTF8( pUpdateEntry1->DomainName,
pUpdateEntry2->DomainName ) )
{
return FALSE;
}
if ( ( pUpdateEntry1->PrimaryDomainName || pUpdateEntry2->PrimaryDomainName )
&&
! Dns_NameCompare_UTF8(
pUpdateEntry1->PrimaryDomainName,
pUpdateEntry2->PrimaryDomainName ) )
{
return FALSE;
}
if ( pUpdateEntry1->HostAddrCount != pUpdateEntry2->HostAddrCount ||
! compareHostEntryAddrs(
pUpdateEntry1->HostAddrs,
pUpdateEntry2->HostAddrs,
pUpdateEntry1->HostAddrCount ) )
{
return FALSE;
}
if ( pUpdateEntry1->DnsServerList &&
pUpdateEntry2->DnsServerList &&
! compareServerLists(
pUpdateEntry1->DnsServerList,
pUpdateEntry2->DnsServerList ) )
{
return FALSE;
}
return TRUE;
}
//
// Glenn's old registry function
//
// No longer in use anywhere else but still used in these
// registration (dynreg and asyncreg) modules.
//
DWORD
GetRegistryValue(
HKEY KeyHandle,
PSTR ValueName,
DWORD ValueType,
PBYTE BufferPtr
)
/*++
Routine Description:
This function retrieves the value of the specified value field. This
function allocates memory for variable length fields such as REG_SZ.
For REG_DWORD data type, it copies the field value directly into
BufferPtr. If fIsWin9X is NOT set, all string types are read as
UNICODE (W) and then converted to UTF8 format. Currently it can
handle only the following fields :
REG_DWORD,
REG_SZ,
REG_MULTI_SZ,
REG_EXPAND_SZ
REG_BINARY
Arguments:
KeyHandle : handle of the key whose value field is retrieved.
ValueName : name of the value field.
ValueType : Expected type of the value field.
BufferPtr : Pointer to DWORD location where a DWORD datatype value
is returned or a buffer pointer for REG_SZ or REG_BINARY
datatype value is returned.
Return Value:
Registry Errors.
--*/
{
DWORD Error;
DWORD LocalValueType;
DWORD ValueSize;
PBYTE DataBuffer = NULL;
PBYTE AllotedBuffer = NULL;
PWSTR ValueNameW = NULL;
//
// DCR_PERF: heap buffer for name is stupid (MAX_PATH covers it)
//
DWORD Length = ( strlen( ValueName ) + 1 ) * sizeof( WCHAR );
ValueNameW = ALLOCATE_HEAP( Length );
if ( !ValueNameW )
{
return DNS_ERROR_NO_MEMORY;
}
Dns_Utf8ToUnicode( ValueName,
strlen( ValueName ),
ValueNameW,
Length );
//
// Query DataType and BufferSize.
//
Error = RegQueryValueExW( KeyHandle,
ValueNameW,
0,
&LocalValueType,
NULL,
&ValueSize );
if ( Error != ERROR_SUCCESS )
{
FREE_HEAP( ValueNameW );
return(Error);
}
switch( ValueType )
{
case REG_DWORD:
DataBuffer = BufferPtr;
break;
case REG_SZ:
case REG_MULTI_SZ:
case REG_EXPAND_SZ:
case REG_BINARY:
if ( ValueSize == 0 )
{
//
// if string not found in the registry,
// allocate space for null string.
//
ValueSize = sizeof(WCHAR);
}
AllotedBuffer = DataBuffer = ALLOCATE_HEAP( ValueSize );
if ( DataBuffer == NULL )
{
return( DNS_ERROR_NO_MEMORY );
}
break;
default:
FREE_HEAP( ValueNameW );
return( ERROR_INVALID_PARAMETER );
}
//
// retrieve data.
//
Error = RegQueryValueExW( KeyHandle,
ValueNameW,
0,
&LocalValueType,
DataBuffer,
&ValueSize );
FREE_HEAP( ValueNameW );
if ( Error != ERROR_SUCCESS )
{
if ( AllotedBuffer )
{
FREE_HEAP( AllotedBuffer );
}
*(DWORD *)BufferPtr = 0;
return(Error);
}
switch( ValueType )
{
case REG_BINARY:
if ( ValueSize == 0 )
{
//
// if string no found in the registry,
// return null string.
//
*(LPWSTR)DataBuffer = '\0';
}
*(LPBYTE *)BufferPtr = DataBuffer;
break;
case REG_SZ:
case REG_EXPAND_SZ:
case REG_MULTI_SZ:
if ( ValueSize == 0 )
{
//
// if string no found in the registry,
// return null string.
//
*(LPWSTR)DataBuffer = '\0';
}
{
LPBYTE Utf8Buffer = ALLOCATE_HEAP( ValueSize * 2 );
if ( Utf8Buffer == NULL )
{
return( DNS_ERROR_NO_MEMORY );
}
if ( !Dns_UnicodeToUtf8( (LPWSTR) DataBuffer,
ValueSize / sizeof(WCHAR),
Utf8Buffer,
ValueSize * 2 ) )
{
FREE_HEAP( DataBuffer );
return ERROR_INVALID_PARAMETER;
}
FREE_HEAP( DataBuffer );
*(LPBYTE *)BufferPtr = Utf8Buffer;
}
break;
default:
break;
}
return( Error );
}
//
// Jim Utils
//
PDNS_RECORD
CreatePtrRecord(
IN PSTR pszHostName,
IN PSTR pszDomainName,
IN IP4_ADDRESS Ip4Addr,
IN DWORD Ttl
)
/*++
Routine Description:
Create PTR record for update from IP and host and domain names.
Arguments:
Return Value:
PTR record to use in update.
--*/
{
IP_UNION ipUnion;
DNSDBG( TRACE, (
"CreatePtrRecord( %s, %s, %s )\n",
pszHostName,
pszDomainName,
IP_STRING( Ip4Addr ) ));
IPUNION_SET_IP4( &ipUnion, Ip4Addr );
return Dns_CreatePtrRecordExEx(
& ipUnion,
pszHostName,
pszDomainName,
Ttl,
DnsCharSetUtf8, // from UTF8
DnsCharSetUtf8 // to UTF8
);
}
VOID
UpdatePtrRecords(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN BOOL fAdd
)
/*++
Routine Description:
Register PTR records for an update entry.
Arguments:
pUpdateEntry -- update being processed
fAdd -- TRUE for add; FALSE for delete
Return Value:
PTR record to use in update.
--*/
{
DWORD iter;
PDNS_RECORD prr = NULL;
DNS_STATUS status = NO_ERROR;
IP_ADDRESS ipServer;
DNS_RRSET rrset;
PSTR pdomain = NULL;
PSTR pprimary = NULL;
DWORD ttl = pUpdateEntry->TTL;
PSTR phostname = pUpdateEntry->HostName;
DNSDBG( TRACE, (
"UpdatePtrRecords( %p, fAdd=%d )\n",
pUpdateEntry,
fAdd ));
IF_DNSDBG( TRACE )
{
DnsDbg_UpdateEntry(
"Entering UpdatePtrRecords:",
pUpdateEntry );
}
//
// make sure we have update to do
// only do ADD updates if forward registrations were
// successful
//
pdomain = pUpdateEntry->DomainName;
pprimary = pUpdateEntry->PrimaryDomainName;
if ( fAdd )
{
if ( !pUpdateEntry->fRegisteredFWD )
{
pdomain = NULL;
}
if ( !pUpdateEntry->fRegisteredPRI )
{
pprimary = NULL;
}
}
if ( !pdomain && !pprimary )
{
DNSDBG( TRACE, (
"UpdatePtrRecords() => no forward registrations"
"-- skipping PTR update.\n" ));
return;
}
//
// build PTR (or set) for each IP in update entry
//
for ( iter = 0; iter < pUpdateEntry->HostAddrCount; iter++ )
{
IP4_ADDRESS ip = pUpdateEntry->HostAddrs[iter].Addr.ipAddr;
if ( ip == 0 || ip == DNS_NET_ORDER_LOOPBACK )
{
DNS_ASSERT( FALSE );
continue;
}
//
// build update PTR set
// - primary name
// - adapter name
//
DNS_RRSET_INIT( rrset );
if ( pprimary )
{
prr = CreatePtrRecord(
phostname,
pprimary,
ip,
ttl );
if ( prr )
{
DNS_RRSET_ADD( rrset, prr );
}
}
if ( pdomain )
{
prr = CreatePtrRecord(
phostname,
pdomain,
ip,
ttl );
if ( prr )
{
DNS_RRSET_ADD( rrset, prr );
}
}
prr = rrset.pFirstRR;
if ( !prr )
{
continue;
}
//
// do update
//
// for ADD => replace, we own the IP address now
// for REMOVE => modify, as another update might have already
// written correct info
//
if ( fAdd )
{
status = DnsReplaceRecordSetUTF8(
prr, // update set
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no security context
(PIP4_ARRAY) pUpdateEntry->DnsServerList,
NULL // reserved
);
}
else
{
status = DnsModifyRecordsInSet_UTF8(
NULL, // no add records
prr, // delete records
DNS_UPDATE_CACHE_SECURITY_CONTEXT,
NULL, // no context handle
pUpdateEntry->DnsServerList,
NULL // reserved
);
}
DNSDBG( TRACE, (
"%s on PTRs for IP %s => %d (%s)\n",
fAdd
? "Replace"
: "Modify (remove)",
IP_STRING(ip),
status,
Dns_StatusString(status) ));
ipServer = 0;
if ( status == NO_ERROR ||
// status == DNS_ERROR_RCODE_SERVER_FAILURE ||
status == DNS_ERROR_RCODE_NOT_IMPLEMENTED ||
status == DNS_ERROR_RCODE_REFUSED ||
status == DNS_ERROR_RCODE_YXRRSET ||
status == DNS_ERROR_RCODE_NXRRSET )
{
ipServer = DnsGetLastServerUpdateIP();
}
if ( !fAdd ||
pUpdateEntry->RetryCount == 2 )
{
LogRegistration(
pUpdateEntry,
status,
UPTYPE_PTR,
!fAdd,
ipServer,
ip );
}
// note successful PTR registrations (adds)
if ( fAdd && status==NO_ERROR )
{
pUpdateEntry->fRegisteredPTR = TRUE;
}
Dns_RecordListFree( prr );
}
DNSDBG( TRACE, (
"Leave UpdatePtrRecords()\n" ));
}
PDNS_RECORD
CreateForwardRecords(
IN PUPDATE_ENTRY pUpdateEntry,
IN UPTYPE UpType
)
/*++
Routine Description:
Create A records for update.
Arguments:
pUpdateEntry -- update entry
UpType -- update type
UPTYPE_DOMAIN
UPTYPE_PRIMARY
UPTYPE_ALTERNATE
Return Value:
Ptr to list of A records.
--*/
{
PDNS_RECORD prr = NULL;
PSTR pname;
DWORD iter;
CHAR nameBuffer[ DNS_MAX_NAME_BUFFER_LENGTH ];
DNS_RRSET rrset;
DNSDBG( TRACE, (
"CreateForwardRecords( %p, %d )\n",
pUpdateEntry,
UpType ));
//
// build FQDN
//
// for alternate name, go to name for desired index
//
if ( IS_UPTYPE_ALTERNATE(UpType) )
{
DWORD count = pUpdateEntry->AlternateIndex;
pname = pUpdateEntry->AlternateNames;
while ( count-- )
{
pname = MultiSz_NextString_A( pname );
if ( !pname )
{
DNSDBG( ANY, (
"ERROR: Alternate count %d does NOT exist in name!\n",
pUpdateEntry->AlternateIndex ));
DNS_ASSERT( FALSE );
return NULL;
}
}
DNSDBG( DHCP, (
"Create records with alternate name %s\n",
pname ));
}
else
{
PSTR pdomain = pUpdateEntry->DomainName;
if ( IS_UPTYPE_PRIMARY(UpType) )
{
pdomain = pUpdateEntry->PrimaryDomainName;
}
if ( !pdomain || !pUpdateEntry->HostName )
{
return NULL;
}
if ( !Dns_NameAppend_A(
nameBuffer,
DNS_MAX_NAME_BUFFER_LENGTH,
pUpdateEntry->HostName,
pdomain ) )
{
return NULL;
}
pname = nameBuffer;
}
//
// create records for name
//
DNS_RRSET_INIT( rrset );
for ( iter = 0; iter < pUpdateEntry->HostAddrCount; iter++ )
{
if ( !(pUpdateEntry->HostAddrs[iter].dwOptions & REGISTER_HOST_A) )
{
continue;
}
prr = Dns_CreateARecord(
pname,
pUpdateEntry->HostAddrs[iter].Addr.ipAddr,
pUpdateEntry->TTL,
DnsCharSetUtf8,
DnsCharSetUtf8 );
if ( !prr )
{
SetLastError( DNS_ERROR_NO_MEMORY );
Dns_RecordListFree( rrset.pFirstRR );
return NULL;
}
DNS_RRSET_ADD( rrset, prr );
}
DNSDBG( TRACE, (
"Leave CreateForwardRecords() => %p\n",
rrset.pFirstRR ));
return rrset.pFirstRR;
}
VOID
SetUpdateStatus(
IN OUT PUPDATE_ENTRY pUpdateEntry,
IN DNS_STATUS Status,
IN UPTYPE UpType
)
/*++
Routine Description:
Set update Status info in update entry.
Arguments:
pUpdateEntry -- entry to set Status in
Status -- result of update
fPrimary -- TRUE if update was for primary name; FALSE otherwise
Return Value:
None
--*/
{
IP4_ADDRESS ipServer = 0;
BOOL fregistered = FALSE;
DNSDBG( TRACE, ( "SetUpdateStatus()\n" ));
DNS_ASSERT( pUpdateEntry != NULL );
fregistered = ( Status == NO_ERROR );
ipServer = DnsGetLastServerUpdateIP();
if ( IS_UPTYPE_PRIMARY(UpType) )
{
pUpdateEntry->SentPriUpdateToIp = ipServer;
pUpdateEntry->fRegisteredPRI = fregistered;
}
else if ( IS_UPTYPE_DOMAIN(UpType) )
{
pUpdateEntry->SentUpdateToIp = ipServer;
pUpdateEntry->fRegisteredFWD = fregistered;
}
}
VOID
DnsPrint_UpdateEntry(
IN PRINT_ROUTINE PrintRoutine,
IN OUT PPRINT_CONTEXT pContext,
IN PSTR pszHeader,
IN PUPDATE_ENTRY pEntry
)
/*++
Routine Description:
Print update entry.
Arguments:
PrintRoutine - routine to print with
pszHeader - header
pEntry - ptr to update entry
Return Value:
None.
--*/
{
DWORD i;
if ( !pszHeader )
{
pszHeader = "Update Entry:";
}
if ( !pEntry )
{
PrintRoutine(
pContext,
"%s %s\r\n",
pszHeader,
"NULL Update Entry ptr." );
return;
}
// print the struct
PrintRoutine(
pContext,
"%s\r\n"
"\tPtr = %p\n"
"\tSignatureTop = %08x\n"
"\tAdapterName = %s\n"
"\tHostName = %s\n"
"\tDomainName = %s\n"
"\tPrimaryDomainName = %s\n"
"\tAlternateName = %s\n"
"\tAlternateIndex = %d\n"
"\tHostAddrCount = %d\n"
"\tHostAddrs = %p\n"
"\tDnsServerList = %p\n"
"\tSentUpdateToIp = %s\n"
"\tSentPriUpdateToIp = %s\n"
"\tTTL = %d\n"
"\tFlags = %08x\n"
"\tfNewElement = %d\n"
"\tfFromRegistry = %d\n"
"\tfRemove = %d\n"
"\tfRegisteredFWD = %d\n"
"\tfRegisteredPRI = %d\n"
"\tfRegisteredPTR = %d\n"
"\tfDisableLogging = %d\n"
"\tRetryCount = %d\n"
"\tRetryTime = %d\n"
"\tpRegisterStatus = %p\n"
"\tSignatureBottom = %08x\n",
pszHeader,
pEntry,
pEntry->SignatureTop,
pEntry->AdapterName,
pEntry->HostName,
pEntry->DomainName,
pEntry->PrimaryDomainName,
pEntry->AlternateNames,
pEntry->AlternateIndex,
pEntry->HostAddrCount,
pEntry->HostAddrs,
pEntry->DnsServerList,
IP_STRING( pEntry->SentUpdateToIp ),
IP_STRING( pEntry->SentPriUpdateToIp ),
pEntry->TTL,
pEntry->Flags,
pEntry->fNewElement,
pEntry->fFromRegistry,
pEntry->fRemove,
pEntry->fRegisteredFWD,
pEntry->fRegisteredPRI,
pEntry->fRegisteredPTR,
pEntry->fDisableErrorLogging,
pEntry->RetryCount,
pEntry->RetryTime,
pEntry->pRegisterStatus,
pEntry->SignatureBottom
);
}
VOID
AsyncLogUpdateEntry(
IN PSTR pszHeader,
IN PUPDATE_ENTRY pEntry
)
{
if ( !pEntry )
{
return;
}
ASYNCREG_F2( " %s", pszHeader );
ASYNCREG_F1( " Update Entry" );
ASYNCREG_F1( " ______________________________________________________" );
ASYNCREG_F2( " AdapterName : %s", pEntry->AdapterName );
ASYNCREG_F2( " HostName : %s", pEntry->HostName );
ASYNCREG_F2( " DomainName : %s", pEntry->DomainName );
ASYNCREG_F2( " PrimaryDomainName : %s", pEntry->PrimaryDomainName );
ASYNCREG_F2( " HostAddrCount : %d", pEntry->HostAddrCount );
DNSLOG_HOST_ENTRYS( pEntry->HostAddrCount,
pEntry->HostAddrs );
if ( pEntry->DnsServerList )
{
DNSLOG_PIP_ARRAY( pEntry->DnsServerList );
}
ASYNCREG_F2( " TTL : %d", pEntry->TTL );
ASYNCREG_F2( " Flags : %d", pEntry->Flags );
ASYNCREG_F2( " fNewElement : %d", pEntry->fNewElement );
ASYNCREG_F2( " fRemove : %d", pEntry->fRemove );
ASYNCREG_F2( " fRegisteredFWD : %d", pEntry->fRegisteredFWD );
ASYNCREG_F2( " fRegisteredPRI : %d", pEntry->fRegisteredPRI );
ASYNCREG_F2( " fRegisteredPTR : %d", pEntry->fRegisteredPTR );
ASYNCREG_F2( " RetryCount : %d", pEntry->RetryCount );
ASYNCREG_F2( " RetryTime : %d", pEntry->RetryTime );
ASYNCREG_F1( "" );
}
//
// Logging
//
DWORD RegistrationEventArray[6][6] =
{
EVENT_DNSAPI_REGISTRATION_FAILED_TIMEOUT,
EVENT_DNSAPI_REGISTRATION_FAILED_SERVERFAIL,
EVENT_DNSAPI_REGISTRATION_FAILED_NOTSUPP,
EVENT_DNSAPI_REGISTRATION_FAILED_REFUSED,
EVENT_DNSAPI_REGISTRATION_FAILED_SECURITY,
EVENT_DNSAPI_REGISTRATION_FAILED_OTHER,
EVENT_DNSAPI_DEREGISTRATION_FAILED_TIMEOUT,
EVENT_DNSAPI_DEREGISTRATION_FAILED_SERVERFAIL,
EVENT_DNSAPI_DEREGISTRATION_FAILED_NOTSUPP,
EVENT_DNSAPI_DEREGISTRATION_FAILED_REFUSED,
EVENT_DNSAPI_DEREGISTRATION_FAILED_SECURITY,
EVENT_DNSAPI_DEREGISTRATION_FAILED_OTHER,
EVENT_DNSAPI_REGISTRATION_FAILED_NOTSUPP_PRIMARY_DN,
EVENT_DNSAPI_REGISTRATION_FAILED_REFUSED_PRIMARY_DN,
EVENT_DNSAPI_REGISTRATION_FAILED_TIMEOUT_PRIMARY_DN,
EVENT_DNSAPI_REGISTRATION_FAILED_SERVERFAIL_PRIMARY_DN,
EVENT_DNSAPI_REGISTRATION_FAILED_SECURITY_PRIMARY_DN,
EVENT_DNSAPI_REGISTRATION_FAILED_OTHER_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_NOTSUPP_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_REFUSED_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_TIMEOUT_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_SERVERFAIL_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_SECURITY_PRIMARY_DN,
EVENT_DNSAPI_DEREGISTRATION_FAILED_OTHER_PRIMARY_DN,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_TIMEOUT,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_SERVERFAIL,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_NOTSUPP,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_REFUSED,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_SECURITY,
EVENT_DNSAPI_PTR_REGISTRATION_FAILED_OTHER,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_TIMEOUT,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_SERVERFAIL,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_NOTSUPP,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_REFUSED,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_SECURITY,
EVENT_DNSAPI_PTR_DEREGISTRATION_FAILED_OTHER
};
//
// Map update status to index into table
//
// This is the outside -- fast varying -- index
//
#define EVENTINDEX_TIMEOUT (0)
#define EVENTINDEX_SERVFAIL (1)
#define EVENTINDEX_NOTSUPP (2)
#define EVENTINDEX_REFUSED (3)
#define EVENTINDEX_SECURITY (4)
#define EVENTINDEX_OTHER (5)
//
// Map adapter, primary, PTR registration into index into table
//
// This index +0 for reg, +1 for dereg gives inside index into
// event table.
//
#define EVENTINDEX_ADAPTER (0)
#define EVENTINDEX_PRIMARY (2)
#define EVENTINDEX_PTR (4)
DWORD
GetUpdateEventId(
IN DNS_STATUS Status,
IN UPTYPE UpType,
IN BOOL fDeregister,
OUT PDWORD pdwLevel
)
/*++
Routine Description:
Get event ID.
Arguments:
Status -- status from update call
fDeregister -- TRUE if deregistration, FALSE for registration
fPtr -- TRUE if PTR, FALSE for forward
fPrimary -- TRUE for primary domain name
Return Value:
Event Id.
Zero if no event.
--*/
{
DWORD level = EVENTLOG_WARNING_TYPE;
DWORD statusIndex;
DWORD typeIndex;
//
// find status code
//
switch ( Status )
{
case NO_ERROR :
// success logging in disabled
return 0;
case ERROR_TIMEOUT:
statusIndex = EVENTINDEX_TIMEOUT;
break;
case DNS_ERROR_RCODE_SERVER_FAILURE:
statusIndex = EVENTINDEX_SERVFAIL;
break;
case DNS_ERROR_RCODE_NOT_IMPLEMENTED:
// NOT_IMPL means no update on DNS server, not a client
// specific problem so informational level
statusIndex = EVENTINDEX_NOTSUPP;
level = EVENTLOG_INFORMATION_TYPE;
break;
case DNS_ERROR_RCODE_REFUSED:
statusIndex = EVENTINDEX_REFUSED;
break;
case DNS_ERROR_RCODE_BADSIG:
case DNS_ERROR_RCODE_BADKEY:
case DNS_ERROR_RCODE_BADTIME:
statusIndex = EVENTINDEX_SECURITY;
break;
default:
statusIndex = EVENTINDEX_OTHER;
break;
}
//
// determine interior index for type of update
// - all PTR logging is at informational level
// - dereg events are one group behind registration events
// in table; just inc index
if ( IS_UPTYPE_PTR(UpType) )
{
typeIndex = EVENTINDEX_PTR;
}
else if ( IS_UPTYPE_PRIMARY(UpType) )
{
typeIndex = EVENTINDEX_PRIMARY;
}
else
{
typeIndex = EVENTINDEX_ADAPTER;
}
if ( fDeregister )
{
typeIndex++;
}
//
// get event from table
//
*pdwLevel = level;
return RegistrationEventArray[ typeIndex ][ statusIndex ];
}
VOID
LogRegistration(
IN PUPDATE_ENTRY pUpdateEntry,
IN DNS_STATUS Status,
IN DWORD UpType,
IN BOOL fDeregister,
IN IP4_ADDRESS DnsIp,
IN IP4_ADDRESS UpdateIp
)
/*++
Routine Description:
Log register\deregister failure.
Arguments:
pUpdateEntry -- update entry being executed
Status -- status from update call
Type -- UPTYPE (PRIMARY, ADAPTER, PTR)
fDeregister -- TRUE if deregistration, FALSE for registration
DnsIp -- DNS server IP that failed update
UpdateIp -- IP we tried to update
Return Value:
None
--*/
{
PSTR insertStrings[ 7 ];
CHAR serverIpBuffer[ IP4_ADDRESS_STRING_BUFFER_LENGTH ];
CHAR serverListBuffer[ (IP4_ADDRESS_STRING_BUFFER_LENGTH+2)*9 ];
CHAR ipListBuffer[ (IP4_ADDRESS_STRING_BUFFER_LENGTH+2)*9 ];
CHAR hostnameBuffer[ DNS_MAX_NAME_BUFFER_LENGTH ];
CHAR domainBuffer[ DNS_MAX_NAME_BUFFER_LENGTH*2 ];
CHAR errorCodeBuffer[ 25 ];
DWORD iter;
IP4_ADDRESS ip;
PSTR pname;
DWORD eventId;
DWORD level;
DNSDBG( TRACE, (
"LogRegistration()\n"
"\tpEntry = %p\n"
"\tStatus = %d\n"
"\tUpType = %d\n"
"\tfDereg = %d\n"
"\tDNS IP = %s\n"
"\tUpdate IP = %s\n",
pUpdateEntry,
Status,
UpType,
fDeregister,
IP_STRING( DnsIp ),
IP_STRING( UpdateIp ) ));
//
// not logging?
// - no success logging
// - disabled
// - on DNS server (which registers itself)
//
if ( Status == NO_ERROR ||
pUpdateEntry->fDisableErrorLogging ||
g_IsDnsServer )
{
return;
}
//
// adapter name
//
insertStrings[0] = pUpdateEntry->AdapterName;
//
// hostname
//
Dns_NameCopy(
(PCHAR) hostnameBuffer,
NULL,
pUpdateEntry->HostName,
0,
DnsCharSetUtf8,
DnsCharSetAnsi );
insertStrings[1] = hostnameBuffer;
//
// domain name
// - name depends on type
// - if no name, no logging
if ( IS_UPTYPE_PTR(UpType) )
{
pname = pUpdateEntry->PrimaryDomainName;
if ( !pname )
{
pname = pUpdateEntry->DomainName;
}
}
else if ( IS_UPTYPE_PRIMARY(UpType) )
{
pname = pUpdateEntry->PrimaryDomainName;
}
else
{
pname = pUpdateEntry->DomainName;
}
if ( !pname )
{
return;
}
Dns_NameCopy(
(PCHAR) domainBuffer,
NULL,
pname,
0,
DnsCharSetUtf8,
DnsCharSetAnsi );
insertStrings[2] = domainBuffer;
//
// DNS server list
// - layout comma separated, four per line, limit 8
{
PCHAR pch = serverListBuffer;
DWORD count = 0;
*pch = 0;
if ( pUpdateEntry->DnsServerList )
{
count = pUpdateEntry->DnsServerList->AddrCount;
}
for ( iter=0; iter < count; iter++ )
{
if ( iter == 0 )
{
strcpy( pch, "\t" );
pch++;
}
else
{
*pch++ = ',';
*pch++ = ' ';
if ( iter == 4 )
{
strcpy( pch, "\r\n\t" );
pch += 3;
}
else if ( iter > 8 )
{
strcpy( pch, "..." );
break;
}
}
pch = Dns_Ip4AddressToString_A(
pch,
& pUpdateEntry->DnsServerList->AddrArray[iter]
);
}
if ( pch == serverListBuffer )
{
strcpy( serverListBuffer, "\t<?>" );
}
insertStrings[3] = serverListBuffer;
}
//
// DNS server IP
//
ip = DnsIp;
if ( ip == 0 )
{
if ( IS_UPTYPE_PRIMARY(UpType) )
{
ip = pUpdateEntry->SentPriUpdateToIp;
}
else
{
ip = pUpdateEntry->SentUpdateToIp;
}
}
if ( ip )
{
sprintf(
serverIpBuffer,
"%d.%d.%d.%d",
(ip & 0xff),
((ip>8) & 0xff),
((ip>16) & 0xff),
((ip>24) & 0xff) );
}
else
{
strcpy( serverIpBuffer, "<?>" );
}
insertStrings[4] = serverIpBuffer;
//
// Update IP
// - passed in (for PTR)
// - OR get IP list from update entry
// - layout comma separated, four per line, limit 8
//
ip = UpdateIp;
if ( ip )
{
sprintf(
ipListBuffer,
"%d.%d.%d.%d",
(ip & 0xff),
((ip>8) & 0xff),
((ip>16) & 0xff),
((ip>24) & 0xff) );
}
else
{
DWORD count = pUpdateEntry->HostAddrCount;
PCHAR pch = ipListBuffer;
*pch = 0;
for ( iter=0; iter < count; iter++ )
{
if ( iter > 0 )
{
*pch++ = ',';
*pch++ = ' ';
if ( iter == 4 )
{
strcpy( pch, "\r\n\t" );
pch += 3;
}
else if ( iter > 8 )
{
strcpy( pch, "..." );
break;
}
}
pch = Dns_Ip4AddressToString_A(
pch,
& pUpdateEntry->HostAddrs[iter].Addr.ipAddr );
}
if ( pch == ipListBuffer )
{
strcpy( ipListBuffer, "<?>" );
}
}
insertStrings[5] = ipListBuffer;
// terminate insert string array
insertStrings[6] = NULL;
//
// get event ID for type of update and update status
//
eventId = GetUpdateEventId(
Status,
UpType,
fDeregister,
& level );
if ( !eventId )
{
DNS_ASSERT( FALSE );
return;
}
//
// log the event
//
DNSDBG( TRACE, (
"Logging registration event:\n"
"\tid = %d\n"
"\tlevel = %d\n"
"\tstatus = %d\n"
"\tfor uptype = %d\n",
eventId,
level,
Status,
UpType ));
DnsLogEvent(
eventId,
(WORD) level,
7,
insertStrings,
Status );
}
//
// End asyncreg.c
//
Reference in a new issue Copy permalink