Basic NDIS 3.0 support

svn path=/trunk/; revision=1318

reactos/drivers/net/ndis/include/buffer.h

@@ -25,6 +25,32 @@ typedef struct _NDIS_BUFFER_POOL
     NETWORK_HEADER Buffers[0];
 } NDIS_BUFFER_POOL, *PNDIS_BUFFER_POOL;
 
+
+UINT CopyBufferToBufferChain(
+    PNDIS_BUFFER DstBuffer,
+    UINT DstOffset,
+    PUCHAR SrcData,
+    UINT Length);
+
+UINT CopyBufferChainToBuffer(
+    PUCHAR DstData,
+    PNDIS_BUFFER SrcBuffer,
+    UINT SrcOffset,
+    UINT Length);
+
+UINT CopyPacketToBuffer(
+    PUCHAR DstData,
+    PNDIS_PACKET SrcPacket,
+    UINT SrcOffset,
+    UINT Length);
+
+UINT CopyPacketToBufferChain(
+    PNDIS_BUFFER DstBuffer,
+    UINT DstOffset,
+    PNDIS_PACKET SrcPacket,
+    UINT SrcOffset,
+    UINT Length);
+
 #endif /* __BUFFER_H */
 
 /* EOF */

reactos/drivers/net/ndis/include/debug.h

@@ -18,6 +18,7 @@
 #define DEBUG_REFCOUNT 0x00000100
 #define DEBUG_MINIPORT 0x00000200
 #define DEBUG_PROTOCOL 0x00000400
+#define DEBUG_PACKET   0x00000800
 #define DEBUG_ULTRA    0xFFFFFFFF
 
 #ifdef DBG
@@ -74,7 +75,7 @@ extern DWORD DebugTraceLevel;
 #ifdef _MSC_VER
 
 #define UNIMPLEMENTED \
-    NDIS_DbgPrint(MIN_TRACE, ("The function at %s:%d is unimplemented.\n", __FILE__, __LINE__));
+    NDIS_DbgPrint(MIN_TRACE, ("The function at (%s:%d) is unimplemented.\n", __FILE__, __LINE__));
 
 #else /* _MSC_VER */
 
@@ -85,7 +86,7 @@ extern DWORD DebugTraceLevel;
 
 
 #define CHECKPOINT \
-    do { NDIS_DbgPrint(MIN_TRACE, ("%s:%d\n", __FILE__, __LINE__)); } while(0);
+    do { NDIS_DbgPrint(MIN_TRACE, ("(%s:%d)\n", __FILE__, __LINE__)); } while(0);
 
 #endif /* __DEBUG_H */
 

reactos/drivers/net/ndis/include/miniport.h

@@ -11,6 +11,12 @@
 #include <ndissys.h>
 
 
+typedef struct _HARDWARE_ADDRESS {
+    union {
+        UCHAR Medium802_3[ETH_LENGTH_OF_ADDRESS];
+    } Type;
+} HARDWARE_ADDRESS, *PHARDWARE_ADDRESS;
+
 /* Information about a miniport */
 typedef struct _MINIPORT_DRIVER {
     LIST_ENTRY                      ListEntry;          /* Entry on global list */
@@ -19,7 +25,6 @@ typedef struct _MINIPORT_DRIVER {
     NDIS_MINIPORT_CHARACTERISTICS   Chars;              /* Miniport characteristics */
     WORK_QUEUE_ITEM                 WorkItem;           /* Work item */
     PDRIVER_OBJECT                  DriverObject;       /* Driver object of miniport */
-    NDIS_STRING                     RegistryPath;       /* Registry path of miniport */
     LIST_ENTRY                      AdapterListHead;    /* Adapters created by miniport */
 } MINIPORT_DRIVER, *PMINIPORT_DRIVER;
 
@@ -27,40 +32,102 @@ typedef struct _MINIPORT_DRIVER {
 
 /* Information about a logical adapter */
 typedef struct _LOGICAL_ADAPTER {
+    NDIS_MINIPORT_BLOCK;                                /* NDIS defined fields */
+
+    KDPC                        MiniportDpc;            /* DPC routine for adapter */
+    BOOLEAN                     MiniportBusy;           /* A MiniportXxx routine is executing */
+    NDIS_HANDLE                 MiniportAdapterBinding; /* Binding handle for current caller */
+    ULONG                       WorkQueueLevel;         /* Number of used work item buffers */
+    NDIS_MINIPORT_WORK_ITEM     WorkQueue[NDIS_MINIPORT_WORK_QUEUE_SIZE];
+    PNDIS_MINIPORT_WORK_ITEM    WorkQueueHead;          /* Head of work queue */
+    PNDIS_MINIPORT_WORK_ITEM    WorkQueueTail;          /* Tail of work queue */
+
     LIST_ENTRY                  ListEntry;              /* Entry on global list */
     LIST_ENTRY                  MiniportListEntry;      /* Entry on miniport driver list */
-    KSPIN_LOCK                  Lock;                   /* Protecting spin lock */
+    LIST_ENTRY                  ProtocolListHead;       /* List of bound protocols */
     ULONG                       RefCount;               /* Reference count */
     PMINIPORT_DRIVER            Miniport;               /* Miniport owning this adapter */
     UNICODE_STRING              DeviceName;             /* Device name of this adapter */
-    PDEVICE_OBJECT              DeviceObject;           /* Device object of adapter */
-    PVOID                       MiniportAdapterContext; /* Adapter context for miniport */
     ULONG                       Attributes;             /* Attributes of adapter */
-    NDIS_INTERFACE_TYPE         AdapterType;            /* Type of adapter interface */
     /* TRUE if the miniport has called NdisSetAttributes(Ex) for this adapter */
     BOOLEAN                     AttributesSet;
-    PNDIS_MINIPORT_INTERRUPT    InterruptObject;        /* Interrupt object for adapter */
     PVOID                       QueryBuffer;            /* Buffer to use for queries */
     ULONG                       QueryBufferLength;      /* Length of QueryBuffer */
+    ULONG                       MediumHeaderSize;       /* Size of medium header */
+    HARDWARE_ADDRESS            Address;                /* Hardware address of adapter */
+    ULONG                       AddressLength;          /* Length of hardware address */
+    PUCHAR                      LookaheadBuffer;        /* Pointer to lookahead buffer */
+    ULONG                       LookaheadLength;        /* Length of lookahead buffer */
+    ULONG                       CurLookaheadLength;     /* Current (selected) length of lookahead buffer */
+    ULONG                       MaxLookaheadLength;     /* Maximum length of lookahead buffer */
+
+    PNDIS_PACKET                PacketQueueHead;        /* Head of packet queue */
+    PNDIS_PACKET                PacketQueueTail;        /* Head of packet queue */
+
+    PNDIS_PACKET                LoopPacket;             /* Current packet beeing looped */
 } LOGICAL_ADAPTER, *PLOGICAL_ADAPTER;
 
 #define GET_LOGICAL_ADAPTER(Handle)((PLOGICAL_ADAPTER)Handle)
 
-
 extern LIST_ENTRY MiniportListHead;
 extern KSPIN_LOCK MiniportListLock;
 extern LIST_ENTRY AdapterListHead;
 extern KSPIN_LOCK AdapterListLock;
 
-PLOGICAL_ADAPTER MiniLocateDevice(
+
+#ifdef DBG
+VOID
+MiniDisplayPacket(
+    PNDIS_PACKET Packet);
+#endif /* DBG */
+
+VOID
+MiniIndicateData(
+    PLOGICAL_ADAPTER    Adapter,
+    NDIS_HANDLE         MacReceiveContext,
+    PVOID               HeaderBuffer,
+    UINT                HeaderBufferSize,
+    PVOID               LookaheadBuffer,
+    UINT                LookaheadBufferSize,
+    UINT                PacketSize);
+
+BOOLEAN
+MiniAdapterHasAddress(
+    PLOGICAL_ADAPTER Adapter,
+    PNDIS_PACKET Packet);
+
+PLOGICAL_ADAPTER
+MiniLocateDevice(
     PNDIS_STRING AdapterName);
 
-NDIS_STATUS MiniQueryInformation(
+NDIS_STATUS
+MiniQueryInformation(
     PLOGICAL_ADAPTER    Adapter,
     NDIS_OID            Oid,
     ULONG               Size,
     PULONG              BytesWritten);
 
+NDIS_STATUS
+FASTCALL
+MiniQueueWorkItem(
+    PLOGICAL_ADAPTER    Adapter,
+    NDIS_WORK_ITEM_TYPE WorkItemType,
+    PVOID               WorkItemContext,
+    NDIS_HANDLE         Initiator);
+
+NDIS_STATUS
+FASTCALL
+MiniDequeueWorkItem(
+    PLOGICAL_ADAPTER    Adapter,
+    NDIS_WORK_ITEM_TYPE *WorkItemType,
+    PVOID               *WorkItemContext,
+    NDIS_HANDLE         *Initiator);
+
+NDIS_STATUS
+MiniDoRequest(
+    PLOGICAL_ADAPTER Adapter,
+    PNDIS_REQUEST NdisRequest);
+
 #endif /* __MINIPORT_H */
 
 /* EOF */

reactos/drivers/net/ndis/include/ndissys.h

@@ -107,6 +107,13 @@
         PoolFreeBuffer(Object);                           \
 }
 
+
+#define MIN(value1, value2) \
+    ((value1 < value2)? value1 : value2)
+
+#define MAX(value1, value2) \
+    ((value1 > value2)? value1 : value2)
+
 #endif /* __NDISSYS_H */
 
 /* EOF */

reactos/drivers/net/ndis/include/protocol.h

@@ -25,10 +25,14 @@ typedef struct _PROTOCOL_BINDING {
 
 
 typedef struct _ADAPTER_BINDING {
+    NDIS_OPEN_BLOCK;                            /* NDIS defined fields */
+
     LIST_ENTRY        ListEntry;                /* Entry on global list */
     LIST_ENTRY        ProtocolListEntry;        /* Entry on protocol binding adapter list */
+    LIST_ENTRY        AdapterListEntry;         /* Entry on logical adapter list */
     KSPIN_LOCK        Lock;                     /* Protecting spin lock */
     ULONG             RefCount;                 /* Reference count */
+    PPROTOCOL_BINDING ProtocolBinding;          /* Protocol that opened adapter */
     PLOGICAL_ADAPTER  Adapter;                  /* Adapter opened by protocol */
 } ADAPTER_BINDING, *PADAPTER_BINDING;
 
@@ -38,6 +42,12 @@ typedef struct _ADAPTER_BINDING {
 extern LIST_ENTRY ProtocolListHead;
 extern KSPIN_LOCK ProtocolListLock;
 
+
+NDIS_STATUS
+ProIndicatePacket(
+    PLOGICAL_ADAPTER Adapter,
+    PNDIS_PACKET Packet);
+
 #endif /* __PROTOCOL_H */
 
 /* EOF */

reactos/drivers/net/ndis/ndis/buffer.c

@@ -10,6 +10,284 @@
 #include <buffer.h>
 
 
+
+__inline ULONG SkipToOffset(
+    PNDIS_BUFFER Buffer,
+    UINT Offset,
+    PUCHAR *Data,
+    PUINT Size)
+/*
+ * FUNCTION: Skips Offset bytes into a buffer chain
+ * ARGUMENTS:
+ *     Buffer = Pointer to NDIS buffer
+ *     Offset = Number of bytes to skip
+ *     Data   = Address of a pointer that on return will contain the
+ *              address of the offset in the buffer
+ *     Size   = Address of a pointer that on return will contain the
+ *              size of the destination buffer
+ * RETURNS:
+ *     Offset into buffer, -1 if buffer chain was smaller than Offset bytes
+ * NOTES:
+ *     Buffer may be NULL
+ */
+{
+    for (;;) {
+
+        if (!Buffer)
+            return -1;
+
+        NdisQueryBuffer(Buffer, (PVOID)Data, Size);
+
+        if (Offset < *Size) {
+            ((ULONG_PTR)*Data) += Offset;
+            *Size              -= Offset;
+            break;
+        }
+
+        Offset -= *Size;
+
+        NdisGetNextBuffer(Buffer, &Buffer);
+    }
+
+    return Offset;
+}
+
+
+UINT CopyBufferToBufferChain(
+    PNDIS_BUFFER DstBuffer,
+    UINT DstOffset,
+    PUCHAR SrcData,
+    UINT Length)
+/*
+ * FUNCTION: Copies data from a buffer to an NDIS buffer chain
+ * ARGUMENTS:
+ *     DstBuffer = Pointer to destination NDIS buffer 
+ *     DstOffset = Destination start offset
+ *     SrcData   = Pointer to source buffer
+ *     Length    = Number of bytes to copy
+ * RETURNS:
+ *     Number of bytes copied to destination buffer
+ * NOTES:
+ *     The number of bytes copied may be limited by the destination
+ *     buffer size
+ */
+{
+    UINT BytesCopied, BytesToCopy, DstSize;
+    PUCHAR DstData;
+
+    NDIS_DbgPrint(MAX_TRACE, ("DstBuffer (0x%X)  DstOffset (0x%X)  SrcData (0x%X)  Length (%d)\n", DstBuffer, DstOffset, SrcData, Length));
+
+    /* Skip DstOffset bytes in the destination buffer chain */
+    if (SkipToOffset(DstBuffer, DstOffset, &DstData, &DstSize) == -1)
+        return 0;
+
+    /* Start copying the data */
+    BytesCopied = 0;
+    for (;;) {
+        BytesToCopy = MIN(DstSize, Length);
+
+        RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, BytesToCopy);
+        BytesCopied        += BytesToCopy;
+        (ULONG_PTR)SrcData += BytesToCopy;
+
+        Length -= BytesToCopy;
+        if (Length == 0)
+            break;
+
+        DstSize -= BytesToCopy;
+        if (DstSize == 0) {
+            /* No more bytes in desination buffer. Proceed to
+               the next buffer in the destination buffer chain */
+            NdisGetNextBuffer(DstBuffer, &DstBuffer);
+            if (!DstBuffer)
+                break;
+
+            NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
+        }
+    }
+
+    return BytesCopied;
+}
+
+
+UINT CopyBufferChainToBuffer(
+    PUCHAR DstData,
+    PNDIS_BUFFER SrcBuffer,
+    UINT SrcOffset,
+    UINT Length)
+/*
+ * FUNCTION: Copies data from an NDIS buffer chain to a buffer
+ * ARGUMENTS:
+ *     DstData   = Pointer to destination buffer
+ *     SrcBuffer = Pointer to source NDIS buffer
+ *     SrcOffset = Source start offset
+ *     Length    = Number of bytes to copy
+ * RETURNS:
+ *     Number of bytes copied to destination buffer
+ * NOTES:
+ *     The number of bytes copied may be limited by the source
+ *     buffer size
+ */
+{
+    UINT BytesCopied, BytesToCopy, SrcSize;
+    PUCHAR SrcData;
+
+    NDIS_DbgPrint(MAX_TRACE, ("DstData 0x%X  SrcBuffer 0x%X  SrcOffset 0x%X  Length %d\n",DstData,SrcBuffer, SrcOffset, Length));
+    
+    /* Skip SrcOffset bytes in the source buffer chain */
+    if (SkipToOffset(SrcBuffer, SrcOffset, &SrcData, &SrcSize) == -1)
+        return 0;
+
+    /* Start copying the data */
+    BytesCopied = 0;
+    for (;;) {
+        BytesToCopy = MIN(SrcSize, Length);
+
+        NDIS_DbgPrint(MAX_TRACE, ("Copying (%d) bytes from 0x%X to 0x%X\n", BytesToCopy, SrcData, DstData));
+
+        RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, BytesToCopy);
+        BytesCopied        += BytesToCopy;
+        (ULONG_PTR)DstData += BytesToCopy;
+
+        Length -= BytesToCopy;
+        if (Length == 0)
+            break;
+
+        SrcSize -= BytesToCopy;
+        if (SrcSize == 0) {
+            /* No more bytes in source buffer. Proceed to
+               the next buffer in the source buffer chain */
+            NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
+            if (!SrcBuffer)
+                break;
+
+            NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
+        }
+    }
+
+    return BytesCopied;
+}
+
+
+UINT CopyPacketToBuffer(
+    PUCHAR DstData,
+    PNDIS_PACKET SrcPacket,
+    UINT SrcOffset,
+    UINT Length)
+/*
+ * FUNCTION: Copies data from an NDIS packet to a buffer
+ * ARGUMENTS:
+ *     DstData   = Pointer to destination buffer
+ *     SrcPacket = Pointer to source NDIS packet
+ *     SrcOffset = Source start offset
+ *     Length    = Number of bytes to copy
+ * RETURNS:
+ *     Number of bytes copied to destination buffer
+ * NOTES:
+ *     The number of bytes copied may be limited by the source
+ *     buffer size
+ */
+{
+    PNDIS_BUFFER FirstBuffer;
+    PVOID Address;
+    UINT FirstLength;
+    UINT TotalLength;
+
+    NDIS_DbgPrint(MAX_TRACE, ("DstData (0x%X)  SrcPacket (0x%X)  SrcOffset (0x%X)  Length (%d)\n", DstData, SrcPacket, SrcOffset, Length));
+
+    NdisGetFirstBufferFromPacket(SrcPacket,
+                                 &FirstBuffer,
+                                 &Address,
+                                 &FirstLength,
+                                 &TotalLength);
+
+    return CopyBufferChainToBuffer(DstData, FirstBuffer, SrcOffset, Length);
+}
+
+
+UINT CopyPacketToBufferChain(
+    PNDIS_BUFFER DstBuffer,
+    UINT DstOffset,
+    PNDIS_PACKET SrcPacket,
+    UINT SrcOffset,
+    UINT Length)
+/*
+ * FUNCTION: Copies data from an NDIS packet to an NDIS buffer chain
+ * ARGUMENTS:
+ *     DstBuffer = Pointer to destination NDIS buffer
+ *     DstOffset = Destination start offset
+ *     SrcPacket = Pointer to source NDIS packet
+ *     SrcOffset = Source start offset
+ *     Length    = Number of bytes to copy
+ * RETURNS:
+ *     Number of bytes copied to destination buffer
+ * NOTES:
+ *     The number of bytes copied may be limited by the source and
+ *     destination buffer sizes
+ */
+{
+    PNDIS_BUFFER SrcBuffer;
+    PUCHAR DstData, SrcData;
+    UINT DstSize, SrcSize;
+    UINT Count, Total;
+
+    NDIS_DbgPrint(MAX_TRACE, ("DstBuffer (0x%X)  DstOffset (0x%X)  SrcPacket (0x%X)  SrcOffset (0x%X)  Length (%d)\n", DstBuffer, DstOffset, SrcPacket, SrcOffset, Length));
+
+    /* Skip DstOffset bytes in the destination buffer chain */
+    NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
+    if (SkipToOffset(DstBuffer, DstOffset, &DstData, &DstSize) == -1)
+        return 0;
+
+    /* Skip SrcOffset bytes in the source packet */
+    NdisGetFirstBufferFromPacket(SrcPacket, &SrcBuffer, (PVOID)&SrcData, &SrcSize, &Total);
+    if (SkipToOffset(SrcBuffer, SrcOffset, &SrcData, &SrcSize) == -1)
+        return 0;
+
+    /* Copy the data */
+    for (Total = 0;;) {
+        /* Find out how many bytes we can copy at one time */
+        if (Length < SrcSize)
+            Count = Length;
+        else
+            Count = SrcSize;
+        if (DstSize < Count)
+            Count = DstSize;
+
+        RtlCopyMemory((PVOID)DstData, (PVOID)SrcData, Count);
+
+        Total  += Count;
+        Length -= Count;
+        if (Length == 0)
+            break;
+
+        DstSize -= Count;
+        if (DstSize == 0) {
+            /* No more bytes in destination buffer. Proceed to
+               the next buffer in the destination buffer chain */
+            NdisGetNextBuffer(DstBuffer, &DstBuffer);
+            if (!DstBuffer)
+                break;
+
+            NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
+        }
+
+        SrcSize -= Count;
+        if (SrcSize == 0) {
+            /* No more bytes in source buffer. Proceed to
+               the next buffer in the source buffer chain */
+            NdisGetNextBuffer(SrcBuffer, &SrcBuffer);
+            if (!SrcBuffer)
+                break;
+
+            NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
+        }
+    }
+
+    return Total;
+}
+
+
+
 VOID
 EXPORT
 NdisAdjustBufferLength(
@@ -276,15 +554,17 @@ EXPORT
 NdisBufferLength(
     IN  PNDIS_BUFFER    Buffer)
 /*
- * FUNCTION:
+ * FUNCTION: Modifies the length of an NDIS buffer
  * ARGUMENTS:
+ *     Buffer = Pointer to NDIS buffer descriptor
+ *     Length = New size of buffer
  * NOTES:
  *    NDIS 5.0
+ * RETURNS:
+ *     Length of NDIS buffer
  */
 {
-    UNIMPLEMENTED
+    return Buffer->ByteCount;
-
-    return 0;
 }
 
 
@@ -329,52 +609,6 @@ NdisCopyBuffer(
 }
 
 
-__inline ULONG SkipToOffset(
-    PNDIS_BUFFER Buffer,
-    UINT Offset,
-    PVOID *Data,
-    PUINT Size)
-/*
- * FUNCTION: Skips Offset bytes into a buffer chain
- * ARGUMENTS:
- *     Buffer = Pointer to NDIS buffer
- *     Offset = Number of bytes to skip
- *     Data   = Address of a pointer that on return will contain the
- *              address of the offset in the buffer
- *     Size   = Address of a pointer that on return will contain the
- *              size of the destination buffer
- * RETURNS:
- *     Offset into buffer, -1 if buffer chain was smaller than Offset bytes
- * NOTES:
- *     Buffer may be NULL
- */
-{
-    ULONG Address = 0;
-
-    for (;;) {
-
-        if (!Buffer)
-            return -1;
-
-        NdisQueryBuffer(Buffer, Data, Size);
-
-        if (Offset < *Size) {
-            Address += Offset;
-            *Size   -= Offset;
-            break;
-        }
-
-        Offset -= *Size;
-
-        NdisGetNextBuffer(Buffer, &Buffer);
-    }
-
-    *Data = (PVOID)Address;
-
-    return Offset;
-}
-
-
 VOID
 EXPORT
 NdisCopyFromPacketToPacket(
@@ -397,19 +631,19 @@ NdisCopyFromPacketToPacket(
 {
     PNDIS_BUFFER SrcBuffer;
     PNDIS_BUFFER DstBuffer;
-    PVOID DstData, SrcData;
+    PUCHAR DstData, SrcData;
     UINT DstSize, SrcSize;
     UINT Count, Total;
 
     *BytesCopied = 0;
 
     /* Skip DestinationOffset bytes in the destination packet */
-    NdisGetFirstBufferFromPacket(Destination, &DstBuffer, &DstData, &DstSize, &Total);
+    NdisGetFirstBufferFromPacket(Destination, &DstBuffer, (PVOID)&DstData, &DstSize, &Total);
     if (SkipToOffset(DstBuffer, DestinationOffset, &DstData, &DstSize) == -1)
         return;
 
     /* Skip SourceOffset bytes in the source packet */
-    NdisGetFirstBufferFromPacket(Source, &SrcBuffer, &SrcData, &SrcSize, &Total);
+    NdisGetFirstBufferFromPacket(Source, &SrcBuffer, (PVOID)&SrcData, &SrcSize, &Total);
     if (SkipToOffset(SrcBuffer, SourceOffset, &SrcData, &SrcSize) == -1)
         return;
 
@@ -438,7 +672,7 @@ NdisCopyFromPacketToPacket(
             if (!DstBuffer)
                 break;
 
-            NdisQueryBuffer(DstBuffer, &DstData, &DstSize);
+            NdisQueryBuffer(DstBuffer, (PVOID)&DstData, &DstSize);
         }
 
         SrcSize -= Count;
@@ -449,7 +683,7 @@ NdisCopyFromPacketToPacket(
             if (!SrcBuffer)
                 break;
 
-            NdisQueryBuffer(SrcBuffer, &SrcData, &SrcSize);
+            NdisQueryBuffer(SrcBuffer, (PVOID)&SrcData, &SrcSize);
         }
     }
 
@@ -616,8 +850,34 @@ NdisGetFirstBufferFromPacket(
     OUT PVOID           *_FirstBufferVA,
     OUT PUINT           _FirstBufferLength,
     OUT PUINT           _TotalBufferLength)
+/*
+ * FUNCTION: Retrieves information about an NDIS packet
+ * ARGUMENTS:
+ *     _Packet            = Pointer to NDIS packet
+ *     _FirstBuffer       = Address of buffer for pointer to first NDIS buffer
+ *     _FirstBufferVA     = Address of buffer for address of first NDIS buffer
+ *     _FirstBufferLength = Address of buffer for length of first buffer
+ *     _TotalBufferLength = Address of buffer for total length of packet
+ */
 {
-    UNIMPLEMENTED
+    PNDIS_BUFFER Buffer;
+
+    Buffer          = _Packet->Private.Head;
+    *_FirstBuffer   = Buffer;
+    *_FirstBufferVA = MmGetMdlVirtualAddress(Buffer);
+
+    if (Buffer != NULL) {
+        *_FirstBufferLength = MmGetMdlByteCount(Buffer);
+        Buffer = Buffer->Next;
+    } else
+        *_FirstBufferLength = 0;
+
+    *_TotalBufferLength = *_FirstBufferLength;
+
+    while (Buffer != NULL) {
+        *_TotalBufferLength += MmGetMdlByteCount(Buffer);
+        Buffer = Buffer->Next;
+    }
 }
 
 
@@ -683,7 +943,8 @@ NdisQueryBufferOffset(
     OUT PUINT           Offset,
     OUT PUINT           Length)
 {
-    UNIMPLEMENTED
+    *((PUINT)Offset) = MmGetMdlByteOffset(Buffer);
+    *((PUINT)Length) = MmGetMdlByteCount(Buffer);
 }
 
 

reactos/drivers/net/ndis/ndis/io.c

@@ -25,10 +25,33 @@ VOID HandleDeferredProcessing(
  *     SystemArgument2 = Unused
  */
 {
+    BOOLEAN WasBusy;
     PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(DeferredContext);
 
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+    WasBusy = Adapter->MiniportBusy;
+    Adapter->MiniportBusy = TRUE;
+    KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
+    NDIS_DbgPrint(MAX_TRACE, ("Before HandleInterruptHandler.\n"));
+
     /* Call the deferred interrupt service handler for this adapter */
-    (*Adapter->Miniport->Chars.HandleInterruptHandler)(Adapter);
+    (*Adapter->Miniport->Chars.HandleInterruptHandler)(
+        Adapter->MiniportAdapterContext);
+
+    NDIS_DbgPrint(MAX_TRACE, ("After HandleInterruptHandler.\n"));
+
+    KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+    if ((!WasBusy) && (Adapter->WorkQueueHead)) {
+        KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
+    } else {
+        Adapter->MiniportBusy = WasBusy;
+    }
+    KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+
+    NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }
 
 
@@ -41,23 +64,27 @@ BOOLEAN ServiceRoutine(
  *     Interrupt      = Pointer to interrupt object
  *     ServiceContext = Pointer to context information (LOGICAL_ADAPTER)
  * RETURNS
- *     TRUE if our device generated the interrupt
+ *     TRUE if a miniport controlled device generated the interrupt
  */
 {
     BOOLEAN InterruptRecognized;
     BOOLEAN QueueMiniportHandleInterrupt;
     PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(ServiceContext);
 
-    /* FIXME: Support shared interrupts */
+    NDIS_DbgPrint(MAX_TRACE, ("Called. Adapter (0x%X)\n", Adapter));
 
     (*Adapter->Miniport->Chars.ISRHandler)(&InterruptRecognized,
-        &QueueMiniportHandleInterrupt, Adapter);
+                                           &QueueMiniportHandleInterrupt,
+                                           Adapter->MiniportAdapterContext);
 
     if (QueueMiniportHandleInterrupt) {
-        KeInsertQueueDpc(&Adapter->InterruptObject->InterruptDpc, NULL, NULL);
+        NDIS_DbgPrint(MAX_TRACE, ("Queueing DPC.\n"));
+        KeInsertQueueDpc(&Adapter->Interrupt->InterruptDpc, NULL, NULL);
     }
 
-    return TRUE;
+    NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
+
+    return InterruptRecognized;
 }
 
 
@@ -230,7 +257,9 @@ NdisMDeregisterIoPortRange(
  *     PortOffset            = Pointer to mapped base port address
  */
 {
-    UNIMPLEMENTED
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    /* Thank you */
 }
 
 
@@ -257,16 +286,6 @@ NdisMMapIoSpace(
 }
 
 
-VOID
-EXPORT
-NdisMQueryInformationComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_STATUS Status)
-{
-    UNIMPLEMENTED
-}
-
-
 ULONG
 EXPORT
 NdisMReadDmaCounter(
@@ -312,39 +331,70 @@ NdisMRegisterInterrupt(
  *     InterruptVector       = Specifies bus-relative vector to register
  *     InterruptLevel        = Specifies bus-relative DIRQL vector for interrupt
  *     RequestIsr            = TRUE if MiniportISR should always be called
- *     SharedInterrupt       = TRUE if other devices may use tha same interrupt
+ *     SharedInterrupt       = TRUE if other devices may use the same interrupt
  *     InterruptMode         = Specifies type of interrupt
  * RETURNS:
  *     Status of operation
  */
 {
-    NTSTATUS NtStatus;
+    NTSTATUS Status;
     ULONG MappedIRQ;
     KIRQL DIrql;
-    KAFFINITY Affinity = 0xFFFFFFFF;
+    KAFFINITY Affinity;
     PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(MiniportAdapterHandle);
 
+    NDIS_DbgPrint(MAX_TRACE, ("Called. InterruptVector (0x%X)  InterruptLevel (0x%X)  "
+        "SharedInterrupt (%d)  InterruptMode (0x%X)\n",
+        InterruptVector, InterruptLevel, SharedInterrupt, InterruptMode));
+
     RtlZeroMemory(Interrupt, sizeof(NDIS_MINIPORT_INTERRUPT));
 
     KeInitializeSpinLock(&Interrupt->DpcCountLock);
 
-    KeInitializeDpc(&Interrupt->InterruptDpc, HandleDeferredProcessing, Adapter);
+    KeInitializeDpc(&Interrupt->InterruptDpc,
+                    HandleDeferredProcessing,
+                    Adapter);
 
     KeInitializeEvent(&Interrupt->DpcsCompletedEvent,
-        NotificationEvent, FALSE);
+                      NotificationEvent,
+                      FALSE);
 
     Interrupt->SharedInterrupt = SharedInterrupt;
 
-    Adapter->InterruptObject = Interrupt;
+    Adapter->Interrupt = Interrupt;
 
-    MappedIRQ = HalGetInterruptVector(Adapter->AdapterType, 0,
+    MappedIRQ = HalGetInterruptVector(Internal, /* Adapter->AdapterType, */
-        InterruptLevel, InterruptVector, &DIrql, &Affinity);
+                                      0,
+                                      InterruptLevel,
+                                      InterruptVector,
+                                      &DIrql,
+                                      &Affinity);
 
-    NtStatus = IoConnectInterrupt(&Interrupt->InterruptObject, ServiceRoutine, Adapter,
+    NDIS_DbgPrint(MAX_TRACE, ("Connecting to interrupt vector (0x%X)  Affinity (0x%X).\n", MappedIRQ, Affinity));
-        &Interrupt->DpcCountLock, MappedIRQ, DIrql, DIrql, InterruptMode,
-        SharedInterrupt, Affinity, FALSE);
 
+    Status = IoConnectInterrupt(&Interrupt->InterruptObject,
+                                ServiceRoutine,
+                                Adapter,
+                                &Interrupt->DpcCountLock,
+                                MappedIRQ,
+                                DIrql,
+                                DIrql,
+                                InterruptMode,
+                                SharedInterrupt,
+                                Affinity,
+                                FALSE);
+
+    NDIS_DbgPrint(MAX_TRACE, ("Leaving. Status (0x%X).\n", Status));
+
+    if (NT_SUCCESS(Status))
         return NDIS_STATUS_SUCCESS;
+
+    if (Status == STATUS_INSUFFICIENT_RESOURCES) {
+        /* FIXME: Log error */
+        return NDIS_STATUS_RESOURCE_CONFLICT;
+    }
+
+    return NDIS_STATUS_FAILURE;
 }
 
 
@@ -367,14 +417,15 @@ NdisMRegisterIoPortRange(
  */
 {
 #if 0
-    NTSTATUS NtStatus;
+    NTSTATUS Status;
     BOOLEAN ConflictDetected;
     PLOGICAL_ADAPTER Adapter  = GET_LOGICAL_ADAPTER(MiniportAdapterHandle);
     PMINIPORT_DRIVER Miniport = Adapter->Miniport;
 
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
     /* Non-PnP hardware. NT5 function */
-    NtStatus = IoReportResourceForDetection(
+    Status = IoReportResourceForDetection(Miniport->DriverObject,
-        Miniport->DriverObject,
                                           NULL,
                                           0,
                                           NULL,
@@ -383,6 +434,8 @@ NdisMRegisterIoPortRange(
                                           &ConflictDetected);
     return NDIS_STATUS_FAILURE;
 #else
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
     /* It's yours! */
     *PortOffset = (PVOID)InitialPort;
 
@@ -391,16 +444,6 @@ NdisMRegisterIoPortRange(
 }
 
 
-VOID
-EXPORT
-NdisMSetInformationComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_STATUS Status)
-{
-    UNIMPLEMENTED
-}
-
-
 VOID
 EXPORT
 NdisMSetupDmaTransfer(
@@ -415,18 +458,6 @@ NdisMSetupDmaTransfer(
 }
 
 
-VOID
-EXPORT
-NdisMTransferDataComplete(
-    IN  NDIS_HANDLE     MiniportAdapterHandle,
-    IN  PNDIS_PACKET    Packet,
-    IN  NDIS_STATUS     Status,
-    IN  UINT            BytesTransferred)
-{
-    UNIMPLEMENTED
-}
-
-
 VOID
 EXPORT
 NdisMUnmapIoSpace(

reactos/drivers/net/ndis/ndis/main.c

@@ -8,10 +8,15 @@
  *   CSH 01/08-2000 Created
  */
 #include <ndissys.h>
+#include <protocol.h>
+#include <miniport.h>
+
 
 #ifdef DBG
+
 /* See debug.h for debug/trace constants */
 DWORD DebugTraceLevel = MIN_TRACE;
+
 #endif /* DBG */
 
 
@@ -45,6 +50,15 @@ DriverEntry(
 {
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
+    InitializeListHead(&ProtocolListHead);
+    KeInitializeSpinLock(&ProtocolListLock);
+
+    InitializeListHead(&MiniportListHead);
+    KeInitializeSpinLock(&MiniportListLock);
+
+    InitializeListHead(&AdapterListHead);
+    KeInitializeSpinLock(&AdapterListLock);
+
 #ifdef _MSC_VER
     DriverObject->DriverUnload = MainUnload;
 #else

reactos/drivers/net/ndis/ndis/protocol.c

@@ -10,25 +10,291 @@
 #include <ndissys.h>
 #include <miniport.h>
 #include <protocol.h>
+#include <buffer.h>
+
 
 LIST_ENTRY ProtocolListHead;
 KSPIN_LOCK ProtocolListLock;
 
 
-VOID ProtocolWorker(
+NDIS_STATUS
-    PVOID Context)
+ProIndicatePacket(
+    PLOGICAL_ADAPTER Adapter,
+    PNDIS_PACKET Packet)
 /*
- * FUNCTION: Worker function for ProtocolXxx functions
+ * FUNCTION: Indicates a packet to bound protocols
  * ARGUMENTS:
- *     Context = Pointer to context information (PROTOCOL_BINDING)
+ *     Adapter = Pointer to logical adapter
+ *     Packet  = Pointer to packet to indicate
+ * RETURNS:
+ *     Status of operation
  */
 {
+    KIRQL OldIrql;
+    UINT Length;
+    UINT Total;
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+#ifdef DBG
+    MiniDisplayPacket(Packet);
+#endif
+
+    NdisQueryPacket(Packet, NULL, NULL, NULL, &Total);
+
+    KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
+
+    Adapter->LoopPacket = Packet;
+
+    Length = CopyPacketToBuffer(
+        Adapter->LookaheadBuffer,
+        Packet,
+        0,
+        Adapter->CurLookaheadLength);
+
+    KeReleaseSpinLock(&Adapter->Lock, OldIrql);
+
+    if (Length > Adapter->MediumHeaderSize) {
+        MiniIndicateData(Adapter,
+                         NULL,
+                         Adapter->LookaheadBuffer,
+                         Adapter->MediumHeaderSize,
+                         &Adapter->LookaheadBuffer[Adapter->MediumHeaderSize],
+                         Length - Adapter->MediumHeaderSize,
+                         Total - Adapter->MediumHeaderSize);
+    } else {
+        MiniIndicateData(Adapter,
+                         NULL,
+                         Adapter->LookaheadBuffer,
+                         Adapter->MediumHeaderSize,
+                         NULL,
+                         0,
+                         0);
+    }
+
+    KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
+
+    Adapter->LoopPacket = NULL;
+
+    KeReleaseSpinLock(&Adapter->Lock, OldIrql);
+
+    return STATUS_SUCCESS;
+}
+
+
+NDIS_STATUS
+ProRequest(
+    IN  NDIS_HANDLE     MacBindingHandle,
+    IN  PNDIS_REQUEST   NdisRequest)
+/*
+ * FUNCTION: Forwards a request to an NDIS miniport
+ * ARGUMENTS:
+ *     MacBindingHandle = Adapter binding handle
+ *     NdisRequest      = Pointer to request to perform
+ * RETURNS:
+ *     Status of operation
+ */
+{
+    KIRQL OldIrql;
+    BOOLEAN Queue;
+    NDIS_STATUS NdisStatus;
+    PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
+    PLOGICAL_ADAPTER Adapter        = AdapterBinding->Adapter;
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
+    Queue = Adapter->MiniportBusy;
+    if (Queue) {
+        MiniQueueWorkItem(Adapter,
+                          NdisWorkItemRequest,
+                          (PVOID)NdisRequest,
+                          (NDIS_HANDLE)AdapterBinding);
+    } else {
+        Adapter->MiniportBusy = TRUE;
+    }
+    KeReleaseSpinLock(&Adapter->Lock, OldIrql);
+
+    if (!Queue) {
+        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+        NdisStatus = MiniDoRequest(Adapter, NdisRequest);
+        KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+        Adapter->MiniportBusy = FALSE;
+        if (Adapter->WorkQueueHead)
+            KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
+        KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+        KeLowerIrql(OldIrql);
+    } else {
+        NdisStatus = NDIS_STATUS_PENDING;
+    }
+    return NdisStatus;
+}
+
+
+NDIS_STATUS
+ProReset(
+    IN  NDIS_HANDLE MacBindingHandle)
+{
+    UNIMPLEMENTED
+
+    return NDIS_STATUS_FAILURE;
+}
+
+
+NDIS_STATUS
+ProSend(
+    IN  NDIS_HANDLE     MacBindingHandle,
+    IN  PNDIS_PACKET    Packet)
+/*
+ * FUNCTION: Forwards a request to send a packet to an NDIS miniport
+ * ARGUMENTS:
+ *     MacBindingHandle = Adapter binding handle
+ *     Packet           = Pointer to NDIS packet descriptor
+ */
+{
+    KIRQL OldIrql;
+    BOOLEAN Queue;
+    NDIS_STATUS NdisStatus;
+    PADAPTER_BINDING AdapterBinding  = GET_ADAPTER_BINDING(MacBindingHandle);
+    PLOGICAL_ADAPTER Adapter         = AdapterBinding->Adapter;
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    /* FIXME: Should queue packet if miniport returns NDIS_STATUS_RESOURCES */
+
+    Packet->Reserved[0] = (ULONG_PTR)MacBindingHandle;
+
+    KeAcquireSpinLock(&Adapter->Lock, &OldIrql);
+    Queue = Adapter->MiniportBusy;
+
+    /* We may have to loop this packet if miniport cannot */
+    if (Adapter->MacOptions & NDIS_MAC_OPTION_NO_LOOPBACK) {
+        if (MiniAdapterHasAddress(Adapter, Packet)) {
+            /* Do software loopback because miniport does not support it */
+
+            NDIS_DbgPrint(MIN_TRACE, ("Looping packet.\n"));
+
+            if (Queue) {
+
+                /* FIXME: Packets should properbly be queued directly on the adapter instead */
+
+                MiniQueueWorkItem(Adapter,
+                                  NdisWorkItemSendLoopback,
+                                  (PVOID)Packet,
+                                  (NDIS_HANDLE)AdapterBinding);
+            } else {
+                Adapter->MiniportBusy = TRUE;
+            }
+            KeReleaseSpinLock(&Adapter->Lock, OldIrql);
+
+            if (!Queue) {
+                KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+                NdisStatus = ProIndicatePacket(Adapter, Packet);
+                KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+                Adapter->MiniportBusy = FALSE;
+                if (Adapter->WorkQueueHead)
+                    KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
+                KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+                KeLowerIrql(OldIrql);
+                return NdisStatus;
+            } else {
+                return NDIS_STATUS_PENDING;
+            }
+        }
+    }
+
+    if (Queue) {
+
+        /* FIXME: Packets should properbly be queued directly on the adapter instead */
+
+        MiniQueueWorkItem(Adapter,
+                          NdisWorkItemSend,
+                          (PVOID)Packet,
+                          (NDIS_HANDLE)AdapterBinding);
+    } else {
+        Adapter->MiniportBusy = TRUE;
+    }
+    KeReleaseSpinLock(&Adapter->Lock, OldIrql);
+
+    if (!Queue) {
+        KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+        NdisStatus = (*Adapter->Miniport->Chars.u1.SendHandler)(
+            Adapter->MiniportAdapterContext,
+            Packet,
+            0);
+        KeAcquireSpinLockAtDpcLevel(&Adapter->Lock);
+        Adapter->MiniportBusy = FALSE;
+        if (Adapter->WorkQueueHead)
+            KeInsertQueueDpc(&Adapter->MiniportDpc, NULL, NULL);
+        KeReleaseSpinLockFromDpcLevel(&Adapter->Lock);
+        KeLowerIrql(OldIrql);
+    } else {
+        NdisStatus = NDIS_STATUS_PENDING;
+    }
+    return NdisStatus;
 }
 
 
+VOID
+ProSendPackets(
+    IN  NDIS_HANDLE     NdisBindingHandle,
+    IN  PPNDIS_PACKET   PacketArray,
+    IN  UINT            NumberOfPackets)
+{
+    UNIMPLEMENTED
+}
+
+
+NDIS_STATUS
+ProTransferData(
+    IN  NDIS_HANDLE         MacBindingHandle,
+    IN  NDIS_HANDLE         MacReceiveContext,
+    IN  UINT                ByteOffset,
+    IN  UINT                BytesToTransfer,
+    IN  OUT	PNDIS_PACKET    Packet,
+    OUT PUINT               BytesTransferred)
+/*
+ * FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
+ * ARGUMENTS:
+ *     MacBindingHandle  = Adapter binding handle
+ *     MacReceiveContext = MAC receive context
+ *     ByteOffset        = Offset in packet to place data
+ *     BytesToTransfer   = Number of bytes to copy into packet
+ *     Packet            = Pointer to NDIS packet descriptor
+ *     BytesTransferred  = Address of buffer to place number of bytes copied
+ */
+{
+    PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(MacBindingHandle);
+    PLOGICAL_ADAPTER Adapter        = AdapterBinding->Adapter;
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    /* FIXME: Interrupts must be disabled for adapter */
+
+    if (Packet == Adapter->LoopPacket) {
+        /* NDIS is responsible for looping this packet */
+        NdisCopyFromPacketToPacket(Packet,
+                                   ByteOffset,
+                                   BytesToTransfer,
+                                   Adapter->LoopPacket,
+                                   0,
+                                   BytesTransferred);
+        return NDIS_STATUS_SUCCESS;
+    }
+
+    return (*Adapter->Miniport->Chars.u2.TransferDataHandler)(
+        Packet,
+        BytesTransferred,
+        Adapter->MiniportAdapterContext,
+        MacReceiveContext,
+        ByteOffset,
+        BytesToTransfer);
+}
+
+
+
 VOID
 EXPORT
-STDCALL
 NdisCloseAdapter(
     OUT PNDIS_STATUS    Status,
     IN  NDIS_HANDLE     NdisBindingHandle)
@@ -39,8 +305,21 @@ NdisCloseAdapter(
  *     NdisBindingHandle = Handle returned by NdisOpenAdapter
  */
 {
+    KIRQL OldIrql;
     PADAPTER_BINDING AdapterBinding = GET_ADAPTER_BINDING(NdisBindingHandle);
 
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    /* Remove from protocol's bound adapters list */
+    KeAcquireSpinLock(&AdapterBinding->ProtocolBinding->Lock, &OldIrql);
+    RemoveEntryList(&AdapterBinding->ProtocolListEntry);
+    KeReleaseSpinLock(&AdapterBinding->ProtocolBinding->Lock, OldIrql);
+
+    /* Remove protocol from adapter's bound protocols list */
+    KeAcquireSpinLock(&AdapterBinding->Adapter->Lock, &OldIrql);
+    RemoveEntryList(&AdapterBinding->AdapterListEntry);
+    KeReleaseSpinLock(&AdapterBinding->Adapter->Lock, OldIrql);
+
     ExFreePool(AdapterBinding);
 
     *Status = NDIS_STATUS_SUCCESS;
@@ -59,7 +338,20 @@ NdisDeregisterProtocol(
  *     NdisProtocolHandle = Handle returned by NdisRegisterProtocol
  */
 {
-    ExFreePool(NdisProtocolHandle);
+    KIRQL OldIrql;
+    PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+    /* FIXME: Make sure no adapter bindings exist */
+
+    /* Remove protocol from global list */
+    KeAcquireSpinLock(&ProtocolListLock, &OldIrql);
+    RemoveEntryList(&Protocol->ListEntry);
+    KeReleaseSpinLock(&ProtocolListLock, OldIrql);
+
+    ExFreePool(Protocol);
+
     *Status = NDIS_STATUS_SUCCESS;
 }
 
@@ -94,60 +386,38 @@ NdisOpenAdapter(
  *     AddressingInformation  = Optional pointer to buffer with NIC specific information
  */
 {
-    PADAPTER_BINDING AdapterBinding;
+    UINT i;
-    PLOGICAL_ADAPTER Adapter;
-    NDIS_STATUS NdisStatus;
-    PNDIS_MEDIUM Medium1;
-    PNDIS_MEDIUM Medium2;
-    ULONG BytesWritten;
     BOOLEAN Found;
-    UINT i, j;
+    PLOGICAL_ADAPTER Adapter;
-    PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(ProtocolBindingContext);
+    PADAPTER_BINDING AdapterBinding;
+    PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
+
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
     Adapter = MiniLocateDevice(AdapterName);
-
     if (!Adapter) {
         NDIS_DbgPrint(MIN_TRACE, ("Adapter not found.\n"));
         *Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
         return;
     }
 
-    /* Query the miniport driver for it's supported medias and search the list
+    /* Find the media type in the list provided by the protocol driver */
-       to find the first medium also supported by the protocol driver */
-
-    NdisStatus = MiniQueryInformation(Adapter, OID_GEN_MEDIA_SUPPORTED, 0, &BytesWritten);
-
-    /* FIXME: Handle this */
-    if (NdisStatus == NDIS_STATUS_PENDING) {
-        NDIS_DbgPrint(MIN_TRACE, ("NDIS_STATUS_PENDING returned!\n"));
-    }
-
-    if (!NT_SUCCESS(NdisStatus))
-        *Status = NdisStatus;
-
-    Medium1 = Adapter->QueryBuffer;
-    Medium2 = MediumArray;
     Found = FALSE;
-    for (i = 0; i < BytesWritten / sizeof(NDIS_MEDIUM); i++) {
+    for (i = 0; i < MediumArraySize; i++) {
-        for (j = 0; j < MediumArraySize; j++) {
+        if (Adapter->MediaType == MediumArray[i]) {
-            if (Medium2[j] == Medium1[i]) {
+            *SelectedMediumIndex = i;
-                *SelectedMediumIndex = j;
             Found = TRUE;
             break;
         }
     }
-        if (Found)
-            break;
-    }
 
     if (!Found) {
-        NDIS_DbgPrint(MIN_TRACE, ("Media is not supported.\n"));
+        NDIS_DbgPrint(MIN_TRACE, ("Medium is not supported.\n"));
         *Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
         return;
     }
 
     AdapterBinding = ExAllocatePool(NonPagedPool, sizeof(ADAPTER_BINDING));
-
     if (!AdapterBinding) {
         NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         *Status = NDIS_STATUS_RESOURCES;
@@ -156,12 +426,32 @@ NdisOpenAdapter(
 
     RtlZeroMemory(AdapterBinding, sizeof(ADAPTER_BINDING));
 
-    /* Put on protocol binding adapter list */
+    AdapterBinding->ProtocolBinding        = Protocol;
+    AdapterBinding->Adapter                = Adapter;
+    AdapterBinding->ProtocolBindingContext = ProtocolBindingContext;
+
+    /* Set fields required by some NDIS macros */
+    AdapterBinding->MacBindingHandle = (NDIS_HANDLE)AdapterBinding;
+    
+    /* Set handlers (some NDIS macros require these) */
+
+    AdapterBinding->RequestHandler      = ProRequest;
+    AdapterBinding->ResetHandler        = ProReset;
+    AdapterBinding->u1.SendHandler      = ProSend;
+    AdapterBinding->SendPacketsHandler  = ProSendPackets;
+    AdapterBinding->TransferDataHandler = ProTransferData;
+
+    /* Put on protocol's bound adapters list */
     ExInterlockedInsertTailList(&Protocol->AdapterListHead,
                                 &AdapterBinding->ProtocolListEntry,
                                 &Protocol->Lock);
 
-    *NdisBindingHandle = AdapterBinding;
+    /* Put protocol on adapter's bound protocols list */
+    ExInterlockedInsertTailList(&Adapter->ProtocolListHead,
+                                &AdapterBinding->AdapterListEntry,
+                                &Adapter->Lock);
+
+    *NdisBindingHandle = (NDIS_HANDLE)AdapterBinding;
 
     *Status = NDIS_STATUS_SUCCESS;
 }
@@ -187,6 +477,8 @@ NdisRegisterProtocol(
     NTSTATUS NtStatus;
     UINT MinSize;
 
+    NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
     switch (ProtocolCharacteristics->MajorNdisVersion) {
     case 0x03:
         MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS_S);
@@ -221,8 +513,7 @@ NdisRegisterProtocol(
     RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
     RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
 
-    NtStatus = RtlUpcaseUnicodeString(
+    NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name,
-        &Protocol->Chars.Name,
                                       &ProtocolCharacteristics->Name,
                                       TRUE);
     if (!NT_SUCCESS(NtStatus)) {
@@ -236,10 +527,13 @@ NdisRegisterProtocol(
 
     Protocol->RefCount = 1;
 
-    ExInitializeWorkItem(&Protocol->WorkItem, ProtocolWorker, Protocol);
-
     InitializeListHead(&Protocol->AdapterListHead);
 
+    /* Put protocol binding on global list */
+    ExInterlockedInsertTailList(&ProtocolListHead,
+                                &Protocol->ListEntry,
+                                &ProtocolListLock);
+
     *NdisProtocolHandle = Protocol;
     *Status             = NDIS_STATUS_SUCCESS;
 }
@@ -251,8 +545,15 @@ NdisRequest(
     OUT PNDIS_STATUS    Status,
     IN  NDIS_HANDLE     NdisBindingHandle,
     IN  PNDIS_REQUEST   NdisRequest)
+/*
+ * FUNCTION: Forwards a request to an NDIS driver
+ * ARGUMENTS:
+ *     Status            = Address of buffer for status information
+ *     NdisBindingHandle = Adapter binding handle
+ *     NdisRequest       = Pointer to request to perform
+ */
 {
-    UNIMPLEMENTED
+    *Status = ProRequest(NdisBindingHandle, NdisRequest);
 }
 
 
@@ -262,7 +563,7 @@ NdisReset(
     OUT PNDIS_STATUS    Status,
     IN  NDIS_HANDLE     NdisBindingHandle)
 {
-    UNIMPLEMENTED
+    *Status = ProReset(NdisBindingHandle);
 }
 
 
@@ -272,8 +573,15 @@ NdisSend(
     OUT PNDIS_STATUS    Status,
     IN  NDIS_HANDLE     NdisBindingHandle,
     IN  PNDIS_PACKET    Packet)
+/*
+ * FUNCTION: Forwards a request to send a packet
+ * ARGUMENTS:
+ *     Status             = Address of buffer for status information
+ *     NdisBindingHandle  = Adapter binding handle
+ *     Packet             = Pointer to NDIS packet descriptor
+ */
 {
-    UNIMPLEMENTED
+    *Status = ProSend(NdisBindingHandle, Packet);
 }
 
 
@@ -284,7 +592,7 @@ NdisSendPackets(
     IN  PPNDIS_PACKET   PacketArray,
     IN  UINT            NumberOfPackets)
 {
-    UNIMPLEMENTED
+    ProSendPackets(NdisBindingHandle, PacketArray, NumberOfPackets);
 }
 
 
@@ -298,8 +606,24 @@ NdisTransferData(
     IN      UINT            BytesToTransfer,
     IN OUT	PNDIS_PACKET    Packet,
     OUT     PUINT           BytesTransferred)
+/*
+ * FUNCTION: Forwards a request to copy received data into a protocol-supplied packet
+ * ARGUMENTS:
+ *     Status            = Address of buffer for status information
+ *     NdisBindingHandle = Adapter binding handle
+ *     MacReceiveContext = MAC receive context
+ *     ByteOffset        = Offset in packet to place data
+ *     BytesToTransfer   = Number of bytes to copy into packet
+ *     Packet            = Pointer to NDIS packet descriptor
+ *     BytesTransferred  = Address of buffer to place number of bytes copied
+ */
 {
-    UNIMPLEMENTED
+    *Status = ProTransferData(NdisBindingHandle,
+                              MacReceiveContext,
+                              ByteOffset,
+                              BytesToTransfer,
+                              Packet,
+                              BytesTransferred);
 }
 
 /* EOF */

reactos/drivers/net/ndis/ndis/stubs.c

@@ -100,27 +100,6 @@ NdisInterlockedRemoveHeadList(
 }
 
 
-VOID
-EXPORT
-NdisMArcIndicateReceive(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  PUCHAR      HeaderBuffer,
-    IN  PUCHAR      DataBuffer,
-    IN  UINT        Length)
-{
-    UNIMPLEMENTED
-}
-
-
-VOID
-EXPORT
-NdisMArcIndicateReceiveComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle)
-{
-    UNIMPLEMENTED
-}
-
-
 VOID
 EXPORT
 NdisMCompleteBufferPhysicalMapping(
@@ -131,54 +110,6 @@ NdisMCompleteBufferPhysicalMapping(
 }
 
 
-VOID
-EXPORT
-NdisMEthIndicateReceive (
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_HANDLE MiniportReceiveContext,
-    IN  PVOID       HeaderBuffer,
-    IN  UINT        HeaderBufferSize,
-    IN  PVOID       LookaheadBuffer,
-    IN  UINT        LookaheadBufferSize,
-    IN  UINT        PacketSize)
-{
-    UNIMPLEMENTED
-}
-
-
-VOID
-EXPORT
-NdisMEthIndicateReceiveComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle)
-{
-    UNIMPLEMENTED
-}
-
-
-VOID
-EXPORT
-NdisMFddiIndicateReceive(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_HANDLE MiniportReceiveContext,
-    IN  PVOID       HeaderBuffer,
-    IN  UINT        HeaderBufferSize,
-    IN  PVOID       LookaheadBuffer,
-    IN  UINT        LookaheadBufferSize,
-    IN  UINT        PacketSize)
-{
-    UNIMPLEMENTED
-}
-
-
-VOID
-EXPORT
-NdisMFddiIndicateReceiveComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle)
-{
-    UNIMPLEMENTED
-}
-
-
 VOID
 EXPORT
 NdisMStartBufferPhysicalMapping(
@@ -193,30 +124,6 @@ NdisMStartBufferPhysicalMapping(
 }
 
 
-VOID
-EXPORT
-NdisMTrIndicateReceive(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_HANDLE MiniportReceiveContext,
-    IN  PVOID       HeaderBuffer,
-    IN  UINT        HeaderBufferSize,
-    IN  PVOID       LookaheadBuffer,
-    IN  UINT        LookaheadBufferSize,
-    IN  UINT        PacketSize)
-{
-    UNIMPLEMENTED
-}
-
-
-VOID
-EXPORT
-NdisMTrIndicateReceiveComplete(
-    IN  NDIS_HANDLE  MiniportAdapterHandle)
-{
-    UNIMPLEMENTED
-}
-
-
 VOID
 EXPORT
 NdisMapFile(

reactos/include/net/ntddndis.h

@@ -0,0 +1,35 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ReactOS NDIS library
+ * FILE:        include/net/ntddndis.h
+ * PURPOSE:     Structures for accessing NDIS devices
+ */
+#ifndef __NTDDNDIS_H
+#define __NIDDNDIS_H
+
+typedef enum _NDIS_DEVICE_POWER_STATE
+{
+    NdisDeviceStateUnspecified = 0,
+    NdisDeviceStateD0,
+    NdisDeviceStateD1,
+    NdisDeviceStateD2,
+    NdisDeviceStateD3,
+    NdisDeviceStateMaximum
+} NDIS_DEVICE_POWER_STATE, *PNDIS_DEVICE_POWER_STATE;
+
+typedef struct _NDIS_PM_WAKE_UP_CAPABILITIES
+{
+    NDIS_DEVICE_POWER_STATE MinMagicPacketWakeUp;
+    NDIS_DEVICE_POWER_STATE MinPatternWakeUp;
+    NDIS_DEVICE_POWER_STATE MinLinkChangeWakeUp;
+} NDIS_PM_WAKE_UP_CAPABILITIES, *PNDIS_PM_WAKE_UP_CAPABILITIES;
+
+typedef struct _NDIS_PNP_CAPABILITIES
+{
+    ULONG                           Flags;
+    NDIS_PM_WAKE_UP_CAPABILITIES    WakeUpCapabilities;
+} NDIS_PNP_CAPABILITIES, *PNDIS_PNP_CAPABILITIES;
+
+#endif /* __NTDDNDIS_H */
+
+/* EOF */