//++ // // Copyright (C) Microsoft Corporation, 1987 - 1999 // // Module Name: // // nettest.c // // Abstract: // // Test to ensure that a workstation has network (IP) connectivity to // the outside. // // Author: // // 15-Dec-1997 (cliffv) // Anilth - 4-20-1998 // // Environment: // // User mode only. // Contains NT-specific code. // // Revision History: // // 1-June-1998 (denisemi) add DnsServerHasDCRecords to check DC dns records // registration // // 26-June-1998 (t-rajkup) add general tcp/ip , dhcp and routing, // winsock, ipx, wins and netbt information. //-- // // Common include files. // #include "precomp.h" #include "ipxtest.h" #include "ipcfgtest.h" #include "machine.h" #include "global.h" #include "crtdbg.h" #include ////////////////////////////////////////////////////////////////////////////// // // Globals // ////////////////////////////////////////////////////////////////////////////// const TCHAR c_szLogFileName[] = _T("NetDiag.log"); //BOOL IpConfigCalled = FALSE; //BOOL ProblemBased = FALSE; int ProblemNumber; // // New functions for displaying routing table - Rajkumar // #define WILD_CARD (ULONG)(-1) #define ROUTE_DATA_STRING_SIZE 300 #define MAX_METRIC 9999 #define ROUTE_SEPARATOR ',' int match( const char * p, const char * s ); // Replaced by pResults->IpConfig.pFixedInfo //PFIXED_INFO GlobalIpconfigFixedInfo = NULL; // Replaced by per-adapter info, pResults->pArrayInterface[i].IpConfig //PADAPTER_INFO GlobalIpconfigAdapterInfo = NULL; // Replaced by per-adapter info, pResults->pArrayInterface[i].IpConfig.pAdapterInfo //PIP_ADAPTER_INFO IpGlobalIpconfigAdapterInfo = NULL; // See pResults->IpConfig.fDhcpEnabled //BOOLEAN GlobalDhcpEnabled; // See pResults->NetBt.Transports //LIST_ENTRY GlobalNetbtTransports; // See pResults->NetBt.cTransportCount //ULONG GlobalNetbtTransportCount; // !!! not replaced yet // See pResults->Global.listTestedDomains //LIST_ENTRY GlobalTestedDomains; // // Globals defining the command line arguments. // // Replaced by pParams->fVerbose //BOOL Verbose; // Replaced by pParams->fReallyVerbose // Maintain this global variable so that we don't mess up the compiling // of getdcnam.c BOOL ReallyVerbose; // Replaced by pParams->fDebugVerbose //BOOL DebugVerbose; // Replaced by pParams->fFixProblems //BOOL GlobalFixProblems; // Replaced by pParams->fDcAccountEnum //BOOL GlobalDcAccountEnum; // !!! not replaced yet //PTESTED_DOMAIN GlobalQueriedDomain; // // Describe the domain this machine is a member of // // Replaced by pResults->Global.pszCurrentBuildNumber //int GlobalNtBuildNumber; // Replaced by pResults->Global.pPrimaryDomainInfo //PDSROLE_PRIMARY_DOMAIN_INFO_BASIC GlobalDomainInfo = NULL; // Replaced by pResults->Global.pMemberDomain //PTESTED_DOMAIN GlobalMemberDomain; // // Who we're currently logged on as // // Replaced by pResults->Global.pLogonUser //PUNICODE_STRING GlobalLogonUser; // Replaced by pResults->Global.pLogonDomainName //PUNICODE_STRING GlobalLogonDomainName; // Replaced by pResults->Global.pLogonDomain //PTESTED_DOMAIN GlobalLogonDomain; // Replaced by pResults->Global.fLogonWithCachedCredentials //BOOLEAN GlobalLogonWithCachedCredentials = FALSE; // // A Zero GUID for comparison // GUID NlDcZeroGuid; // // State determined by previous tests // // Replaced by pResults->Global.fNetlogonIsRunning //BOOL GlobalNetlogonIsRunning = FALSE; // Netlogon is running on this machine // !!! not replaced yet // Replaced by pResults->Global.fKerberosIsWorking //BOOL GlobalKerberosIsWorking = FALSE; // Kerberos is working // // Netbios name of this machine // // Replaced by pResults->Global.swzNetBiosName //WCHAR GlobalNetbiosComputerName[MAX_COMPUTERNAME_LENGTH+1]; // Replaced by pResults->Global.szDnsHostName //CHAR GlobalDnsHostName[DNS_MAX_NAME_LENGTH+1]; // Replaced by pResults->Global.pszDnsDomainName //LPSTR GlobalDnsDomainName; //(nsun) this macro already exists in // // Macro for comparing GUIDs // /* #define InlineIsEqualGUID(rguid1, rguid2) \ (((PLONG) rguid1)[0] == ((PLONG) rguid2)[0] && \ ((PLONG) rguid1)[1] == ((PLONG) rguid2)[1] && \ ((PLONG) rguid1)[2] == ((PLONG) rguid2)[2] && \ ((PLONG) rguid1)[3] == ((PLONG) rguid2)[3]) #define IsEqualGUID(rguid1, rguid2) InlineIsEqualGUID(rguid1, rguid2) */ DSGETDCNAMEW NettestDsGetDcNameW; PFNGUIDTOFRIENDLYNAME pfnGuidToFriendlyName = NULL; /*--------------------------------------------------------------------------- Function prototypes ---------------------------------------------------------------------------*/ HRESULT LoadNamesForListOfTests(); void FreeNamesForListOfTests(); void DoGlobalPrint(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pResults); void DoPerInterfacePrint(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pResults); /*--------------------------------------------------------------------------- Functions provided by ipconfig ---------------------------------------------------------------------------*/ #define DECLARE_TEST_FUNCTIONS(_test) \ HRESULT _test##Test(NETDIAG_PARAMS *, NETDIAG_RESULT *); \ void _test##GlobalPrint(NETDIAG_PARAMS *, NETDIAG_RESULT *); \ void _test##PerInterfacePrint(NETDIAG_PARAMS *, NETDIAG_RESULT *, INTERFACE_RESULT *); \ void _test##Cleanup(NETDIAG_PARAMS *, NETDIAG_RESULT *); DECLARE_TEST_FUNCTIONS(IpConfig); DECLARE_TEST_FUNCTIONS(Member); DECLARE_TEST_FUNCTIONS(IpLoopBk); DECLARE_TEST_FUNCTIONS(NetBT); DECLARE_TEST_FUNCTIONS(Autonet); DECLARE_TEST_FUNCTIONS(DefGw); DECLARE_TEST_FUNCTIONS(NbtNm); DECLARE_TEST_FUNCTIONS(Wins); DECLARE_TEST_FUNCTIONS(Bindings); DECLARE_TEST_FUNCTIONS(Dns); DECLARE_TEST_FUNCTIONS(Browser); DECLARE_TEST_FUNCTIONS(Winsock); DECLARE_TEST_FUNCTIONS(Route); DECLARE_TEST_FUNCTIONS(Netstat); DECLARE_TEST_FUNCTIONS(Ndis); DECLARE_TEST_FUNCTIONS(WAN); #ifndef _WIN64 //Netware and IPX support is removed from WIN64 DECLARE_TEST_FUNCTIONS(Netware); DECLARE_TEST_FUNCTIONS(Ipx); #endif DECLARE_TEST_FUNCTIONS(Trust); DECLARE_TEST_FUNCTIONS(Modem); DECLARE_TEST_FUNCTIONS(Kerberos); DECLARE_TEST_FUNCTIONS(DcList); DECLARE_TEST_FUNCTIONS(LDAP); DECLARE_TEST_FUNCTIONS(DsGetDc); DECLARE_TEST_FUNCTIONS(IPSec); ////////////////////////////////////////////////////////////////////////////// // // List of tests to run // ////////////////////////////////////////////////////////////////////////////// typedef struct { // Each of these strings has a max of 256 characters UINT uIdsShortName; // ID of the string for the short name UINT uIdsLongName; // ID of the string for the long name HRESULT (*TestProc)(NETDIAG_PARAMS* pParams, NETDIAG_RESULT* pResults); void (*SystemPrintProc)(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pRes); void (*GlobalPrintProc)(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pRes); void (*PerInterfacePrintProc)(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pRes, INTERFACE_RESULT *pIfRes); void (*CleanupProc)(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pResults); BOOL fSkippable; BOOL fPerDomainTest; BOOL fSkipped; BOOL fPerformed; // We will call LoadString() on the id's above to get these // strings. LPTSTR pszShortName; LPTSTR pszLongName; } TEST_INFO; #define EACH_TEST(_szID, _uShortIDS, _uLongIDS, _skip, _perdomain) \ { _uShortIDS, _uLongIDS, _szID##Test, NULL, _szID##GlobalPrint, \ _szID##PerInterfacePrint, _szID##Cleanup, _skip, _perdomain, \ FALSE, FALSE, NULL, NULL} #define SYSTEM_PRINT_TEST(_szID, _uShortIDS, _uLongIDS, _skip, _perdomain) \ { _uShortIDS, _uLongIDS, _szID##Test, _szID##GlobalPrint, NULL, \ _szID##PerInterfacePrint, _szID##Cleanup, _skip, _perdomain, \ FALSE, FALSE, NULL, NULL} // // Tests below are marked "skippable" unless subsequent tests will AV if the // test isn't run. // static TEST_INFO s_rgListOfTests[] = { // IP Configuration SYSTEM_PRINT_TEST( Ndis, IDS_NDIS_SHORT, IDS_NDIS_LONG, FALSE, FALSE), EACH_TEST( IpConfig,IDS_IPCONFIG_SHORT, IDS_IPCONFIG_LONG, TRUE, FALSE), EACH_TEST( Member, IDS_MEMBER_SHORT, IDS_MEMBER_LONG, FALSE,FALSE), EACH_TEST( NetBT, IDS_NETBT_SHORT, IDS_NETBT_LONG, FALSE,FALSE), EACH_TEST( Autonet, IDS_AUTONET_SHORT, IDS_AUTONET_LONG, TRUE, FALSE), EACH_TEST( IpLoopBk,IDS_IPLOOPBK_SHORT, IDS_IPLOOPBK_LONG, TRUE, FALSE), EACH_TEST( DefGw, IDS_DEFGW_SHORT, IDS_DEFGW_LONG, TRUE, FALSE), EACH_TEST( NbtNm, IDS_NBTNM_SHORT, IDS_NBTNM_LONG, TRUE, FALSE), EACH_TEST( Wins, IDS_WINS_SHORT, IDS_WINS_LONG, TRUE, FALSE), EACH_TEST( Winsock, IDS_WINSOCK_SHORT, IDS_WINSOCK_LONG, TRUE, FALSE), EACH_TEST( Dns, IDS_DNS_SHORT, IDS_DNS_LONG, TRUE, FALSE), EACH_TEST( Browser, IDS_BROWSER_SHORT, IDS_BROWSER_LONG, TRUE, FALSE), EACH_TEST( DsGetDc, IDS_DSGETDC_SHORT, IDS_DSGETDC_LONG, TRUE, TRUE ), EACH_TEST( DcList, IDS_DCLIST_SHORT, IDS_DCLIST_LONG, TRUE, TRUE ), EACH_TEST( Trust, IDS_TRUST_SHORT, IDS_TRUST_LONG, TRUE, FALSE), EACH_TEST( Kerberos,IDS_KERBEROS_SHORT, IDS_KERBEROS_LONG, TRUE, FALSE ), EACH_TEST( LDAP, IDS_LDAP_SHORT, IDS_LDAP_LONG, TRUE, TRUE ), EACH_TEST( Route, IDS_ROUTE_SHORT, IDS_ROUTE_LONG, TRUE, FALSE ), EACH_TEST( Netstat, IDS_NETSTAT_SHORT, IDS_NETSTAT_LONG, TRUE, FALSE), EACH_TEST( Bindings,IDS_BINDINGS_SHORT, IDS_BINDINGS_LONG, TRUE, FALSE), EACH_TEST( WAN, IDS_WAN_SHORT, IDS_WAN_LONG, TRUE, FALSE), EACH_TEST( Modem, IDS_MODEM_SHORT, IDS_MODEM_LONG, TRUE, FALSE), #ifndef _WIN64 //Netware and IPX support is removed from WIN64 EACH_TEST( Netware, IDS_NETWARE_SHORT, IDS_NETWARE_LONG, TRUE, FALSE), EACH_TEST( Ipx, IDS_IPX_SHORT, IDS_IPX_LONG, TRUE, FALSE), #endif EACH_TEST( IPSec, IDS_IPSEC_SHORT, IDS_IPSEC_LONG, TRUE, FALSE) }; ///////////////////////////////////////////////////////////////////////////// // // List of problems and the corresponding tests to run // ///////////////////////////////////////////////////////////////////////////// // max no of tests #define NO_OF_TESTS 25 typedef BOOL (*FuncPtr)(NETDIAG_PARAMS* pParams, NETDIAG_RESULT* pResults); typedef struct _A_PROBLEM { LPTSTR problem; // Problem description LONG n; // no of tests FuncPtr TestProc[NO_OF_TESTS]; } A_PROBLEM; // Number of problems defined #define NO_OF_PROBLEMS 2 A_PROBLEM ListOfProblems[] = { _T("Fake test"), 1 , IpConfigTest, NULL, NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL // "Not Able to Reach Other Segments Of the Network", 1 , DefGwTest, NULL, NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL, // "Not Able to Resolve NetBios Names", 1 , WINSTest, NULL, NULL,NULL,NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL }; /*!-------------------------------------------------------------------------- ParseArgs Routine Description: Parse the command line arguments Arguments: argc - the number of command-line arguments. argv - an array of pointers to the arguments. pParams - this function sets these values pResults - additional output Return Value: 0: All OK Exit status Author: KennT ---------------------------------------------------------------------------*/ int ParseArgs( IN int argc, IN TCHAR ** argv, IN OUT NETDIAG_PARAMS *pParams, IN OUT NETDIAG_RESULT *pResults ) { LPSTR pszArgument; LPSTR TestName; int ArgumentIndex; ULONG i; BOOL SeenTestOption = FALSE; PTESTED_DOMAIN pQueriedDomain; // // Flags used by problem option // BOOL OtherOptions = FALSE; // // Set the defaults // pParams->fVerbose = TRUE; pParams->fReallyVerbose = FALSE; pParams->fDebugVerbose = FALSE; pParams->fFixProblems = FALSE; pParams->fDcAccountEnum = FALSE; pParams->fProblemBased = FALSE; pParams->nProblemNumber = 0; // // Loop through the arguments handle each in turn // for ( ArgumentIndex=1; ArgumentIndexfReallyVerbose || pParams->fProblemBased ) { goto Usage; } pParams->fVerbose = FALSE; OtherOptions = TRUE; } else if ( StriCmp( pszArgument, _T("/v") ) == 0 || StriCmp( pszArgument, _T("-v") ) == 0 ) { if ( !pParams->fVerbose || pParams->fProblemBased) { goto Usage; } pParams->fVerbose = TRUE; pParams->fReallyVerbose = TRUE; OtherOptions = TRUE; } else if ( StriCmp( pszArgument, _T("/debug") ) == 0 || StriCmp( pszArgument, _T("-debug") ) == 0 ) { if ( !pParams->fVerbose || pParams->fProblemBased) { goto Usage; } pParams->fVerbose = TRUE; pParams->fReallyVerbose = TRUE; pParams->fDebugVerbose = TRUE; OtherOptions = TRUE; } else if ( StriCmp( pszArgument, _T("/fix") ) == 0 || StriCmp( pszArgument, _T("-fix") ) == 0 ) { if (pParams->fProblemBased) goto Usage; pParams->fFixProblems = TRUE; OtherOptions = TRUE; } else if ( StriCmp( pszArgument, _T("/DcAccountEnum") ) == 0 || StriCmp( pszArgument, _T("-DcAccountEnum") ) == 0 ) { if (pParams->fProblemBased) goto Usage; pParams->fDcAccountEnum = TRUE; OtherOptions = TRUE; // // Allow the caller to specify the name of a domain to query. // } else if ( StrniCmp( pszArgument, _T("/d:"), 3 ) == 0 || StrniCmp( pszArgument, _T("-d:"), 3 ) == 0 ) { WCHAR UnicodeDomainName[MAX_PATH+1]; if (pParams->fProblemBased) goto Usage; OtherOptions = TRUE; NetpCopyStrToWStr( UnicodeDomainName, &pszArgument[3] ); pQueriedDomain = AddTestedDomain(pParams, pResults, UnicodeDomainName, NULL, FALSE ); if ( pQueriedDomain == NULL ) { goto Usage; } // // Allow the caller to skip certain tests // } else if ( StrniCmp( pszArgument, _T("/skip:"), 6 ) == 0 || StrniCmp( pszArgument, _T("-skip:"), 6 ) == 0 ) { TestName = &pszArgument[6]; OtherOptions = TRUE; if (pParams->fProblemBased) goto Usage; for ( i=0; i < DimensionOf(s_rgListOfTests); i++) { if ( StriCmp( s_rgListOfTests[i].pszShortName, TestName ) == 0 ) { // // If the caller specified a non-optional test, // tell him. // if ( !s_rgListOfTests[i].fSkippable ) { //IDS_GLOBAL_NOT_OPTIONAL "'%s' is not an optional test.\n" PrintMessage(pParams, IDS_GLOBAL_NOT_OPTIONAL, TestName ); goto Usage; } s_rgListOfTests[i].fSkipped = TRUE; break; } } if ( i >= DimensionOf(s_rgListOfTests) ) { //IDS_GLOBAL_NOT_VALID_TEST "'%s' is not an valid test name.\n" PrintMessage( pParams, IDS_GLOBAL_NOT_VALID_TEST, TestName ); goto Usage; } // // Handle all other parameters // } else if ( StrniCmp( pszArgument, _T("/test:"),6 ) == 0 || StrniCmp( pszArgument, _T("-test:"),6 ) == 0 ) { TestName = &pszArgument[6]; OtherOptions = TRUE; if (pParams->fProblemBased) goto Usage; for ( i =0; i < DimensionOf(s_rgListOfTests); i++) { if ( StriCmp( s_rgListOfTests[i].pszShortName, TestName ) == 0) s_rgListOfTests[i].fSkipped = FALSE; else { if (!SeenTestOption && s_rgListOfTests[i].fSkippable) s_rgListOfTests[i].fSkipped = TRUE; } } SeenTestOption = TRUE; } else if( StrniCmp( pszArgument, _T("/l"), 5) == 0 || StrniCmp( pszArgument, _T("-l"), 5) == 0 ) { /* We change to always log the output pParams->pfileLog = fopen(c_szLogFileName, "wt"); if( NULL == pParams->pfileLog ) { //IDS_NETTEST_LOGFILE_ERROR "[ERROR] Cannot open %s to log output!\n" PrintMessage(pParams, IDS_NETTEST_LOGFILE_ERROR, c_szLogFileName); return 1; } else { pParams->fLog = TRUE; } */ } /*$REVIEW (nsun) we won't support problem configuration for NT5.0 else if ( StrniCmp( pszArgument, _T("/problem:"),9) == 0 || StrniCmp( pszArgument, _T("-problem:"),9) == 0 ) { TestName = &pszArgument[9]; i = atoi(TestName); if ( i > NO_OF_PROBLEMS) { printf("Incorrect problem number\n"); exit(0); } if (OtherOptions) goto Usage; pParams->fProblemBased = TRUE; pParams->nProblemNumber = i-1; } */ else { Usage: // IDS_NETTEST_17000 "\nUsage: %s [/Options]>\n", argv[0] ); // IDS_NETTEST_17001 " /q - Quiet output (errors only)\n" ); // IDS_NETTEST_17002 " /v - Verbose output \n"); // IDS_NETTEST_LOG " /l - Log output to NetDiag.log \n" // IDS_NETTEST_17003 " /debug - Even more verbose.\n"); // IDS_NETTEST_17004 " /d: - Find a DC in the specified domain.\n"); // IDS_NETTEST_17005 " /fix - fix trivial problems.\n"); // IDS_NETTEST_17006 " /DcAccountEnum - Enumerate DC machine accounts.\n"); // IDS_NETTEST_17007 " /test: - tests only this test. Non - skippable tests will still be run\n"); // IDS_NETTEST_17008 " Valid tests are :-\n"); PrintMessage(pParams, IDS_NETTEST_17000, argv[0]); PrintMessage(pParams, IDS_NETTEST_17001); PrintMessage(pParams, IDS_NETTEST_17002); PrintMessage(pParams, IDS_NETTEST_LOG); PrintMessage(pParams, IDS_NETTEST_17003); PrintMessage(pParams, IDS_NETTEST_17004); PrintMessage(pParams, IDS_NETTEST_17005); PrintMessage(pParams, IDS_NETTEST_17006); PrintMessage(pParams, IDS_NETTEST_17007); PrintMessage(pParams, IDS_NETTEST_17008); for ( i =0; i < DimensionOf(s_rgListOfTests); i++) { // IDS_GLOBAL_TEST_NAME " %s - %s Test\n" PrintMessage(pParams, IDS_GLOBAL_TEST_NAME, s_rgListOfTests[i].pszShortName, s_rgListOfTests[i].pszLongName); } // IDS_GLOBAL_SKIP " /skip: - skip the named test. Valid tests are:\n" PrintMessage( pParams, IDS_GLOBAL_SKIP_OPTION); for ( i =0; i < DimensionOf(s_rgListOfTests); i++) { if ( s_rgListOfTests[i].fSkippable ) { // IDS_GLOBAL_TEST_NAME " %s - %s Test\n" PrintMessage( pParams, IDS_GLOBAL_TEST_NAME, s_rgListOfTests[i].pszShortName, s_rgListOfTests[i].pszLongName ); } } return 1; } } return 0; } int __cdecl main( IN int argc, IN TCHAR ** argv ) { int RetVal; LONG i; LONG err; BOOL Failed = FALSE; int iWSAStatus; HRESULT hr = hrOK; NETDIAG_PARAMS Params; NETDIAG_RESULT Results; // set the locale to the system default setlocale( LC_ALL, ""); // Turn on debug checking // ---------------------------------------------------------------- #ifdef _DEBUG int tmpFlag; tmpFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); tmpFlag |= _CRTDBG_CHECK_ALWAYS_DF; tmpFlag |= _CRTDBG_DELAY_FREE_MEM_DF; tmpFlag |= _CRTDBG_LEAK_CHECK_DF; // _CrtSetDbgFlag( tmpFlag ); #endif // Global initialization. // ---------------------------------------------------------------- RtlZeroMemory( &NlDcZeroGuid, sizeof(NlDcZeroGuid) ); ZeroMemory(&Params, sizeof(NETDIAG_PARAMS)); ZeroMemory(&Results, sizeof(NETDIAG_RESULT)); InitializeListHead( &Results.NetBt.Transports ); // InitializeListHead( &GlobalNetbtTransports ); // InitializeListHead( &GlobalTestedDomains ); InitializeListHead( &Results.Global.listTestedDomains ); // GlobalDnsHostName[0] = 0; // GlobalDhcpEnabled = FALSE; // GlobalDnsDomainName = NULL; // Load the names of all the tests (this is used by the ParseArgs). // which is why it needs to get loaded first. // ---------------------------------------------------------------- CheckHr( LoadNamesForListOfTests() ); // Parse input flags. // ---------------------------------------------------------------- RetVal = ParseArgs( argc, argv, &Params, &Results); if ( RetVal != 0 ) { return 1; } Params.pfileLog = fopen(c_szLogFileName, "wt"); if( NULL == Params.pfileLog ) { //IDS_NETTEST_LOGFILE_ERROR "[ERROR] Cannot open %s to log output!\n" PrintMessage(&Params, IDS_NETTEST_LOGFILE_ERROR, c_szLogFileName); } else { Params.fLog = TRUE; } // Initialize Winsock // ---------------------------------------------------------------- iWSAStatus = WsaInitialize(&Params, &Results); if ( iWSAStatus ) { return 1; } /* if (pParams->fProblemBased) { for (i =0; i < ListOfProblems[pParams->nProblemNumber].n; i++) { if ( !(*ListOfProblems[pParams->nProblemNumber].TestProc[i])((PVOID)NULL) ) Failed = TRUE; } if (Failed) PrintMessage(pParams, IDS_GLOBAL_Problem); else PrintMessage(pParams, IDS_GLOBAL_NoProblem); return 0; } */ // Get the NetBIOS computer name of this computer // ---------------------------------------------------------------- CheckHr( GetComputerNameInfo(&Params, &Results) ); // Get the DNS host name and DNS domain. // ---------------------------------------------------------------- CheckHr( GetDNSInfo(&Params, &Results) ); // Get OS-version info, etc.. // ---------------------------------------------------------------- CheckHr( GetMachineSpecificInfo(&Params, &Results) ); // Other non-ip config info - Rajkumar // ---------------------------------------------------------------- CheckHr( GetNetBTParameters(&Params, &Results) ); if ( Params.fVerbose ) { PrintNewLine(&Params, 1); } // // Grab all the information from the registry that 'ipconfig /all' // would print. // // This routine doesn't always return on fatal errors. // hr = InitIpconfig(&Params, &Results); if (!FHrSucceeded(hr)) { PrintMessage(&Params, IDS_GLOBAL_NoIpCfg); CheckHr( hr ); } #ifndef _WIN64 hr = InitIpxConfig(&Params, &Results); if (!FHrSucceeded(hr)) { CheckHr( hr ); } #endif // // Determine if any adapter has DHCP enabled. // for ( i = 0; iDhcpEnabled) { Results.IpConfig.fDhcpEnabled = TRUE; break; } } //if to detect a predefined problem if (Params.fProblemBased) { for (i =0; i < ListOfProblems[Params.nProblemNumber].n; i++) { if ( !(*ListOfProblems[Params.nProblemNumber].TestProc[i])(&Params, &Results) ) Failed = TRUE; } if (Failed) PrintMessage(&Params, IDS_GLOBAL_Problem); else PrintMessage(&Params, IDS_GLOBAL_NoProblem); return 0; } // // Test individual components // for ( i=0; i < DimensionOf(s_rgListOfTests); i++ ) { // If the caller wanted to skip this test, // do so now. // ------------------------------------------------------------ if ( s_rgListOfTests[i].fSkipped ) continue; //We will perform this test s_rgListOfTests[i].fPerformed = TRUE; // // If the test is to be run for each tested domain, // do so. // if ( s_rgListOfTests[i].fPerDomainTest ) { PTESTED_DOMAIN TestedDomain; PLIST_ENTRY pListEntry; // // Loop through the list of tested domains // for ( pListEntry = Results.Global.listTestedDomains.Flink ; pListEntry != &Results.Global.listTestedDomains ; pListEntry = pListEntry->Flink ) { // // If the entry is found, // use it. // TestedDomain = CONTAINING_RECORD( pListEntry, TESTED_DOMAIN, Next ); Params.pDomain = TestedDomain; // // Run this test. // if ( FHrFailed((*s_rgListOfTests[i].TestProc)(&Params, &Results))) { Failed = TRUE; } } // // If any test failed, // we're done. // if ( Failed ) { goto Print_Results; } // // If the test is to be run just once, // do it. // } else { // // Run this test. // if ( FHrFailed((*s_rgListOfTests[i].TestProc)(&Params, &Results))) { goto Print_Results; } } } Print_Results: // Now that we've run through all of the tests, run through the // print outs if (Params.fReallyVerbose) { // IDS_GLOBAL_COMPLETE "\n Tests complete.\n\n\n" PrintMessage( &Params, IDS_GLOBAL_COMPLETE ); } else { PrintNewLine(&Params, 2); } DoSystemPrint(&Params, &Results); DoPerInterfacePrint(&Params, &Results); DoGlobalPrint(&Params, &Results); // // All tests passed. // // IDS_GLOBAL_SUCCESS "\nThe command completed successfully\n" PrintMessage( &Params, IDS_GLOBAL_SUCCESS); Error: FreeNamesForListOfTests(); if(Params.pfileLog != NULL && Params.fLog) { fclose(Params.pfileLog); } ResultsCleanup(&Params, &Results); return hr != S_OK; } HRESULT LoadNamesForListOfTests() { int i; TCHAR szBuffer[256]; for (i=0; i < DimensionOf(s_rgListOfTests); i++) { szBuffer[0] = 0; LoadString(NULL, s_rgListOfTests[i].uIdsShortName, szBuffer, DimensionOf(szBuffer)); s_rgListOfTests[i].pszShortName = _tcsdup(szBuffer); szBuffer[0] = 0; LoadString(NULL, s_rgListOfTests[i].uIdsLongName, szBuffer, DimensionOf(szBuffer)); s_rgListOfTests[i].pszLongName = StrDup(szBuffer); } return hrOK; } void FreeNamesForListOfTests() { int i; for (i=0; i < DimensionOf(s_rgListOfTests); i++) { Free(s_rgListOfTests[i].pszShortName); s_rgListOfTests[i].pszShortName = NULL; Free(s_rgListOfTests[i].pszLongName); s_rgListOfTests[i].pszLongName = NULL; } } void DoSystemPrint(IN NETDIAG_PARAMS *pParams, IN NETDIAG_RESULT *pResults) { int cInstalled; int i; int ids; PrintMessage(pParams, IDSWSZ_GLOBAL_ComputerName, pResults->Global.swzNetBiosName); PrintMessage(pParams, IDSSZ_GLOBAL_DnsHostName, pResults->Global.szDnsHostName ); if (pParams->fReallyVerbose) PrintMessage(pParams, IDSSZ_DnsDomainName, pResults->Global.pszDnsDomainName); // " System info : %s (Build %s)\n" PrintMessage(pParams, IDS_MACHINE_15801, pResults->Global.pszServerType, pResults->Global.pszCurrentBuildNumber); // " Processor : %s\n" PrintMessage(pParams, IDS_MACHINE_15802, pResults->Global.pszProcessorInfo); if (pResults->Global.cHotFixes == 0) // " Hotfixes : none detected\n" PrintMessage(pParams, IDS_MACHINE_15803); else { // If in Verbose mode, only print out the hotfixes that are // installed if (pParams->fReallyVerbose) { // print out a list of all hotfixes // " Hotfixes :\n" PrintMessage(pParams, IDS_MACHINE_15804); // " Installed? Name\n" PrintMessage(pParams, IDS_MACHINE_15805); for (i=0; iGlobal.cHotFixes; i++) { if (pResults->Global.pHotFixes[i].fInstalled) ids = IDS_MACHINE_YES_INSTALLED; else ids = IDS_MACHINE_NO_INSTALLED; PrintMessage(pParams, ids, pResults->Global.pHotFixes[i].pszName); } } else { // print out a list of the installed hotfixes // count the number of installed hotfixes cInstalled = 0; for (i=0; iGlobal.cHotFixes; i++) { if (pResults->Global.pHotFixes[i].fInstalled) cInstalled++; } if (cInstalled == 0) { // " Hotfixes : not hotfixes have been installed\n" PrintMessage(pParams, IDS_MACHINE_15806); } else { // " List of installed hotfixes : \n" PrintMessage(pParams, IDS_MACHINE_15807); for (i=0; iGlobal.cHotFixes; i++) { if (pResults->Global.pHotFixes[i].fInstalled) { // " %s\n" PrintMessage(pParams, IDS_MACHINE_15808, pResults->Global.pHotFixes[i].pszName); } } } } } for ( i=0; i < DimensionOf(s_rgListOfTests); i++ ) { // If the caller wanted to skip this test, // do so now. // ------------------------------------------------------------ if ( s_rgListOfTests[i].fSkipped || !s_rgListOfTests[i].fPerformed) continue; if(s_rgListOfTests[i].SystemPrintProc) s_rgListOfTests[i].SystemPrintProc(pParams, pResults); } PrintNewLine(pParams, 1); } void DoGlobalPrint(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pResults) { int i; // IDS_GLOBAL_RESULTS "\nGlobal results\n\n" PrintMessage( pParams, IDS_GLOBAL_RESULTS ); for ( i=0; i < DimensionOf(s_rgListOfTests); i++ ) { // If the caller wanted to skip this test, // do so now. // ------------------------------------------------------------ if ( s_rgListOfTests[i].fSkipped || !s_rgListOfTests[i].fPerformed) continue; if(s_rgListOfTests[i].GlobalPrintProc) s_rgListOfTests[i].GlobalPrintProc(pParams, pResults); } PrintNewLine(pParams, 1); } void DoPerInterfacePrint(NETDIAG_PARAMS *pParams, NETDIAG_RESULT *pResults) { int i, iIf; INTERFACE_RESULT * pIfResult; //IDS_GLOBAL_INTERFACE_RESULTS "\nPer interface results:\n\n" PrintMessage( pParams, IDS_GLOBAL_INTERFACE_RESULTS ); // Loop through the interfaces for ( iIf = 0; iIf < pResults->cNumInterfaces; iIf++) { pIfResult = pResults->pArrayInterface + iIf; if (!pIfResult->fActive) continue; PrintNewLine(pParams, 1); // Print out the interface name PrintMessage(pParams, IDSSZ_IPCFG_Adapter, pResults->pArrayInterface[iIf].pszFriendlyName ? pResults->pArrayInterface[iIf].pszFriendlyName : MapGuidToAdapterName(pIfResult->IpConfig.pAdapterInfo->AdapterName)); if (pParams->fReallyVerbose) PrintMessage(pParams, IDS_IPCFG_10004, pResults->pArrayInterface[iIf].pszName); for ( i=0; i < DimensionOf(s_rgListOfTests); i++ ) { // If the caller wanted to skip this test, // do so now. // ------------------------------------------------------------ if ( s_rgListOfTests[i].fSkipped || !s_rgListOfTests[i].fPerformed ) continue; s_rgListOfTests[i].PerInterfacePrintProc(pParams, pResults, pIfResult); } fflush(stdout); } }