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.
1478 lines
36 KiB
1478 lines
36 KiB
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <dnsrslvr.h>
|
|
|
|
extern LPWSTR NetworkAddress;
|
|
|
|
#define COMPUTE_STRING_HASH_2( _String, _ulHashTableSize, _lpulHash ) \
|
|
{ \
|
|
PWCHAR _p = _String; \
|
|
PWCHAR _ep = _p + wcslen( _String ); \
|
|
ULONG h = 0; \
|
|
\
|
|
while( _p < _ep ) \
|
|
{ \
|
|
h <<= 1; \
|
|
h ^= *_p++; \
|
|
} \
|
|
\
|
|
*_lpulHash = h % _ulHashTableSize; \
|
|
}
|
|
|
|
|
|
VOID
|
|
GetStringA( char * );
|
|
|
|
VOID
|
|
GetStringW( WCHAR * );
|
|
|
|
VOID
|
|
PrintMenu( VOID );
|
|
|
|
VOID
|
|
DoFlushCache( VOID );
|
|
|
|
VOID
|
|
DoFlushCacheEntry( VOID );
|
|
|
|
VOID
|
|
DoFlushCacheEntryForType( VOID );
|
|
|
|
VOID
|
|
DoTrimCache( VOID );
|
|
|
|
VOID
|
|
DoReadCacheEntry( VOID );
|
|
|
|
VOID
|
|
DoQuery( VOID );
|
|
|
|
VOID
|
|
DoQueryThenCache( VOID );
|
|
|
|
VOID
|
|
DoDisplayCache( VOID );
|
|
|
|
VOID
|
|
DoGetAdapterInfo( VOID );
|
|
|
|
VOID
|
|
DoGetSearchList( VOID );
|
|
|
|
VOID
|
|
DoGetPrimaryDomainName( VOID );
|
|
|
|
VOID
|
|
DoGetIpAddressList( VOID );
|
|
|
|
VOID
|
|
DoGetHashTableStats( VOID );
|
|
|
|
VOID
|
|
DoGetHashTableIndex( VOID );
|
|
|
|
VOID
|
|
DoUpdateTest( VOID );
|
|
|
|
VOID
|
|
PrintServerInfo( PDNS_RPC_SERVER_INFO );
|
|
|
|
VOID
|
|
PrintIpAddress ( DWORD IpAddress );
|
|
|
|
VOID
|
|
PrintRecords (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintARecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintSOARecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintPTRRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintMINFORecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintMXRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintHINFORecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintNULLRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintWKSRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintAAAARecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintSRVRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintWINSRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
PrintWINSRRecord (
|
|
IN PDNS_RECORD pDnsRecord );
|
|
|
|
VOID
|
|
GetCachedData(
|
|
IN LPWSTR Name,
|
|
IN WORD Type );
|
|
|
|
_cdecl
|
|
main(int argc, char **argv)
|
|
{
|
|
char String[256];
|
|
WCHAR usNetName[100];
|
|
LONG cch;
|
|
DWORD Status = NO_ERROR;
|
|
|
|
if ( argc == 2 )
|
|
{
|
|
cch = MultiByteToWideChar( CP_ACP,
|
|
0L,
|
|
argv[1],
|
|
-1,
|
|
usNetName,
|
|
100 );
|
|
|
|
if ( !cch )
|
|
{
|
|
Status = GetLastError();
|
|
printf("Error %ux in MultiByteToWideChar\n", Status );
|
|
return (Status);
|
|
}
|
|
|
|
NetworkAddress = usNetName;
|
|
}
|
|
|
|
Menu :
|
|
|
|
PrintMenu();
|
|
GetStringA( String );
|
|
printf( "\n" );
|
|
|
|
switch( atoi( String ) )
|
|
{
|
|
case 1 :
|
|
DoFlushCache();
|
|
break;
|
|
|
|
case 2 :
|
|
DoFlushCacheEntry();
|
|
break;
|
|
|
|
case 3 :
|
|
DoFlushCacheEntryForType();
|
|
break;
|
|
|
|
case 4 :
|
|
DoTrimCache();
|
|
break;
|
|
|
|
case 5 :
|
|
DoReadCacheEntry();
|
|
break;
|
|
|
|
case 6 :
|
|
DoQuery();
|
|
break;
|
|
|
|
case 7 :
|
|
DoQueryThenCache();
|
|
break;
|
|
|
|
case 8 :
|
|
DoDisplayCache();
|
|
break;
|
|
|
|
case 9 :
|
|
DoUpdateTest();
|
|
break;
|
|
|
|
case 10 :
|
|
DoGetAdapterInfo();
|
|
break;
|
|
|
|
case 11 :
|
|
DoGetSearchList();
|
|
break;
|
|
|
|
case 12 :
|
|
DoGetPrimaryDomainName();
|
|
break;
|
|
|
|
case 13 :
|
|
DoGetIpAddressList();
|
|
break;
|
|
|
|
case 14 :
|
|
DoGetHashTableStats();
|
|
break;
|
|
|
|
case 15 :
|
|
DoGetHashTableIndex();
|
|
break;
|
|
|
|
case 16 :
|
|
return( -1 );
|
|
|
|
default :
|
|
printf( "Invalid option\n" );
|
|
}
|
|
|
|
goto Menu;
|
|
}
|
|
|
|
|
|
VOID
|
|
GetStringA( char * String )
|
|
{
|
|
WORD iter = 0;
|
|
char ch = getchar();
|
|
|
|
while ( ch != 0x0a )
|
|
{
|
|
String[iter] = ch;
|
|
ch = getchar();
|
|
iter++;
|
|
}
|
|
|
|
String[iter] = 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
GetStringW( WCHAR * String )
|
|
{
|
|
WORD iter = 0;
|
|
WCHAR ch = getchar();
|
|
|
|
while ( ch != 0x0a )
|
|
{
|
|
String[iter] = ch;
|
|
ch = getchar();
|
|
iter++;
|
|
}
|
|
|
|
String[iter] = 0;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintMenu( VOID )
|
|
{
|
|
printf( "\n" );
|
|
printf( "------------------------------------------------------\n" );
|
|
printf( "| DNS Caching Resolver Service Client |\n" );
|
|
printf( "------------------------------------------------------\n" );
|
|
printf( "| |\n" );
|
|
printf( "| 1) Flush cache |\n" );
|
|
printf( "| 2) Flush a specific cache entry |\n" );
|
|
printf( "| 3) Flush a specific record set from a cache entry |\n" );
|
|
printf( "| 4) Trim cache (gets rid of records with old ttls) |\n" );
|
|
printf( "| 5) Read a cache entry's record set |\n" );
|
|
printf( "| 6) Query records for a DNS name and type |\n" );
|
|
printf( "| 7) Query records then CacheRecordSet |\n" );
|
|
printf( "| 8) Display cache contents |\n" );
|
|
printf( "| 9) Perform update test with local machine account |\n" );
|
|
printf( "| 10) Get the net adapter info for this machine |\n" );
|
|
printf( "| 11) Get the DNS search list for this machine |\n" );
|
|
printf( "| 12) Get the Primary Domain Name for this machine |\n" );
|
|
printf( "| 13) Get the list of IP addresses for this machine |\n" );
|
|
printf( "| 14) Get the DNS resolver cache statistics |\n" );
|
|
printf( "| 15) Compute the hash table index for a name |\n" );
|
|
printf( "| 16) Quit |\n" );
|
|
printf( "| |\n" );
|
|
printf( ">>> " );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintIpAddress ( DWORD IpAddress )
|
|
{
|
|
printf( " %d.%d.%d.%d\n",
|
|
((BYTE *) &IpAddress)[0],
|
|
((BYTE *) &IpAddress)[1],
|
|
((BYTE *) &IpAddress)[2],
|
|
((BYTE *) &IpAddress)[3] );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoFlushCache( VOID )
|
|
{
|
|
DWORD Status = NO_ERROR;
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrFlushCache( NULL );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoFlushCacheEntry( VOID )
|
|
{
|
|
DWORD Status = NO_ERROR;
|
|
WCHAR Name[256];
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrFlushCacheEntry( NULL, Name );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoFlushCacheEntryForType( VOID )
|
|
{
|
|
DWORD Status = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
printf( "Type (0, 1, 2, etc): " );
|
|
GetStringA( TypeStr );
|
|
printf( "\n" );
|
|
Type = atoi( TypeStr );
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrFlushCacheEntryForType( NULL, Name, Type );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoTrimCache( VOID )
|
|
{
|
|
DWORD Status = NO_ERROR;
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrTrimCache( NULL );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoReadCacheEntry( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
PDNS_RECORD pDNSRecord = NULL;
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
printf( "Type (0, 1, 2, etc): " );
|
|
GetStringA( TypeStr );
|
|
printf( "\n" );
|
|
Type = atoi( TypeStr );
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrReadCacheEntry( NULL, Name, Type, &pDNSRecord );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
PrintRecords ( ( PDNS_RECORD ) pDNSRecord );
|
|
|
|
DnsFreeRRSet( (PDNS_RECORD) pDNSRecord, TRUE );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoQuery( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
PDNS_RECORD pDNSRecord = NULL;
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
printf( "Type (0, 1, 2, etc): " );
|
|
GetStringA( TypeStr );
|
|
printf( "\n" );
|
|
Type = atoi( TypeStr );
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrQuery( NULL,
|
|
Name,
|
|
Type,
|
|
0,
|
|
&pDNSRecord );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
PrintRecords ( ( PDNS_RECORD ) pDNSRecord );
|
|
|
|
DnsFreeRRSet( (PDNS_RECORD) pDNSRecord, TRUE );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoQueryThenCache( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
PDNS_RECORD pDNSRecord = NULL;
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
printf( "Type (0, 1, 2, etc): " );
|
|
GetStringA( TypeStr );
|
|
printf( "\n" );
|
|
Type = atoi( TypeStr );
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrQuery( NULL,
|
|
Name,
|
|
Type,
|
|
0,
|
|
&pDNSRecord );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "CRrQuery returned error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
PrintRecords ( ( PDNS_RECORD ) pDNSRecord );
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrCacheRecordSet( NULL,
|
|
Name,
|
|
Type,
|
|
0,
|
|
pDNSRecord );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "CRrCacheRecordSet returned error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
DnsFreeRRSet( (PDNS_RECORD) pDNSRecord, TRUE );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoDisplayCache( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
PDNS_RPC_CACHE_TABLE pDNSCacheTable = NULL;
|
|
PDNS_RPC_CACHE_TABLE pTempDNSCacheTable = NULL;
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrReadCache( NULL,
|
|
&pDNSCacheTable );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
pTempDNSCacheTable = pDNSCacheTable;
|
|
|
|
while ( pTempDNSCacheTable )
|
|
{
|
|
PDNS_RPC_CACHE_TABLE pNext = pTempDNSCacheTable->pNext;
|
|
|
|
printf( " %S\n", pTempDNSCacheTable->Name );
|
|
printf( " ------------------------------------------------------\n" );
|
|
|
|
if ( pTempDNSCacheTable->Type1 != DNS_TYPE_ZERO )
|
|
{
|
|
printf( " Type: %d\n", pTempDNSCacheTable->Type1 );
|
|
GetCachedData( pTempDNSCacheTable->Name,
|
|
pTempDNSCacheTable->Type1 );
|
|
printf( "\n" );
|
|
}
|
|
|
|
if ( pTempDNSCacheTable->Type2 != DNS_TYPE_ZERO )
|
|
{
|
|
printf( " Type: %d\n", pTempDNSCacheTable->Type2 );
|
|
GetCachedData( pTempDNSCacheTable->Name,
|
|
pTempDNSCacheTable->Type2 );
|
|
printf( "\n" );
|
|
}
|
|
|
|
if ( pTempDNSCacheTable->Type3 != DNS_TYPE_ZERO )
|
|
{
|
|
printf( " Type: %d\n", pTempDNSCacheTable->Type3 );
|
|
GetCachedData( pTempDNSCacheTable->Name,
|
|
pTempDNSCacheTable->Type3 );
|
|
printf( "\n" );
|
|
}
|
|
|
|
if ( pTempDNSCacheTable->Name )
|
|
LocalFree( pTempDNSCacheTable->Name );
|
|
|
|
LocalFree( pTempDNSCacheTable );
|
|
|
|
pTempDNSCacheTable = pNext;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoUpdateTest( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
WCHAR Name[256];
|
|
char lpAddress[256];
|
|
char TypeStr[25];
|
|
WORD Type;
|
|
PDNS_RECORD pDNSRecord = NULL;
|
|
PDNS_RECORD pTempDNSRecord = NULL;
|
|
BYTE Part1, Part2, Part3, Part4;
|
|
IP_ADDRESS Address;
|
|
LPSTR lpTemp = NULL;
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
printf( "Server IP: " );
|
|
GetStringA( lpAddress );
|
|
printf( "\n" );
|
|
|
|
lpTemp = strtok( lpAddress, "." );
|
|
Part1 = atoi( lpTemp );
|
|
lpTemp = strtok( NULL, "." );
|
|
Part2 = atoi( lpTemp );
|
|
lpTemp = strtok( NULL, "." );
|
|
Part3 = atoi( lpTemp );
|
|
lpTemp = strtok( NULL, "." );
|
|
Part4 = atoi( lpTemp );
|
|
|
|
((BYTE *) &Address)[0] = Part1;
|
|
((BYTE *) &Address)[1] = Part2;
|
|
((BYTE *) &Address)[2] = Part3;
|
|
((BYTE *) &Address)[3] = Part4;
|
|
|
|
printf( "\n Sendine update test for name (%S) to server (%d.%d.%d.%d) ...\n\n",
|
|
Name,
|
|
Part1,
|
|
Part2,
|
|
Part3,
|
|
Part4 );
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrUpdateTest( NULL,
|
|
Name,
|
|
0,
|
|
Address );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetAdapterInfo( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
PDNS_RPC_ADAPTER_INFO pAdapterInfo = NULL;
|
|
PDNS_RPC_ADAPTER_INFO pTempAdapterInfo;
|
|
DWORD iter = 1;
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrGetAdapterInfo( NULL, &pAdapterInfo );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
pTempAdapterInfo = pAdapterInfo;
|
|
|
|
while ( pTempAdapterInfo )
|
|
{
|
|
printf( " Net Adapter Info (%d):\n", iter );
|
|
printf( " -------------------------------------\n" );
|
|
printf( " pszAdapterDomainName : %s\n",
|
|
pTempAdapterInfo->pszAdapterDomainName );
|
|
printf( " Flags : %d\n",
|
|
pTempAdapterInfo->Flags );
|
|
if ( pTempAdapterInfo->pServerInfo )
|
|
PrintServerInfo( pTempAdapterInfo->pServerInfo );
|
|
pTempAdapterInfo = pTempAdapterInfo->pNext;
|
|
iter++;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetSearchList( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
PDNS_RPC_SEARCH_LIST pSearchList = NULL;
|
|
PDNS_RPC_SEARCH_LIST pTempSearchList;
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrGetSearchList( NULL, &pSearchList );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
pTempSearchList = pSearchList;
|
|
|
|
printf( " Search List:\n" );
|
|
printf( " -------------------------------------\n" );
|
|
while ( pTempSearchList )
|
|
{
|
|
printf( " pszName : %s\n", pTempSearchList->pszName );
|
|
pTempSearchList = pTempSearchList->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetPrimaryDomainName( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
LPSTR PrimaryDomainName = NULL;
|
|
|
|
RpcTryExcept
|
|
{
|
|
CRrGetPrimaryDomainName( NULL, &PrimaryDomainName );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
printf( " Primary Domain Name : %s\n", PrimaryDomainName );
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetIpAddressList( VOID )
|
|
{
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
PDNS_IP_ADDR_LIST pIpAddrList = NULL;
|
|
DWORD Count;
|
|
DWORD iter;
|
|
|
|
RpcTryExcept
|
|
{
|
|
Count = CRrGetIpAddressList( NULL, &pIpAddrList );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
if ( Count && pIpAddrList )
|
|
{
|
|
printf( "%d Ip Addresses returned :\n", Count );
|
|
|
|
for ( iter = 0; iter < Count; iter++ )
|
|
{
|
|
printf( "(%d) \t", iter+1 );
|
|
PrintIpAddress( pIpAddrList->AddressArray[iter].ipAddress );
|
|
printf( " \t" );
|
|
PrintIpAddress( pIpAddrList->AddressArray[iter].subnetMask );
|
|
}
|
|
|
|
LocalFree( pIpAddrList );
|
|
}
|
|
else
|
|
{
|
|
printf( "No Ip Addresses found.\n" );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetHashTableStats( VOID )
|
|
{
|
|
DNS_STATUS Status = NO_ERROR;
|
|
DWORD CacheHashTableSize;
|
|
DWORD CacheHashTableBucketSize;
|
|
DWORD NumberOfCacheEntries;
|
|
DWORD NumberOfRecords;
|
|
DWORD NumberOfExpiredRecords;
|
|
PDNS_STATS_TABLE pStatsTable = NULL;
|
|
PDNS_STATS_TABLE pTempRow = NULL;
|
|
|
|
RpcTryExcept
|
|
{
|
|
Status = CRrGetHashTableStats( NULL,
|
|
&CacheHashTableSize,
|
|
&CacheHashTableBucketSize,
|
|
&NumberOfCacheEntries,
|
|
&NumberOfRecords,
|
|
&NumberOfExpiredRecords,
|
|
&pStatsTable );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( Status )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( Status );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
Status, ErrorString );
|
|
return;
|
|
}
|
|
|
|
printf( " DNS Cache Hash Table Statistics\n" );
|
|
printf( " -------------------------------------\n" );
|
|
printf( " Cache hash table size : %d\n",
|
|
CacheHashTableSize );
|
|
printf( " Cache hash table bucket size : %d\n",
|
|
CacheHashTableBucketSize );
|
|
printf( " Number of cache entries : %d\n",
|
|
NumberOfCacheEntries );
|
|
printf( " Number of RR sets : %d\n",
|
|
NumberOfRecords );
|
|
printf( " Number of expired RR sets : %d\n",
|
|
NumberOfExpiredRecords );
|
|
printf( "\n DNS Cache Hast Table Histogram\n" );
|
|
printf( " -------------------------------------\n" );
|
|
|
|
pTempRow = pStatsTable;
|
|
|
|
while ( pTempRow )
|
|
{
|
|
PDWORD_LIST_ITEM pTempItem = pTempRow->pListItem;
|
|
DWORD count = 0;
|
|
DWORD iter;
|
|
|
|
printf( " |" );
|
|
|
|
while ( pTempItem )
|
|
{
|
|
for ( iter = 0; iter < pTempItem->Value2; iter++ )
|
|
printf( "x" );
|
|
|
|
count += pTempItem->Value1 - pTempItem->Value2;
|
|
pTempItem = pTempItem->pNext;
|
|
}
|
|
|
|
for ( iter = 0; iter < count; iter++ )
|
|
printf( "*" );
|
|
|
|
printf( "\n" );
|
|
|
|
pTempRow = pTempRow->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DoGetHashTableIndex( VOID )
|
|
{
|
|
DWORD Status = NO_ERROR;
|
|
WCHAR Name[256];
|
|
DWORD index;
|
|
DWORD CacheHashTableSize;
|
|
DWORD CacheHashTableBucketSize;
|
|
DWORD NumberOfCacheEntries;
|
|
DWORD NumberOfRecords;
|
|
DWORD NumberOfExpiredRecords;
|
|
PDNS_STATS_TABLE pStatsTable = NULL;
|
|
PDNS_STATS_TABLE pTempRow = NULL;
|
|
|
|
RpcTryExcept
|
|
{
|
|
Status = CRrGetHashTableStats( NULL,
|
|
&CacheHashTableSize,
|
|
&CacheHashTableBucketSize,
|
|
&NumberOfCacheEntries,
|
|
&NumberOfRecords,
|
|
&NumberOfExpiredRecords,
|
|
&pStatsTable );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
Status = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( Status == RPC_S_SERVER_UNAVAILABLE ||
|
|
Status == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( Status )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( Status );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
Status, ErrorString );
|
|
return;
|
|
}
|
|
|
|
printf( " CacheHashTableSize : %d\n", CacheHashTableSize );
|
|
printf( " CacheHashTableBucketSize : %d\n", CacheHashTableBucketSize );
|
|
printf( " NumberOfCacheEntries : %d\n", NumberOfCacheEntries );
|
|
printf( " NumberOfRecords : %d\n", NumberOfRecords );
|
|
printf( " NumberOfExpiredRecords : %d\n", NumberOfExpiredRecords );
|
|
|
|
printf( "Name: " );
|
|
GetStringW( Name );
|
|
printf( "\n" );
|
|
|
|
COMPUTE_STRING_HASH_2( Name, CacheHashTableSize, &index );
|
|
|
|
printf( " Hash table index for %S is : %d\n",
|
|
Name,
|
|
index );
|
|
|
|
pTempRow = pStatsTable;
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintServerInfo( IN PDNS_RPC_SERVER_INFO pServerInfo )
|
|
{
|
|
PDNS_RPC_SERVER_INFO pTempServerInfo = pServerInfo;
|
|
DWORD iter = 1;
|
|
|
|
while ( pTempServerInfo )
|
|
{
|
|
printf( " Server Info (%d):\n", iter );
|
|
printf( " -------------------------------------\n" );
|
|
printf( " ipAddress : %d.%d.%d.%d\n",
|
|
((BYTE *) &pTempServerInfo->ipAddress)[0],
|
|
((BYTE *) &pTempServerInfo->ipAddress)[1],
|
|
((BYTE *) &pTempServerInfo->ipAddress)[2],
|
|
((BYTE *) &pTempServerInfo->ipAddress)[3] );
|
|
printf( " Status : 0x%x\n", pTempServerInfo->Status );
|
|
printf( " Priority : %d\n", pTempServerInfo->Priority );
|
|
pTempServerInfo = pTempServerInfo->pNext;
|
|
iter++;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintRecords (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
PDNS_RECORD pTemp = pDnsRecord;
|
|
|
|
while ( pTemp )
|
|
{
|
|
PrintRecord( pTemp );
|
|
pTemp = pTemp->pNext;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
if ( ! pDnsRecord )
|
|
return;
|
|
|
|
printf( " Record Name : %S\n", pDnsRecord->pName );
|
|
printf( " Record Type : %d\n", pDnsRecord->wType );
|
|
printf( " Time To Live : %d (seconds)\n", pDnsRecord->dwTtl );
|
|
printf( " Data Length : %d\n", pDnsRecord->wDataLength );
|
|
|
|
if ( pDnsRecord->Flags.S.Section == DNSREC_QUESTION )
|
|
printf( " Section : Question Record\n" );
|
|
else if ( pDnsRecord->Flags.S.Section == DNSREC_ANSWER )
|
|
printf( " Section : Answer Record\n" );
|
|
else if ( pDnsRecord->Flags.S.Section == DNSREC_AUTHORITY )
|
|
printf( " Section : Authority Record\n" );
|
|
else
|
|
printf( " Section : Additional Record\n" );
|
|
|
|
switch( pDnsRecord->wType )
|
|
{
|
|
case DNS_TYPE_A :
|
|
PrintARecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_SOA :
|
|
PrintSOARecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_PTR :
|
|
case DNS_TYPE_NS :
|
|
case DNS_TYPE_CNAME :
|
|
case DNS_TYPE_MB :
|
|
case DNS_TYPE_MD :
|
|
case DNS_TYPE_MF :
|
|
case DNS_TYPE_MG :
|
|
case DNS_TYPE_MR :
|
|
PrintPTRRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_MINFO :
|
|
case DNS_TYPE_RP :
|
|
PrintMINFORecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_MX :
|
|
case DNS_TYPE_AFSDB :
|
|
case DNS_TYPE_RT :
|
|
PrintMXRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_HINFO :
|
|
case DNS_TYPE_ISDN :
|
|
case DNS_TYPE_TEXT :
|
|
case DNS_TYPE_X25 :
|
|
PrintHINFORecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_NULL :
|
|
PrintNULLRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_WKS :
|
|
PrintWKSRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_AAAA :
|
|
PrintAAAARecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_SRV :
|
|
PrintSRVRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_WINS :
|
|
PrintWINSRecord( pDnsRecord );
|
|
break;
|
|
|
|
case DNS_TYPE_NBSTAT :
|
|
PrintWINSRRecord( pDnsRecord );
|
|
break;
|
|
|
|
default :
|
|
printf( "Don't know how to print record type %d\n", pDnsRecord->wType );
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintARecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " A record :\n" );
|
|
printf( " ipAddress = %d.%d.%d.%d\n",
|
|
((BYTE *) &pDnsRecord->Data.A.ipAddress)[0],
|
|
((BYTE *) &pDnsRecord->Data.A.ipAddress)[1],
|
|
((BYTE *) &pDnsRecord->Data.A.ipAddress)[2],
|
|
((BYTE *) &pDnsRecord->Data.A.ipAddress)[3] );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintSOARecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " SOA record :\n" );
|
|
printf( " pNamePrimaryServer = %S\n",
|
|
pDnsRecord->Data.SOA.pNamePrimaryServer );
|
|
printf( " pNameAdministrator = %S\n",
|
|
pDnsRecord->Data.SOA.pNameAdministrator );
|
|
printf( " dwSerialNo = %d\n",
|
|
pDnsRecord->Data.SOA.dwSerialNo );
|
|
printf( " dwRefresh = %d\n",
|
|
pDnsRecord->Data.SOA.dwRefresh );
|
|
printf( " dwRetry = %d\n",
|
|
pDnsRecord->Data.SOA.dwRetry );
|
|
printf( " dwExpire = %d\n",
|
|
pDnsRecord->Data.SOA.dwExpire );
|
|
printf( " dwDefaultTtl = %d\n",
|
|
pDnsRecord->Data.SOA.dwDefaultTtl );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintPTRRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " PTR, NS, CNAME, MB, MD, MF, MG, MR record :\n" );
|
|
printf( " nameHost = %S\n",
|
|
pDnsRecord->Data.PTR.pNameHost );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintMINFORecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " MINFO, RP record :\n" );
|
|
printf( " pNameMailbox = %S\n",
|
|
pDnsRecord->Data.MINFO.pNameMailbox );
|
|
printf( " pNameErrorsMailbox = %S\n",
|
|
pDnsRecord->Data.MINFO.pNameErrorsMailbox );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintMXRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " MX, AFSDB, RT record :\n" );
|
|
printf( " pNameExchange = %S\n",
|
|
pDnsRecord->Data.MX.pNameExchange );
|
|
printf( " wPreference = %d\n",
|
|
pDnsRecord->Data.MX.wPreference );
|
|
printf( " Pad = %d\n",
|
|
pDnsRecord->Data.MX.Pad );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintHINFORecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
DWORD iter;
|
|
|
|
printf( " HINFO, ISDN, TEXT, X25 record :\n" );
|
|
printf( " dwStringCount = %d\n",
|
|
pDnsRecord->Data.HINFO.dwStringCount );
|
|
for ( iter = 0; iter < pDnsRecord->Data.HINFO.dwStringCount; iter ++ )
|
|
{
|
|
printf( " pStringArray[%d] = %S\n",
|
|
iter,
|
|
pDnsRecord->Data.HINFO.pStringArray[iter] );
|
|
}
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintNULLRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " NULL record :\n" );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintWKSRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " WKS record :\n" );
|
|
printf( " ipAddress = %d.%d.%d.%d\n",
|
|
((BYTE *) &pDnsRecord->Data.WKS.ipAddress)[0],
|
|
((BYTE *) &pDnsRecord->Data.WKS.ipAddress)[1],
|
|
((BYTE *) &pDnsRecord->Data.WKS.ipAddress)[2],
|
|
((BYTE *) &pDnsRecord->Data.WKS.ipAddress)[3] );
|
|
printf( " chProtocol = %d\n",
|
|
pDnsRecord->Data.WKS.chProtocol );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintAAAARecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " AAAA record :\n" );
|
|
printf( " ipAddress = %d.%d.%d.%d\n",
|
|
((BYTE *) &pDnsRecord->Data.AAAA.ipv6Address)[0],
|
|
((BYTE *) &pDnsRecord->Data.AAAA.ipv6Address)[1],
|
|
((BYTE *) &pDnsRecord->Data.AAAA.ipv6Address)[2],
|
|
((BYTE *) &pDnsRecord->Data.AAAA.ipv6Address)[3] );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintSRVRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " SRV record :\n" );
|
|
printf( " pNameTarget = %S\n",
|
|
pDnsRecord->Data.SRV.pNameTarget );
|
|
printf( " wPriority = %d\n",
|
|
pDnsRecord->Data.SRV.wPriority );
|
|
printf( " wWeight = %d\n",
|
|
pDnsRecord->Data.SRV.wWeight );
|
|
printf( " wPort = %d\n",
|
|
pDnsRecord->Data.SRV.wPort );
|
|
printf( " Pad = %d\n",
|
|
pDnsRecord->Data.SRV.Pad );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintWINSRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " WINS record :\n" );
|
|
printf( " dwMappingFlag = %d\n",
|
|
pDnsRecord->Data.WINS.dwMappingFlag );
|
|
printf( " dwLookupTimeout = %d\n",
|
|
pDnsRecord->Data.WINS.dwLookupTimeout );
|
|
printf( " dwCacheTimeout = %d\n",
|
|
pDnsRecord->Data.WINS.dwCacheTimeout );
|
|
printf( " cWinsServerCount = %d\n",
|
|
pDnsRecord->Data.WINS.cWinsServerCount );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
PrintWINSRRecord (
|
|
IN PDNS_RECORD pDnsRecord )
|
|
{
|
|
printf( " NBSTAT record :\n" );
|
|
printf( " dwMappingFlag = %d\n",
|
|
pDnsRecord->Data.WINSR.dwMappingFlag );
|
|
printf( " dwLookupTimeout = %d\n",
|
|
pDnsRecord->Data.WINSR.dwLookupTimeout );
|
|
printf( " dwCacheTimeout = %d\n",
|
|
pDnsRecord->Data.WINSR.dwCacheTimeout );
|
|
printf( " pNameResultDomain = %S\n",
|
|
pDnsRecord->Data.WINSR.pNameResultDomain );
|
|
printf( "\n" );
|
|
}
|
|
|
|
|
|
VOID
|
|
GetCachedData(
|
|
IN LPWSTR Name,
|
|
IN WORD Type )
|
|
{
|
|
PDNS_RECORD pDNSRecord = NULL;
|
|
DNS_STATUS DnsStatus = NO_ERROR;
|
|
|
|
RpcTryExcept
|
|
{
|
|
DnsStatus = CRrReadCacheEntry( NULL, Name, Type, &pDNSRecord );
|
|
}
|
|
RpcExcept(1)
|
|
{
|
|
DnsStatus = RpcExceptionCode();
|
|
}
|
|
RpcEndExcept
|
|
|
|
if ( DnsStatus == RPC_S_SERVER_UNAVAILABLE ||
|
|
DnsStatus == RPC_S_UNKNOWN_IF )
|
|
{
|
|
printf( "Error: DNS Caching Resolver Service is not running\n" );
|
|
return;
|
|
}
|
|
|
|
if ( DnsStatus )
|
|
{
|
|
LPSTR ErrorString = DnsStatusToErrorString_A( DnsStatus );
|
|
|
|
printf( "Error: 0x%.8x (%s)\n",
|
|
DnsStatus, ErrorString );
|
|
return;
|
|
}
|
|
|
|
PrintRecords ( ( PDNS_RECORD ) pDNSRecord );
|
|
|
|
DnsFreeRRSet( (PDNS_RECORD) pDNSRecord, TRUE );
|
|
}
|
|
|
|
|