Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

761 lines
13 KiB

/*++
Copyright (c) 1996-2000 Microsoft Corporation
Module Name:
dnsapi.c
Abstract:
Domain Name System (DNS) API
Dnsapi.dll infrastructure (init, shutdown, etc)
Routines to access DNS resolver
Author:
GlennC 22-Jan-1997
Revision History:
Jim Gilroy (jamesg) March 2000 cleanup
--*/
#include "local.h"
#include <lmcons.h>
#define DNS_NET_FAILURE_CACHE_TIME 30 // Seconds
//
// Global Definitions
//
//
// Globals
//
CRITICAL_SECTION g_RegistrationListCS;
CRITICAL_SECTION g_RegistrationThreadCS;
CRITICAL_SECTION g_QueueCS;
CRITICAL_SECTION g_NetFailureCS;
DWORD g_NetFailureTime;
DNS_STATUS g_NetFailureStatus;
IP_ADDRESS g_LastDNSServerUpdated = 0;
//
// Local Function Prototypes
//
BOOL
DnsInitialize(
VOID
);
VOID
DnsCleanup(
VOID
);
VOID
ClearDnsCacheEntry_A (
IN LPSTR,
IN WORD );
VOID
ClearDnsCacheEntry_W (
IN LPWSTR,
IN WORD );
VOID
FreeRpcIpAddressList(
IN PDNS_IP_ADDR_LIST );
//
// System public Network Information
//
// The dnsapi.dll interface is in config.c
//
PDNS_NETWORK_INFORMATION
CreateNetworkInformation(
IN DWORD cAdapterCount
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_NETWORK_INFORMATION pNetworkInfo = NULL;
DWORD dwAdapterListBufLen = sizeof( DNS_NETWORK_INFORMATION ) -
sizeof( PDNS_ADAPTER_INFORMATION ) +
( sizeof( PDNS_ADAPTER_INFORMATION ) *
cAdapterCount );
pNetworkInfo = (PDNS_NETWORK_INFORMATION) ALLOCATE_HEAP_ZERO(
dwAdapterListBufLen );
return pNetworkInfo;
}
PDNS_SEARCH_INFORMATION
CreateSearchInformation(
IN DWORD cNameCount,
IN LPSTR pszName
)
{
PDNS_SEARCH_INFORMATION pSearchInfo = NULL;
DWORD dwSearchInfoBufLen = sizeof( DNS_SEARCH_INFORMATION ) -
sizeof( LPSTR ) +
( sizeof( LPSTR ) *
cNameCount );
if ( ( cNameCount == 0 ) && ( ! pszName ) )
{
return NULL;
}
pSearchInfo =
(PDNS_SEARCH_INFORMATION) ALLOCATE_HEAP_ZERO( dwSearchInfoBufLen );
if ( ! pSearchInfo )
{
return NULL;
}
if ( pszName )
{
pSearchInfo->pszPrimaryDomainName = Dns_NameCopyAllocate(
pszName,
0,
DnsCharSetUtf8,
DnsCharSetUtf8 );
if ( ! pSearchInfo->pszPrimaryDomainName )
{
FREE_HEAP( pSearchInfo );
return NULL;
}
}
return pSearchInfo;
}
PDNS_SEARCH_INFORMATION
CreateSearchInformationCopyFromList(
IN PSEARCH_LIST pSearchList
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_SEARCH_INFORMATION pSearchInformation;
DWORD iter;
if ( ! pSearchList )
{
return NULL;
}
pSearchInformation = CreateSearchInformation(
pSearchList->NameCount,
pSearchList->pszDomainOrZoneName );
if ( ! pSearchInformation )
{
return NULL;
}
for ( iter = 0; iter < pSearchList->NameCount; iter++ )
{
if ( pSearchList->SearchNameArray[iter].pszName )
{
pSearchInformation->aSearchListNames[iter] =
Dns_NameCopyAllocate(
pSearchList->SearchNameArray[iter].pszName,
0,
DnsCharSetUtf8,
DnsCharSetUtf8 );
}
if ( pSearchInformation->aSearchListNames[iter] )
{
pSearchInformation->cNameCount++;
}
}
return pSearchInformation;
}
PDNS_ADAPTER_INFORMATION
CreateAdapterInformation(
IN DWORD cServerCount,
IN DWORD dwFlags,
IN LPSTR pszDomain,
IN LPSTR pszGuidName
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_ADAPTER_INFORMATION pAdapter = NULL;
DWORD dwAdapterInfoBufLen = sizeof( DNS_ADAPTER_INFORMATION ) -
sizeof( DNS_SERVER_INFORMATION ) +
( sizeof( DNS_SERVER_INFORMATION ) *
cServerCount );
pAdapter = (PDNS_ADAPTER_INFORMATION)
ALLOCATE_HEAP_ZERO( dwAdapterInfoBufLen );
if ( ! pAdapter )
{
return NULL;
}
pAdapter->InfoFlags = dwFlags;
pAdapter->cServerCount = 0;
if ( pszDomain )
{
pAdapter->pszDomain = Dns_NameCopyAllocate(
pszDomain,
0,
DnsCharSetUtf8,
DnsCharSetUtf8 );
}
if ( pszGuidName )
{
pAdapter->pszAdapterGuidName = Dns_NameCopyAllocate(
pszGuidName,
0,
DnsCharSetUtf8,
DnsCharSetUtf8 );
}
return pAdapter;
}
PDNS_ADAPTER_INFORMATION
CreateAdapterInformationCopyFromList(
IN PDNS_ADAPTER pAdapter
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_ADAPTER_INFORMATION pAdapterInformation;
DWORD iter;
if ( ! pAdapter )
{
return NULL;
}
pAdapterInformation = CreateAdapterInformation(
pAdapter->ServerCount,
pAdapter->InfoFlags,
pAdapter->pszAdapterDomain,
pAdapter->pszAdapterGuidName );
if ( ! pAdapterInformation )
{
return NULL;
}
pAdapterInformation->pIPAddresses =
Dns_CreateIpArrayCopy( pAdapter->pAdapterIPAddresses );
pAdapterInformation->pIPSubnetMasks =
Dns_CreateIpArrayCopy( pAdapter->pAdapterIPSubnetMasks );
for ( iter = 0; iter < pAdapter->ServerCount; iter++ )
{
pAdapterInformation->aipServers[iter].ipAddress =
pAdapter->ServerArray[iter].IpAddress;
pAdapterInformation->aipServers[iter].Priority =
pAdapter->ServerArray[iter].Priority;
}
pAdapterInformation->cServerCount = pAdapter->ServerCount;
return pAdapterInformation ;
}
PDNS_NETWORK_INFORMATION
WINAPI
GetNetworkInformation(
VOID )
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_NETINFO pNetInfo = GetNetworkInfo();
DWORD iter;
PDNS_NETWORK_INFORMATION pNetworkInformation = NULL;
if ( !pNetInfo )
{
return NULL;
}
//
// create Network Information of desired size
// then copy entire structure
//
pNetworkInformation = CreateNetworkInformation( pNetInfo->AdapterCount );
if ( ! pNetworkInformation )
{
goto Done;
}
pNetworkInformation->pSearchInformation =
CreateSearchInformationCopyFromList( pNetInfo->pSearchList );
for ( iter = 0; iter < pNetInfo->AdapterCount; iter++ )
{
pNetworkInformation->aAdapterInfoList[iter] =
CreateAdapterInformationCopyFromList( pNetInfo->AdapterArray[iter] );
if ( pNetworkInformation->aAdapterInfoList[iter] )
{
pNetworkInformation->cAdapterCount += 1;
}
}
Done:
NetInfo_Free( pNetInfo );
return pNetworkInformation;
}
PDNS_SEARCH_INFORMATION
WINAPI
GetSearchInformation(
VOID )
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
PDNS_NETINFO pNetInfo = GetNetworkInfo();
PDNS_SEARCH_INFORMATION pSearchInformation = NULL;
if ( !pNetInfo )
{
return NULL;
}
pSearchInformation = CreateSearchInformationCopyFromList(
pNetInfo->pSearchList );
NetInfo_Free( pNetInfo );
return pSearchInformation;
}
VOID
WINAPI
FreeAdapterInformation(
IN PDNS_ADAPTER_INFORMATION pAdapterInformation
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
if ( pAdapterInformation )
{
if ( pAdapterInformation->pszAdapterGuidName )
{
FREE_HEAP( pAdapterInformation->pszAdapterGuidName );
}
if ( pAdapterInformation->pszDomain )
{
FREE_HEAP( pAdapterInformation->pszDomain );
}
if ( pAdapterInformation->pIPAddresses )
{
FREE_HEAP( pAdapterInformation->pIPAddresses );
}
if ( pAdapterInformation->pIPSubnetMasks )
{
FREE_HEAP( pAdapterInformation->pIPSubnetMasks );
}
FREE_HEAP( pAdapterInformation );
}
}
VOID
WINAPI
FreeSearchInformation(
IN PDNS_SEARCH_INFORMATION pSearchInformation
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
DWORD iter;
if ( pSearchInformation )
{
if ( pSearchInformation->pszPrimaryDomainName )
{
FREE_HEAP( pSearchInformation->pszPrimaryDomainName );
}
for ( iter = 0; iter < pSearchInformation->cNameCount; iter++ )
{
if ( pSearchInformation->aSearchListNames[iter] )
{
FREE_HEAP( pSearchInformation->aSearchListNames[iter] );
}
}
FREE_HEAP( pSearchInformation );
}
}
VOID
WINAPI
FreeNetworkInformation(
IN PDNS_NETWORK_INFORMATION pNetworkInformation
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
DWORD iter;
if ( pNetworkInformation )
{
FreeSearchInformation( pNetworkInformation->pSearchInformation );
for ( iter = 0; iter < pNetworkInformation->cAdapterCount; iter++ )
{
FreeAdapterInformation( pNetworkInformation ->
aAdapterInfoList[iter] );
}
FREE_HEAP( pNetworkInformation );
}
}
//
// Net failure caching
//
BOOL
IsKnownNetFailure(
VOID
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
BOOL flag = FALSE;
DNSDBG( TRACE, ( "IsKnownNetFailure()\n" ));
EnterCriticalSection( &g_NetFailureCS );
if ( g_NetFailureStatus )
{
if ( g_NetFailureTime < Dns_GetCurrentTimeInSeconds() )
{
g_NetFailureTime = 0;
g_NetFailureStatus = ERROR_SUCCESS;
flag = FALSE;
}
else
{
SetLastError( g_NetFailureStatus );
flag = TRUE;
}
}
LeaveCriticalSection( &g_NetFailureCS );
return flag;
}
VOID
SetKnownNetFailure(
IN DNS_STATUS Status
)
/*++
Routine Description:
None.
Arguments:
None.
Return Value:
None.
--*/
{
DNSDBG( TRACE, ( "SetKnownNetFailure()\n" ));
EnterCriticalSection( &g_NetFailureCS );
g_NetFailureTime = Dns_GetCurrentTimeInSeconds() +
DNS_NET_FAILURE_CACHE_TIME;
g_NetFailureStatus = Status;
LeaveCriticalSection( &g_NetFailureCS );
}
BOOL
WINAPI
DnsGetCacheDataTable(
OUT PDNS_CACHE_TABLE * ppTable
)
/*++
Routine Description:
Get cache data table.
Arguments:
ppTable -- address to receive ptr to cache data table
Return Value:
ERROR_SUCCES if successful.
Error code on failure.
--*/
{
DNS_STATUS status = ERROR_SUCCESS;
DWORD rpcStatus = ERROR_SUCCESS;
PDNS_RPC_CACHE_TABLE pcacheTable = NULL;
DNSDBG( TRACE, ( "DnsGetCacheDataTable()\n" ));
if ( ! ppTable )
{
return FALSE;
}
#if DNSBUILDOLD
if ( g_IsWin9X )
{
return FALSE;
}
#endif
RpcTryExcept
{
status = CRrReadCache( NULL, &pcacheTable );
}
RpcExcept( DNS_RPC_EXCEPTION_FILTER )
{
status = RpcExceptionCode();
}
RpcEndExcept
// set out param
*ppTable = (PDNS_CACHE_TABLE) pcacheTable;
#if DBG
if ( status != ERROR_SUCCESS )
{
DNSDBG( RPC, (
"DnsGetCacheDataTable() status = %d\n",
status ));
}
#endif
return( pcacheTable && status == ERROR_SUCCESS );
}
BOOL
IsLocalIpAddress(
IN IP_ADDRESS IpAddress
)
//
// DCR_FIX: this has no customers other than debug code in update.c
//
// If wanted this API it should be remoteable -- we could avoid alloc
// and include IP6
//
{
BOOL bfound = FALSE;
PIP_ARRAY ipList = Dns_GetLocalIpAddressArray();
DWORD iter;
if ( !ipList )
{
return bfound;
}
//
// check if IpAddress is in local list
//
for ( iter = 0; iter < ipList->AddrCount; iter++ )
{
if ( IpAddress == ipList->AddrArray[iter] )
{
bfound = TRUE;
}
}
FREE_HEAP( ipList );
return bfound;
}
//
// End dnsapi.c
//