// -----------------------------------
//
// Copyright (c) 1990 Microsoft Corporation
//
// Module Name:
//
//     tpctl.h
//
// Abstract:
//
//     This module defines the external definitions used for the MAC Tester
//
// Author:
//
//     Tom Adams (tomad) 11-May-1991
//
// Revision History:
//
//     11-May-1991    tomad
//          Created
//
//      4-27-94     timothyw
//          Added performance test; CPP style comments
//      5-18-94
//          Added globvars; fixed warnings
//      6-08-94
//          chgs for client/server model, perf tests
//
// -----------------------------------

#include "tp_ndis.h"
#include "common.h"

//
//
//

extern CMD_ARGS GlobalCmdArgs;

extern LPSTR GlobalBuf;

extern BOOL Verbose;

extern BOOL CommandsFromScript;

extern BOOL CommandLineLogging;

extern BOOL RecordToScript;

extern HANDLE CommandLineLogHandle;

extern HANDLE ScriptRecordHandle;

extern CHAR RecordScriptName[TPCTL_MAX_PATHNAME_SIZE];

extern BOOL ExitFlag;

extern BOOL ContinueLooping;

extern INT TpctlSeed;

//
// Script Control is used to keep track of where in a script file the
// application is, and where to log the next set of results in the
// respective log file.
//

typedef struct _SCRIPTCONTROL {
    LPSTR ScriptFile;
    BOOL IsLowestLevel;
    LPBYTE Buffer;
    DWORD Length;

    DWORD BufIndex;
    HANDLE LogHandle;
    LPSTR LogFile;
} SCRIPTCONTROL, * PSCRIPTCONTROL;

//
// Scripts is an array of 10 script control structures allowing recursion
// of upto ten script files at any one time.  Any more then 10 and an error
// occurs resulting in the closing of all upper recursive levels of script
// files.
//

#define TPCTL_MAX_SCRIPT_LEVELS 10

extern SCRIPTCONTROL Scripts[TPCTL_MAX_SCRIPT_LEVELS+1];

extern DWORD ScriptIndex;

//
// Initialize the script array.
//

// ------
//
// VOID
// TpctlInitializeScripts(
//     VOID
//     );
//
// -----

#define TpctlInitializeScripts() {              \
    DWORD i;                                    \
    ScriptIndex = 0xFFFFFFFF;                   \
    for (i=0;i<TPCTL_MAX_SCRIPT_LEVELS+1;i++) { \
        Scripts[i].ScriptFile = NULL;           \
        Scripts[i].IsLowestLevel = FALSE;       \
        Scripts[i].Buffer = NULL;               \
        Scripts[i].Length = 0;                  \
        Scripts[i].BufIndex = 0;                \
        Scripts[i].LogHandle = (HANDLE)-1;      \
        Scripts[i].LogFile = NULL;              \
    }                                           \
}

//
// TPCTLCLOSESCRIPTS close any and all script files that
// are currently opened.
//

// -----
//
// VOID
// TpctlCloseScripts(
//     VOID
//     );
//
// -----

#define TpctlCloseScripts() {                   \
    if ( CommandsFromScript == TRUE ) {         \
        while ( ScriptIndex != (ULONG)-1 ) {    \
            TpctlUnLoadFiles();                 \
        }                                       \
    }                                           \
}

//
// PRINT_DIFF_FLAG will print the diff flag string S into the buffer B
// if we are printing the results to a logfile.
//

// -----
//
// VOID
// ADD_DIFF_FLAG(
//     LPSTR B
//     LPSTR S
//     );
//
// -----

#define ADD_DIFF_FLAG( B,S ) {                               \
    if (( CommandsFromScript ) || ( CommandLineLogging )) {  \
        B += (BYTE)sprintf(B,"\t%s",S);                      \
    }                                                        \
    TmpBuf += (BYTE)sprintf(TmpBuf,"\n");                    \
}

#define ADD_SKIP_FLAG( B,S )    ADD_DIFF_FLAG( B,S )

//
// Reset all opens to their initial state.
//

// -----
//
// VOID
// TpctlResetAllOpenStates(
//     HANDLE fh
//     );
//
// -----

#define TpctlResetAllOpenStates( fh ) {                \
    DWORD i;                                           \
    if ( CommandsFromScript ) {                        \
        TpctlErrorLog("\n\tTpctl: Resetting the state of all Open Instances.\n",NULL); \
        for ( i = 0 ; i < NUM_OPEN_INSTANCES ; i++ ) { \
            TpctlResetOpenState( &Open[i],fh );        \
        }                                              \
    }                                                  \
}

//
// Parse Tables are the structures used to contain each of the possible
// argument names for a given command, and their value.
//

typedef struct _ParsedIntTable {
    LPSTR    FieldName;
    DWORD  FieldValue;
} PARSETABLE, *PPARSETABLE;

//
// Paramtypes are the different types of parameters that may be parsed
// by the ParseOptions routine for each command.
//

//
// STARTCHANGE
//
typedef enum {
    Integer,
    String,
    ParsedInteger,
//    Address2,        // Accomodate 802.3, 802.4, 802.5, FDDI addresses
    Address4,        // Accomodate 802.4, 802.5 addresses
    Address6,        // Accomodate 802.3, 802.4, 802.5, FDDI addresses
//    Address2or6      // Conjugate type in which addresses can be 2 or 6 octets
} PARAMTYPES;
//
// STOPCHANGE
//


//
// The Test Options structures is used by the ParseOptions routine to
// load the default value for a given argument, set up the prompt for
// the argument and prompt the user for the argument.  If the command is
// entered from a script file the Test Options structures is used to
// determine the Argument names or abbreviations and then stores the
// values in their proper destinations.
//

typedef struct _TestOptions {
    DWORD       OptionNumber;
    LPSTR       TestPrompt;
    LPSTR       ArgName;
    LPSTR       ArgNameAbbr;
    BOOL        ArgValueSet;
    PARAMTYPES  TestType;
    DWORD       IntegerDefault;
    LPSTR       StringDefault;
    PPARSETABLE ParsedIntTable;
    DWORD       ParsedIntTableSize;
    PVOID       Destination;
} TESTPARAMS, *PTESTPARAMS;

//
// Array entries for the Events in the Open Block
//

typedef enum {
    TPCONTROL,
    TPSTRESS,
    TPSEND,
    TPRECEIVE,
    TPPERF
} TPEVENT_TYPE;

//
// Multicast Address struct used to create a list of all the
// address set on a given open.
//

typedef struct _MULT_ADDR {
    struct _MULT_ADDR *Next;
    BYTE MulticastAddress[ADDRESS_LENGTH];
} MULT_ADDR, *PMULT_ADDR;

//
// the Open Block holding the info about the state of the open,
// particulars about the card opened, and the control structs for
// each of the given test types.
//

typedef struct _OPEN_BLOCK {
    DWORD Signature;
    UCHAR OpenInstance;
    BOOL AdapterOpened;
    NDIS_MEDIUM MediumType;
    DWORD NdisVersion;

    LPBYTE AdapterName;
    BYTE AdapterAddress[ADDRESS_LENGTH];
    PENVIRONMENT_VARIABLES EnvVars;

    BOOL EventThreadStarted;
    HANDLE Events[5];

    BOOL Stressing;
    PCMD_ARGS StressArgs;
    IO_STATUS_BLOCK StressStatusBlock;
    HANDLE StressEvent;
    PSTRESS_RESULTS StressResults;
    BOOL StressResultsCompleted;
    BOOL StressClient;
    BOOL Ack10;

    BOOL Sending;
    PCMD_ARGS SendArgs;
    IO_STATUS_BLOCK SendStatusBlock;
    HANDLE SendEvent;
    PSEND_RECEIVE_RESULTS SendResults;
    BOOL SendResultsCompleted;

    BOOL Receiving;
    IO_STATUS_BLOCK ReceiveStatusBlock;
    HANDLE ReceiveEvent;
    PSEND_RECEIVE_RESULTS ReceiveResults;
    BOOL ReceiveResultsCompleted;

    IO_STATUS_BLOCK PerfStatusBlock;
    HANDLE PerfEvent;
    PPERF_RESULTS PerfResults;
    BOOL   PerfResultsCompleted;

    DWORD PacketFilter;

    DWORD LookaheadSize;
    PMULT_ADDR MulticastAddresses;
    ULONG NumberMultAddrs;
    BYTE FunctionalAddress[FUNCTIONAL_ADDRESS_LENGTH];

    BYTE GroupAddress[FUNCTIONAL_ADDRESS_LENGTH];
} OPEN_BLOCK, *POPEN_BLOCK;

extern OPEN_BLOCK Open[NUM_OPEN_INSTANCES];

#define OPEN_BLOCK_SIGNATURE 0x12121212

//
// TPCTL.C function prototypes
//

DWORD
TpctlInitializeOpenArray(
    VOID
    );

VOID
TpctlFreeOpenArray(
    VOID
    );

DWORD
TpctlOpenTpdrvr(
    IN OUT PHANDLE lphFileHandle
    );

VOID
TpctlCloseTpdrvr(
    IN HANDLE hFileHandle
    );

DWORD
TpctlStartEventHandlerThread(
    IN POPEN_BLOCK Open
    );

VOID
TpctlStopEventHandlerThread(
    IN POPEN_BLOCK Open
    );

DWORD
TpctlEventHandler(
    IN LPVOID Open
    );

BOOL
TpctlCtrlCHandler(
    IN DWORD CtrlType
    );

//
//
//

DWORD
TpctlRunTest(
    IN HANDLE hFileHandle
    );

VOID
TpctlGetEvents(
    IN HANDLE FileHandle,
    IN HANDLE InputBuffer,
    IN DWORD InputBufferSize
    );

VOID
TpctlPauseGo(
    IN HANDLE FileHandle,
    IN HANDLE InputBuffer,
    IN DWORD InputBufferSize,
    IN DWORD CmdCode
    );

DWORD
TpctlResetOpenState(
    IN POPEN_BLOCK Open,
    IN HANDLE FileHandle
    );

VOID
TpctlLoadUnload(
    IN DWORD CmdCode
    );

VOID
TpctlQueryStatistics(
    IN PUCHAR DriverName,
    IN NDIS_OID OID,
    IN PUCHAR StatsBuffer,
    IN DWORD BufLen
    );

BOOL
Disable(
    IN DWORD argc,
    IN LPSTR argv[]
       );

//
//
//


VOID
TpctlPrintResults(
    PREQUEST_RESULTS Results,
    DWORD CmdCode,
    NDIS_OID OID
    );

VOID
TpctlPrintQueryInfoResults(
    PREQUEST_RESULTS Results,
    DWORD CmdCode,
    NDIS_OID OID
    );

VOID
TpctlPrintSetInfoResults(
    PREQUEST_RESULTS Results,
    DWORD CmdCode,
    NDIS_OID OID
    );

VOID
TpctlPrintSendResults(
    PSEND_RECEIVE_RESULTS Results
    );

VOID
TpctlPrintReceiveResults(
    PSEND_RECEIVE_RESULTS Results
    );

VOID
TpctlPrintPerformResults(
    PPERF_RESULTS Results
    );

VOID
TpctlPrintStressResults1(
    IN PSTRESS_RESULTS Results,
    IN BOOL Ack10
    );

VOID
TpctlPrintStressResults(
    PSTRESS_RESULTS Results,
    IN BOOL Ack10
    );

VOID
TpctlPrintEventResults(
    PEVENT_RESULTS Event
    );

VOID
TpctlZeroStressStatistics(
    PSTRESS_RESULTS Results
    );

DWORD
TpctlLog(
    LPSTR String,
    PVOID Input
    );

DWORD
TpctlErrorLog(
    LPSTR String,
    PVOID Input
    );

DWORD
TpctlScriptLog(
    LPSTR String,
    PVOID Input
    );

DWORD
TpctlCmdLneLog(
    LPSTR String,
    PVOID Input
    );

//
// CMD.C function prototypes
//

DWORD
TpctlParseCommandLine(
    IN WORD argc,
    IN LPSTR argv[]
    );

VOID
TpctlUsage(
    VOID
    );

VOID
TpctlHelp(
    LPSTR Command
    );

DWORD
TpctlLoadFiles(
    IN LPSTR ScriptFile,
    IN LPSTR LogFile
    );


VOID
TpctlUnLoadFiles(
    VOID
    );


HANDLE
TpctlOpenLogFile(
    VOID
    );


VOID
TpctlCloseLogFile(
    VOID
    );


HANDLE
TpctlOpenScriptFile(
    VOID
    );


VOID
TpctlCloseScriptFile(
    VOID
    );

DWORD
TpctlReadCommand(
    IN LPSTR Prompt,
    OUT LPSTR Response,
    IN DWORD MaximumResponse
    );


BOOL
TpctlParseCommand(
    IN LPSTR CommandLine,
    OUT LPSTR Argv[],
    OUT PDWORD Argc,
    IN DWORD MaxArgc
    );


VOID
TpctlPrompt(
    LPSTR Prompt,
    LPSTR Buffer,
    DWORD BufferSize
    );


VOID
TpctlLoadLastEnvironmentVariables(
    DWORD OpenInstance
    );


VOID
TpctlSaveNewEnvironmentVariables(
    DWORD OpenInstance
    );

VOID
TpctlPerformRegistryOperation(
                    IN PCMD_ARGS CmdArgs
                             );
BOOL
TpctlInitCommandBuffer(
    IN OUT PCMD_ARGS CmdArgs,
    IN DWORD CmdType
    );


LPSTR
TpctlGetEventType(
    TP_EVENT_TYPE TpEventType
    );


LPSTR
TpctlGetStatus(
    NDIS_STATUS GeneralStatus
    );


DWORD
TpctlGetCommandCode(
    LPSTR Argument
    );


LPSTR
TpctlGetCommandName(
    LPSTR Command
    );

LPSTR
TpctlGetCmdCode(
    DWORD CmdCode
    );


VOID
TpctlCopyAdapterAddress(
    DWORD OpenInstance,
    PREQUEST_RESULTS Results
    );

VOID
TpctlRecordArguments(
    IN TESTPARAMS Options[],
    IN DWORD      OptionTableSize,
    IN DWORD      argc,
    IN LPSTR      argv[TPCTL_MAX_ARGC]
    );

LPSTR
TpctlEnumerateRegistryInfo(
     IN PUCHAR TmpBuf,
     IN PUCHAR DbaseName,
     IN PUCHAR SubKeyName,
     IN PUCHAR ValueName,
     IN DWORD  ReadValueType,
     IN PUCHAR ReadValue,
     IN DWORD  ReadValueSize
     );

LPSTR
TpctlGetValueType(
    IN DWORD ValueType
    );


//
// PARSE.C Function Prototypes
//

DWORD
TpctlParseArguments(
    IN TESTPARAMS Options[],
    IN DWORD TestSize,
    IN DWORD ArgC,
    IN LPSTR ArgV[]
    );


BOOL
TpctlParseSetInfoArguments(
    IN OUT DWORD *ArgC,
    IN OUT LPSTR ArgV[],
    IN OUT DWORD *tmpArgC,
    IN OUT LPSTR tmpArgV[]
    );


DWORD
TpctlParseAddress(
    IN BYTE Buffer[],
    OUT PDWORD Ret,
    IN DWORD OpenInstance,
    IN DWORD AddressLength
    );


VOID
Dump_Desired_PacketFilter(
    LPSTR Buffer,
    DWORD PacketFilter
    );


VOID
Dump_Information_Class(
    LPSTR Buffer,
    DWORD InfoClass
    );


VOID
Dump_Ndis_Medium(
    LPSTR Buffer,
    DWORD Medium
    );

//
// GLOBALS.C Function Prototypes
//


PVOID
TpctlParseGlobalVariable(
    IN BYTE         Buffer[],
    IN PARAMTYPES   reqtype
    );

VOID
TpctlInitGlobalVariables(
    VOID
    );


DWORD
TpctlParseSet(
    IN DWORD ArgC,
    IN LPSTR ArgV[]
    );


// functions from cpuperf.c


VOID     CpuUsageInit(VOID);


ULONG    CpuUsageGetData(PULONG *KernPercent,
                         ULONG  NumCpus);