windows-xp/Source/XPSP1/NT/net/diagnostics/netdiag/nettest.c

//++
//
//  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 <locale.h>


//////////////////////////////////////////////////////////////////////////////
//
// 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 <objbase.h>
//
// 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; ArgumentIndex<argc; ArgumentIndex++ ) {

        pszArgument = argv[ArgumentIndex];

        if ( StriCmp( pszArgument, _T("/q") ) == 0 ||
             StriCmp( pszArgument, _T("-q") ) == 0 )
        {
            if ( pParams->fReallyVerbose || 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:<DomainName> - 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:<test name>  - 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:<TestName> - 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; i<Results.cNumInterfaces; i++)
    {
        if (Results.pArrayInterface[i].IpConfig.fActive &&
            Results.pArrayInterface[i].IpConfig.pAdapterInfo->DhcpEnabled)
        {
            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; i<pResults->Global.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; i<pResults->Global.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; i<pResults->Global.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);
    }
}