- Add support for manually setting the adapter's network address

svn path=/branches/aicom-network-fixes/; revision=39995

dll/win32/dnsapi/dnsapi/query.c

@@ -64,7 +64,7 @@ DnsQuery_A(LPCSTR Name,
     switch(Type)
     {
         case DNS_TYPE_A:
-            adns_error = adns_init(&astate, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn | (Servers ? adns_if_noserver : 0), 0);
+            adns_error = adns_init(&astate, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn, 0);
 
             if(adns_error != adns_s_ok)
                 return DnsIntTranslateAdnsToDNS_STATUS(adns_error);

drivers/network/afd/afd/connect.c

@@ -77,11 +77,6 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
     AFD_DbgPrint(MID_TRACE,("Called: FCB %x, FO %x\n",
 			    Context, FCB->FileObject));
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->ConnectIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     /* I was wrong about this before as we can have pending writes to a not
      * yet connected socket */
     if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED;
@@ -91,6 +86,11 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
 
     FCB->ConnectIrp.InFlightRequest = NULL;
 
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
     if( NT_SUCCESS(Irp->IoStatus.Status) ) {
 	FCB->PollState |= AFD_EVENT_CONNECT | AFD_EVENT_SEND;
 	AFD_DbgPrint(MID_TRACE,("Going to connected state %d\n", FCB->State));
@@ -114,7 +114,7 @@ static NTSTATUS NTAPI StreamSocketConnectComplete
 	IoCompleteRequest( NextIrp, IO_NETWORK_INCREMENT );
     }
 
-    if( NT_SUCCESS(Status) ) {
+    if( NT_SUCCESS(Status) && FCB->State == SOCKET_STATE_CONNECTED ) {
 	Status = MakeSocketIntoConnection( FCB );
 
 	if( !NT_SUCCESS(Status) ) {

drivers/network/afd/afd/info.c

@@ -13,7 +13,7 @@
 #include "debug.h"
 #include "pseh/pseh.h"
 
-NTSTATUS STDCALL
+NTSTATUS NTAPI
 AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	    PIO_STACK_LOCATION IrpSp ) {
     NTSTATUS Status = STATUS_SUCCESS;
@@ -69,23 +69,19 @@ AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
     return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
 }
 
-NTSTATUS STDCALL
-AfdGetSockOrPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
-                      PIO_STACK_LOCATION IrpSp, BOOLEAN Local ) {
+NTSTATUS NTAPI
+AfdGetSockName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
+                      PIO_STACK_LOCATION IrpSp ) {
     NTSTATUS Status = STATUS_SUCCESS;
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     PAFD_FCB FCB = FileObject->FsContext;
-    PMDL Mdl = NULL, SysMdl = NULL;
-    PTDI_CONNECTION_INFORMATION ConnInfo = NULL;
-    PTRANSPORT_ADDRESS TransAddr = NULL;
-
-    AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
+    PMDL Mdl = NULL;
 
     if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
 
-    if( FCB->AddressFile.Object == NULL) {
-	return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0,
-	                               NULL );
+    if( FCB->AddressFile.Object == NULL && FCB->Connection.Object == NULL ) {
+	 return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0,
+	                                NULL );
     }
 
     Mdl = IoAllocateMdl
@@ -104,65 +100,69 @@ AfdGetSockOrPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	} _SEH_END;
 
 	if( NT_SUCCESS(Status) ) {
-            if( Local ) {
                 Status = TdiQueryInformation
-                    ( FCB->AddressFile.Object,
+                    ( FCB->Connection.Object ? FCB->Connection.Object : FCB->AddressFile.Object,
                       TDI_QUERY_ADDRESS_INFO,
                       Mdl );
-            } else {
-                if( NT_SUCCESS
-                    ( Status = TdiBuildNullConnectionInfo
-                      ( &ConnInfo,
-                        FCB->LocalAddress->Address[0].AddressType ) ) ) {
-                    SysMdl = IoAllocateMdl
-                        ( ConnInfo,
-                          sizeof( TDI_CONNECTION_INFORMATION ) +
-                          TaLengthOfTransportAddress
-                          ( ConnInfo->RemoteAddress ),
-                          FALSE,
-                          FALSE,
-                          NULL );
-                }
-
-                if( SysMdl ) {
-                    _SEH_TRY {
-                        MmProbeAndLockPages( SysMdl, Irp->RequestorMode, IoModifyAccess );
-                    } _SEH_HANDLE {
-	                AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
-	                Status = _SEH_GetExceptionCode();
-                    } _SEH_END;
-                } else Status = STATUS_NO_MEMORY;
-
-                if( NT_SUCCESS(Status) ) {
-                    Status = TdiQueryInformation
-                        ( FCB->Connection.Object,
-                          TDI_QUERY_CONNECTION_INFO,
-                          SysMdl );
-                }
-
-                if( NT_SUCCESS(Status) ) {
-                    TransAddr =
-                        (PTRANSPORT_ADDRESS)MmGetSystemAddressForMdlSafe( Mdl, NormalPagePriority );
-
-                    if( TransAddr )
-                        RtlCopyMemory( TransAddr, ConnInfo->RemoteAddress,
-                                       TaLengthOfTransportAddress
-                                       ( ConnInfo->RemoteAddress ) );
-                    else Status = STATUS_INSUFFICIENT_RESOURCES;
-		}
-
-                if( ConnInfo ) ExFreePool( ConnInfo );
-                if( SysMdl ) IoFreeMdl( SysMdl );
-                if( TransAddr ) MmUnmapLockedPages( TransAddr, Mdl );
-                MmUnlockPages( Mdl );
-                IoFreeMdl( Mdl );
-            }
-	}
-    } else {
-    	Status = STATUS_INSUFFICIENT_RESOURCES;
-    }
-
-    AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
+        }
+    } else
+        Status = STATUS_INSUFFICIENT_RESOURCES;
+
+    return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
+}
+
+NTSTATUS NTAPI
+AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
+                      PIO_STACK_LOCATION IrpSp ) {
+    NTSTATUS Status = STATUS_SUCCESS;
+    PFILE_OBJECT FileObject = IrpSp->FileObject;
+    PAFD_FCB FCB = FileObject->FsContext;
+    PMDL Mdl = NULL;
+    PTDI_CONNECTION_INFORMATION ConnInfo = NULL;
+
+
+    if( !SocketAcquireStateLock( FCB ) ) return LostSocket( Irp );
+
+    if (FCB->RemoteAddress == NULL || FCB->Connection.Object == NULL) {
+        return UnlockAndMaybeComplete( FCB, STATUS_INVALID_PARAMETER, Irp, 0, NULL );
+    }
+
+    if(NT_SUCCESS(Status = TdiBuildNullConnectionInfo
+                      (&ConnInfo,
+                       FCB->RemoteAddress->Address[0].AddressType)))
+    {
+        Mdl = IoAllocateMdl(ConnInfo, 
+                            sizeof(TDI_CONNECTION_INFORMATION) + 
+                                   TaLengthOfTransportAddress(ConnInfo->RemoteAddress),
+                            FALSE,
+                            FALSE,
+                            NULL);
+
+        if (Mdl)
+        {
+            _SEH_TRY {
+               MmProbeAndLockPages(Mdl, Irp->RequestorMode, IoModifyAccess);
+            } _SEH_HANDLE {
+	       AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
+	       Status = _SEH_GetExceptionCode();
+	    } _SEH_END;
+
+            if (NT_SUCCESS(Status))
+            {
+                Status = TdiQueryInformation(FCB->Connection.Object,
+                          TDI_QUERY_CONNECTION_INFO,
+                          Mdl);
+
+                if (NT_SUCCESS(Status))
+                {
+                    RtlCopyMemory(Irp->UserBuffer, ConnInfo->RemoteAddress, TaLengthOfTransportAddress
+                                                                                  (ConnInfo->RemoteAddress));
+                }
+            }
+         }
+
+         ExFreePool(ConnInfo);
+    }
 
     return UnlockAndMaybeComplete( FCB, Status, Irp, 0, NULL );
 }

drivers/network/afd/afd/listen.c

@@ -12,17 +12,15 @@
 #include "tdiconn.h"
 #include "debug.h"
 
-static VOID SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
+static NTSTATUS SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
                            PIRP Irp,
                            PFILE_OBJECT NewFileObject,
 		                   PAFD_TDI_OBJECT_QELT Qelt ) {
     PAFD_FCB FCB = NewFileObject->FsContext;
     NTSTATUS Status;
 
-    if( !SocketAcquireStateLock( FCB ) ) { 
-        LostSocket( Irp );
-        return;
-    }
+    if( !SocketAcquireStateLock( FCB ) )
+        return LostSocket( Irp );
 
     /* Transfer the connection to the new socket, launch the opening read */
     AFD_DbgPrint(MID_TRACE,("Completing a real accept (FCB %x)\n", FCB));
@@ -50,9 +48,11 @@ static VOID SatisfyAccept( PAFD_DEVICE_EXTENSION DeviceExt,
     IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
 
     SocketStateUnlock( FCB );
+
+    return Status;
 }
 
-static VOID SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
+static NTSTATUS SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
     PAFD_RECEIVED_ACCEPT_DATA ListenReceive =
 	(PAFD_RECEIVED_ACCEPT_DATA)Irp->AssociatedIrp.SystemBuffer;
     PTA_IP_ADDRESS IPAddr;
@@ -74,6 +74,7 @@ static VOID SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
 	Irp->IoStatus.Status = STATUS_NO_MEMORY;
 	Irp->IoStatus.Information = 0;
 	IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+        return STATUS_NO_MEMORY;
     }
 
     AFD_DbgPrint(MID_TRACE,("IPAddr->TAAddressCount %d\n",
@@ -92,6 +93,7 @@ static VOID SatisfyPreAccept( PIRP Irp, PAFD_TDI_OBJECT_QELT Qelt ) {
     Irp->IoStatus.Information = ((PCHAR)&IPAddr[1]) - ((PCHAR)ListenReceive);
     Irp->IoStatus.Status = STATUS_SUCCESS;
     IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
+    return STATUS_SUCCESS;
 }
 
 static NTSTATUS NTAPI ListenComplete
@@ -102,15 +104,15 @@ static NTSTATUS NTAPI ListenComplete
     PAFD_FCB FCB = (PAFD_FCB)Context;
     PAFD_TDI_OBJECT_QELT Qelt;
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->ListenIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED;
 
     FCB->ListenIrp.InFlightRequest = NULL;
 
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
     if( FCB->State == SOCKET_STATE_CLOSED ) {
 	SocketStateUnlock( FCB );
 	DestroySocket( FCB );
@@ -159,8 +161,16 @@ static NTSTATUS NTAPI ListenComplete
 				 ListEntry ) );
     }
 
-    if( FCB->ListenIrp.ConnectionCallInfo ) ExFreePool( FCB->ListenIrp.ConnectionCallInfo );
-    if( FCB->ListenIrp.ConnectionReturnInfo ) ExFreePool( FCB->ListenIrp.ConnectionReturnInfo );
+    if( FCB->ListenIrp.ConnectionCallInfo ) {
+        ExFreePool( FCB->ListenIrp.ConnectionCallInfo );
+        FCB->ListenIrp.ConnectionCallInfo = NULL;
+    }
+
+    if( FCB->ListenIrp.ConnectionReturnInfo ) {
+        ExFreePool( FCB->ListenIrp.ConnectionReturnInfo );
+        FCB->ListenIrp.ConnectionReturnInfo = NULL;
+    }
+
     FCB->NeedsNewListen = TRUE;
 
     /* Trigger a select return if appropriate */
@@ -236,6 +246,7 @@ NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 			   PIO_STACK_LOCATION IrpSp ) {
     PFILE_OBJECT FileObject = IrpSp->FileObject;
     PAFD_FCB FCB = FileObject->FsContext;
+    NTSTATUS Status;
 
     AFD_DbgPrint(MID_TRACE,("Called\n"));
 
@@ -245,7 +256,7 @@ NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	PLIST_ENTRY PendingConn = FCB->PendingConnections.Flink;
 
 	/* We have a pending connection ... complete this irp right away */
-	SatisfyPreAccept
+	Status = SatisfyPreAccept
 	    ( Irp,
 	      CONTAINING_RECORD
 	      ( PendingConn, AFD_TDI_OBJECT_QELT, ListEntry ) );
@@ -256,7 +267,7 @@ NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,
         PollReeval( FCB->DeviceExt, FCB->FileObject );
 
 	SocketStateUnlock( FCB );
-	return Irp->IoStatus.Status;
+	return Status;
     } else {
 	AFD_DbgPrint(MID_TRACE,("Holding\n"));
 
@@ -333,7 +344,7 @@ NTSTATUS AfdAccept( PDEVICE_OBJECT DeviceObject, PIRP Irp,
             ASSERT(NewFileObject->FsContext != FCB);
 
 	    /* We have a pending connection ... complete this irp right away */
-	    SatisfyAccept( DeviceExt, Irp, NewFileObject, PendingConnObj );
+	    Status = SatisfyAccept( DeviceExt, Irp, NewFileObject, PendingConnObj );
 
 	    ObDereferenceObject( NewFileObject );
 
@@ -347,7 +358,7 @@ NTSTATUS AfdAccept( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	    }
 
 	    SocketStateUnlock( FCB );
-	    return Irp->IoStatus.Status;
+	    return Status;
 	}
     }
 

drivers/network/afd/afd/lock.c

@@ -25,7 +25,7 @@ PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
 		       NULL );
     if( Irp->MdlAddress ) {
 	_SEH_TRY {
-	    MmProbeAndLockPages( Irp->MdlAddress, KernelMode, IoModifyAccess );
+	    MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
 	} _SEH_HANDLE {
 	    LockFailed = TRUE;
 	} _SEH_END;

drivers/network/afd/afd/main.c

@@ -221,10 +221,6 @@ VOID DestroySocket( PAFD_FCB FCB ) {
 	ExFreePool( FCB->LocalAddress );
     if( FCB->RemoteAddress )
 	ExFreePool( FCB->RemoteAddress );
-    if( FCB->ListenIrp.ConnectionReturnInfo )
-	ExFreePool( FCB->ListenIrp.ConnectionReturnInfo );
-    if( FCB->ListenIrp.ConnectionCallInfo )
-	ExFreePool( FCB->ListenIrp.ConnectionCallInfo );
     if( FCB->TdiDeviceName.Buffer )
 	ExFreePool(FCB->TdiDeviceName.Buffer);
 
@@ -406,10 +402,10 @@ AfdDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
 	    return AfdDisconnect( DeviceObject, Irp, IrpSp );
 
 	case IOCTL_AFD_GET_SOCK_NAME:
-	    return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, TRUE );
+	    return AfdGetSockName( DeviceObject, Irp, IrpSp );
 
         case IOCTL_AFD_GET_PEER_NAME:
-            return AfdGetSockOrPeerName( DeviceObject, Irp, IrpSp, FALSE );
+            return AfdGetPeerName( DeviceObject, Irp, IrpSp );
 
 	case IOCTL_AFD_GET_TDI_HANDLES:
 	    AFD_DbgPrint(MIN_TRACE, ("IOCTL_AFD_GET_TDI_HANDLES\n"));

drivers/network/afd/afd/read.c

@@ -234,14 +234,15 @@ NTSTATUS NTAPI ReceiveComplete
 
     ASSERT_IRQL(APC_LEVEL);
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->ReceiveIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     if( !SocketAcquireStateLock( FCB ) ) return Status;
 
     FCB->ReceiveIrp.InFlightRequest = NULL;
+
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
     FCB->Recv.Content = Irp->IoStatus.Information;
     FCB->Recv.BytesUsed = 0;
 
@@ -424,7 +425,7 @@ SatisfyPacketRecvRequest( PAFD_FCB FCB, PIRP Irp,
 
         *TotalBytesCopied = BytesToCopy;
 
-        if (!RecvReq->TdiFlags & TDI_RECEIVE_PEEK) {
+        if (!(RecvReq->TdiFlags & TDI_RECEIVE_PEEK)) {
             FCB->Recv.BytesUsed = 0;
         }
     }
@@ -455,15 +456,15 @@ PacketSocketRecvComplete(
 
     AFD_DbgPrint(MID_TRACE,("Called on %x\n", FCB));
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->ReceiveIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     if( !SocketAcquireStateLock( FCB ) ) return STATUS_FILE_CLOSED;
 
     FCB->ReceiveIrp.InFlightRequest = NULL;
 
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
     if( FCB->State == SOCKET_STATE_CLOSED ) {
 	SocketStateUnlock( FCB );
 	DestroySocket( FCB );

drivers/network/afd/afd/select.c

@@ -181,7 +181,7 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	Irp->IoStatus.Status = STATUS_NO_MEMORY;
 	Irp->IoStatus.Information = 0;
 	IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
-	return Irp->IoStatus.Status;
+	return STATUS_NO_MEMORY;
     }
 
     if( Exclusive ) {
@@ -263,8 +263,6 @@ AfdSelect( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 
     AFD_DbgPrint(MID_TRACE,("Returning %x\n", Status));
 
-    Irp->IoStatus.Status = Status;
-
     return Status;
 }
 

drivers/network/afd/afd/tdi.c

@@ -74,7 +74,7 @@ static NTSTATUS TdiCall(
         KeWaitForSingleObject(
           Event,
           Executive,
-          UserMode,
+          KernelMode,
           FALSE,
           NULL);
         Status = Iosb->Status;
@@ -420,21 +420,13 @@ NTSTATUS TdiListen
         return STATUS_INVALID_PARAMETER;
   }
 
-  Status = TdiBuildNullConnectionInfo(RequestConnectionInfo,
-				      TDI_ADDRESS_TYPE_IP);
-  if (!NT_SUCCESS(Status))
-    return Status;
-
   *Irp = TdiBuildInternalDeviceControlIrp(TDI_LISTEN,              /* Sub function */
 					  DeviceObject,            /* Device object */
 					  ConnectionObject,        /* File object */
 					  NULL,                    /* Event */
 					  Iosb);                   /* Status */
   if (*Irp == NULL)
-    {
-	ExFreePool(*RequestConnectionInfo);
 	return STATUS_INSUFFICIENT_RESOURCES;
-    }
 
   TdiBuildListen(*Irp,                   /* IRP */
                  DeviceObject,           /* Device object */
@@ -853,7 +845,7 @@ NTSTATUS TdiSend
                         BufferLength,   /* Length of buffer */
                         FALSE,          /* Not secondary */
                         FALSE,          /* Don't charge quota */
-                        *Irp);          /* use IRP */
+                        *Irp);          /* Use IRP */
     if (!Mdl) {
         AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         IoFreeIrp(*Irp);
@@ -862,7 +854,7 @@ NTSTATUS TdiSend
     }
 
     _SEH_TRY {
-        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
+        MmProbeAndLockPages(Mdl, (*Irp)->RequestorMode, IoModifyAccess);
     } _SEH_HANDLE {
         AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
 	IoFreeMdl(Mdl);
@@ -934,7 +926,7 @@ NTSTATUS TdiReceive(
                         BufferLength,   /* Length of buffer */
                         FALSE,          /* Not secondary */
                         FALSE,          /* Don't charge quota */
-                        *Irp);          /* Don't use IRP */
+                        *Irp);          /* Use IRP */
     if (!Mdl) {
         AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         IoFreeIrp(*Irp);
@@ -944,7 +936,7 @@ NTSTATUS TdiReceive(
 
     _SEH_TRY {
         AFD_DbgPrint(MIN_TRACE, ("probe and lock\n"));
-        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
+        MmProbeAndLockPages(Mdl, (*Irp)->RequestorMode, IoModifyAccess);
         AFD_DbgPrint(MIN_TRACE, ("probe and lock done\n"));
     } _SEH_HANDLE {
         AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
@@ -1034,7 +1026,7 @@ NTSTATUS TdiReceiveDatagram(
                         BufferLength,   /* Length of buffer */
                         FALSE,          /* Not secondary */
                         FALSE,          /* Don't charge quota */
-                        *Irp);          /* Don't use IRP */
+                        *Irp);          /* Use IRP */
     if (!Mdl) {
         AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         IoFreeIrp(*Irp);
@@ -1043,7 +1035,7 @@ NTSTATUS TdiReceiveDatagram(
     }
 
     _SEH_TRY {
-        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
+        MmProbeAndLockPages(Mdl, (*Irp)->RequestorMode, IoModifyAccess);
     } _SEH_HANDLE {
         AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
 	IoFreeMdl(Mdl);
@@ -1132,7 +1124,7 @@ NTSTATUS TdiSendDatagram(
                         BufferLength,   /* Length of buffer */
                         FALSE,          /* Not secondary */
                         FALSE,          /* Don't charge quota */
-                        *Irp);          /* Don't use IRP */
+                        *Irp);          /* Use IRP */
 
     if (!Mdl) {
         AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
@@ -1142,7 +1134,7 @@ NTSTATUS TdiSendDatagram(
     }
 
     _SEH_TRY {
-        MmProbeAndLockPages(Mdl, KernelMode, IoModifyAccess);
+        MmProbeAndLockPages(Mdl, (*Irp)->RequestorMode, IoModifyAccess);
     } _SEH_HANDLE {
         AFD_DbgPrint(MIN_TRACE, ("MmProbeAndLockPages() failed.\n"));
 	IoFreeMdl(Mdl);

drivers/network/afd/afd/write.c

@@ -40,16 +40,16 @@ static NTSTATUS NTAPI SendComplete
 
     ASSERT_IRQL(APC_LEVEL);
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->SendIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     if( !SocketAcquireStateLock( FCB ) ) return Status;
 
     FCB->SendIrp.InFlightRequest = NULL;
     /* Request is not in flight any longer */
 
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
     if( FCB->State == SOCKET_STATE_CLOSED ) {
 	SocketStateUnlock( FCB );
 	DestroySocket( FCB );
@@ -176,20 +176,20 @@ static NTSTATUS NTAPI PacketSocketSendComplete
 			    Irp->IoStatus.Status,
 			    Irp->IoStatus.Information));
 
-    if( Irp->Cancel ) {
-	if( FCB ) FCB->SendIrp.InFlightRequest = NULL;
-	return STATUS_CANCELLED;
-    }
-
     /* It's ok if the FCB already died */
     if( !SocketAcquireStateLock( FCB ) ) return STATUS_SUCCESS;
 
-    FCB->PollState |= AFD_EVENT_SEND;
-    PollReeval( FCB->DeviceExt, FCB->FileObject );
-
     FCB->SendIrp.InFlightRequest = NULL;
     /* Request is not in flight any longer */
 
+    if( Irp->Cancel ) {
+        SocketStateUnlock( FCB );
+	return STATUS_CANCELLED;
+    }
+
+    FCB->PollState |= AFD_EVENT_SEND;
+    PollReeval( FCB->DeviceExt, FCB->FileObject );
+
     if( FCB->State == SOCKET_STATE_CLOSED ) {
 	SocketStateUnlock( FCB );
 	DestroySocket( FCB );

drivers/network/afd/include/afd.h

@@ -232,8 +232,12 @@ AfdGetInfo( PDEVICE_OBJECT DeviceObject, PIRP Irp,
 	    PIO_STACK_LOCATION IrpSp );
 
 NTSTATUS STDCALL
-AfdGetSockOrPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
-                      PIO_STACK_LOCATION IrpSp, BOOLEAN Local );
+AfdGetSockName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
+                PIO_STACK_LOCATION IrpSp );
+
+NTSTATUS STDCALL
+AfdGetPeerName( PDEVICE_OBJECT DeviceObject, PIRP Irp,
+                PIO_STACK_LOCATION IrpSp );
 
 /* listen.c */
 NTSTATUS AfdWaitForListen( PDEVICE_OBJECT DeviceObject, PIRP Irp,

drivers/network/dd/ne2000/ne2000/main.c

@@ -238,6 +238,9 @@ static NDIS_STATUS STDCALL MiniportInitialize(
     UINT i;
     NDIS_STATUS Status;
     PNIC_ADAPTER Adapter;
+    NDIS_HANDLE ConfigurationHandle;
+    UINT *RegNetworkAddress = 0;
+    UINT RegNetworkAddressLength = 0;
 
     ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
 
@@ -284,10 +287,7 @@ static NDIS_STATUS STDCALL MiniportInitialize(
     if (Status != NDIS_STATUS_SUCCESS)
     {
         PNDIS_CONFIGURATION_PARAMETER ConfigurationParameter;
-        NDIS_HANDLE ConfigurationHandle;
         UNICODE_STRING Keyword;
-        UINT *RegNetworkAddress = 0;
-        UINT RegNetworkAddressLength = 0;
 
         NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
         if (Status == NDIS_STATUS_SUCCESS)
@@ -311,18 +311,6 @@ static NDIS_STATUS STDCALL MiniportInitialize(
                 Adapter->IoBaseAddress = ConfigurationParameter->ParameterData.IntegerData;
             }
 
-            /* the returned copy of the data is owned by NDIS and will be released on NdisCloseConfiguration */
-            NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
-            if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == DRIVER_LENGTH_OF_ADDRESS)
-            {
-                int i;
-                NDIS_DbgPrint(MID_TRACE,("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
-                        RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
-                        RegNetworkAddress[4], RegNetworkAddress[5]));
-                for(i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
-                    Adapter->StationAddress[i] = RegNetworkAddress[i];
-            }
-
             NdisCloseConfiguration(ConfigurationHandle);
         }
         else
@@ -371,6 +359,30 @@ static NDIS_STATUS STDCALL MiniportInitialize(
         return Status;
     }
 
+    NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
+    if (Status == NDIS_STATUS_SUCCESS)
+    {
+         NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
+         if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == DRIVER_LENGTH_OF_ADDRESS)
+         {
+             int i;
+             NDIS_DbgPrint(MID_TRACE,("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
+                     RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
+                     RegNetworkAddress[4], RegNetworkAddress[5]));
+             for(i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
+                 Adapter->StationAddress[i] = RegNetworkAddress[i];
+         }
+
+         NdisCloseConfiguration(ConfigurationHandle);
+    }
+
+    if (Status != NDIS_STATUS_SUCCESS)
+    {
+        int i;
+        for (i = 0; i < DRIVER_LENGTH_OF_ADDRESS; i++)
+             Adapter->StationAddress[i] = Adapter->PermanentAddress[i];
+    }
+
     NDIS_DbgPrint(MID_TRACE, ("BOARDDATA:\n"));
     for (i = 0; i < 4; i++) {
         NDIS_DbgPrint(MID_TRACE, ("%02X %02X %02X %02X\n",
@@ -662,11 +674,19 @@ static NDIS_STATUS STDCALL MiniportReset(
  *     Status of operation
  */
 {
+    NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
+
     ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
-    return NDIS_STATUS_FAILURE;
+#ifndef NOCARD
+    NdisStatus = NICReset((PNIC_ADAPTER)MiniportAdapterContext);
+#endif
+
+    *AddressingReset = TRUE;
+
+    return NdisStatus;
 }
 
 

drivers/network/dd/pcnet/pcnet.c

@@ -830,6 +830,9 @@ MiniportInitialize(
   PADAPTER Adapter = 0;
   NDIS_STATUS Status = NDIS_STATUS_FAILURE;
   BOOLEAN InterruptRegistered = FALSE;
+  NDIS_HANDLE ConfigurationHandle;
+  UINT *RegNetworkAddress = 0;
+  UINT RegNetworkAddressLength = 0;
 
   ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
 
@@ -924,6 +927,25 @@ MiniportInitialize(
       /* set up the initialization block */
       MiPrepareInitializationBlock(Adapter);
 
+      /* see if someone set a network address manually */
+      NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
+      if (Status == NDIS_STATUS_SUCCESS)
+      {
+         NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
+         if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == 6)
+         {
+             int i;
+             DPRINT("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
+                     RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
+                     RegNetworkAddress[4], RegNetworkAddress[5]);
+
+             for(i = 0; i < 6; i++)
+                 Adapter->InitializationBlockVirt->PADR[i] = RegNetworkAddress[i];
+         }
+
+         NdisCloseConfiguration(ConfigurationHandle);
+      }
+
       DPRINT("Interrupt registered successfully\n");
 
       /* Initialize and start the chip */

drivers/network/dd/pcnet/requests.c

@@ -352,9 +352,9 @@ MiniportQueryInformation(
     {
       if (CopySize > InformationBufferLength)
         {
-          *BytesNeeded  = (CopySize - InformationBufferLength);
+          *BytesNeeded = CopySize;
           *BytesWritten = 0;
-          Status        = NDIS_STATUS_BUFFER_TOO_SHORT;
+          Status        = NDIS_STATUS_INVALID_LENGTH;
         }
       else
         {
@@ -363,6 +363,11 @@ MiniportQueryInformation(
           *BytesNeeded  = CopySize;
          }
     }
+   else
+    {
+       *BytesWritten = 0;
+       *BytesNeeded = 0;
+    }
 
   NdisDprReleaseSpinLock(&Adapter->Lock);
 
@@ -417,7 +422,7 @@ MiniportSetInformation(
         if (InformationBufferLength < sizeof(ULONG))
           {
             *BytesRead   = 0;
-            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
+            *BytesNeeded = sizeof(ULONG);
             Status       = NDIS_STATUS_INVALID_LENGTH;
             break;
           }
@@ -434,7 +439,7 @@ MiniportSetInformation(
             NDIS_PACKET_TYPE_SOURCE_ROUTING)
            )
           {
-            *BytesRead   = 4;
+            *BytesRead   = sizeof(ULONG);
             *BytesNeeded = 0;
             Status       = NDIS_STATUS_NOT_SUPPORTED;
             break;
@@ -453,7 +458,7 @@ MiniportSetInformation(
         if (InformationBufferLength < sizeof(ULONG))
           {
             *BytesRead   = 0;
-            *BytesNeeded = sizeof(ULONG) - InformationBufferLength;
+            *BytesNeeded = sizeof(ULONG);
             Status = NDIS_STATUS_INVALID_LENGTH;
             break;
           }
@@ -461,7 +466,7 @@ MiniportSetInformation(
         NdisMoveMemory(&GenericULONG, InformationBuffer, sizeof(ULONG));
 
         if (GenericULONG > 1500)
-          Status = NDIS_STATUS_INVALID_LENGTH;
+          Status = NDIS_STATUS_INVALID_DATA;
         else
           Adapter->CurrentLookaheadSize = GenericULONG;
 
@@ -474,7 +479,7 @@ MiniportSetInformation(
         if ((InformationBufferLength % 6) != 0)
           {
             *BytesRead   = 0;
-            *BytesNeeded = 0;
+            *BytesNeeded = InformationBufferLength + (InformationBufferLength % 6);
             Status       = NDIS_STATUS_INVALID_LENGTH;
             break;
           }

drivers/network/lan/lan/routines.c

@@ -87,23 +87,22 @@ NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket,
     NDIS_STATUS Status;
     PCHAR NewData;
 
-    NewData = ExAllocatePool( NonPagedPool, Len );
+    NewData = exAllocatePool( NonPagedPool, Len );
     if( !NewData ) return NDIS_STATUS_NOT_ACCEPTED; // XXX
-    TrackWithTag(EXALLOC_TAG, NewData, File, Line);
 
     if( Data )
 	RtlCopyMemory(NewData, Data, Len);
 
     NdisAllocatePacket( &Status, &Packet, GlobalPacketPool );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	ExFreePool( NewData );
+	exFreePool( NewData );
 	return Status;
     }
     TrackWithTag(NDIS_PACKET_TAG, Packet, File, Line);
 
     NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	ExFreePool( NewData );
+	exFreePool( NewData );
 	FreeNdisPacket( Packet );
     }
     TrackWithTag(NDIS_BUFFER_TAG, Buffer, File, Line);
@@ -139,8 +138,7 @@ VOID FreeNdisPacketX
         NdisQueryBuffer(Buffer, &Data, &Length);
         NdisFreeBuffer(Buffer);
 	UntrackFL(File,Line,Buffer);
-        ExFreePool(Data);
-	UntrackFL(File,Line,Data);
+        exFreePool(Data);
     }
 
     /* Finally free the NDIS packet discriptor */

drivers/network/ndis/include/miniport.h

@@ -75,7 +75,6 @@ typedef struct _NDIS_WRAPPER_CONTEXT {
 typedef struct _LOGICAL_ADAPTER
 {
     NDIS_MINIPORT_BLOCK         NdisMiniportBlock;      /* NDIS defined fields */
-    BOOLEAN                     MiniportBusy;           /* A MiniportXxx routine is executing */
     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 */
@@ -84,8 +83,6 @@ typedef struct _LOGICAL_ADAPTER
     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 */
     PMINIPORT_BUGCHECK_CONTEXT  BugcheckContext;        /* Adapter's shutdown handler */
 } LOGICAL_ADAPTER, *PLOGICAL_ADAPTER;
 
@@ -130,12 +127,13 @@ MiniQueryInformation(
     PVOID               Buffer,
     PULONG              BytesWritten);
 
-NDIS_STATUS
+VOID
 FASTCALL
 MiniQueueWorkItem(
     PLOGICAL_ADAPTER    Adapter,
     NDIS_WORK_ITEM_TYPE WorkItemType,
-    PVOID               WorkItemContext);
+    PVOID               WorkItemContext,
+    BOOLEAN             Top);
 
 NDIS_STATUS
 FASTCALL
@@ -159,6 +157,23 @@ NdisFindDevice(
 VOID
 NdisStartDevices();
 
+VOID
+NTAPI
+MiniportWorker(
+    IN PDEVICE_OBJECT DeviceObject,
+    IN PVOID WorkItem);
+
+VOID NTAPI
+MiniSendComplete(
+    IN  NDIS_HANDLE     MiniportAdapterHandle,
+    IN  PNDIS_PACKET    Packet,
+    IN  NDIS_STATUS     Status);
+
+BOOLEAN
+MiniIsBusy(
+    PLOGICAL_ADAPTER Adapter,
+    NDIS_WORK_ITEM_TYPE Type);
+
 #endif /* __MINIPORT_H */
 
 /* EOF */

drivers/network/ndis/ndis.def

@@ -233,7 +233,7 @@ NdisReadMcaPosInformation@16
 NdisReadNetworkAddress@16
 NdisReadPciSlotInformation@20
 NdisReadPcmciaAttributeMemory@16
-;NdisReEnumerateProtocolBindings ?
+NdisReEnumerateProtocolBindings@4
 NdisRegisterAdapter@24
 NdisRegisterAdapterShutdownHandler@12
 NdisRegisterProtocol@16

drivers/network/ndis/ndis/config.c

@@ -139,7 +139,7 @@ NdisCloseConfiguration(
 
     while(!IsListEmpty(&ConfigurationContext->ResourceListHead))
     {
-        Resource = (PMINIPORT_RESOURCE)RemoveTailList(&ConfigurationContext->ResourceListHead);
+        Resource = (PMINIPORT_RESOURCE)ExInterlockedRemoveHeadList(&ConfigurationContext->ResourceListHead, &ConfigurationContext->ResourceLock);
         if(Resource->ResourceType == MINIPORT_RESOURCE_TYPE_MEMORY)
         {
             NDIS_DbgPrint(MAX_TRACE,("freeing 0x%x\n", Resource->Resource));
@@ -699,16 +699,7 @@ NdisReadNetworkAddress(
     PNDIS_CONFIGURATION_PARAMETER ParameterValue = NULL;
     NDIS_STRING Keyword;
     UINT *IntArray = 0;
-    int i;
-
-    /* FIXME - We don't quite support this yet due to buggy code below */
-      {
-        *Status = NDIS_STATUS_FAILURE;
-        return;
-      }
-
-    *NetworkAddress = NULL;
-    *NetworkAddressLength = 6;/* XXX magic constant */
+    UINT i,j = 0;
 
     NdisInitUnicodeString(&Keyword, L"NetworkAddress");
     NdisReadConfiguration(Status, &ParameterValue, ConfigurationHandle, &Keyword, NdisParameterString);
@@ -718,8 +709,18 @@ NdisReadNetworkAddress(
         return;
     }
 
-    /* 6 bytes for ethernet, tokenring, fddi, everything else? */
-    IntArray = ExAllocatePool(PagedPool, 6*sizeof(UINT));
+    while (ParameterValue->ParameterData.StringData.Buffer[j] != '\0') j++;
+
+    *NetworkAddressLength = (UINT)((j/2)+0.5);
+
+    if (j == 0)
+    {
+        NDIS_DbgPrint(MIN_TRACE,("Empty NetworkAddress registry entry.\n"));
+        *Status = NDIS_STATUS_FAILURE;
+        return;
+    }
+
+    IntArray = ExAllocatePool(PagedPool, (*NetworkAddressLength)*sizeof(UINT));
     if(!IntArray)
     {
         NDIS_DbgPrint(MIN_TRACE,("Insufficient resources.\n"));
@@ -742,7 +743,7 @@ NdisReadNetworkAddress(
     ExInterlockedInsertTailList(&ConfigurationContext->ResourceListHead, &MiniportResource->ListEntry, &ConfigurationContext->ResourceLock);
 
     /* convert from string to bytes */
-    for(i=0; i<6; i++)
+    for(i=0; i<(*NetworkAddressLength); i++)
     {
         IntArray[i] = (UnicodeToHexByte((ParameterValue->ParameterData.StringData.Buffer)[2*i]) << 4) +
                 UnicodeToHexByte((ParameterValue->ParameterData.StringData.Buffer)[2*i+1]);

drivers/network/ndis/ndis/io.c

@@ -55,26 +55,27 @@ BOOLEAN NTAPI ServiceRoutine(
  * FUNCTION: Interrupt service routine
  * ARGUMENTS:
  *     Interrupt      = Pointer to interrupt object
- *     ServiceContext = Pointer to context information (LOGICAL_ADAPTER)
+ *     ServiceContext = Pointer to context information (PNDIS_MINIPORT_INTERRUPT)
  * RETURNS
  *     TRUE if a miniport controlled device generated the interrupt
  */
 {
   BOOLEAN InterruptRecognized = FALSE;
   BOOLEAN QueueMiniportHandleInterrupt = FALSE;
-  PLOGICAL_ADAPTER Adapter = ServiceContext;
+  PNDIS_MINIPORT_INTERRUPT NdisInterrupt = ServiceContext;
+  PNDIS_MINIPORT_BLOCK NdisMiniportBlock = NdisInterrupt->Miniport;
 
-  NDIS_DbgPrint(MAX_TRACE, ("Called. Adapter (0x%X)\n", Adapter));
+  NDIS_DbgPrint(MAX_TRACE, ("Called. Interrupt (0x%X)\n", NdisInterrupt));
 
-  if (Adapter->NdisMiniportBlock.Interrupt->IsrRequested) {
-      (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ISRHandler)(
+  if (NdisInterrupt->IsrRequested) {
+      (*NdisMiniportBlock->DriverHandle->MiniportCharacteristics.ISRHandler)(
           &InterruptRecognized,
           &QueueMiniportHandleInterrupt,
-          Adapter->NdisMiniportBlock.MiniportAdapterContext);
+          NdisMiniportBlock->MiniportAdapterContext);
 
-  } else if (Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.DisableInterruptHandler) {
-      (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.DisableInterruptHandler)(
-          Adapter->NdisMiniportBlock.MiniportAdapterContext);
+  } else if (NdisMiniportBlock->DriverHandle->MiniportCharacteristics.DisableInterruptHandler) {
+      (*NdisMiniportBlock->DriverHandle->MiniportCharacteristics.DisableInterruptHandler)(
+          NdisMiniportBlock->MiniportAdapterContext);
        QueueMiniportHandleInterrupt = TRUE;
        InterruptRecognized = TRUE;
   }
@@ -83,7 +84,7 @@ BOOLEAN NTAPI ServiceRoutine(
   if (QueueMiniportHandleInterrupt)
   {
       NDIS_DbgPrint(MAX_TRACE, ("Queuing DPC.\n"));
-      KeInsertQueueDpc(&Adapter->NdisMiniportBlock.Interrupt->InterruptDpc, NULL, NULL);
+      KeInsertQueueDpc(&NdisInterrupt->InterruptDpc, NULL, NULL);
   }
 
   NDIS_DbgPrint(MAX_TRACE, ("Leaving.\n"));
@@ -550,6 +551,10 @@ NdisMDeregisterInterrupt(
 {
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
     IoDisconnectInterrupt(Interrupt->InterruptObject);
+    Interrupt->Miniport->RegisteredInterrupts--;
+
+    if (Interrupt->Miniport->Interrupt == Interrupt)
+        Interrupt->Miniport->Interrupt = NULL;
 }
 
 
@@ -777,8 +782,7 @@ NdisMRegisterInterrupt(
 
   Interrupt->SharedInterrupt = SharedInterrupt;
   Interrupt->IsrRequested = RequestIsr;
-
-  Adapter->NdisMiniportBlock.Interrupt = Interrupt;
+  Interrupt->Miniport = &Adapter->NdisMiniportBlock;
 
   MappedIRQ = HalGetInterruptVector(Adapter->NdisMiniportBlock.BusType, Adapter->NdisMiniportBlock.BusNumber,
                                     InterruptLevel, InterruptVector, &DIrql,
@@ -786,13 +790,16 @@ NdisMRegisterInterrupt(
 
   NDIS_DbgPrint(MAX_TRACE, ("Connecting to interrupt vector (0x%X)  Affinity (0x%X).\n", MappedIRQ, Affinity));
 
-  Status = IoConnectInterrupt(&Interrupt->InterruptObject, ServiceRoutine, Adapter, &Interrupt->DpcCountLock, MappedIRQ,
+  Status = IoConnectInterrupt(&Interrupt->InterruptObject, ServiceRoutine, Interrupt, &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 (NT_SUCCESS(Status)) {
+      Adapter->NdisMiniportBlock.Interrupt = Interrupt;
+      Adapter->NdisMiniportBlock.RegisteredInterrupts++;
+      return NDIS_STATUS_SUCCESS;
+  }
 
   if (Status == STATUS_INSUFFICIENT_RESOURCES)
     {

drivers/network/ndis/ndis/miniport.c

@@ -134,6 +134,55 @@ MiniDisplayPacket2(
 #endif /* DBG */
 }
 
+PNDIS_MINIPORT_WORK_ITEM
+MiniGetFirstWorkItem(
+    PLOGICAL_ADAPTER Adapter,
+    NDIS_WORK_ITEM_TYPE Type)
+{
+    PNDIS_MINIPORT_WORK_ITEM CurrentEntry = Adapter->WorkQueueHead;
+
+    while (CurrentEntry)
+    {
+      if (CurrentEntry->WorkItemType == Type)
+          return CurrentEntry;
+
+      CurrentEntry = (PNDIS_MINIPORT_WORK_ITEM)CurrentEntry->Link.Next;
+    }
+
+    return NULL;
+}
+
+BOOLEAN
+MiniIsBusy(
+    PLOGICAL_ADAPTER Adapter,
+    NDIS_WORK_ITEM_TYPE Type)
+{
+    BOOLEAN Busy = FALSE;
+    KIRQL OldIrql;
+
+    KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+
+    if (Type == NdisWorkItemRequest &&
+        (Adapter->NdisMiniportBlock.PendingRequest || MiniGetFirstWorkItem(Adapter, NdisWorkItemRequest)))
+    {
+       Busy = TRUE;
+    }
+    else if (Type == NdisWorkItemSend &&
+             (Adapter->NdisMiniportBlock.FirstPendingPacket || MiniGetFirstWorkItem(Adapter, NdisWorkItemSend)))
+    {
+       Busy = TRUE;
+    }
+    else if (Type == NdisWorkItemResetRequested &&
+             (Adapter->NdisMiniportBlock.ResetStatus == NDIS_STATUS_PENDING || MiniGetFirstWorkItem(Adapter, NdisWorkItemResetRequested)))
+    {
+       Busy = TRUE;
+    }
+
+    KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+
+    return Busy;
+}
+
 
 VOID
 MiniIndicateData(
@@ -265,11 +314,30 @@ MiniResetComplete(
     IN  BOOLEAN     AddressingReset)
 {
     PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
+    PLIST_ENTRY CurrentEntry;
+    PADAPTER_BINDING AdapterBinding;
     KIRQL OldIrql;
-    NDIS_DbgPrint(MIN_TRACE, ("FIXME: MiniResetComplete is partially implemented\n"));
+
     NdisMIndicateStatus(Adapter, NDIS_STATUS_RESET_END, NULL, 0);
+    NdisMIndicateStatusComplete(Adapter);
+
     KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-    Adapter->MiniportBusy = FALSE;
+
+    Adapter->NdisMiniportBlock.ResetStatus = Status;
+
+    CurrentEntry = Adapter->ProtocolListHead.Flink;
+
+    while (CurrentEntry != &Adapter->ProtocolListHead)
+    {
+        AdapterBinding = CONTAINING_RECORD(CurrentEntry, ADAPTER_BINDING, AdapterListEntry);
+
+        (*AdapterBinding->ProtocolBinding->Chars.ResetCompleteHandler)(
+               AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
+               Status);
+
+        CurrentEntry = CurrentEntry->Flink;
+    }
+
     KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
 }
 
@@ -288,15 +356,17 @@ MiniRequestComplete(
     NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
 
     KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+    Adapter->NdisMiniportBlock.PendingRequest = NULL;
+    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
     if( MacBlock->Binding->RequestCompleteHandler ) {
         (*MacBlock->Binding->RequestCompleteHandler)(
             MacBlock->Binding->ProtocolBindingContext,
             Request,
             Status);
     }
-    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-    Adapter->MiniportBusy = FALSE;
-    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
     KeLowerIrql(OldIrql);
 }
 
@@ -314,7 +384,6 @@ MiniSendComplete(
  *     Status            = Status of send operation
  */
 {
-    PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
     PADAPTER_BINDING AdapterBinding;
     KIRQL OldIrql;
 
@@ -327,9 +396,6 @@ MiniSendComplete(
         AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
         Packet,
         Status);
-    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-    Adapter->MiniportBusy = FALSE;
-    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
     KeLowerIrql(OldIrql);
 }
 
@@ -351,7 +417,6 @@ MiniTransferDataComplete(
     IN  NDIS_STATUS     Status,
     IN  UINT            BytesTransferred)
 {
-    PLOGICAL_ADAPTER Adapter = MiniportAdapterHandle;
     PADAPTER_BINDING AdapterBinding;
     KIRQL OldIrql;
 
@@ -364,9 +429,6 @@ MiniTransferDataComplete(
         AdapterBinding->NdisOpenBlock.ProtocolBindingContext,
         Packet,
         Status);
-    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-    Adapter->MiniportBusy = FALSE;
-    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
     KeLowerIrql(OldIrql);
 }
 
@@ -596,10 +658,8 @@ MiniReset(
    NDIS_STATUS Status;
    KIRQL OldIrql;
 
-   if (Adapter->MiniportBusy) {
-       KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-       MiniQueueWorkItem(Adapter, NdisWorkItemResetRequested, NULL);
-       KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+   if (MiniIsBusy(Adapter, NdisWorkItemResetRequested)) {
+       MiniQueueWorkItem(Adapter, NdisWorkItemResetRequested, NULL, FALSE);
        return NDIS_STATUS_PENDING;
    }
 
@@ -610,15 +670,16 @@ MiniReset(
    Status = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ResetHandler)(
             Adapter->NdisMiniportBlock.MiniportAdapterContext,
             AddressingReset);
+
+   KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+   Adapter->NdisMiniportBlock.ResetStatus = Status;
+   KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
    KeLowerIrql(OldIrql);
 
    if (Status != NDIS_STATUS_PENDING) {
        NdisMIndicateStatus(Adapter, NDIS_STATUS_RESET_END, NULL, 0);
        NdisMIndicateStatusComplete(Adapter);
-   } else {
-       KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-       Adapter->MiniportBusy = TRUE;
-       KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
    }
 
    return Status;
@@ -644,72 +705,77 @@ MiniportHangDpc(
 }
 
 
-NDIS_STATUS
+VOID
 FASTCALL
 MiniQueueWorkItem(
     PLOGICAL_ADAPTER     Adapter,
     NDIS_WORK_ITEM_TYPE  WorkItemType,
-    PVOID                WorkItemContext)
+    PVOID                WorkItemContext,
+    BOOLEAN              Top)
 /*
  * FUNCTION: Queues a work item for execution at a later time
  * ARGUMENTS:
  *     Adapter         = Pointer to the logical adapter object to queue work item on
  *     WorkItemType    = Type of work item to queue
  *     WorkItemContext = Pointer to context information for work item
- * NOTES:
- *     Adapter lock must be held when called
  * RETURNS:
  *     Status of operation
  */
 {
     PNDIS_MINIPORT_WORK_ITEM MiniportWorkItem;
-    PNDIS_WORK_ITEM NdisWorkItem;
-    PWORK_QUEUE_ITEM WorkQueueItem;
+    PIO_WORKITEM IoWorkItem;
+    KIRQL OldIrql;
 
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
     ASSERT(Adapter);
-    ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
 
-    MiniportWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
-    if (!MiniportWorkItem)
+    KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
+    if (Top)
     {
-        NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
-        return NDIS_STATUS_RESOURCES;
-    }
-
-    NdisWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_WORK_ITEM));
-    if (!NdisWorkItem)
-    {
-        ExFreePool(MiniportWorkItem);
-        return NDIS_STATUS_RESOURCES;
-    }
-
-    MiniportWorkItem->WorkItemType    = WorkItemType;
-    MiniportWorkItem->WorkItemContext = WorkItemContext;
-
-    /* safe due to adapter lock held */
-    MiniportWorkItem->Link.Next = NULL;
-    if (!Adapter->WorkQueueHead)
-    {
-        Adapter->WorkQueueHead = MiniportWorkItem;
-        Adapter->WorkQueueTail = MiniportWorkItem;
+        if (WorkItemType == NdisWorkItemSend)
+        {
+            NDIS_DbgPrint(MIN_TRACE, ("Requeuing failed packet (%x).\n", WorkItemContext));
+            Adapter->NdisMiniportBlock.FirstPendingPacket = WorkItemContext;
+        }
+        else
+        {
+            //This should never happen
+            ASSERT(FALSE);
+        }
     }
     else
     {
-        Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)MiniportWorkItem;
-        Adapter->WorkQueueTail = MiniportWorkItem;
+        MiniportWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_MINIPORT_WORK_ITEM));
+        if (!MiniportWorkItem)
+        {
+            KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+            NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+            return;
+        }
+
+        MiniportWorkItem->WorkItemType    = WorkItemType;
+        MiniportWorkItem->WorkItemContext = WorkItemContext;
+
+        /* safe due to adapter lock held */
+        MiniportWorkItem->Link.Next = NULL;
+        if (!Adapter->WorkQueueHead)
+        {
+            Adapter->WorkQueueHead = MiniportWorkItem;
+            Adapter->WorkQueueTail = MiniportWorkItem;
+        }
+        else
+        {
+            Adapter->WorkQueueTail->Link.Next = (PSINGLE_LIST_ENTRY)MiniportWorkItem;
+            Adapter->WorkQueueTail = MiniportWorkItem;
+        }
     }
 
-    WorkQueueItem = (PWORK_QUEUE_ITEM)NdisWorkItem->WrapperReserved;
+    IoWorkItem = IoAllocateWorkItem(Adapter->NdisMiniportBlock.DeviceObject);
+    if (IoWorkItem)
+        IoQueueWorkItem(IoWorkItem, MiniportWorker, CriticalWorkQueue, IoWorkItem);
 
-    NdisWorkItem->Context = Adapter;
-
-    ExInitializeWorkItem(WorkQueueItem, MiniportWorker, NdisWorkItem);
-
-    ExQueueWorkItem(WorkQueueItem, CriticalWorkQueue);
-
-    return NDIS_STATUS_SUCCESS;
+    KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
 }
 
 
@@ -733,26 +799,22 @@ MiniDequeueWorkItem(
  */
 {
     PNDIS_MINIPORT_WORK_ITEM MiniportWorkItem;
-    PNDIS_WORK_ITEM NdisWorkItem;
-    PWORK_QUEUE_ITEM WorkQueueItem;
-
+    PNDIS_PACKET Packet;
 
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
-    if (Adapter->MiniportBusy) {
-        NDIS_DbgPrint(MID_TRACE, ("Waiting for miniport to become free.\n"));
-        NdisWorkItem = ExAllocatePool(NonPagedPool, sizeof(NDIS_WORK_ITEM));
-        if (!NdisWorkItem) return NDIS_STATUS_RESOURCES;
-        WorkQueueItem = (PWORK_QUEUE_ITEM)NdisWorkItem->WrapperReserved;
-        NdisWorkItem->Context = Adapter;
-        ExInitializeWorkItem(WorkQueueItem, MiniportWorker, NdisWorkItem);
-        ExQueueWorkItem(WorkQueueItem, CriticalWorkQueue);
-        return NDIS_STATUS_FAILURE;
-    }
-
     MiniportWorkItem = Adapter->WorkQueueHead;
 
-    if (MiniportWorkItem)
+    if ((Packet = Adapter->NdisMiniportBlock.FirstPendingPacket))
+    {
+        Adapter->NdisMiniportBlock.FirstPendingPacket = NULL;
+
+        *WorkItemType = NdisWorkItemSend;
+        *WorkItemContext = Packet;
+
+        return NDIS_STATUS_SUCCESS;
+    }
+    else if (MiniportWorkItem)
     {
         /* safe due to adapter lock held */
         Adapter->WorkQueueHead = (PNDIS_MINIPORT_WORK_ITEM)MiniportWorkItem->Link.Next;
@@ -765,12 +827,12 @@ MiniDequeueWorkItem(
 
         ExFreePool(MiniportWorkItem);
 
-        Adapter->MiniportBusy = TRUE;
-
         return NDIS_STATUS_SUCCESS;
     }
-
-    return NDIS_STATUS_FAILURE;
+    else
+    {
+        return NDIS_STATUS_FAILURE;
+    }
 }
 
 
@@ -791,9 +853,12 @@ MiniDoRequest(
     KIRQL OldIrql;
     NDIS_DbgPrint(DEBUG_MINIPORT, ("Called.\n"));
 
-    Adapter->NdisMiniportBlock.MediaRequest = NdisRequest;
-
     KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+    Adapter->NdisMiniportBlock.PendingRequest = NdisRequest;
+    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+
     switch (NdisRequest->RequestType)
     {
     case NdisRequestQueryInformation:
@@ -820,9 +885,9 @@ MiniDoRequest(
         Status = NDIS_STATUS_FAILURE;
     }
 
-    if (Status == NDIS_STATUS_PENDING) {
+    if (Status != NDIS_STATUS_PENDING) {
         KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-        Adapter->MiniportBusy = TRUE;
+        Adapter->NdisMiniportBlock.PendingRequest = NULL;
         KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
     }
 
@@ -830,6 +895,27 @@ MiniDoRequest(
     return Status;
 }
 
+
+/*
+ * @implemented
+ */
+#undef NdisMSetInformationComplete
+VOID
+EXPORT
+NdisMSetInformationComplete(
+    IN  NDIS_HANDLE MiniportAdapterHandle,
+    IN  NDIS_STATUS Status)
+{
+  PLOGICAL_ADAPTER Adapter =
+	(PLOGICAL_ADAPTER)MiniportAdapterHandle;
+  KIRQL OldIrql;
+  ASSERT(Adapter);
+  KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+  if (Adapter->NdisMiniportBlock.SetCompleteHandler)
+     (Adapter->NdisMiniportBlock.SetCompleteHandler)(MiniportAdapterHandle, Status);
+  KeLowerIrql(OldIrql);
+}
+
 
 /*
  * @implemented
@@ -848,22 +934,22 @@ NdisMQueryInformationComplete(
     KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
     if( Adapter->NdisMiniportBlock.QueryCompleteHandler )
 	(Adapter->NdisMiniportBlock.QueryCompleteHandler)(MiniportAdapterHandle, Status);
-    KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-    Adapter->MiniportBusy = FALSE;
-    KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
     KeLowerIrql(OldIrql);
 }
 
-VOID NTAPI MiniportWorker(IN PVOID WorkItem)
+VOID
+NTAPI
+MiniportWorker(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
 {
-  PNDIS_WORK_ITEM NdisWorkItem = WorkItem;
-  PLOGICAL_ADAPTER Adapter = GET_LOGICAL_ADAPTER(NdisWorkItem->Context);
+  PLOGICAL_ADAPTER Adapter = DeviceObject->DeviceExtension;
   KIRQL OldIrql, RaiseOldIrql;
   NDIS_STATUS NdisStatus;
   PVOID WorkItemContext;
   NDIS_WORK_ITEM_TYPE WorkItemType;
   BOOLEAN AddressingReset;
 
+  IoFreeWorkItem((PIO_WORKITEM)Context);
+
   KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
 
   NdisStatus =
@@ -880,9 +966,7 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
             /*
              * called by ProSend when protocols want to send packets to the miniport
              */
-#ifdef DBG
-            MiniDisplayPacket((PNDIS_PACKET)WorkItemContext);
-#endif
+
             if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
               {
                 if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
@@ -905,9 +989,7 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
 
                     NdisStatus = NDIS_GET_PACKET_STATUS((PNDIS_PACKET)WorkItemContext);
                     if( NdisStatus == NDIS_STATUS_RESOURCES ) {
-                        KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-                        MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext);
-                        KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+                        MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext, TRUE);
                         break;
                     }
                 }
@@ -931,9 +1013,7 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
                   NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
                   KeLowerIrql(RaiseOldIrql);
                   if( NdisStatus == NDIS_STATUS_RESOURCES ) {
-                      KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-                      MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext);
-                      KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+                      MiniQueueWorkItem(Adapter, WorkItemType, WorkItemContext, TRUE);
                       break;
                   }
                 }
@@ -967,12 +1047,18 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
             NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.ResetHandler)(
                           Adapter->NdisMiniportBlock.MiniportAdapterContext,
                           &AddressingReset);
-            KeLowerIrql(OldIrql);
 
             if (NdisStatus == NDIS_STATUS_PENDING)
-                break;
+            {
+                KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+                Adapter->NdisMiniportBlock.ResetStatus = NDIS_STATUS_PENDING;
+                KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
+            }
 
-            MiniResetComplete(Adapter, NdisStatus, AddressingReset);
+            KeLowerIrql(OldIrql);
+
+            if (NdisStatus != NDIS_STATUS_PENDING)
+               MiniResetComplete(Adapter, NdisStatus, AddressingReset);
             break;
 
           case NdisWorkItemResetInProgress:
@@ -1001,6 +1087,7 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
 
                 default:
                   NDIS_DbgPrint(MIN_TRACE, ("Unknown NDIS request type.\n"));
+                  MiniRequestComplete( (NDIS_HANDLE)Adapter, (PNDIS_REQUEST)WorkItemContext, NdisStatus );
                   break;
               }
             break;
@@ -1010,14 +1097,6 @@ VOID NTAPI MiniportWorker(IN PVOID WorkItem)
             break;
         }
     }
-
-  if( NdisStatus != NDIS_STATUS_PENDING ) {
-      KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-      Adapter->MiniportBusy = FALSE;
-      KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
-  }
-
-  ExFreePool(WorkItem);
 }
 
 
@@ -1416,15 +1495,6 @@ DoQueries(
 
   NDIS_DbgPrint(DEBUG_MINIPORT, ("CurLookaheadLength (0x%X).\n", Adapter->NdisMiniportBlock.CurrentLookahead));
 
-  if (Adapter->NdisMiniportBlock.MaximumLookahead != 0)
-    {
-      Adapter->LookaheadLength = Adapter->NdisMiniportBlock.MaximumLookahead + Adapter->MediumHeaderSize;
-      Adapter->LookaheadBuffer = ExAllocatePool(NonPagedPool, Adapter->LookaheadLength);
-
-      if (!Adapter->LookaheadBuffer)
-        return NDIS_STATUS_RESOURCES;
-    }
-
   return STATUS_SUCCESS;
 }
 
@@ -1703,12 +1773,6 @@ NdisIPnPStartDevice(
   if (NdisStatus != NDIS_STATUS_SUCCESS)
     {
       NDIS_DbgPrint(MAX_TRACE, ("couldn't create filter (%x)\n", NdisStatus));
-      if (Adapter->LookaheadBuffer)
-        {
-          ExFreePool(Adapter->LookaheadBuffer);
-          Adapter->LookaheadBuffer = NULL;
-        }
-      ExInterlockedRemoveEntryList( &Adapter->ListEntry, &AdapterListLock );
       return NdisStatus;
     }
 
@@ -1746,27 +1810,17 @@ NdisIPnPStopDevice(
  */
 {
   PLOGICAL_ADAPTER Adapter = (PLOGICAL_ADAPTER)DeviceObject->DeviceExtension;
-  KIRQL OldIrql;
 
   /* Remove adapter from adapter list for this miniport */
-  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, &OldIrql);
-  RemoveEntryList(&Adapter->MiniportListEntry);
-  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.DriverHandle->Lock, OldIrql);
+  ExInterlockedRemoveEntryList(&Adapter->MiniportListEntry, &Adapter->NdisMiniportBlock.DriverHandle->Lock);
 
   /* Remove adapter from global adapter list */
-  KeAcquireSpinLock(&AdapterListLock, &OldIrql);
-  RemoveEntryList(&Adapter->ListEntry);
-  KeReleaseSpinLock(&AdapterListLock, OldIrql);
+  ExInterlockedRemoveEntryList(&Adapter->ListEntry, &AdapterListLock);
 
   KeCancelTimer(&Adapter->NdisMiniportBlock.WakeUpDpcTimer.Timer);
 
   (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.HaltHandler)(Adapter);
 
-  if (Adapter->LookaheadBuffer)
-    {
-      ExFreePool(Adapter->LookaheadBuffer);
-      Adapter->LookaheadBuffer = NULL;
-    }
   if (Adapter->NdisMiniportBlock.AllocatedResources)
     {
       ExFreePool(Adapter->NdisMiniportBlock.AllocatedResources);
@@ -2172,29 +2226,6 @@ NdisMTransferDataComplete(
   MiniTransferDataComplete(MiniportAdapterHandle, Packet, Status, BytesTransferred);
 }
 
-
-/*
- * @implemented
- */
-#undef NdisMSetInformationComplete
-VOID
-EXPORT
-NdisMSetInformationComplete(
-    IN  NDIS_HANDLE MiniportAdapterHandle,
-    IN  NDIS_STATUS Status)
-{
-  PLOGICAL_ADAPTER Adapter =
-	(PLOGICAL_ADAPTER)MiniportAdapterHandle;
-  KIRQL OldIrql;
-  ASSERT(Adapter);
-  KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
-  (Adapter->NdisMiniportBlock.SetCompleteHandler)(MiniportAdapterHandle, Status);
-  KeAcquireSpinLockAtDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-  Adapter->MiniportBusy = FALSE;
-  KeReleaseSpinLockFromDpcLevel(&Adapter->NdisMiniportBlock.Lock);
-  KeLowerIrql(OldIrql);
-}
-
 
 /*
  * @implemented
@@ -2367,6 +2398,7 @@ NdisTerminateWrapper(
 
   ExFreePool(Miniport->RegistryPath->Buffer);
   ExFreePool(Miniport->RegistryPath);
+  ExInterlockedRemoveEntryList(&Miniport->ListEntry, &MiniportListLock);
   ExFreePool(Miniport);
 }
 

drivers/network/ndis/ndis/protocol.c

@@ -20,6 +20,8 @@
 LIST_ENTRY ProtocolListHead;
 KSPIN_LOCK ProtocolListLock;
 
+#define WORKER_TEST 0
+
 
 /*
  * @implemented
@@ -68,6 +70,7 @@ ProIndicatePacket(
   UINT BufferedLength;
   UINT PacketLength;
   KIRQL OldIrql;
+  PUCHAR LookaheadBuffer;
 
   NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
@@ -75,36 +78,34 @@ ProIndicatePacket(
   MiniDisplayPacket(Packet);
 #endif
 
+  LookaheadBuffer = ExAllocatePool(NonPagedPool, Adapter->NdisMiniportBlock.CurrentLookahead + Adapter->MediumHeaderSize);
+  if (!LookaheadBuffer)
+      return NDIS_STATUS_RESOURCES;
+
   NdisQueryPacket(Packet, NULL, NULL, NULL, &PacketLength);
 
   NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
   KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
     {
-      Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = Packet;
-      BufferedLength = CopyPacketToBuffer(Adapter->LookaheadBuffer, Packet, 0, Adapter->NdisMiniportBlock.CurrentLookahead);
+      BufferedLength = CopyPacketToBuffer(LookaheadBuffer, Packet, 0, Adapter->NdisMiniportBlock.CurrentLookahead);
     }
   KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
 
   if (BufferedLength > Adapter->MediumHeaderSize)
     {
       /* XXX Change this to call SendPackets so we don't have to duplicate this wacky logic */
-      MiniIndicateData(Adapter, NULL, Adapter->LookaheadBuffer, Adapter->MediumHeaderSize,
-          &Adapter->LookaheadBuffer[Adapter->MediumHeaderSize], BufferedLength - Adapter->MediumHeaderSize,
+      MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize,
+          &LookaheadBuffer[Adapter->MediumHeaderSize], BufferedLength - Adapter->MediumHeaderSize,
           PacketLength - Adapter->MediumHeaderSize);
     }
   else
     {
-      MiniIndicateData(Adapter, NULL, Adapter->LookaheadBuffer, Adapter->MediumHeaderSize, NULL, 0, 0);
+      MiniIndicateData(Adapter, NULL, LookaheadBuffer, Adapter->MediumHeaderSize, NULL, 0, 0);
     }
 
-  NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
-  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-    {
-      Adapter->NdisMiniportBlock.IndicatedPacket[KeGetCurrentProcessorNumber()] = NULL;
-    }
-  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+  ExFreePool(LookaheadBuffer);
 
-  return STATUS_SUCCESS;
+  return NDIS_STATUS_SUCCESS;
 }
 
 
@@ -121,7 +122,6 @@ ProRequest(
  *     Status of operation
  */
 {
-  KIRQL OldIrql;
   PADAPTER_BINDING AdapterBinding;
   PLOGICAL_ADAPTER Adapter;
   PNDIS_REQUEST_MAC_BLOCK MacBlock = (PNDIS_REQUEST_MAC_BLOCK)NdisRequest->MacReserved;
@@ -136,21 +136,17 @@ ProRequest(
 
   MacBlock->Binding = &AdapterBinding->NdisOpenBlock;
 
-  /*
-   * If the miniport is already busy, queue a workitem
-   */
-  NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
-  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &OldIrql);
-    {
-      if (Adapter->MiniportBusy) {
-          MiniQueueWorkItem(Adapter, NdisWorkItemRequest, (PVOID)NdisRequest);
-          KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
-          return NDIS_STATUS_PENDING;
-      }
-    }
-  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, OldIrql);
+#if WORKER_TEST
+  MiniQueueWorkItem(Adapter, NdisWorkItemRequest, NdisRequest, FALSE);
+  return NDIS_STATUS_PENDING;
+#else
+  if (MiniIsBusy(Adapter, NdisWorkItemRequest)) {
+      MiniQueueWorkItem(Adapter, NdisWorkItemRequest, NdisRequest, FALSE);
+      return NDIS_STATUS_PENDING;
+  }
 
   return MiniDoRequest(Adapter, NdisRequest);
+#endif
 }
 
 
@@ -163,6 +159,74 @@ ProReset(
     return NDIS_STATUS_FAILURE;
 }
 
+NDIS_STATUS
+proSendPacketToMiniport(PLOGICAL_ADAPTER Adapter, PNDIS_PACKET Packet)
+{
+#if WORKER_TEST
+   MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, FALSE);
+   return NDIS_STATUS_PENDING;
+#else
+   KIRQL RaiseOldIrql;
+   NDIS_STATUS NdisStatus;
+
+   if(MiniIsBusy(Adapter, NdisWorkItemSend)) {
+      MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, FALSE);
+      return NDIS_STATUS_PENDING;
+   }
+
+   if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
+   {
+        if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
+        {
+            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
+            (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
+             Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
+             NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
+        } else {
+            /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
+            KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
+            {
+               NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
+               (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
+                Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
+            }
+            KeLowerIrql(RaiseOldIrql);
+
+            NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
+            if (NdisStatus == NDIS_STATUS_RESOURCES) {
+                MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, TRUE);
+                NdisStatus = NDIS_STATUS_PENDING;
+            }
+        }
+
+        return NdisStatus;
+   } else {
+        if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
+        {
+            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
+            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
+                          Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, 0);
+            NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
+        } else {
+            /* Send is called at DISPATCH_LEVEL for all serialized miniports */
+            KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
+            NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
+            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
+                          Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, 0);
+            NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
+            KeLowerIrql(RaiseOldIrql);
+
+            if (NdisStatus == NDIS_STATUS_RESOURCES) {
+                MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet, TRUE);
+                NdisStatus = NDIS_STATUS_PENDING;
+            }
+        }
+
+        return NdisStatus;
+   }
+#endif
+}
+
 
 NDIS_STATUS NTAPI
 ProSend(
@@ -176,15 +240,10 @@ ProSend(
  * RETURNS:
  *     NDIS_STATUS_SUCCESS if the packet was successfully sent
  *     NDIS_STATUS_PENDING if the miniport was busy or a serialized miniport returned NDIS_STATUS_RESOURCES
- * NOTES:
- * TODO:
- *     - Break this up
  */
 {
-  KIRQL SpinOldIrql, RaiseOldIrql;
   PADAPTER_BINDING AdapterBinding;
   PLOGICAL_ADAPTER Adapter;
-  NDIS_STATUS NdisStatus;
 
   NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
 
@@ -210,83 +269,18 @@ ProSend(
    * this is a loopback frame.
    */
 
-  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &SpinOldIrql);
-
   if ((Adapter->NdisMiniportBlock.MacOptions & NDIS_MAC_OPTION_NO_LOOPBACK) &&
       MiniAdapterHasAddress(Adapter, Packet))
     {
-        if(Adapter->MiniportBusy) {
-           MiniQueueWorkItem(Adapter, NdisWorkItemSendLoopback, Packet);
-           KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-           return NDIS_STATUS_PENDING;
-        }
-
-        KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-
+#if WORKER_TEST
+        MiniQueueWorkItem(Adapter, NdisWorkItemSendLoopback, Packet, FALSE);
+        return NDIS_STATUS_PENDING;
+#else
         return ProIndicatePacket(Adapter, Packet);
+#endif
     } else {
-        if(Adapter->MiniportBusy) {
-           MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet);
-           KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-           return NDIS_STATUS_PENDING;
-        }
-
-        KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-
-        if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
-        {
-           if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
-           {
-               NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
-               (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
-                Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
-                NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
-           } else {
-               /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
-               KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
-               {
-                  NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's SendPackets handler\n"));
-                  (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
-                   Adapter->NdisMiniportBlock.MiniportAdapterContext, &Packet, 1);
-               }
-               KeLowerIrql(RaiseOldIrql);
-
-               NdisStatus = NDIS_GET_PACKET_STATUS(Packet);
-               if( NdisStatus == NDIS_STATUS_RESOURCES ) {
-                   KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &SpinOldIrql);
-                   MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet);
-                   KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-                   NdisStatus = NDIS_STATUS_PENDING;
-               }
-           }
-
-           return NdisStatus;
-         } else {
-           if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
-           {
-              NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
-              NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
-                            Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, 0);
-              NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
-           } else {
-              /* Send is called at DISPATCH_LEVEL for all serialized miniports */
-              KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
-              NDIS_DbgPrint(MAX_TRACE, ("Calling miniport's Send handler\n"));
-              NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
-                            Adapter->NdisMiniportBlock.MiniportAdapterContext, Packet, 0);
-              NDIS_DbgPrint(MAX_TRACE, ("back from miniport's send handler\n"));
-              KeLowerIrql(RaiseOldIrql);
-              if( NdisStatus == NDIS_STATUS_RESOURCES ) {
-                  KeAcquireSpinLock(&Adapter->NdisMiniportBlock.Lock, &SpinOldIrql);
-                  MiniQueueWorkItem(Adapter, NdisWorkItemSend, Packet);
-                  KeReleaseSpinLock(&Adapter->NdisMiniportBlock.Lock, SpinOldIrql);
-                  NdisStatus = NDIS_STATUS_PENDING;
-              }
-           }
-
-           return NdisStatus;
-         }
-     }
+        return proSendPacketToMiniport(Adapter, Packet);
+    }
 }
 
 
@@ -296,7 +290,66 @@ ProSendPackets(
     IN  PPNDIS_PACKET   PacketArray,
     IN  UINT            NumberOfPackets)
 {
-    UNIMPLEMENTED
+    PADAPTER_BINDING AdapterBinding = NdisBindingHandle;
+    PLOGICAL_ADAPTER Adapter = AdapterBinding->Adapter;
+    KIRQL RaiseOldIrql;
+    NDIS_STATUS NdisStatus;
+    UINT i;
+
+    if(Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)
+    {
+       if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
+       {
+          (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
+           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray, NumberOfPackets);
+          for (i = 0; i < NumberOfPackets; i++)
+          {
+             NdisStatus = NDIS_GET_PACKET_STATUS(PacketArray[i]);
+             if (NdisStatus != NDIS_STATUS_PENDING)
+                 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
+          }
+       }
+       else
+       {
+          /* SendPackets is called at DISPATCH_LEVEL for all serialized miniports */
+          KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
+          (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendPacketsHandler)(
+           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray, NumberOfPackets);
+          KeLowerIrql(RaiseOldIrql);
+          for (i = 0; i < NumberOfPackets; i++)
+          {
+             NdisStatus = NDIS_GET_PACKET_STATUS(PacketArray[i]);
+             if (NdisStatus != NDIS_STATUS_PENDING)
+                 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
+          }
+       }
+     }
+     else
+     {
+       if(Adapter->NdisMiniportBlock.Flags & NDIS_ATTRIBUTE_DESERIALIZE)
+       {  
+          for (i = 0; i < NumberOfPackets; i++)
+          {
+             NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
+                           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray[i], 0);
+             if (NdisStatus != NDIS_STATUS_PENDING)
+                 MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
+          }
+       }
+       else
+       {
+         /* Send is called at DISPATCH_LEVEL for all serialized miniports */
+         KeRaiseIrql(DISPATCH_LEVEL, &RaiseOldIrql);
+         for (i = 0; i < NumberOfPackets; i++)
+         {
+            NdisStatus = (*Adapter->NdisMiniportBlock.DriverHandle->MiniportCharacteristics.SendHandler)(
+                           Adapter->NdisMiniportBlock.MiniportAdapterContext, PacketArray[i], 0);
+            if (NdisStatus != NDIS_STATUS_PENDING)
+                MiniSendComplete(Adapter, PacketArray[i], NdisStatus);
+         }
+         KeLowerIrql(RaiseOldIrql);
+       }
+     }
 }
 
 
@@ -373,21 +426,15 @@ 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);
+    ExInterlockedRemoveEntryList(&AdapterBinding->ProtocolListEntry, &AdapterBinding->ProtocolBinding->Lock);
 
     /* Remove protocol from adapter's bound protocols list */
-    NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
-    KeAcquireSpinLock(&AdapterBinding->Adapter->NdisMiniportBlock.Lock, &OldIrql);
-    RemoveEntryList(&AdapterBinding->AdapterListEntry);
-    KeReleaseSpinLock(&AdapterBinding->Adapter->NdisMiniportBlock.Lock, OldIrql);
+    ExInterlockedRemoveEntryList(&AdapterBinding->AdapterListEntry, &AdapterBinding->Adapter->NdisMiniportBlock.Lock);
 
     ExFreePool(AdapterBinding);
 
@@ -410,7 +457,6 @@ NdisDeregisterProtocol(
  *     NdisProtocolHandle = Handle returned by NdisRegisterProtocol
  */
 {
-    KIRQL OldIrql;
     PPROTOCOL_BINDING Protocol = GET_PROTOCOL_BINDING(NdisProtocolHandle);
 
     NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
@@ -418,9 +464,7 @@ NdisDeregisterProtocol(
     /* FIXME: Make sure no adapter bindings exist */
 
     /* Remove protocol from global list */
-    KeAcquireSpinLock(&ProtocolListLock, &OldIrql);
-    RemoveEntryList(&Protocol->ListEntry);
-    KeReleaseSpinLock(&ProtocolListLock, OldIrql);
+    ExInterlockedRemoveEntryList(&Protocol->ListEntry, &ProtocolListLock);
 
     ExFreePool(Protocol);
 
@@ -533,14 +577,9 @@ NdisOpenAdapter(
   AdapterBinding->NdisOpenBlock.RequestCompleteHandler =
     Protocol->Chars.RequestCompleteHandler;
 
-#if 0
-  /* XXX this looks fishy */
-  /* OK, this really *is* fishy - it bugchecks */
   /* Put on protocol's bound adapters list */
   ExInterlockedInsertTailList(&Protocol->AdapterListHead, &AdapterBinding->ProtocolListEntry, &Protocol->Lock);
-#endif
 
-  /* XXX so does this */
   /* Put protocol on adapter's bound protocols list */
   NDIS_DbgPrint(MAX_TRACE, ("acquiring miniport block lock\n"));
   ExInterlockedInsertTailList(&Adapter->ProtocolListHead, &AdapterBinding->AdapterListEntry, &Adapter->NdisMiniportBlock.Lock);
@@ -550,100 +589,10 @@ NdisOpenAdapter(
   *Status = NDIS_STATUS_SUCCESS;
 }
 
-
-/*
- * @implemented
- */
 VOID
-EXPORT
-NdisRegisterProtocol(
-    OUT PNDIS_STATUS                    Status,
-    OUT PNDIS_HANDLE                    NdisProtocolHandle,
-    IN  PNDIS_PROTOCOL_CHARACTERISTICS  ProtocolCharacteristics,
-    IN  UINT                            CharacteristicsLength)
-/*
- * FUNCTION: Registers an NDIS driver's ProtocolXxx entry points
- * ARGUMENTS:
- *     Status                  = Address of buffer for status information
- *     NdisProtocolHandle      = Address of buffer for handle used to identify the driver
- *     ProtocolCharacteristics = Pointer to NDIS_PROTOCOL_CHARACTERISTICS structure
- *     CharacteristicsLength   = Size of structure which ProtocolCharacteristics targets
- * NOTES:
- *     - you *must* set NdisProtocolHandle before doing anything that could wind up
- *       getting BindAdapterHandler, as it will probably call OpenAdapter with this handle
- *     - the above implies that the initialization of the protocol block must be complete
- *       by then
- * TODO:
- *     - break this function up - probably do a 'ndisRefreshProtocolBindings' function
- *     - make this thing able to handle >1 protocol
- */
+NTAPI
+ndisBindMiniportsToProtocol(OUT PNDIS_STATUS Status, IN PNDIS_PROTOCOL_CHARACTERISTICS ProtocolCharacteristics)
 {
-  PPROTOCOL_BINDING Protocol;
-  NTSTATUS NtStatus;
-  UINT MinSize;
-  HANDLE DriverKeyHandle = NULL;
-  PKEY_VALUE_PARTIAL_INFORMATION KeyInformation = NULL;
-  WCHAR *DataPtr;
-
-  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
-
-  *NdisProtocolHandle = NULL;
-
-  /* first validate the PROTOCOL_CHARACTERISTICS */
-  switch (ProtocolCharacteristics->MajorNdisVersion)
-    {
-    case 0x03:
-      /* we don't really want to support ndis3 drivers - so we complain for now */
-      NDIS_DbgPrint(MID_TRACE, ("NDIS 3 protocol attempting to register\n"));
-      MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS);
-      break;
-
-    case 0x04:
-      MinSize = sizeof(NDIS40_PROTOCOL_CHARACTERISTICS);
-      break;
-
-    case 0x05:
-      MinSize = sizeof(NDIS50_PROTOCOL_CHARACTERISTICS);
-      break;
-
-    default:
-      *Status = NDIS_STATUS_BAD_VERSION;
-      NDIS_DbgPrint(MIN_TRACE, ("Incorrect characteristics size\n"));
-      return;
-    }
-
-  if (CharacteristicsLength < MinSize)
-    {
-      NDIS_DbgPrint(DEBUG_PROTOCOL, ("Bad protocol characteristics.\n"));
-      *Status = NDIS_STATUS_BAD_CHARACTERISTICS;
-      return;
-    }
-
-  /* set up the protocol block */
-  Protocol = ExAllocatePool(NonPagedPool, sizeof(PROTOCOL_BINDING));
-  if (!Protocol)
-    {
-      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
-      *Status = NDIS_STATUS_RESOURCES;
-      return;
-    }
-
-  RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
-  RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
-
-  NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name, &ProtocolCharacteristics->Name, TRUE);
-  if (!NT_SUCCESS(NtStatus))
-    {
-      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
-      ExFreePool(Protocol);
-      *Status = NDIS_STATUS_RESOURCES;
-      return;
-    }
-
-  KeInitializeSpinLock(&Protocol->Lock);
-
-  InitializeListHead(&Protocol->AdapterListHead);
-
   /*
    * bind the protocol to all of its miniports
    *
@@ -651,16 +600,18 @@ NdisRegisterProtocol(
    * get list of devices from Bind key
    * call BindAdapterHandler for each
    */
-  {
     OBJECT_ATTRIBUTES ObjectAttributes;
     UNICODE_STRING RegistryPath;
     WCHAR *RegistryPathStr;
+    NTSTATUS NtStatus;
+    WCHAR *DataPtr;
+    HANDLE DriverKeyHandle = NULL;
+    PKEY_VALUE_PARTIAL_INFORMATION KeyInformation = NULL;
 
     RegistryPathStr = ExAllocatePoolWithTag(PagedPool, sizeof(SERVICES_KEY) + ProtocolCharacteristics->Name.Length + sizeof(LINKAGE_KEY), NDIS_TAG + __LINE__);
     if(!RegistryPathStr)
       {
         NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
-        ExFreePool(Protocol);
         *Status = NDIS_STATUS_RESOURCES;
         return;
       }
@@ -680,12 +631,10 @@ NdisRegisterProtocol(
 
     if(!NT_SUCCESS(NtStatus))
       {
-        NDIS_DbgPrint(MID_TRACE, ("Unable to open protocol configuration\n"));
-        ExFreePool(Protocol);
+        NDIS_DbgPrint(MIN_TRACE, ("Unable to open protocol configuration\n"));
         *Status = NDIS_STATUS_FAILURE;
         return;
       }
-  }
 
   NDIS_DbgPrint(MAX_TRACE, ("Successfully opened the registry configuration\n"));
 
@@ -698,9 +647,8 @@ NdisRegisterProtocol(
     NtStatus = ZwQueryValueKey(DriverKeyHandle, &ValueName, KeyValuePartialInformation, NULL, 0, &ResultLength);
     if(NtStatus != STATUS_BUFFER_OVERFLOW && NtStatus != STATUS_BUFFER_TOO_SMALL && NtStatus != STATUS_SUCCESS)
       {
-        NDIS_DbgPrint(MID_TRACE, ("Unable to query the Bind value for size\n"));
+        NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value for size\n"));
         ZwClose(DriverKeyHandle);
-        ExFreePool(Protocol);
         *Status = NDIS_STATUS_FAILURE;
         return;
       }
@@ -710,7 +658,6 @@ NdisRegisterProtocol(
       {
         NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         ZwClose(DriverKeyHandle);
-        ExFreePool(Protocol);
         *Status = NDIS_STATUS_FAILURE;
         return;
       }
@@ -724,7 +671,6 @@ NdisRegisterProtocol(
       {
         NDIS_DbgPrint(MIN_TRACE, ("Unable to query the Bind value\n"));
         ExFreePool(KeyInformation);
-        ExFreePool(Protocol);
         *Status = NDIS_STATUS_FAILURE;
         return;
       }
@@ -761,7 +707,6 @@ NdisRegisterProtocol(
         {
           NDIS_DbgPrint(MIN_TRACE, ("insufficient resources.\n"));
           ExFreePool(KeyInformation);
-          ExFreePool(Protocol);
           *Status = NDIS_STATUS_RESOURCES;
           return;
         }
@@ -778,9 +723,6 @@ NdisRegisterProtocol(
       NDIS_DbgPrint(MAX_TRACE, ("Calling protocol's BindAdapter handler with DeviceName %wZ and RegistryPath %wZ\n",
           &DeviceName, &RegistryPath));
 
-      /* XXX SD must do something with bind context */
-      *NdisProtocolHandle = Protocol;
-
         {
           BIND_HANDLER BindHandler = ProtocolCharacteristics->BindAdapterHandler;
           if(BindHandler)
@@ -788,27 +730,115 @@ NdisRegisterProtocol(
           else
             NDIS_DbgPrint(MID_TRACE, ("No protocol bind handler specified\n"));
         }
-
-      /*
-      (*(Protocol->Chars.BindAdapterHandler))(Status, BindContext, &DeviceName, &RegistryPath, 0);
-      */
-
-      if(*Status == NDIS_STATUS_SUCCESS)
-        {
-          /* Put protocol binding struct on global list */
-          ExInterlockedInsertTailList(&ProtocolListHead, &Protocol->ListEntry, &ProtocolListLock);
-        }
-      else if(*Status != NDIS_STATUS_PENDING)
-        {
-          ExFreePool(Protocol);
-          ExFreePool(KeyInformation);
-          *NdisProtocolHandle = NULL;
-          return;
-        }
     }
 
-  ExFreePool(KeyInformation);
-  *Status = NDIS_STATUS_SUCCESS;
+   *Status = NDIS_STATUS_SUCCESS;
+   ExFreePool(KeyInformation);
+}
+
+/*
+ * @implemented
+ */
+VOID
+EXPORT
+NdisRegisterProtocol(
+    OUT PNDIS_STATUS                    Status,
+    OUT PNDIS_HANDLE                    NdisProtocolHandle,
+    IN  PNDIS_PROTOCOL_CHARACTERISTICS  ProtocolCharacteristics,
+    IN  UINT                            CharacteristicsLength)
+/*
+ * FUNCTION: Registers an NDIS driver's ProtocolXxx entry points
+ * ARGUMENTS:
+ *     Status                  = Address of buffer for status information
+ *     NdisProtocolHandle      = Address of buffer for handle used to identify the driver
+ *     ProtocolCharacteristics = Pointer to NDIS_PROTOCOL_CHARACTERISTICS structure
+ *     CharacteristicsLength   = Size of structure which ProtocolCharacteristics targets
+ * NOTES:
+ *     - you *must* set NdisProtocolHandle before doing anything that could wind up
+ *       getting BindAdapterHandler, as it will probably call OpenAdapter with this handle
+ *     - the above implies that the initialization of the protocol block must be complete
+ *       by then
+ * TODO:
+ *     - break this function up - probably do a 'ndisRefreshProtocolBindings' function
+ *     - make this thing able to handle >1 protocol
+ */
+{
+  PPROTOCOL_BINDING Protocol;
+  NTSTATUS NtStatus;
+  UINT MinSize;
+
+  NDIS_DbgPrint(MAX_TRACE, ("Called.\n"));
+
+  *NdisProtocolHandle = NULL;
+
+  /* first validate the PROTOCOL_CHARACTERISTICS */
+  switch (ProtocolCharacteristics->MajorNdisVersion)
+    {
+    case 0x03:
+      /* we don't really want to support ndis3 drivers - so we complain for now */
+      NDIS_DbgPrint(MID_TRACE, ("NDIS 3 protocol attempting to register\n"));
+      MinSize = sizeof(NDIS30_PROTOCOL_CHARACTERISTICS);
+      break;
+
+    case 0x04:
+      MinSize = sizeof(NDIS40_PROTOCOL_CHARACTERISTICS);
+      break;
+
+    case 0x05:
+      MinSize = sizeof(NDIS50_PROTOCOL_CHARACTERISTICS);
+      break;
+
+    default:
+      *Status = NDIS_STATUS_BAD_VERSION;
+      NDIS_DbgPrint(MIN_TRACE, ("Incorrect characteristics size\n"));
+      return;
+    }
+
+  if (CharacteristicsLength < MinSize)
+    {
+      NDIS_DbgPrint(MIN_TRACE, ("Bad protocol characteristics.\n"));
+      *Status = NDIS_STATUS_BAD_CHARACTERISTICS;
+      return;
+    }
+
+  /* set up the protocol block */
+  Protocol = ExAllocatePool(NonPagedPool, sizeof(PROTOCOL_BINDING));
+  if (!Protocol)
+    {
+      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+      *Status = NDIS_STATUS_RESOURCES;
+      return;
+    }
+
+  RtlZeroMemory(Protocol, sizeof(PROTOCOL_BINDING));
+  RtlCopyMemory(&Protocol->Chars, ProtocolCharacteristics, MinSize);
+
+  NtStatus = RtlUpcaseUnicodeString(&Protocol->Chars.Name, &ProtocolCharacteristics->Name, TRUE);
+  if (!NT_SUCCESS(NtStatus))
+    {
+      NDIS_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
+      ExFreePool(Protocol);
+      *Status = NDIS_STATUS_RESOURCES;
+      return;
+    }
+
+  KeInitializeSpinLock(&Protocol->Lock);
+
+  InitializeListHead(&Protocol->AdapterListHead);
+
+  /* We must set this before the call to ndisBindMiniportsToProtocol because the protocol's 
+   * BindAdapter handler might need it */
+
+  *NdisProtocolHandle = Protocol;
+
+  ndisBindMiniportsToProtocol(Status, &Protocol->Chars);
+
+  if (*Status == NDIS_STATUS_SUCCESS) {
+      ExInterlockedInsertTailList(&ProtocolListHead, &Protocol->ListEntry, &ProtocolListLock);
+  } else {
+      ExFreePool(Protocol);
+      *NdisProtocolHandle = NULL;
+  }
 }
 
 
@@ -917,4 +947,17 @@ NdisTransferData(
                               BytesTransferred);
 }
 
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+NdisReEnumerateProtocolBindings(IN NDIS_HANDLE NdisProtocolHandle)
+{
+    PPROTOCOL_BINDING Protocol = NdisProtocolHandle;
+    NDIS_STATUS NdisStatus;
+
+    ndisBindMiniportsToProtocol(&NdisStatus, &Protocol->Chars);
+}
+
 /* EOF */

drivers/network/ndis/ndis/stubs.c

@@ -1063,7 +1063,3 @@ NdisScheduleWorkItem(
     ExQueueWorkItem(pntWorkItem, CriticalWorkQueue);
     return NDIS_STATUS_SUCCESS;
 }
-
-
-
-/* EOF */

drivers/network/tcpip/datalink/lan.c

@@ -10,9 +10,6 @@
 
 #include "precomp.h"
 
-/* Define this to bugcheck on double complete */
-/* #define BREAK_ON_DOUBLE_COMPLETE */
-
 UINT TransferDataCalled = 0;
 UINT TransferDataCompleteCalled = 0;
 UINT LanReceiveWorkerCalled = 0;
@@ -51,54 +48,6 @@ BOOLEAN ProtocolRegistered     = FALSE;
 LIST_ENTRY AdapterListHead;
 KSPIN_LOCK AdapterListLock;
 
-/* Double complete protection */
-KSPIN_LOCK LanSendCompleteLock;
-LIST_ENTRY LanSendCompleteList;
-
-VOID LanChainCompletion( PLAN_ADAPTER Adapter, PNDIS_PACKET NdisPacket ) {
-    PLAN_WQ_ITEM PendingCompletion =
-	ExAllocatePool( NonPagedPool, sizeof(LAN_WQ_ITEM) );
-
-    if( !PendingCompletion ) return;
-
-    PendingCompletion->Packet  = NdisPacket;
-    PendingCompletion->Adapter = Adapter;
-
-    ExInterlockedInsertTailList( &LanSendCompleteList,
-				 &PendingCompletion->ListEntry,
-				 &LanSendCompleteLock );
-}
-
-BOOLEAN LanShouldComplete( PLAN_ADAPTER Adapter, PNDIS_PACKET NdisPacket ) {
-    PLIST_ENTRY ListEntry;
-    PLAN_WQ_ITEM CompleteEntry;
-    KIRQL OldIrql;
-
-    KeAcquireSpinLock( &LanSendCompleteLock, &OldIrql );
-    for( ListEntry = LanSendCompleteList.Flink;
-	 ListEntry != &LanSendCompleteList;
-	 ListEntry = ListEntry->Flink ) {
-	CompleteEntry = CONTAINING_RECORD(ListEntry, LAN_WQ_ITEM, ListEntry);
-
-	if( CompleteEntry->Adapter == Adapter &&
-	    CompleteEntry->Packet  == NdisPacket ) {
-	    RemoveEntryList( ListEntry );
-	    KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
-	    ExFreePool( CompleteEntry );
-	    return TRUE;
-	}
-    }
-    KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
-
-    DbgPrint("NDIS completed the same send packet twice "
-	     "(Adapter %x Packet %x)!!\n", Adapter, NdisPacket);
-#ifdef BREAK_ON_DOUBLE_COMPLETE
-    KeBugCheck(0);
-#endif
-
-    return FALSE;
-}
-
 NDIS_STATUS NDISCall(
     PLAN_ADAPTER Adapter,
     NDIS_REQUEST_TYPE Type,
@@ -283,13 +232,11 @@ VOID STDCALL ProtocolSendComplete(
  */
 {
     TI_DbgPrint(DEBUG_DATALINK, ("Calling completion routine\n"));
-    if( LanShouldComplete( (PLAN_ADAPTER)BindingContext, Packet ) ) {
-	ASSERT_KM_POINTER(Packet);
-	ASSERT_KM_POINTER(PC(Packet));
-	ASSERT_KM_POINTER(PC(Packet)->DLComplete);
-	(*PC(Packet)->DLComplete)( PC(Packet)->Context, Packet, Status);
-	TI_DbgPrint(DEBUG_DATALINK, ("Finished\n"));
-    }
+    ASSERT_KM_POINTER(Packet);
+    ASSERT_KM_POINTER(PC(Packet));
+    ASSERT_KM_POINTER(PC(Packet)->DLComplete);
+    (*PC(Packet)->DLComplete)( PC(Packet)->Context, Packet, Status);
+    TI_DbgPrint(DEBUG_DATALINK, ("Finished\n"));
 }
 
 VOID LanReceiveWorker( PVOID Context ) {
@@ -628,6 +575,11 @@ VOID LANTransmit(
 		("Called( NdisPacket %x, Offset %d, Adapter %x )\n",
 		 NdisPacket, Offset, Adapter));
 
+    if (Adapter->State != LAN_STATE_STARTED) {
+        ProtocolSendComplete(Context, NdisPacket, NDIS_STATUS_NOT_ACCEPTED);
+        return;
+    }
+
     TI_DbgPrint(DEBUG_DATALINK,
 		("Adapter Address [%02x %02x %02x %02x %02x %02x]\n",
 		 Adapter->HWAddress[0] & 0xff,
@@ -641,9 +593,6 @@ VOID LANTransmit(
      * not needed immediately */
     GetDataPtr( NdisPacket, 0, &Data, &Size );
 
-    LanChainCompletion( Adapter, NdisPacket );
-
-    if (Adapter->State == LAN_STATE_STARTED) {
         switch (Adapter->Media) {
         case NdisMedium802_3:
             EHeader = (PETH_HEADER)Data;
@@ -713,9 +662,6 @@ VOID LANTransmit(
 	 * the situation with IRPs. */
         if (NdisStatus != NDIS_STATUS_PENDING)
             ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NdisStatus);
-    } else {
-        ProtocolSendComplete((NDIS_HANDLE)Context, NdisPacket, NDIS_STATUS_CLOSED);
-    }
 }
 
 static NTSTATUS
@@ -757,7 +703,7 @@ static NTSTATUS ReadStringFromRegistry( HANDLE RegHandle,
     UnicodeString.MaximumLength = Information->DataLength;
 
     String->Buffer =
-	(PWCHAR)exAllocatePool( NonPagedPool,
+	(PWCHAR)ExAllocatePool( NonPagedPool,
 				UnicodeString.MaximumLength + sizeof(WCHAR) );
 
     if( !String->Buffer ) return STATUS_NO_MEMORY;
@@ -964,7 +910,6 @@ BOOLEAN BindAdapter(
     IP_ADDRESS DefaultMask = { 0 };
     ULONG Lookahead = LOOKAHEAD_SIZE;
     NTSTATUS Status;
-    HANDLE RegHandle = 0;
 
     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 
@@ -1007,16 +952,10 @@ BOOLEAN BindAdapter(
 
     GetName( RegistryPath, &IF->Name );
 
-    Status = OpenRegistryKey( RegistryPath, &RegHandle );
+    Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description );
 
-    if(NT_SUCCESS(Status)) {
-	Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description );
-        TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n",
-                    &IF->Description));
-    } else {
-	IPDestroyInterface( IF );
-	return FALSE;
-    }
+    TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n",
+                &IF->Description));
 
     DefaultMask.Type = IP_ADDRESS_V4;
 
@@ -1052,6 +991,7 @@ BOOLEAN BindAdapter(
 
     if (NdisStatus != NDIS_STATUS_SUCCESS) {
         TI_DbgPrint(DEBUG_DATALINK, ("Could not set packet filter (0x%X).\n", NdisStatus));
+        IPUnregisterInterface(IF);
         IPDestroyInterface(IF);
         return FALSE;
     }
@@ -1386,24 +1326,4 @@ VOID LANUnregisterProtocol(
     }
 }
 
-VOID LANStartup() {
-    InitializeListHead( &LanSendCompleteList );
-    KeInitializeSpinLock( &LanSendCompleteLock );
-}
-
-VOID LANShutdown() {
-    KIRQL OldIrql;
-    PLAN_WQ_ITEM WorkItem;
-    PLIST_ENTRY ListEntry;
-
-    KeAcquireSpinLock( &LanSendCompleteLock, &OldIrql );
-    while( !IsListEmpty( &LanSendCompleteList ) ) {
-	ListEntry = RemoveHeadList( &LanSendCompleteList );
-	WorkItem = CONTAINING_RECORD(ListEntry, LAN_WQ_ITEM, ListEntry);
-	FreeNdisPacket( WorkItem->Packet );
-	ExFreePool( WorkItem );
-    }
-    KeReleaseSpinLock( &LanSendCompleteLock, OldIrql );
-}
-
 /* EOF */

drivers/network/tcpip/include/bug.h

@@ -1,6 +0,0 @@
-#ifndef _TCPIP_BUG_H
-#define _TCPIP_BUG_H
-
-VOID TcpipBugCheck( ULONG BugCode );
-
-#endif/*_TCPIP_BUG_H*/

drivers/network/tcpip/include/irp.h

@@ -10,10 +10,4 @@
 VOID IRPRemember( PIRP Irp, PCHAR File, UINT Line );
 NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status );
 
-#ifdef MEMTRACK
-#define RIRP(x) IRPRemember(x,__FILE__,__LINE__)
-#else
-#define RIRP(x)
-#endif
-
 #endif/*__IRP_H*/

drivers/network/tcpip/include/memtrack.h

@@ -10,18 +10,18 @@
 #define FBSD_MALLOC FOURCC('d','s','b','f')
 #define EXALLOC_TAG FOURCC('E','x','A','l')
 #define IRP_TAG     FOURCC('P','I','R','P')
+#define NPLOOK_TAG  FOURCC('N','P','L','A')
 
 #define AllocatePacketWithBuffer(x,y,z) AllocatePacketWithBufferX(x,y,z,__FILE__,__LINE__)
 #define FreeNdisPacket(x) FreeNdisPacketX(x,__FILE__,__LINE__)
 
-#ifdef MEMTRACK
+#ifdef DBG
 #define MTMARK() TrackDumpFL(__FILE__, __LINE__)
 #define exAllocatePool(x,y) ExAllocatePoolX(x,y,__FILE__,__LINE__)
 #define exAllocatePoolWithTag(x,y,z) ExAllocatePoolX(x,y,__FILE__,__LINE__)
 #define exFreePool(x) ExFreePoolX(x,__FILE__,__LINE__)
-
-extern LIST_ENTRY AllocatedObjectsHead;
-extern KSPIN_LOCK AllocatedObjectsLock;
+#define exAllocateFromNPagedLookasideList(x) ExAllocateFromNPagedLookasideListX(x,__FILE__,__LINE__)
+#define exFreeToNPagedLookasideList(x,y) ExFreeToNPagedLookasideListX(x,y,__FILE__,__LINE__)
 
 typedef struct _ALLOCATION_TRACKER {
     LIST_ENTRY Entry;
@@ -34,20 +34,32 @@ typedef struct _ALLOCATION_TRACKER {
 VOID TrackingInit();
 VOID TrackWithTag( DWORD Tag, PVOID Thing, PCHAR File, DWORD Line );
 #define Track(Tag,Thing) TrackWithTag(Tag,Thing,__FILE__,__LINE__)
-VOID UntrackFL( PCHAR File, DWORD Line, PVOID Thing );
+VOID UntrackFL( PCHAR File, DWORD Line, PVOID Thing, DWORD Tag );
 #define Untrack(Thing) UntrackFL(__FILE__,__LINE__,Thing)
 VOID TrackDumpFL( PCHAR File, DWORD Line );
 #define TrackDump() TrackDumpFL(__FILE__,__LINE__)
 VOID TrackTag( DWORD Tag );
 
+static __inline PVOID ExAllocateFromNPagedLookasideListX( PNPAGED_LOOKASIDE_LIST List, PCHAR File, ULONG Line ) {
+    PVOID Out = ExAllocateFromNPagedLookasideList( List );
+    if( Out ) TrackWithTag( NPLOOK_TAG, Out, File, Line );
+    return Out;
+}
+
+static __inline VOID ExFreeToNPagedLookasideListX( PNPAGED_LOOKASIDE_LIST List, PVOID Thing, PCHAR File, ULONG Line ) {
+    UntrackFL(File, Line, Thing, NPLOOK_TAG);
+    ExFreeToNPagedLookasideList( List, Thing );
+}
+
 static __inline PVOID ExAllocatePoolX( POOL_TYPE type, SIZE_T size, PCHAR File, ULONG Line ) {
-    PVOID Out = PoolAllocateBuffer( size );
+    PVOID Out = ExAllocatePool( type, size );
     if( Out ) TrackWithTag( EXALLOC_TAG, Out, File, Line );
     return Out;
 }
+
 static __inline VOID ExFreePoolX( PVOID Data, PCHAR File, ULONG Line ) {
-    UntrackFL(File, Line, Data);
-    PoolFreeBuffer(Data);
+    UntrackFL(File, Line, Data, EXALLOC_TAG);
+    ExFreePool( Data );
 }
 
 #define MEMTRACK_MAX_TAGS_TO_TRACK 64
@@ -59,10 +71,12 @@ static __inline VOID ExFreePoolX( PVOID Data, PCHAR File, ULONG Line ) {
 #define Untrack(x)
 #define TrackTag(x)
 #define exAllocatePoolWithTag(x,y,z) ExAllocatePoolWithTag(x,y,z)
-#define exAllocatePool(x,y) PoolAllocateBuffer(y)
-#define exFreePool(x) PoolFreeBuffer(x)
+#define exAllocatePool(x,y) ExAllocatePool(x,y)
+#define exFreePool(x) ExFreePool(x)
+#define exAllocateFromNPagedLookasideList(x) ExAllocateFromNPagedLookasideList(x)
+#define exFreeToNPagedLookasideList(x,y) ExFreeToNPagedLookasideList(x,y)
 #define TrackWithTag(w,x,y,z)
-#define UntrackFL(x,y,z)
+#define UntrackFL(w,x,y,z)
 #endif
 
 #endif/*MEMMTRAC_H*/

drivers/network/tcpip/include/pool.h

@@ -7,16 +7,6 @@
 #ifndef __POOL_H
 #define __POOL_H
 
-
-PVOID PoolAllocateBuffer(
-    ULONG Size);
-
-VOID PoolFreeBuffer(
-    PVOID Buffer);
-
-PVOID TcpipAllocateFromNPagedLookasideList( PNPAGED_LOOKASIDE_LIST List );
-VOID TcpipFreeToNPagedLookasideList( PNPAGED_LOOKASIDE_LIST List,
-				     PVOID Thing );
 NDIS_STATUS PrependPacket( PNDIS_PACKET Packet, PCHAR Data, UINT Len,
 			   BOOLEAN Copy );
 

drivers/network/tcpip/include/ports.h

@@ -16,7 +16,6 @@ typedef struct _PORT_SET {
     PVOID ProtoBitBuffer;
     UINT StartingPort;
     UINT PortsToOversee;
-    UINT LastAllocatedPort;
     FAST_MUTEX Mutex;
 } PORT_SET, *PPORT_SET;
 

drivers/network/tcpip/include/precomp.h

@@ -32,7 +32,6 @@
 #include <fileobjs.h>
 #include <lock.h>
 #include <wait.h>
-#include <bug.h>
 #include <memtrack.h>
 #include <oskittcp.h>
 #include <interface.h>

drivers/network/tcpip/tcpip.rbuild

@@ -24,7 +24,6 @@
 	</directory>
 	<directory name="tcpip">
 		<file>buffer.c</file>
-		<file>bug.c</file>
 		<file>dispatch.c</file>
 		<file>fileobjs.c</file>
 		<file>iinfo.c</file>
@@ -33,7 +32,6 @@
 		<file>lock.c</file>
 		<file>main.c</file>
 		<file>ninfo.c</file>
-		<file>pool.c</file>
 		<file>proto.c</file>
 		<file>tinfo.c</file>
 		<file>wait.c</file>

drivers/network/tcpip/tcpip/buffer.c

@@ -318,7 +318,7 @@ NDIS_STATUS PrependPacket( PNDIS_PACKET Packet, PCHAR Data, UINT Length,
     PCHAR NewBuf;
 
     if( Copy ) {
-	NewBuf = ExAllocatePool( NonPagedPool, Length );
+	NewBuf = exAllocatePool( NonPagedPool, Length );
 	if( !NewBuf ) return NDIS_STATUS_RESOURCES;
 	RtlCopyMemory( NewBuf, Data, Length );
     } else NewBuf = Data;
@@ -350,25 +350,21 @@ NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket,
     NDIS_STATUS Status;
     PCHAR NewData;
 
-    NewData = ExAllocatePool( NonPagedPool, Len );
+    NewData = exAllocatePool( NonPagedPool, Len );
     if( !NewData ) return NDIS_STATUS_RESOURCES;
-    TrackWithTag(EXALLOC_TAG, NewData, File, Line);
 
     if( Data ) RtlCopyMemory(NewData, Data, Len);
 
     NdisAllocatePacket( &Status, &Packet, GlobalPacketPool );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	UntrackFL( File, Line, NewData );
-	ExFreePool( NewData );
+	exFreePool( NewData );
 	return Status;
     }
     TrackWithTag(NDIS_PACKET_TAG, Packet, File, Line);
 
     NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	UntrackFL( File, Line, NewData );
-	ExFreePool( NewData );
-	UntrackFL( File, Line, Packet );
+	exFreePool( NewData );
 	FreeNdisPacket( Packet );
 	return Status;
     }
@@ -404,14 +400,13 @@ VOID FreeNdisPacketX
         NdisGetNextBuffer(Buffer, &NextBuffer);
         NdisQueryBuffer(Buffer, &Data, &Length);
 	TI_DbgPrint(DEBUG_PBUFFER, ("Freeing ndis buffer (0x%X)\n", Buffer));
-	UntrackFL(File,Line,Buffer);
+	UntrackFL(File,Line,Buffer,NDIS_BUFFER_TAG);
         NdisFreeBuffer(Buffer);
 	TI_DbgPrint(DEBUG_PBUFFER, ("Freeing exal buffer (0x%X)\n", Data));
-	UntrackFL(File,Line,Data);
-        ExFreePool(Data);
+        exFreePool(Data);
     }
 
     /* Finally free the NDIS packet discriptor */
-    UntrackFL(File,Line,Packet);
+    UntrackFL(File,Line,Packet,NDIS_PACKET_TAG);
     NdisFreePacket(Packet);
 }

drivers/network/tcpip/tcpip/bug.c

@@ -1,11 +0,0 @@
-/*
- * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     ReactOS TCP/IP protocol driver
- * FILE:        tcpip/bug.c
- * PURPOSE:     Bugcheck
- * PROGRAMMERS: Art Yerkes
- * REVISIONS:
- */
-#include "precomp.h"
-
-VOID TcpipBugCheck( ULONG BugCode ) { KeBugCheck( BugCode ); }

drivers/network/tcpip/tcpip/dispatch.c

@@ -27,12 +27,17 @@ NTSTATUS DispPrepareIrpForCancel(
  */
 {
     KIRQL OldIrql;
+    PIO_STACK_LOCATION IrpSp;
+    PTRANSPORT_CONTEXT TransContext;
 
     TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
 
+    IrpSp       = IoGetCurrentIrpStackLocation(Irp);
+    TransContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
+
     IoAcquireCancelSpinLock(&OldIrql);
 
-    if (!Irp->Cancel) {
+    if (!Irp->Cancel && !TransContext->CancelIrps) {
         (void)IoSetCancelRoutine(Irp, CancelRoutine);
         IoReleaseCancelSpinLock(OldIrql);
 
@@ -50,7 +55,7 @@ NTSTATUS DispPrepareIrpForCancel(
 
     TI_DbgPrint(DEBUG_IRP, ("Leaving (IRP was already cancelled).\n"));
 
-    return IRPFinish(Irp, STATUS_CANCELLED);
+    return Irp->IoStatus.Status;
 }
 
 VOID DispDataRequestComplete(
@@ -101,7 +106,7 @@ VOID DispDataRequestComplete(
 			    Irp->IoStatus.Information));
     TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
 
-    IRPFinish(Irp, Irp->IoStatus.Status);
+    IRPFinish(Irp, Status);
 
     TI_DbgPrint(DEBUG_IRP, ("Done Completing IRP\n"));
 }
@@ -176,11 +181,11 @@ VOID NTAPI DispCancelRequest(
 
 	TCPRemoveIRP( TranContext->Handle.ConnectionContext, Irp );
 
+	IoReleaseCancelSpinLock(Irp->CancelIrql);
+
 	if( !ChewCreate( &WorkItem, sizeof(DISCONNECT_TYPE),
 			 DispDoDisconnect, &DisType ) )
 	    ASSERT(0);
-
-	IoReleaseCancelSpinLock(Irp->CancelIrql);
         return;
 
     case TDI_SEND_DATAGRAM:
@@ -188,6 +193,8 @@ VOID NTAPI DispCancelRequest(
             TI_DbgPrint(MIN_TRACE, ("TDI_SEND_DATAGRAM, but no address file.\n"));
             break;
         }
+
+        DGRemoveIRP(TranContext->Handle.AddressHandle, Irp);
         break;
 
     case TDI_RECEIVE_DATAGRAM:
@@ -205,7 +212,7 @@ VOID NTAPI DispCancelRequest(
     }
 
     IoReleaseCancelSpinLock(Irp->CancelIrql);
-    IoCompleteRequest(Irp, IO_NO_INCREMENT);
+    IRPFinish(Irp, STATUS_CANCELLED);
 
     TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }
@@ -249,7 +256,8 @@ VOID NTAPI DispCancelListenRequest(
 
     IoReleaseCancelSpinLock(Irp->CancelIrql);
 
-    DispDataRequestComplete(Irp, STATUS_CANCELLED, 0);
+    Irp->IoStatus.Information = 0;
+    IRPFinish(Irp, STATUS_CANCELLED);
 
     TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }
@@ -384,16 +392,20 @@ NTSTATUS DispTdiConnect(
 
   /* Get associated connection endpoint file object. Quit if none exists */
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   TranContext = IrpSp->FileObject->FsContext;
   if (!TranContext) {
     TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-    return STATUS_INVALID_CONNECTION;
+    Status = STATUS_INVALID_CONNECTION;
+    goto done;
   }
 
   Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
   if (!Connection) {
     TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
-    return STATUS_INVALID_CONNECTION;
+    Status = STATUS_INVALID_CONNECTION;
+    goto done;
   }
 
   Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
@@ -405,6 +417,14 @@ NTSTATUS DispTdiConnect(
       DispDataRequestComplete,
       Irp );
 
+done:
+  if (Status != STATUS_PENDING) {
+      DispDataRequestComplete(Irp, Status, 0);
+  } else
+      IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
   TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
 
   return Status;
@@ -473,18 +493,22 @@ NTSTATUS DispTdiDisconnect(
   IrpSp = IoGetCurrentIrpStackLocation(Irp);
   DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters;
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   /* Get associated connection endpoint file object. Quit if none exists */
 
   TranContext = IrpSp->FileObject->FsContext;
   if (!TranContext) {
     TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-    return STATUS_INVALID_CONNECTION;
+    Status = STATUS_INVALID_CONNECTION;
+    goto done;
   }
 
   Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
   if (!Connection) {
     TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
-    return STATUS_INVALID_CONNECTION;
+    Status = STATUS_INVALID_CONNECTION;
+    goto done;
   }
 
   Status = TCPDisconnect(
@@ -495,7 +519,15 @@ NTSTATUS DispTdiDisconnect(
       DispDataRequestComplete,
       Irp );
 
-  TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
+done:
+   if (Status != STATUS_PENDING) {
+       DispDataRequestComplete(Irp, Status, 0);
+   } else
+       IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
+  TI_DbgPrint(MAX_TRACE, ("TCP Disconnect returned %08x\n", Status));
 
   return Status;
 }
@@ -523,18 +555,22 @@ NTSTATUS DispTdiListen(
 
   /* Get associated connection endpoint file object. Quit if none exists */
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   TranContext = IrpSp->FileObject->FsContext;
   if (TranContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
   if (Connection == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
@@ -588,6 +624,14 @@ NTSTATUS DispTdiListen(
 	    Irp );
   }
 
+done:
+  if (Status != STATUS_PENDING) {
+      DispDataRequestComplete(Irp, Status, 0);
+  } else
+      IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
   TI_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
 
   return Status;
@@ -731,24 +775,28 @@ NTSTATUS DispTdiReceive(
   PTDI_REQUEST_KERNEL_RECEIVE ReceiveInfo;
   PTRANSPORT_CONTEXT TranContext;
   NTSTATUS Status;
-  ULONG BytesReceived;
+  ULONG BytesReceived = 0;
 
   TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
 
   IrpSp = IoGetCurrentIrpStackLocation(Irp);
   ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters);
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   TranContext = IrpSp->FileObject->FsContext;
   if (TranContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   if (TranContext->Handle.ConnectionContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   /* Initialize a receive request */
@@ -760,9 +808,6 @@ NTSTATUS DispTdiReceive(
   TI_DbgPrint(MID_TRACE,("TCPIP<<< Got an MDL: %x\n", Irp->MdlAddress));
   if (NT_SUCCESS(Status))
     {
-      /* Lock here so we're sure we've got the following 'mark pending' */
-      TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-
       Status = TCPReceiveData(
 	  TranContext->Handle.ConnectionContext,
 	  (PNDIS_BUFFER)Irp->MdlAddress,
@@ -771,16 +816,16 @@ NTSTATUS DispTdiReceive(
 	  ReceiveInfo->ReceiveFlags,
 	  DispDataRequestComplete,
 	  Irp);
-      if (Status != STATUS_PENDING)
-      {
-          DispDataRequestComplete(Irp, Status, BytesReceived);
-      } else {
-	  IoMarkIrpPending(Irp);
-      }
-
-      TcpipRecursiveMutexLeave( &TCPLock );
     }
 
+done:
+  if (Status != STATUS_PENDING) {
+      DispDataRequestComplete(Irp, Status, BytesReceived);
+  } else
+      IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
 
   return Status;
@@ -802,18 +847,21 @@ NTSTATUS DispTdiReceiveDatagram(
   PTRANSPORT_CONTEXT TranContext;
   TDI_REQUEST Request;
   NTSTATUS Status;
-  ULONG BytesReceived;
+  ULONG BytesReceived = 0;
 
   TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
 
   IrpSp     = IoGetCurrentIrpStackLocation(Irp);
   DgramInfo = (PTDI_REQUEST_KERNEL_RECEIVEDG)&(IrpSp->Parameters);
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   TranContext = IrpSp->FileObject->FsContext;
   if (TranContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-      return STATUS_INVALID_ADDRESS;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   /* Initialize a receive request */
@@ -846,12 +894,16 @@ NTSTATUS DispTdiReceiveDatagram(
 	  (PDATAGRAM_COMPLETION_ROUTINE)DispDataRequestComplete,
 	  Irp,
           Irp);
-      if (Status != STATUS_PENDING) {
-          DispDataRequestComplete(Irp, Status, BytesReceived);
-      } else
-	  IoMarkIrpPending(Irp);
     }
 
+done:
+   if (Status != STATUS_PENDING) {
+       DispDataRequestComplete(Irp, Status, BytesReceived);
+   } else
+       IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
 
   return Status;
@@ -872,24 +924,28 @@ NTSTATUS DispTdiSend(
   PTDI_REQUEST_KERNEL_SEND SendInfo;
   PTRANSPORT_CONTEXT TranContext;
   NTSTATUS Status;
-  ULONG BytesSent;
+  ULONG BytesSent = 0;
 
   TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
 
   IrpSp = IoGetCurrentIrpStackLocation(Irp);
   SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters);
 
+  TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
   TranContext = IrpSp->FileObject->FsContext;
   if (TranContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   if (TranContext->Handle.ConnectionContext == NULL)
     {
       TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
-      return STATUS_INVALID_CONNECTION;
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
     }
 
   Status = DispPrepareIrpForCancel(
@@ -914,13 +970,16 @@ NTSTATUS DispTdiSend(
 	    SendInfo->SendFlags,
 	    DispDataRequestComplete,
 	    Irp);
-	if (Status != STATUS_PENDING)
-	{
-	    DispDataRequestComplete(Irp, Status, BytesSent);
-	} else
-	    IoMarkIrpPending( Irp );
     }
 
+done:
+   if (Status != STATUS_PENDING) {
+       DispDataRequestComplete(Irp, Status, BytesSent);
+   } else
+       IoMarkIrpPending(Irp);
+
+  TcpipRecursiveMutexLeave( &TCPLock );
+
   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
 
   return Status;
@@ -947,7 +1006,16 @@ NTSTATUS DispTdiSendDatagram(
 
     IrpSp       = IoGetCurrentIrpStackLocation(Irp);
     DgramInfo   = (PTDI_REQUEST_KERNEL_SENDDG)&(IrpSp->Parameters);
+
+    TcpipRecursiveMutexEnter( &TCPLock, TRUE );
+
     TranContext = IrpSp->FileObject->FsContext;
+    if (TranContext == NULL)
+    {
+      TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
+      Status = STATUS_INVALID_CONNECTION;
+      goto done;
+    }
 
     /* Initialize a send request */
     Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
@@ -984,13 +1052,16 @@ NTSTATUS DispTdiSendDatagram(
                 &Irp->IoStatus.Information);
         else
             Status = STATUS_UNSUCCESSFUL;
-
-        if (Status != STATUS_PENDING) {
-            DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information);
-        } else
-	    IoMarkIrpPending( Irp );
     }
 
+done:
+    if (Status != STATUS_PENDING) {
+        DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information);
+    } else
+        IoMarkIrpPending(Irp);
+
+    TcpipRecursiveMutexLeave( &TCPLock );
+
     TI_DbgPrint(DEBUG_IRP, ("Leaving.\n"));
 
     return Status;
@@ -1211,7 +1282,7 @@ VOID DispTdiQueryInformationExComplete(
     QueryContext->Irp->IoStatus.Information = ByteCount;
     QueryContext->Irp->IoStatus.Status      = Status;
 
-    ExFreePool(QueryContext);
+    exFreePool(QueryContext);
 }
 
 
@@ -1274,7 +1345,7 @@ NTSTATUS DispTdiQueryInformationEx(
             IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
         OutputBuffer = Irp->UserBuffer;
 
-        QueryContext = ExAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
+        QueryContext = exAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
         if (QueryContext) {
 	    _SEH_TRY {
                 InputMdl = IoAllocateMdl(InputBuffer,
@@ -1337,7 +1408,7 @@ NTSTATUS DispTdiQueryInformationEx(
                 IoFreeMdl(OutputMdl);
             }
 
-            ExFreePool(QueryContext);
+            exFreePool(QueryContext);
         } else
             Status = STATUS_INSUFFICIENT_RESOURCES;
     } else if( InputBufferLength ==
@@ -1350,7 +1421,7 @@ NTSTATUS DispTdiQueryInformationEx(
 
 	Size = 0;
 
-        QueryContext = ExAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
+        QueryContext = exAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
         if (!QueryContext) return STATUS_INSUFFICIENT_RESOURCES;
 
 	_SEH_TRY {
@@ -1370,7 +1441,7 @@ NTSTATUS DispTdiQueryInformationEx(
 
 	if( !NT_SUCCESS(Status) || !InputMdl ) {
 	    if( InputMdl ) IoFreeMdl( InputMdl );
-	    ExFreePool(QueryContext);
+	    exFreePool(QueryContext);
 	    return Status;
 	}
 
@@ -1439,7 +1510,7 @@ NTSTATUS DispTdiSetInformationEx(
 
         TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
 
-        return IRPFinish(Irp, STATUS_INVALID_PARAMETER);
+        return Irp->IoStatus.Status;
     }
 
     Status = DispPrepareIrpForCancel(TranContext, Irp, NULL);
@@ -1483,6 +1554,7 @@ NTSTATUS DispTdiSetIPAddress( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
             IF->Unicast.Address.IPv4Address = IpAddrChange->Address;
             IF->Netmask.Type = IP_ADDRESS_V4;
             IF->Netmask.Address.IPv4Address = IpAddrChange->Netmask;
+            IF->Broadcast.Type = IP_ADDRESS_V4;
 	    IF->Broadcast.Address.IPv4Address =
 		IF->Unicast.Address.IPv4Address |
 		~IF->Netmask.Address.IPv4Address;
@@ -1517,6 +1589,8 @@ NTSTATUS DispTdiDeleteIPAddress( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
             IF->Unicast.Address.IPv4Address = 0;
             IF->Netmask.Type = IP_ADDRESS_V4;
             IF->Netmask.Address.IPv4Address = 0;
+            IF->Broadcast.Type = IP_ADDRESS_V4;
+            IF->Broadcast.Address.IPv4Address = 0;
             Status = STATUS_SUCCESS;
         }
     } EndFor(IF);

drivers/network/tcpip/tcpip/fileobjs.c

@@ -123,7 +123,7 @@ VOID AddrFileFree(
  *     Object = Pointer to address file object to free
  */
 {
-    ExFreePool(Object);
+    exFreePool(Object);
 }
 
 
@@ -135,7 +135,7 @@ VOID ControlChannelFree(
  *     Object = Pointer to address file object to free
  */
 {
-    ExFreePool(Object);
+    exFreePool(Object);
 }
 
 
@@ -190,7 +190,7 @@ VOID DeleteAddress(PADDRESS_FILE AddrFile)
     /* Abort the request and free its resources */
     TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
     (*SendRequest->Complete)(SendRequest->Context, STATUS_ADDRESS_CLOSED, 0);
-    ExFreePool(SendRequest);
+    exFreePool(SendRequest);
     TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
     CurrentEntry = NextEntry;
   }
@@ -220,7 +220,7 @@ VOID DeleteConnectionEndpoint(
   RemoveEntryList(&Connection->ListEntry);
   TcpipReleaseSpinLock(&ConnectionEndpointListLock, OldIrql);
 
-  ExFreePool(Connection);
+  TCPFreeConnectionEndpoint(Connection);
 
   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }
@@ -247,7 +247,7 @@ NTSTATUS FileOpenAddress(
 
   TI_DbgPrint(MID_TRACE, ("Called (Proto %d).\n", Protocol));
 
-  AddrFile = ExAllocatePool(NonPagedPool, sizeof(ADDRESS_FILE));
+  AddrFile = exAllocatePool(NonPagedPool, sizeof(ADDRESS_FILE));
   if (!AddrFile) {
     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
     return STATUS_INSUFFICIENT_RESOURCES;
@@ -272,7 +272,7 @@ NTSTATUS FileOpenAddress(
       Matched = AddrLocateADEv4(IPv4Address, &AddrFile->Address);
 
   if (!Matched) {
-    ExFreePool(AddrFile);
+    exFreePool(AddrFile);
     TI_DbgPrint(MIN_TRACE, ("Non-local address given (0x%X).\n", DN2H(IPv4Address)));
     return STATUS_INVALID_PARAMETER;
   }
@@ -285,6 +285,15 @@ NTSTATUS FileOpenAddress(
   case IPPROTO_TCP:
       AddrFile->Port =
           TCPAllocatePort(Address->Address[0].Address[0].sin_port);
+
+      if ((Address->Address[0].Address[0].sin_port &&
+           AddrFile->Port != Address->Address[0].Address[0].sin_port) ||
+           AddrFile->Port == 0xffff)
+      {
+          exFreePool(AddrFile);
+          return STATUS_INVALID_PARAMETER;
+      }
+
       AddrFile->Send = NULL; /* TCPSendData */
       break;
 
@@ -292,6 +301,15 @@ NTSTATUS FileOpenAddress(
       TI_DbgPrint(MID_TRACE,("Allocating udp port\n"));
       AddrFile->Port =
 	  UDPAllocatePort(Address->Address[0].Address[0].sin_port);
+
+      if ((Address->Address[0].Address[0].sin_port &&
+           AddrFile->Port != Address->Address[0].Address[0].sin_port) ||
+           AddrFile->Port == 0xffff)
+      {
+          exFreePool(AddrFile);
+          return STATUS_INVALID_PARAMETER;
+      }
+
       TI_DbgPrint(MID_TRACE,("Setting port %d (wanted %d)\n",
                              AddrFile->Port,
                              Address->Address[0].Address[0].sin_port));
@@ -369,8 +387,10 @@ NTSTATUS FileCloseAddress(
   switch (AddrFile->Protocol) {
   case IPPROTO_TCP:
     TCPFreePort( AddrFile->Port );
-    if( AddrFile->Listener )
-	TCPClose( AddrFile->Listener );
+    if( AddrFile->Listener ) {
+	    TCPClose( AddrFile->Listener );
+	    exFreePool( AddrFile->Listener );
+    }
     break;
 
   case IPPROTO_UDP:
@@ -470,20 +490,18 @@ NTSTATUS FileCloseConnection(
   PTDI_REQUEST Request)
 {
   PCONNECTION_ENDPOINT Connection;
-  NTSTATUS Status = STATUS_SUCCESS;
 
   TI_DbgPrint(MID_TRACE, ("Called.\n"));
 
   Connection = Request->Handle.ConnectionContext;
 
   TcpipRecursiveMutexEnter( &TCPLock, TRUE );
-  TCPClose(Connection);
   DeleteConnectionEndpoint(Connection);
   TcpipRecursiveMutexLeave( &TCPLock );
 
   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 
-  return Status;
+  return STATUS_SUCCESS;
 }
 
 
@@ -500,7 +518,7 @@ NTSTATUS FileOpenControlChannel(
   PCONTROL_CHANNEL ControlChannel;
   TI_DbgPrint(MID_TRACE, ("Called.\n"));
 
-  ControlChannel = ExAllocatePool(NonPagedPool, sizeof(*ControlChannel));
+  ControlChannel = exAllocatePool(NonPagedPool, sizeof(*ControlChannel));
 
   if (!ControlChannel) {
     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
@@ -540,7 +558,7 @@ NTSTATUS FileCloseControlChannel(
   PCONTROL_CHANNEL ControlChannel = Request->Handle.ControlChannel;
   NTSTATUS Status = STATUS_SUCCESS;
 
-  ExFreePool(ControlChannel);
+  exFreePool(ControlChannel);
   Request->Handle.ControlChannel = NULL;
 
   return Status;

drivers/network/tcpip/tcpip/iinfo.c

@@ -26,7 +26,7 @@ TDI_STATUS InfoTdiQueryGetInterfaceMIB(TDIEntityID *ID,
 		 Interface, IF, ID->tei_entity, ID->tei_instance));
 
     OutData =
-	(PIFENTRY)ExAllocatePool( NonPagedPool,
+	(PIFENTRY)exAllocatePool( NonPagedPool,
 				  sizeof(IFENTRY) + MAX_IFDESCR_LEN );
 
     if( !OutData ) return TDI_NO_RESOURCES; /* Out of memory */
@@ -71,7 +71,7 @@ TDI_STATUS InfoTdiQueryGetInterfaceMIB(TDIEntityID *ID,
 			    ID->tei_entity, ID->tei_instance, Size));
 
     Status = InfoCopyOut( (PCHAR)OutData, Size, Buffer, BufferSize );
-    ExFreePool( OutData );
+    exFreePool( OutData );
 
     TI_DbgPrint(DEBUG_INFO,("Returning %x\n", Status));
 
@@ -86,7 +86,7 @@ TDI_STATUS InfoTdiQueryGetArptableMIB(TDIEntityID *ID,
     DWORD NumNeighbors = NBCopyNeighbors( Interface, NULL );
     DWORD MemSize = NumNeighbors * sizeof(IPARP_ENTRY);
     PIPARP_ENTRY ArpEntries =
-	ExAllocatePoolWithTag
+	exAllocatePoolWithTag
 	( NonPagedPool, MemSize, FOURCC('A','R','P','t') );
 
     if( !ArpEntries ) return STATUS_NO_MEMORY;
@@ -94,7 +94,7 @@ TDI_STATUS InfoTdiQueryGetArptableMIB(TDIEntityID *ID,
 
     Status = InfoCopyOut( (PVOID)ArpEntries, MemSize, Buffer, BufferSize );
 
-    ExFreePool( ArpEntries );
+    exFreePool( ArpEntries );
 
     return Status;
 }

drivers/network/tcpip/tcpip/irp.c

@@ -12,9 +12,7 @@
 #include "precomp.h"
 
 VOID IRPRemember( PIRP Irp, PCHAR File, UINT Line ) {
-#ifdef MEMTRACK
     TrackWithTag( IRP_TAG, Irp, File, Line );
-#endif
 }
 
 NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status ) {
@@ -23,9 +21,7 @@ NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status ) {
 
     //DbgPrint("Called: Irp %x, Status %x Event %x\n", Irp, Status, Irp->UserEvent);
 
-#ifdef MEMTRACK
-    UntrackFL( __FILE__, __LINE__, Irp );
-#endif
+    UntrackFL( __FILE__, __LINE__, Irp, IRP_TAG );
 
     Irp->IoStatus.Status = Status;
 

drivers/network/tcpip/tcpip/lock.c

@@ -50,13 +50,12 @@ VOID TcpipRecursiveMutexInit( PRECURSIVE_MUTEX RecMutex ) {
 
 UINT TcpipRecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex, BOOL ToWrite ) {
     UINT Ret;
-    TI_DbgPrint(DEBUG_LOCK,("Locking\n"));
+    //TI_DbgPrint(DEBUG_LOCK,("Locking\n"));
     Ret = RecursiveMutexEnter( RecMutex, ToWrite );
-    TI_DbgPrint(DEBUG_LOCK,("Locked\n"));
     return Ret;
 }
 
 VOID TcpipRecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex ) {
-    TI_DbgPrint(DEBUG_LOCK,("Unlocking\n"));
+    //TI_DbgPrint(DEBUG_LOCK,("Unlocking\n"));
     RecursiveMutexLeave( RecMutex );
 }

drivers/network/tcpip/tcpip/main.c

@@ -131,7 +131,7 @@ CP
 #endif
 CP
   /* Allocate resources here. We release them again if something failed */
-  Context = ExAllocatePool(NonPagedPool, sizeof(TRANSPORT_CONTEXT));
+  Context = exAllocatePool(NonPagedPool, sizeof(TRANSPORT_CONTEXT));
   if (!Context) {
     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
     return STATUS_INSUFFICIENT_RESOURCES;
@@ -169,7 +169,7 @@ CP
 	  TI_DbgPrint(MIN_TRACE, ("AddressType: %\n",
 				  Address->Address[0].AddressType));
       }
-      PoolFreeBuffer(Context);
+      exFreePool(Context);
       return STATUS_INVALID_PARAMETER;
     }
 CP
@@ -186,12 +186,12 @@ CP
       Status = TiGetProtocolNumber(&IrpSp->FileObject->FileName, &Protocol);
       if (!NT_SUCCESS(Status)) {
         TI_DbgPrint(MIN_TRACE, ("Raw IP protocol number is invalid.\n"));
-        PoolFreeBuffer(Context);
+        exFreePool(Context);
         return STATUS_INVALID_PARAMETER;
       }
     } else {
       TI_DbgPrint(MIN_TRACE, ("Invalid device object at (0x%X).\n", DeviceObject));
-      PoolFreeBuffer(Context);
+      exFreePool(Context);
       return STATUS_INVALID_PARAMETER;
     }
 CP
@@ -213,7 +213,7 @@ CP
 
     if (EaInfo->EaValueLength < sizeof(PVOID)) {
       TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
-      PoolFreeBuffer(Context);
+      exFreePool(Context);
       return STATUS_INVALID_PARAMETER;
     }
 
@@ -221,7 +221,7 @@ CP
 
     if (DeviceObject != TCPDeviceObject) {
       TI_DbgPrint(MIN_TRACE, ("Bad device object.\n"));
-      PoolFreeBuffer(Context);
+      exFreePool(Context);
       return STATUS_INVALID_PARAMETER;
     }
 
@@ -244,7 +244,7 @@ CP
   }
 
   if (!NT_SUCCESS(Status))
-    PoolFreeBuffer(Context);
+    exFreePool(Context);
 
   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 
@@ -337,7 +337,7 @@ TiDispatchOpenClose(
   NTSTATUS Status;
   PTRANSPORT_CONTEXT Context;
 
-  RIRP(Irp);
+  IRPRemember(Irp, __FILE__, __LINE__);
 
 //  DbgPrint("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp);
 
@@ -353,7 +353,7 @@ TiDispatchOpenClose(
   case IRP_MJ_CLOSE:
     Context = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
     if (Context)
-        PoolFreeBuffer(Context);
+        exFreePool(Context);
     Status = STATUS_SUCCESS;
     break;
 
@@ -390,7 +390,7 @@ TiDispatchInternal(
   BOOL Complete = TRUE;
   PIO_STACK_LOCATION IrpSp;
 
-  RIRP(Irp);
+  IRPRemember(Irp, __FILE__, __LINE__);
 
   IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
@@ -437,6 +437,7 @@ TiDispatchInternal(
 
   case TDI_DISCONNECT:
     Status = DispTdiDisconnect(Irp);
+    Complete = FALSE;
     break;
 
   case TDI_ASSOCIATE_ADDRESS:
@@ -472,8 +473,6 @@ TiDispatchInternal(
 
   if( Complete )
       IRPFinish( Irp, Status );
-  else
-      Irp->IoStatus.Status = Status;
 
   return Status;
 }
@@ -495,7 +494,7 @@ TiDispatch(
   NTSTATUS Status;
   PIO_STACK_LOCATION IrpSp;
 
-  RIRP(Irp);
+  IRPRemember(Irp, __FILE__, __LINE__);
 
   IrpSp  = IoGetCurrentIrpStackLocation(Irp);
 
@@ -584,9 +583,6 @@ VOID STDCALL TiUnload(
   /* Shutdown network level protocol subsystem */
   IPShutdown();
 
-  /* Shutdown the lan worker */
-  LANShutdown();
-
   /* Free NDIS buffer descriptors */
   if (GlobalBufferPool)
     NdisFreeBufferPool(GlobalBufferPool);
@@ -610,7 +606,7 @@ VOID STDCALL TiUnload(
     IoDeleteDevice(IPDeviceObject);
 
   if (EntityList)
-    PoolFreeBuffer(EntityList);
+    exFreePool(EntityList);
 
   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 }
@@ -686,7 +682,8 @@ DriverEntry(
     FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject);
   if (!NT_SUCCESS(Status)) {
     TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status));
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
     return Status;
   }
 
@@ -695,7 +692,9 @@ DriverEntry(
     FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject);
   if (!NT_SUCCESS(Status)) {
     TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status));
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
     return Status;
   }
 
@@ -704,16 +703,23 @@ DriverEntry(
     FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject);
   if (!NT_SUCCESS(Status)) {
     TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status));
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
     return Status;
   }
 
   /* Setup network layer and transport layer entities */
   KeInitializeSpinLock(&EntityListLock);
-  EntityList = ExAllocatePool(NonPagedPool, sizeof(TDIEntityID) * MAX_TDI_ENTITIES );
+  EntityList = exAllocatePool(NonPagedPool, sizeof(TDIEntityID) * MAX_TDI_ENTITIES );
   if (!EntityList) {
     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
+    IoDeleteDevice(TCPDeviceObject);
     return STATUS_INSUFFICIENT_RESOURCES;
   }
 
@@ -733,14 +739,25 @@ DriverEntry(
   /* Allocate NDIS packet descriptors */
   NdisAllocatePacketPool(&NdisStatus, &GlobalPacketPool, 100, sizeof(PACKET_CONTEXT));
   if (NdisStatus != NDIS_STATUS_SUCCESS) {
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
+    IoDeleteDevice(TCPDeviceObject);
+    exFreePool(EntityList);
     return STATUS_INSUFFICIENT_RESOURCES;
   }
 
   /* Allocate NDIS buffer descriptors */
   NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 100);
   if (NdisStatus != NDIS_STATUS_SUCCESS) {
-    TiUnload(DriverObject);
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
+    IoDeleteDevice(TCPDeviceObject);
+    exFreePool(EntityList);
+    NdisFreePacketPool(GlobalPacketPool);
     return STATUS_INSUFFICIENT_RESOURCES;
   }
 
@@ -762,25 +779,49 @@ DriverEntry(
   /* Initialize transport level protocol subsystems */
   Status = RawIPStartup();
   if( !NT_SUCCESS(Status) ) {
-	TiUnload(DriverObject);
+        IPShutdown();
+        ChewShutdown();
+        IoDeleteDevice(IPDeviceObject);
+        IoDeleteDevice(RawIPDeviceObject);
+        IoDeleteDevice(UDPDeviceObject);
+        IoDeleteDevice(TCPDeviceObject);
+        exFreePool(EntityList);
+        NdisFreePacketPool(GlobalPacketPool);
+        NdisFreeBufferPool(GlobalBufferPool);
 	return Status;
   }
 
   Status = UDPStartup();
   if( !NT_SUCCESS(Status) ) {
-	TiUnload(DriverObject);
+        RawIPShutdown();
+        IPShutdown();
+        ChewShutdown();
+        IoDeleteDevice(IPDeviceObject);
+        IoDeleteDevice(RawIPDeviceObject);
+        IoDeleteDevice(UDPDeviceObject);
+        IoDeleteDevice(TCPDeviceObject);
+        exFreePool(EntityList);
+        NdisFreePacketPool(GlobalPacketPool);
+        NdisFreeBufferPool(GlobalBufferPool);
 	return Status;
   }
 
   Status = TCPStartup();
   if( !NT_SUCCESS(Status) ) {
-	TiUnload(DriverObject);
+        UDPShutdown();
+        RawIPShutdown();
+        IPShutdown();
+        ChewShutdown();
+        IoDeleteDevice(IPDeviceObject);
+        IoDeleteDevice(RawIPDeviceObject);
+        IoDeleteDevice(UDPDeviceObject);
+        IoDeleteDevice(TCPDeviceObject);
+        exFreePool(EntityList);
+        NdisFreePacketPool(GlobalPacketPool);
+        NdisFreeBufferPool(GlobalBufferPool);
 	return Status;
   }
 
-  /* Initialize the lan worker */
-  LANStartup();
-
   /* Register protocol with NDIS */
   /* This used to be IP_DEVICE_NAME but the DDK says it has to match your entry in the SCM */
   Status = LANRegisterProtocol(&strNdisDeviceName);
@@ -794,15 +835,39 @@ DriverEntry(
       NULL,
       0,
       NULL);
-    TiUnload(DriverObject);
+    TCPShutdown();
+    UDPShutdown();
+    RawIPShutdown();
+    IPShutdown();
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
+    IoDeleteDevice(TCPDeviceObject);
+    exFreePool(EntityList);
+    NdisFreePacketPool(GlobalPacketPool);
+    NdisFreeBufferPool(GlobalBufferPool);
     return Status;
   }
 
   /* Open loopback adapter */
-  if (!NT_SUCCESS(LoopRegisterAdapter(NULL, NULL))) {
+  Status = LoopRegisterAdapter(NULL, NULL);
+  if (!NT_SUCCESS(Status)) {
     TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status));
-    TiUnload(DriverObject);
-    return STATUS_INSUFFICIENT_RESOURCES;
+    TCPShutdown();
+    UDPShutdown();
+    RawIPShutdown();
+    IPShutdown();
+    ChewShutdown();
+    IoDeleteDevice(IPDeviceObject);
+    IoDeleteDevice(RawIPDeviceObject);
+    IoDeleteDevice(UDPDeviceObject);
+    IoDeleteDevice(TCPDeviceObject);
+    exFreePool(EntityList);
+    NdisFreePacketPool(GlobalPacketPool);
+    NdisFreeBufferPool(GlobalBufferPool);
+    LANUnregisterProtocol();
+    return Status;
   }
 
   /* Use direct I/O */

drivers/network/tcpip/tcpip/mockbuffer.c

@@ -430,23 +430,22 @@ NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket,
     NDIS_STATUS Status;
     PCHAR NewData;
 
-    NewData = ExAllocatePool( NonPagedPool, Len );
+    NewData = exAllocatePool( NonPagedPool, Len );
     if( !NewData ) return NDIS_STATUS_NOT_ACCEPTED; // XXX
-    TrackWithTag(EXALLOC_TAG, NewData, File, Line);
 
     if( Data )
 	RtlCopyMemory(NewData, Data, Len);
 
     NdisAllocatePacket( &Status, &Packet, GlobalPacketPool );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	ExFreePool( NewData );
+	exFreePool( NewData );
 	return Status;
     }
     TrackWithTag(NDIS_PACKET_TAG, Packet, File, Line);
 
     NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len );
     if( Status != NDIS_STATUS_SUCCESS ) {
-	ExFreePool( NewData );
+	exFreePool( NewData );
 	FreeNdisPacket( Packet );
     }
     TrackWithTag(NDIS_BUFFER_TAG, Buffer, File, Line);
@@ -482,8 +481,7 @@ VOID FreeNdisPacketX
         XNdisQueryBuffer(Buffer, &Data, &Length);
 	UntrackFL(File,Line,Buffer);
         NdisFreeBuffer(Buffer);
-	UntrackFL(File,Line,Data);
-        ExFreePool(Data);
+        exFreePool(Data);
     }
 
     /* Finally free the NDIS packet discriptor */

drivers/network/tcpip/tcpip/mockbug.c

@@ -1,14 +0,0 @@
-/*
- * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     ReactOS TCP/IP protocol driver
- * FILE:        tcpip/bug.c
- * PURPOSE:     Bugcheck
- * PROGRAMMERS: Art Yerkes
- * REVISIONS:
- */
-#include "precomp.h"
-
-VOID TcpipBugCheck( ULONG BugCode ) {
-    DbgPrint("BugCheck called: %x\n", BugCode);
-    ASSERT(0);
-}

drivers/network/tcpip/tcpip/ninfo.c

@@ -21,7 +21,7 @@ TDI_STATUS InfoTdiQueryGetAddrTable( PNDIS_BUFFER Buffer,
     UINT Count = 0;
     UINT IfCount = CountInterfaces();
     PIPADDR_ENTRY IpAddress =
-	ExAllocatePool( NonPagedPool, sizeof( IPADDR_ENTRY ) * IfCount );
+	exAllocatePool( NonPagedPool, sizeof( IPADDR_ENTRY ) * IfCount );
     PIPADDR_ENTRY IpCurrent = IpAddress;
     IF_LIST_ITER(CurrentIF);
 
@@ -58,7 +58,7 @@ TDI_STATUS InfoTdiQueryGetAddrTable( PNDIS_BUFFER Buffer,
     Status = InfoCopyOut( (PCHAR)IpAddress, sizeof(*IpAddress) * IfCount,
 			  Buffer, BufferSize );
 
-    ExFreePool( IpAddress );
+    exFreePool( IpAddress );
 
     TI_DbgPrint(DEBUG_INFO, ("Returning %08x\n", Status));
 
@@ -72,17 +72,17 @@ TDI_STATUS InfoTdiQueryGetRouteTable( PNDIS_BUFFER Buffer, PUINT BufferSize ) {
     UINT RtCount = CountFIBs();
     UINT Size = sizeof( IPROUTE_ENTRY ) * RtCount;
     PFIB_ENTRY RCache =
-	ExAllocatePool( NonPagedPool, sizeof( FIB_ENTRY ) * RtCount ),
+	exAllocatePool( NonPagedPool, sizeof( FIB_ENTRY ) * RtCount ),
 	RCacheCur = RCache;
-    PIPROUTE_ENTRY RouteEntries = ExAllocatePool( NonPagedPool, Size ),
+    PIPROUTE_ENTRY RouteEntries = exAllocatePool( NonPagedPool, Size ),
 	RtCurrent = RouteEntries;
 
     TI_DbgPrint(DEBUG_INFO, ("Called, routes = %d, RCache = %08x\n",
 			    RtCount, RCache));
 
     if( !RCache || !RouteEntries ) {
-	if( RCache ) ExFreePool( RCache );
-	if( RouteEntries ) ExFreePool( RouteEntries );
+	if( RCache ) exFreePool( RCache );
+	if( RouteEntries ) exFreePool( RouteEntries );
 	return TDI_NO_RESOURCES;
     }
 
@@ -133,8 +133,8 @@ TDI_STATUS InfoTdiQueryGetRouteTable( PNDIS_BUFFER Buffer, PUINT BufferSize ) {
 
     Status = InfoCopyOut( (PCHAR)RouteEntries, Size, Buffer, BufferSize );
 
-    ExFreePool( RouteEntries );
-    ExFreePool( RCache );
+    exFreePool( RouteEntries );
+    exFreePool( RCache );
 
     TI_DbgPrint(DEBUG_INFO, ("Returning %08x\n", Status));
 

drivers/network/tcpip/tcpip/pool.c

@@ -1,68 +0,0 @@
-/*
- * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:     ReactOS TCP/IP protocol driver
- * FILE:        tcpip/pool.c
- * PURPOSE:     Routines for controling pools
- * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
- * REVISIONS:
- *   CSH 01/08-2000 Created
- */
-
-#include "precomp.h"
-
-
-PVOID PoolAllocateBuffer(
-    ULONG Size)
-/*
- * FUNCTION: Returns a buffer from the free buffer pool
- * RETURNS:
- *     Pointer to buffer, NULL if there was not enough
- *     free resources
- */
-{
-    PVOID Buffer;
-
-    /* FIXME: Get buffer from a free buffer pool with enough room */
-
-    Buffer = ExAllocatePool(NonPagedPool, Size);
-
-    TI_DbgPrint(DEBUG_MEMORY, ("Allocated (%i) bytes at (0x%X).\n", Size, Buffer));
-
-    return Buffer;
-}
-
-
-VOID PoolFreeBuffer(
-    PVOID Buffer)
-/*
- * FUNCTION: Returns a buffer to the free buffer pool
- * ARGUMENTS:
- *     Buffer = Buffer to return to free buffer pool
- */
-{
-    /* FIXME: Put buffer in free buffer pool */
-
-    TI_DbgPrint(DEBUG_MEMORY, ("Freeing buffer at (0x%X).\n", Buffer));
-
-    ExFreePool(Buffer);
-}
-
-PVOID TcpipAllocateFromNPagedLookasideList( PNPAGED_LOOKASIDE_LIST List ) {
-    PVOID Buffer;
-
-    Buffer = ExAllocateFromNPagedLookasideList( List );
-
-    TI_DbgPrint(DEBUG_MEMORY, ("Allocated from Nonpaged Lookaside List at (0x%X).\n", Buffer));
-
-    return Buffer;
-}
-
-VOID TcpipFreeToNPagedLookasideList( PNPAGED_LOOKASIDE_LIST List,
-				     PVOID Thing ) {
-
-    TI_DbgPrint(DEBUG_MEMORY, ("Freeing buffer (0x%X) to Nonpaged Lookaside List.\n", Thing));
-
-    ExFreeToNPagedLookasideList( List, Thing );
-}
-
-/* EOF */

lib/3rdparty/adns/adns_win32/README.TXT

@@ -5,9 +5,9 @@ ADNS is not officially suppoted for Windows, but this
 port provides a 100% native Windows DLL and linker
 library for the DLL - suitable for traditional compilers 
 and linkers under Windows. The library itself is ported to
-Microsot Visual C++ 6.0 SP 2.
+Microsot Visual C++ 6.0.
 
-The library is tested under Windows 2000, but should work
+The library is tested under Windows 2000 and XP, but should work
 with all versions from Windows NT 4 and up, and Windows98
 and up. Windows95 is not supported.
 
@@ -37,3 +37,32 @@ reasons for this:
 For more information about this port, see http://adns.jgaa.com
 
 
+///////////////////////////////////////////////////////
+
+October 13th 2005 jgaa: adns-1.0-win32-05
+  - Fixed a problem with the return-value from adns_inet_aton()
+    Thanks to Gerald Combs for reporting the problem.
+
+October 7th 2004 jgaa: adns-1.0-win32-03
+
+ - Fixed a problem with error-messages when the program
+   works off-line.
+   Thanks to Ulf Lamping for pointing ourt and solving the problem.
+
+
+April 4th 2004 jgaa: adns-1.0-win32-03
+
+ - Fixed broken gettimeofday() function.
+
+ - Fixed problem with TCP connections, where the librarry
+   failed to connect to DNS servers with TCP, and flooded
+   the servers with TCP connection attempts.
+ 
+ - Made sure that errno was handled corrcetly after all network
+   (winsock) calls.
+
+ - Fixed a few places where noblocking calls were not handled
+   EAGAIN and EWOULDBLOCK is not the same under Windows.
+
+
+

lib/3rdparty/adns/adns_win32/adns_unix_calls.c

@@ -1,3 +1,4 @@
+
 /*
 * adns_unix_calls.c
 * - Simple implementation of requiered UNIX system calls and
@@ -29,20 +30,20 @@
 
 #include "adns.h"
 
-int adns_writev(SOCKET FileDescriptor, const struct iovec * iov, int iovCount)
+int adns_writev(int FileDescriptor, const struct iovec * iov, int iovCount)
 {
-	int total_len = 0;
+	size_t total_len = 0;
 	int i = 0, r = 0;
 	char *buf = NULL, *p = NULL;
 
 	for(; i < iovCount; i++)
 		total_len += iov[i].iov_len;
 
-	p = buf = (char *)alloca( (size_t) total_len);
+	p = buf = (char *)alloca(total_len);
 
 	for(; i < iovCount; i++)
 	{
-		memcpy(p, iov[i].iov_base, (size_t) iov[i].iov_len);
+		memcpy(p, iov[i].iov_base, iov[i].iov_len);
 		p += iov[i].iov_len;
 	}
 
@@ -54,8 +55,21 @@ int adns_writev(SOCKET FileDescriptor, const struct iovec * iov, int iovCount)
 
 int adns_inet_aton(const char *cp, struct in_addr *inp)
 {
+    if (!cp || !*cp || !inp)
+    {
+        errno = EINVAL;
+        return -1; 
+    }
+
+    if (!strcmp(cp, "255.255.255.255"))
+    {
+        // Special case
+        inp->s_addr = INADDR_NONE;
+        return 0;
+    }
+
 	inp->s_addr = inet_addr(cp);
-	return inp->s_addr != INADDR_ANY;
+    return (inp->s_addr == INADDR_NONE) ? -1 : 0;
 }
 
 int adns_getpid()
@@ -63,35 +77,30 @@ int adns_getpid()
 	return GetCurrentProcessId();
 }
 
-/* ReactOS: Fixed gettimeofday implementation.  Was wrong by a factor of
- * 10 */
 int gettimeofday(struct timeval *tv, struct timezone *tz)
 {
-    static __int64 Adjustment;
-    __int64 Now = 0;
+	static __int64 Adjustment;
+	__int64 now = 0;
+	
+	if (!Adjustment)
+	{
+		SYSTEMTIME st = {1970,1,0,1,0,0,0};
+		SystemTimeToFileTime(&st, (LPFILETIME)&Adjustment);
+	}
+	
+	if (tz)
+	{
+		errno = EINVAL;
+		return -1;
+	}
+	
+	GetSystemTimeAsFileTime((LPFILETIME)&now);
+	now -= Adjustment;
+	
+	tv->tv_sec = (long)(now / 10000000);
+	tv->tv_usec = (long)((now % 10000000) / 10); 
 
-
-    if (!Adjustment)
-    {
-	SYSTEMTIME st = {1970,1,3,0,0,0,0};
-
-	SystemTimeToFileTime(&st, ((LPFILETIME)(VOID *)&Adjustment));
-    }
-
-    if (tz)
-    {
-	return -1;
-    }
-
-    GetSystemTimeAsFileTime(((LPFILETIME)(VOID *)&Now));
-    Now -= Adjustment;
-
-    /* 100 ns
-       .1  us
-       10 * 1000000 */
-    tv->tv_sec = (long)(Now / 10000000);
-    tv->tv_usec = (long)((Now /     10) % 1000000);
-    return 0;
+	return 0;
 }
 
 /* Memory allocated in the DLL must be freed in the dll, so

lib/3rdparty/adns/adns_win32/adns_win32.h

@@ -105,6 +105,8 @@ extern "C"
 #define EINPROGRESS WSAEINPROGRESS
 #define EMSGSIZE WSAEMSGSIZE
 #define ENOPROTOOPT WSAENOPROTOOPT
+#define ECONNRESET WSAECONNRESET
+
 //#define NONRETURNING
 //#define NONRETURNPRINTFFORMAT(si,tc)
 
@@ -129,9 +131,9 @@ struct timezone; /* XXX arty */
  * Undef ADNS_MAP_UNIXAPI in the calling code to use natve calls
  */
 ADNS_API int adns_gettimeofday(struct timeval *tv, struct timezone *tz);
-ADNS_API int adns_writev (SOCKET FileDescriptor, const struct iovec * iov, int iovCount);
+ADNS_API int adns_writev (int FileDescriptor, const struct iovec * iov, int iovCount);
 ADNS_API int adns_inet_aton(const char *cp, struct in_addr *inp);
-ADNS_API int adns_getpid(void);
+ADNS_API int adns_getpid();
 
 #ifdef ADNS_DLL
  ADNS_API void *adns_malloc(const size_t bytes);
@@ -155,7 +157,5 @@ ADNS_API int adns_getpid(void);
 }
 #endif /* __cplusplus */
 
-#include "timercmp.h" /* arty added: mingw headers don't seem to have it */
-
 #endif /* ADNS_WIN32_H_INCLUDED */
 

lib/3rdparty/adns/client/adh-main.c

@@ -240,7 +240,7 @@ int main(int argc, const char *const *argv) {
     for (;;) {
       qu= ov_asynch ? 0 : outstanding.head ? outstanding.head->qu : 0;
       r= adns_check(ads,&qu,&answer,&qun_v);
-      if (r == EAGAIN) break;
+      if ((r == EAGAIN) || (r == EWOULDBLOCK)) break;
       if (r == ESRCH) { if (!ov_pipe) goto x_quit; else break; }
       assert(!r);
       query_done(qun_v,answer);
@@ -259,7 +259,6 @@ int main(int argc, const char *const *argv) {
     r= select(maxfd, &readfds,&writefds,&exceptfds, tv);
 	ADNS_CAPTURE_ERRNO;
     if (r == -1) {
-		ADNS_CAPTURE_ERRNO;
       if (errno == EINTR) continue;
       sysfail("select",errno);
     }

lib/3rdparty/adns/client/adnslogres.c

@@ -30,9 +30,6 @@
  *  subsequently.
  */
 
-static const char * const cvsid =
-	"$Id$";
-
 #ifdef ADNS_JGAA_WIN32
 # include "adns_win32.h"
 # include "getopt.h"
@@ -202,7 +199,7 @@ static void proclog(FILE *inf, FILE *outf, int maxpending, int opts) {
       } else {
 	err= adns_check(adns, &head->query, &answer, NULL);
       }
-      if (err == EAGAIN) break;
+      if ((err == EAGAIN) || (EWOULDBLOCK == err)) break;
       if (err) {
 	fprintf(stderr, "%s: adns_wait/check: %s", progname, strerror(err));
 	exit(1);

lib/3rdparty/adns/client/fanftest.c

@@ -29,9 +29,6 @@
  * modified by Ian Jackson as it was incorporated into adns.
  */
 
-static const char * const cvsid =
-	"$Id$";
-
 #ifdef ADNS_JGAA_WIN32
 # include "adns_win32.h"
 #else

lib/3rdparty/adns/src/adns.h

@@ -51,7 +51,6 @@
  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  *
- *  $Id$
  */
 
 #ifndef ADNS_H_INCLUDED
@@ -95,8 +94,7 @@ typedef enum {
   adns_if_eintr=        0x0020, /* allow _wait and _synchronous to return EINTR */
   adns_if_nosigpipe=    0x0040, /* applic has SIGPIPE set to SIG_IGN, do not protect */
   adns_if_checkc_entex= 0x0100, /* do consistency checks on entry/exit to adns funcs */
-  adns_if_checkc_freq=  0x0300, /* do consistency checks very frequently (slow!) */
-  adns_if_noserver=     0x0800, /* do not get dns servers from the environment */
+  adns_if_checkc_freq=  0x0300  /* do consistency checks very frequently (slow!) */
 } adns_initflags;
 
 typedef enum {

lib/3rdparty/adns/src/check.c

@@ -101,8 +101,8 @@ static void checkc_notcpbuf(adns_state ads) {
 
 static void checkc_global(adns_state ads) {
   int i;
-
-  assert(ads->udpsocket != INVALID_SOCKET);
+  
+  assert(ads->udpsocket >= 0);
 
   for (i=0; i<ads->nsortlist; i++)
     assert(!(ads->sortlist[i].base.s_addr & ~ads->sortlist[i].mask.s_addr));
@@ -111,16 +111,16 @@ static void checkc_global(adns_state ads) {
 
   switch (ads->tcpstate) {
   case server_connecting:
-    assert(ads->tcpsocket != INVALID_SOCKET);
+    assert(ads->tcpsocket >= 0);
     checkc_notcpbuf(ads);
     break;
   case server_disconnected:
   case server_broken:
-    assert(ads->tcpsocket == INVALID_SOCKET);
+    assert(ads->tcpsocket == -1);
     checkc_notcpbuf(ads);
     break;
   case server_ok:
-    assert(ads->tcpsocket != INVALID_SOCKET);
+    assert(ads->tcpsocket >= 0);
     assert(ads->tcprecv_skip <= ads->tcprecv.used);
     break;
   default:

lib/3rdparty/adns/src/event.c

@@ -28,10 +28,10 @@
  */
 
 #include <errno.h>
-# include "adns_win32.h"
 #include <stdlib.h>
 
 #ifdef ADNS_JGAA_WIN32
+# include "adns_win32.h"
 #else
 # include <unistd.h>
 # include <sys/types.h>
@@ -52,7 +52,7 @@ static void tcp_close(adns_state ads) {
 
   serv= ads->tcpserver;
   adns_socket_close(ads->tcpsocket);
-  ads->tcpsocket= INVALID_SOCKET;
+  ads->tcpsocket= -1;
   ads->tcprecv.used= ads->tcprecv_skip= ads->tcpsend.used= 0;
 }
 
@@ -114,7 +114,7 @@ void adns__tcp_tryconnect(adns_state ads, struct timeval now) {
 	ADNS_CLEAR_ERRNO
     fd= socket(AF_INET,SOCK_STREAM,proto->p_proto);
 	ADNS_CAPTURE_ERRNO;
-    if (fd == INVALID_SOCKET) {
+    if (fd<0) {
       adns__diag(ads,-1,0,"cannot create TCP socket: %s",strerror(errno));
       return;
     }
@@ -128,7 +128,9 @@ void adns__tcp_tryconnect(adns_state ads, struct timeval now) {
     addr.sin_family= AF_INET;
     addr.sin_port= htons(DNS_PORT);
     addr.sin_addr= ads->servers[ads->tcpserver].addr;
+    ADNS_CLEAR_ERRNO;
     r= connect(fd,(const struct sockaddr*)&addr,sizeof(addr));
+    ADNS_CAPTURE_ERRNO;
     ads->tcpsocket= fd;
     ads->tcpstate= server_connecting;
     if (r==0) { tcp_connected(ads,now); return; }
@@ -398,10 +400,10 @@ int adns_processreadable(adns_state ads, ADNS_SOCKET fd, const struct timeval *n
 		  (struct sockaddr*)&udpaddr,&udpaddrlen);
 	  ADNS_CAPTURE_ERRNO;
       if (r<0) {
-	if (errno == EAGAIN || errno == EWOULDBLOCK) { r= 0; goto xit; }
+	if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNRESET) { r= 0; goto xit; }
 	if (errno == EINTR) continue;
 	if (errno_resources(errno)) { r= errno; goto xit; }
-	adns__warn(ads,-1,0,"datagram receive error: %s",strerror(errno));
+	adns__warn(ads,-1,0,"datagram receive error: %s (%d)",strerror(errno), errno);
 	r= 0; goto xit;
       }
       if (udpaddrlen != sizeof(udpaddr)) {

lib/3rdparty/adns/src/general.c

@@ -254,7 +254,7 @@ static const struct sinfo {
   SINFO(  nodata,              "No such data"                                  )
 };
 
-static int __cdecl si_compar(const void *key, const void *elem) {
+static int si_compar(const void *key, const void *elem) {
   const adns_status *st= key;
   const struct sinfo *si= elem;
 
@@ -295,7 +295,7 @@ static const struct stinfo {
   STINFO(  permfail    )
 };
 
-static int __cdecl sti_compar(const void *key, const void *elem) {
+static int sti_compar(const void *key, const void *elem) {
   const adns_status *st= key;
   const struct stinfo *sti= elem;
 

lib/3rdparty/adns/src/internal.h

@@ -31,7 +31,7 @@
 #define ADNS_INTERNAL_H_INCLUDED
 
 #include "config.h"
-/*typedef unsigned char byte;*/ /* FIXME: horrible kludge to avoid conflicts with an SDK type */
+typedef unsigned char byte;
 
 #include <stdarg.h>
 #include <assert.h>
@@ -575,7 +575,7 @@ typedef enum {
 } parsedomain_flags;
 
 adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu,
-			       vbuf *vb, parsedomain_flags flags,
+			       vbuf *vb, adns_queryflags flags,
 			       const byte *dgram, int dglen, int *cbyte_io, int max);
 /* vb must already have been initialised; it will be reset if necessary.
  * If there is truncation, vb->used will be set to 0; otherwise
@@ -690,17 +690,17 @@ void adns__consistency(adns_state ads, adns_query qu, consistency_checks cc);
 
 /* Useful static inline functions: */
 
-static __inline int ctype_whitespace(int c) { return c==' ' || c=='\n' || c=='\t'; }
-static __inline int ctype_digit(int c) { return c>='0' && c<='9'; }
-static __inline int ctype_alpha(int c) {
+static inline int ctype_whitespace(int c) { return c==' ' || c=='\n' || c=='\t'; }
+static inline int ctype_digit(int c) { return c>='0' && c<='9'; }
+static inline int ctype_alpha(int c) {
   return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
 }
-static __inline int ctype_822special(int c) { return strchr("()<>@,;:\\\".[]",c) != 0; }
-static __inline int ctype_domainunquoted(int c) {
+static inline int ctype_822special(int c) { return strchr("()<>@,;:\\\".[]",c) != 0; }
+static inline int ctype_domainunquoted(int c) {
   return ctype_alpha(c) || ctype_digit(c) || (strchr("-_/+",c) != 0);
 }
 
-static __inline int errno_resources(int e) { return e==ENOMEM || e==ENOBUFS; }
+static inline int errno_resources(int e) { return e==ENOMEM || e==ENOBUFS; }
 
 /* Useful macros */
 

lib/3rdparty/adns/src/parse.c

@@ -115,7 +115,7 @@ adns_status adns__findlabel_next(findlabel_state *fls,
 }
 
 adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu,
-			       vbuf *vb, parsedomain_flags flags,
+			       vbuf *vb, adns_queryflags flags,
 			       const byte *dgram, int dglen, int *cbyte_io, int max) {
   findlabel_state fls;
 

lib/3rdparty/adns/src/setup.c

@@ -131,13 +131,13 @@ static void ccf_search(adns_state ads, const char *fn, int lno, const char *buf)
   while (nextword(&bufp,&word,&l)) { count++; tl += l+1; }
 
   newptrs= malloc(sizeof(char*)*count);  if (!newptrs) { saveerr(ads,errno); return; }
-  newchars= malloc((size_t) tl);  if (!newchars) { saveerr(ads,errno); free(newptrs); return; }
+  newchars= malloc(tl);  if (!newchars) { saveerr(ads,errno); free(newptrs); return; }
 
   bufp= buf;
   pp= newptrs;
   while (nextword(&bufp,&word,&l)) {
     *pp++= newchars;
-    memcpy(newchars,word,(size_t) l);
+    memcpy(newchars,word,l);
     newchars += l;
     *newchars++ = 0;
   }
@@ -163,12 +163,12 @@ static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *bu
       return;
     }
 
-    if (l >= (int)sizeof(tbuf)) {
+    if (l >= sizeof(tbuf)) {
       configparseerr(ads,fn,lno,"sortlist entry `%.*s' too long",l,word);
       continue;
     }
 
-    memcpy(tbuf,word, (size_t) l); tbuf[l]= 0;
+    memcpy(tbuf,word,l); tbuf[l]= 0;
     slash= strchr(tbuf,'/');
     if (slash) *slash++= 0;
 
@@ -351,7 +351,7 @@ static int gl_text(adns_state ads, getline_ctx *src_io, const char *filename,
     return -2;
   }
 
-  memcpy(buf,cp, (size_t) l);
+  memcpy(buf,cp,l);
   buf[l]= 0;
   return l;
 }
@@ -382,7 +382,7 @@ static void readconfiggeneric(adns_state ads, const char *filename,
     while (*q && !ctype_whitespace(*q)) q++;
     dirl= q-p;
     for (ccip=configcommandinfos;
-	 ccip->name && !((int)strlen(ccip->name)==dirl && !memcmp(ccip->name,p,(size_t) (q-p)));
+	 ccip->name && !((int)strlen(ccip->name)==dirl && !memcmp(ccip->name,p,q-p));
 	 ccip++);
     if (!ccip->name) {
       adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'",
@@ -457,7 +457,7 @@ static void readconfigenvtext(adns_state ads, const char *envvar) {
 int adns__setnonblock(adns_state ads, ADNS_SOCKET fd) {
 #ifdef ADNS_JGAA_WIN32
    unsigned long Val = 1;
-   return (ioctlsocket (fd, (long) FIONBIO, &Val) == 0) ? 0 : -1;
+   return (ioctlsocket (fd, FIONBIO, &Val) == 0) ? 0 : -1;
 #else
   int r;
 
@@ -488,7 +488,7 @@ static int init_begin(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
   LIST_INIT(ads->output);
   ads->forallnext= 0;
   ads->nextid= 0x311f;
-  ads->udpsocket= ads->tcpsocket= ((unsigned) -1);
+  ads->udpsocket= ads->tcpsocket= -1;
   adns__vbuf_init(&ads->tcpsend);
   adns__vbuf_init(&ads->tcprecv);
   ads->tcprecv_skip= 0;
@@ -525,7 +525,7 @@ static int init_finish(adns_state ads) {
   struct protoent *proto;
   int r;
 
-  if (!ads->nservers && !(ads->iflags & adns_if_noserver)) {
+  if (!ads->nservers) {
     if (ads->diagfile && ads->iflags & adns_if_debug)
       fprintf(ads->diagfile,"adns: no nameservers, using localhost\n");
     ia.s_addr= htonl(INADDR_LOOPBACK);
@@ -536,7 +536,7 @@ static int init_finish(adns_state ads) {
   ADNS_CLEAR_ERRNO;
   ads->udpsocket= socket(AF_INET,SOCK_DGRAM,proto->p_proto);
   ADNS_CAPTURE_ERRNO;
-  if (ads->udpsocket == INVALID_SOCKET) { r= errno; goto x_free; }
+  if (ads->udpsocket<0) { r= errno; goto x_free; }
 
   r= adns__setnonblock(ads,ads->udpsocket);
   if (r) { r= errno; goto x_closeudp; }
@@ -589,35 +589,33 @@ int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 
 #ifdef ADNS_JGAA_WIN32
-  if (!(flags & adns_if_noserver)) {
-    GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
-    strcat(PathBuf,"\\resolv.conf");
-    readconfig(ads,PathBuf,1);
-    GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
-    strcat(PathBuf,"\\resolv-adns.conf");
-    readconfig(ads,PathBuf,0);
-    GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
-    strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv.conf");
-    readconfig(ads,PathBuf,1);
-    GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
-    strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv-adns.conf");
-    readconfig(ads,PathBuf,0);
-    network_info_result = GetNetworkParams(network_info, &network_info_blen);
-    if (network_info_result != ERROR_SUCCESS){
-      switch(network_info_result) {
-      case ERROR_BUFFER_OVERFLOW: network_err_str = "ERROR_BUFFER_OVERFLOW"; break;
-      case ERROR_INVALID_PARAMETER: network_err_str = "ERROR_INVALID_PARAMETER"; break;
-      case ERROR_NO_DATA: network_err_str = "ERROR_NO_DATA"; break;
-      case ERROR_NOT_SUPPORTED: network_err_str = "ERROR_NOT_SUPPORTED"; break;}
-      adns__diag(ads,-1,0,"GetNetworkParams() failed with error [%d] %s",
-		 network_info_result,network_err_str);
+  GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
+  strcat(PathBuf,"\\resolv.conf");
+  readconfig(ads,PathBuf,1);
+  GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
+  strcat(PathBuf,"\\resolv-adns.conf");
+  readconfig(ads,PathBuf,0);
+  GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
+  strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv.conf");
+  readconfig(ads,PathBuf,1);
+  GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
+  strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv-adns.conf");
+  readconfig(ads,PathBuf,0);
+  network_info_result = GetNetworkParams(network_info, &network_info_blen);
+  if (network_info_result != ERROR_SUCCESS){
+    switch(network_info_result) {
+    case ERROR_BUFFER_OVERFLOW: network_err_str = "ERROR_BUFFER_OVERFLOW"; break;
+    case ERROR_INVALID_PARAMETER: network_err_str = "ERROR_INVALID_PARAMETER"; break;
+    case ERROR_NO_DATA: network_err_str = "ERROR_NO_DATA"; break;
+    case ERROR_NOT_SUPPORTED: network_err_str = "ERROR_NOT_SUPPORTED"; break;}
+    adns__diag(ads,-1,0,"GetNetworkParams() failed with error [%d] %s",
+      network_info_result,network_err_str);
     }
-    else {
-      for(pip = &(network_info->DnsServerList); pip; pip = pip->Next) {
-	addr.s_addr = inet_addr(pip->IpAddress.String);
-	if ((addr.s_addr != INADDR_ANY) && (addr.s_addr != INADDR_NONE))
-	  addserver(ads, addr);
-      }
+  else {
+    for(pip = &(network_info->DnsServerList); pip; pip = pip->Next) {
+      addr.s_addr = inet_addr(pip->IpAddress.String);
+      if ((addr.s_addr != INADDR_ANY) && (addr.s_addr != INADDR_NONE))
+        addserver(ads, addr);
     }
   }
 #else
@@ -682,7 +680,7 @@ void adns_finish(adns_state ads) {
     else break;
   }
   adns_socket_close(ads->udpsocket);
-  if (ads->tcpsocket != INVALID_SOCKET) adns_socket_close(ads->tcpsocket);
+  if (ads->tcpsocket >= 0) adns_socket_close(ads->tcpsocket);
   adns__vbuf_free(&ads->tcpsend);
   adns__vbuf_free(&ads->tcprecv);
   freesearchlist(ads);

lib/3rdparty/adns/src/transmit.c

@@ -194,10 +194,13 @@ void adns__querysend_tcp(adns_query qu, struct timeval now) {
     iov[1].iov_base= (char*)qu->query_dgram;
     iov[1].iov_len= qu->query_dglen;
     adns__sigpipe_protect(qu->ads);
+
+    ADNS_CLEAR_ERRNO;
     wr= writev(qu->ads->tcpsocket,iov,2);
+    ADNS_CAPTURE_ERRNO;
     adns__sigpipe_unprotect(qu->ads);
     if (wr < 0) {
-      if (!(errno == EAGAIN || errno == EINTR || errno == ENOSPC ||
+      if (!(errno == EAGAIN || EWOULDBLOCK || errno == EINTR || errno == ENOSPC ||
 	    errno == ENOBUFS || errno == ENOMEM)) {
 	adns__tcp_broken(ads,"write",strerror(errno));
 	return;
@@ -255,7 +258,7 @@ void adns__query_send(adns_query qu, struct timeval now) {
 	    (const struct sockaddr*)&servaddr,sizeof(servaddr));
   ADNS_CAPTURE_ERRNO;
   if (r<0 && errno == EMSGSIZE) { qu->retries= 0; query_usetcp(qu,now); return; }
-  if (r<0 && errno != EAGAIN) adns__warn(ads,serv,0,"sendto failed: %s (%d)",strerror(errno), errno);
+  if (r<0 && ((errno != EAGAIN) && (errno != EWOULDBLOCK))) adns__warn(ads,serv,0,"sendto failed: %s (%d)",strerror(errno), errno);
 
   qu->timeout= now;
   timevaladd(&qu->timeout,UDPRETRYMS);

lib/drivers/ip/ip.rbuild

@@ -1,6 +1,6 @@
 <?xml version="1.0"?>
 <!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd">
-<module name="ip" type="staticlibrary" allowwarnings="true">
+<module name="ip" type="staticlibrary">
 	<define name="__NTDRIVER__"/>
 	<include base="tcpip">include</include>
 	<include base="oskittcp">include</include>

lib/drivers/ip/network/address.c

@@ -106,7 +106,7 @@ VOID IPAddressFree(
  *     Nothing
  */
 {
-    PoolFreeBuffer(Object);
+    exFreePool(Object);
 }
 
 

lib/drivers/ip/network/arp.c

@@ -230,7 +230,7 @@ VOID ARPReceive(
             Header->HWAddrLen, NUD_REACHABLE);
     }
 
-    if (Header->Opcode != ARP_OPCODE_REQUEST)
+    if (Header->Opcode != ARP_OPCODE_REQUEST || !NCE)
         return;
 
     /* This is a request for our address. Swap the addresses and

lib/drivers/ip/network/icmp.c

@@ -181,6 +181,7 @@ VOID ICMPTransmit(
  */
 {
     PNEIGHBOR_CACHE_ENTRY NCE;
+    NTSTATUS Status;
 
     TI_DbgPrint(DEBUG_ICMP, ("Called.\n"));
 
@@ -191,7 +192,11 @@ VOID ICMPTransmit(
     /* Get a route to the destination address */
     if ((NCE = RouteGetRouteToDestination(&IPPacket->DstAddr))) {
         /* Send the packet */
-	IPSendDatagram(IPPacket, NCE, Complete, Context);
+	Status = IPSendDatagram(IPPacket, NCE, Complete, Context);
+	if (!NT_SUCCESS(Status))
+	{
+		Complete(Context, IPPacket->NdisPacket, Status);
+	}
     } else {
         /* No route to destination (or no free resources) */
         TI_DbgPrint(DEBUG_ICMP, ("No route to destination address 0x%X.\n",

lib/drivers/ip/network/ip.c

@@ -33,7 +33,7 @@ VOID FreePacket(
  *     Object = Pointer to an IP packet structure
  */
 {
-    TcpipFreeToNPagedLookasideList(&IPPacketList, Object);
+    exFreeToNPagedLookasideList(&IPPacketList, Object);
 }
 
 
@@ -70,7 +70,7 @@ PIP_PACKET IPCreatePacket(ULONG Type)
 {
   PIP_PACKET IPPacket;
 
-  IPPacket = TcpipAllocateFromNPagedLookasideList(&IPPacketList);
+  IPPacket = exAllocateFromNPagedLookasideList(&IPPacketList);
   if (!IPPacket)
     return NULL;
 
@@ -147,15 +147,21 @@ VOID IPDispatchProtocol(
         TI_DbgPrint(MIN_TRACE, ("IPv6 datagram discarded.\n"));
         return;
     default:
-        Protocol = 0;
+        TI_DbgPrint(MIN_TRACE, ("Unrecognized datagram discarded.\n"));
+        return;
     }
 
-    /* Call the appropriate protocol handler */
-    (*ProtocolTable[Protocol])(Interface, IPPacket);
-    /* Special case for ICMP -- ICMP can be caught by a SOCK_RAW but also
-     * must be handled here. */
-    if( Protocol == IPPROTO_ICMP )
-        ICMPReceive( Interface, IPPacket );
+    if (Protocol < IP_PROTOCOL_TABLE_SIZE &&
+        Protocol >= 0)
+    {
+       /* Call the appropriate protocol handler */
+       (*ProtocolTable[Protocol])(Interface, IPPacket);
+
+       /* Special case for ICMP -- ICMP can be caught by a SOCK_RAW but also
+        * must be handled here. */
+        if( Protocol == IPPROTO_ICMP )
+            ICMPReceive( Interface, IPPacket );
+    }
 }
 
 
@@ -288,8 +294,6 @@ BOOLEAN IPRegisterInterface(
 
     IF->Index = ChosenIndex;
 
-    IPAddInterfaceRoute( IF );
-
     /* Add interface to the global interface list */
     TcpipInterlockedInsertTailList(&InterfaceListHead,
 				   &IF->ListEntry,
@@ -304,22 +308,20 @@ VOID IPRemoveInterfaceRoute( PIP_INTERFACE IF ) {
     PNEIGHBOR_CACHE_ENTRY NCE;
     IP_ADDRESS GeneralRoute;
 
-    TCPDisposeInterfaceData( IF->TCPContext );
-    IF->TCPContext = NULL;
-
-    TI_DbgPrint(DEBUG_IP,("Removing interface Addr %s\n", A2S(&IF->Unicast)));
-    TI_DbgPrint(DEBUG_IP,("                   Mask %s\n", A2S(&IF->Netmask)));
-
-    AddrWidenAddress(&GeneralRoute,&IF->Unicast,&IF->Netmask);
-
-    RouterRemoveRoute(&GeneralRoute, &IF->Unicast);
-
-    /* Remove permanent NCE, but first we have to find it */
     NCE = NBLocateNeighbor(&IF->Unicast);
     if (NCE)
-	NBRemoveNeighbor(NCE);
-    else
-	TI_DbgPrint(DEBUG_IP, ("Could not delete IF route (0x%X)\n", IF));
+    {
+       TCPDisposeInterfaceData( IF->TCPContext );
+
+       TI_DbgPrint(DEBUG_IP,("Removing interface Addr %s\n", A2S(&IF->Unicast)));
+       TI_DbgPrint(DEBUG_IP,("                   Mask %s\n", A2S(&IF->Netmask)));
+
+       AddrWidenAddress(&GeneralRoute,&IF->Unicast,&IF->Netmask);
+
+       RouterRemoveRoute(&GeneralRoute, &IF->Unicast);
+
+       NBRemoveNeighbor(NCE);
+    }
 }
 
 VOID IPUnregisterInterface(
@@ -342,6 +344,21 @@ VOID IPUnregisterInterface(
 }
 
 
+VOID DefaultProtocolHandler(
+    PIP_INTERFACE Interface,
+    PIP_PACKET IPPacket)
+/*
+ * FUNCTION: Default handler for Internet protocols
+ * ARGUMENTS:
+ *     NTE      = Pointer to net table entry which the packet was received on
+ *     IPPacket = Pointer to an IP packet that was received
+ */
+{
+    TI_DbgPrint(MID_TRACE, ("[IF %x] Packet of unknown Internet protocol "
+			    "discarded.\n", Interface));
+}
+
+
 VOID IPRegisterProtocol(
     UINT ProtocolNumber,
     IP_PROTOCOL_HANDLER Handler)
@@ -359,22 +376,7 @@ VOID IPRegisterProtocol(
         return;
     }
 
-    ProtocolTable[ProtocolNumber] = Handler;
-}
-
-
-VOID DefaultProtocolHandler(
-    PIP_INTERFACE Interface,
-    PIP_PACKET IPPacket)
-/*
- * FUNCTION: Default handler for Internet protocols
- * ARGUMENTS:
- *     NTE      = Pointer to net table entry which the packet was received on
- *     IPPacket = Pointer to an IP packet that was received
- */
-{
-    TI_DbgPrint(MID_TRACE, ("[IF %x] Packet of unknown Internet protocol "
-			    "discarded.\n", Interface));
+    ProtocolTable[ProtocolNumber] = Handler ? Handler : DefaultProtocolHandler;
 }
 
 

lib/drivers/ip/network/loopback.c

@@ -45,7 +45,7 @@ VOID STDCALL LoopReceiveWorker( PVOID Context ) {
 	Adapter = WorkItem->Adapter;
 	BytesTransferred = WorkItem->BytesTransferred;
 
-	ExFreePool( WorkItem );
+	exFreePool( WorkItem );
 
         IPPacket.NdisPacket = Packet;
 
@@ -88,7 +88,7 @@ VOID LoopSubmitReceiveWork(
 
     TcpipAcquireSpinLock( &LoopWorkLock, &OldIrql );
 
-    WQItem = ExAllocatePool( NonPagedPool, sizeof(LAN_WQ_ITEM) );
+    WQItem = exAllocatePool( NonPagedPool, sizeof(LAN_WQ_ITEM) );
     if( !WQItem ) {
 	TcpipReleaseSpinLock( &LoopWorkLock, OldIrql );
 	return;
@@ -196,8 +196,10 @@ NDIS_STATUS LoopRegisterAdapter(
 
   AddrInitIPv4(&Loopback->Unicast, LOOPBACK_ADDRESS_IPv4);
   AddrInitIPv4(&Loopback->Netmask, LOOPBACK_ADDRMASK_IPv4);
+  AddrInitIPv4(&Loopback->Broadcast, LOOPBACK_BCASTADDR_IPv4);
 
   IPRegisterInterface(Loopback);
+  IPAddInterfaceRoute(Loopback);
 
   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 

lib/drivers/ip/network/memtrack.c

@@ -1,8 +1,8 @@
 #define MEMTRACK_NO_POOL
 #include "precomp.h"
 
-#ifdef MEMTRACK
 
+#ifdef DBG
 #define TRACK_TAG TAG('T','r','C','K')
 
 static LIST_ENTRY AllocatedObjectsList;
@@ -29,12 +29,24 @@ VOID TrackingInit() {
                                    0 );
 }
 
-VOID ShowTrackedThing( PCHAR What, PALLOCATION_TRACKER Thing,
-		       PCHAR File, UINT Line ) {
-    /* if( ShowTag( Thing->Tag ) ) */
-    if( File ) {
+VOID ShowTrackedThing( PCHAR What, PALLOCATION_TRACKER Thing, BOOLEAN ForceShow ) {
+
+    if (ForceShow)
+    {
+        DbgPrint("[%s] Thing %08x %c%c%c%c (%s:%d)\n",
+		  What,
+		  Thing->Thing,
+		  ((PCHAR)&Thing->Tag)[3],
+		  ((PCHAR)&Thing->Tag)[2],
+		  ((PCHAR)&Thing->Tag)[1],
+		  ((PCHAR)&Thing->Tag)[0],
+		  Thing->FileName,
+		  Thing->LineNo);
+    }
+    else
+    {
 	TI_DbgPrint(MAX_TRACE,
-		    ("[%s] Thing %08x %c%c%c%c (%s:%d) (Called from %s:%d)\n",
+		    ("[%s] Thing %08x %c%c%c%c (%s:%d)\n",
 		     What,
 		     Thing->Thing,
 		     ((PCHAR)&Thing->Tag)[3],
@@ -42,19 +54,7 @@ VOID ShowTrackedThing( PCHAR What, PALLOCATION_TRACKER Thing,
 		     ((PCHAR)&Thing->Tag)[1],
 		     ((PCHAR)&Thing->Tag)[0],
 		     Thing->FileName,
-		     Thing->LineNo,
-		     File, Line));
-    } else {
-	TI_DbgPrint(MAX_TRACE,
-		    ( "[%s] Thing %08x %c%c%c%c (%s:%d)\n",
-		      What,
-		      Thing->Thing,
-		      ((PCHAR)&Thing->Tag)[3],
-		      ((PCHAR)&Thing->Tag)[2],
-		      ((PCHAR)&Thing->Tag)[1],
-		      ((PCHAR)&Thing->Tag)[0],
-		      Thing->FileName,
-		      Thing->LineNo ));
+		     Thing->LineNo));
     }
 }
 
@@ -66,6 +66,15 @@ VOID TrackWithTag( DWORD Tag, PVOID Thing, PCHAR FileName, DWORD LineNo ) {
     PLIST_ENTRY Entry;
     PALLOCATION_TRACKER ThingInList;
 
+    if (!TrackedThing) return;
+
+    TrackedThing->Tag      = Tag;
+    TrackedThing->Thing    = Thing;
+    TrackedThing->FileName = FileName;
+    TrackedThing->LineNo   = LineNo;
+
+    ShowTrackedThing( "Alloc", TrackedThing, FALSE );
+
     TcpipAcquireSpinLock( &AllocatedObjectsLock, &OldIrql );
     Entry = AllocatedObjectsList.Flink;
     while( Entry != &AllocatedObjectsList ) {
@@ -73,30 +82,21 @@ VOID TrackWithTag( DWORD Tag, PVOID Thing, PCHAR FileName, DWORD LineNo ) {
 	if( ThingInList->Thing == Thing ) {
 	    RemoveEntryList(Entry);
 
-	    TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
-	    ShowTrackedThing( "Alloc", ThingInList, FileName, LineNo );
-	    PoolFreeBuffer( ThingInList );
-	    TrackDumpFL( FileName, LineNo );
-	    DbgPrint("TRACK: SPECIFIED ALREADY ALLOCATED ITEM %x\n", Thing);
-	    TcpipBugCheck( 0 );
+            TI_DbgPrint(MAX_TRACE,("TRACK: SPECIFIED ALREADY ALLOCATED ITEM %x\n", Thing));
+            ShowTrackedThing( "Double Alloc (Item in list)", ThingInList, FALSE );
+            ShowTrackedThing( "Double Alloc (Item not in list)", TrackedThing, FALSE );
+
+            ExFreeToNPagedLookasideList( &AllocatedObjectsLookasideList,
+	                                 ThingInList );
+
+            break;
 	}
 	Entry = Entry->Flink;
     }
 
-    if( TrackedThing ) {
-	TrackedThing->Tag      = Tag;
-	TrackedThing->Thing    = Thing;
-	TrackedThing->FileName = FileName;
-	TrackedThing->LineNo   = LineNo;
-
-
-	InsertHeadList( &AllocatedObjectsList, &TrackedThing->Entry );
-	ShowTrackedThing( "Alloc", TrackedThing, FileName, LineNo );
-    }
+    InsertHeadList( &AllocatedObjectsList, &TrackedThing->Entry );
 
     TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
-
-    /*TrackDumpFL( FileName, LineNo );*/
 }
 
 BOOL ShowTag( DWORD Tag ) {
@@ -107,7 +107,7 @@ BOOL ShowTag( DWORD Tag ) {
     return TagsToShow[i] ? TRUE : FALSE;
 }
 
-VOID UntrackFL( PCHAR File, DWORD Line, PVOID Thing ) {
+VOID UntrackFL( PCHAR File, DWORD Line, PVOID Thing, DWORD Tag ) {
     KIRQL OldIrql;
     PLIST_ENTRY Entry;
     PALLOCATION_TRACKER ThingInList;
@@ -119,21 +119,27 @@ VOID UntrackFL( PCHAR File, DWORD Line, PVOID Thing ) {
 	if( ThingInList->Thing == Thing ) {
 	    RemoveEntryList(Entry);
 
-	    ShowTrackedThing( "Free ", ThingInList, File, Line );
+	    ShowTrackedThing( "Free ", ThingInList, FALSE );
+
+            if ( ThingInList->Tag != Tag ) {
+                 DbgPrint("UNTRACK: TAG DOES NOT MATCH (%x)\n", Thing);
+                 ShowTrackedThing("Tag Mismatch (Item in list)", ThingInList, TRUE);
+                 ASSERT( FALSE );
+            }
 
 	    ExFreeToNPagedLookasideList( &AllocatedObjectsLookasideList,
 	                                ThingInList );
 
 	    TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
+
 	    /* TrackDumpFL( File, Line ); */
 	    return;
 	}
 	Entry = Entry->Flink;
     }
     TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
-    TrackDumpFL( File, Line );
     DbgPrint("UNTRACK: SPECIFIED ALREADY FREE ITEM %x\n", Thing);
-    TcpipBugCheck( 0 );
+    ASSERT( FALSE );
 }
 
 VOID TrackDumpFL( PCHAR File, DWORD Line ) {
@@ -147,10 +153,10 @@ VOID TrackDumpFL( PCHAR File, DWORD Line ) {
     Entry = AllocatedObjectsList.Flink;
     while( Entry != &AllocatedObjectsList ) {
 	Thing = CONTAINING_RECORD(Entry, ALLOCATION_TRACKER, Entry);
-	ShowTrackedThing( "Dump ", Thing, 0, 0 );
+	ShowTrackedThing( "Dump ", Thing, FALSE );
 	Entry = Entry->Flink;
     }
     TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
 }
 
-#endif/*MEMTRACK*/
+#endif /* DBG */

lib/drivers/ip/network/neighbor.c

@@ -21,17 +21,27 @@ VOID NBCompleteSend( PVOID Context,
     ASSERT_KM_POINTER(Packet->Complete);
     Packet->Complete( Packet->Context, Packet->Packet, Status );
     TI_DbgPrint(MID_TRACE, ("Completed\n"));
-    PoolFreeBuffer( Packet );
+    exFreePool( Packet );
     TI_DbgPrint(MID_TRACE, ("Freed\n"));
 }
 
 VOID NBSendPackets( PNEIGHBOR_CACHE_ENTRY NCE ) {
     PLIST_ENTRY PacketEntry;
     PNEIGHBOR_PACKET Packet;
+    UINT HashValue;
+
+    if(!(NCE->State & NUD_CONNECTED))
+       return;
+
+    HashValue  = *(PULONG)(&NCE->Address.Address);
+    HashValue ^= HashValue >> 16;
+    HashValue ^= HashValue >> 8;
+    HashValue ^= HashValue >> 4;
+    HashValue &= NB_HASHMASK;
 
     /* Send any waiting packets */
     PacketEntry = ExInterlockedRemoveHeadList(&NCE->PacketQueue,
-                                              &NCE->Table->Lock);
+                                              &NeighborCache[HashValue].Lock);
     if( PacketEntry != NULL ) {
 	Packet = CONTAINING_RECORD( PacketEntry, NEIGHBOR_PACKET, Next );
 
@@ -76,10 +86,10 @@ VOID NBFlushPacketQueue( PNEIGHBOR_CACHE_ENTRY NCE,
             ASSERT_KM_POINTER(Packet->Complete);
 	    Packet->Complete( Packet->Context,
 			      Packet->Packet,
-			      NDIS_STATUS_REQUEST_ABORTED );
+			      ErrorCode );
         }
 
-	PoolFreeBuffer( Packet );
+	exFreePool( Packet );
     }
 }
 
@@ -227,7 +237,7 @@ VOID NBSendSolicit(PNEIGHBOR_CACHE_ENTRY NCE)
 {
     TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X).\n", NCE));
 
-    if (NCE->State == NUD_INCOMPLETE)
+    if (NCE->State & NUD_INCOMPLETE)
     {
 	/* This is the first solicitation of this neighbor. Broadcast
 	   a request for the neighbor */
@@ -273,7 +283,7 @@ PNEIGHBOR_CACHE_ENTRY NBAddNeighbor(
 	"LinkAddress (0x%X)  LinkAddressLength (%d)  State (0x%X)\n",
 	Interface, Address, LinkAddress, LinkAddressLength, State));
 
-  NCE = ExAllocatePool
+  NCE = exAllocatePool
       (NonPagedPool, sizeof(NEIGHBOR_CACHE_ENTRY) + LinkAddressLength);
   if (NCE == NULL)
     {
@@ -330,15 +340,22 @@ VOID NBUpdateNeighbor(
  */
 {
     KIRQL OldIrql;
+    UINT HashValue;
 
     TI_DbgPrint(DEBUG_NCACHE, ("Called. NCE (0x%X)  LinkAddress (0x%X)  State (0x%X).\n", NCE, LinkAddress, State));
 
-    TcpipAcquireSpinLock(&NCE->Table->Lock, &OldIrql);
+    HashValue  = *(PULONG)(&NCE->Address.Address);
+    HashValue ^= HashValue >> 16;
+    HashValue ^= HashValue >> 8;
+    HashValue ^= HashValue >> 4;
+    HashValue &= NB_HASHMASK;
+
+    TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
     RtlCopyMemory(NCE->LinkAddress, LinkAddress, NCE->LinkAddressLength);
     NCE->State = State;
 
-    TcpipReleaseSpinLock(&NCE->Table->Lock, OldIrql);
+    TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
     if( NCE->State & NUD_CONNECTED )
 	NBSendPackets( NCE );
@@ -441,29 +458,33 @@ BOOLEAN NBQueuePacket(
  *   TRUE if the packet was successfully queued, FALSE if not
  */
 {
-  PKSPIN_LOCK Lock;
   KIRQL OldIrql;
   PNEIGHBOR_PACKET Packet;
+  UINT HashValue;
 
   TI_DbgPrint
       (DEBUG_NCACHE,
        ("Called. NCE (0x%X)  NdisPacket (0x%X).\n", NCE, NdisPacket));
 
-  Packet = PoolAllocateBuffer( sizeof(NEIGHBOR_PACKET) );
+  Packet = exAllocatePool( NonPagedPool, sizeof(NEIGHBOR_PACKET) );
   if( !Packet ) return FALSE;
 
   /* FIXME: Should we limit the number of queued packets? */
 
-  Lock = &NCE->Table->Lock;
+  HashValue  = *(PULONG)(&NCE->Address.Address);
+  HashValue ^= HashValue >> 16;
+  HashValue ^= HashValue >> 8;
+  HashValue ^= HashValue >> 4;
+  HashValue &= NB_HASHMASK;
 
-  TcpipAcquireSpinLock(Lock, &OldIrql);
+  TcpipAcquireSpinLock(&NeighborCache[HashValue].Lock, &OldIrql);
 
   Packet->Complete = PacketComplete;
   Packet->Context = PacketContext;
   Packet->Packet = NdisPacket;
   InsertTailList( &NCE->PacketQueue, &Packet->Next );
 
-  TcpipReleaseSpinLock(Lock, OldIrql);
+  TcpipReleaseSpinLock(&NeighborCache[HashValue].Lock, OldIrql);
 
   if( NCE->State & NUD_CONNECTED )
       NBSendPackets( NCE );
@@ -508,7 +529,7 @@ VOID NBRemoveNeighbor(
           *PrevNCE = CurNCE->Next;
 
 	  NBFlushPacketQueue( CurNCE, TRUE, NDIS_STATUS_REQUEST_ABORTED );
-          ExFreePool(CurNCE);
+          exFreePool(CurNCE);
 
 	  break;
         }

lib/drivers/ip/network/ports.c

@@ -15,10 +15,9 @@ NTSTATUS PortsStartup( PPORT_SET PortSet,
 		   UINT PortsToManage ) {
     PortSet->StartingPort = StartingPort;
     PortSet->PortsToOversee = PortsToManage;
-    PortSet->LastAllocatedPort = PortSet->StartingPort +
-                                 PortSet->PortsToOversee - 1;
+
     PortSet->ProtoBitBuffer =
-	PoolAllocateBuffer( (PortSet->PortsToOversee + 7) / 8 );
+	exAllocatePool( NonPagedPool, (PortSet->PortsToOversee + 7) / 8 );
     if(!PortSet->ProtoBitBuffer) return STATUS_INSUFFICIENT_RESOURCES;
     RtlInitializeBitMap( &PortSet->ProtoBitmap,
 			 PortSet->ProtoBitBuffer,
@@ -29,7 +28,7 @@ NTSTATUS PortsStartup( PPORT_SET PortSet,
 }
 
 VOID PortsShutdown( PPORT_SET PortSet ) {
-    PoolFreeBuffer( PortSet->ProtoBitBuffer );
+    exFreePool( PortSet->ProtoBitBuffer );
 }
 
 VOID DeallocatePort( PPORT_SET PortSet, ULONG Port ) {
@@ -43,7 +42,13 @@ BOOLEAN AllocatePort( PPORT_SET PortSet, ULONG Port ) {
     BOOLEAN Clear;
 
     Port = htons(Port);
-    ASSERT(Port >= PortSet->StartingPort);
+
+    if ((Port < PortSet->StartingPort) ||
+        (Port >= PortSet->StartingPort + PortSet->PortsToOversee))
+    {
+       return FALSE;
+    }
+
     Port -= PortSet->StartingPort;
 
     ExAcquireFastMutex( &PortSet->Mutex );
@@ -56,58 +61,41 @@ BOOLEAN AllocatePort( PPORT_SET PortSet, ULONG Port ) {
 
 ULONG AllocateAnyPort( PPORT_SET PortSet ) {
     ULONG AllocatedPort;
-    ULONG Next;
-
-    if (PortSet->StartingPort + PortSet->PortsToOversee <=
-        PortSet->LastAllocatedPort + 1) {
-	Next = PortSet->StartingPort;
-    } else {
-	Next = PortSet->LastAllocatedPort + 1;
-    }
-    Next -= PortSet->StartingPort;
 
     ExAcquireFastMutex( &PortSet->Mutex );
     AllocatedPort = RtlFindClearBits( &PortSet->ProtoBitmap, 1, 0 );
     if( AllocatedPort != (ULONG)-1 ) {
 	RtlSetBit( &PortSet->ProtoBitmap, AllocatedPort );
 	AllocatedPort += PortSet->StartingPort;
-	PortSet->LastAllocatedPort = AllocatedPort;
+	ExReleaseFastMutex( &PortSet->Mutex );
+	return htons(AllocatedPort);
     }
     ExReleaseFastMutex( &PortSet->Mutex );
 
-    AllocatedPort = htons(AllocatedPort);
-
-    return AllocatedPort;
+    return -1;
 }
 
 ULONG AllocatePortFromRange( PPORT_SET PortSet, ULONG Lowest, ULONG Highest ) {
     ULONG AllocatedPort;
-    ULONG Next;
 
-    if (PortSet->StartingPort + PortSet->PortsToOversee <=
-        PortSet->LastAllocatedPort + 1) {
-	Next = PortSet->StartingPort;
-    } else {
-	Next = PortSet->LastAllocatedPort + 1;
+    if ((Lowest < PortSet->StartingPort) ||
+        (Highest >= PortSet->StartingPort + PortSet->PortsToOversee))
+    {
+        return -1;
     }
-    if (Next < Lowest || Highest <= Next) {
-	Next = Lowest;
-    }
-    Next -= PortSet->StartingPort;
+
     Lowest -= PortSet->StartingPort;
     Highest -= PortSet->StartingPort;
 
     ExAcquireFastMutex( &PortSet->Mutex );
-    AllocatedPort = RtlFindClearBits( &PortSet->ProtoBitmap, 1, Next );
-    if( AllocatedPort != (ULONG)-1 && AllocatedPort >= Lowest &&
-        AllocatedPort <= Highest) {
+    AllocatedPort = RtlFindClearBits( &PortSet->ProtoBitmap, 1, Lowest );
+    if( AllocatedPort != (ULONG)-1 && AllocatedPort <= Highest) {
 	RtlSetBit( &PortSet->ProtoBitmap, AllocatedPort );
 	AllocatedPort += PortSet->StartingPort;
-	PortSet->LastAllocatedPort = AllocatedPort;
+	ExReleaseFastMutex( &PortSet->Mutex );
+	return htons(AllocatedPort);
     }
     ExReleaseFastMutex( &PortSet->Mutex );
 
-    AllocatedPort = htons(AllocatedPort);
-
-    return AllocatedPort;
+    return -1;
 }

lib/drivers/ip/network/receive.c

@@ -41,7 +41,7 @@ PIPDATAGRAM_HOLE CreateHoleDescriptor(
 
 	TI_DbgPrint(DEBUG_IP, ("Called. First (%d)  Last (%d).\n", First, Last));
 
-	Hole = TcpipAllocateFromNPagedLookasideList(&IPHoleList);
+	Hole = exAllocateFromNPagedLookasideList(&IPHoleList);
 	if (!Hole) {
 	    TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 	    return NULL;
@@ -82,7 +82,7 @@ VOID FreeIPDR(
     TI_DbgPrint(DEBUG_IP, ("Freeing hole descriptor at (0x%X).\n", CurrentH));
 
     /* And free the hole descriptor */
-    TcpipFreeToNPagedLookasideList(&IPHoleList, CurrentH);
+    exFreeToNPagedLookasideList(&IPHoleList, CurrentH);
 
     CurrentEntry = NextEntry;
   }
@@ -103,13 +103,13 @@ VOID FreeIPDR(
     TI_DbgPrint(DEBUG_IP, ("Freeing fragment at (0x%X).\n", CurrentF));
 
     /* And free the fragment descriptor */
-    TcpipFreeToNPagedLookasideList(&IPFragmentList, CurrentF);
+    exFreeToNPagedLookasideList(&IPFragmentList, CurrentF);
     CurrentEntry = NextEntry;
   }
 
   TI_DbgPrint(DEBUG_IP, ("Freeing IPDR data at (0x%X).\n", IPDR));
 
-  TcpipFreeToNPagedLookasideList(&IPDRList, IPDR);
+  exFreeToNPagedLookasideList(&IPDRList, IPDR);
 }
 
 
@@ -250,8 +250,7 @@ PIP_PACKET ReassembleDatagram(
 __inline VOID Cleanup(
   PKSPIN_LOCK Lock,
   KIRQL OldIrql,
-  PIPDATAGRAM_REASSEMBLY IPDR,
-  PVOID Buffer OPTIONAL)
+  PIPDATAGRAM_REASSEMBLY IPDR)
 /*
  * FUNCTION: Performs cleaning operations on errors
  * ARGUMENTS:
@@ -266,8 +265,6 @@ __inline VOID Cleanup(
   TcpipReleaseSpinLock(Lock, OldIrql);
   RemoveIPDR(IPDR);
   FreeIPDR(IPDR);
-  if (Buffer)
-    exFreePool(Buffer);
 }
 
 
@@ -311,7 +308,7 @@ VOID ProcessFragment(
     TI_DbgPrint(DEBUG_IP, ("Starting new assembly.\n"));
 
     /* We don't have a reassembly structure, create one */
-    IPDR = TcpipAllocateFromNPagedLookasideList(&IPDRList);
+    IPDR = exAllocateFromNPagedLookasideList(&IPDRList);
     if (!IPDR)
       /* We don't have the resources to process this packet, discard it */
       return;
@@ -322,7 +319,7 @@ VOID ProcessFragment(
     Hole = CreateHoleDescriptor(0, 65536);
     if (!Hole) {
       /* We don't have the resources to process this packet, discard it */
-      TcpipFreeToNPagedLookasideList(&IPDRList, IPDR);
+      exFreeToNPagedLookasideList(&IPDRList, IPDR);
       return;
     }
     AddrInitIPv4(&IPDR->SrcAddr, IPv4Header->SrcAddr);
@@ -375,7 +372,8 @@ VOID ProcessFragment(
       NewHole = CreateHoleDescriptor(Hole->First, FragLast - 1);
       if (!NewHole) {
         /* We don't have the resources to process this packet, discard it */
-        Cleanup(&IPDR->Lock, OldIrql, IPDR, Hole);
+        exFreeToNPagedLookasideList(&IPHoleList, Hole);
+        Cleanup(&IPDR->Lock, OldIrql, IPDR);
         return;
       }
 
@@ -385,12 +383,12 @@ VOID ProcessFragment(
 
     if ((FragLast < Hole->Last) && (MoreFragments)) {
       /* We can reuse the descriptor for the new hole */
-		  Hole->First = FragLast + 1;
+      Hole->First = FragLast + 1;
 
-		  /* Put the new hole descriptor in the list */
+      /* Put the new hole descriptor in the list */
       InsertTailList(&IPDR->HoleListHead, &Hole->ListEntry);
     } else
-      TcpipFreeToNPagedLookasideList(&IPHoleList, Hole);
+      exFreeToNPagedLookasideList(&IPHoleList, Hole);
 
     /* If this is the first fragment, save the IP header */
     if (FragFirst == 0) {
@@ -404,10 +402,10 @@ VOID ProcessFragment(
     /* Create a buffer, copy the data into it and put it
        in the fragment list */
 
-    Fragment = TcpipAllocateFromNPagedLookasideList(&IPFragmentList);
+    Fragment = exAllocateFromNPagedLookasideList(&IPFragmentList);
     if (!Fragment) {
       /* We don't have the resources to process this packet, discard it */
-      Cleanup(&IPDR->Lock, OldIrql, IPDR, NULL);
+      Cleanup(&IPDR->Lock, OldIrql, IPDR);
       return;
     }
 
@@ -417,7 +415,8 @@ VOID ProcessFragment(
     Fragment->Data = exAllocatePool(NonPagedPool, Fragment->Size);
     if (!Fragment->Data) {
       /* We don't have the resources to process this packet, discard it */
-      Cleanup(&IPDR->Lock, OldIrql, IPDR, Fragment);
+      exFreeToNPagedLookasideList(&IPFragmentList, Fragment);
+      Cleanup(&IPDR->Lock, OldIrql, IPDR);
       return;
     }
 

lib/drivers/ip/network/router.c

@@ -51,7 +51,7 @@ VOID FreeFIB(
  *     Object = Pointer to an forward information base structure
  */
 {
-    PoolFreeBuffer(Object);
+    exFreePool(Object);
 }
 
 
@@ -213,7 +213,7 @@ PFIB_ENTRY RouterAddRoute(
 			       A2S(Netmask),
 			       A2S(&Router->Address)));
 
-    FIBE = PoolAllocateBuffer(sizeof(FIB_ENTRY));
+    FIBE = exAllocatePool(NonPagedPool, sizeof(FIB_ENTRY));
     if (!FIBE) {
         TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
         return NULL;
@@ -390,7 +390,7 @@ NTSTATUS RouterRemoveRoute(PIP_ADDRESS Target, PIP_ADDRESS Router)
 
     TI_DbgPrint(DEBUG_ROUTER, ("Leaving\n"));
 
-    return Found ? STATUS_NO_SUCH_FILE : STATUS_SUCCESS;
+    return Found ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
 }
 
 

lib/drivers/ip/network/transmit.c

@@ -28,6 +28,7 @@ VOID IPSendComplete
  */
 {
     PIPFRAGMENT_CONTEXT IFC = (PIPFRAGMENT_CONTEXT)Context;
+    NTSTATUS Status;
 
     TI_DbgPrint
 	(MAX_TRACE,
@@ -35,8 +36,14 @@ VOID IPSendComplete
 	  Context, NdisPacket, NdisStatus));
 
     if (NT_SUCCESS(NdisStatus) && PrepareNextFragment(IFC)) {
-	/* A fragment was prepared for transmission, so send it */
-	IPSendFragment(IFC->NdisPacket, IFC->NCE, IFC);
+	    /* A fragment was prepared for transmission, so send it */
+	    Status = IPSendFragment(IFC->NdisPacket, IFC->NCE, IFC);
+        if (!NT_SUCCESS(Status))
+        {
+            FreeNdisPacket(IFC->NdisPacket);
+            IFC->Complete(IFC->Context, IFC->Datagram, Status);
+            exFreePool(IFC);
+        }
     } else {
 	TI_DbgPrint(MAX_TRACE, ("Calling completion handler.\n"));
 
@@ -87,7 +94,7 @@ BOOLEAN PrepareNextFragment(
 
     TI_DbgPrint(MAX_TRACE, ("Called. IFC (0x%X)\n", IFC));
 
-    if (IFC->BytesLeft != 0) {
+    if (IFC->BytesLeft > 0) {
 
         TI_DbgPrint(MAX_TRACE, ("Preparing 1 fragment.\n"));
 
@@ -203,8 +210,19 @@ NTSTATUS SendFragments(
 
     /* Prepare next fragment for transmission and send it */
 
-    PrepareNextFragment(IFC);
-    return IPSendFragment(IFC->NdisPacket, NCE, IFC);
+    if (!PrepareNextFragment(IFC)) {
+        FreeNdisPacket(IFC->NdisPacket);
+        exFreePool(IFC);
+        return NDIS_STATUS_FAILURE;
+    }
+
+    if (!NT_SUCCESS((NdisStatus = IPSendFragment(IFC->NdisPacket, NCE, IFC))))
+    {
+        FreeNdisPacket(IFC->NdisPacket);
+        exFreePool(IFC);
+    }
+
+    return NdisStatus;
 }
 
 NTSTATUS IPSendDatagram(PIP_PACKET IPPacket, PNEIGHBOR_CACHE_ENTRY NCE,

lib/drivers/ip/transport/datagram/datagram.c

@@ -16,10 +16,13 @@ VOID DGRemoveIRP(
 {
     PLIST_ENTRY ListEntry;
     PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
+    KIRQL OldIrql;
 
     TI_DbgPrint(MAX_TRACE, ("Called (Cancel IRP %08x for file %08x).\n",
                             Irp, AddrFile));
 
+    KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
+
     for( ListEntry = AddrFile->ReceiveQueue.Flink; 
          ListEntry != &AddrFile->ReceiveQueue;
          ListEntry = ListEntry->Flink )
@@ -37,6 +40,8 @@ VOID DGRemoveIRP(
         }
     }
 
+    KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
+
     TI_DbgPrint(MAX_TRACE, ("Done.\n"));
 }
 
@@ -254,6 +259,9 @@ NTSTATUS DGReceiveDatagram(
             {
 		ReceiveRequest->RemotePort    = 0;
             }
+
+	    IoMarkIrpPending(Irp);
+
 	    ReceiveRequest->ReturnInfo = ReturnInfo;
 	    ReceiveRequest->Buffer = BufferData;
 	    ReceiveRequest->BufferSize = ReceiveLength;

lib/drivers/ip/transport/rawip/rawip.c

@@ -223,12 +223,18 @@ NTSTATUS RawIPSendDatagram(
 
     TI_DbgPrint(MID_TRACE,("About to get route to destination\n"));
 
-    if(!(NCE = RouteGetRouteToDestination( &RemoteAddress )))
+    if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
+        FreeNdisPacket(Packet.NdisPacket);
 	return STATUS_UNSUCCESSFUL;
+    }
 
     TI_DbgPrint(MID_TRACE,("About to send datagram\n"));
 
-    IPSendDatagram( &Packet, NCE, RawIpSendPacketComplete, NULL );
+    if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, RawIpSendPacketComplete, NULL )))
+    {
+        FreeNdisPacket(Packet.NdisPacket);
+        return Status;
+    }
 
     TI_DbgPrint(MID_TRACE,("Leaving\n"));
 

lib/drivers/ip/transport/tcp/accept.c

@@ -87,13 +87,13 @@ NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog ) {
 
     TI_DbgPrint(DEBUG_TCP,("AddressToBind - %x:%x\n", AddressToBind.sin_addr, AddressToBind.sin_port));
 
-    OskitTCPBind( Connection->SocketContext,
-		  Connection,
-		  &AddressToBind,
-		  sizeof(AddressToBind) );
+    Status = TCPTranslateError( OskitTCPBind( Connection->SocketContext,
+		                Connection,
+		                &AddressToBind,
+		                sizeof(AddressToBind) ) );
 
-    Status = TCPTranslateError( OskitTCPListen( Connection->SocketContext,
-						Backlog ) );
+    if (NT_SUCCESS(Status))
+        Status = TCPTranslateError( OskitTCPListen( Connection->SocketContext, Backlog ) );
 
     TcpipRecursiveMutexLeave( &TCPLock );
 
@@ -112,13 +112,14 @@ VOID TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener,
     ListEntry = Listener->ListenRequest.Flink;
     while ( ListEntry != &Listener->ListenRequest ) {
 	Bucket = CONTAINING_RECORD(ListEntry, TDI_BUCKET, Entry);
-	ListEntry = ListEntry->Flink;
 
 	if( Bucket->AssociatedEndpoint == Connection ) {
-	    RemoveEntryList( ListEntry->Blink );
-	    ExFreePool( Bucket );
+	    RemoveEntryList( &Bucket->Entry );
+	    exFreePool( Bucket );
 	    break;
 	}
+
+	ListEntry = ListEntry->Flink;
     }
 
    TcpipRecursiveMutexLeave( &TCPLock );
@@ -141,7 +142,7 @@ NTSTATUS TCPAccept
 				       (PTDI_REQUEST_KERNEL)Request );
 
    if( Status == STATUS_PENDING ) {
-       Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) );
+       Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 
        if( Bucket ) {
            Bucket->AssociatedEndpoint = Connection;

lib/drivers/ip/transport/tcp/event.c

@@ -77,8 +77,6 @@ int TCPPacketSend(void *ClientData, OSK_PCHAR data, OSK_UINT len ) {
 	return OSK_EINVAL;
     }
 
-    RemoteAddress.Type = LocalAddress.Type = IP_ADDRESS_V4;
-
     if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
 	TI_DbgPrint(MIN_TRACE,("No route to %s\n", A2S(&RemoteAddress)));
 	return OSK_EADDRNOTAVAIL;
@@ -102,7 +100,11 @@ int TCPPacketSend(void *ClientData, OSK_PCHAR data, OSK_UINT len ) {
     Packet.SrcAddr = LocalAddress;
     Packet.DstAddr = RemoteAddress;
 
-    IPSendDatagram( &Packet, NCE, TCPPacketSendComplete, NULL );
+    if (!NT_SUCCESS(IPSendDatagram( &Packet, NCE, TCPPacketSendComplete, NULL )))
+    {
+        FreeNdisPacket(Packet.NdisPacket);
+        return OSK_EINVAL;
+    }
 
     return 0;
 }
@@ -115,7 +117,7 @@ int TCPSleep( void *ClientData, void *token, int priority, char *msg,
 		("Called TSLEEP: tok = %x, pri = %d, wmesg = %s, tmio = %x\n",
 		 token, priority, msg, tmio));
 
-    SleepingThread = PoolAllocateBuffer( sizeof( *SleepingThread ) );
+    SleepingThread = exAllocatePool( NonPagedPool, sizeof( *SleepingThread ) );
     if( SleepingThread ) {
 	KeInitializeEvent( &SleepingThread->Event, NotificationEvent, FALSE );
 	SleepingThread->SleepToken = token;
@@ -142,7 +144,7 @@ int TCPSleep( void *ClientData, void *token, int priority, char *msg,
 
 	TcpipRecursiveMutexEnter( &TCPLock, TRUE );
 
-	PoolFreeBuffer( SleepingThread );
+	exFreePool( SleepingThread );
     } else
         return OSK_ENOBUFS;
 
@@ -234,22 +236,22 @@ void *TCPMalloc( void *ClientData,
     if ( ! Found ) {
 	if ( ArrayAllocated <= ArrayUsed ) {
 	    NewSize = ( 0 == ArrayAllocated ? 16 : 2 * ArrayAllocated );
-	    NewArray = PoolAllocateBuffer( 2 * NewSize * sizeof( OSK_UINT ) );
+	    NewArray = exAllocatePool( NonPagedPool, 2 * NewSize * sizeof( OSK_UINT ) );
 	    if ( NULL != NewArray ) {
 		if ( 0 != ArrayAllocated ) {
 		    memcpy( NewArray, Sizes,
 		            ArrayAllocated * sizeof( OSK_UINT ) );
-		    PoolFreeBuffer( Sizes );
+		    exFreePool( Sizes );
 		    memcpy( NewArray + NewSize, Counts,
 		            ArrayAllocated * sizeof( OSK_UINT ) );
-		    PoolFreeBuffer( Counts );
+		    exFreePool( Counts );
 		}
 		Sizes = NewArray;
 		Counts = NewArray + NewSize;
 		ArrayAllocated = NewSize;
 	    } else if ( 0 != ArrayAllocated ) {
-		PoolFreeBuffer( Sizes );
-		PoolFreeBuffer( Counts );
+		exFreePool( Sizes );
+		exFreePool( Counts );
 		ArrayAllocated = 0;
 	    }
 	}
@@ -277,7 +279,7 @@ void *TCPMalloc( void *ClientData,
 	v = ExAllocateFromNPagedLookasideList( &LargeLookasideList );
 	Signature = SIGNATURE_LARGE;
     } else {
-	v = PoolAllocateBuffer( Bytes + sizeof(ULONG) );
+	v = ExAllocatePool( NonPagedPool, Bytes + sizeof(ULONG) );
 	Signature = SIGNATURE_OTHER;
     }
     if( v ) {
@@ -293,7 +295,7 @@ void TCPFree( void *ClientData,
 	      void *data, OSK_PCHAR File, OSK_UINT Line ) {
     ULONG Signature;
 
-    UntrackFL( (PCHAR)File, Line, data );
+    UntrackFL( (PCHAR)File, Line, data, FOURCC('f','b','s','d') );
     data = (void *)((char *) data - sizeof(ULONG));
     Signature = *((ULONG *) data);
     if ( SIGNATURE_SMALL == Signature ) {
@@ -301,7 +303,7 @@ void TCPFree( void *ClientData,
     } else if ( SIGNATURE_LARGE == Signature ) {
 	ExFreeToNPagedLookasideList( &LargeLookasideList, data );
     } else if ( SIGNATURE_OTHER == Signature ) {
-	PoolFreeBuffer( data );
+	ExFreePool( data );
     } else {
 	ASSERT( FALSE );
     }

lib/drivers/ip/transport/tcp/tcp.c

@@ -36,7 +36,6 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
     /* Things that can happen when we try the initial connection */
     if( NewState & SEL_CONNECT ) {
 	while( !IsListEmpty( &Connection->ConnectRequest ) ) {
-            Connection->State |= NewState;
             Entry = RemoveHeadList( &Connection->ConnectRequest );
             TI_DbgPrint(DEBUG_TCP, ("Connect Event\n"));
 
@@ -54,7 +53,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
             Complete( Bucket->Request.RequestContext, Status, 0 );
 
             /* Frees the bucket allocated in TCPConnect */
-            PoolFreeBuffer( Bucket );
+            exFreePool( Bucket );
         }
     }
 
@@ -91,7 +90,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
 		break;
 	    } else {
 		Complete( Bucket->Request.RequestContext, Status, 0 );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 	    }
 	}
     }
@@ -143,7 +142,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
 
 		Complete( Bucket->Request.RequestContext,
 			  STATUS_SUCCESS, Received );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 	    } else if( Status == STATUS_PENDING ) {
 		InsertHeadList
 		    ( &Connection->ReceiveRequest, &Bucket->Entry );
@@ -153,7 +152,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
 			    ("Completing Receive request: %x %x\n",
 			     Bucket->Request, Status));
 		Complete( Bucket->Request.RequestContext, Status, 0 );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 	    }
 	}
     }
@@ -202,7 +201,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
 
 		Complete( Bucket->Request.RequestContext,
 			  STATUS_SUCCESS, Sent );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 	    } else if( Status == STATUS_PENDING ) {
 		InsertHeadList
 		    ( &Connection->SendRequest, &Bucket->Entry );
@@ -212,7 +211,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
 			    ("Completing Send request: %x %x\n",
 			     Bucket->Request, Status));
 		Complete( Bucket->Request.RequestContext, Status, 0 );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 	    }
 	}
     }
@@ -239,7 +238,7 @@ static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection,
                 Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
                 Complete = Bucket->Request.RequestNotifyObject;
                 Complete( Bucket->Request.RequestContext, IrpStatus[i], 0 );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
             }
         }
     }
@@ -261,7 +260,7 @@ VOID DrainSignals() {
 
 PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint( PVOID ClientContext ) {
     PCONNECTION_ENDPOINT Connection =
-	ExAllocatePool(NonPagedPool, sizeof(CONNECTION_ENDPOINT));
+	exAllocatePool(NonPagedPool, sizeof(CONNECTION_ENDPOINT));
     if (!Connection)
 	return Connection;
 
@@ -283,9 +282,8 @@ PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint( PVOID ClientContext ) {
 }
 
 VOID TCPFreeConnectionEndpoint( PCONNECTION_ENDPOINT Connection ) {
-    TI_DbgPrint(MAX_TRACE,("FIXME: Cancel all pending requests\n"));
-    /* XXX Cancel all pending requests */
-    ExFreePool( Connection );
+    TCPClose( Connection );
+    exFreePool( Connection );
 }
 
 NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
@@ -406,10 +404,9 @@ TimerThread(PVOID Context)
         Timeout.QuadPart = (LONGLONG) (Next - Current) * -1000000; /* 100 ms */
         Status = KeWaitForSingleObject(&TimerLoopEvent, Executive, KernelMode,
                                        FALSE, &Timeout);
-        if (STATUS_SUCCESS == Status) {
-            PsTerminateSystemThread(STATUS_SUCCESS);
+        if (Status != STATUS_TIMEOUT) {
+            PsTerminateSystemThread(Status);
         }
-        ASSERT(STATUS_TIMEOUT == Status);
 
         TcpipRecursiveMutexEnter( &TCPLock, TRUE );
         TimerOskitTCP( Next == NextFast, Next == NextSlow );
@@ -548,7 +545,7 @@ NTSTATUS TCPConnect
 
     TI_DbgPrint(DEBUG_TCP,("TCPConnect: Called\n"));
 
-    Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) );
+    Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
     if( !Bucket ) return STATUS_NO_MEMORY;
 
     TcpipRecursiveMutexEnter( &TCPLock, TRUE );
@@ -578,21 +575,24 @@ NTSTATUS TCPConnect
     AddressToConnect.sin_family = AF_INET;
     AddressToBind = AddressToConnect;
 
-    OskitTCPBind( Connection->SocketContext,
+    Status = TCPTranslateError
+        ( OskitTCPBind( Connection->SocketContext,
 		  Connection,
 		  &AddressToBind,
-		  sizeof(AddressToBind) );
+		  sizeof(AddressToBind) ) );
 
-    memcpy( &AddressToConnect.sin_addr,
-	    &RemoteAddress.Address.IPv4Address,
-	    sizeof(AddressToConnect.sin_addr) );
-    AddressToConnect.sin_port = RemotePort;
+    if (NT_SUCCESS(Status)) {
+        memcpy( &AddressToConnect.sin_addr,
+	        &RemoteAddress.Address.IPv4Address,
+	        sizeof(AddressToConnect.sin_addr) );
+        AddressToConnect.sin_port = RemotePort;
 
-    Status = TCPTranslateError
-	( OskitTCPConnect( Connection->SocketContext,
-			   Connection,
-			   &AddressToConnect,
-			   sizeof(AddressToConnect) ) );
+        Status = TCPTranslateError
+	    ( OskitTCPConnect( Connection->SocketContext,
+		       	       Connection,
+			       &AddressToConnect,
+			       sizeof(AddressToConnect) ) );
+    }
 
     TcpipRecursiveMutexLeave( &TCPLock );
 
@@ -695,7 +695,7 @@ NTSTATUS TCPReceiveData
     /* Keep this request around ... there was no data yet */
     if( Status == STATUS_PENDING ) {
 	/* Freed in TCPSocketState */
-	Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) );
+	Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 	if( !Bucket ) {
 	    TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 	    TcpipRecursiveMutexLeave( &TCPLock );
@@ -754,7 +754,7 @@ NTSTATUS TCPSendData
     /* Keep this request around ... there was no data yet */
     if( Status == STATUS_PENDING ) {
 	/* Freed in TCPSocketState */
-	Bucket = ExAllocatePool( NonPagedPool, sizeof(*Bucket) );
+	Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 	if( !Bucket ) {
 	    TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 	    TcpipRecursiveMutexLeave( &TCPLock );
@@ -837,7 +837,7 @@ VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
 
     TcpipAcquireSpinLock( &Endpoint->Lock, &OldIrql );
 
-    for( i = 0; i < sizeof( ListHead ) / sizeof( ListHead[0] ); i++ ) {
+    for( i = 0; i < 4; i++ ) {
 	for( Entry = ListHead[i]->Flink;
 	     Entry != ListHead[i];
 	     Entry = Entry->Flink ) {
@@ -845,7 +845,7 @@ VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
 
 	    if( Bucket->Request.RequestContext == Irp ) {
 		RemoveEntryList( &Bucket->Entry );
-		PoolFreeBuffer( Bucket );
+		exFreePool( Bucket );
 		break;
 	    }
 	}

lib/drivers/ip/transport/udp/udp.c

@@ -33,18 +33,20 @@ NTSTATUS AddUDPHeaderIPv4(
  */
 {
     PUDP_HEADER UDPHeader;
+    NTSTATUS Status;
 
     TI_DbgPrint(MID_TRACE, ("Packet: %x NdisPacket %x\n",
 			    IPPacket, IPPacket->NdisPacket));
 
-    AddGenericHeaderIPv4
+    Status = AddGenericHeaderIPv4
         ( RemoteAddress, RemotePort,
           LocalAddress, LocalPort,
           IPPacket, DataLength, IPPROTO_UDP,
           sizeof(UDP_HEADER), (PVOID *)&UDPHeader );
 
-    /* Build UDP header */
-    UDPHeader = (PUDP_HEADER)((ULONG_PTR)IPPacket->Data - sizeof(UDP_HEADER));
+    if (!NT_SUCCESS(Status))
+        return Status;
+
     /* Port values are already big-endian values */
     UDPHeader->SourcePort = LocalPort;
     UDPHeader->DestPort   = RemotePort;
@@ -53,8 +55,6 @@ NTSTATUS AddUDPHeaderIPv4(
     /* Length of UDP header and data */
     UDPHeader->Length     = WH2N(DataLength + sizeof(UDP_HEADER));
 
-    IPPacket->Data        = ((PCHAR)UDPHeader) + sizeof(UDP_HEADER);
-
     TI_DbgPrint(MID_TRACE, ("Packet: %d ip %d udp %d payload\n",
 			    (PCHAR)UDPHeader - (PCHAR)IPPacket->Header,
 			    (PCHAR)IPPacket->Data - (PCHAR)UDPHeader,
@@ -195,10 +195,16 @@ NTSTATUS UDPSendDatagram(
     if( !NT_SUCCESS(Status) )
 	return Status;
 
-    if(!(NCE = RouteGetRouteToDestination( &RemoteAddress )))
+    if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
+        FreeNdisPacket(Packet.NdisPacket);
 	return STATUS_UNSUCCESSFUL;
+    }
 
-    IPSendDatagram( &Packet, NCE, UDPSendPacketComplete, NULL );
+    if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, UDPSendPacketComplete, NULL )))
+    {
+        FreeNdisPacket(Packet.NdisPacket);
+        return Status;
+    }
 
     return STATUS_SUCCESS;
 }
@@ -305,7 +311,7 @@ NTSTATUS UDPStartup(
   
   NTSTATUS Status;
 
-  Status = PortsStartup( &UDPPorts, 1, 0xfffe );
+  Status = PortsStartup( &UDPPorts, 1, UDP_STARTING_PORT + UDP_DYNAMIC_PORTS );
 
   if( !NT_SUCCESS(Status) ) return Status;
 

lib/drivers/oskittcp/include/memtrack.h

@@ -8,7 +8,7 @@
 #define FBSD_MALLOC FOURCC('d','s','b','f')
 #define EXALLOC_TAG FOURCC('E','x','A','l')
 
-#ifdef MEMTRACK
+#ifdef DBG
 #define MTMARK() TrackDumpFL(__FILE__, __LINE__)
 #define NdisAllocateBuffer(x,y,z,a,b) { \
     NdisAllocateBuffer(x,y,z,a,b); \
@@ -71,8 +71,10 @@ static __inline VOID ExFreePoolX( PVOID Data, PCHAR File, ULONG Line ) {
 #define exFreePool(x) ExFreePool(x)
 #define exAllocatePool(x,y) ExAllocatePool(x,y)
 #define exAllocatePoolWithTag(x,y,z) ExAllocatePoolWithTag(x,y,z)
-#define TrackWithTag(a,b,c,d)
-#define UntrackFL(a,b,c)
+#define exAllocateFromNPagedLookasideList(x) ExAllocateFromNPagedLookasideList(x)
+#define exFreeToNPagedLookasideList(x,y) ExFreeToNPagedLookasideList(x,y)
+#define TrackWithTag(w,x,y,z)
+#define UntrackFL(w,x,y,z)
 #endif
 
 #endif/*MEMMTRAC_H*/