path: root/private/ntos/ndis/testprot/tpdrvr/tputils.c

// *******************************
// 
// Copyright (c) 1990  Microsoft Corporation
// 
// Module Name:
// 
//     tputils.c
// 
// Abstract:
// 
//     This module implements the utility functions for the NDIS 3.0
//     Test Protocol Tester.
// 
// Author:
// 
//     Tom Adams (tomad) 14-Jul-1990
// 
// Environment:
// 
//     Kernel mode
// 
// Revision History:
// 
//     Tom Adams (tomad) 15-Dec-1990
//     seperate from testprot.c and add test control and statistics fcns.
// 
//     Tom Adams (tomad) 14-March-1991
//     add support for calling TpStress from command line with arguments.
// 
//     Tim Wynsma (timothyw) 5-18-94
//     Fixed warnings, some general cleanup
//
// ****************************

#include <ndis.h>
#include <stdlib.h>
#include <string.h>

#include "tpdefs.h"
#include "media.h"
#include "tpprocs.h"


PUCHAR
TpGetStatus(
    NDIS_STATUS GeneralStatus
    )
{
    static NDIS_STATUS Status[] = {
        NDIS_STATUS_SUCCESS,
        NDIS_STATUS_PENDING,
        NDIS_STATUS_NOT_RECOGNIZED,
        NDIS_STATUS_NOT_COPIED,
        NDIS_STATUS_ONLINE,
        NDIS_STATUS_RESET_START,
        NDIS_STATUS_RESET_END,
        NDIS_STATUS_RING_STATUS,
        NDIS_STATUS_CLOSED,

        NDIS_STATUS_WAN_LINE_UP,
        NDIS_STATUS_WAN_LINE_DOWN,
        NDIS_STATUS_WAN_FRAGMENT,

        NDIS_STATUS_NOT_RESETTABLE,
        NDIS_STATUS_SOFT_ERRORS,
        NDIS_STATUS_HARD_ERRORS,
        NDIS_STATUS_FAILURE,
        NDIS_STATUS_RESOURCES,
        NDIS_STATUS_CLOSING,
        NDIS_STATUS_BAD_VERSION,
        NDIS_STATUS_BAD_CHARACTERISTICS,
        NDIS_STATUS_ADAPTER_NOT_FOUND,
        NDIS_STATUS_OPEN_FAILED,
        NDIS_STATUS_DEVICE_FAILED,
        NDIS_STATUS_MULTICAST_FULL,
        NDIS_STATUS_MULTICAST_EXISTS,
        NDIS_STATUS_MULTICAST_NOT_FOUND,
        NDIS_STATUS_REQUEST_ABORTED,
        NDIS_STATUS_RESET_IN_PROGRESS,
        NDIS_STATUS_CLOSING_INDICATING,
        NDIS_STATUS_NOT_SUPPORTED,
        NDIS_STATUS_INVALID_PACKET,
        NDIS_STATUS_OPEN_LIST_FULL,
        NDIS_STATUS_ADAPTER_NOT_READY,
        NDIS_STATUS_ADAPTER_NOT_OPEN,
        NDIS_STATUS_NOT_INDICATING,
        NDIS_STATUS_INVALID_LENGTH,
        NDIS_STATUS_INVALID_DATA,
        NDIS_STATUS_BUFFER_TOO_SHORT,
        NDIS_STATUS_INVALID_OID,
        NDIS_STATUS_ADAPTER_REMOVED,
        NDIS_STATUS_UNSUPPORTED_MEDIA,
        NDIS_STATUS_GROUP_ADDRESS_IN_USE,
        NDIS_STATUS_FILE_NOT_FOUND,
        NDIS_STATUS_ERROR_READING_FILE,
        NDIS_STATUS_ALREADY_MAPPED,
        NDIS_STATUS_RESOURCE_CONFLICT,
        NDIS_STATUS_TOKEN_RING_OPEN_ERROR,
        TP_STATUS_NO_SERVERS,
        TP_STATUS_NO_EVENTS
    };

    static PUCHAR String[] = {
        "NDIS_STATUS_SUCCESS",
        "NDIS_STATUS_PENDING",
        "NDIS_STATUS_NOT_RECOGNIZED",
        "NDIS_STATUS_NOT_COPIED",
        "NDIS_STATUS_ONLINE",
        "NDIS_STATUS_RESET_START",
        "NDIS_STATUS_RESET_END",
        "NDIS_STATUS_RING_STATUS",
        "NDIS_STATUS_CLOSED",
        "NDIS_STATUS_WAN_LINE_UP",
        "NDIS_STATUS_WAN_LINE_DOWN",
        "NDIS_STATUS_WAN_FRAGMENT",
        "NDIS_STATUS_NOT_RESETTABLE",
        "NDIS_STATUS_SOFT_ERRORS",
        "NDIS_STATUS_HARD_ERRORS",
        "NDIS_STATUS_FAILURE",
        "NDIS_STATUS_RESOURCES",
        "NDIS_STATUS_CLOSING",
        "NDIS_STATUS_BAD_VERSION",
        "NDIS_STATUS_BAD_CHARACTERISTICS",
        "NDIS_STATUS_ADAPTER_NOT_FOUND",
        "NDIS_STATUS_OPEN_FAILED",
        "NDIS_STATUS_DEVICE_FAILED",
        "NDIS_STATUS_MULTICAST_FULL",
        "NDIS_STATUS_MULTICAST_EXISTS",
        "NDIS_STATUS_MULTICAST_NOT_FOUND",
        "NDIS_STATUS_REQUEST_ABORTED",
        "NDIS_STATUS_RESET_IN_PROGRESS",
        "NDIS_STATUS_CLOSING_INDICATING",
        "NDIS_STATUS_NOT_SUPPORTED",
        "NDIS_STATUS_INVALID_PACKET",
        "NDIS_STATUS_OPEN_LIST_FULL",
        "NDIS_STATUS_ADAPTER_NOT_READY",
        "NDIS_STATUS_ADAPTER_NOT_OPEN",
        "NDIS_STATUS_NOT_INDICATING",
        "NDIS_STATUS_INVALID_LENGTH",
        "NDIS_STATUS_INVALID_DATA",
        "NDIS_STATUS_BUFFER_TOO_SHORT",
        "NDIS_STATUS_INVALID_OID",
        "NDIS_STATUS_ADAPTER_REMOVED",
        "NDIS_STATUS_UNSUPPORTED_MEDIA",
        "NDIS_STATUS_GROUP_ADDRESS_IN_USE",
        "NDIS_STATUS_FILE_NOT_FOUND",
        "NDIS_STATUS_ERROR_READING_FILE",
        "NDIS_STATUS_ALREADY_MAPPED",
        "NDIS_STATUS_RESOURCE_CONFLICT",
        "NDIS_STATUS_TOKEN_RING_OPEN_ERROR",
        "TP_STATUS_NO_SERVERS",
        "TP_STATUS_NO_EVENTS"
    };

    static UCHAR BadStatus[] = "UNDEFINED";

#define StatusCount (sizeof(Status)/sizeof(NDIS_STATUS))

    INT i;

    for (i=0; i<StatusCount; i++)
    { 
        if (GeneralStatus == Status[i])
        {
            return String[i];
        }
    }
    return BadStatus;

#undef StatusCount
}



NDIS_STATUS
TpInitStressArguments(
    PSTRESS_ARGUMENTS *StressArguments,
    PCMD_ARGS CmdArgs
    )

// --------
// 
// Routine Description:
// 
// Arguments:
// 
//     The arguments for the test to be run.
// 
// Return Value:
// 
//  ------

{
    NDIS_STATUS Status;

    Status = NdisAllocateMemory((PVOID *)StressArguments,
                                sizeof( STRESS_ARGUMENTS ),
                                0,
                                HighestAddress );

    if ( Status != NDIS_STATUS_SUCCESS ) 
    {
        IF_TPDBG (TP_DEBUG_RESOURCES) 
        {
            TpPrint0("TpInitStressArguments: unable to allocate Argument buffer.\n");
        }
        return NDIS_STATUS_RESOURCES;
    } 
    else 
    {
        NdisZeroMemory( *StressArguments,sizeof( STRESS_ARGUMENTS ));
    }


    (*StressArguments)->MemberType = CmdArgs->ARGS.TPSTRESS.MemberType;
    (*StressArguments)->PacketType = CmdArgs->ARGS.TPSTRESS.PacketType;
    (*StressArguments)->PacketSize = CmdArgs->ARGS.TPSTRESS.PacketSize;
    (*StressArguments)->PacketMakeUp = CmdArgs->ARGS.TPSTRESS.PacketMakeUp;
    (*StressArguments)->ResponseType = CmdArgs->ARGS.TPSTRESS.ResponseType;
    (*StressArguments)->Iterations = 0;
    (*StressArguments)->TotalIterations = CmdArgs->ARGS.TPSTRESS.TotalIterations;
    (*StressArguments)->TotalPackets = CmdArgs->ARGS.TPSTRESS.TotalPackets;
    (*StressArguments)->AllPacketsSent = FALSE;
    (*StressArguments)->DelayType  = CmdArgs->ARGS.TPSTRESS.DelayType;
    (*StressArguments)->DelayLength = CmdArgs->ARGS.TPSTRESS.DelayLength;
    (*StressArguments)->WindowEnabled = (UCHAR)CmdArgs->ARGS.TPSTRESS.WindowEnabled;
    (*StressArguments)->DataChecking = (UCHAR)CmdArgs->ARGS.TPSTRESS.DataChecking;
    (*StressArguments)->PacketsFromPool = (UCHAR)CmdArgs->ARGS.TPSTRESS.PacketsFromPool;
    (*StressArguments)->BeginReceives = FALSE;
    (*StressArguments)->ServerContinue = TRUE;

    return NDIS_STATUS_SUCCESS;
}



NDIS_STATUS
TpInitServerArguments(
    PSTRESS_ARGUMENTS *StressArguments
    )

// -----------
// 
// Routine Description:
// 
// Arguments:
// 
//     The arguments for the test to be run.
// 
// Return Value:
// 
//  ----------------

{
    NDIS_STATUS Status;

    Status = NdisAllocateMemory((PVOID *)StressArguments,
                                sizeof( STRESS_ARGUMENTS ),
                                0,
                                HighestAddress );

    if ( Status != NDIS_STATUS_SUCCESS ) 
    {
        IF_TPDBG (TP_DEBUG_RESOURCES) 
        {
            TpPrint0("TpInitServerArguments: unable to allocate Argument buffer.\n");
        }
        return NDIS_STATUS_RESOURCES;
    } 
    else 
    {
        NdisZeroMemory( *StressArguments,sizeof( STRESS_ARGUMENTS ));
    }

    (*StressArguments)->MemberType = TP_SERVER;
    (*StressArguments)->PacketType = 0;
    (*StressArguments)->PacketSize = 100;
    (*StressArguments)->PacketMakeUp = RAND;
    (*StressArguments)->ResponseType = ACK_EVERY;
    (*StressArguments)->Iterations = 0;
    (*StressArguments)->TotalIterations = 0;
    (*StressArguments)->TotalPackets = 0;
    (*StressArguments)->AllPacketsSent = FALSE;
    (*StressArguments)->DelayType  = 0;
    (*StressArguments)->DelayLength = FIXEDDELAY;
    (*StressArguments)->WindowEnabled = TRUE;
    (*StressArguments)->DataChecking = FALSE;
    (*StressArguments)->PacketsFromPool = TRUE;
    (*StressArguments)->BeginReceives = FALSE;
    (*StressArguments)->ServerContinue = TRUE;

    return NDIS_STATUS_SUCCESS;
}



VOID
TpStressWriteResults(
    IN POPEN_BLOCK OpenP
    )

// ---------
// 
// Routine Description:
// 
// Arguments:
// 
// Return Value:
// 
//     None.
// 
// ---------

{
    PSTRESS_RESULTS OutputBuffer;

    NdisAcquireSpinLock( &OpenP->SpinLock );

    OutputBuffer = MmGetSystemAddressForMdl( OpenP->Stress->StressIrp->MdlAddress );

    RtlMoveMemory(  OutputBuffer,
                    OpenP->Stress->Results,
                    sizeof( STRESS_RESULTS ) );

    NdisReleaseSpinLock( &OpenP->SpinLock );
}



VOID
TpCopyClientStatistics(
    IN POPEN_BLOCK OpenP
    )

// --------
// 
// Routine Description:
// 
// Arguments:
// 
// Return Value:
// 
//     None.
// 
// ---------

{
    PSTRESS_RESULTS res;
    PGLOBAL_COUNTERS gc;
    PINSTANCE_COUNTERS ic;
    PINSTANCE_COUNTERS lc;
    PUCHAR p, q;
    USHORT i;

    p = OpenP->Stress->Results->Address;
    q = OpenP->StationAddress;

    for ( i=0;i<OpenP->Media->AddressLen;i++ ) 
    {
        *p++ = *q++;
    }

    res = OpenP->Stress->Results;
    gc = OpenP->GlobalCounters;

    res->OpenInstance = OpenP->OpenInstance;
    res->NumServers = OpenP->Stress->Client->NumServers;

    res->Global.Sends = gc->Sends;
    res->Global.SendComps = gc->SendComps;
    res->Global.Receives = gc->Receives;
    res->Global.ReceiveComps = gc->ReceiveComps;
    res->Global.CorruptRecs = gc->CorruptRecs;
    res->Global.InvalidPacketRecs = gc->InvalidPacketRecs;

    //
    // Now calculate the Packets Per Second value.
    //

    // first find the total number of test packets sent.

    gc->Sends = 0;
    gc->Receives = 0;

    for ( i = 0 ; i < OpenP->Stress->Client->NumServers ; i++ ) 
    {
        ic = OpenP->Stress->Client->Servers[i].Counters;
        gc->Sends += ic->Sends;
        gc->Receives += ic->Receives;
    }

    // find the total test time in Nanoseconds

    OpenP->Stress->EndTime = RtlLargeIntegerSubtract(   OpenP->Stress->EndTime,
                                                        OpenP->Stress->StartTime );
    // convert it to seconds.

    OpenP->Stress->EndTime = RtlExtendedLargeIntegerDivide( OpenP->Stress->EndTime,
                                                            10000000,
                                                            NULL );

    // then determine the packets per second value.
    // NOTE: we are assuming that the high part of time is now 0.

    res->PacketsPerSecond = OpenP->Stress->PacketsPerSecond =
        (( gc->Sends + gc->Receives ) / OpenP->Stress->EndTime.LowPart );

    //
    // Now copy the Server stats into the buffer.
    //

    for( i=0;i<OpenP->Stress->Client->NumServers;i++ ) 
    {
        ic = OpenP->Stress->Client->Servers[i].Counters;
        lc = &res->Servers[i].Instance;

        lc->Sends = ic->Sends;
        lc->SendPends = ic->SendPends;
        lc->SendComps = ic->SendComps;
        lc->SendFails = ic->SendFails;
        lc->Receives = ic->Receives;
        ic->ReceiveComps = ic->ReceiveComps;
        lc->CorruptRecs = ic->CorruptRecs;
    }
}



VOID
TpCopyServerStatistics(
    IN POPEN_BLOCK OpenP,
    IN PVOID Buffer,
    IN INT ServerReference
    )

// -----------
// 
// Routine Description:
// 
// Arguments:
// 
// Return Value:
// 
//     None.
// 
// -------------

{
    PSERVER_RESULTS res;
    PINSTANCE_COUNTERS ic;
    PGLOBAL_COUNTERS gc;
    PUCHAR p, q;
    USHORT i;

    res = &OpenP->Stress->Results->Servers[ServerReference];

    ic = (PINSTANCE_COUNTERS)((PUCHAR)Buffer +
                              (ULONG)sizeof( PACKET_INFO ) +
                              (ULONG)sizeof( STRESS_CONTROL ));

    gc = (PGLOBAL_COUNTERS)((PUCHAR)Buffer +
                            (ULONG)( sizeof( PACKET_INFO ) +
                                     sizeof( STRESS_CONTROL ) +
                                     sizeof( INSTANCE_COUNTERS )));

    res->OpenInstance = OpenP->Stress->Client->Servers[ServerReference].ServerInstance;

    res->StatsRcvd = TRUE;

    // p = res->Address;
    p = OpenP->Stress->Results->Servers[ServerReference].Address;
    q = OpenP->Stress->Client->Servers[ServerReference].Address;

    for ( i=0;i<OpenP->Media->AddressLen;i++ ) 
    {
        *p++ = *q++;
    }

    //
    // Now copy the servers instance counters into the results buffer array.
    //

    res->S_Instance.Sends = ic->Sends;
    res->S_Instance.SendPends = ic->SendPends;
    res->S_Instance.SendComps = ic->SendComps;
    res->S_Instance.SendFails = ic->SendFails;

    res->S_Instance.Receives = ic->Receives;
    res->S_Instance.ReceiveComps = ic->ReceiveComps;
    res->S_Instance.CorruptRecs = ic->CorruptRecs;

    res->S_Instance.XferData = ic->XferData;
    res->S_Instance.XferDataPends = ic->XferDataPends;
    res->S_Instance.XferDataComps = ic->XferDataComps;
    res->S_Instance.XferDataFails = ic->XferDataFails;

    //
    // and the servers global counters.
    //

    res->S_Global.Sends = gc->Sends;
    res->S_Global.SendComps = gc->SendComps;
    res->S_Global.Receives = gc->Receives;
    res->S_Global.ReceiveComps = gc->ReceiveComps;

    res->S_Global.CorruptRecs = gc->CorruptRecs;
    res->S_Global.InvalidPacketRecs = gc->InvalidPacketRecs;
}



VOID
TpWriteServerStatistics(
    IN POPEN_BLOCK OpenP,
    IN OUT PNDIS_PACKET Packet,
    IN PCLIENT_INFO Client
    )

// -----------------
// 
// Routine Description:
// 
// 
//     NOTE: This routine requires a packet with one single contiguous
//           buffer, it does not attempt to write to any other buffers.
// 
// Arguments:
// 
//     OpenP - A pointer to the OPEN_BLOCK describing the Server.
// 
// Return Value:
// 
//     None.
// 
// -----------------

{
    PNDIS_BUFFER Buffer;
    PUCHAR Memory;
    UINT BufLen;


    NdisQueryPacket(Packet,NULL,NULL,&Buffer,NULL);

    NdisQueryBuffer( Buffer,(PVOID *)&Memory,&BufLen );

    RtlMoveMemory(  Memory + sizeof( STRESS_PACKET ),
                    (PVOID)Client->Counters,
                    sizeof( INSTANCE_COUNTERS ) );

    RtlMoveMemory(  Memory + (ULONG) ( sizeof( STRESS_PACKET ) +
                                       sizeof( INSTANCE_COUNTERS )),
                    (PVOID)OpenP->GlobalCounters,
                    sizeof( GLOBAL_COUNTERS ) );
}



VOID
TpPrintClientStatistics(
    POPEN_BLOCK OpenP
    )

// --------------
// 
// Routine Description:
// 
//     This routine dumps the interesting statistics held in the Client's
//     Test Protocol data structures at the end of the test.
// 
// Arguments:
// 
//     OpenP - A pointer to the OPEN_BLOCK describing the Client.
// 
// Return Value:
// 
//     None.
// 
// --------------

{
    PGLOBAL_COUNTERS GCounters;
    PINSTANCE_COUNTERS ICounters;
    PSERVER_INFO Server;
    USHORT i;

    //
    // Print out the Client Network Address and Test Counters.
    //

    IF_TPDBG ( TP_DEBUG_STATISTICS ) 
    {
        TpPrint0("\n\t****** CLIENT STATISTICS ******\n\n");
        if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) 
        {
            TpPrint1("\tLocal Address %x\t", OpenP->StationAddress[0]);
        } 
        else 
        {
            TpPrint6("\tLocal Address %x-%x-%x-%x-%x-%x\t",
                OpenP->StationAddress[0],OpenP->StationAddress[1],
                OpenP->StationAddress[2],OpenP->StationAddress[3],
                OpenP->StationAddress[4],OpenP->StationAddress[5]);
        }
        TpPrint1("OpenInstance %d\n",OpenP->OpenInstance);

        TpPrint0("\n\t****** Global Statistics ******\n\n");

        GCounters = OpenP->GlobalCounters;

        GCounters->Sends = 0;
        GCounters->Receives = 0;

        for (i=0;i<OpenP->Stress->Client->NumServers;i++) 
        {
            ICounters = OpenP->Stress->Client->Servers[i].Counters;
            GCounters->Sends += ICounters->Sends;
            GCounters->Receives += ICounters->Receives;
        }

        TpPrint1("\tTotal Packets Sent:\t\t%8lu\n",GCounters->Sends);
        TpPrint1("\tTotal Packets Received:\t\t%8lu\n",GCounters->Receives);
        TpPrint1("\tTotal Packets Lost:\t\t%8lu\n\n", GCounters->Sends-GCounters->Receives);

        TpPrint1("\tTotal Packet Sends Completed:\t%8lu\n", GCounters->SendComps);
        TpPrint1("\tTotal Packet Receives Completed:%8lu\n\n", GCounters->ReceiveComps);

        TpPrint1("\tCorrupted Packet Receives:\t%8lu\n", GCounters->CorruptRecs);
        TpPrint1("\tInvalid Packet Receives:\t%8lu\n", GCounters->InvalidPacketRecs);

        //
        // And then print out the information about each of the Servers
        // involved in the test.
        //

        TpPrint0("\n\t***** Remote Server Statistics ******\n\n");

        TpPrint1("\tClient at this address has %d Server(s) as follows:\n",
            OpenP->Stress->Client->NumServers);

        for (i=0;i<OpenP->Stress->Client->NumServers;i++) 
        {
            Server = &OpenP->Stress->Client->Servers[i];

            if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) 
            {
                TpPrint1("\n\tRemote Server Address %x, ", Server->Address[0]);
            } 
            else 
            {
                TpPrint6("\n\tRemote Server Address %x-%x-%x-%x-%x-%x, ",
                    Server->Address[0],Server->Address[1],Server->Address[2],
                    Server->Address[3],Server->Address[4],Server->Address[5]);
            }

            TpPrint1("OpenInstance %d\n\n",Server->ServerInstance);

            ICounters = Server->Counters;

            TpPrint1("\tTotal Packets Sent To:\t\t%8lu\n", ICounters->Sends);
            TpPrint1("\tTotal Packets Received From:\t%8lu\n", ICounters->Receives);
            TpPrint1("\tTotal Packets Lost:\t\t%8lu\n\n", ICounters->Sends-ICounters->Receives);

            TpPrint1("\tPacket Sends Failed:\t\t%8lu\n", ICounters->SendFails);
            TpPrint1("\tPacket Sends Pended:\t\t%8lu\n", ICounters->SendPends);
            TpPrint1("\tPacket Sends Completed:\t\t%8lu\n\n", ICounters->SendComps);
        }
    }
}



VOID
TpPrintServerStatistics(
    POPEN_BLOCK OpenP,
    PCLIENT_INFO Client
    )

// --------------
// 
// Routine Description:
// 
//     This routine dumps the interesting statistics held in the Server's
//     Test Protocol data structures at the end of the test, and information
//     about the Client that the Server was cooperating with.
// 
// Arguments:
// 
//     OpenP - A pointer to the OPEN_BLOCK describing the Server.
// 
//     Client - A pointer to the CLIENT_INFO structure describing the
//              Client this Server was responding to.
// 
// Return Value:
// 
//     None.
// 
// ----------------

{
    PINSTANCE_COUNTERS ICounters;

    //
    // Print out the Server's Network Address and Test Counters.
    //
    IF_TPDBG ( TP_DEBUG_STATISTICS ) 
    {
        TpPrint0("\t****** SERVER STATISTICS ******\n\n");

        if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) 
        {
            TpPrint1("\tLocal Address %x\t", OpenP->StationAddress[0]);
        } 
        else 
        {
            TpPrint6("\tLocal Address %x-%x-%x-%x-%x-%x\t",
                OpenP->StationAddress[0],OpenP->StationAddress[1],
                OpenP->StationAddress[2],OpenP->StationAddress[3],
                OpenP->StationAddress[4],OpenP->StationAddress[5]);
        }

        TpPrint1("OpenInstance %d\n",OpenP->OpenInstance);

        TpPrint0("\n\t****** Client Instance Statistics ******\n");

        if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) 
        {
            TpPrint1("\n\tRemote Client Address %x, ", Client->Address[0]);
        } 
        else 
        {
            TpPrint6("\n\tRemote Client Address %x-%x-%x-%x-%x-%x, ",
                Client->Address[0],Client->Address[1],Client->Address[2],
                Client->Address[3],Client->Address[4],Client->Address[5]);
        }
        TpPrint1("OpenInstance %d\n\n",Client->ClientInstance);

        //
        // And then print out the information about the Client involved
        // in the test.
        //

        ICounters = Client->Counters;

        TpPrint1("\tPackets Received:\t\t%8lu\n",ICounters->Receives);
        TpPrint1("\tPackets Sent:\t\t\t%8lu\n",ICounters->Sends);
        TpPrint1("\tPackets Not Responded To:\t%8lu\n\n", ICounters->Receives-ICounters->Sends);

        TpPrint1("\tPacket Sends Failed:\t\t%8lu\n",ICounters->SendFails);
        TpPrint1("\tPacket Sends Pended:\t\t%8lu\n",ICounters->SendPends);
        TpPrint1("\tPacket Sends Completed:\t\t%8lu\n", ICounters->SendComps);
        TpPrint1("\tPacket Receives Completed:\t%8lu\n\n", ICounters->ReceiveComps);
    }
}



VOID
TpWriteSendReceiveResults(
    PINSTANCE_COUNTERS Counters,
    PIRP Irp
    )

// ------------
// 
// Routine Description:
// 
//     Write the SEND test statistics into the Output buffer passed
//     in by the IOCTL call.  The buffer is in the Irp->MdlAddress.
//     NOTE: The OpenP->SpinLock must be held when making this call.
// 
// Arguments:
// 
//     OpenP - The location of the Irp to find the Output buffer on.
// 
//     Counters - The counters to write into the Output buffer into.
// 
// Return Value:
// 
//     None.
// 
// -------------

{
    PSEND_RECEIVE_RESULTS OutputBuffer;

    //
    // Get the output buffer out of the MDL stored in the IRP, and map
    // it so we may write the statistics to it.
    //

    OutputBuffer = MmGetSystemAddressForMdl( Irp->MdlAddress );

    //
    // Write the statistics to the outbuffer
    //

    OutputBuffer->Signature    = SENDREC_RESULTS_SIGNATURE;
    OutputBuffer->ResultsExist = TRUE;

    OutputBuffer->Counters.Sends     = Counters->Sends;
    OutputBuffer->Counters.SendPends = Counters->SendPends;
    OutputBuffer->Counters.SendComps = Counters->SendComps;
    OutputBuffer->Counters.SendFails = Counters->SendFails;

    OutputBuffer->Counters.Receives     = Counters->Receives;
    OutputBuffer->Counters.ReceiveComps = Counters->ReceiveComps;
    OutputBuffer->Counters.CorruptRecs  = Counters->CorruptRecs;

    OutputBuffer->Counters.XferData      = Counters->XferData;
    OutputBuffer->Counters.XferDataPends = Counters->XferDataPends;
    OutputBuffer->Counters.XferDataComps = Counters->XferDataComps;
    OutputBuffer->Counters.XferDataFails = Counters->XferDataFails;
}



VOID
TpInitializePending(
    PPENDING Pend
    )

// ----------
// 
// Routine Description:
// 
//     This routine zeroes the counters in a PENDING_WATCH structure, and
//     sets up the storage area for pending packets.
// 
// Arguments:
// 
//     Pend - A pointer to the Pend Structure to be zeroed.
// 
// Return Value:
// 
//     None.
// 
// ----------

{
    INT i;

    //
    // set up the pending packet storage and counters.
    //

    Pend->PendingPackets = 0;
    Pend->PendingRequests = 0;
    Pend->PacketPendNumber = 0;
    Pend->PacketCompleteNumber = 0;

    for ( i=0 ; i<NUM_PACKET_PENDS ; i++ ) 
    {
        Pend->Packets[i] = NULL;
    }
}



VOID
TpInitializeStressResults(
    PSTRESS_RESULTS Results
    )

// ---------
// 
// Routine Description:
// 
// Arguments:
// 
// Return Value:
// 
//     None.
// 
// ---------

{
    INT i;

    NdisZeroMemory((PVOID)Results,sizeof( STRESS_RESULTS ));

    Results->Signature = STRESS_RESULTS_SIGNATURE;

    for ( i=0;i<MAX_SERVERS;i++ ) 
    {
        Results->Servers[i].Signature = STRESS_RESULTS_SIGNATURE;
    }
}


#if 0

//   do it on a per open basis.


VOID
TpDumpInfo(
    VOID
    )

// --------------
// 
// Routine Description:
// 
//     TpDumpInfo is a debugging routine that may be called from the kernel
//     debugger by resetting EIP to the entry of TpDumpInfo to dump the state
//     for the Test Protocol at any given time.
// 
//     NOTE: This routine does not reset the stack so care must be used if
//           one wishes to continue running the Test Protocol after this
//           procedure has executed.  This routine was designed to dump
//           the state of the Protocol after a system crash.
// 
// Arguments:
// 
//     None.
// 
// Return Value:
// 
//     None.
// 
// --------------

{
    static POPEN_BLOCK OpenP;
    static PSTRESS_ARGUMENTS Args;
    static PCLIENT_STORAGE Client;
    static PSERVER_STORAGE Server;
    static PGLOBAL_COUNTERS GCounters
    static PINSTANCE_COUNTERS ICounters;
    static INT i;

    OpenP = OpenList;

    TpPrint0("****** Open Block Structure ******\n\n");

    TpPrint1("Ndis Handle\t\t%10lX\n",OpenP->NdisBindingHandle);
    TpPrint1("Next Open Block\t\t%10lX\n",OpenP->Next);
    TpPrint1("Open Instance\t\t%10ld\n",OpenP->OpenInstance);

    if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) 
    {
        TpPrint1("Machine Address  \t%x\n\n", OpenP->StationAddress[0] );
    } 
    else 
    {
        TpPrint6("Machine Address  \t%x-%x-%x-%x-%x-%x\n\n",
            OpenP->StationAddress[0],OpenP->StationAddress[1],
            OpenP->StationAddress[2],OpenP->StationAddress[3],
            OpenP->StationAddress[4],OpenP->StationAddress[5]);
    }

    TpPrint0("****** Test Arguments Structure ******\n\n");

    Args = OpenP->Arguments;

    TpPrint1("MemberType\t\t%10d\n",Args->MemberType);
    TpPrint1"PACKET_TYPE\t\t%10d\n",Args->PacketType);
    TpPrint1("Packet Size Value\t%10d\n",Args->PacketSize);
    TpPrint1("PACKET_MAKEUP\t\t%10d\n",Args->PacketMakeUp);
    TpPrint1("RESPONSE_TYPE\t\t%10d\n",Args->ResponseType);
    TpPrint1("Iterations So Far\t%10lu\n",Args->Iterations);
    TpPrint1("Total Iterations\t%10lu\n",Args->TotalIterations);
    TpPrint1("Total Packets\t\t%10lu\n",Args->TotalPackets);
    TpPrint1("Interpacket Delay\t%10lu\n",Args->DelayLength);
    TpPrint1("All Packets Sent?\t\t%s\n",(Args->AllPacketsSent) ? "TRUE" : "FALSE");
    TpPrint1("Window Enabled?\t\t\t%s\n",(Args->WindowEnabled) ? "TRUE" : "FALSE");
    TpPrint1("Data Checking?\t\t\t%s\n",(Args->DataChecking) ? "TRUE" : "FALSE");
    TpPrint1("Packets From Pool?\t\t%s\n",(Args->PacketsFromPool) ? "TRUE" : "FALSE");
    TpPrint1("Begin Receives?\t\t\t%s\n",(Args->BeginReceives) ? "TRUE" : "FALSE");
    TpPrint1("Server Continue?\t\t\t%s\n\n",(Args->ServerContinue) ? "TRUE" : "FALSE");

    TpPrint0("****** Global Counters Structure ******\n\n");

    GCounters = OpenP->GlobalCounters;

    TpPrint1("Packet Sends\t\t\t%10lu\n",GCounters->Sends);
    TpPrint1("Packet Receives\t\t%10lu\n",GCounters->Receives);
    TpPrint1("Corrupted Packet Receives\t%10lu\n",GCounters->CorruptRecs);
    TpPrint1("Invalid Protocol Receives\t%10lu\n",GCounters->InvalidPacketRecs);

    if (OpenP->Stress->Client != NULL) 
    {
        TpPrint0("****** Client Storage Structure ******\n\n");

        Client = OpenP->Stress->Client;

        TpPrint1("Number of Servers\t\t%10ld\n",Client->NumServers);
        TpPrint1("Packet Pool\t\t\t%10lX\n",Client->PacketPool);
        TpPrint1("Transmit Pool\t\t\t%10lX\n",Client->TransmitPool);

        TpPrint0("\n****** Servers with this Client ******\n\n");

        for (i=0;i<Client->NumServers;i++) 
        {
            TpPrint1("****** Server Number %d ******\n\n",i+1);
            TpPrint1("Server Instance\t\t\t%10ld\n",Client->Servers[i].ServerInstance);
            TpPrint1("Client Reference\t\t%10ld\n",Client->Servers[i].ClientReference);
            TpPrint1("Server Reference\t\t\t%10ld\n",Client->Servers[i].ServerReference);

            if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) 
            {
                TpPrint1("Server[%d] Address\t%x\n",i, Client->Servers[i].Address[0]);
            } 
            else 
            {
                TpPrint6("Server[%d] Address\t%x-%x-%x-%x-%x-%x\n",i,
                    Client->Servers[i].Address[0],Client->Servers[i].Address[1],
                    Client->Servers[i].Address[2],Client->Servers[i].Address[3],
                    Client->Servers[i].Address[4],Client->Servers[i].Address[5]);
            }

            TpPrint1("Sequence Number\t\t\t%10lu\n",Client->Servers[i].SequenceNumber);
            TpPrint1("Max Sequence Number\t\t%10lu\n",Client->Servers[i].MaxSequenceNumber);
            TpPrint1("Packet Delay\t\t\t%10lu\n\n", Client->Servers[i].PacketDelay);

            ICounters = Client->Servers[i].Counters;

            TpPrint1("****** Server Number %d's Counters ******\n\n",i+1);
            TpPrint1("Packet Sends\t\t\t%10lu\n",ICounters->Sends);
            TpPrint1("Packet Send Pends\t\t%10lu\n",ICounters->SendPends);
            TpPrint1("Packet Send Completes\t\t%10lu\n",ICounters->SendComps);
            TpPrint1("Packet Send Fails\t\t%10lu\n",ICounters->SendFails);
            TpPrint1("Packet Receives\t\t\t%10lu\n",ICounters->Receives);
            TpPrint1("Corrupted Packet Receives\t%10lu\n",ICounters->CorruptRecs);
        }
    }

    if (OpenP->Stress->Server != NULL) 
    {
        TpPrint0("****** Server Storage Structure ******\n\n");

        Server = OpenP->Stress->Server;

        TpPrint1("Number of Clients\t%10ld\n",Server->NumClients);
        TpPrint1("Number of Active Clients%10ld\n",Server->ActiveClients);
        TpPrint1("Packet Pool\t\t%10lX\n",Server->PacketPool);
        TpPrint1("Transmit Pool\t\t%10lX\n\n",Server->TransmitPool);

        TpPrint0("******Clients with this Server******\n\n");

        for (i=0;i<Server->NumClients;i++) 
        {
            TpPrint1("****** Client Number %d ******\n\n",i+1);
            TpPrint1("Client Instance\t\t%10ld\n",Server->Clients[i].ClientInstance);
            TpPrint1("Client Reference\t%10ld\n",Server->Clients[i].ClientReference);
            TpPrint1("Data Checking\t\t\t%s\n",
                (Server->Clients[i].DataChecking) ? "TRUE" : "FALSE");

            if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) 
            {
                TpPrint1("Client[%d] Address\t%x\n\n",i, Server->Clients[i].Address[0]);
            } 
            else 
            {
                TpPrint6("Client[%d] Address\t%x-%x-%x-%x-%x-%x\n\n",i,
                    Server->Clients[i].Address[0],Server->Clients[i].Address[1],
                    Server->Clients[i].Address[2],Server->Clients[i].Address[3],
                    Server->Clients[i].Address[4],Server->Clients[i].Address[5]);
            }

            ICounters = Server->Clients[i].Counters;

            TpPrint1("****** Client Number %d's ICountersers ******\n\n",i);
            TpPrint1("Packet Sends\t\t\t%10lu\n",ICounters->Sends);
            TpPrint1("Packet Send Pends\t\t%10lu\n",ICounters->SendPends);
            TpPrint1("Packet Send Completes\t\t%10lu\n",ICounters->SendComps);
            TpPrint1("Packet Send Fails\t\t%10lu\n",ICounters->SendFails);
            TpPrint1("Packet Receives\t\t\t%10lu\n",ICounters->Receives);
            TpPrint1("Corrupted Packet Receives\t%10lu\n",ICounters->CorruptRecs);
        }
    }

    TpPrint0("\n\n\n");

    ASSERT( FALSE );
}

#endif