5 files changed, 1300 insertions, 0 deletions

diff --git a/private/ntos/ndis/testprot/tpkd/makefile b/private/ntos/ndis/testprot/tpkd/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/ntos/ndis/testprot/tpkd/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/ntos/ndis/testprot/tpkd/sources b/private/ntos/ndis/testprot/tpkd/sources
new file mode 100644
index 000000000..92652ad3e
--- /dev/null
+++ b/private/ntos/ndis/testprot/tpkd/sources
@@ -0,0 +1,55 @@
+!IF 0
+
+Copyright (c) 1989  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+
+Author:
+
+    Steve Wood (stevewo) 12-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\bak\bin\sources.tpl
+
+!ENDIF
+
+MAJORCOMP=ntos
+MINORCOMP=testprot
+
+TARGETNAME=tpkd
+TARGETPATH=obj
+TARGETTYPE=DYNLINK
+TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\libc.lib \
+           $(BASEDIR)\public\sdk\lib\*\kernel32.lib
+
+DLLBASE=0x1010000
+
+INCLUDES=..\inc;..\..\inc;..\..\..\inc;..\..\..\..\inc
+
+SOURCES=tpkd.c
+
+i386_SOURCES=
+MIPS_SOURCES=
+
+386_STDCALL=1
+MIPS_FLAGS=-D_stdcall
+
+UMTYPE=console
+OPTIONAL_NTTEST=
+
+!IFNDEF 386_WARNING_LEVEL
+386_WARNING_LEVEL=/W3
+!ENDIF
+
+!IFNDEF MIPS_WARNINGS
+MIPS_WARNINGS=-std
+!ENDIF
diff --git a/private/ntos/ndis/testprot/tpkd/tpkd.c b/private/ntos/ndis/testprot/tpkd/tpkd.c
new file mode 100644
index 000000000..fb208dbc4
--- /dev/null
+++ b/private/ntos/ndis/testprot/tpkd/tpkd.c
@@ -0,0 +1,450 @@
+/*++
+
+Copyright (c) 1990 Microsoft Corporation
+
+Module Name:
+
+    kdndis.c
+
+Abstract:
+
+    Ndis Testprot Kernel Debugger extension
+
+    This module contains a set of useful kernel debugger extensions for the
+    NT MAC Tester
+
+Author:
+
+    Sanjeev Katariya May-6-1993
+
+Revision History:
+
+        Created
+
+--*/
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <windows.h>
+#include <ntkdexts.h>
+#include <stdlib.h>
+#include <malloc.h>
+
+#include "tpkd.h"
+
+
+VOID
+DumpNdisPacket(
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine,
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine,
+    PNDIS_PACKET              NdisPacket,
+    DWORD                     AddressNdisPacket
+              )
+{
+
+    NDIS_BUFFER    NdisBuffer;
+    DWORD          BufferAddress;
+    BOOL           ReadMemory = FALSE;
+    INT            i;
+
+    (OutputRoutine)( "\nNDIS_PACKET at Memory location: 0x%lx\n", AddressNdisPacket );
+
+    (OutputRoutine)( "\tNDIS_PACKET_PRIVATE\n" );
+    (OutputRoutine)( "\t\tPhysical Count       : %ld\n"  , NdisPacket->Private.PhysicalCount );
+    (OutputRoutine)( "\t\tTotal Length         : %ld\n"  , NdisPacket->Private.TotalLength   );
+    (OutputRoutine)( "\t\tNdis Buffer Head Ptr : 0x%lx\n", NdisPacket->Private.Head          );
+    (OutputRoutine)( "\t\tNdis Buffer Tail Ptr : 0x%lx\n", NdisPacket->Private.Tail          );
+    (OutputRoutine)( "\t\tNdis Packet Pool Ptr : 0x%lx\n", NdisPacket->Private.Pool          );
+    (OutputRoutine)( "\t\tCount                : %ld\n"  , NdisPacket->Private.Count         );
+    (OutputRoutine)( "\t\tFlags                : 0x%lx\n", NdisPacket->Private.Flags         );
+    (OutputRoutine)( "\t\tValid Counts         : %d\n"   , NdisPacket->Private.ValidCounts   );
+    (OutputRoutine)( "\t\tMacReserved          : " );
+
+    for( i = 0; i < 16; i++ ) {
+        (OutputRoutine)( "0x%2.2x", NdisPacket->MacReserved[i] );
+    }
+    (OutputRoutine)( "\n\t\tProtocolReserved     : 0x%2.2x\n", NdisPacket->ProtocolReserved[0] );
+
+
+    //
+    // And now the NDIS_BUFFER chain
+    //
+    BufferAddress  = NdisPacket->Private.Head;
+
+    try {
+
+        ReadMemory     = (ReadMemoryRoutine)( (LPVOID)BufferAddress,
+                                              &NdisBuffer,
+                                              sizeof( NDIS_BUFFER ),
+                                              NULL
+                                            );
+
+    } except ( EXCEPTION_ACCESS_VIOLATION ) {
+
+        (OutputRoutine)( "The routine was unable to access NDIS_BUFFER number of bytes.\n"  );
+        (OutputRoutine)( "Possible bad NDIS_BUFFER address 0x%lx\n", BufferAddress );
+        return;
+
+    }
+
+    while ( ReadMemory ) {
+
+        DumpNdisBuffer( OutputRoutine, ReadMemoryRoutine, &NdisBuffer, BufferAddress );
+
+        BufferAddress = NdisBuffer.Next;
+        (OutputRoutine)( "\n\tNext NDIS_BUFFER at address 0x%lx\n", BufferAddress );
+
+        try {
+
+            ReadMemory     = (ReadMemoryRoutine)( (LPVOID)BufferAddress,
+                                                  &NdisBuffer,
+                                                  sizeof( NDIS_BUFFER ),
+                                                  NULL
+                                                );
+
+        } except ( EXCEPTION_ACCESS_VIOLATION ) {
+
+            (OutputRoutine)( "The routine was unable to access NDIS_BUFFER number of bytes.\n"  );
+            (OutputRoutine)( "Possible bad NDIS_BUFFER address 0x%lx\n", BufferAddress );
+            return;
+
+        }
+    }
+
+}
+
+
+VOID
+DumpNdisBuffer(
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine,
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine,
+    PNDIS_BUFFER              NdisBuffer,
+    DWORD                     AddressNdisBuffer
+              )
+{
+    ULONG    i;
+    BOOL     ReadMemory = FALSE;
+    PUCHAR   Buffer = calloc( NdisBuffer->ByteCount, sizeof( UCHAR ) );
+
+    (OutputRoutine)( "\n\tNDIS_BUFFER at Memory location: 0x%lx\n", AddressNdisBuffer );
+
+    (OutputRoutine)( "\t\tNext Buffer          : 0x%lx\n", NdisBuffer->Next     );
+    (OutputRoutine)( "\t\tSize                 : %d\n"   , NdisBuffer->Size     );
+    (OutputRoutine)( "\t\tMDL Flags            : 0x%x\n" , NdisBuffer->MdlFlags );
+    (OutputRoutine)( "\t\tEPROCESS Ptr         : 0x%lx\n", NdisBuffer->Process  );
+    (OutputRoutine)( "\t\tMapped System VA     : 0x%lx\n", NdisBuffer->MappedSystemVa );
+    (OutputRoutine)( "\t\tStart VA             : 0x%lx\n", NdisBuffer->StartVa  );
+    (OutputRoutine)( "\t\tByte Count           : 0x%lx\n", NdisBuffer->ByteCount);
+    (OutputRoutine)( "\t\tByte Offset          : 0x%lx\n", NdisBuffer->ByteOffset );
+    (OutputRoutine)( "\t\tVA Contents\n" );
+
+
+    if ( Buffer != NULL ) {
+
+        try {
+
+            ReadMemory = (ReadMemoryRoutine)( (LPVOID)NdisBuffer->StartVa,
+                                              Buffer,
+                                              NdisBuffer->ByteCount,
+                                              NULL
+                                            );
+
+        } except ( EXCEPTION_ACCESS_VIOLATION ) {
+
+            (OutputRoutine)( "The routine was unable to access Byte Count number of bytes.\n"  );
+            (OutputRoutine)( "Possible bad StartVa address 0x%lx\n", NdisBuffer->StartVa );
+            ReadMemory = FALSE;
+
+        }
+
+        if ( ReadMemory ) {
+
+            for( i = 0; i < NdisBuffer->ByteCount ; i++ ) {
+
+                if ( (i%16) == 0 ) {
+
+                    (OutputRoutine)( "\n\t\t%2x", Buffer[i] );
+
+                } else  {
+
+                    (OutputRoutine)( "-%2x", Buffer[i] );
+
+                }
+            }
+            (OutputRoutine)( "\n" );
+            free( Buffer );
+            return;
+
+        }
+
+        free( Buffer );
+
+    }
+
+    (OutputRoutine)( "Unable to access contents of StartVa: 0x%lx\n", NdisBuffer->StartVa );
+
+
+}
+
+
+VOID
+DumpOpenBuffer(
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine,
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine,
+    POPEN_BLOCK               OpenBuffer,
+    DWORD                     AddressOpenBuffer
+              )
+{
+    ULONG    i;
+    BOOL     ReadMemory = FALSE;
+
+    (OutputRoutine)( "\n\tOPEN_BLOCK at Memory location: 0x%lx\n\n", AddressOpenBuffer );
+
+    (OutputRoutine)( "\t\tNdisBindingHandle            : 0x%lx\n", OpenBuffer->NdisBindingHandle  );
+    (OutputRoutine)( "\t\tNdisProtocolHandle           : 0x%lx\n", OpenBuffer->NdisProtocolHandle );
+    (OutputRoutine)( "\t\tOpenInstance                 : %d\n"   , OpenBuffer->OpenInstance       );
+    (OutputRoutine)( "\t\tClosing Status               : %d\n"   , OpenBuffer->Closing            );
+    (OutputRoutine)( "\t\tStation Address              : " );
+    for( i = 0 ; i < ADDRESS_LENGTH; i++ ) {
+        (OutputRoutine)( "%2.2x", OpenBuffer->StationAddress[i] );
+    }
+    (OutputRoutine)( "\n" );
+    (OutputRoutine)( "\t\tPtr to Adapter Name          : 0x%lx\n", OpenBuffer->AdapterName    );
+    (OutputRoutine)( "\t\tSpin Lock Resource           : 0x%lx\n", OpenBuffer->SpinLock       );
+    (OutputRoutine)( "\t\tReference Count              : %d\n"   , OpenBuffer->ReferenceCount );
+    (OutputRoutine)( "\t\tMedium Index                 : %d\n"   , OpenBuffer->MediumIndex    );
+    (OutputRoutine)( "\t\tPtr to Media Info            : 0x%lx\n", OpenBuffer->Media          );
+    (OutputRoutine)( "\t\tPtr to Global Counters       : 0x%lx\n", OpenBuffer->GlobalCounters );
+    (OutputRoutine)( "\t\tPtr to Environment           : 0x%lx\n", OpenBuffer->Environment    );
+    (OutputRoutine)( "\t\tPtr to Stress Block          : 0x%lx\n", OpenBuffer->Stress         );
+    (OutputRoutine)( "\t\tPtr to Send Block            : 0x%lx\n", OpenBuffer->Send           );
+    (OutputRoutine)( "\t\tPtr to Receive Block         : 0x%lx\n", OpenBuffer->Receive        );
+    (OutputRoutine)( "\t\tPtr to Event Queue           : 0x%lx\n", OpenBuffer->EventQueue     );
+    (OutputRoutine)( "\t\tPtr to Pause Block           : 0x%lx\n", OpenBuffer->Pause          );
+    (OutputRoutine)( "\t\tPtr to Open  Request Handle  : 0x%lx\n", OpenBuffer->OpenReqHndl    );
+    (OutputRoutine)( "\t\tPtr to Close Request Handle  : 0x%lx\n", OpenBuffer->CloseReqHndl   );
+    (OutputRoutine)( "\t\tPtr to Reset Request Handle  : 0x%lx\n", OpenBuffer->ResetReqHndl   );
+    (OutputRoutine)( "\t\tPtr to Request Request Handle: 0x%lx\n", OpenBuffer->RequestReqHndl );
+    (OutputRoutine)( "\t\tPtr to Stress Request Handle : 0x%lx\n", OpenBuffer->StressReqHndl  );
+
+    (OutputRoutine)( "\t\tStatus IRP cancelled         : %d\n"   , OpenBuffer->IrpCancelled );
+    (OutputRoutine)( "\t\tPtr to IRP                   : 0x%lx\n", OpenBuffer->Irp          );
+    (OutputRoutine)( "\t\tSignature                    : 0x%lx\n", OpenBuffer->Signature    );
+
+}
+
+
+
+/*
+ *************************  Exported Routines **********************************
+ *                                                                             *
+ *  Method for invoking at debugger                                            *
+ *                                                                             *
+ *  kd > !tpkd.ndispacket Address  where Address is of type pointer            *
+ *  kd > !tpkd.ndisbuffer Address  where Address is of type pointer            *
+ *  kd > !tpkd.openblock  Address  where Address is of type pointer            *
+ *  kd > !tpkd.help                                                            *
+ *                                                                             *
+ *******************************************************************************
+*/
+
+
+VOID
+ndispacket(
+    DWORD                CurrentPc,
+    PNTKD_EXTENSION_APIS ExtensionApis,
+    LPSTR                ArgumentString
+          )
+{
+
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine       ;
+    PNTKD_GET_EXPRESSION      GetExpressionRoutine;
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine   ;
+    PNTKD_GET_SYMBOL          GetSymbolRoutine    ;
+    NDIS_PACKET               Packet              ;
+    DWORD                     AddressNdisPacket   ;
+    BOOL                      ReadMemory = FALSE  ;
+
+    OutputRoutine        = ExtensionApis->lpOutputRoutine;
+    GetExpressionRoutine = ExtensionApis->lpGetExpressionRoutine;
+    GetSymbolRoutine     = ExtensionApis->lpGetSymbolRoutine;
+    ReadMemoryRoutine    = ExtensionApis->lpReadVirtualMemRoutine;
+
+    //
+    // Get the address of the NDIS_PACKET
+    AddressNdisPacket = (GetExpressionRoutine)(ArgumentString);
+    //
+    if ( !AddressNdisPacket ) {
+        return;
+    }
+
+    try {
+
+        //
+        // Now read the memory contents into our buffer area
+        //
+        ReadMemory = (ReadMemoryRoutine)( (LPVOID)AddressNdisPacket,
+                                          &Packet,
+                                          sizeof(NDIS_PACKET),
+                                          NULL
+                                        );
+    } except( EXCEPTION_ACCESS_VIOLATION ) {
+
+        (OutputRoutine)( "The routine was unable to access NDIS_PACKET size bytes.\n"  );
+        (OutputRoutine)( "Possible bad NDIS_PACKET address 0x%lx\n", AddressNdisPacket );
+        ReadMemory = FALSE;
+
+    }
+
+    if ( !ReadMemory ) {
+        return;
+    }
+
+
+    DumpNdisPacket( OutputRoutine,
+                    ReadMemoryRoutine,
+                    &Packet,
+                    AddressNdisPacket );
+
+}
+
+
+VOID
+ndisbuffer(
+    DWORD                CurrentPc,
+    PNTKD_EXTENSION_APIS ExtensionApis,
+    LPSTR                ArgumentString
+          )
+{
+
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine       ;
+    PNTKD_GET_EXPRESSION      GetExpressionRoutine;
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine   ;
+    PNTKD_GET_SYMBOL          GetSymbolRoutine    ;
+    NDIS_BUFFER               NdisBuffer          ;
+    DWORD                     AddressNdisBuffer   ;
+    BOOL                      ReadMemory = FALSE  ;
+
+    OutputRoutine        = ExtensionApis->lpOutputRoutine;
+    GetExpressionRoutine = ExtensionApis->lpGetExpressionRoutine;
+    GetSymbolRoutine     = ExtensionApis->lpGetSymbolRoutine;
+    ReadMemoryRoutine    = ExtensionApis->lpReadVirtualMemRoutine;
+
+    //
+    // Get the address of the NDIS_PACKET
+    //
+
+    AddressNdisBuffer = (GetExpressionRoutine)(ArgumentString);
+    if ( !AddressNdisBuffer ) {
+        return;
+    }
+
+    try {
+
+        //
+        // Now read the memory contents into our buffer area
+        //
+        ReadMemory = (ReadMemoryRoutine)( (LPVOID)AddressNdisBuffer,
+                                           &NdisBuffer,
+                                           sizeof(NDIS_BUFFER),
+                                           NULL
+                                        );
+    } except( EXCEPTION_ACCESS_VIOLATION ) {
+
+        (OutputRoutine)( "The routine was unable to access NDIS_BUFFER size bytes.\n"  );
+        (OutputRoutine)( "Possible bad NDIS_BUFFER address 0x%lx\n", AddressNdisBuffer );
+        ReadMemory = FALSE;
+
+    }
+
+    if ( !ReadMemory ) {
+        return;
+    }
+
+
+    DumpNdisBuffer( OutputRoutine,
+                    ReadMemoryRoutine,
+                    &NdisBuffer,
+                    AddressNdisBuffer );
+
+}
+
+
+VOID
+openblock(
+    DWORD                CurrentPc,
+    PNTKD_EXTENSION_APIS ExtensionApis,
+    LPSTR                ArgumentString
+          )
+{
+
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine       ;
+    PNTKD_GET_EXPRESSION      GetExpressionRoutine;
+    PNTKD_READ_VIRTUAL_MEMORY ReadMemoryRoutine   ;
+    PNTKD_GET_SYMBOL          GetSymbolRoutine    ;
+    OPEN_BLOCK                OpenBuffer          ;
+    DWORD                     AddressOpenBuffer   ;
+    BOOL                      ReadMemory = FALSE  ;
+
+    OutputRoutine        = ExtensionApis->lpOutputRoutine;
+    GetExpressionRoutine = ExtensionApis->lpGetExpressionRoutine;
+    GetSymbolRoutine     = ExtensionApis->lpGetSymbolRoutine;
+    ReadMemoryRoutine    = ExtensionApis->lpReadVirtualMemRoutine;
+
+    //
+    // Get the address of the OPEN_BLOCK
+    //
+
+    AddressOpenBuffer = (GetExpressionRoutine)(ArgumentString);
+    if ( !AddressOpenBuffer ) {
+        return;
+    }
+
+    try {
+
+        //
+        // Now read the memory contents into our buffer area
+        //
+        ReadMemory = (ReadMemoryRoutine)( (LPVOID)AddressOpenBuffer,
+                                           &OpenBuffer,
+                                           sizeof(OPEN_BLOCK),
+                                           NULL
+                                        );
+    } except( EXCEPTION_ACCESS_VIOLATION ) {
+
+        (OutputRoutine)( "The routine was unable to access OPEN_BLOCK size bytes.\n"  );
+        (OutputRoutine)( "Possible bad OPEN_BLOCK address 0x%lx\n", AddressOpenBuffer );
+        ReadMemory = FALSE;
+
+    }
+
+    if ( !ReadMemory ) {
+        return;
+    }
+
+
+    DumpOpenBuffer( OutputRoutine,
+                    ReadMemoryRoutine,
+                    &OpenBuffer,
+                    AddressOpenBuffer );
+
+}
+
+VOID
+help(
+    DWORD                CurrentPc,
+    PNTKD_EXTENSION_APIS ExtensionApis,
+    LPSTR                ArgumentString
+    )
+{
+
+    PNTKD_OUTPUT_ROUTINE      OutputRoutine;
+
+    OutputRoutine        = ExtensionApis->lpOutputRoutine;
+
+    (OutputRoutine)( "The following commands are available\n" );
+    (OutputRoutine)( "\tndispacket <address>\n\tndisbuffer <address>\n\topenblock\n\thelp\n" );
+
+
+}
diff --git a/private/ntos/ndis/testprot/tpkd/tpkd.def b/private/ntos/ndis/testprot/tpkd/tpkd.def
new file mode 100644
index 000000000..9ee251527
--- /dev/null
+++ b/private/ntos/ndis/testprot/tpkd/tpkd.def
@@ -0,0 +1,8 @@
+LIBRARY     TPKD
+DESCRIPTION 'NDIS KD extensions'
+
+EXPORTS
+        ndispacket
+        ndisbuffer
+        openblock
+        help
diff --git a/private/ntos/ndis/testprot/tpkd/tpkd.h b/private/ntos/ndis/testprot/tpkd/tpkd.h
new file mode 100644
index 000000000..23942288d
--- /dev/null
+++ b/private/ntos/ndis/testprot/tpkd/tpkd.h
@@ -0,0 +1,781 @@
+//
+// I/O system definitions.
+//
+// Define a Memory Descriptor List (MDL)
+//
+// An MDL describes pages in a virtual buffer in terms of physical pages.  The
+// pages associated with the buffer are described in an array that is allocated
+// just after the MDL header structure itself.  In a future compiler this will
+// be placed at:
+//
+//      ULONG Pages[];
+//
+// Until this declaration is permitted, however, one simply calculates the
+// base of the array by adding one to the base MDL pointer:
+//
+//      Pages = (PULONG) (Mdl + 1);
+//
+// Notice that while in the context of the subject thread, the base virtual
+// address of a buffer mapped by an MDL may be referenced using the following:
+//
+//      Mdl->StartVa | Mdl->ByteOffset
+//
+
+typedef struct _MDL {
+
+    struct _MDL      *Next;
+    CSHORT           Size;
+    CSHORT           MdlFlags;
+    struct _EPROCESS *Process;
+    PVOID            MappedSystemVa;
+    PVOID            StartVa;
+    ULONG            ByteCount;
+    ULONG            ByteOffset;
+
+} MDL, *PMDL;
+
+typedef struct _IRP    { ULONG Value; }  IRP   ;
+typedef struct _KEVENT { ULONG Value; }  KEVENT;
+typedef struct _KDPC   { ULONG Value; }  KDPC  ;
+typedef struct _KTIMER { ULONG Value; }  KTIMER;
+
+typedef IRP     *PIRP;
+typedef KEVENT  *PKEVENT;
+typedef KDPC    *PKDPC;
+typedef KTIMER  *PKTIMER;
+
+
+//
+//      NDIS DEFINITIONS
+//
+
+typedef MDL NDIS_BUFFER,   * PNDIS_BUFFER;
+typedef ULONG NDIS_OID,    *PNDIS_OID    ;
+typedef PVOID NDIS_HANDLE, *PNDIS_HANDLE ;
+typedef NTSTATUS           NDIS_STATUS   ;
+
+
+typedef struct _NDIS_SPIN_LOCK {
+
+    KSPIN_LOCK SpinLock;
+    KIRQL      OldIrql;
+
+} NDIS_SPIN_LOCK, * PNDIS_SPIN_LOCK;
+
+typedef struct _NDIS_PACKET_POOL {
+
+    NDIS_SPIN_LOCK      SpinLock;
+    struct _NDIS_PACKET *FreeList;         // linked list of free slots in pool
+    UINT                PacketLength;      // amount needed in each packet
+    UCHAR               Buffer[1];         // actual pool memory
+
+} NDIS_PACKET_POOL, * PNDIS_PACKET_POOL;
+
+typedef struct _NDIS_PACKET_PRIVATE {
+
+    UINT              PhysicalCount;     // number of physical pages in packet.
+    UINT              TotalLength;       // Total amount of data in the packet.
+    PNDIS_BUFFER      Head;              // first buffer in the chain
+    PNDIS_BUFFER      Tail;              // last buffer in the chain
+    PNDIS_PACKET_POOL Pool;              // so we know where to free it back to
+    UINT              Count;
+    ULONG             Flags;
+    BOOLEAN           ValidCounts;
+
+} NDIS_PACKET_PRIVATE, * PNDIS_PACKET_PRIVATE;
+
+typedef struct _NDIS_PACKET {
+
+    NDIS_PACKET_PRIVATE Private;
+    UCHAR               MacReserved[16];
+    UCHAR               ProtocolReserved[1];
+
+} NDIS_PACKET, * PNDIS_PACKET;
+
+typedef enum _NDIS_REQUEST_TYPE {
+
+    NdisRequestQueryInformation,
+    NdisRequestSetInformation,
+    NdisRequestQueryStatistics,
+    NdisRequestOpen,
+    NdisRequestClose,
+    NdisRequestSend,
+    NdisRequestTransferData,
+    NdisRequestReset,
+    NdisRequestGeneric1,
+    NdisRequestGeneric2,
+    NdisRequestGeneric3,
+    NdisRequestGeneric4
+
+} NDIS_REQUEST_TYPE, *PNDIS_REQUEST_TYPE;
+
+typedef struct _NDIS_REQUEST {
+
+    UCHAR             MacReserved[16];
+    NDIS_REQUEST_TYPE RequestType;
+    union _DATA {
+
+        struct _QUERY_INFORMATION {
+            NDIS_OID Oid;
+            PVOID    InformationBuffer;
+            UINT     InformationBufferLength;
+            UINT     BytesWritten;
+            UINT     BytesNeeded;
+        } QUERY_INFORMATION;
+
+        struct _SET_INFORMATION {
+            NDIS_OID Oid;
+            PVOID    InformationBuffer;
+            UINT     InformationBufferLength;
+            UINT     BytesRead;
+            UINT     BytesNeeded;
+        } SET_INFORMATION;
+
+    } DATA;
+
+} NDIS_REQUEST, *PNDIS_REQUEST;
+
+//
+// END OF NDIS DEFINITIONS
+//
+
+
+//
+// TPDEF DEFINITIONS
+//
+
+#define ADDRESS_LENGTH            6
+#define ADDRESS_LENGTH_1_OCTET    1
+#define MAX_SERVERS               10
+#define MAX_CLIENTS               10
+#define NUM_PACKET_PENDS          1000
+#define MAX_NUMBER_BUFFERS        2
+#define NUMBER_OF_POOL_PACKETS    10
+#define MAX_EVENT                 20
+
+#include <packon.h>
+
+//
+//              THE MEDIA HEADER
+//
+typedef struct _E_802_3 {
+
+    UCHAR  DestAddress[ADDRESS_LENGTH];
+    UCHAR  SrcAddress[ADDRESS_LENGTH];
+    UCHAR  PacketSize_Hi;
+    UCHAR  PacketSize_Lo;
+
+} E_802_3;
+
+typedef struct _TR_802_5 {
+
+    UCHAR  AC;
+    UCHAR  FC;
+    UCHAR  DestAddress[ADDRESS_LENGTH];
+    UCHAR  SrcAddress[ADDRESS_LENGTH];
+
+} TR_802_5;
+
+typedef struct _FDDI {
+
+    UCHAR  FC;
+    UCHAR  DestAddress[ADDRESS_LENGTH];
+    UCHAR  SrcAddress[ADDRESS_LENGTH];
+
+} FDDI;
+
+typedef struct _ARCNET {
+
+    UCHAR  SrcAddress[ADDRESS_LENGTH_1_OCTET] ;
+    UCHAR  DestAddress[ADDRESS_LENGTH_1_OCTET];
+    UCHAR  ProtocolID                 ;
+
+} ARCNET;
+
+typedef union _MEDIA_HEADER {
+
+        E_802_3  e;
+        TR_802_5 tr;
+        FDDI     fddi;
+        ARCNET   a;
+
+} MEDIA_HEADER ;
+
+//
+//             THE TEST PROTOCOL HEADER
+//
+typedef struct _PACKET_INFO {
+
+    ULONG     Signature;
+    ULONG     PacketSize;         // the total size of the packet
+    UCHAR     DestInstance;       // instance of the packet's dest ndis binding
+    UCHAR     SrcInstance;        // instance of the packet's src ndis binding
+    UCHAR     PacketType;         // type of packet; STRESS or FUNC
+    union {
+    UCHAR     PacketProtocol;     // for STRESS packets the actual protocol type.
+    UCHAR     PacketNumber;       // ranges from 0x00 to 0xff, for tracking FUNCs.
+    }         u;
+    ULONG     CheckSum;           // functional packet header check sum
+
+} PACKET_INFO;
+
+//
+//              THE FUNC1 PACKET HEADER
+//
+typedef struct _FUNC1_PACKET {
+
+    MEDIA_HEADER media;
+    PACKET_INFO  info;
+
+} FUNC1_PACKET;
+
+//
+//              THE FUNC2 PACKET HEADER
+//
+typedef struct _FUNC2_PACKET {
+
+    FUNC1_PACKET hdr1;
+    FUNC1_PACKET hdr2;
+
+} FUNC2_PACKET;
+
+//
+//              THE STRESS PACKET CONTROL INFORMATION
+//
+typedef struct _STRESS_CONTROL {
+
+    ULONG    DataBufOffset;      // offset into databuf used to generate packet data
+    ULONG    SequenceNumber;     // packet's sequence in order of sending
+    ULONG    MaxSequenceNumber;  // server window sequence number
+    UCHAR    ResponseType;       // how the server should respond.
+    UCHAR    ClientReference;    // the number of the Client sending the packet
+    UCHAR    ServerReference;    // the number of the Server sending the packet
+    BOOLEAN  DataChecking;       //
+    ULONG    CheckSum;           // stress packet header check sum
+
+} STRESS_CONTROL;
+
+//
+//              THE STRESS_PACKET
+//
+typedef struct _STRESS_PACKET {
+
+    FUNC1_PACKET hdr;
+    STRESS_CONTROL sc;
+
+} STRESS_PACKET;
+
+
+//
+//             THE GO PAUSE HEADER INFORMATION
+//
+
+typedef struct _GO_PACKET_INFO {
+
+    ULONG   Signature;          // GO_PACKET_SIGNATURE
+    ULONG   TestSignature;      // Test Signature
+    ULONG   UniqueSignature;    // Unique Signature for this GO PAUSE instance
+    UCHAR   PacketType;         // type of packet; STRESS or FUNC
+    ULONG   CheckSum;           // functional packet header check sum
+
+} GO_PACKET_INFO;
+
+//
+//             THE GO-PAUSE PACKET
+//
+typedef struct _GO_PACKET {
+
+    MEDIA_HEADER     go_media;
+    GO_PACKET_INFO   info;
+
+} GO_PACKET;
+
+
+//
+// IN TOTAL: 4 TYPES OF PACKETS EXIST
+//
+// 1. FUNC1
+// 2. FUNC2
+// 3. STRESS
+// 4. GO-PAUSE
+//
+#include <packoff.h>
+
+
+typedef struct _ENVIRONMENT_VARIABLES {
+
+    ULONG WindowSize;
+    ULONG RandomBufferNumber;
+    UCHAR StressAddress[ADDRESS_LENGTH];
+    UCHAR ResendAddress[ADDRESS_LENGTH];
+    ULONG StressDelayInterval;
+    ULONG UpForAirDelay;
+    ULONG StandardDelay;
+    ULONG MulticastListSize;
+
+} ENVIRONMENT_VARIABLES, * PENVIRONMENT_VARIABLES;
+
+typedef struct _GLOBAL_COUNTERS {
+
+    ULONG Sends;
+    ULONG SendComps;
+    ULONG Receives;
+    ULONG ReceiveComps;
+    ULONG CorruptRecs;
+    ULONG InvalidPacketRecs;
+
+} GLOBAL_COUNTERS, *PGLOBAL_COUNTERS;
+
+typedef struct _INSTANCE_COUNTERS {
+
+    ULONG Sends;
+    ULONG SendPends;
+    ULONG SendComps;
+    ULONG SendFails;
+    ULONG Receives;
+    ULONG ReceiveComps;
+    ULONG CorruptRecs;
+    ULONG XferData;
+    ULONG XferDataPends;
+    ULONG XferDataComps;
+    ULONG XferDataFails;
+
+} INSTANCE_COUNTERS, *PINSTANCE_COUNTERS;
+
+typedef enum _RESPONSE_TYPE {
+
+    FULL_RESPONSE,
+    ACK_EVERY,
+    ACK_10_TIMES,
+    NO_RESPONSE
+
+} RESPONSE_TYPE;
+
+typedef enum _INTERPACKET_DELAY {
+
+    FIXEDDELAY,
+    RANDOMDELAY
+
+} INTERPACKET_DELAY;
+
+typedef enum _PACKET_MAKEUP {
+
+    RAND,
+    SMALL,
+    ZEROS,
+    ONES,
+    KNOWN
+
+} PACKET_MAKEUP;
+
+typedef enum _MEMBER_TYPE {
+
+    TP_CLIENT,
+    TP_SERVER,
+    BOTH
+
+} MEMBER_TYPE;
+
+typedef enum _PACKET_TYPE {
+
+    FIXEDSIZE,
+    RANDOMSIZE,
+    CYCLICAL
+
+} PACKET_TYPE;
+
+typedef enum _TP_EVENT_TYPE {
+
+    CompleteOpen,
+    CompleteClose,
+    CompleteSend,
+    CompleteTransferData,
+    CompleteReset,
+    CompleteRequest,
+    IndicateReceive,
+    IndicateReceiveComplete,
+    IndicateStatus,
+    IndicateStatusComplete,
+    Unknown
+
+} TP_EVENT_TYPE;
+
+
+typedef struct _SERVER_RESULTS {
+
+    ULONG             Signature;
+    UCHAR             Address[ADDRESS_LENGTH];
+    ULONG             OpenInstance;
+    BOOLEAN           StatsRcvd;
+    INSTANCE_COUNTERS Instance;
+    INSTANCE_COUNTERS S_Instance;
+    GLOBAL_COUNTERS   S_Global;
+
+} SERVER_RESULTS, *PSERVER_RESULTS;
+
+
+
+typedef struct _STRESS_RESULTS {
+
+    ULONG            Signature;
+    UCHAR            Address[ADDRESS_LENGTH];
+    ULONG            OpenInstance;
+    ULONG            NumServers;
+    ULONG            PacketsPerSecond;
+    GLOBAL_COUNTERS  Global;
+    SERVER_RESULTS   Servers[MAX_SERVERS];
+
+} STRESS_RESULTS, *PSTRESS_RESULTS;
+
+typedef struct _TP_TRANSMIT_POOL {
+
+    NDIS_SPIN_LOCK  SpinLock;
+    BOOLEAN         SpinLockAllocated;
+    ULONG           Allocated;
+    ULONG           Deallocated;
+    PNDIS_PACKET    Head;
+    PNDIS_PACKET    Tail;
+
+} TP_TRANSMIT_POOL, *PTP_TRANSMIT_POOL;
+
+struct _OPEN_BLOCK;
+
+typedef struct _TP_REQUEST_HANDLE {
+
+    ULONG                Signature;
+    struct _OPEN_BLOCK   *Open;
+    BOOLEAN              RequestPended;
+    PIRP                 Irp;
+
+    union {
+
+        struct _OPEN_REQ {
+
+            NTSTATUS  RequestStatus;
+            KEVENT    OpenEvent;
+
+        } OPEN_REQ;
+
+        struct _RESET_REQ {
+
+            NTSTATUS RequestStatus;
+            BOOLEAN  PostResetStressCleanup;
+
+        } RESET_REQ;
+
+        struct _INFO_REQ {
+
+            ULONG             IoControlCode;
+            NDIS_REQUEST_TYPE NdisRequestType;
+            NDIS_OID          OID;
+            PVOID             InformationBuffer;
+            UINT              InformationBufferLength;
+
+        } INFO_REQ;
+
+        struct _SEND_REQ {
+
+            PNDIS_PACKET Packet;
+            ULONG        PacketSize;
+            BOOLEAN      SendPacket;
+
+        } SEND_REQ;
+
+        struct _TRANS_REQ {
+
+            PNDIS_PACKET       Packet;
+            ULONG              DataOffset;
+            UINT               DataSize;
+            PINSTANCE_COUNTERS InstanceCounters;
+
+        } TRANS_REQ;
+
+        struct _STRESS_REQ {
+
+            struct _TP_REQUEST_HANDLE *NextReqHndl;
+            PNDIS_REQUEST             Request;
+
+        } STRESS_REQ;
+
+    } u;
+
+} TP_REQUEST_HANDLE, *PTP_REQUEST_HANDLE;
+
+
+typedef struct _PROTOCOL_RESERVED {
+
+    union {
+        NDIS_HANDLE       PacketHandle;
+        PTP_TRANSMIT_POOL TransmitPool;
+        PNDIS_PACKET      NextPacket;
+    } Pool;
+    PTP_REQUEST_HANDLE    RequestHandle;
+    PINSTANCE_COUNTERS    InstanceCounters;
+    ULONG                 CheckSum;
+
+} PROTOCOL_RESERVED, * PPROTOCOL_RESERVED;
+
+
+typedef struct _SERVER_INFO {
+
+    UCHAR                ServerInstance;
+    UCHAR                ClientReference;
+    UCHAR                ServerReference;
+    UCHAR                Address[ADDRESS_LENGTH];  // will be the same for a given ServerReference
+    BOOLEAN              ServerActive;
+    UCHAR                WindowReset;
+    ULONG                SequenceNumber;
+    ULONG                MaxSequenceNumber;
+    ULONG                LastSequenceNumber;
+    ULONG                PacketDelay;
+    ULONG                DelayLength;
+    PINSTANCE_COUNTERS   Counters;
+
+} SERVER_INFO, * PSERVER_INFO;
+
+typedef struct _CLIENT_STORAGE {
+
+    UCHAR              NumServers;
+    UCHAR              NextServer;
+    UCHAR              ActiveServers;
+    BOOLEAN            PoolInitialized;
+    NDIS_HANDLE        PacketHandle;
+    PTP_TRANSMIT_POOL  TransmitPool;
+    ULONG              PacketSize;
+    ULONG              BufferSize;
+    ULONG              SizeIncrease;
+    SERVER_INFO        Servers[MAX_SERVERS];
+
+} CLIENT_STORAGE, * PCLIENT_STORAGE;
+
+typedef struct _CLIENT_INFO {
+
+    UCHAR               ClientInstance;
+    UCHAR               ClientReference;
+    UCHAR               Address[ADDRESS_LENGTH];
+    BOOLEAN             DataChecking;
+    BOOLEAN             TestEnding;
+    RESPONSE_TYPE       ServerResponseType;
+    ULONG               LastSequenceNumber;
+    PINSTANCE_COUNTERS  Counters;
+
+} CLIENT_INFO, * PCLIENT_INFO;
+
+
+
+typedef struct _SERVER_STORAGE {
+
+    UCHAR              NumClients;
+    UCHAR              ActiveClients;
+    BOOLEAN            PoolInitialized;
+    UCHAR              PadByte;
+    NDIS_HANDLE        PacketHandle;
+    PTP_TRANSMIT_POOL  TransmitPool;
+    ULONG              PadLong;
+    CLIENT_INFO        Clients[MAX_CLIENTS];
+
+} SERVER_STORAGE, * PSERVER_STORAGE;
+
+//
+//
+//
+
+typedef struct _STRESS_ARGUMENTS {
+
+    MEMBER_TYPE        MemberType;
+    PACKET_TYPE        PacketType;
+    INT                PacketSize;
+    PACKET_MAKEUP      PacketMakeUp;
+    UCHAR              ResponseType;
+    INTERPACKET_DELAY  DelayType;
+    ULONG              DelayLength;
+    ULONG              Iterations;
+    ULONG              TotalIterations;
+    ULONG              TotalPackets;
+    BOOLEAN            AllPacketsSent;
+    BOOLEAN            WindowEnabled;
+    BOOLEAN            DataChecking;
+    BOOLEAN            PacketsFromPool;
+    BOOLEAN            BeginReceives;
+    BOOLEAN            ServerContinue;
+
+} STRESS_ARGUMENTS, * PSTRESS_ARGUMENTS;
+
+
+
+
+typedef struct _PENDING {
+
+    ULONG           PendingPackets;
+    ULONG           PendingRequests;
+    ULONG           PacketPendNumber;
+    ULONG           PacketCompleteNumber;
+    BOOLEAN         PendingSpinLockAllocated;
+    NDIS_SPIN_LOCK  SpinLock;
+    PNDIS_PACKET    Packets[NUM_PACKET_PENDS];
+
+} PENDING, * PPENDING;
+
+
+
+
+typedef struct _STRESS_BLOCK {
+
+    volatile BOOLEAN   Stressing;
+    BOOLEAN            StressStarted;
+    BOOLEAN            StopStressing;
+    BOOLEAN            StressFinal;
+    BOOLEAN            StressEnded;
+    BOOLEAN            Resetting;
+    BOOLEAN            FirstIteration;
+    PCLIENT_STORAGE    Client;
+    PSERVER_STORAGE    Server;
+    LARGE_INTEGER      StartTime;
+    LARGE_INTEGER      EndTime;
+    ULONG              PacketsPerSecond;
+    PSTRESS_ARGUMENTS  Arguments;
+    PPENDING           Pend;
+    PUCHAR             DataBuffer[MAX_NUMBER_BUFFERS];
+    PMDL               DataBufferMdl[MAX_NUMBER_BUFFERS];
+    BOOLEAN            PoolInitialized;
+    NDIS_HANDLE        PacketHandle;
+    PSTRESS_RESULTS    Results;
+    PIRP               StressIrp;
+    ULONG              Counter;
+    ULONG              Reg2Counter;
+    KTIMER             TpStressTimer;
+    KTIMER             TpStressReg2Timer;
+    KDPC               TpStressDpc;
+    KDPC               TpStressReg2Dpc;
+    KDPC               TpStressStatsDpc;
+    KDPC               TpStressEndReqDpc;
+    KDPC               TpStressFinalDpc;
+
+} STRESS_BLOCK, * PSTRESS_BLOCK;
+
+
+typedef struct _SEND_BLOCK {
+
+    volatile BOOLEAN    Sending;
+    BOOLEAN             StopSending;
+    BOOLEAN             ResendPackets;
+    UCHAR               PadByte;
+    UCHAR               DestAddress[ADDRESS_LENGTH];
+    UCHAR               ResendAddress[ADDRESS_LENGTH];
+    ULONG               PacketSize;
+    ULONG               NumberOfPackets;
+    ULONG               PacketsSent;
+    ULONG               PacketsPending;
+    ULONG               SendEndDpcCount;
+    NDIS_HANDLE         PacketHandle;
+    PINSTANCE_COUNTERS  Counters;
+    PIRP                SendIrp;
+    KTIMER              SendTimer;
+    KDPC                SendDpc;
+    KDPC                SendEndDpc;
+
+} SEND_BLOCK, * PSEND_BLOCK;
+
+
+
+typedef struct _RECEIVE_BLOCK {
+
+    volatile BOOLEAN    Receiving;
+    BOOLEAN             StopReceiving;
+    ULONG               PacketsPending;
+    ULONG               ReceiveEndDpcCount;
+    NDIS_HANDLE         PacketHandle;
+    PINSTANCE_COUNTERS  Counters;
+    PIRP                ReceiveIrp;
+    KTIMER              ReceiveTimer;
+    KDPC                ReceiveDpc;
+    KDPC                ReceiveEndDpc;
+
+} RECEIVE_BLOCK, * PRECEIVE_BLOCK;
+
+typedef struct _PAUSE_BLOCK {
+
+    volatile BOOLEAN GoReceived;
+    BOOLEAN          PoolAllocated;
+    NDIS_HANDLE      PacketHandle;
+    UCHAR            RemoteAddress[ADDRESS_LENGTH];
+    ULONG            TestSignature;
+    ULONG            UniqueSignature;
+    UCHAR            PacketType;
+    ULONG            TimeOut;
+    NDIS_SPIN_LOCK   SpinLock;
+
+} PAUSE_BLOCK, * PPAUSE_BLOCK;
+
+
+typedef struct _EVENTS {
+
+    TP_EVENT_TYPE TpEventType;
+    NDIS_STATUS   Status;
+    BOOLEAN       Overflow;
+    PVOID         EventInfo;
+
+} EVENTS, * PEVENTS;
+
+
+
+
+typedef struct _EVENT_QUEUE {
+
+    NDIS_SPIN_LOCK  SpinLock;
+    ULONG           ReceiveIndicationCount;
+    ULONG           StatusIndicationCount;
+    BOOLEAN         ExpectReceiveComplete;
+    BOOLEAN         ExpectStatusComplete;
+    ULONG           Head;
+    ULONG           Tail;
+    ULONG           PadUlong;
+    EVENTS          Events[MAX_EVENT];
+
+} EVENT_QUEUE, * PEVENT_QUEUE;
+
+
+typedef struct _OPEN_BLOCK {
+
+    NDIS_HANDLE             NdisBindingHandle;
+    NDIS_HANDLE             NdisProtocolHandle;
+    UCHAR                   OpenInstance;
+    BOOLEAN                 Closing;
+    UCHAR                   StationAddress[ADDRESS_LENGTH];
+    PSZ                     AdapterName;
+    NDIS_SPIN_LOCK          SpinLock;
+    volatile UCHAR          ReferenceCount;
+    UINT                    MediumIndex;
+    struct _TP_MEDIA_INFO   *Media;
+    PGLOBAL_COUNTERS        GlobalCounters;
+    PENVIRONMENT_VARIABLES  Environment;
+    PSTRESS_BLOCK           Stress;
+    PSEND_BLOCK             Send;
+    PRECEIVE_BLOCK          Receive;
+    PEVENT_QUEUE            EventQueue;
+    PPAUSE_BLOCK            Pause;
+    PTP_REQUEST_HANDLE      OpenReqHndl;
+    PTP_REQUEST_HANDLE      CloseReqHndl;
+    PTP_REQUEST_HANDLE      ResetReqHndl;
+    PTP_REQUEST_HANDLE      RequestReqHndl;
+    PTP_REQUEST_HANDLE      StressReqHndl;
+    BOOLEAN                 IrpCancelled;
+    PIRP                    Irp;
+    ULONG                   Signature;
+
+} OPEN_BLOCK, * POPEN_BLOCK;
+
+
+
+
+
+//
+// Functions
+//
+VOID    DumpNdisPacket( PNTKD_OUTPUT_ROUTINE, PNTKD_READ_VIRTUAL_MEMORY, PNDIS_PACKET, DWORD );
+VOID    DumpNdisBuffer( PNTKD_OUTPUT_ROUTINE, PNTKD_READ_VIRTUAL_MEMORY, PNDIS_BUFFER, DWORD );
+VOID    DumpOpenBuffer( PNTKD_OUTPUT_ROUTINE, PNTKD_READ_VIRTUAL_MEMORY, PNDIS_BUFFER, DWORD );
+VOID    ndispacket    ( DWORD, PNTKD_EXTENSION_APIS, LPSTR );
+VOID    ndisbuffer    ( DWORD, PNTKD_EXTENSION_APIS, LPSTR );
+VOID    openblock     ( DWORD, PNTKD_EXTENSION_APIS, LPSTR );
+VOID    help          ( DWORD, PNTKD_EXTENSION_APIS, LPSTR );