2041 lines
64 KiB
C++
2041 lines
64 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) 2002 Microsoft Corporation
|
|
//
|
|
// Abstract:
|
|
//
|
|
// Source file for DNS diagnostic tool. Links into dnslib.lib which has
|
|
// the SMTP DNS resolution logic and calls into DNS resolution functions
|
|
// while printing diagnostic messages.
|
|
//
|
|
// Author:
|
|
//
|
|
// gpulla
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "dnsdiag.h"
|
|
|
|
int g_nProgramStatus = DNSDIAG_FAILURE;
|
|
CDnsLogger *g_pDnsLogger = NULL;
|
|
HANDLE g_hCompletion = NULL;
|
|
BOOL g_fDebug = FALSE;
|
|
DWORD g_cDnsObjects = 0;
|
|
HANDLE g_hConsole = INVALID_HANDLE_VALUE;
|
|
DWORD g_rgBindings[32];
|
|
PIP_ARRAY g_pipBindings = (PIP_ARRAY)g_rgBindings;
|
|
DWORD g_cMaxBindings = sizeof(g_rgBindings)/sizeof(DWORD) - 1;
|
|
|
|
char g_szUsage[] =
|
|
"Summary:\n"
|
|
"\n"
|
|
"This tool is used to troubleshoot problems with DNS resolution for SMTP. It\n"
|
|
"simulates SMTPSVC's internal code-path and prints diagnostic messages that\n"
|
|
"indicate how the resolution is proceeding. The tool must be run on the machine\n"
|
|
"where the DNS problems are occurring.\n"
|
|
"\n"
|
|
"Program return codes:\n"
|
|
" These are set as the ERRORLEVEL for usage in batch files.\n"
|
|
"\n"
|
|
" 0 - The name was resolved successfully to one or more IP addresses.\n"
|
|
" 1 - The name could not be resolved due to an unspecified error.\n"
|
|
" 2 - The name does not exist. The error was returned by an authoritative DNS\n"
|
|
" server for the domain.\n"
|
|
" 3 - The name could not be located in DNS. This is not an error from the\n"
|
|
" authoritative DNS server.\n"
|
|
" 4 - A loopback was detected.\n"
|
|
"\n"
|
|
"Usage:\n"
|
|
"\n"
|
|
"dnsdiag <hostname> [-d] [options]\n"
|
|
"\n"
|
|
"<hostname>\n"
|
|
" Hostname to query for. Note that this may not be the same as the display\n"
|
|
" -name of the queue (in ESM, if Exchange is installed). It should be the\n"
|
|
" fully-qualified domain name of the target for the queue seeing the DNS\n"
|
|
" errors\n"
|
|
"\n"
|
|
"-d\n"
|
|
" This is a special option to run in debug/verbose mode. There is a lot of\n"
|
|
" output, and the most important messages (the ones that normally appear when\n"
|
|
" this mode is not turned on) are highlighted in a different color.\n"
|
|
"\n"
|
|
"Options are:\n"
|
|
"-v <VSID>\n"
|
|
" If running on an Exchange DMZ machine, you can specify the VSI# of the\n"
|
|
" VSI to simulate DNS for that SMTP VS. Then this tool will read the\n"
|
|
" external DNS serverlist for that VSI and query that serverlist for\n"
|
|
" <hostname> when <hostname> is an \"external\" host. If <hostname> is the\n"
|
|
" name of an Exchange computer, the query is generated against the default\n"
|
|
" DNS servers for the local computer.\n"
|
|
"\n"
|
|
"-s <serverlist>\n"
|
|
" DNS servers to use, if you want to specify a specific set of servers.\n"
|
|
"\n"
|
|
" If this option is not specified, the default DNS servers on the local\n"
|
|
" computer are used as specified by -v.\n"
|
|
"\n"
|
|
" This option is incompatible with -v.\n"
|
|
"\n"
|
|
"-p <protocol>\n"
|
|
" TCP, UDP or DEF. TCP generates a TCP only query. UDP generates a UDP only\n"
|
|
" query. DEF generates a default query that will initially query a server with\n"
|
|
" UDP, and then if that query results in a truncated reply, it will be retried\n"
|
|
" with TCP.\n"
|
|
"\n"
|
|
" If this option is not specified the protocol configured in the metabase for\n"
|
|
" /smtpsvc/UseTcpDns is used.\n"
|
|
"\n"
|
|
" This option is incompatible with the -v option.\n"
|
|
"\n"
|
|
"-a\n"
|
|
" All the DNS servers obtained (either through the registry, active directory,\n"
|
|
" or -s option) are tried in sequence and the results of querying each are\n"
|
|
" displayed.\n";
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// DNS diagnostic utility. See above for usage.
|
|
//-----------------------------------------------------------------------------
|
|
int __cdecl main(int argc, char *argv[])
|
|
{
|
|
CAsyncTestDns *pAsyncTestDns = NULL;
|
|
CSimpleDnsServerList *pDnsSimpleList = NULL;
|
|
CDnsLogToFile *pDnsLogToFile = NULL;
|
|
char szMyHostName[MAX_PATH + 1];
|
|
char szHostName[MAX_PATH + 1];
|
|
BOOL fAtqInitialized = FALSE;
|
|
BOOL fIISRTLInitialized = FALSE;
|
|
BOOL fWSAInitialized = FALSE;
|
|
WORD wVersion = MAKEWORD(2, 2);
|
|
WSADATA wsaData;
|
|
BOOL fRet = TRUE;
|
|
int nRet = 0;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
DWORD dwDnsFlags = 0;
|
|
BOOL fUdp = TRUE;
|
|
BOOL fGlobalList = FALSE;
|
|
BOOL fTryAllDnsServers = FALSE;
|
|
DWORD rgDnsServers[16];
|
|
PIP_ARRAY pipArray = (PIP_ARRAY)rgDnsServers;
|
|
DWORD cMaxServers = sizeof(rgDnsServers)/sizeof(DWORD) - 1;
|
|
DWORD rgSingleServer[2];
|
|
PIP_ARRAY pipSingleServer = (PIP_ARRAY)rgSingleServer;
|
|
DWORD cNextServer = 0;
|
|
PIP_ARRAY pipDnsArray = NULL;
|
|
|
|
ZeroMemory(rgDnsServers, sizeof(rgDnsServers));
|
|
ZeroMemory(rgSingleServer, sizeof(rgSingleServer));
|
|
ZeroMemory(g_rgBindings, sizeof(g_rgBindings));
|
|
|
|
if(1 == argc)
|
|
{
|
|
SetProgramStatus(DNSDIAG_RESOLVED);
|
|
printf("%s", g_szUsage);
|
|
goto Cleanup;
|
|
}
|
|
|
|
nRet = WSAStartup(wVersion, &wsaData);
|
|
if(0 != nRet)
|
|
{
|
|
errprintf("Failed Winsock init, error - %d\n", WSAGetLastError());
|
|
goto Cleanup;
|
|
}
|
|
|
|
fWSAInitialized = TRUE;
|
|
|
|
if(0 != gethostname(szMyHostName, sizeof(szMyHostName)))
|
|
{
|
|
printf("Unable to get local machine name. Error - %d\n",
|
|
WSAGetLastError());
|
|
goto Cleanup;
|
|
}
|
|
|
|
g_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
if(g_hConsole == INVALID_HANDLE_VALUE)
|
|
{
|
|
printf("Failed to GetStdHandle\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
g_hCompletion = CreateEvent(NULL, TRUE, FALSE, NULL);
|
|
if(NULL == g_hCompletion)
|
|
goto Cleanup;
|
|
|
|
dbgprintf("Reading options and configuration.\n");
|
|
fRet = ParseCommandLine(argc, argv, szHostName,
|
|
sizeof(szHostName), &pDnsLogToFile, pipArray, cMaxServers,
|
|
&fUdp, &dwDnsFlags, &fGlobalList, &fTryAllDnsServers);
|
|
|
|
if(!fRet)
|
|
goto Cleanup;
|
|
|
|
g_pDnsLogger = (CDnsLogger *)pDnsLogToFile;
|
|
|
|
fIISRTLInitialized = InitializeIISRTL();
|
|
if(!fIISRTLInitialized)
|
|
{
|
|
errprintf("Failed IISRTL init, error - %d\n", GetLastError());
|
|
errprintf("Make sure you are running this tool on a server with IIS "
|
|
"installed\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
fAtqInitialized = AtqInitialize(0);
|
|
if(!fAtqInitialized)
|
|
{
|
|
errprintf("Failed ISATQ init, error - %d\n", GetLastError());
|
|
errprintf("Make sure you are running this tool on a server with IIS "
|
|
"installed\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
cNextServer = 0;
|
|
pipSingleServer->cAddrCount = 1;
|
|
|
|
while(TRUE)
|
|
{
|
|
//
|
|
// Set pipDnsArray to the DNS servers to be used. If the -a option is
|
|
// specified, each DNS server will be tried individually. We will run
|
|
// through this while loop and set pipDnsArray to single DNS server
|
|
// in turn. If -a is not given, all servers are set on pipDnsServers.
|
|
//
|
|
|
|
if(fTryAllDnsServers)
|
|
{
|
|
if(cNextServer >= pipArray->cAddrCount)
|
|
break;
|
|
|
|
pipSingleServer->aipAddrs[0] = pipArray->aipAddrs[cNextServer];
|
|
cNextServer++;
|
|
pipDnsArray = pipSingleServer;
|
|
msgprintf("\n\nQuerying DNS server: %s\n",
|
|
iptostring(pipSingleServer->aipAddrs[0]));
|
|
}
|
|
else
|
|
{
|
|
pipDnsArray = pipArray;
|
|
}
|
|
|
|
//
|
|
// Create the DNS serverlist object and set however many DNS servers we
|
|
// want to query on the object
|
|
//
|
|
|
|
pDnsSimpleList = new CSimpleDnsServerList();
|
|
if(!pDnsSimpleList)
|
|
{
|
|
errprintf("Out of memory creating DNS serverlist object.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
fRet = pDnsSimpleList->Update(pipDnsArray);
|
|
if(!fRet)
|
|
{
|
|
errprintf("Unable to create DNS serverlist\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// DNS querying object
|
|
//
|
|
|
|
pAsyncTestDns = new CAsyncTestDns(szMyHostName, fGlobalList, g_hCompletion);
|
|
if(!pAsyncTestDns)
|
|
{
|
|
errprintf("Out of memory allocating DNS object.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwStatus = pAsyncTestDns->Dns_QueryLib(
|
|
szHostName,
|
|
DNS_TYPE_MX,
|
|
dwDnsFlags,
|
|
fUdp,
|
|
pDnsSimpleList,
|
|
fGlobalList);
|
|
|
|
|
|
//
|
|
// If the query failed we need to manually delete the object. If the
|
|
// query succeeded, the completing ATQ threads will delete the object
|
|
// after the results have been reported.
|
|
//
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
errprintf("DNS query failed.\n");
|
|
delete pAsyncTestDns;
|
|
pAsyncTestDns = NULL;
|
|
}
|
|
|
|
//
|
|
// This event is set in the destructor of pAsyncTestDns when the object
|
|
// has finally finished the query (either successfully or with a failure).
|
|
//
|
|
|
|
WaitForSingleObject(g_hCompletion, INFINITE);
|
|
ResetEvent(g_hCompletion);
|
|
|
|
delete pDnsSimpleList;
|
|
pDnsSimpleList = NULL;
|
|
|
|
//
|
|
// If -a was specified, we go on to the next iteration, and pick up the
|
|
// next DNS server in line. Otherwise we just finish after a single
|
|
// query.
|
|
//
|
|
|
|
if(!fTryAllDnsServers)
|
|
break;
|
|
}
|
|
|
|
Cleanup:
|
|
if(pDnsSimpleList)
|
|
delete pDnsSimpleList;
|
|
|
|
while(g_cDnsObjects)
|
|
Sleep(100);
|
|
|
|
if(fAtqInitialized)
|
|
{
|
|
dbgprintf("Shutting down ATQ\n");
|
|
AtqTerminate();
|
|
}
|
|
|
|
if(fIISRTLInitialized)
|
|
{
|
|
dbgprintf("Shutting down IISRTL\n");
|
|
TerminateIISRTL();
|
|
}
|
|
|
|
if(fWSAInitialized)
|
|
WSACleanup();
|
|
|
|
if(g_hCompletion)
|
|
CloseHandle(g_hCompletion);
|
|
|
|
dbgprintf("Exit code: %d\n", g_nProgramStatus);
|
|
exit(g_nProgramStatus);
|
|
return g_nProgramStatus;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Parses the argc and argv and gets the various options. Also reads from
|
|
// the metabase and DS to get the configuration as needed.
|
|
//
|
|
// Arguments:
|
|
// IN int argc - Command line arg-count
|
|
// IN char *argv[] - Command line args
|
|
// OUT char *pszHostName - Pass in buffer to get target host
|
|
// IN DWORD cchHostName - Length of above buffer in chars
|
|
// OUT CDnsLogToFile **ppDnsLogger - Returns a logging object
|
|
// OUT PIP_ARRAY pipArray - Pass in buffer to get DNS servers
|
|
// IN int cMaxServers - Number of DNS servers that can be returned above
|
|
// OUT BOOL *pfUdp - Use TCP or UDP for the query
|
|
// OUT DWORD *pdwDnsFlags - Metabase configured SMTP DNS flags
|
|
// OUT BOOL *pfGlobalList - Are the servers global?
|
|
// OUT BOOL *pfTryAllServers - The "-a" option
|
|
//
|
|
// Returns:
|
|
// TRUE arguments were successfully parsed, configuration was read without
|
|
// problems, and initialization completed without errors.
|
|
// FALSE there was an error. Abort. This function prints error messages
|
|
// to stdout.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL ParseCommandLine(
|
|
int argc,
|
|
char *argv[],
|
|
char *pszHostName,
|
|
DWORD cchHostName,
|
|
CDnsLogToFile **ppDnsLogger,
|
|
PIP_ARRAY pipArray,
|
|
DWORD cMaxServers,
|
|
BOOL *pfUdp,
|
|
DWORD *pdwDnsFlags,
|
|
BOOL *pfGlobalList,
|
|
BOOL *pfTryAllServers)
|
|
{
|
|
int i = 0;
|
|
BOOL fRet = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
BOOL fOptionS = FALSE;
|
|
BOOL fOptionV = FALSE;
|
|
BOOL fOptionD = FALSE;
|
|
BOOL fOptionA = FALSE;
|
|
BOOL fOptionP = FALSE;
|
|
DWORD dwVsid = 0;
|
|
DWORD cServers = 0;
|
|
DWORD dwIpAddress = INADDR_NONE;
|
|
|
|
*pszHostName = '\0';
|
|
|
|
*pfGlobalList = FALSE;
|
|
*pfTryAllServers = FALSE;
|
|
|
|
if(argc < 2)
|
|
{
|
|
errprintf("Must specify a hostname as first argument.\n");
|
|
printf("%s", g_szUsage);
|
|
return FALSE;
|
|
}
|
|
else if(argc == 2 && (!_stricmp(argv[1], "/?") || !_stricmp(argv[1], "-?")))
|
|
{
|
|
SetProgramStatus(DNSDIAG_RESOLVED);
|
|
printf("%s", g_szUsage);
|
|
return FALSE;
|
|
}
|
|
|
|
pszHostName[cchHostName - 1] = '\0';
|
|
strncpy(pszHostName, argv[1], cchHostName);
|
|
if(pszHostName[cchHostName - 1] != '\0')
|
|
{
|
|
errprintf("Hostname too long. Maximum that can be handled by this tool is "
|
|
"%d characters\n", cchHostName);
|
|
return FALSE;
|
|
}
|
|
|
|
i = 2;
|
|
|
|
while(i < argc)
|
|
{
|
|
if(!g_fDebug && !_stricmp(argv[i], "-d"))
|
|
{
|
|
i++;
|
|
g_fDebug = TRUE;
|
|
printf("Running in debug/verbose mode.\n");
|
|
continue;
|
|
}
|
|
|
|
if(!fOptionV && !_stricmp(argv[i], "-v"))
|
|
{
|
|
i++;
|
|
if(i >= argc)
|
|
{
|
|
printf("Specify an SMTP VSI# for -v option.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwVsid = atoi(argv[i]);
|
|
if(dwVsid <= 0)
|
|
{
|
|
printf("Illegal operand to -v. Should be a number > 0.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
fOptionV = TRUE;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if(!fOptionS && !_stricmp(argv[i], "-s"))
|
|
{
|
|
i++;
|
|
if(i >= argc)
|
|
{
|
|
printf("No DNS servers specified for -s option.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
cServers = 0;
|
|
while(*argv[i] != '-')
|
|
{
|
|
dwIpAddress = inet_addr(argv[i]);
|
|
if(dwIpAddress == INADDR_NONE)
|
|
{
|
|
printf("Non IP address \"%s\" in -s option.\n", argv[i]);
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(cServers >= cMaxServers)
|
|
{
|
|
printf("Too many servers in -s. Maximum that can be handled"
|
|
" by this tool is %d.\n", cMaxServers);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pipArray->aipAddrs[cServers] = dwIpAddress;
|
|
cServers++;
|
|
i++;
|
|
|
|
if(i >= argc)
|
|
break;
|
|
}
|
|
|
|
pipArray->cAddrCount = cServers;
|
|
*pdwDnsFlags = 0;
|
|
*pfGlobalList = FALSE;
|
|
fOptionS = TRUE;
|
|
continue;
|
|
}
|
|
|
|
if(!fOptionA && !_stricmp(argv[i], "-a"))
|
|
{
|
|
fOptionA = TRUE;
|
|
*pfTryAllServers = TRUE;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if(!fOptionP && !_stricmp(argv[i], "-p"))
|
|
{
|
|
i++;
|
|
|
|
if(i >= argc)
|
|
{
|
|
printf("Specify protocol for -p option. Either TCP, UDP or"
|
|
" DEF (for default). Default means that UDP will be tried"
|
|
" first followed by TCP if the reply was truncated.\n");
|
|
}
|
|
|
|
if(!_stricmp(argv[i], "tcp"))
|
|
{
|
|
*pfUdp = FALSE;
|
|
*pdwDnsFlags = DNS_FLAGS_TCP_ONLY;
|
|
}
|
|
else if(!_stricmp(argv[i], "udp"))
|
|
{
|
|
*pfUdp = TRUE;
|
|
*pdwDnsFlags = DNS_FLAGS_UDP_ONLY;
|
|
}
|
|
else if(!_stricmp(argv[i], "def"))
|
|
{
|
|
*pfUdp = TRUE;
|
|
*pdwDnsFlags = DNS_FLAGS_NONE;
|
|
}
|
|
else
|
|
{
|
|
printf("Unrecognized protocol %s\n", argv[i]);
|
|
goto Cleanup;
|
|
}
|
|
|
|
i++;
|
|
fOptionP = TRUE;
|
|
continue;
|
|
}
|
|
|
|
printf("Unrecognized option \"%s\".\n", argv[i]);
|
|
printf("%s", g_szUsage);
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(fOptionV)
|
|
{
|
|
if(fOptionS)
|
|
{
|
|
printf("Options -s and -v are incompatible\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(fOptionP)
|
|
{
|
|
printf("Options -p and -v are incompatible\n");
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
*ppDnsLogger = new CDnsLogToFile();
|
|
if(!*ppDnsLogger)
|
|
{
|
|
errprintf("Out of memory creating DNS logger.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(fOptionV)
|
|
{
|
|
hr = HrGetVsiConfig(pszHostName, dwVsid, pdwDnsFlags, pipArray,
|
|
cMaxServers, pfGlobalList, pfUdp, g_pipBindings,
|
|
g_cMaxBindings);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
errprintf("Unable to get VSI configuration\n");
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
if(pipArray->cAddrCount == 0)
|
|
{
|
|
errprintf("Either specify DNS servers using -s, or use -v.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
Cleanup:
|
|
if(*ppDnsLogger)
|
|
{
|
|
delete *ppDnsLogger;
|
|
*ppDnsLogger = NULL;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
//
|
|
// This function reads from the metabase and the Active directory (if
|
|
// Exchange is installed) to determine the DNS settings for the VSI that
|
|
// is to be simulated. Additionally, if the VSI is configured as a DMZ
|
|
// (i.e. with additional external DNS servers configured in the AD), we
|
|
// determine if the target server is an Exchange computer by searching
|
|
// for it in the directory.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// IN LPSTR pszTargetServer - Name to resolve
|
|
// IN DWORD dwVsid - VSI to simulate
|
|
// OUT PDWORD pdwFlags - Flags to pass to Dns_QueryLib (from metabase)
|
|
// OUT PIP_ARRAY pipDnsServers - Returns DNS servers to query
|
|
// IN DWORD cMaxServers - Capacity of above buffer
|
|
// OUT BOOL *pfGlobalList - TRUE if default DNS servers are to be used
|
|
// OUT BOOL *pfUdp - Indicates protocol to connect with DNS
|
|
//
|
|
// Returns:
|
|
//
|
|
// S_OK - If the configuration was successfully read
|
|
// ERROR HRESULT if something failed. Diagnostic error messages are
|
|
// printed.
|
|
//-----------------------------------------------------------------------------
|
|
HRESULT HrGetVsiConfig(
|
|
LPSTR pszTargetServer,
|
|
DWORD dwVsid,
|
|
PDWORD pdwFlags,
|
|
PIP_ARRAY pipDnsServers,
|
|
DWORD cMaxServers,
|
|
BOOL *pfGlobalList,
|
|
BOOL *pfUdp,
|
|
PIP_ARRAY pipServerBindings,
|
|
DWORD cMaxServerBindings)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
BOOL fCoInitialized = FALSE;
|
|
IMSAdminBase *pIMeta = NULL;
|
|
METADATA_RECORD mdRecord;
|
|
DWORD dwLength = 0;
|
|
PBYTE pbMDData = (PBYTE) pdwFlags;
|
|
PIP_ARRAY pipTempServers = NULL;
|
|
BOOL fExternal = FALSE;
|
|
WCHAR wszVirtualServer[256];
|
|
WCHAR wszBindings[256];
|
|
|
|
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
if(FAILED(hr))
|
|
{
|
|
errprintf("Unable to initialize COM. The error HRESULT is 0x%08x\n", hr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
fCoInitialized = TRUE;
|
|
|
|
// Check metabase configuration for DNS
|
|
hr = CoCreateInstance(CLSID_MSAdminBase, NULL, CLSCTX_ALL,
|
|
IID_IMSAdminBase, (void **) &pIMeta);
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
errprintf("Failed to connect to IIS metabase. Make sure the IISADMIN"
|
|
" service is installed and running and that you are running this"
|
|
" tool with sufficient permissions. The failure HRESULT is"
|
|
" 0x%08x\n", hr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
ZeroMemory(&mdRecord, sizeof(mdRecord));
|
|
mdRecord.dwMDIdentifier = MD_SMTP_USE_TCP_DNS;
|
|
mdRecord.dwMDAttributes = METADATA_INHERIT;
|
|
mdRecord.dwMDUserType = IIS_MD_UT_FILE;
|
|
mdRecord.dwMDDataType = DWORD_METADATA;
|
|
mdRecord.dwMDDataLen = sizeof(DWORD);
|
|
mdRecord.pbMDData = pbMDData;
|
|
|
|
hr = pIMeta->GetData(METADATA_MASTER_ROOT_HANDLE, L"/LM/SMTPSVC",
|
|
&mdRecord, &dwLength);
|
|
|
|
if(hr == MD_ERROR_DATA_NOT_FOUND)
|
|
{
|
|
*pdwFlags = DNS_FLAGS_NONE;
|
|
dbgprintf("The DNS flags are not explicitly set in the metabase, assuming "
|
|
"default flags - 0x%08x\n", DNS_FLAGS_NONE);
|
|
}
|
|
else if(FAILED(hr))
|
|
{
|
|
errprintf("Error reading key MD_SMTP_USE_TCP_DNS (%d) under /SMTPSVC in"
|
|
" the metabase. The error HRESULT is 0x%08x - %s\n",
|
|
MD_SMTP_USE_TCP_DNS, hr, MDErrorToString(hr));
|
|
goto Cleanup;
|
|
}
|
|
else
|
|
{
|
|
dbgprintf("These DNS flags are configured in the metabase");
|
|
|
|
if(*pdwFlags & DNS_FLAGS_UDP_ONLY)
|
|
dbgprintf(" DNS_FLAGS_UDP_ONLY");
|
|
else if(*pdwFlags & DNS_FLAGS_TCP_ONLY)
|
|
dbgprintf(" DNS_FLAGS_TCP_ONLY");
|
|
|
|
dbgprintf(" (0x%08x)\n", *pdwFlags);
|
|
}
|
|
|
|
mdRecord.dwMDIdentifier = MD_SERVER_BINDINGS;
|
|
mdRecord.dwMDAttributes = METADATA_NO_ATTRIBUTES;
|
|
mdRecord.dwMDUserType = IIS_MD_UT_SERVER;
|
|
mdRecord.dwMDDataType = MULTISZ_METADATA;
|
|
mdRecord.dwMDDataLen = sizeof(wszBindings);
|
|
mdRecord.pbMDData = (PBYTE) wszBindings;
|
|
|
|
swprintf(wszVirtualServer, L"/LM/SMTPSVC/%d", dwVsid);
|
|
hr = pIMeta->GetData(METADATA_MASTER_ROOT_HANDLE, wszVirtualServer,
|
|
&mdRecord, &dwLength);
|
|
|
|
if(hr == MD_ERROR_DATA_NOT_FOUND)
|
|
{
|
|
errprintf("No VSI bindings in metabase. The key %S had no data.\n");
|
|
goto Cleanup;
|
|
}
|
|
else if(FAILED(hr))
|
|
{
|
|
errprintf("Error reading /SMTPSVC/%d/ServerBindings from the metabase."
|
|
" The error HRESULT is 0x%08x - %s\n", dwVsid, hr,
|
|
MDErrorToString(hr));
|
|
goto Cleanup;
|
|
}
|
|
else
|
|
{
|
|
if(!GetServerBindings(wszBindings, pipServerBindings,
|
|
cMaxServerBindings))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("These are the local IP addresses (server-bindings)\n");
|
|
if(g_fDebug)
|
|
PrintIPArray(pipServerBindings);
|
|
}
|
|
|
|
// UDP is used (for the intial query) iff exclusive TCP_ONLY is not set
|
|
*pfUdp = ((*pdwFlags) != DNS_FLAGS_TCP_ONLY);
|
|
|
|
dwErr = DsGetConfiguration(pszTargetServer, dwVsid, pipDnsServers,
|
|
cMaxServers, &fExternal);
|
|
|
|
if(dwErr != ERROR_SUCCESS)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// If external DNS servers were configured AND pszServer is an external
|
|
// target, then then we have all the information we need. Otherwise we
|
|
// need to supply the default DNS servers configured on this machine
|
|
//
|
|
|
|
if(pipDnsServers->cAddrCount > 0 && fExternal)
|
|
goto Cleanup;
|
|
|
|
*pfGlobalList = TRUE;
|
|
DnsGetDnsServerList(&pipTempServers);
|
|
if(NULL == pipTempServers)
|
|
{
|
|
errprintf("Unable to get configured DNS servers for this computer\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(pipTempServers->cAddrCount <= cMaxServers)
|
|
{
|
|
CopyMemory(pipDnsServers, pipTempServers,
|
|
(1 + pipTempServers->cAddrCount) * sizeof(DWORD));
|
|
}
|
|
else
|
|
{
|
|
errprintf("Too many DNS servers are configured on this computer for this"
|
|
" tool to handle. The maximum number that can be handled by this"
|
|
" tool is %d\n", cMaxServers);
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("Using the default DNS servers configured for this computer.\n");
|
|
if(g_fDebug)
|
|
PrintIPArray(pipDnsServers);
|
|
|
|
Cleanup:
|
|
if(pIMeta)
|
|
pIMeta->Release();
|
|
|
|
if(pipTempServers)
|
|
DnsApiFree(pipTempServers);
|
|
|
|
if(fCoInitialized)
|
|
CoUninitialize();
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL GetServerBindings(
|
|
WCHAR *pwszMultiSzBindings,
|
|
PIP_ARRAY pipServerBindings,
|
|
DWORD cMaxServerBindings)
|
|
{
|
|
int lErr = 0;
|
|
DWORD cbOutBuffer = 0;
|
|
WCHAR *pwszBinding = pwszMultiSzBindings;
|
|
WCHAR *pwchEnd = pwszBinding;
|
|
char szBinding[256];
|
|
int cchWritten = 0;
|
|
SOCKET sock;
|
|
SOCKADDR_IN *lpSockAddrIn = NULL;
|
|
BYTE rgbBuffer[512];
|
|
LPSOCKET_ADDRESS_LIST pIpBuffer = (LPSOCKET_ADDRESS_LIST)rgbBuffer;
|
|
|
|
if(*pwszBinding == L':')
|
|
{
|
|
// Blank binding string
|
|
dbgprintf("Encountered blank server binding string for VSI\n");
|
|
|
|
sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
if(sock == INVALID_SOCKET)
|
|
{
|
|
errprintf("Unable to create socket for WSAIoctl. The Win32 error"
|
|
" is %d\n", WSAGetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
lErr = WSAIoctl(sock, SIO_ADDRESS_LIST_QUERY, NULL, 0,
|
|
(PBYTE)(pIpBuffer), sizeof(rgbBuffer), &cbOutBuffer, NULL, NULL);
|
|
|
|
closesocket(sock);
|
|
if(lErr != 0)
|
|
{
|
|
errprintf("Unable to issue WSAIoctl to get local IP addresses."
|
|
" The Win32 error is %d\n", WSAGetLastError());
|
|
return FALSE;
|
|
}
|
|
|
|
if(pIpBuffer->iAddressCount > (int)cMaxServerBindings)
|
|
{
|
|
errprintf("%d IP addresses were returned for the local machine"
|
|
" by WSAIoctl. The maximum number that can be accomodated"
|
|
" by this tool is %d\n", pIpBuffer->iAddressCount,
|
|
cMaxServerBindings);
|
|
return FALSE;
|
|
}
|
|
|
|
for(pipServerBindings->cAddrCount = 0;
|
|
(int)pipServerBindings->cAddrCount < pIpBuffer->iAddressCount;
|
|
pipServerBindings->cAddrCount++)
|
|
{
|
|
lpSockAddrIn =
|
|
(SOCKADDR_IN *)
|
|
(pIpBuffer->Address[pipServerBindings->cAddrCount].lpSockaddr);
|
|
CopyMemory(
|
|
(PVOID)&(pipServerBindings->aipAddrs[pipServerBindings->cAddrCount]),
|
|
(PVOID)&(lpSockAddrIn->sin_addr),
|
|
sizeof(DWORD));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
while(TRUE)
|
|
{
|
|
pwchEnd = wcschr(pwszBinding, L':');
|
|
if(pwchEnd == NULL)
|
|
{
|
|
errprintf("Illegal format for server binding string. The server"
|
|
" binding string should be in the format <ipaddress>:<port>."
|
|
" Instead, the string is \"%S\"\n", pwszBinding);
|
|
return FALSE;
|
|
}
|
|
|
|
*pwchEnd = L'\0';
|
|
pwchEnd++;
|
|
|
|
if(pipServerBindings->cAddrCount > cMaxServerBindings)
|
|
{
|
|
errprintf("Too many server bindings for VSI. Maximum that can be"
|
|
" handled by this tool is %d.\n", cMaxServerBindings);
|
|
return FALSE;
|
|
}
|
|
|
|
// Explicit IP in binding string
|
|
cchWritten = wcstombs(szBinding, pwszBinding, sizeof(szBinding));
|
|
if(cchWritten < 0)
|
|
{
|
|
errprintf("Failed to conversion of %S from widechar to ASCII\n",
|
|
pwszBinding);
|
|
return FALSE;
|
|
}
|
|
|
|
pipServerBindings->aipAddrs[pipServerBindings->cAddrCount] =
|
|
inet_addr(szBinding);
|
|
|
|
if(pipServerBindings->aipAddrs[pipServerBindings->cAddrCount] ==
|
|
INADDR_NONE)
|
|
{
|
|
errprintf("Illegal format for binding\n");
|
|
return FALSE;
|
|
}
|
|
|
|
pipServerBindings->cAddrCount++;
|
|
|
|
// Skip to end of string
|
|
while(*pwchEnd != L'\0')
|
|
pwchEnd++;
|
|
|
|
// 2 NULL terminations signal end of MULTI_SZ
|
|
pwchEnd++;
|
|
if(*pwchEnd == L'\0')
|
|
return TRUE;
|
|
|
|
pwszBinding = pwchEnd;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Checks the regkey which is created when Exchange is installed, and uses
|
|
// it to determine if Exchange is installed.
|
|
// Arguments:
|
|
// OUT BOOL *pfBool - Set to TRUE if the regkey exists, FALSE otherwise.
|
|
// Returns:
|
|
// Win32 Error if something failed.
|
|
//-----------------------------------------------------------------------------
|
|
DWORD IsExchangeInstalled(BOOL *pfBool)
|
|
{
|
|
LONG lResult = 0;
|
|
HKEY hkExchange;
|
|
const char szExchange[] =
|
|
"Software\\Microsoft\\Exchange";
|
|
|
|
lResult = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
szExchange,
|
|
0,
|
|
KEY_READ,
|
|
&hkExchange);
|
|
|
|
if(lResult == ERROR_SUCCESS)
|
|
{
|
|
dbgprintf("Microsoft Exchange is installed on this machine.\n");
|
|
RegCloseKey(hkExchange);
|
|
*pfBool = TRUE;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
else if(lResult == ERROR_NOT_FOUND || lResult == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
dbgprintf("Microsoft Exchange not installed on this machine\n");
|
|
*pfBool = FALSE;
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
errprintf("Error opening registry key HKLM\\%s, Win32 err - %d\n",
|
|
szExchange, lResult);
|
|
return lResult;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Connects to a domain controller and reads configuration options for the
|
|
// VSI being simulated. In addition it checks if the target-server (which
|
|
// is to be resolved) is an Exchange computer that is a member of the
|
|
// Exchange Org or not.
|
|
//
|
|
// Arguments:
|
|
// IN char *pszTargetServer - Server to resolve
|
|
// IN DWORD dwVsid - VSI to simulate
|
|
// OUT PIP_ARRAY pipExternalDnsServers - External DNS servers on VSI if
|
|
// any are returned in this caller allocated buffer.
|
|
// IN DWORD cMaxServers - Capacity of above buffer.
|
|
// OUT PBOOL pfExternal - Set to TRUE when there are external DNS servers
|
|
// configured.
|
|
//
|
|
// Returns:
|
|
// ERROR_SUCCESS if configuration was read without problems.
|
|
// Win32 error code if there was a problem. Error messages are written to
|
|
// stdout for diagnostic purposes.
|
|
//-----------------------------------------------------------------------------
|
|
DWORD
|
|
DsGetConfiguration(
|
|
char *pszTargetServer,
|
|
DWORD dwVsid,
|
|
PIP_ARRAY pipExternalDnsServers,
|
|
DWORD cMaxServers,
|
|
PBOOL pfExternal)
|
|
{
|
|
DWORD dwErr = ERROR_NOT_FOUND;
|
|
BOOL fRet = FALSE;
|
|
PLDAP pldap = NULL;
|
|
PLDAPMessage pldapMsgContexts = NULL;
|
|
PLDAPMessage pldapMsgSmtpVsi = NULL;
|
|
PLDAPMessage pEntry = 0;
|
|
char szLocalComputerName[256];
|
|
DWORD cchLocalComputerName = sizeof(szLocalComputerName);
|
|
|
|
// Context attributes to read at the base level - so we know where to base
|
|
// the rest of our searches from
|
|
char *rgszContextAttrs[] =
|
|
{ "configurationNamingContext", NULL };
|
|
|
|
// Attributes we are interested in for the VSI object
|
|
char *rgszSmtpVsiAttrs[] =
|
|
{ "msExchSmtpExternalDNSServers", NULL };
|
|
|
|
// LDAP result ptrs to store the results of the search
|
|
char **rgszConfigurationNamingContext = NULL;
|
|
char **rgszSmtpVsiExternalDNSServers = NULL;
|
|
char *pszExchangeServerDN = NULL;
|
|
char szSmtpVsiDN[256];
|
|
|
|
char *pchSeparator = NULL;
|
|
char *pszIPServer = NULL;
|
|
char *pszStringEnd = NULL;
|
|
|
|
int i = 0;
|
|
int cValues = 0;
|
|
int cch = 0;
|
|
BOOL fInstalled = FALSE;
|
|
BOOL fFound = FALSE;
|
|
|
|
*pfExternal = FALSE;
|
|
pipExternalDnsServers->cAddrCount = 0;
|
|
|
|
dwErr = IsExchangeInstalled(&fInstalled);
|
|
if(ERROR_SUCCESS != dwErr || !fInstalled)
|
|
return dwErr;
|
|
|
|
dbgprintf("Querying domain controller for configuration.\n");
|
|
|
|
pldap = BindToDC();
|
|
if(!pldap)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwErr = ldap_search_s(
|
|
pldap, // ldap binding
|
|
"", // base DN
|
|
LDAP_SCOPE_BASE, // scope
|
|
"(objectClass=*)", // filter
|
|
rgszContextAttrs, // attributes we want to read
|
|
FALSE, // FALSE means read value
|
|
&pldapMsgContexts); // return results here
|
|
|
|
if(dwErr != LDAP_SUCCESS)
|
|
{
|
|
errprintf("Error encountered during LDAP search. LDAP err - %d.\n", dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(pldap, pldapMsgContexts);
|
|
if(pEntry == NULL)
|
|
{
|
|
dwErr = ERROR_INVALID_DATA;
|
|
errprintf("Base object not found on domain controller!\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
rgszConfigurationNamingContext = ldap_get_values(pldap, pEntry, rgszContextAttrs[0]);
|
|
if(rgszConfigurationNamingContext == NULL)
|
|
{
|
|
dwErr = ERROR_INVALID_DATA;
|
|
errprintf("configurationNamingContext attribute not set on base object of"
|
|
" domain controller.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
if((cValues = ldap_count_values(rgszConfigurationNamingContext)) == 1)
|
|
{
|
|
dbgprintf("configurationNamingContext is \"%s\"\n", rgszConfigurationNamingContext[0]);
|
|
dbgprintf("This will be used as the Base DN for all directory searches.\n");
|
|
}
|
|
else
|
|
{
|
|
dwErr = ERROR_INVALID_DATA;
|
|
errprintf("Unexpected error reading configurationNamingContext. Expected"
|
|
" a single string value, instead there were %d values set\n",
|
|
cValues);
|
|
goto Cleanup;
|
|
}
|
|
|
|
// See if the target server is an Exchange Server in the Org
|
|
dbgprintf("Checking if the target server %s is an Exchange server\n",
|
|
pszTargetServer);
|
|
|
|
dwErr = DsFindExchangeServer(pldap, rgszConfigurationNamingContext[0],
|
|
pszTargetServer, NULL, &fFound);
|
|
|
|
//
|
|
// If it is in the Org, nothing more to do - we just use the default DNS
|
|
// servers configured for the box to do the resolution
|
|
//
|
|
|
|
if(dwErr == LDAP_SUCCESS && fFound)
|
|
{
|
|
msgprintf("%s is in the Exchange Org. Global DNS servers will be used.\n",
|
|
pszTargetServer);
|
|
|
|
*pfExternal = FALSE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// On the other hand, if the target is not an Exchange computer in the org,
|
|
// we need to lookup the VSI object on the local computer and check if it
|
|
// is configured with external DNS servers
|
|
//
|
|
|
|
*pfExternal = TRUE;
|
|
msgprintf("%s is an external server (not in the Exchange Org).\n", pszTargetServer);
|
|
|
|
cchLocalComputerName = sizeof(szLocalComputerName);
|
|
fRet = GetComputerNameEx(ComputerNamePhysicalDnsFullyQualified,
|
|
szLocalComputerName, &cchLocalComputerName);
|
|
|
|
if(!fRet)
|
|
{
|
|
dwErr = GetLastError();
|
|
errprintf("Unable to retrieve local computer DNS name, Win32 err - %d.\n",
|
|
dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("Checking on DC if the VSI being simulated is configured with"
|
|
" external DNS servers.\n");
|
|
|
|
// Find the Exchange Server container object for the local computer
|
|
dwErr = DsFindExchangeServer(pldap, rgszConfigurationNamingContext[0],
|
|
szLocalComputerName, &pszExchangeServerDN, &fFound);
|
|
|
|
if(!fFound || !pszExchangeServerDN)
|
|
{
|
|
errprintf("This server \"%s\" was not found in the DS. Make sure you are"
|
|
" running this tool on an Exchange server in the Organization\n");
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// Construct the DN of the VSI for the server we found. This is fixed relative
|
|
// to the Exchange Server DN
|
|
cch = _snprintf(szSmtpVsiDN, sizeof(szSmtpVsiDN),
|
|
"CN=%d,CN=SMTP,CN=Protocols,%s", dwVsid, pszExchangeServerDN);
|
|
|
|
if(cch < 0)
|
|
{
|
|
errprintf("Unable to construct SMTP virtual server's DN. The DN is too"
|
|
" long for this tool to handle\n");
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("DN for the virtual server is \"%s\"\n", szSmtpVsiDN);
|
|
|
|
// Get the DNS servers attribute for the VSI
|
|
dwErr = ldap_search_s(
|
|
pldap, // ldap binding
|
|
szSmtpVsiDN, // base DN
|
|
LDAP_SCOPE_SUBTREE, // scope
|
|
"(objectClass=*)", // filter
|
|
NULL, //rgszSmtpVsiAttrs, // attributes we want to read
|
|
FALSE, // FALSE means read value
|
|
&pldapMsgSmtpVsi); // return results here
|
|
|
|
if(dwErr == LDAP_NO_SUCH_OBJECT)
|
|
{
|
|
errprintf("No object exists for SMTP virtual server #%d on GC for %s\n",
|
|
dwVsid, szLocalComputerName);
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(dwErr != LDAP_SUCCESS)
|
|
{
|
|
errprintf("Search for SMTP virtual server object failed, LDAP err - %d\n",
|
|
dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(pldap, pldapMsgSmtpVsi);
|
|
if(pEntry == NULL)
|
|
{
|
|
errprintf("SMTP virtual server #%d for server %s was not found in the DS\n",
|
|
dwVsid, szLocalComputerName);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
rgszSmtpVsiExternalDNSServers = ldap_get_values(pldap, pEntry,
|
|
rgszSmtpVsiAttrs[0]);
|
|
|
|
if(rgszSmtpVsiExternalDNSServers == NULL)
|
|
{
|
|
dbgprintf("The attribute msExchSmtpExternalDNSServers was not found on"
|
|
" the SMTP virtual server being simulated.\n");
|
|
|
|
msgprintf("No external DNS servers on VSI. Using global DNS servers.\n");
|
|
|
|
dwErr = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// This is a string of comma separated IP addresses
|
|
if((cValues != ldap_count_values(rgszSmtpVsiExternalDNSServers)) == 1)
|
|
{
|
|
errprintf("Unexpected error reading msExchSmtpExternalDNSServers,"
|
|
" cValues - %d\n", cValues);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("msExchSmtpExternalDNSServers: %s\n", rgszSmtpVsiExternalDNSServers[0]);
|
|
|
|
pszIPServer = rgszSmtpVsiExternalDNSServers[0];
|
|
pszStringEnd = rgszSmtpVsiExternalDNSServers[0] +
|
|
lstrlen(rgszSmtpVsiExternalDNSServers[0]);
|
|
|
|
i = 0;
|
|
pipExternalDnsServers->cAddrCount = 0;
|
|
|
|
while(pszIPServer < pszStringEnd && *pszIPServer != '\0')
|
|
{
|
|
pchSeparator = strchr(pszIPServer, ',');
|
|
|
|
if(pchSeparator != NULL) // last IP address
|
|
*pchSeparator = '\0';
|
|
|
|
if(i > (int)cMaxServers)
|
|
{
|
|
errprintf("Too many DNS servers configured in registry. The maximum"
|
|
" that this tool can handle is %d\n", cMaxServers);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
pipExternalDnsServers->aipAddrs[i] = inet_addr(pszIPServer);
|
|
if(pipExternalDnsServers->aipAddrs[i] == INADDR_NONE)
|
|
{
|
|
errprintf("The attribute msExchSmtpExternalDNSServers is in an"
|
|
" invalid format. Expected a comma separated list of IP"
|
|
" addresses in dotted decimal notation.\n");
|
|
goto Cleanup;
|
|
}
|
|
|
|
pipExternalDnsServers->cAddrCount++;
|
|
if(pchSeparator == NULL) // last IP address
|
|
break;
|
|
|
|
// There was a comma, advance to just after it
|
|
pszIPServer = pchSeparator + 1;
|
|
i++;
|
|
}
|
|
|
|
|
|
if(pipExternalDnsServers->cAddrCount == 0)
|
|
{
|
|
errprintf("No IP addresses could be constructed from"
|
|
" msExchSmtpExternalDNSServers\n");
|
|
}
|
|
else
|
|
{
|
|
msgprintf("Using external DNS servers:\n");
|
|
|
|
SetMsgColor();
|
|
PrintIPArray(pipExternalDnsServers);
|
|
SetNormalColor();
|
|
}
|
|
|
|
dwErr = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
if(pszExchangeServerDN)
|
|
delete [] pszExchangeServerDN;
|
|
|
|
if(rgszSmtpVsiExternalDNSServers)
|
|
ldap_value_free(rgszSmtpVsiExternalDNSServers);
|
|
|
|
if(pldapMsgSmtpVsi)
|
|
ldap_msgfree(pldapMsgSmtpVsi);
|
|
|
|
if(rgszConfigurationNamingContext)
|
|
ldap_value_free(rgszConfigurationNamingContext);
|
|
|
|
if(pldapMsgContexts)
|
|
ldap_msgfree(pldapMsgContexts);
|
|
|
|
if(pldap)
|
|
ldap_unbind(pldap);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Locates a domain controller for the local machine and opens an LDAP
|
|
// connection to it.
|
|
// Arguments:
|
|
// None.
|
|
// Returns:
|
|
// LDAP* which can be used for LDAP queries
|
|
//-----------------------------------------------------------------------------
|
|
PLDAP BindToDC()
|
|
{
|
|
DWORD dwErr = LDAP_SUCCESS;
|
|
PDOMAIN_CONTROLLER_INFO pdci = NULL;
|
|
char *pszDomainController = NULL;
|
|
PLDAP pldap = NULL;
|
|
|
|
dwErr = DsGetDcName(
|
|
NULL, // Computer name
|
|
NULL, // Domain name
|
|
NULL, // Domain GUID,
|
|
NULL, // Sitename
|
|
DS_DIRECTORY_SERVICE_REQUIRED |
|
|
DS_RETURN_DNS_NAME,
|
|
&pdci);
|
|
|
|
if(dwErr != ERROR_SUCCESS)
|
|
{
|
|
errprintf("Error getting domain controller FQDN, Win32 err - %d\n", dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pszDomainController = pdci->DomainControllerName;
|
|
while(*pszDomainController == '\\')
|
|
pszDomainController++;
|
|
|
|
dbgprintf("The domain controller server which will be used for reading"
|
|
" configuration data is %s\n", pszDomainController);
|
|
|
|
dbgprintf("Connecting to %s over port %d\n", pszDomainController, LDAP_PORT);
|
|
|
|
pldap = ldap_open(pszDomainController, LDAP_PORT);
|
|
if(pldap == NULL)
|
|
{
|
|
dwErr = LdapGetLastError();
|
|
errprintf("Unable to initialize an LDAP session to the domain controller"
|
|
" server %s, LDAP err - %d\n", pszDomainController, dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
dwErr = ldap_bind_s(pldap, NULL, NULL, LDAP_AUTH_SSPI);
|
|
if(dwErr != LDAP_SUCCESS)
|
|
{
|
|
errprintf("Unable to authenticate to the domain controller server %s. Make"
|
|
" sure you are running this tool with appropriate credentials,"
|
|
" LDAP err - %d\n", pszDomainController, dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
if(pdci)
|
|
NetApiBufferFree((PVOID)pdci);
|
|
|
|
return pldap;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Checks if a given FQDN is the name of an Exchange server in the org.
|
|
//
|
|
// Arguments:
|
|
// IN PLDAP pldap - Open LDAP session to domain controller.
|
|
// IN LPSTR szBaseDN - Base DN to search from
|
|
// IN LPSTR szServerName - Servername to search for
|
|
// OUT LPSTR *ppszServerDN - If a non-NULL char** is passed in, the DN
|
|
// of the server (if found) is returned to this. The buffer must be
|
|
// freed using delete [].
|
|
// OUT BOOL *pfFound - Set to TRUE if the server is found.
|
|
//
|
|
// Returns:
|
|
// ERROR_SUCCESS if configuration was read without problems.
|
|
// Win32 error code if there was a problem. Error messages are written to
|
|
// stdout for diagnostic purposes.
|
|
//-----------------------------------------------------------------------------
|
|
DWORD DsFindExchangeServer(
|
|
PLDAP pldap,
|
|
LPSTR szBaseDN,
|
|
LPSTR szServerName,
|
|
LPSTR *ppszServerDN,
|
|
BOOL *pfFound)
|
|
{
|
|
int i = 0;
|
|
int cch = 0;
|
|
int cValues = 0;
|
|
DWORD dwErr = LDAP_SUCCESS;
|
|
PLDAPMessage pldapMsgExchangeServer = NULL;
|
|
PLDAPMessage pEntry = NULL;
|
|
char *rgszExchangeServerAttrs[] = { "distinguishedName", "networkAddress", NULL };
|
|
char **rgszExchangeServerDN = NULL;
|
|
char **rgszExchangeServerNetworkName = NULL;
|
|
char szExchangeServerFilter[256];
|
|
char szSearchNetworkName[256];
|
|
|
|
//
|
|
// The Exchange Server object has a multivalued attribute, "networkAddress"
|
|
// that enumerates all the various names by which the Exchange Server is
|
|
// identified such as NetBIOS, DNS etc. We are only interested in the fully
|
|
// qualified domain name. This is set on the attribute as the string
|
|
// "ncacn_ip_tcp:" prefixed to the server's FQDN.
|
|
//
|
|
|
|
szExchangeServerFilter[sizeof(szExchangeServerFilter) - 1] = '\0';
|
|
cch = _snprintf(
|
|
szExchangeServerFilter,
|
|
sizeof(szExchangeServerFilter) - 1,
|
|
"(&(networkAddress=ncacn_ip_tcp:%s)(objectClass=msExchExchangeServer))",
|
|
szServerName);
|
|
|
|
if(cch < 0)
|
|
{
|
|
errprintf("The servername %s is too long for this tool to handle.\n",
|
|
szServerName);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("Searching for an Exchange Server object for %s on the domain"
|
|
" controller\n", szServerName);
|
|
|
|
dwErr = ldap_search_s(
|
|
pldap,
|
|
szBaseDN,
|
|
LDAP_SCOPE_SUBTREE,
|
|
szExchangeServerFilter,
|
|
rgszExchangeServerAttrs,
|
|
FALSE,
|
|
&pldapMsgExchangeServer);
|
|
|
|
if(dwErr == LDAP_NO_SUCH_OBJECT)
|
|
{
|
|
dbgprintf("No Exchange Server object found for %s on domain controller,"
|
|
" LDAP err - LDAP_NO_SUCH_OBJECT\n", szServerName);
|
|
dwErr = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if(dwErr != LDAP_SUCCESS)
|
|
{
|
|
errprintf("LDAP search failed, LDAP err %d\n", dwErr);
|
|
goto Cleanup;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(pldap, pldapMsgExchangeServer);
|
|
if(pEntry == NULL)
|
|
{
|
|
dbgprintf("No Exchange Server object found for %s on domain controller,\n",
|
|
szServerName);
|
|
dwErr = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
|
|
dbgprintf("LDAP search returned some results, examining them.\n");
|
|
|
|
// Loop through the Exchange server objects
|
|
while(pEntry)
|
|
{
|
|
|
|
dbgprintf("Examining next object for attributes we are interested in.\n");
|
|
|
|
// Get the Exchange server-DN
|
|
rgszExchangeServerDN = ldap_get_values(
|
|
pldap,
|
|
pEntry,
|
|
rgszExchangeServerAttrs[0]);
|
|
|
|
if(rgszExchangeServerDN == NULL)
|
|
{
|
|
errprintf("Unexpected error reading the distinguishedName attribute"
|
|
" on the Exchange Server object. The attribute was not set"
|
|
" on the object. This is a required attribute.\n");
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
else if((cValues = ldap_count_values(rgszExchangeServerDN)) != 1)
|
|
{
|
|
errprintf("Unexpected error reading the distinguishedName attribute"
|
|
" on the Exchange Server object. The attribute is supposed to"
|
|
" have a single string value, instead %d values were"
|
|
" returned.\n", cValues);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
else
|
|
{
|
|
dbgprintf("Successfully read the distinguishedName attribute on the"
|
|
" Exchange Server object. The value of the attribute is %s\n",
|
|
rgszExchangeServerDN[0]);
|
|
}
|
|
|
|
// Get the Exchange server network name
|
|
rgszExchangeServerNetworkName = ldap_get_values(
|
|
pldap,
|
|
pEntry,
|
|
rgszExchangeServerAttrs[1]);
|
|
|
|
if(!rgszExchangeServerNetworkName)
|
|
{
|
|
errprintf("The networkName attribute was not set on the Exchange"
|
|
" Server object. This is a required attribute. The DN of the"
|
|
" problematic object is %s\n", rgszExchangeServerDN[0]);
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// This is a multi-valued string attribute
|
|
cch = _snprintf(szSearchNetworkName, sizeof(szSearchNetworkName),
|
|
"ncacn_ip_tcp:%s", szServerName);
|
|
|
|
if(cch < 0)
|
|
{
|
|
errprintf("Exchange server name too long for this tool to handle\n");
|
|
dwErr = ERROR_INVALID_DATA;
|
|
goto Cleanup;
|
|
}
|
|
|
|
cValues = ldap_count_values(rgszExchangeServerNetworkName);
|
|
dbgprintf("The search returned the following %d values for the"
|
|
" networkName attribute for the Exchange Server object for %s\n",
|
|
cValues, szServerName);
|
|
|
|
dbgprintf("Attempting to match the TCP/IP networkName of the Exchange"
|
|
" Server object returned from the domain controller against the FQDN"
|
|
" we are searching for\n");
|
|
|
|
for(i = 0; i < cValues; i++)
|
|
{
|
|
dbgprintf("%d> networkName: %s", i, rgszExchangeServerNetworkName[i]);
|
|
if(!_stricmp(rgszExchangeServerNetworkName[i], szSearchNetworkName))
|
|
{
|
|
// This is an internal server
|
|
dbgprintf("...match succeeded\n");
|
|
dbgprintf("%s is an Exchange Server in the Org.\n",
|
|
szServerName);
|
|
|
|
*pfFound = TRUE;
|
|
|
|
if(ppszServerDN != NULL)
|
|
{
|
|
*ppszServerDN =
|
|
new char[lstrlen(rgszExchangeServerDN[0]) + 1];
|
|
if(*ppszServerDN == NULL)
|
|
{
|
|
errprintf("Out of memory allocating space for Exchange"
|
|
" Server object DN\n");
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
lstrcpy(*ppszServerDN, rgszExchangeServerDN[0]);
|
|
}
|
|
dwErr = ERROR_SUCCESS;
|
|
goto Cleanup;
|
|
}
|
|
dbgprintf("...match failed\n");
|
|
}
|
|
|
|
dbgprintf("No networkName on this object matched the server we are "
|
|
" searching for. Checking for more objects returned by search.\n");
|
|
|
|
pEntry = ldap_next_entry(pldap, pEntry);
|
|
}
|
|
|
|
dbgprintf("Done examining all objects returned by search. No match found.\n");
|
|
dwErr = ERROR_SUCCESS;
|
|
|
|
Cleanup:
|
|
if(rgszExchangeServerNetworkName)
|
|
ldap_value_free(rgszExchangeServerNetworkName);
|
|
|
|
if(rgszExchangeServerDN)
|
|
ldap_value_free(rgszExchangeServerDN);
|
|
|
|
if(pldapMsgExchangeServer)
|
|
ldap_msgfree(pldapMsgExchangeServer);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Destructor for async DNS class. It merely signals when the async
|
|
// resolve has finished. Since this object is deleted by completing ATQ
|
|
// threads on success, we need an explicit way of telling the caller
|
|
// when the resolve has finished.
|
|
//-----------------------------------------------------------------------------
|
|
CAsyncTestDns::~CAsyncTestDns()
|
|
{
|
|
if(m_hCompletion != INVALID_HANDLE_VALUE)
|
|
{
|
|
SetEvent(m_hCompletion);
|
|
if(m_fMxLoopBack)
|
|
SetProgramStatus(DNSDIAG_LOOPBACK);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Virtual method that is called by the async DNS base class when a query
|
|
// needs to be retried. This function creates a new DNS object and spins
|
|
// off a repeat of the previous async query. The difference is only that
|
|
// the DNS serverlist has probably undergone some state changes with some
|
|
// servers being marked down or fUdp is different from the original query.
|
|
//
|
|
// Arguments:
|
|
// IN BOOL fUdp - What protocol to use for the retry query
|
|
//
|
|
// Returns:
|
|
// TRUE on success
|
|
// FALSE if something failed. Diagnostic messages are printed.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CAsyncTestDns::RetryAsyncDnsQuery(BOOL fUdp)
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
CAsyncTestDns *pAsyncRetryDns = NULL;
|
|
|
|
if(GetDnsList()->GetUpServerCount() == 0)
|
|
{
|
|
errprintf("No working DNS servers to retry query with.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
dbgprintf("There are %d DNS servers marked as working. Trying the next"
|
|
" one\n", GetDnsList()->GetUpServerCount());
|
|
|
|
pAsyncRetryDns = new CAsyncTestDns(m_FQDNToDrop, m_fGlobalList,
|
|
m_hCompletion);
|
|
|
|
if(!pAsyncRetryDns)
|
|
{
|
|
errprintf("Unable to create new query. Out of memory.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
dwStatus = pAsyncRetryDns->Dns_QueryLib(
|
|
m_HostName,
|
|
DNS_TYPE_MX,
|
|
m_dwFlags,
|
|
fUdp,
|
|
GetDnsList(),
|
|
m_fGlobalList);
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
// New query object will flag completion event
|
|
m_hCompletion = INVALID_HANDLE_VALUE;
|
|
return TRUE;
|
|
}
|
|
|
|
errprintf("DNS query failed. The Win32 error is %d.\n", dwStatus);
|
|
delete pAsyncRetryDns;
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// This is a virtual function declared in the base CAsyncMxDns object.
|
|
// When the MX resolution is finished, this virtual function is invoked
|
|
// so that the user can do custom app-specific processing. In the case
|
|
// of SMTP this consists of spinning off an async connect to the IP
|
|
// addresses reported in m_AuxList. In this diagnostic application
|
|
// we merely display the results, and if results were not found (an
|
|
// error status is passed in), then we print the error message.
|
|
//
|
|
// In this app, we also set m_hCompletion to signal that the resolve
|
|
// is done. The main thread waiting for us in WaitForQueryCompletion
|
|
// will then exit.
|
|
//
|
|
// Arguments:
|
|
// IN DWORD status - DNS error code from resolve
|
|
//
|
|
// Notes:
|
|
// Results are available in m_AuxList
|
|
//-----------------------------------------------------------------------------
|
|
void CAsyncTestDns::HandleCompletedData(DNS_STATUS status)
|
|
{
|
|
PLIST_ENTRY pListHead = NULL;
|
|
PLIST_ENTRY pListTail = NULL;
|
|
PLIST_ENTRY pListCurrent = NULL;
|
|
LPSTR pszIpAddr = NULL;
|
|
DWORD i = 0;
|
|
PMXIPLIST_ENTRY pMxEntry = NULL;
|
|
BOOL fFoundIpAddresses = FALSE;
|
|
|
|
if(status == ERROR_NOT_FOUND)
|
|
{
|
|
SetProgramStatus(DNSDIAG_NON_EXISTENT);
|
|
goto Exit;
|
|
}
|
|
else if(!m_AuxList || m_AuxList->NumRecords == 0 || m_AuxList->DnsArray[0] == NULL)
|
|
{
|
|
SetProgramStatus(DNSDIAG_NOT_FOUND);
|
|
errprintf("The target server could not be resolved to IP addresses!\n");
|
|
|
|
msgprintf("If the VSI/domain is configured with a fallback"
|
|
" smarthost delivery will be attempted to that smarthost.\n");
|
|
|
|
goto Exit;
|
|
}
|
|
|
|
msgprintf("\nTarget hostnames and IP addresses\n");
|
|
msgprintf("---------------------------------\n");
|
|
for(i = 0; i < m_AuxList->NumRecords && m_AuxList->DnsArray[i] != NULL; i++)
|
|
{
|
|
pListTail = &(m_AuxList->DnsArray[i]->IpListHead);
|
|
pListHead = m_AuxList->DnsArray[i]->IpListHead.Flink;
|
|
pListCurrent = pListHead;
|
|
msgprintf("HostName: \"%s\"\n", m_AuxList->DnsArray[i]->DnsName);
|
|
|
|
if(pListCurrent == pListTail)
|
|
errprintf("\tNo IP addresses for this name!\n");
|
|
|
|
while(pListCurrent != pListTail)
|
|
{
|
|
// Atleast 1 IP address was found
|
|
fFoundIpAddresses = TRUE;
|
|
|
|
pMxEntry = CONTAINING_RECORD(pListCurrent, MXIPLIST_ENTRY, ListEntry);
|
|
pszIpAddr = iptostring(pMxEntry->IpAddress);
|
|
if(pszIpAddr == NULL)
|
|
{
|
|
errprintf("\tUnexpected error. Failed to read IP address, going on to next.\n");
|
|
pListCurrent = pListCurrent->Flink;
|
|
continue;
|
|
}
|
|
|
|
msgprintf("\t%s\n", pszIpAddr);
|
|
pListCurrent = pListCurrent->Flink;
|
|
};
|
|
}
|
|
if(fFoundIpAddresses)
|
|
SetProgramStatus(DNSDIAG_RESOLVED);
|
|
else
|
|
SetProgramStatus(DNSDIAG_NOT_FOUND);
|
|
|
|
Exit:
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// If the -v option is being used to simulate a VSI, this virtual function
|
|
// checks if dwIp is one of the IP addresses in the VSI bindings for the
|
|
// VS being simulated. g_pipBindings is initialized at startup of this
|
|
// app from the metabase.
|
|
// Arguments:
|
|
// IN DWORD dwIp - IP address to check
|
|
// Returns:
|
|
// TRUE is dwIp is a local-binding
|
|
// FALSE if not
|
|
//-----------------------------------------------------------------------------
|
|
BOOL CAsyncTestDns::IsAddressMine(DWORD dwIp)
|
|
{
|
|
DWORD i = 0;
|
|
|
|
if(g_pipBindings->cAddrCount == 0)
|
|
return FALSE;
|
|
|
|
for(i = 0; i < g_pipBindings->cAddrCount; i++)
|
|
{
|
|
if(g_pipBindings->aipAddrs[i] == dwIp)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Description:
|
|
// Various output functions. These print informational, debugging and error
|
|
// messages in various colors depending on the current "mode" as set in
|
|
// the global variable g_fDebug.
|
|
//
|
|
// The CDnsLogToFile is instantiated is a global variable. The DNS library
|
|
// checks to see if there is a non-NULL CDnsLogToFile* and if it is
|
|
// present the messages are directed to this object.
|
|
//-----------------------------------------------------------------------------
|
|
void CDnsLogToFile::DnsPrintfMsg(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
SetMsgColor();
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
SetNormalColor();
|
|
}
|
|
|
|
void CDnsLogToFile::DnsPrintfErr(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
SetErrColor();
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
SetNormalColor();
|
|
}
|
|
|
|
void CDnsLogToFile::DnsPrintfDbg(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
if(!g_fDebug)
|
|
return;
|
|
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void CDnsLogToFile::DnsLogAsyncQuery(
|
|
char *pszQuestionName,
|
|
WORD wQuestionType,
|
|
DWORD dwFlags,
|
|
BOOL fUdp,
|
|
CDnsServerList *pDnsServerList)
|
|
{
|
|
char szFlags[32];
|
|
|
|
GetSmtpFlags(dwFlags, szFlags, sizeof(szFlags));
|
|
|
|
SetMsgColor();
|
|
printf("Created Async Query:\n");
|
|
printf("--------------------\n");
|
|
printf("\tQNAME = %s\n", pszQuestionName);
|
|
printf("\tType = %s (0x%x)\n", QueryType(wQuestionType), wQuestionType);
|
|
printf("\tFlags = %s (0x%x)\n", szFlags, dwFlags);
|
|
printf("\tProtocol = %s\n", fUdp ? "UDP" : "TCP");
|
|
printf("\tDNS Servers: (DNS cache will not be used)\n");
|
|
DnsLogServerList(pDnsServerList);
|
|
printf("\n");
|
|
SetNormalColor();
|
|
}
|
|
|
|
void CDnsLogToFile::DnsLogApiQuery(
|
|
char *pszQuestionName,
|
|
WORD wQuestionType,
|
|
DWORD dwApiFlags,
|
|
BOOL fGlobal,
|
|
PIP_ARRAY pipServers)
|
|
{
|
|
char szFlags[32];
|
|
|
|
GetDnsFlags(dwApiFlags, szFlags, sizeof(szFlags));
|
|
|
|
SetMsgColor();
|
|
printf("Querying via DNSAPI:\n");
|
|
printf("--------------------\n");
|
|
printf("\tQNAME = %s\n", pszQuestionName);
|
|
printf("\tType = %s (0x%x)\n", QueryType(wQuestionType), wQuestionType);
|
|
printf("\tFlags = %s, (0x%x)\n", szFlags, dwApiFlags);
|
|
printf("\tProtocol = Default UDP, TCP on truncation\n");
|
|
printf("\tServers: ");
|
|
if(fGlobal)
|
|
{
|
|
printf("(DNS cache will be used)\n");
|
|
}
|
|
else
|
|
{
|
|
printf("(DNS cache will not be used)\n");
|
|
}
|
|
if(pipServers)
|
|
PrintIPArray(pipServers, "\t");
|
|
else
|
|
printf("\tDefault DNS servers on box.\n");
|
|
|
|
printf("\n");
|
|
if(fGlobal == FALSE)
|
|
SetNormalColor();
|
|
}
|
|
|
|
void CDnsLogToFile::DnsLogResponse(
|
|
DWORD dwStatus,
|
|
PDNS_RECORD pDnsRecordList,
|
|
PBYTE pbMsg,
|
|
DWORD wLength)
|
|
{
|
|
PDNS_RECORD pDnsRecord = pDnsRecordList;
|
|
|
|
SetMsgColor();
|
|
printf("Received DNS Response:\n");
|
|
printf("----------------------\n");
|
|
switch(dwStatus)
|
|
{
|
|
case ERROR_SUCCESS:
|
|
printf("\tError: %d\n", dwStatus);
|
|
printf("\tDescription: Success\n");
|
|
break;
|
|
|
|
case DNS_INFO_NO_RECORDS:
|
|
printf("\tError: %d\n", dwStatus);
|
|
printf("\tDescription: No records could be located for this name\n");
|
|
break;
|
|
|
|
case DNS_ERROR_RCODE_NAME_ERROR:
|
|
printf("\tError: %d\n", dwStatus);
|
|
printf("\tDescription: No records exist for this name.\n");
|
|
break;
|
|
|
|
default:
|
|
printf("\tError: %d\n", dwStatus);
|
|
printf("\tDescription: Not available.\n");
|
|
break;
|
|
}
|
|
|
|
if(pDnsRecord)
|
|
{
|
|
printf("\tThese records were received:\n");
|
|
PrintRecordList(pDnsRecord, "\t");
|
|
printf("\n");
|
|
}
|
|
|
|
SetNormalColor();
|
|
}
|
|
|
|
void CDnsLogToFile::DnsLogServerList(CDnsServerList *pDnsServerList)
|
|
{
|
|
LPSTR pszAddress = NULL;
|
|
PIP_ARRAY pipArray = NULL;
|
|
|
|
if(!pDnsServerList->CopyList(&pipArray))
|
|
{
|
|
printf("Error, out of memory printing serverlist\n");
|
|
return;
|
|
}
|
|
|
|
for(DWORD i = 0; i < pDnsServerList->GetCount(); i++)
|
|
{
|
|
pszAddress = iptostring(pipArray->aipAddrs[i]);
|
|
printf("\t%s\n", pszAddress);
|
|
}
|
|
|
|
delete pipArray;
|
|
}
|
|
|
|
void PrintRecordList(PDNS_RECORD pDnsRecordList, char *pszPrefix)
|
|
{
|
|
PDNS_RECORD pDnsRecord = pDnsRecordList;
|
|
|
|
while(pDnsRecord)
|
|
{
|
|
PrintRecord(pDnsRecord, pszPrefix);
|
|
pDnsRecord = pDnsRecord->pNext;
|
|
}
|
|
}
|
|
|
|
void PrintRecord(PDNS_RECORD pDnsRecord, char *pszPrefix)
|
|
{
|
|
LPSTR pszAddress = NULL;
|
|
|
|
switch(pDnsRecord->wType)
|
|
{
|
|
case DNS_TYPE_MX:
|
|
printf(
|
|
"%s%s MX %d %s\n",
|
|
pszPrefix,
|
|
pDnsRecord->nameOwner,
|
|
pDnsRecord->Data.MX.wPreference,
|
|
pDnsRecord->Data.MX.nameExchange);
|
|
break;
|
|
|
|
case DNS_TYPE_CNAME:
|
|
printf(
|
|
"%s%s CNAME %s\n",
|
|
pszPrefix,
|
|
pDnsRecord->nameOwner,
|
|
pDnsRecord->Data.CNAME.nameHost);
|
|
break;
|
|
|
|
case DNS_TYPE_A:
|
|
pszAddress = iptostring(pDnsRecord->Data.A.ipAddress);
|
|
printf(
|
|
"%s%s A %s\n",
|
|
pszPrefix,
|
|
pDnsRecord->nameOwner,
|
|
pszAddress);
|
|
break;
|
|
|
|
case DNS_TYPE_SOA:
|
|
printf("%s%s SOA (SOA records are not used by us)\n",
|
|
pszPrefix,
|
|
pDnsRecord->nameOwner);
|
|
break;
|
|
|
|
default:
|
|
printf("%s%s (Record type = %d) Unknown record type\n",
|
|
pszPrefix,
|
|
pDnsRecord->nameOwner,
|
|
pDnsRecord->wType);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void msgprintf(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
SetMsgColor();
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
SetNormalColor();
|
|
}
|
|
|
|
void errprintf(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
SetErrColor();
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
SetNormalColor();
|
|
}
|
|
|
|
void dbgprintf(char *szFormat, ...)
|
|
{
|
|
va_list argptr;
|
|
|
|
if(!g_fDebug)
|
|
return;
|
|
|
|
va_start(argptr, szFormat);
|
|
vprintf(szFormat, argptr);
|
|
va_end(argptr);
|
|
}
|
|
|
|
void SetMsgColor()
|
|
{
|
|
if(g_fDebug)
|
|
{
|
|
SetConsoleTextAttribute(g_hConsole,
|
|
FOREGROUND_GREEN | FOREGROUND_INTENSITY);
|
|
}
|
|
}
|
|
|
|
void SetErrColor()
|
|
{
|
|
if(g_fDebug)
|
|
{
|
|
SetConsoleTextAttribute(g_hConsole,
|
|
FOREGROUND_RED | FOREGROUND_INTENSITY);
|
|
}
|
|
}
|
|
|
|
void SetNormalColor()
|
|
{
|
|
if(g_fDebug)
|
|
{
|
|
SetConsoleTextAttribute(g_hConsole,
|
|
FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED);
|
|
}
|
|
}
|