Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 02:34:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Revert 44301

Browse source 
svn path=/branches/aicom-network-branch/; revision=44354
This commit is contained in:
Cameron Gutman 2009-12-02 03:29:17 +00:00
parent 29fa274d6d f41f818156
commit 2cb569197b
49 changed files with 972 additions and 1603 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
drivers/network/tcpip/datalink/lan.c
View file

@ -108,7 +108,7 @@ VOID FreeAdapter(
* Adapter = Pointer to LAN_ADAPTER structure to free * Adapter = Pointer to LAN_ADAPTER structure to free
*/ */
{ {
exFreePool(Adapter); ExFreePoolWithTag(Adapter, LAN_ADAPTER_TAG);
} }
@ -249,7 +249,7 @@ VOID LanReceiveWorker( PVOID Context ) {
Adapter = WorkItem->Adapter; Adapter = WorkItem->Adapter;
BytesTransferred = WorkItem->BytesTransferred; BytesTransferred = WorkItem->BytesTransferred;
exFreePool(WorkItem); ExFreePoolWithTag(WorkItem, WQ_CONTEXT_TAG);
IPInitializePacket(&IPPacket, 0); IPInitializePacket(&IPPacket, 0);
@ -300,7 +300,8 @@ VOID LanSubmitReceiveWork(
PNDIS_PACKET Packet, PNDIS_PACKET Packet,
NDIS_STATUS Status, NDIS_STATUS Status,
UINT BytesTransferred) { UINT BytesTransferred) {
PLAN_WQ_ITEM WQItem = exAllocatePool(NonPagedPool, sizeof(LAN_WQ_ITEM)); PLAN_WQ_ITEM WQItem = ExAllocatePoolWithTag(NonPagedPool, sizeof(LAN_WQ_ITEM),
WQ_CONTEXT_TAG);
PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext; PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
TI_DbgPrint(DEBUG_DATALINK,("called\n")); TI_DbgPrint(DEBUG_DATALINK,("called\n"));
@ -312,7 +313,7 @@ VOID LanSubmitReceiveWork(
WQItem->BytesTransferred = BytesTransferred; WQItem->BytesTransferred = BytesTransferred;
if (!ChewCreate( LanReceiveWorker, WQItem )) if (!ChewCreate( LanReceiveWorker, WQItem ))
exFreePool(WQItem); ExFreePoolWithTag(WQItem, WQ_CONTEXT_TAG);
} }
VOID NTAPI ProtocolTransferDataComplete( VOID NTAPI ProtocolTransferDataComplete(
@ -768,9 +769,9 @@ NTSTATUS NTAPI AppendUnicodeString(PUNICODE_STRING ResultFirst,
BOOLEAN Deallocate) { BOOLEAN Deallocate) {
NTSTATUS Status; NTSTATUS Status;
UNICODE_STRING Ustr = *ResultFirst; UNICODE_STRING Ustr = *ResultFirst;
PWSTR new_string = ExAllocatePoolWithTag PWSTR new_string = ExAllocatePool
(PagedPool, (PagedPool,
(ResultFirst->Length + Second->Length + sizeof(WCHAR)), TAG_STRING); (ResultFirst->Length + Second->Length + sizeof(WCHAR)));
if( !new_string ) { if( !new_string ) {
return STATUS_NO_MEMORY; return STATUS_NO_MEMORY;
} }
@ -991,6 +992,11 @@ BOOLEAN BindAdapter(
GetName( RegistryPath, &IF->Name ); GetName( RegistryPath, &IF->Name );
Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description ); Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description );
if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to get device description.\n"));
IPDestroyInterface(IF);
return FALSE;
}
TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n", TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n",
&IF->Description)); &IF->Description));
@ -1082,7 +1088,7 @@ NDIS_STATUS LANRegisterAdapter(
TI_DbgPrint(DEBUG_DATALINK, ("Called.\n")); TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
IF = exAllocatePool(NonPagedPool, sizeof(LAN_ADAPTER)); IF = ExAllocatePoolWithTag(NonPagedPool, sizeof(LAN_ADAPTER), LAN_ADAPTER_TAG);
if (!IF) { if (!IF) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NDIS_STATUS_RESOURCES; return NDIS_STATUS_RESOURCES;
@ -1120,7 +1126,7 @@ NDIS_STATUS LANRegisterAdapter(
KeWaitForSingleObject(&IF->Event, UserRequest, KernelMode, FALSE, NULL); KeWaitForSingleObject(&IF->Event, UserRequest, KernelMode, FALSE, NULL);
else if (NdisStatus != NDIS_STATUS_SUCCESS) { else if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ\n", AdapterName)); TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ\n", AdapterName));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NdisStatus; return NdisStatus;
} }
@ -1145,7 +1151,7 @@ NDIS_STATUS LANRegisterAdapter(
default: default:
/* Unsupported media */ /* Unsupported media */
TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n")); TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NDIS_STATUS_NOT_SUPPORTED; return NDIS_STATUS_NOT_SUPPORTED;
} }
@ -1157,7 +1163,7 @@ NDIS_STATUS LANRegisterAdapter(
sizeof(UINT)); sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ (NDISCall)\n", AdapterName)); TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ (NDISCall)\n", AdapterName));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NdisStatus; return NdisStatus;
} }
@ -1169,7 +1175,7 @@ NDIS_STATUS LANRegisterAdapter(
sizeof(UINT)); sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum packet size failed.\n")); TI_DbgPrint(MIN_TRACE, ("Query for maximum packet size failed.\n"));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NdisStatus; return NdisStatus;
} }
@ -1192,7 +1198,7 @@ NDIS_STATUS LANRegisterAdapter(
IF->HWAddressLength); IF->HWAddressLength);
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n")); TI_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n"));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NdisStatus; return NdisStatus;
} }
@ -1204,7 +1210,7 @@ NDIS_STATUS LANRegisterAdapter(
sizeof(UINT)); sizeof(UINT));
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
TI_DbgPrint(MIN_TRACE, ("Query for maximum link speed failed.\n")); TI_DbgPrint(MIN_TRACE, ("Query for maximum link speed failed.\n"));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NdisStatus; return NdisStatus;
} }
@ -1214,7 +1220,7 @@ NDIS_STATUS LANRegisterAdapter(
/* Bind adapter to IP layer */ /* Bind adapter to IP layer */
if( !BindAdapter(IF, RegistryPath) ) { if( !BindAdapter(IF, RegistryPath) ) {
TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ (BindAdapter)\n", AdapterName)); TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ (BindAdapter)\n", AdapterName));
exFreePool(IF); ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
return NDIS_STATUS_NOT_ACCEPTED; return NDIS_STATUS_NOT_ACCEPTED;
} }

1
drivers/network/tcpip/include/address.h
View file

@ -15,7 +15,6 @@
*/ */
#define AddrInitIPv4(IPAddress, RawAddress) \ #define AddrInitIPv4(IPAddress, RawAddress) \
{ \ { \
INIT_TAG((IPAddress), '4VPI'); \
(IPAddress)->Type = IP_ADDRESS_V4; \ (IPAddress)->Type = IP_ADDRESS_V4; \
(IPAddress)->Address.IPv4Address = (RawAddress); \ (IPAddress)->Address.IPv4Address = (RawAddress); \
} }

2
drivers/network/tcpip/include/datagram.h
View file

@ -21,7 +21,7 @@ NTSTATUS DGReceiveDatagram(
PVOID Context, PVOID Context,
PIRP Irp); PIRP Irp);
VOID DGRemoveIRP( BOOLEAN DGRemoveIRP(
PADDRESS_FILE AddrFile, PADDRESS_FILE AddrFile,
PIRP Irp); PIRP Irp);

2
drivers/network/tcpip/include/debug.h
View file

@ -71,8 +71,6 @@
#define CP CHECKPOINT #define CP CHECKPOINT
#include <memtrack.h>
#define ASSERT_KM_POINTER(_x) \ #define ASSERT_KM_POINTER(_x) \
ASSERT(((PVOID)_x) != (PVOID)0xcccccccc); \ ASSERT(((PVOID)_x) != (PVOID)0xcccccccc); \
ASSERT(((PVOID)_x) >= (PVOID)0x80000000); ASSERT(((PVOID)_x) >= (PVOID)0x80000000);

2
drivers/network/tcpip/include/dispatch.h
View file

@ -72,6 +72,8 @@ NTSTATUS DispTdiDeleteIPAddress(
VOID DispDoDisconnect( VOID DispDoDisconnect(
PVOID Data); PVOID Data);
NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status );
#endif /* __DISPATCH_H */ #endif /* __DISPATCH_H */
/* EOF */ /* EOF */

3
drivers/network/tcpip/include/fileobjs.h
View file

@ -13,7 +13,6 @@ extern KSPIN_LOCK AddressFileListLock;
extern LIST_ENTRY ConnectionEndpointListHead; extern LIST_ENTRY ConnectionEndpointListHead;
extern KSPIN_LOCK ConnectionEndpointListLock; extern KSPIN_LOCK ConnectionEndpointListLock;
NTSTATUS FileOpenAddress( NTSTATUS FileOpenAddress(
PTDI_REQUEST Request, PTDI_REQUEST Request,
PTA_IP_ADDRESS AddrList, PTA_IP_ADDRESS AddrList,
@ -27,8 +26,6 @@ NTSTATUS FileOpenConnection(
PTDI_REQUEST Request, PTDI_REQUEST Request,
PVOID ClientContext); PVOID ClientContext);
PCONNECTION_ENDPOINT FileFindConnectionByContext( PVOID Context );
NTSTATUS FileCloseConnection( NTSTATUS FileCloseConnection(
PTDI_REQUEST Request); PTDI_REQUEST Request);

3
drivers/network/tcpip/include/ip.h
View file

@ -21,7 +21,6 @@ typedef IPv6_RAW_ADDRESS *PIPv6_RAW_ADDRESS;
/* IP style address */ /* IP style address */
typedef struct IP_ADDRESS { typedef struct IP_ADDRESS {
DEFINE_TAG
UCHAR Type; /* Type of IP address */ UCHAR Type; /* Type of IP address */
union { union {
IPv4_RAW_ADDRESS IPv4Address;/* IPv4 address (in network byte order) */ IPv4_RAW_ADDRESS IPv4Address;/* IPv4 address (in network byte order) */
@ -76,7 +75,6 @@ typedef VOID (*PACKET_COMPLETION_ROUTINE)(
/* Structure for an IP packet */ /* Structure for an IP packet */
typedef struct _IP_PACKET { typedef struct _IP_PACKET {
DEFINE_TAG
OBJECT_FREE_ROUTINE Free; /* Routine used to free resources for the object */ OBJECT_FREE_ROUTINE Free; /* Routine used to free resources for the object */
UCHAR Type; /* Type of IP packet (see IP_ADDRESS_xx above) */ UCHAR Type; /* Type of IP packet (see IP_ADDRESS_xx above) */
UCHAR Flags; /* Flags for packet (see IP_PACKET_FLAG_xx below)*/ UCHAR Flags; /* Flags for packet (see IP_PACKET_FLAG_xx below)*/
@ -150,7 +148,6 @@ typedef struct _SEND_RECV_STATS {
/* Information about an IP interface */ /* Information about an IP interface */
typedef struct _IP_INTERFACE { typedef struct _IP_INTERFACE {
DEFINE_TAG
LIST_ENTRY ListEntry; /* Entry on list */ LIST_ENTRY ListEntry; /* Entry on list */
OBJECT_FREE_ROUTINE Free; /* Routine used to free resources used by the object */ OBJECT_FREE_ROUTINE Free; /* Routine used to free resources used by the object */
KSPIN_LOCK Lock; /* Spin lock for this object */ KSPIN_LOCK Lock; /* Spin lock for this object */

13
drivers/network/tcpip/include/irp.h
View file

@ -1,13 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS TCP/IP protocol driver
* FILE: include/irp.h
* PURPOSE: IRP routines
*/
#ifndef __IRP_H
#define __IRP_H
VOID IRPRemember( PIRP Irp, PCHAR File, UINT Line );
NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status );
#endif/*__IRP_H*/

4
drivers/network/tcpip/include/lock.h
View file

@ -12,9 +12,5 @@ extern VOID TcpipInterlockedInsertTailList( PLIST_ENTRY ListHead,
PKSPIN_LOCK Lock ); PKSPIN_LOCK Lock );
extern VOID TcpipAcquireFastMutex( PFAST_MUTEX Mutex ); extern VOID TcpipAcquireFastMutex( PFAST_MUTEX Mutex );
extern VOID TcpipReleaseFastMutex( PFAST_MUTEX Mutex ); extern VOID TcpipReleaseFastMutex( PFAST_MUTEX Mutex );
extern VOID TcpipRecursiveMutexInit( PRECURSIVE_MUTEX RecMutex );
extern VOID TcpipRecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex,
BOOLEAN ToWrite );
extern VOID TcpipRecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex );
#endif/*_LOCK_H*/ #endif/*_LOCK_H*/

79
drivers/network/tcpip/include/memtrack.h
View file

@ -1,79 +0,0 @@
#ifndef MEMTRACK_H
#define MEMTRACK_H
#include <pool.h>
#ifndef FOURCC
#define FOURCC(a,b,c,d) (((a)<<24)|((b)<<16)|((c)<<8)|(d))
#endif
#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__)
#if 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__)
#define exAllocateFromNPagedLookasideList(x) ExAllocateFromNPagedLookasideListX(x,__FILE__,__LINE__)
#define exFreeToNPagedLookasideList(x,y) ExFreeToNPagedLookasideListX(x,y,__FILE__,__LINE__)
typedef struct _ALLOCATION_TRACKER {
LIST_ENTRY Entry;
ULONG Tag;
PVOID Thing;
PCHAR FileName;
ULONG LineNo;
} ALLOCATION_TRACKER, *PALLOCATION_TRACKER;
VOID TrackingInit();
VOID TrackWithTag( ULONG Tag, PVOID Thing, PCHAR File, ULONG Line );
#define Track(Tag,Thing) TrackWithTag(Tag,Thing,__FILE__,__LINE__)
VOID UntrackFL( PCHAR File, ULONG Line, PVOID Thing, ULONG Tag );
#define Untrack(Thing) UntrackFL(__FILE__,__LINE__,Thing)
VOID TrackDumpFL( PCHAR File, ULONG Line );
#define TrackDump() TrackDumpFL(__FILE__,__LINE__)
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 = 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, EXALLOC_TAG);
ExFreePool( Data );
}
#else
#define MTMARK()
#define Track(x,y)
#define TrackingInit()
#define TrackDump()
#define Untrack(x)
#define exAllocatePoolWithTag(x,y,z) ExAllocatePoolWithTag(x,y,z)
#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(w,x,y,z)
#endif
#endif/*MEMMTRAC_H*/

1
drivers/network/tcpip/include/neighbor.h
View file

@ -27,7 +27,6 @@ typedef struct NEIGHBOR_CACHE_TABLE {
/* Information about a neighbor */ /* Information about a neighbor */
typedef struct NEIGHBOR_CACHE_ENTRY { typedef struct NEIGHBOR_CACHE_ENTRY {
DEFINE_TAG
struct NEIGHBOR_CACHE_ENTRY *Next; /* Pointer to next entry */ struct NEIGHBOR_CACHE_ENTRY *Next; /* Pointer to next entry */
UCHAR State; /* State of NCE */ UCHAR State; /* State of NCE */
UINT EventTimer; /* Ticks since last event */ UINT EventTimer; /* Ticks since last event */

4
drivers/network/tcpip/include/precomp.h
View file

@ -1,9 +1,9 @@
#include <limits.h> #include <limits.h>
#include <ntddk.h> #include <ntddk.h>
#include <ntifs.h> #include <ntifs.h>
#include <tags.h>
#include <tdi.h> #include <tdi.h>
#include <tdistat.h> #include <tdistat.h>
#include <../recmutex/recmutex.h>
#include <tcpip.h> #include <tcpip.h>
#include <loopback.h> #include <loopback.h>
#include <ip.h> #include <ip.h>
@ -24,13 +24,11 @@
#include <udp.h> #include <udp.h>
#include <tcp.h> #include <tcp.h>
#include <arp.h> #include <arp.h>
#include <irp.h>
#include <tilists.h> #include <tilists.h>
#include <dispatch.h> #include <dispatch.h>
#include <fileobjs.h> #include <fileobjs.h>
#include <lock.h> #include <lock.h>
#include <wait.h> #include <wait.h>
#include <memtrack.h>
#include <oskittcp.h> #include <oskittcp.h>
#include <interface.h> #include <interface.h>
#include <ports.h> #include <ports.h>

7
drivers/network/tcpip/include/routines.h
View file

@ -49,9 +49,10 @@ UINT ResizePacket(
PNDIS_PACKET Packet, PNDIS_PACKET Packet,
UINT Size); UINT Size);
NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket, NDIS_STATUS AllocatePacketWithBuffer( PNDIS_PACKET *NdisPacket,
PCHAR Data, UINT Len, PCHAR Data, UINT Len );
PCHAR File, UINT Line );
VOID FreeNdisPacket( PNDIS_PACKET Packet );
void GetDataPtr( PNDIS_PACKET Packet, void GetDataPtr( PNDIS_PACKET Packet,
UINT Offset, UINT Offset,

39
drivers/network/tcpip/include/tags.h Normal file
View file

@ -0,0 +1,39 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS TCP/IP protocol driver
* FILE: include/tags.h
* PURPOSE: Memory tags
*/
#ifndef __TAGS_H
#define __TAGS_H
#define CONN_ENDPT_TAG 'pEnC'
#define ADDR_FILE_TAG 'FrdA'
#define CONTROL_CHANNEL_TAG 'CnoC'
#define TRANS_CONTEXT_TAG 'noCT'
#define TDI_ENTITY_TAG 'EidT'
#define DATAGRAM_SEND_TAG 'StaD'
#define DATAGRAM_RECV_TAG 'RtaD'
#define QUERY_CONTEXT_TAG 'noCQ'
#define IP_ADDRESS_TAG 'dAPI'
#define IP_INTERFACE_TAG 'FIPI'
#define DATAGRAM_REASSEMBLY_TAG 'RDPI'
#define DATAGRAM_FRAGMENT_TAG 'GFPI'
#define DATAGRAM_HOLE_TAG 'LHPI'
#define OSKITTCP_CONTEXT_TAG 'TKSO'
#define NEIGHBOR_PACKET_TAG 'kPbN'
#define NCE_TAG ' ECN'
#define PORT_SET_TAG 'teSP'
#define PACKET_BUFFER_TAG 'fuBP'
#define FRAGMENT_DATA_TAG 'taDF'
#define FIB_TAG ' BIF'
#define IFC_TAG ' CFI'
#define TDI_BUCKET_TAG 'BidT'
#define FBSD_TAG 'DSBF'
#define OSK_OTHER_TAG 'OKSO'
#define OSK_LARGE_TAG 'LKSO'
#define OSK_SMALL_TAG 'SKSO'
#define LAN_ADAPTER_TAG ' NAL'
#define WQ_CONTEXT_TAG 'noCW'
#endif

21
drivers/network/tcpip/include/tcp.h
View file

@ -59,6 +59,11 @@ typedef struct _SLEEPING_THREAD {
KEVENT Event; KEVENT Event;
} SLEEPING_THREAD, *PSLEEPING_THREAD; } SLEEPING_THREAD, *PSLEEPING_THREAD;
typedef struct _CLIENT_DATA {
BOOLEAN Unlocked;
KSPIN_LOCK Lock;
} CLIENT_DATA, *PCLIENT_DATA;
/* Retransmission timeout constants */ /* Retransmission timeout constants */
/* Lower bound for retransmission timeout in TCP timer ticks */ /* Lower bound for retransmission timeout in TCP timer ticks */
@ -84,19 +89,15 @@ typedef struct _SLEEPING_THREAD {
#define SRF_FIN TCP_FIN #define SRF_FIN TCP_FIN
extern LONG TCP_IPIdentification; extern LONG TCP_IPIdentification;
extern LIST_ENTRY SignalledConnectionsList; extern CLIENT_DATA ClientInfo;
extern KSPIN_LOCK SignalledConnectionsLock;
extern LIST_ENTRY SleepingThreadsList;
extern FAST_MUTEX SleepingThreadsLock;
extern RECURSIVE_MUTEX TCPLock;
/* accept.c */ /* accept.c */
NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener, NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener,
PCONNECTION_ENDPOINT Connection, PCONNECTION_ENDPOINT Connection,
PTDI_REQUEST_KERNEL Request ); PTDI_REQUEST_KERNEL Request );
NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog ); NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog );
VOID TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener, BOOLEAN TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener,
PCONNECTION_ENDPOINT Connection ); PCONNECTION_ENDPOINT Connection );
NTSTATUS TCPAccept NTSTATUS TCPAccept
( PTDI_REQUEST Request, ( PTDI_REQUEST Request,
PCONNECTION_ENDPOINT Listener, PCONNECTION_ENDPOINT Listener,
@ -111,6 +112,8 @@ VOID TCPFreeConnectionEndpoint( PCONNECTION_ENDPOINT Connection );
NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection, NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
UINT Family, UINT Type, UINT Proto ); UINT Family, UINT Type, UINT Proto );
VOID HandleSignalledConnection(PCONNECTION_ENDPOINT Connection);
PTCP_SEGMENT TCPCreateSegment( PTCP_SEGMENT TCPCreateSegment(
PIP_PACKET IPPacket, PIP_PACKET IPPacket,
PTCPv4_HEADER TCPHeader, PTCPv4_HEADER TCPHeader,
@ -161,8 +164,6 @@ NTSTATUS TCPClose( PCONNECTION_ENDPOINT Connection );
NTSTATUS TCPTranslateError( int OskitError ); NTSTATUS TCPTranslateError( int OskitError );
VOID TCPTimeout();
UINT TCPAllocatePort( UINT HintPort ); UINT TCPAllocatePort( UINT HintPort );
VOID TCPFreePort( UINT Port ); VOID TCPFreePort( UINT Port );
@ -178,6 +179,6 @@ NTSTATUS TCPStartup(
NTSTATUS TCPShutdown( NTSTATUS TCPShutdown(
VOID); VOID);
VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Connection, PIRP Irp ); BOOLEAN TCPRemoveIRP( PCONNECTION_ENDPOINT Connection, PIRP Irp );
#endif /* __TCP_H */ #endif /* __TCP_H */

40
drivers/network/tcpip/include/titypes.h
View file

@ -10,10 +10,6 @@
#if DBG #if DBG
#define DEFINE_TAG ULONG Tag;
#define INIT_TAG(_Object, _Tag) \
((_Object)->Tag = (_Tag))
#define DEBUG_REFCHECK(Object) { \ #define DEBUG_REFCHECK(Object) { \
if ((Object)->RefCount <= 0) { \ if ((Object)->RefCount <= 0) { \
TI_DbgPrint(MIN_TRACE, ("Object at (0x%X) has invalid reference count (%d).\n", \ TI_DbgPrint(MIN_TRACE, ("Object at (0x%X) has invalid reference count (%d).\n", \
@ -64,9 +60,6 @@
#else /* DBG */ #else /* DBG */
#define DEFINE_TAG
#define INIT_TAG(Object, Tag)
/* /*
* VOID ReferenceObject( * VOID ReferenceObject(
* PVOID Object) * PVOID Object)
@ -149,11 +142,9 @@ typedef struct _DATAGRAM_SEND_REQUEST {
/* Transport address file context structure. The FileObject->FsContext2 /* Transport address file context structure. The FileObject->FsContext2
field holds a pointer to this structure */ field holds a pointer to this structure */
typedef struct _ADDRESS_FILE { typedef struct _ADDRESS_FILE {
DEFINE_TAG
LIST_ENTRY ListEntry; /* Entry on list */ LIST_ENTRY ListEntry; /* Entry on list */
KSPIN_LOCK Lock; /* Spin lock to manipulate this structure */ KSPIN_LOCK Lock; /* Spin lock to manipulate this structure */
OBJECT_FREE_ROUTINE Free; /* Routine to use to free resources for the object */ OBJECT_FREE_ROUTINE Free; /* Routine to use to free resources for the object */
USHORT Flags; /* Flags for address file (see below) */
IP_ADDRESS Address; /* Address of this address file */ IP_ADDRESS Address; /* Address of this address file */
USHORT Family; /* Address family */ USHORT Family; /* Address family */
USHORT Protocol; /* Protocol number */ USHORT Protocol; /* Protocol number */
@ -213,29 +204,6 @@ typedef struct _ADDRESS_FILE {
BOOLEAN RegisteredChainedReceiveExpeditedHandler; BOOLEAN RegisteredChainedReceiveExpeditedHandler;
} ADDRESS_FILE, *PADDRESS_FILE; } ADDRESS_FILE, *PADDRESS_FILE;
/* Address File Flag constants */
#define AFF_VALID 0x0001 /* Address file object is valid for use */
#define AFF_BUSY 0x0002 /* Address file object is exclusive to someone */
#define AFF_DELETE 0x0004 /* Address file object is sheduled to be deleted */
#define AFF_SEND 0x0008 /* A send request is pending */
#define AFF_RECEIVE 0x0010 /* A receive request is pending */
#define AFF_PENDING 0x001C /* A request is pending */
/* Macros for manipulating address file object flags */
#define AF_IS_VALID(ADF) ((ADF)->Flags & AFF_VALID)
#define AF_SET_VALID(ADF) ((ADF)->Flags |= AFF_VALID)
#define AF_CLR_VALID(ADF) ((ADF)->Flags &= ~AFF_VALID)
#define AF_IS_BUSY(ADF) ((ADF)->Flags & AFF_BUSY)
#define AF_SET_BUSY(ADF) ((ADF)->Flags |= AFF_BUSY)
#define AF_CLR_BUSY(ADF) ((ADF)->Flags &= ~AFF_BUSY)
#define AF_IS_PENDING(ADF, X) (ADF->Flags & X)
#define AF_SET_PENDING(ADF, X) (ADF->Flags |= X)
#define AF_CLR_PENDING(ADF, X) (ADF->Flags &= ~X)
/* Structure used to search through Address Files */ /* Structure used to search through Address Files */
typedef struct _AF_SEARCH { typedef struct _AF_SEARCH {
PLIST_ENTRY Next; /* Next address file to check */ PLIST_ENTRY Next; /* Next address file to check */
@ -287,6 +255,8 @@ typedef struct _TDI_BUCKET {
LIST_ENTRY Entry; LIST_ENTRY Entry;
struct _CONNECTION_ENDPOINT *AssociatedEndpoint; struct _CONNECTION_ENDPOINT *AssociatedEndpoint;
TDI_REQUEST Request; TDI_REQUEST Request;
NTSTATUS Status;
ULONG Information;
} TDI_BUCKET, *PTDI_BUCKET; } TDI_BUCKET, *PTDI_BUCKET;
/* Transport connection context structure A.K.A. Transmission Control Block /* Transport connection context structure A.K.A. Transmission Control Block
@ -299,19 +269,15 @@ typedef struct _CONNECTION_ENDPOINT {
PADDRESS_FILE AddressFile; /* Associated address file object (NULL if none) */ PADDRESS_FILE AddressFile; /* Associated address file object (NULL if none) */
PVOID SocketContext; /* Context for lower layer */ PVOID SocketContext; /* Context for lower layer */
UINT State; /* Socket state W.R.T. oskit */
/* Requests */ /* Requests */
LIST_ENTRY ConnectRequest; /* Queued connect rqueusts */ LIST_ENTRY ConnectRequest; /* Queued connect rqueusts */
LIST_ENTRY ListenRequest; /* Queued listen requests */ LIST_ENTRY ListenRequest; /* Queued listen requests */
LIST_ENTRY ReceiveRequest; /* Queued receive requests */ LIST_ENTRY ReceiveRequest; /* Queued receive requests */
LIST_ENTRY SendRequest; /* Queued send requests */ LIST_ENTRY SendRequest; /* Queued send requests */
LIST_ENTRY CompletionQueue;/* Completed requests to finish */
/* Signals */ /* Signals */
LIST_ENTRY SignalList; /* Entry in the list of sockets waiting for
* notification service to the client */
UINT SignalState; /* Active signals from oskit */ UINT SignalState; /* Active signals from oskit */
BOOLEAN Signalled; /* Are we a member of the signal list */
} CONNECTION_ENDPOINT, *PCONNECTION_ENDPOINT; } CONNECTION_ENDPOINT, *PCONNECTION_ENDPOINT;

61
drivers/network/tcpip/recmutex/recmutex.c
View file

@ -1,61 +0,0 @@
#include <ntddk.h>
#include "recmutex.h"
VOID RecursiveMutexInit( PRECURSIVE_MUTEX RecMutex ) {
RtlZeroMemory( RecMutex, sizeof(*RecMutex) );
ExInitializeFastMutex( &RecMutex->Mutex );
KeInitializeEvent( &RecMutex->StateLockedEvent,
NotificationEvent, FALSE );
}
/* NOTE: When we leave, the FAST_MUTEX must have been released. The result
* is that we always exit in the same irql as entering */
VOID RecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex ) {
NTSTATUS Status = STATUS_SUCCESS;
PVOID CurrentThread = KeGetCurrentThread();
ASSERT(RecMutex);
ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
/* Wait for the previous user to unlock the RecMutex state. There might be
* multiple waiters waiting to change the state. We need to check each
* time we get the event whether somebody still has the state locked */
ExAcquireFastMutex( &RecMutex->Mutex );
if( CurrentThread == RecMutex->CurrentThread ) {
RecMutex->LockCount++;
ExReleaseFastMutex( &RecMutex->Mutex );
return;
}
while( RecMutex->LockCount != 0 ) {
ExReleaseFastMutex( &RecMutex->Mutex );
Status = KeWaitForSingleObject( &RecMutex->StateLockedEvent,
UserRequest,
KernelMode,
FALSE,
NULL );
ExAcquireFastMutex( &RecMutex->Mutex );
}
RecMutex->CurrentThread = CurrentThread;
RecMutex->LockCount++;
ExReleaseFastMutex( &RecMutex->Mutex );
}
VOID RecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex ) {
ASSERT(RecMutex);
ExAcquireFastMutex( &RecMutex->Mutex );
ASSERT(RecMutex->LockCount > 0);
RecMutex->LockCount--;
if( !RecMutex->LockCount ) {
KePulseEvent( &RecMutex->StateLockedEvent, IO_NETWORK_INCREMENT,
FALSE );
}
ExReleaseFastMutex( &RecMutex->Mutex );
}

21
drivers/network/tcpip/recmutex/recmutex.h
View file

@ -1,21 +0,0 @@
#ifndef _ROSRTL_RECMUTEX_H
#define _ROSRTL_RECMUTEX_H
typedef struct _RECURSIVE_MUTEX {
/* Lock. */
FAST_MUTEX Mutex;
/* Number of times this object was locked */
SIZE_T LockCount;
/* CurrentThread */
PVOID CurrentThread;
/* Notification event which signals that another thread can take over */
KEVENT StateLockedEvent;
} RECURSIVE_MUTEX, *PRECURSIVE_MUTEX;
extern VOID RecursiveMutexInit( PRECURSIVE_MUTEX RecMutex );
extern VOID RecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex );
extern VOID RecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex );
#define ASSERT_LOCKED(x)
#endif/*_ROSRTL_RECMUTEX_H*/

4
drivers/network/tcpip/tcpip.rbuild
View file

@ -21,9 +21,6 @@
<directory name="datalink"> <directory name="datalink">
<file>lan.c</file> <file>lan.c</file>
</directory> </directory>
<directory name="recmutex">
<file>recmutex.c</file>
</directory>
<directory name="tcpip"> <directory name="tcpip">
<file>ainfo.c</file> <file>ainfo.c</file>
<file>buffer.c</file> <file>buffer.c</file>
@ -31,7 +28,6 @@
<file>fileobjs.c</file> <file>fileobjs.c</file>
<file>iinfo.c</file> <file>iinfo.c</file>
<file>info.c</file> <file>info.c</file>
<file>irp.c</file>
<file>lock.c</file> <file>lock.c</file>
<file>main.c</file> <file>main.c</file>
<file>ninfo.c</file> <file>ninfo.c</file>

5
drivers/network/tcpip/tcpip/ainfo.c
View file

@ -13,6 +13,8 @@ TDI_STATUS SetAddressFileInfo(TDIObjectID *ID,
PVOID Buffer, PVOID Buffer,
UINT BufferSize) UINT BufferSize)
{ {
//KIRQL OldIrql;
switch (ID->toi_id) switch (ID->toi_id)
{ {
#if 0 #if 0
@ -20,7 +22,10 @@ TDI_STATUS SetAddressFileInfo(TDIObjectID *ID,
if (BufferSize < sizeof(UCHAR)) if (BufferSize < sizeof(UCHAR))
return TDI_INVALID_PARAMETER; return TDI_INVALID_PARAMETER;
KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
AddrFile->TTL = *((PUCHAR)Buffer); AddrFile->TTL = *((PUCHAR)Buffer);
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return TDI_SUCCESS; return TDI_SUCCESS;
#endif #endif
default: default:

30
drivers/network/tcpip/tcpip/buffer.c
View file

@ -318,13 +318,16 @@ NDIS_STATUS PrependPacket( PNDIS_PACKET Packet, PCHAR Data, UINT Length,
PCHAR NewBuf; PCHAR NewBuf;
if( Copy ) { if( Copy ) {
NewBuf = exAllocatePool( NonPagedPool, Length ); NewBuf = ExAllocatePoolWithTag( NonPagedPool, Length, PACKET_BUFFER_TAG );
if( !NewBuf ) return NDIS_STATUS_RESOURCES; if( !NewBuf ) return NDIS_STATUS_RESOURCES;
RtlCopyMemory( NewBuf, Data, Length ); RtlCopyMemory( NewBuf, Data, Length );
} else NewBuf = Data; } else NewBuf = Data;
NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewBuf, Length ); NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewBuf, Length );
if( Status != NDIS_STATUS_SUCCESS ) return Status; if( Status != NDIS_STATUS_SUCCESS ) {
if (Copy) ExFreePoolWithTag(NewBuf, PACKET_BUFFER_TAG);
return Status;
}
NdisChainBufferAtFront( Packet, Buffer ); NdisChainBufferAtFront( Packet, Buffer );
@ -342,33 +345,30 @@ void GetDataPtr( PNDIS_PACKET Packet,
SkipToOffset( Buffer, Offset, DataOut, Size ); SkipToOffset( Buffer, Offset, DataOut, Size );
} }
NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket, NDIS_STATUS AllocatePacketWithBuffer( PNDIS_PACKET *NdisPacket,
PCHAR Data, UINT Len, PCHAR Data, UINT Len ) {
PCHAR File, UINT Line ) {
PNDIS_PACKET Packet; PNDIS_PACKET Packet;
PNDIS_BUFFER Buffer; PNDIS_BUFFER Buffer;
NDIS_STATUS Status; NDIS_STATUS Status;
PCHAR NewData; PCHAR NewData;
NewData = exAllocatePool( NonPagedPool, Len ); NewData = ExAllocatePoolWithTag( NonPagedPool, Len, PACKET_BUFFER_TAG );
if( !NewData ) return NDIS_STATUS_RESOURCES; if( !NewData ) return NDIS_STATUS_RESOURCES;
if( Data ) RtlCopyMemory(NewData, Data, Len); if( Data ) RtlCopyMemory(NewData, Data, Len);
NdisAllocatePacket( &Status, &Packet, GlobalPacketPool ); NdisAllocatePacket( &Status, &Packet, GlobalPacketPool );
if( Status != NDIS_STATUS_SUCCESS ) { if( Status != NDIS_STATUS_SUCCESS ) {
exFreePool( NewData ); ExFreePoolWithTag( NewData, PACKET_BUFFER_TAG );
return Status; return Status;
} }
TrackWithTag(NDIS_PACKET_TAG, Packet, File, Line);
NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len ); NdisAllocateBuffer( &Status, &Buffer, GlobalBufferPool, NewData, Len );
if( Status != NDIS_STATUS_SUCCESS ) { if( Status != NDIS_STATUS_SUCCESS ) {
exFreePool( NewData ); ExFreePoolWithTag( NewData, PACKET_BUFFER_TAG );
FreeNdisPacket( Packet ); FreeNdisPacket( Packet );
return Status; return Status;
} }
TrackWithTag(NDIS_BUFFER_TAG, Buffer, File, Line);
NdisChainBufferAtFront( Packet, Buffer ); NdisChainBufferAtFront( Packet, Buffer );
*NdisPacket = Packet; *NdisPacket = Packet;
@ -377,10 +377,8 @@ NDIS_STATUS AllocatePacketWithBufferX( PNDIS_PACKET *NdisPacket,
} }
VOID FreeNdisPacketX VOID FreeNdisPacket
( PNDIS_PACKET Packet, ( PNDIS_PACKET Packet )
PCHAR File,
UINT Line )
/* /*
* FUNCTION: Frees an NDIS packet * FUNCTION: Frees an NDIS packet
* ARGUMENTS: * ARGUMENTS:
@ -400,13 +398,11 @@ VOID FreeNdisPacketX
NdisGetNextBuffer(Buffer, &NextBuffer); NdisGetNextBuffer(Buffer, &NextBuffer);
NdisQueryBuffer(Buffer, &Data, &Length); NdisQueryBuffer(Buffer, &Data, &Length);
TI_DbgPrint(DEBUG_PBUFFER, ("Freeing ndis buffer (0x%X)\n", Buffer)); TI_DbgPrint(DEBUG_PBUFFER, ("Freeing ndis buffer (0x%X)\n", Buffer));
UntrackFL(File,Line,Buffer,NDIS_BUFFER_TAG);
NdisFreeBuffer(Buffer); NdisFreeBuffer(Buffer);
TI_DbgPrint(DEBUG_PBUFFER, ("Freeing exal buffer (0x%X)\n", Data)); TI_DbgPrint(DEBUG_PBUFFER, ("Freeing exal buffer (0x%X)\n", Data));
exFreePool(Data); ExFreePoolWithTag(Data, PACKET_BUFFER_TAG);
} }
/* Finally free the NDIS packet discriptor */ /* Finally free the NDIS packet discriptor */
UntrackFL(File,Line,Packet,NDIS_PACKET_TAG);
NdisFreePacket(Packet); NdisFreePacket(Packet);
} }

216
drivers/network/tcpip/tcpip/dispatch.c
View file

@ -12,6 +12,25 @@
#include "precomp.h" #include "precomp.h"
#include <pseh/pseh2.h> #include <pseh/pseh2.h>
NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status ) {
KIRQL OldIrql;
Irp->IoStatus.Status = Status;
if( Status == STATUS_PENDING )
IoMarkIrpPending( Irp );
else {
IoAcquireCancelSpinLock(&OldIrql);
(void)IoSetCancelRoutine( Irp, NULL );
IoReleaseCancelSpinLock(OldIrql);
IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
}
return Status;
}
NTSTATUS DispPrepareIrpForCancel( NTSTATUS DispPrepareIrpForCancel(
PTRANSPORT_CONTEXT Context, PTRANSPORT_CONTEXT Context,
PIRP Irp, PIRP Irp,
@ -72,7 +91,6 @@ VOID DispDataRequestComplete(
{ {
PIRP Irp; PIRP Irp;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
PTRANSPORT_CONTEXT TranContext;
KIRQL OldIrql; KIRQL OldIrql;
TI_DbgPrint(DEBUG_IRP, ("Called for irp %x (%x, %d).\n", TI_DbgPrint(DEBUG_IRP, ("Called for irp %x (%x, %d).\n",
@ -80,7 +98,6 @@ VOID DispDataRequestComplete(
Irp = Context; Irp = Context;
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
IoAcquireCancelSpinLock(&OldIrql); IoAcquireCancelSpinLock(&OldIrql);
@ -102,26 +119,6 @@ VOID DispDataRequestComplete(
TI_DbgPrint(DEBUG_IRP, ("Done Completing IRP\n")); TI_DbgPrint(DEBUG_IRP, ("Done Completing IRP\n"));
} }
VOID DispDoDisconnect( PVOID Data ) {
PDISCONNECT_TYPE DisType = (PDISCONNECT_TYPE)Data;
TI_DbgPrint(DEBUG_IRP, ("PostCancel: DoDisconnect\n"));
TcpipRecursiveMutexEnter(&TCPLock, TRUE);
TCPDisconnect
( DisType->Context,
DisType->Type,
NULL,
NULL,
DispDataRequestComplete,
DisType->Irp );
TcpipRecursiveMutexLeave(&TCPLock);
TI_DbgPrint(DEBUG_IRP, ("PostCancel: DoDisconnect done\n"));
DispDataRequestComplete(DisType->Irp, STATUS_CANCELLED, 0);
exFreePool(DisType);
}
VOID NTAPI DispCancelRequest( VOID NTAPI DispCancelRequest(
PDEVICE_OBJECT Device, PDEVICE_OBJECT Device,
PIRP Irp) PIRP Irp)
@ -136,7 +133,9 @@ VOID NTAPI DispCancelRequest(
PTRANSPORT_CONTEXT TranContext; PTRANSPORT_CONTEXT TranContext;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
UCHAR MinorFunction; UCHAR MinorFunction;
PDISCONNECT_TYPE DisType; BOOLEAN DequeuedIrp = TRUE;
IoReleaseCancelSpinLock(Irp->CancelIrql);
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
@ -159,22 +158,8 @@ VOID NTAPI DispCancelRequest(
switch(MinorFunction) { switch(MinorFunction) {
case TDI_SEND: case TDI_SEND:
case TDI_RECEIVE: case TDI_RECEIVE:
DisType = exAllocatePool(NonPagedPool, sizeof(DISCONNECT_TYPE)); DequeuedIrp = TCPRemoveIRP( TranContext->Handle.ConnectionContext, Irp );
if (DisType) break;
{
DisType->Type = TDI_DISCONNECT_RELEASE |
((MinorFunction == TDI_RECEIVE) ? TDI_DISCONNECT_ABORT : 0);
DisType->Context = TranContext->Handle.ConnectionContext;
DisType->Irp = Irp;
TCPRemoveIRP( TranContext->Handle.ConnectionContext, Irp );
if (!ChewCreate(DispDoDisconnect, DisType))
exFreePool(DisType);
}
IoReleaseCancelSpinLock(Irp->CancelIrql);
return;
case TDI_SEND_DATAGRAM: case TDI_SEND_DATAGRAM:
if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) { if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
@ -182,7 +167,7 @@ VOID NTAPI DispCancelRequest(
break; break;
} }
DGRemoveIRP(TranContext->Handle.AddressHandle, Irp); DequeuedIrp = DGRemoveIRP(TranContext->Handle.AddressHandle, Irp);
break; break;
case TDI_RECEIVE_DATAGRAM: case TDI_RECEIVE_DATAGRAM:
@ -191,20 +176,21 @@ VOID NTAPI DispCancelRequest(
break; break;
} }
DGRemoveIRP(TranContext->Handle.AddressHandle, Irp); DequeuedIrp = DGRemoveIRP(TranContext->Handle.AddressHandle, Irp);
break; break;
case TDI_CONNECT: case TDI_CONNECT:
TCPRemoveIRP(TranContext->Handle.ConnectionContext, Irp); DequeuedIrp = TCPRemoveIRP(TranContext->Handle.ConnectionContext, Irp);
break; break;
default: default:
TI_DbgPrint(MIN_TRACE, ("Unknown IRP. MinorFunction (0x%X).\n", MinorFunction)); TI_DbgPrint(MIN_TRACE, ("Unknown IRP. MinorFunction (0x%X).\n", MinorFunction));
ASSERT(FALSE);
break; break;
} }
IoReleaseCancelSpinLock(Irp->CancelIrql); if (DequeuedIrp)
IRPFinish(Irp, STATUS_CANCELLED); IRPFinish(Irp, STATUS_CANCELLED);
TI_DbgPrint(MAX_TRACE, ("Leaving.\n")); TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
} }
@ -224,7 +210,8 @@ VOID NTAPI DispCancelListenRequest(
PTRANSPORT_CONTEXT TranContext; PTRANSPORT_CONTEXT TranContext;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PCONNECTION_ENDPOINT Connection; PCONNECTION_ENDPOINT Connection;
/*NTSTATUS Status = STATUS_SUCCESS;*/
IoReleaseCancelSpinLock(Irp->CancelIrql);
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
@ -243,16 +230,12 @@ VOID NTAPI DispCancelListenRequest(
/* Try canceling the request */ /* Try canceling the request */
Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext; Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
TCPRemoveIRP(Connection, Irp); if (TCPAbortListenForSocket(Connection->AddressFile->Listener,
Connection))
TCPAbortListenForSocket( {
Connection->AddressFile->Listener, Irp->IoStatus.Information = 0;
Connection ); IRPFinish(Irp, STATUS_CANCELLED);
}
IoReleaseCancelSpinLock(Irp->CancelIrql);
Irp->IoStatus.Information = 0;
IRPFinish(Irp, STATUS_CANCELLED);
TI_DbgPrint(MAX_TRACE, ("Leaving.\n")); TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
} }
@ -291,6 +274,7 @@ NTSTATUS DispTdiAssociateAddress(
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PADDRESS_FILE AddrFile = NULL; PADDRESS_FILE AddrFile = NULL;
NTSTATUS Status; NTSTATUS Status;
KIRQL OldIrql;
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
@ -310,11 +294,6 @@ NTSTATUS DispTdiAssociateAddress(
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
if (Connection->AddressFile) {
TI_DbgPrint(MID_TRACE, ("An address file is already asscociated.\n"));
return STATUS_INVALID_PARAMETER;
}
Parameters = (PTDI_REQUEST_KERNEL_ASSOCIATE)&IrpSp->Parameters; Parameters = (PTDI_REQUEST_KERNEL_ASSOCIATE)&IrpSp->Parameters;
Status = ObReferenceObjectByHandle( Status = ObReferenceObjectByHandle(
@ -330,8 +309,18 @@ NTSTATUS DispTdiAssociateAddress(
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
KeAcquireSpinLock(&Connection->Lock, &OldIrql);
if (Connection->AddressFile) {
ObDereferenceObject(FileObject);
KeReleaseSpinLock(&Connection->Lock, OldIrql);
TI_DbgPrint(MID_TRACE, ("An address file is already asscociated.\n"));
return STATUS_INVALID_PARAMETER;
}
if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) { if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
ObDereferenceObject(FileObject); ObDereferenceObject(FileObject);
KeReleaseSpinLock(&Connection->Lock, OldIrql);
TI_DbgPrint(MID_TRACE, ("Bad address file object. Magic (0x%X).\n", TI_DbgPrint(MID_TRACE, ("Bad address file object. Magic (0x%X).\n",
FileObject->FsContext2)); FileObject->FsContext2));
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
@ -342,17 +331,21 @@ NTSTATUS DispTdiAssociateAddress(
TranContext = FileObject->FsContext; TranContext = FileObject->FsContext;
if (!TranContext) { if (!TranContext) {
ObDereferenceObject(FileObject); ObDereferenceObject(FileObject);
KeReleaseSpinLock(&Connection->Lock, OldIrql);
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n")); TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle; AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
if (!AddrFile) { if (!AddrFile) {
KeReleaseSpinLock(&Connection->Lock, OldIrql);
ObDereferenceObject(FileObject); ObDereferenceObject(FileObject);
TI_DbgPrint(MID_TRACE, ("No address file object.\n")); TI_DbgPrint(MID_TRACE, ("No address file object.\n"));
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
KeAcquireSpinLockAtDpcLevel(&AddrFile->Lock);
Connection->AddressFile = AddrFile; Connection->AddressFile = AddrFile;
/* Add connection endpoint to the address file */ /* Add connection endpoint to the address file */
@ -361,6 +354,9 @@ NTSTATUS DispTdiAssociateAddress(
/* FIXME: Maybe do this in DispTdiDisassociateAddress() instead? */ /* FIXME: Maybe do this in DispTdiDisassociateAddress() instead? */
ObDereferenceObject(FileObject); ObDereferenceObject(FileObject);
KeReleaseSpinLockFromDpcLevel(&AddrFile->Lock);
KeReleaseSpinLock(&Connection->Lock, OldIrql);
return Status; return Status;
} }
@ -387,8 +383,6 @@ NTSTATUS DispTdiConnect(
/* Get associated connection endpoint file object. Quit if none exists */ /* Get associated connection endpoint file object. Quit if none exists */
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (!TranContext) { if (!TranContext) {
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n")); TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
@ -419,8 +413,6 @@ NTSTATUS DispTdiConnect(
} }
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, 0); DispDataRequestComplete(Irp, Status, 0);
} else } else
@ -445,6 +437,7 @@ NTSTATUS DispTdiDisassociateAddress(
PCONNECTION_ENDPOINT Connection; PCONNECTION_ENDPOINT Connection;
PTRANSPORT_CONTEXT TranContext; PTRANSPORT_CONTEXT TranContext;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
KIRQL OldIrql;
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
@ -464,17 +457,26 @@ NTSTATUS DispTdiDisassociateAddress(
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
KeAcquireSpinLock(&Connection->Lock, &OldIrql);
if (!Connection->AddressFile) { if (!Connection->AddressFile) {
KeReleaseSpinLock(&Connection->Lock, OldIrql);
TI_DbgPrint(MID_TRACE, ("No address file is asscociated.\n")); TI_DbgPrint(MID_TRACE, ("No address file is asscociated.\n"));
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
KeAcquireSpinLockAtDpcLevel(&Connection->AddressFile->Lock);
/* Remove this connection from the address file */ /* Remove this connection from the address file */
Connection->AddressFile->Connection = NULL; Connection->AddressFile->Connection = NULL;
KeReleaseSpinLockFromDpcLevel(&Connection->AddressFile->Lock);
/* Remove the address file from this connection */ /* Remove the address file from this connection */
Connection->AddressFile = NULL; Connection->AddressFile = NULL;
KeReleaseSpinLock(&Connection->Lock, OldIrql);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -500,8 +502,6 @@ NTSTATUS DispTdiDisconnect(
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters; DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters;
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
/* Get associated connection endpoint file object. Quit if none exists */ /* Get associated connection endpoint file object. Quit if none exists */
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
@ -527,8 +527,6 @@ NTSTATUS DispTdiDisconnect(
Irp ); Irp );
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, 0); DispDataRequestComplete(Irp, Status, 0);
} else } else
@ -555,6 +553,7 @@ NTSTATUS DispTdiListen(
PTRANSPORT_CONTEXT TranContext; PTRANSPORT_CONTEXT TranContext;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
KIRQL OldIrql;
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
@ -562,8 +561,6 @@ NTSTATUS DispTdiListen(
/* Get associated connection endpoint file object. Quit if none exists */ /* Get associated connection endpoint file object. Quit if none exists */
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (TranContext == NULL) if (TranContext == NULL)
{ {
@ -582,15 +579,23 @@ NTSTATUS DispTdiListen(
Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters; Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
TI_DbgPrint(MIN_TRACE, ("Connection->AddressFile: %x\n",
Connection->AddressFile ));
ASSERT(Connection->AddressFile);
Status = DispPrepareIrpForCancel Status = DispPrepareIrpForCancel
(TranContext->Handle.ConnectionContext, (TranContext->Handle.ConnectionContext,
Irp, Irp,
(PDRIVER_CANCEL)DispCancelListenRequest); (PDRIVER_CANCEL)DispCancelListenRequest);
KeAcquireSpinLock(&Connection->Lock, &OldIrql);
if (Connection->AddressFile == NULL)
{
TI_DbgPrint(MID_TRACE, ("No associated address file\n"));
KeReleaseSpinLock(&Connection->Lock, OldIrql);
Status = STATUS_INVALID_PARAMETER;
goto done;
}
KeAcquireSpinLockAtDpcLevel(&Connection->AddressFile->Lock);
/* Listening will require us to create a listening socket and store it in /* Listening will require us to create a listening socket and store it in
* the address file. It will be signalled, and attempt to complete an irp * the address file. It will be signalled, and attempt to complete an irp
* when a new connection arrives. */ * when a new connection arrives. */
@ -627,9 +632,10 @@ NTSTATUS DispTdiListen(
Irp ); Irp );
} }
done: KeReleaseSpinLockFromDpcLevel(&Connection->AddressFile->Lock);
TcpipRecursiveMutexLeave( &TCPLock ); KeReleaseSpinLock(&Connection->Lock, OldIrql);
done:
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, 0); DispDataRequestComplete(Irp, Status, 0);
} else } else
@ -656,19 +662,15 @@ NTSTATUS DispTdiQueryInformation(
PTDI_REQUEST_KERNEL_QUERY_INFORMATION Parameters; PTDI_REQUEST_KERNEL_QUERY_INFORMATION Parameters;
PTRANSPORT_CONTEXT TranContext; PTRANSPORT_CONTEXT TranContext;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
TI_DbgPrint(DEBUG_IRP, ("Called.\n")); TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
Parameters = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION)&IrpSp->Parameters; Parameters = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION)&IrpSp->Parameters;
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (!TranContext) { if (!TranContext) {
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n")); TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -686,7 +688,6 @@ NTSTATUS DispTdiQueryInformation(
(FIELD_OFFSET(TDI_ADDRESS_INFO, Address.Address[0].Address) + (FIELD_OFFSET(TDI_ADDRESS_INFO, Address.Address[0].Address) +
sizeof(TDI_ADDRESS_IP))) { sizeof(TDI_ADDRESS_IP))) {
TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n")); TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL;
} }
@ -705,23 +706,18 @@ NTSTATUS DispTdiQueryInformation(
RtlZeroMemory( RtlZeroMemory(
&Address->Address[0].Address[0].sin_zero, &Address->Address[0].Address[0].sin_zero,
sizeof(Address->Address[0].Address[0].sin_zero)); sizeof(Address->Address[0].Address[0].sin_zero));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_SUCCESS; return STATUS_SUCCESS;
case TDI_CONNECTION_FILE: case TDI_CONNECTION_FILE:
Endpoint = Endpoint =
(PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext; (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
TCPGetSockAddress( Endpoint, (PTRANSPORT_ADDRESS)Address, FALSE );
DbgPrint("Returning socket address %x\n", Address->Address[0].Address[0].in_addr);
RtlZeroMemory( RtlZeroMemory(
&Address->Address[0].Address[0].sin_zero, &Address->Address[0].Address[0].sin_zero,
sizeof(Address->Address[0].Address[0].sin_zero)); sizeof(Address->Address[0].Address[0].sin_zero));
TcpipRecursiveMutexLeave(&TCPLock); return TCPGetSockAddress( Endpoint, (PTRANSPORT_ADDRESS)Address, FALSE );
return STATUS_SUCCESS;
default: default:
TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n")); TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
} }
@ -736,7 +732,6 @@ NTSTATUS DispTdiQueryInformation(
(FIELD_OFFSET(TDI_CONNECTION_INFORMATION, RemoteAddress) + (FIELD_OFFSET(TDI_CONNECTION_INFORMATION, RemoteAddress) +
sizeof(PVOID))) { sizeof(PVOID))) {
TI_DbgPrint(MID_TRACE, ("MDL buffer too small (ptr).\n")); TI_DbgPrint(MID_TRACE, ("MDL buffer too small (ptr).\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_BUFFER_TOO_SMALL; return STATUS_BUFFER_TOO_SMALL;
} }
@ -756,24 +751,18 @@ NTSTATUS DispTdiQueryInformation(
default: default:
TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n")); TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
if (!Endpoint) { if (!Endpoint) {
TI_DbgPrint(MID_TRACE, ("No connection object.\n")); TI_DbgPrint(MID_TRACE, ("No connection object.\n"));
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
Status = TCPGetSockAddress( Endpoint, AddressInfo->RemoteAddress, TRUE ); return TCPGetSockAddress( Endpoint, AddressInfo->RemoteAddress, TRUE );
TcpipRecursiveMutexLeave(&TCPLock);
return Status;
} }
} }
TcpipRecursiveMutexLeave(&TCPLock);
return STATUS_NOT_IMPLEMENTED; return STATUS_NOT_IMPLEMENTED;
} }
@ -799,8 +788,6 @@ NTSTATUS DispTdiReceive(
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters); ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters);
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (TranContext == NULL) if (TranContext == NULL)
{ {
@ -836,8 +823,6 @@ NTSTATUS DispTdiReceive(
} }
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, BytesReceived); DispDataRequestComplete(Irp, Status, BytesReceived);
} else } else
@ -871,8 +856,6 @@ NTSTATUS DispTdiReceiveDatagram(
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
DgramInfo = (PTDI_REQUEST_KERNEL_RECEIVEDG)&(IrpSp->Parameters); DgramInfo = (PTDI_REQUEST_KERNEL_RECEIVEDG)&(IrpSp->Parameters);
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (TranContext == NULL) if (TranContext == NULL)
{ {
@ -914,8 +897,6 @@ NTSTATUS DispTdiReceiveDatagram(
} }
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, BytesReceived); DispDataRequestComplete(Irp, Status, BytesReceived);
} else } else
@ -948,8 +929,6 @@ NTSTATUS DispTdiSend(
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters); SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters);
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (TranContext == NULL) if (TranContext == NULL)
{ {
@ -990,8 +969,6 @@ NTSTATUS DispTdiSend(
} }
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, BytesSent); DispDataRequestComplete(Irp, Status, BytesSent);
} else } else
@ -1024,8 +1001,6 @@ NTSTATUS DispTdiSendDatagram(
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
DgramInfo = (PTDI_REQUEST_KERNEL_SENDDG)&(IrpSp->Parameters); DgramInfo = (PTDI_REQUEST_KERNEL_SENDDG)&(IrpSp->Parameters);
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TranContext = IrpSp->FileObject->FsContext; TranContext = IrpSp->FileObject->FsContext;
if (TranContext == NULL) if (TranContext == NULL)
{ {
@ -1067,13 +1042,13 @@ NTSTATUS DispTdiSendDatagram(
DataBuffer, DataBuffer,
BufferSize, BufferSize,
&Irp->IoStatus.Information); &Irp->IoStatus.Information);
else else {
Status = STATUS_UNSUCCESSFUL; Status = STATUS_UNSUCCESSFUL;
ASSERT(FALSE);
}
} }
done: done:
TcpipRecursiveMutexLeave( &TCPLock );
if (Status != STATUS_PENDING) { if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information); DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information);
} else } else
@ -1122,7 +1097,7 @@ NTSTATUS DispTdiSetEventHandler(PIRP Irp)
Parameters = (PTDI_REQUEST_KERNEL_SET_EVENT)&IrpSp->Parameters; Parameters = (PTDI_REQUEST_KERNEL_SET_EVENT)&IrpSp->Parameters;
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql); KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
/* Set the event handler. if an event handler is associated with /* Set the event handler. if an event handler is associated with
a specific event, it's flag (RegisteredXxxHandler) is TRUE. a specific event, it's flag (RegisteredXxxHandler) is TRUE.
@ -1243,7 +1218,7 @@ NTSTATUS DispTdiSetEventHandler(PIRP Irp)
Status = STATUS_INVALID_PARAMETER; Status = STATUS_INVALID_PARAMETER;
} }
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql); KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return Status; return Status;
} }
@ -1278,11 +1253,10 @@ VOID DispTdiQueryInformationExComplete(
*/ */
{ {
PTI_QUERY_CONTEXT QueryContext; PTI_QUERY_CONTEXT QueryContext;
UINT Count = 0;
QueryContext = (PTI_QUERY_CONTEXT)Context; QueryContext = (PTI_QUERY_CONTEXT)Context;
if (NT_SUCCESS(Status)) { if (NT_SUCCESS(Status)) {
Count = CopyBufferToBufferChain( CopyBufferToBufferChain(
QueryContext->InputMdl, QueryContext->InputMdl,
FIELD_OFFSET(TCP_REQUEST_QUERY_INFORMATION_EX, Context), FIELD_OFFSET(TCP_REQUEST_QUERY_INFORMATION_EX, Context),
(PCHAR)&QueryContext->QueryInfo.Context, (PCHAR)&QueryContext->QueryInfo.Context,
@ -1299,7 +1273,7 @@ VOID DispTdiQueryInformationExComplete(
QueryContext->Irp->IoStatus.Information = ByteCount; QueryContext->Irp->IoStatus.Information = ByteCount;
QueryContext->Irp->IoStatus.Status = Status; QueryContext->Irp->IoStatus.Status = Status;
exFreePool(QueryContext); ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
} }
@ -1362,7 +1336,7 @@ NTSTATUS DispTdiQueryInformationEx(
IrpSp->Parameters.DeviceIoControl.Type3InputBuffer; IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
OutputBuffer = Irp->UserBuffer; OutputBuffer = Irp->UserBuffer;
QueryContext = exAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT)); QueryContext = ExAllocatePoolWithTag(NonPagedPool, sizeof(TI_QUERY_CONTEXT), QUERY_CONTEXT_TAG);
if (QueryContext) { if (QueryContext) {
_SEH2_TRY { _SEH2_TRY {
InputMdl = IoAllocateMdl(InputBuffer, InputMdl = IoAllocateMdl(InputBuffer,
@ -1425,7 +1399,7 @@ NTSTATUS DispTdiQueryInformationEx(
IoFreeMdl(OutputMdl); IoFreeMdl(OutputMdl);
} }
exFreePool(QueryContext); ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
} else } else
Status = STATUS_INSUFFICIENT_RESOURCES; Status = STATUS_INSUFFICIENT_RESOURCES;
} else if( InputBufferLength == } else if( InputBufferLength ==
@ -1438,7 +1412,7 @@ NTSTATUS DispTdiQueryInformationEx(
Size = 0; Size = 0;
QueryContext = exAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT)); QueryContext = ExAllocatePoolWithTag(NonPagedPool, sizeof(TI_QUERY_CONTEXT), QUERY_CONTEXT_TAG);
if (!QueryContext) return STATUS_INSUFFICIENT_RESOURCES; if (!QueryContext) return STATUS_INSUFFICIENT_RESOURCES;
_SEH2_TRY { _SEH2_TRY {
@ -1458,7 +1432,7 @@ NTSTATUS DispTdiQueryInformationEx(
if( !NT_SUCCESS(Status) || !InputMdl ) { if( !NT_SUCCESS(Status) || !InputMdl ) {
if( InputMdl ) IoFreeMdl( InputMdl ); if( InputMdl ) IoFreeMdl( InputMdl );
exFreePool(QueryContext); ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
return Status; return Status;
} }

105
drivers/network/tcpip/tcpip/fileobjs.c
View file

@ -153,7 +153,7 @@ VOID AddrFileFree(
* Object = Pointer to address file object to free * Object = Pointer to address file object to free
*/ */
{ {
exFreePool(Object); ExFreePoolWithTag(Object, ADDR_FILE_TAG);
} }
@ -165,7 +165,7 @@ VOID ControlChannelFree(
* Object = Pointer to address file object to free * Object = Pointer to address file object to free
*/ */
{ {
exFreePool(Object); ExFreePoolWithTag(Object, CONTROL_CHANNEL_TAG);
} }
@ -189,7 +189,8 @@ NTSTATUS FileOpenAddress(
TI_DbgPrint(MID_TRACE, ("Called (Proto %d).\n", Protocol)); TI_DbgPrint(MID_TRACE, ("Called (Proto %d).\n", Protocol));
AddrFile = exAllocatePool(NonPagedPool, sizeof(ADDRESS_FILE)); AddrFile = ExAllocatePoolWithTag(NonPagedPool, sizeof(ADDRESS_FILE),
ADDR_FILE_TAG);
if (!AddrFile) { if (!AddrFile) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
@ -212,7 +213,7 @@ NTSTATUS FileOpenAddress(
if (!AddrIsUnspecified(&AddrFile->Address) && if (!AddrIsUnspecified(&AddrFile->Address) &&
!AddrLocateInterface(&AddrFile->Address)) { !AddrLocateInterface(&AddrFile->Address)) {
exFreePool(AddrFile); ExFreePoolWithTag(AddrFile, ADDR_FILE_TAG);
TI_DbgPrint(MIN_TRACE, ("Non-local address given (0x%X).\n", A2S(&AddrFile->Address))); TI_DbgPrint(MIN_TRACE, ("Non-local address given (0x%X).\n", A2S(&AddrFile->Address)));
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -230,7 +231,7 @@ NTSTATUS FileOpenAddress(
AddrFile->Port != Address->Address[0].Address[0].sin_port) || AddrFile->Port != Address->Address[0].Address[0].sin_port) ||
AddrFile->Port == 0xffff) AddrFile->Port == 0xffff)
{ {
exFreePool(AddrFile); ExFreePoolWithTag(AddrFile, ADDR_FILE_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -248,7 +249,7 @@ NTSTATUS FileOpenAddress(
AddrFile->Port != Address->Address[0].Address[0].sin_port) || AddrFile->Port != Address->Address[0].Address[0].sin_port) ||
AddrFile->Port == 0xffff) AddrFile->Port == 0xffff)
{ {
exFreePool(AddrFile); ExFreePoolWithTag(AddrFile, ADDR_FILE_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -295,9 +296,6 @@ NTSTATUS FileOpenAddress(
/* Initialize spin lock that protects the address file object */ /* Initialize spin lock that protects the address file object */
KeInitializeSpinLock(&AddrFile->Lock); KeInitializeSpinLock(&AddrFile->Lock);
/* Set valid flag so the address can be used */
AF_SET_VALID(AddrFile);
/* Return address file object */ /* Return address file object */
Request->Handle.AddressHandle = AddrFile; Request->Handle.AddressHandle = AddrFile;
@ -328,7 +326,7 @@ NTSTATUS FileCloseAddress(
KIRQL OldIrql; KIRQL OldIrql;
PDATAGRAM_RECEIVE_REQUEST ReceiveRequest; PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
PDATAGRAM_SEND_REQUEST SendRequest; PDATAGRAM_SEND_REQUEST SendRequest;
PLIST_ENTRY CurrentEntry, NextEntry; PLIST_ENTRY CurrentEntry;
AddrFile = Request->Handle.AddressHandle; AddrFile = Request->Handle.AddressHandle;
@ -339,8 +337,6 @@ NTSTATUS FileCloseAddress(
RemoveEntryList(&AddrFile->ListEntry); RemoveEntryList(&AddrFile->ListEntry);
TcpipReleaseSpinLock(&AddressFileListLock, OldIrql); TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
/* FIXME: Kill TCP connections on this address file object */ /* FIXME: Kill TCP connections on this address file object */
/* Return pending requests with error */ /* Return pending requests with error */
@ -348,45 +344,27 @@ NTSTATUS FileCloseAddress(
TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting receive requests on AddrFile at (0x%X).\n", AddrFile)); TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting receive requests on AddrFile at (0x%X).\n", AddrFile));
/* Go through pending receive request list and cancel them all */ /* Go through pending receive request list and cancel them all */
CurrentEntry = AddrFile->ReceiveQueue.Flink; while ((CurrentEntry = ExInterlockedRemoveHeadList(&AddrFile->ReceiveQueue, &AddrFile->Lock))) {
while (CurrentEntry != &AddrFile->ReceiveQueue) {
NextEntry = CurrentEntry->Flink;
ReceiveRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry); ReceiveRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_RECEIVE_REQUEST, ListEntry);
/* Abort the request and free its resources */
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
(*ReceiveRequest->Complete)(ReceiveRequest->Context, STATUS_CANCELLED, 0); (*ReceiveRequest->Complete)(ReceiveRequest->Context, STATUS_CANCELLED, 0);
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql); /* ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG); FIXME: WTF? */
CurrentEntry = NextEntry;
} }
TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting send requests on address file at (0x%X).\n", AddrFile)); TI_DbgPrint(DEBUG_ADDRFILE, ("Aborting send requests on address file at (0x%X).\n", AddrFile));
/* Go through pending send request list and cancel them all */ /* Go through pending send request list and cancel them all */
CurrentEntry = AddrFile->TransmitQueue.Flink; while ((CurrentEntry = ExInterlockedRemoveHeadList(&AddrFile->ReceiveQueue, &AddrFile->Lock))) {
while (CurrentEntry != &AddrFile->TransmitQueue) { SendRequest = CONTAINING_RECORD(CurrentEntry, DATAGRAM_SEND_REQUEST, ListEntry);
NextEntry = CurrentEntry->Flink;
SendRequest = CONTAINING_RECORD(CurrentEntry,
DATAGRAM_SEND_REQUEST, ListEntry);
/* Abort the request and free its resources */
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
(*SendRequest->Complete)(SendRequest->Context, STATUS_CANCELLED, 0); (*SendRequest->Complete)(SendRequest->Context, STATUS_CANCELLED, 0);
exFreePool(SendRequest); ExFreePoolWithTag(SendRequest, DATAGRAM_SEND_TAG);
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
CurrentEntry = NextEntry;
} }
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
/* Protocol specific handling */ /* Protocol specific handling */
switch (AddrFile->Protocol) { switch (AddrFile->Protocol) {
case IPPROTO_TCP: case IPPROTO_TCP:
TCPFreePort( AddrFile->Port ); TCPFreePort( AddrFile->Port );
if( AddrFile->Listener ) { if( AddrFile->Listener )
TcpipRecursiveMutexEnter(&TCPLock, TRUE); TCPClose( AddrFile->Listener );
TCPClose( AddrFile->Listener );
TcpipRecursiveMutexLeave(&TCPLock);
exFreePool( AddrFile->Listener );
}
break; break;
case IPPROTO_UDP: case IPPROTO_UDP:
@ -425,9 +403,7 @@ NTSTATUS FileOpenConnection(
if( !Connection ) return STATUS_NO_MEMORY; if( !Connection ) return STATUS_NO_MEMORY;
TcpipRecursiveMutexEnter(&TCPLock, TRUE);
Status = TCPSocket( Connection, AF_INET, SOCK_STREAM, IPPROTO_TCP ); Status = TCPSocket( Connection, AF_INET, SOCK_STREAM, IPPROTO_TCP );
TcpipRecursiveMutexLeave(&TCPLock);
if( !NT_SUCCESS(Status) ) { if( !NT_SUCCESS(Status) ) {
TCPFreeConnectionEndpoint( Connection ); TCPFreeConnectionEndpoint( Connection );
@ -437,48 +413,11 @@ NTSTATUS FileOpenConnection(
/* Return connection endpoint file object */ /* Return connection endpoint file object */
Request->Handle.ConnectionContext = Connection; Request->Handle.ConnectionContext = Connection;
/* Add connection endpoint to global list */
ExInterlockedInsertTailList(
&ConnectionEndpointListHead,
&Connection->ListEntry,
&ConnectionEndpointListLock);
TI_DbgPrint(MAX_TRACE, ("Leaving.\n")); TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/*
* FUNCTION: Find a connection by examining the context field. This
* is needed in some situations where a FIN reply is needed after a
* socket is formally broken.
* ARGUMENTS:
* Request = Pointer to TDI request structure for this request
* RETURNS:
* Status of operation
*/
PCONNECTION_ENDPOINT FileFindConnectionByContext( PVOID Context ) {
PLIST_ENTRY Entry;
KIRQL OldIrql;
PCONNECTION_ENDPOINT Connection = NULL;
TcpipAcquireSpinLock( &ConnectionEndpointListLock, &OldIrql );
for( Entry = ConnectionEndpointListHead.Flink;
Entry != &ConnectionEndpointListHead;
Entry = Entry->Flink ) {
Connection =
CONTAINING_RECORD( Entry, CONNECTION_ENDPOINT, ListEntry );
if( Connection->SocketContext == Context ) break;
else Connection = NULL;
}
TcpipReleaseSpinLock( &ConnectionEndpointListLock, OldIrql );
return Connection;
}
/* /*
* FUNCTION: Closes an connection file object * FUNCTION: Closes an connection file object
* ARGUMENTS: * ARGUMENTS:
@ -490,21 +429,12 @@ NTSTATUS FileCloseConnection(
PTDI_REQUEST Request) PTDI_REQUEST Request)
{ {
PCONNECTION_ENDPOINT Connection; PCONNECTION_ENDPOINT Connection;
KIRQL OldIrql;
TI_DbgPrint(MID_TRACE, ("Called.\n")); TI_DbgPrint(MID_TRACE, ("Called.\n"));
Connection = Request->Handle.ConnectionContext; Connection = Request->Handle.ConnectionContext;
TcpipAcquireSpinLock(&ConnectionEndpointListLock, &OldIrql);
RemoveEntryList(&Connection->ListEntry);
TcpipReleaseSpinLock(&ConnectionEndpointListLock, OldIrql);
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
TCPClose( Connection ); TCPClose( Connection );
TcpipRecursiveMutexLeave( &TCPLock );
TCPFreeConnectionEndpoint(Connection);
TI_DbgPrint(MAX_TRACE, ("Leaving.\n")); TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
@ -525,7 +455,8 @@ NTSTATUS FileOpenControlChannel(
PCONTROL_CHANNEL ControlChannel; PCONTROL_CHANNEL ControlChannel;
TI_DbgPrint(MID_TRACE, ("Called.\n")); TI_DbgPrint(MID_TRACE, ("Called.\n"));
ControlChannel = exAllocatePool(NonPagedPool, sizeof(*ControlChannel)); ControlChannel = ExAllocatePoolWithTag(NonPagedPool, sizeof(*ControlChannel),
CONTROL_CHANNEL_TAG);
if (!ControlChannel) { if (!ControlChannel) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
@ -565,7 +496,7 @@ NTSTATUS FileCloseControlChannel(
PCONTROL_CHANNEL ControlChannel = Request->Handle.ControlChannel; PCONTROL_CHANNEL ControlChannel = Request->Handle.ControlChannel;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
exFreePool(ControlChannel); ExFreePoolWithTag(ControlChannel, CONTROL_CHANNEL_TAG);
Request->Handle.ControlChannel = NULL; Request->Handle.ControlChannel = NULL;
return Status; return Status;

8
drivers/network/tcpip/tcpip/iinfo.c
View file

@ -32,7 +32,7 @@ TDI_STATUS InfoTdiQueryGetInterfaceMIB(TDIEntityID ID,
Interface, IF, ID.tei_entity, ID.tei_instance)); Interface, IF, ID.tei_entity, ID.tei_instance));
OutData = OutData =
(PIFENTRY)exAllocatePool( NonPagedPool, (PIFENTRY)ExAllocatePool( NonPagedPool,
sizeof(IFENTRY) + MAX_IFDESCR_LEN ); sizeof(IFENTRY) + MAX_IFDESCR_LEN );
if( !OutData ) return TDI_NO_RESOURCES; /* Out of memory */ if( !OutData ) return TDI_NO_RESOURCES; /* Out of memory */
@ -99,7 +99,7 @@ TDI_STATUS InfoTdiQueryGetInterfaceMIB(TDIEntityID ID,
ID.tei_entity, ID.tei_instance, Size)); ID.tei_entity, ID.tei_instance, Size));
Status = InfoCopyOut( (PCHAR)OutData, Size, Buffer, BufferSize ); Status = InfoCopyOut( (PCHAR)OutData, Size, Buffer, BufferSize );
exFreePool( OutData ); ExFreePool( OutData );
TI_DbgPrint(DEBUG_INFO,("Returning %x\n", Status)); TI_DbgPrint(DEBUG_INFO,("Returning %x\n", Status));
@ -117,14 +117,14 @@ TDI_STATUS InfoTdiQueryGetArptableMIB(TDIEntityID ID,
if (MemSize != 0) if (MemSize != 0)
{ {
ArpEntries = exAllocatePoolWithTag( NonPagedPool, MemSize, FOURCC('A','R','P','t') ); ArpEntries = ExAllocatePool( NonPagedPool, MemSize );
if( !ArpEntries ) return STATUS_NO_MEMORY; if( !ArpEntries ) return STATUS_NO_MEMORY;
NBCopyNeighbors( Interface, ArpEntries ); NBCopyNeighbors( Interface, ArpEntries );
Status = InfoCopyOut( (PVOID)ArpEntries, MemSize, Buffer, BufferSize ); Status = InfoCopyOut( (PVOID)ArpEntries, MemSize, Buffer, BufferSize );
exFreePool( ArpEntries ); ExFreePool( ArpEntries );
} }
else else
{ {

37
drivers/network/tcpip/tcpip/irp.c
View file

@ -1,37 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS TCP/IP protocol driver
* FILE: tcpip/dispatch.h
* PURPOSE: TDI dispatch routines
* PROGRAMMERS: arty
* REVISIONS:
* CSH 01/08-2000 Created
* TODO: Validate device object in all dispatch routines
*/
#include "precomp.h"
VOID IRPRemember( PIRP Irp, PCHAR File, UINT Line ) {
TrackWithTag( IRP_TAG, Irp, File, Line );
}
NTSTATUS IRPFinish( PIRP Irp, NTSTATUS Status ) {
KIRQL OldIrql;
UntrackFL( __FILE__, __LINE__, Irp, IRP_TAG );
Irp->IoStatus.Status = Status;
if( Status == STATUS_PENDING )
IoMarkIrpPending( Irp );
else {
IoAcquireCancelSpinLock(&OldIrql);
(void)IoSetCancelRoutine( Irp, NULL );
IoReleaseCancelSpinLock(OldIrql);
IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
}
return Status;
}

13
drivers/network/tcpip/tcpip/lock.c
View file

@ -44,16 +44,3 @@ VOID TcpipReleaseFastMutex( PFAST_MUTEX Mutex ) {
ExReleaseFastMutex( Mutex ); ExReleaseFastMutex( Mutex );
} }
VOID TcpipRecursiveMutexInit( PRECURSIVE_MUTEX RecMutex ) {
RecursiveMutexInit( RecMutex );
}
VOID TcpipRecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex, BOOLEAN ToWrite ) {
//TI_DbgPrint(DEBUG_LOCK,("Locking\n"));
RecursiveMutexEnter( RecMutex );
}
VOID TcpipRecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex ) {
//TI_DbgPrint(DEBUG_LOCK,("Unlocking\n"));
RecursiveMutexLeave( RecMutex );
}

206
drivers/network/tcpip/tcpip/main.c
View file

@ -119,30 +119,25 @@ NTSTATUS TiCreateFileObject(
TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp)); TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
EaInfo = Irp->AssociatedIrp.SystemBuffer; EaInfo = Irp->AssociatedIrp.SystemBuffer;
CP
/* Parameter check */ /* Parameter check */
/* No EA information means that we're opening for SET/QUERY_INFORMATION /* No EA information means that we're opening for SET/QUERY_INFORMATION
* style calls. */ * style calls. */
#if 0
if (!EaInfo) {
TI_DbgPrint(MIN_TRACE, ("No EA information in IRP.\n"));
return STATUS_INVALID_PARAMETER;
}
#endif
CP
/* Allocate resources here. We release them again if something failed */ /* Allocate resources here. We release them again if something failed */
Context = exAllocatePool(NonPagedPool, sizeof(TRANSPORT_CONTEXT)); Context = ExAllocatePoolWithTag(NonPagedPool, sizeof(TRANSPORT_CONTEXT),
TRANS_CONTEXT_TAG);
if (!Context) { if (!Context) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
CP
Context->CancelIrps = FALSE; Context->CancelIrps = FALSE;
CP
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
IrpSp->FileObject->FsContext = Context; IrpSp->FileObject->FsContext = Context;
Request.RequestContext = Irp; Request.RequestContext = Irp;
CP
/* Branch to the right handler */ /* Branch to the right handler */
if (EaInfo && if (EaInfo &&
(EaInfo->EaNameLength == TDI_TRANSPORT_ADDRESS_LENGTH) && (EaInfo->EaNameLength == TDI_TRANSPORT_ADDRESS_LENGTH) &&
@ -150,7 +145,7 @@ CP
(&EaInfo->EaName, TdiTransportAddress, (&EaInfo->EaName, TdiTransportAddress,
TDI_TRANSPORT_ADDRESS_LENGTH) == TDI_TRANSPORT_ADDRESS_LENGTH)) { TDI_TRANSPORT_ADDRESS_LENGTH) == TDI_TRANSPORT_ADDRESS_LENGTH)) {
/* This is a request to open an address */ /* This is a request to open an address */
CP
/* XXX This should probably be done in IoCreateFile() */ /* XXX This should probably be done in IoCreateFile() */
/* Parameter checks */ /* Parameter checks */
@ -169,10 +164,10 @@ CP
TI_DbgPrint(MIN_TRACE, ("AddressType: %\n", TI_DbgPrint(MIN_TRACE, ("AddressType: %\n",
Address->Address[0].AddressType)); Address->Address[0].AddressType));
} }
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
CP
/* Open address file object */ /* Open address file object */
/* Protocol depends on device object so find the protocol */ /* Protocol depends on device object so find the protocol */
@ -186,21 +181,21 @@ CP
Status = TiGetProtocolNumber(&IrpSp->FileObject->FileName, &Protocol); Status = TiGetProtocolNumber(&IrpSp->FileObject->FileName, &Protocol);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Raw IP protocol number is invalid.\n")); TI_DbgPrint(MIN_TRACE, ("Raw IP protocol number is invalid.\n"));
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
} else { } else {
TI_DbgPrint(MIN_TRACE, ("Invalid device object at (0x%X).\n", DeviceObject)); TI_DbgPrint(MIN_TRACE, ("Invalid device object at (0x%X).\n", DeviceObject));
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
CP
Status = FileOpenAddress(&Request, Address, Protocol, NULL); Status = FileOpenAddress(&Request, Address, Protocol, NULL);
if (NT_SUCCESS(Status)) { if (NT_SUCCESS(Status)) {
IrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE; IrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
Context->Handle.AddressHandle = Request.Handle.AddressHandle; Context->Handle.AddressHandle = Request.Handle.AddressHandle;
} }
CP
} else if (EaInfo && } else if (EaInfo &&
(EaInfo->EaNameLength == TDI_CONNECTION_CONTEXT_LENGTH) && (EaInfo->EaNameLength == TDI_CONNECTION_CONTEXT_LENGTH) &&
(RtlCompareMemory (RtlCompareMemory
@ -208,12 +203,12 @@ CP
TDI_CONNECTION_CONTEXT_LENGTH) == TDI_CONNECTION_CONTEXT_LENGTH) ==
TDI_CONNECTION_CONTEXT_LENGTH)) { TDI_CONNECTION_CONTEXT_LENGTH)) {
/* This is a request to open a connection endpoint */ /* This is a request to open a connection endpoint */
CP
/* Parameter checks */ /* Parameter checks */
if (EaInfo->EaValueLength < sizeof(PVOID)) { if (EaInfo->EaValueLength < sizeof(PVOID)) {
TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n")); TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -221,7 +216,7 @@ CP
if (DeviceObject != TCPDeviceObject) { if (DeviceObject != TCPDeviceObject) {
TI_DbgPrint(MIN_TRACE, ("Bad device object.\n")); TI_DbgPrint(MIN_TRACE, ("Bad device object.\n"));
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
@ -244,7 +239,7 @@ CP
} }
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
exFreePool(Context); ExFreePoolWithTag(Context, TRANS_CONTEXT_TAG);
TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status)); TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
@ -322,9 +317,6 @@ TiDispatchOpenClose(
{ {
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
NTSTATUS Status; NTSTATUS Status;
PTRANSPORT_CONTEXT Context;
IRPRemember(Irp, __FILE__, __LINE__);
// DbgPrint("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp); // DbgPrint("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp);
@ -338,8 +330,7 @@ TiDispatchOpenClose(
/* Close an address file, connection endpoint, or control connection */ /* Close an address file, connection endpoint, or control connection */
case IRP_MJ_CLOSE: case IRP_MJ_CLOSE:
Context = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext; Status = TiCloseFileObject(DeviceObject, Irp);
Status = TiCloseFileObject(DeviceObject, Irp);
break; break;
default: default:
@ -369,8 +360,6 @@ TiDispatchInternal(
BOOLEAN Complete = TRUE; BOOLEAN Complete = TRUE;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
IRPRemember(Irp, __FILE__, __LINE__);
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X) MN (%d).\n", TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X) MN (%d).\n",
@ -473,8 +462,6 @@ TiDispatch(
NTSTATUS Status; NTSTATUS Status;
PIO_STACK_LOCATION IrpSp; PIO_STACK_LOCATION IrpSp;
IRPRemember(Irp, __FILE__, __LINE__);
IrpSp = IoGetCurrentIrpStackLocation(Irp); IrpSp = IoGetCurrentIrpStackLocation(Irp);
TI_DbgPrint(DEBUG_IRP, ("Called. IRP is at (0x%X).\n", Irp)); TI_DbgPrint(DEBUG_IRP, ("Called. IRP is at (0x%X).\n", Irp));
@ -543,8 +530,6 @@ VOID NTAPI TiUnload(
} }
TcpipReleaseSpinLock(&AddressFileListLock, OldIrql); TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
#endif #endif
ChewShutdown();
/* Cancel timer */ /* Cancel timer */
KeCancelTimer(&IPTimer); KeCancelTimer(&IPTimer);
@ -582,11 +567,13 @@ VOID NTAPI TiUnload(
if (RawIPDeviceObject) if (RawIPDeviceObject)
IoDeleteDevice(RawIPDeviceObject); IoDeleteDevice(RawIPDeviceObject);
if (IPDeviceObject) if (IPDeviceObject) {
IoDeleteDevice(IPDeviceObject); ChewShutdown();
IoDeleteDevice(IPDeviceObject);
}
if (EntityList) if (EntityList)
exFreePool(EntityList); ExFreePoolWithTag(EntityList, TDI_ENTITY_TAG);
TI_DbgPrint(MAX_TRACE, ("Leaving.\n")); TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
} }
@ -637,17 +624,22 @@ DriverEntry(
TI_DbgPrint(MAX_TRACE, ("Called.\n")); TI_DbgPrint(MAX_TRACE, ("Called.\n"));
TrackingInit();
/* TdiInitialize() ? */ /* TdiInitialize() ? */
/* FIXME: Create symbolic links in Win32 namespace */ /* FIXME: Create symbolic links in Win32 namespace */
/* Initialize our periodic timer and its associated DPC object. When the
timer expires, the IPTimeout deferred procedure call (DPC) is queued */
ExInitializeWorkItem( &IpWorkItem, IPTimeout, NULL );
KeInitializeDpc(&IPTimeoutDpc, IPTimeoutDpcFn, NULL);
KeInitializeTimer(&IPTimer);
/* Create IP device object */ /* Create IP device object */
Status = IoCreateDevice(DriverObject, 0, &strIpDeviceName, Status = IoCreateDevice(DriverObject, 0, &strIpDeviceName,
FILE_DEVICE_NETWORK, 0, FALSE, &IPDeviceObject); FILE_DEVICE_NETWORK, 0, FALSE, &IPDeviceObject);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to create IP device object. Status (0x%X).\n", Status)); TI_DbgPrint(MIN_TRACE, ("Failed to create IP device object. Status (0x%X).\n", Status));
TiUnload(DriverObject);
return Status; return Status;
} }
@ -658,8 +650,7 @@ DriverEntry(
FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject); FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status)); TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status));
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
return Status; return Status;
} }
@ -668,9 +659,7 @@ DriverEntry(
FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject); FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status)); TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status));
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
return Status; return Status;
} }
@ -679,23 +668,18 @@ DriverEntry(
FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject); FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status)); TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status));
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
return Status; return Status;
} }
/* Setup network layer and transport layer entities */ /* Setup network layer and transport layer entities */
KeInitializeSpinLock(&EntityListLock); KeInitializeSpinLock(&EntityListLock);
EntityList = exAllocatePool(NonPagedPool, sizeof(TDIEntityID) * MAX_TDI_ENTITIES ); EntityList = ExAllocatePoolWithTag(NonPagedPool,
sizeof(TDIEntityID) * MAX_TDI_ENTITIES,
TDI_ENTITY_TAG );
if (!EntityList) { if (!EntityList) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
@ -705,25 +689,14 @@ DriverEntry(
/* Allocate NDIS packet descriptors */ /* Allocate NDIS packet descriptors */
NdisAllocatePacketPool(&NdisStatus, &GlobalPacketPool, 100, sizeof(PACKET_CONTEXT)); NdisAllocatePacketPool(&NdisStatus, &GlobalPacketPool, 100, sizeof(PACKET_CONTEXT));
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
/* Allocate NDIS buffer descriptors */ /* Allocate NDIS buffer descriptors */
NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 100); NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 100);
if (NdisStatus != NDIS_STATUS_SUCCESS) { if (NdisStatus != NDIS_STATUS_SUCCESS) {
ChewShutdown(); TiUnload(DriverObject);
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
@ -745,64 +718,26 @@ DriverEntry(
/* Initialize transport level protocol subsystems */ /* Initialize transport level protocol subsystems */
Status = RawIPStartup(); Status = RawIPStartup();
if( !NT_SUCCESS(Status) ) { if( !NT_SUCCESS(Status) ) {
IPShutdown(); TiUnload(DriverObject);
ChewShutdown(); return Status;
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status;
} }
Status = UDPStartup(); Status = UDPStartup();
if( !NT_SUCCESS(Status) ) { if( !NT_SUCCESS(Status) ) {
RawIPShutdown(); TiUnload(DriverObject);
IPShutdown(); return Status;
ChewShutdown();
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status;
} }
Status = TCPStartup(); Status = TCPStartup();
if( !NT_SUCCESS(Status) ) { if( !NT_SUCCESS(Status) ) {
UDPShutdown(); TiUnload(DriverObject);
RawIPShutdown(); return Status;
IPShutdown();
ChewShutdown();
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status;
} }
Status = ICMPStartup(); Status = ICMPStartup();
if( !NT_SUCCESS(Status) ) { if( !NT_SUCCESS(Status) ) {
TCPShutdown(); TiUnload(DriverObject);
UDPShutdown(); return Status;
RawIPShutdown();
IPShutdown();
ChewShutdown();
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status;
} }
/* Use direct I/O */ /* Use direct I/O */
@ -819,33 +754,11 @@ DriverEntry(
DriverObject->DriverUnload = TiUnload; DriverObject->DriverUnload = TiUnload;
/* Initialize our periodic timer and its associated DPC object. When the
timer expires, the IPTimeout deferred procedure call (DPC) is queued */
ExInitializeWorkItem( &IpWorkItem, IPTimeout, NULL );
KeInitializeDpc(&IPTimeoutDpc, IPTimeoutDpcFn, NULL);
KeInitializeTimer(&IPTimer);
/* Start the periodic timer with an initial and periodic
relative expiration time of IP_TIMEOUT milliseconds */
DueTime.QuadPart = -(LONGLONG)IP_TIMEOUT * 10000;
KeSetTimerEx(&IPTimer, DueTime, IP_TIMEOUT, &IPTimeoutDpc);
/* Open loopback adapter */ /* Open loopback adapter */
Status = LoopRegisterAdapter(NULL, NULL); Status = LoopRegisterAdapter(NULL, NULL);
if (!NT_SUCCESS(Status)) { if (!NT_SUCCESS(Status)) {
TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status)); TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status));
TCPShutdown(); TiUnload(DriverObject);
UDPShutdown();
RawIPShutdown();
IPShutdown();
ChewShutdown();
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status; return Status;
} }
@ -862,25 +775,18 @@ DriverEntry(
NULL, NULL,
0, 0,
NULL); NULL);
TCPShutdown(); TiUnload(DriverObject);
UDPShutdown(); return Status;
RawIPShutdown();
IPShutdown();
ChewShutdown();
IoDeleteDevice(IPDeviceObject);
IoDeleteDevice(RawIPDeviceObject);
IoDeleteDevice(UDPDeviceObject);
IoDeleteDevice(TCPDeviceObject);
exFreePool(EntityList);
NdisFreePacketPool(GlobalPacketPool);
NdisFreeBufferPool(GlobalBufferPool);
return Status;
} }
/* Start the periodic timer with an initial and periodic
relative expiration time of IP_TIMEOUT milliseconds */
DueTime.QuadPart = -(LONGLONG)IP_TIMEOUT * 10000;
KeSetTimerEx(&IPTimer, DueTime, IP_TIMEOUT, &IPTimeoutDpc);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
VOID NTAPI VOID NTAPI
IPAddInterface( IPAddInterface(
ULONG Unknown0, ULONG Unknown0,

9
drivers/network/tcpip/tcpip/mocklock.c
View file

@ -45,12 +45,3 @@ VOID TcpipAcquireFastMutex( PFAST_MUTEX Mutex ) {
VOID TcpipReleaseFastMutex( PFAST_MUTEX Mutex ) { VOID TcpipReleaseFastMutex( PFAST_MUTEX Mutex ) {
} }
VOID TcpipRecursiveMutexInit( PRECURSIVE_MUTEX RecMutex ) {
}
UINT TcpipRecursiveMutexEnter( PRECURSIVE_MUTEX RecMutex, BOOL ToWrite ) {
return 0;
}
VOID TcpipRecursiveMutexLeave( PRECURSIVE_MUTEX RecMutex ) {
}

16
drivers/network/tcpip/tcpip/ninfo.c
View file

@ -22,9 +22,9 @@ TDI_STATUS InfoTdiQueryGetRouteTable( PIP_INTERFACE IF, PNDIS_BUFFER Buffer, PUI
UINT RtCount = CountFIBs(IF); UINT RtCount = CountFIBs(IF);
UINT Size = sizeof( IPROUTE_ENTRY ) * RtCount; UINT Size = sizeof( IPROUTE_ENTRY ) * RtCount;
PFIB_ENTRY RCache = PFIB_ENTRY RCache =
exAllocatePool( NonPagedPool, sizeof( FIB_ENTRY ) * RtCount ), ExAllocatePool( NonPagedPool, sizeof( FIB_ENTRY ) * RtCount ),
RCacheCur = RCache; RCacheCur = RCache;
PIPROUTE_ENTRY RouteEntries = exAllocatePool( NonPagedPool, Size ), PIPROUTE_ENTRY RouteEntries = ExAllocatePool( NonPagedPool, Size ),
RtCurrent = RouteEntries; RtCurrent = RouteEntries;
UINT i; UINT i;
@ -32,8 +32,8 @@ TDI_STATUS InfoTdiQueryGetRouteTable( PIP_INTERFACE IF, PNDIS_BUFFER Buffer, PUI
RtCount, RCache)); RtCount, RCache));
if( !RCache || !RouteEntries ) { if( !RCache || !RouteEntries ) {
if( RCache ) exFreePool( RCache ); if( RCache ) ExFreePool( RCache );
if( RouteEntries ) exFreePool( RouteEntries ); if( RouteEntries ) ExFreePool( RouteEntries );
return TDI_NO_RESOURCES; return TDI_NO_RESOURCES;
} }
@ -83,8 +83,8 @@ TDI_STATUS InfoTdiQueryGetRouteTable( PIP_INTERFACE IF, PNDIS_BUFFER Buffer, PUI
Status = InfoCopyOut( (PCHAR)RouteEntries, Size, Buffer, BufferSize ); Status = InfoCopyOut( (PCHAR)RouteEntries, Size, Buffer, BufferSize );
exFreePool( RouteEntries ); ExFreePool( RouteEntries );
exFreePool( RCache ); ExFreePool( RCache );
TI_DbgPrint(DEBUG_INFO, ("Returning %08x\n", Status)); TI_DbgPrint(DEBUG_INFO, ("Returning %08x\n", Status));
@ -118,7 +118,7 @@ TDI_STATUS InfoTdiQueryGetAddrTable(TDIEntityID ID,
return TDI_INVALID_PARAMETER; return TDI_INVALID_PARAMETER;
} }
IPEntry = exAllocatePool(NonPagedPool, sizeof(IPADDR_ENTRY)); IPEntry = ExAllocatePool(NonPagedPool, sizeof(IPADDR_ENTRY));
if (!IPEntry) if (!IPEntry)
{ {
TcpipReleaseSpinLock(&EntityListLock, OldIrql); TcpipReleaseSpinLock(&EntityListLock, OldIrql);
@ -143,7 +143,7 @@ TDI_STATUS InfoTdiQueryGetAddrTable(TDIEntityID ID,
InfoCopyOut((PCHAR)IPEntry, sizeof(IPADDR_ENTRY), InfoCopyOut((PCHAR)IPEntry, sizeof(IPADDR_ENTRY),
Buffer, BufferSize); Buffer, BufferSize);
exFreePool(IPEntry); ExFreePool(IPEntry);
return TDI_SUCCESS; return TDI_SUCCESS;
} }

1
lib/drivers/ip/ip.rbuild
View file

@ -17,7 +17,6 @@
<file>interface.c</file> <file>interface.c</file>
<file>ip.c</file> <file>ip.c</file>
<file>loopback.c</file> <file>loopback.c</file>
<file>memtrack.c</file>
<file>neighbor.c</file> <file>neighbor.c</file>
<file>ports.c</file> <file>ports.c</file>
<file>receive.c</file> <file>receive.c</file>

2
lib/drivers/ip/network/address.c
View file

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

29
lib/drivers/ip/network/ip.c
View file

@ -39,7 +39,7 @@ VOID FreeIF(
* Object = Pointer to an interface structure * Object = Pointer to an interface structure
*/ */
{ {
exFreePool(Object); ExFreePoolWithTag(Object, IP_INTERFACE_TAG);
} }
PIP_PACKET IPInitializePacket( PIP_PACKET IPInitializePacket(
@ -56,8 +56,6 @@ PIP_PACKET IPInitializePacket(
/* FIXME: Is this needed? */ /* FIXME: Is this needed? */
RtlZeroMemory(IPPacket, sizeof(IP_PACKET)); RtlZeroMemory(IPPacket, sizeof(IP_PACKET));
INIT_TAG(IPPacket, 'TKPI');
IPPacket->Free = DontFreePacket; IPPacket->Free = DontFreePacket;
IPPacket->Type = Type; IPPacket->Type = Type;
@ -73,9 +71,6 @@ void NTAPI IPTimeout( PVOID Context ) {
/* Clean possible outdated cached neighbor addresses */ /* Clean possible outdated cached neighbor addresses */
NBTimeout(); NBTimeout();
/* Call upper layer timeout routines */
TCPTimeout();
} }
@ -142,14 +137,13 @@ PIP_INTERFACE IPCreateInterface(
} }
#endif #endif
IF = exAllocatePool(NonPagedPool, sizeof(IP_INTERFACE)); IF = ExAllocatePoolWithTag(NonPagedPool, sizeof(IP_INTERFACE),
IP_INTERFACE_TAG);
if (!IF) { if (!IF) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL; return NULL;
} }
INIT_TAG(IF, 'ECAF');
RtlZeroMemory(IF, sizeof(IP_INTERFACE)); RtlZeroMemory(IF, sizeof(IP_INTERFACE));
IF->Free = FreeIF; IF->Free = FreeIF;
@ -168,10 +162,11 @@ PIP_INTERFACE IPCreateInterface(
TcpipInitializeSpinLock(&IF->Lock); TcpipInitializeSpinLock(&IF->Lock);
IF->TCPContext = exAllocatePool IF->TCPContext = ExAllocatePoolWithTag
( NonPagedPool, sizeof(OSK_IFADDR) + 2 * sizeof( struct sockaddr_in ) ); ( NonPagedPool, sizeof(OSK_IFADDR) + 2 * sizeof( struct sockaddr_in ),
OSKITTCP_CONTEXT_TAG );
if (!IF->TCPContext) { if (!IF->TCPContext) {
exFreePool(IF); ExFreePoolWithTag(IF, IP_INTERFACE_TAG);
return NULL; return NULL;
} }
@ -197,8 +192,8 @@ VOID IPDestroyInterface(
RemoveTDIInterfaceEntity( IF ); RemoveTDIInterfaceEntity( IF );
#endif #endif
exFreePool(IF->TCPContext); ExFreePoolWithTag(IF->TCPContext, OSKITTCP_CONTEXT_TAG);
exFreePool(IF); ExFreePoolWithTag(IF, IP_INTERFACE_TAG);
} }
VOID IPAddInterfaceRoute( PIP_INTERFACE IF ) { VOID IPAddInterfaceRoute( PIP_INTERFACE IF ) {
@ -364,7 +359,7 @@ NTSTATUS IPStartup(PUNICODE_STRING RegistryPath)
NULL, /* Free routine */ NULL, /* Free routine */
0, /* Flags */ 0, /* Flags */
sizeof(IPDATAGRAM_REASSEMBLY), /* Size of each entry */ sizeof(IPDATAGRAM_REASSEMBLY), /* Size of each entry */
'RDPI', /* Tag */ DATAGRAM_REASSEMBLY_TAG, /* Tag */
0); /* Depth */ 0); /* Depth */
ExInitializeNPagedLookasideList( ExInitializeNPagedLookasideList(
@ -373,7 +368,7 @@ NTSTATUS IPStartup(PUNICODE_STRING RegistryPath)
NULL, /* Free routine */ NULL, /* Free routine */
0, /* Flags */ 0, /* Flags */
sizeof(IP_FRAGMENT), /* Size of each entry */ sizeof(IP_FRAGMENT), /* Size of each entry */
'GFPI', /* Tag */ DATAGRAM_FRAGMENT_TAG, /* Tag */
0); /* Depth */ 0); /* Depth */
ExInitializeNPagedLookasideList( ExInitializeNPagedLookasideList(
@ -382,7 +377,7 @@ NTSTATUS IPStartup(PUNICODE_STRING RegistryPath)
NULL, /* Free routine */ NULL, /* Free routine */
0, /* Flags */ 0, /* Flags */
sizeof(IPDATAGRAM_HOLE), /* Size of each entry */ sizeof(IPDATAGRAM_HOLE), /* Size of each entry */
'LHPI', /* Tag */ DATAGRAM_HOLE_TAG, /* Tag */
0); /* Depth */ 0); /* Depth */
/* Start routing subsystem */ /* Start routing subsystem */

153
lib/drivers/ip/network/memtrack.c
View file

@ -1,153 +0,0 @@
#define MEMTRACK_NO_POOL
#include "precomp.h"
#if DBG
#define TRACK_TAG 'KCrT'
static LIST_ENTRY AllocatedObjectsList;
static KSPIN_LOCK AllocatedObjectsLock;
static NPAGED_LOOKASIDE_LIST AllocatedObjectsLookasideList;
VOID TrackingInit() {
TcpipInitializeSpinLock( &AllocatedObjectsLock );
InitializeListHead( &AllocatedObjectsList );
ExInitializeNPagedLookasideList(&AllocatedObjectsLookasideList,
NULL,
NULL,
0,
sizeof(ALLOCATION_TRACKER),
TRACK_TAG,
0 );
}
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)\n",
What,
Thing->Thing,
((PCHAR)&Thing->Tag)[3],
((PCHAR)&Thing->Tag)[2],
((PCHAR)&Thing->Tag)[1],
((PCHAR)&Thing->Tag)[0],
Thing->FileName,
Thing->LineNo));
}
}
VOID TrackWithTag( ULONG Tag, PVOID Thing, PCHAR FileName, ULONG LineNo ) {
PALLOCATION_TRACKER TrackedThing =
ExAllocateFromNPagedLookasideList( &AllocatedObjectsLookasideList );
KIRQL OldIrql;
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 ) {
ThingInList = CONTAINING_RECORD(Entry, ALLOCATION_TRACKER, Entry);
if( ThingInList->Thing == Thing ) {
RemoveEntryList(Entry);
ShowTrackedThing( "Double Alloc (Item in list)", ThingInList, TRUE );
ShowTrackedThing( "Double Alloc (Item not in list)", TrackedThing, TRUE );
ExFreeToNPagedLookasideList( &AllocatedObjectsLookasideList,
ThingInList );
break;
}
Entry = Entry->Flink;
}
InsertHeadList( &AllocatedObjectsList, &TrackedThing->Entry );
TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
}
VOID UntrackFL( PCHAR File, ULONG Line, PVOID Thing, ULONG Tag ) {
KIRQL OldIrql;
PLIST_ENTRY Entry;
PALLOCATION_TRACKER ThingInList;
TcpipAcquireSpinLock( &AllocatedObjectsLock, &OldIrql );
Entry = AllocatedObjectsList.Flink;
while( Entry != &AllocatedObjectsList ) {
ThingInList = CONTAINING_RECORD(Entry, ALLOCATION_TRACKER, Entry);
if( ThingInList->Thing == Thing ) {
RemoveEntryList(Entry);
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 );
return;
}
Entry = Entry->Flink;
}
TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
DbgPrint("[Double Free] Thing %08x %c%c%c%c (%s:%d)\n",
Thing,
((PCHAR)&Tag)[3],
((PCHAR)&Tag)[2],
((PCHAR)&Tag)[1],
((PCHAR)&Tag)[0],
File,
Line);
ASSERT( FALSE );
}
VOID TrackDumpFL( PCHAR File, ULONG Line ) {
KIRQL OldIrql;
PLIST_ENTRY Entry;
PALLOCATION_TRACKER Thing;
TI_DbgPrint(MAX_TRACE,("Dump: %s:%d\n", File, Line));
TcpipAcquireSpinLock( &AllocatedObjectsLock, &OldIrql );
Entry = AllocatedObjectsList.Flink;
while( Entry != &AllocatedObjectsList ) {
Thing = CONTAINING_RECORD(Entry, ALLOCATION_TRACKER, Entry);
ShowTrackedThing( "Dump ", Thing, FALSE );
Entry = Entry->Flink;
}
TcpipReleaseSpinLock( &AllocatedObjectsLock, OldIrql );
}
#endif /* DBG */

20
lib/drivers/ip/network/neighbor.c
View file

@ -21,7 +21,7 @@ VOID NBCompleteSend( PVOID Context,
ASSERT_KM_POINTER(Packet->Complete); ASSERT_KM_POINTER(Packet->Complete);
Packet->Complete( Packet->Context, Packet->Packet, Status ); Packet->Complete( Packet->Context, Packet->Packet, Status );
TI_DbgPrint(MID_TRACE, ("Completed\n")); TI_DbgPrint(MID_TRACE, ("Completed\n"));
exFreePool( Packet ); ExFreePoolWithTag( Packet, NEIGHBOR_PACKET_TAG );
TI_DbgPrint(MID_TRACE, ("Freed\n")); TI_DbgPrint(MID_TRACE, ("Freed\n"));
} }
@ -84,7 +84,7 @@ VOID NBFlushPacketQueue( PNEIGHBOR_CACHE_ENTRY NCE,
Packet->Packet, Packet->Packet,
ErrorCode ); ErrorCode );
exFreePool( Packet ); ExFreePoolWithTag( Packet, NEIGHBOR_PACKET_TAG );
} }
} }
@ -128,7 +128,7 @@ VOID NBTimeout(VOID)
*PrevNCE = NCE->Next; *PrevNCE = NCE->Next;
NBFlushPacketQueue(NCE, NDIS_STATUS_REQUEST_ABORTED); NBFlushPacketQueue(NCE, NDIS_STATUS_REQUEST_ABORTED);
exFreePool(NCE); ExFreePoolWithTag(NCE, NCE_TAG);
continue; continue;
} }
@ -179,7 +179,7 @@ VOID NBShutdown(VOID)
/* Flush wait queue */ /* Flush wait queue */
NBFlushPacketQueue( CurNCE, NDIS_STATUS_NOT_ACCEPTED ); NBFlushPacketQueue( CurNCE, NDIS_STATUS_NOT_ACCEPTED );
exFreePool(CurNCE); ExFreePoolWithTag(CurNCE, NCE_TAG);
CurNCE = NextNCE; CurNCE = NextNCE;
} }
@ -241,16 +241,15 @@ PNEIGHBOR_CACHE_ENTRY NBAddNeighbor(
"LinkAddress (0x%X) LinkAddressLength (%d) State (0x%X)\n", "LinkAddress (0x%X) LinkAddressLength (%d) State (0x%X)\n",
Interface, Address, LinkAddress, LinkAddressLength, State)); Interface, Address, LinkAddress, LinkAddressLength, State));
NCE = exAllocatePool NCE = ExAllocatePoolWithTag
(NonPagedPool, sizeof(NEIGHBOR_CACHE_ENTRY) + LinkAddressLength); (NonPagedPool, sizeof(NEIGHBOR_CACHE_ENTRY) + LinkAddressLength,
NCE_TAG);
if (NCE == NULL) if (NCE == NULL)
{ {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL; return NULL;
} }
INIT_TAG(NCE, ' ECN');
NCE->Interface = Interface; NCE->Interface = Interface;
NCE->Address = *Address; NCE->Address = *Address;
NCE->LinkAddressLength = LinkAddressLength; NCE->LinkAddressLength = LinkAddressLength;
@ -452,7 +451,8 @@ BOOLEAN NBQueuePacket(
(DEBUG_NCACHE, (DEBUG_NCACHE,
("Called. NCE (0x%X) NdisPacket (0x%X).\n", NCE, NdisPacket)); ("Called. NCE (0x%X) NdisPacket (0x%X).\n", NCE, NdisPacket));
Packet = exAllocatePool( NonPagedPool, sizeof(NEIGHBOR_PACKET) ); Packet = ExAllocatePoolWithTag( NonPagedPool, sizeof(NEIGHBOR_PACKET),
NEIGHBOR_PACKET_TAG );
if( !Packet ) return FALSE; if( !Packet ) return FALSE;
/* FIXME: Should we limit the number of queued packets? */ /* FIXME: Should we limit the number of queued packets? */
@ -514,7 +514,7 @@ VOID NBRemoveNeighbor(
*PrevNCE = CurNCE->Next; *PrevNCE = CurNCE->Next;
NBFlushPacketQueue( CurNCE, NDIS_STATUS_REQUEST_ABORTED ); NBFlushPacketQueue( CurNCE, NDIS_STATUS_REQUEST_ABORTED );
exFreePool(CurNCE); ExFreePoolWithTag(CurNCE, NCE_TAG);
break; break;
} }

5
lib/drivers/ip/network/ports.c
View file

@ -17,7 +17,8 @@ NTSTATUS PortsStartup( PPORT_SET PortSet,
PortSet->PortsToOversee = PortsToManage; PortSet->PortsToOversee = PortsToManage;
PortSet->ProtoBitBuffer = PortSet->ProtoBitBuffer =
exAllocatePool( NonPagedPool, (PortSet->PortsToOversee + 7) / 8 ); ExAllocatePoolWithTag( NonPagedPool, (PortSet->PortsToOversee + 7) / 8,
PORT_SET_TAG );
if(!PortSet->ProtoBitBuffer) return STATUS_INSUFFICIENT_RESOURCES; if(!PortSet->ProtoBitBuffer) return STATUS_INSUFFICIENT_RESOURCES;
RtlInitializeBitMap( &PortSet->ProtoBitmap, RtlInitializeBitMap( &PortSet->ProtoBitmap,
PortSet->ProtoBitBuffer, PortSet->ProtoBitBuffer,
@ -28,7 +29,7 @@ NTSTATUS PortsStartup( PPORT_SET PortSet,
} }
VOID PortsShutdown( PPORT_SET PortSet ) { VOID PortsShutdown( PPORT_SET PortSet ) {
exFreePool( PortSet->ProtoBitBuffer ); ExFreePoolWithTag( PortSet->ProtoBitBuffer, PORT_SET_TAG );
} }
VOID DeallocatePort( PPORT_SET PortSet, ULONG Port ) { VOID DeallocatePort( PPORT_SET PortSet, ULONG Port ) {

30
lib/drivers/ip/network/receive.c
View file

@ -35,7 +35,7 @@ PIPDATAGRAM_HOLE CreateHoleDescriptor(
TI_DbgPrint(DEBUG_IP, ("Called. First (%d) Last (%d).\n", First, Last)); TI_DbgPrint(DEBUG_IP, ("Called. First (%d) Last (%d).\n", First, Last));
Hole = exAllocateFromNPagedLookasideList(&IPHoleList); Hole = ExAllocateFromNPagedLookasideList(&IPHoleList);
if (!Hole) { if (!Hole) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL; return NULL;
@ -76,7 +76,7 @@ VOID FreeIPDR(
TI_DbgPrint(DEBUG_IP, ("Freeing hole descriptor at (0x%X).\n", CurrentH)); TI_DbgPrint(DEBUG_IP, ("Freeing hole descriptor at (0x%X).\n", CurrentH));
/* And free the hole descriptor */ /* And free the hole descriptor */
exFreeToNPagedLookasideList(&IPHoleList, CurrentH); ExFreeToNPagedLookasideList(&IPHoleList, CurrentH);
CurrentEntry = NextEntry; CurrentEntry = NextEntry;
} }
@ -92,18 +92,18 @@ VOID FreeIPDR(
TI_DbgPrint(DEBUG_IP, ("Freeing fragment data at (0x%X).\n", CurrentF->Data)); TI_DbgPrint(DEBUG_IP, ("Freeing fragment data at (0x%X).\n", CurrentF->Data));
/* Free the fragment data buffer */ /* Free the fragment data buffer */
exFreePool(CurrentF->Data); ExFreePoolWithTag(CurrentF->Data, FRAGMENT_DATA_TAG);
TI_DbgPrint(DEBUG_IP, ("Freeing fragment at (0x%X).\n", CurrentF)); TI_DbgPrint(DEBUG_IP, ("Freeing fragment at (0x%X).\n", CurrentF));
/* And free the fragment descriptor */ /* And free the fragment descriptor */
exFreeToNPagedLookasideList(&IPFragmentList, CurrentF); ExFreeToNPagedLookasideList(&IPFragmentList, CurrentF);
CurrentEntry = NextEntry; CurrentEntry = NextEntry;
} }
TI_DbgPrint(DEBUG_IP, ("Freeing IPDR data at (0x%X).\n", IPDR)); TI_DbgPrint(DEBUG_IP, ("Freeing IPDR data at (0x%X).\n", IPDR));
exFreeToNPagedLookasideList(&IPDRList, IPDR); ExFreeToNPagedLookasideList(&IPDRList, IPDR);
} }
@ -205,7 +205,7 @@ ReassembleDatagram(
RtlCopyMemory(&IPPacket->DstAddr, &IPDR->DstAddr, sizeof(IP_ADDRESS)); RtlCopyMemory(&IPPacket->DstAddr, &IPDR->DstAddr, sizeof(IP_ADDRESS));
/* Allocate space for full IP datagram */ /* Allocate space for full IP datagram */
IPPacket->Header = exAllocatePool(NonPagedPool, IPPacket->TotalSize); IPPacket->Header = ExAllocatePoolWithTag(NonPagedPool, IPPacket->TotalSize, PACKET_BUFFER_TAG);
if (!IPPacket->Header) { if (!IPPacket->Header) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
(*IPPacket->Free)(IPPacket); (*IPPacket->Free)(IPPacket);
@ -297,7 +297,7 @@ VOID ProcessFragment(
TI_DbgPrint(DEBUG_IP, ("Starting new assembly.\n")); TI_DbgPrint(DEBUG_IP, ("Starting new assembly.\n"));
/* We don't have a reassembly structure, create one */ /* We don't have a reassembly structure, create one */
IPDR = exAllocateFromNPagedLookasideList(&IPDRList); IPDR = ExAllocateFromNPagedLookasideList(&IPDRList);
if (!IPDR) if (!IPDR)
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
return; return;
@ -308,7 +308,7 @@ VOID ProcessFragment(
Hole = CreateHoleDescriptor(0, 65536); Hole = CreateHoleDescriptor(0, 65536);
if (!Hole) { if (!Hole) {
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
exFreeToNPagedLookasideList(&IPDRList, IPDR); ExFreeToNPagedLookasideList(&IPDRList, IPDR);
return; return;
} }
AddrInitIPv4(&IPDR->SrcAddr, IPv4Header->SrcAddr); AddrInitIPv4(&IPDR->SrcAddr, IPv4Header->SrcAddr);
@ -361,7 +361,7 @@ VOID ProcessFragment(
NewHole = CreateHoleDescriptor(Hole->First, FragFirst - 1); NewHole = CreateHoleDescriptor(Hole->First, FragFirst - 1);
if (!NewHole) { if (!NewHole) {
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
exFreeToNPagedLookasideList(&IPHoleList, Hole); ExFreeToNPagedLookasideList(&IPHoleList, Hole);
Cleanup(&IPDR->Lock, OldIrql, IPDR); Cleanup(&IPDR->Lock, OldIrql, IPDR);
return; return;
} }
@ -374,7 +374,7 @@ VOID ProcessFragment(
NewHole = CreateHoleDescriptor(FragLast + 1, Hole->Last); NewHole = CreateHoleDescriptor(FragLast + 1, Hole->Last);
if (!NewHole) { if (!NewHole) {
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
exFreeToNPagedLookasideList(&IPHoleList, Hole); ExFreeToNPagedLookasideList(&IPHoleList, Hole);
Cleanup(&IPDR->Lock, OldIrql, IPDR); Cleanup(&IPDR->Lock, OldIrql, IPDR);
return; return;
} }
@ -383,7 +383,7 @@ VOID ProcessFragment(
InsertTailList(&IPDR->HoleListHead, &NewHole->ListEntry); InsertTailList(&IPDR->HoleListHead, &NewHole->ListEntry);
} }
exFreeToNPagedLookasideList(&IPHoleList, Hole); ExFreeToNPagedLookasideList(&IPHoleList, Hole);
/* If this is the first fragment, save the IP header */ /* If this is the first fragment, save the IP header */
if (FragFirst == 0) { if (FragFirst == 0) {
@ -397,7 +397,7 @@ VOID ProcessFragment(
/* Create a buffer, copy the data into it and put it /* Create a buffer, copy the data into it and put it
in the fragment list */ in the fragment list */
Fragment = exAllocateFromNPagedLookasideList(&IPFragmentList); Fragment = ExAllocateFromNPagedLookasideList(&IPFragmentList);
if (!Fragment) { if (!Fragment) {
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
Cleanup(&IPDR->Lock, OldIrql, IPDR); Cleanup(&IPDR->Lock, OldIrql, IPDR);
@ -407,10 +407,10 @@ VOID ProcessFragment(
TI_DbgPrint(DEBUG_IP, ("Fragment descriptor allocated at (0x%X).\n", Fragment)); TI_DbgPrint(DEBUG_IP, ("Fragment descriptor allocated at (0x%X).\n", Fragment));
Fragment->Size = IPPacket->TotalSize - IPPacket->HeaderSize; Fragment->Size = IPPacket->TotalSize - IPPacket->HeaderSize;
Fragment->Data = exAllocatePool(NonPagedPool, Fragment->Size); Fragment->Data = ExAllocatePoolWithTag(NonPagedPool, Fragment->Size, FRAGMENT_DATA_TAG);
if (!Fragment->Data) { if (!Fragment->Data) {
/* We don't have the resources to process this packet, discard it */ /* We don't have the resources to process this packet, discard it */
exFreeToNPagedLookasideList(&IPFragmentList, Fragment); ExFreeToNPagedLookasideList(&IPFragmentList, Fragment);
Cleanup(&IPDR->Lock, OldIrql, IPDR); Cleanup(&IPDR->Lock, OldIrql, IPDR);
return; return;
} }
@ -465,7 +465,7 @@ VOID ProcessFragment(
IF->Stats.InBytes += Datagram.TotalSize; IF->Stats.InBytes += Datagram.TotalSize;
/* We're done with this datagram */ /* We're done with this datagram */
exFreePool(Datagram.Header); ExFreePoolWithTag(Datagram.Header, PACKET_BUFFER_TAG);
TI_DbgPrint(MAX_TRACE, ("Freeing datagram at (0x%X).\n", Datagram)); TI_DbgPrint(MAX_TRACE, ("Freeing datagram at (0x%X).\n", Datagram));
(*Datagram.Free)(&Datagram); (*Datagram.Free)(&Datagram);
} else } else

6
lib/drivers/ip/network/router.c
View file

@ -51,7 +51,7 @@ VOID FreeFIB(
* Object = Pointer to an forward information base structure * Object = Pointer to an forward information base structure
*/ */
{ {
exFreePool(Object); ExFreePoolWithTag(Object, FIB_TAG);
} }
@ -217,14 +217,12 @@ PFIB_ENTRY RouterAddRoute(
A2S(Netmask), A2S(Netmask),
A2S(&Router->Address))); A2S(&Router->Address)));
FIBE = exAllocatePool(NonPagedPool, sizeof(FIB_ENTRY)); FIBE = ExAllocatePoolWithTag(NonPagedPool, sizeof(FIB_ENTRY), FIB_TAG);
if (!FIBE) { if (!FIBE) {
TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n")); TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
return NULL; return NULL;
} }
INIT_TAG(Router, 'TUOR');
RtlCopyMemory( &FIBE->NetworkAddress, NetworkAddress, RtlCopyMemory( &FIBE->NetworkAddress, NetworkAddress,
sizeof(FIBE->NetworkAddress) ); sizeof(FIBE->NetworkAddress) );
RtlCopyMemory( &FIBE->Netmask, Netmask, RtlCopyMemory( &FIBE->Netmask, Netmask,

4
lib/drivers/ip/network/routines.c
View file

@ -115,11 +115,11 @@ VOID DisplayTCPPacket(
if (IPPacket->NdisPacket) { if (IPPacket->NdisPacket) {
NdisQueryPacket(IPPacket->NdisPacket, NULL, NULL, NULL, &Length); NdisQueryPacket(IPPacket->NdisPacket, NULL, NULL, NULL, &Length);
Buffer = exAllocatePool(NonPagedPool, Length); Buffer = ExAllocatePool(NonPagedPool, Length);
if (Buffer) { if (Buffer) {
Length = CopyPacketToBuffer(Buffer, IPPacket->NdisPacket, 0, Length); Length = CopyPacketToBuffer(Buffer, IPPacket->NdisPacket, 0, Length);
DisplayTCPHeader(Buffer, Length); DisplayTCPHeader(Buffer, Length);
exFreePool(Buffer); ExFreePool(Buffer);
} }
} else { } else {
Buffer = IPPacket->Header; Buffer = IPPacket->Header;

12
lib/drivers/ip/network/transmit.c
View file

@ -42,7 +42,7 @@ VOID IPSendComplete
{ {
FreeNdisPacket(IFC->NdisPacket); FreeNdisPacket(IFC->NdisPacket);
IFC->Complete(IFC->Context, IFC->Datagram, Status); IFC->Complete(IFC->Context, IFC->Datagram, Status);
exFreePool(IFC); ExFreePoolWithTag(IFC, IFC_TAG);
} }
} else { } else {
TI_DbgPrint(MAX_TRACE, ("Calling completion handler.\n")); TI_DbgPrint(MAX_TRACE, ("Calling completion handler.\n"));
@ -50,7 +50,7 @@ VOID IPSendComplete
/* There are no more fragments to transmit, so call completion handler */ /* There are no more fragments to transmit, so call completion handler */
FreeNdisPacket(IFC->NdisPacket); FreeNdisPacket(IFC->NdisPacket);
IFC->Complete(IFC->Context, IFC->Datagram, NdisStatus); IFC->Complete(IFC->Context, IFC->Datagram, NdisStatus);
exFreePool(IFC); ExFreePoolWithTag(IFC, IFC_TAG);
} }
} }
@ -178,7 +178,7 @@ NTSTATUS SendFragments(
TI_DbgPrint(MAX_TRACE, ("Fragment buffer is %d bytes\n", BufferSize)); TI_DbgPrint(MAX_TRACE, ("Fragment buffer is %d bytes\n", BufferSize));
IFC = exAllocatePool(NonPagedPool, sizeof(IPFRAGMENT_CONTEXT)); IFC = ExAllocatePoolWithTag(NonPagedPool, sizeof(IPFRAGMENT_CONTEXT), IFC_TAG);
if (IFC == NULL) if (IFC == NULL)
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
@ -187,7 +187,7 @@ NTSTATUS SendFragments(
( &IFC->NdisPacket, NULL, BufferSize ); ( &IFC->NdisPacket, NULL, BufferSize );
if( !NT_SUCCESS(NdisStatus) ) { if( !NT_SUCCESS(NdisStatus) ) {
exFreePool( IFC ); ExFreePoolWithTag( IFC, IFC_TAG );
return NdisStatus; return NdisStatus;
} }
@ -215,14 +215,14 @@ NTSTATUS SendFragments(
if (!PrepareNextFragment(IFC)) { if (!PrepareNextFragment(IFC)) {
FreeNdisPacket(IFC->NdisPacket); FreeNdisPacket(IFC->NdisPacket);
exFreePool(IFC); ExFreePoolWithTag(IFC, IFC_TAG);
return NDIS_STATUS_FAILURE; return NDIS_STATUS_FAILURE;
} }
if (!NT_SUCCESS((NdisStatus = IPSendFragment(IFC->NdisPacket, NCE, IFC)))) if (!NT_SUCCESS((NdisStatus = IPSendFragment(IFC->NdisPacket, NCE, IFC))))
{ {
FreeNdisPacket(IFC->NdisPacket); FreeNdisPacket(IFC->NdisPacket);
exFreePool(IFC); ExFreePoolWithTag(IFC, IFC_TAG);
} }
return NdisStatus; return NdisStatus;

120
lib/drivers/ip/transport/datagram/datagram.c
View file

@ -10,13 +10,14 @@
#include "precomp.h" #include "precomp.h"
VOID DGRemoveIRP( BOOLEAN DGRemoveIRP(
PADDRESS_FILE AddrFile, PADDRESS_FILE AddrFile,
PIRP Irp) PIRP Irp)
{ {
PLIST_ENTRY ListEntry; PLIST_ENTRY ListEntry;
PDATAGRAM_RECEIVE_REQUEST ReceiveRequest; PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
KIRQL OldIrql; KIRQL OldIrql;
BOOLEAN Found = FALSE;
TI_DbgPrint(MAX_TRACE, ("Called (Cancel IRP %08x for file %08x).\n", TI_DbgPrint(MAX_TRACE, ("Called (Cancel IRP %08x for file %08x).\n",
Irp, AddrFile)); Irp, AddrFile));
@ -35,7 +36,8 @@ VOID DGRemoveIRP(
if (ReceiveRequest->Irp == Irp) if (ReceiveRequest->Irp == Irp)
{ {
RemoveEntryList(&ReceiveRequest->ListEntry); RemoveEntryList(&ReceiveRequest->ListEntry);
exFreePool(ReceiveRequest); ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG);
Found = TRUE;
break; break;
} }
} }
@ -43,6 +45,8 @@ VOID DGRemoveIRP(
KeReleaseSpinLock(&AddrFile->Lock, OldIrql); KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
TI_DbgPrint(MAX_TRACE, ("Done.\n")); TI_DbgPrint(MAX_TRACE, ("Done.\n"));
return Found;
} }
VOID DGDeliverData( VOID DGDeliverData(
@ -79,7 +83,7 @@ VOID DGDeliverData(
TI_DbgPrint(MAX_TRACE, ("Called.\n")); TI_DbgPrint(MAX_TRACE, ("Called.\n"));
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql); KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
if (AddrFile->Protocol == IPPROTO_UDP) if (AddrFile->Protocol == IPPROTO_UDP)
{ {
@ -136,7 +140,7 @@ VOID DGDeliverData(
&SrcAddress->Address.IPv4Address, &SrcAddress->Address.IPv4Address,
sizeof(SrcAddress->Address.IPv4Address) ); sizeof(SrcAddress->Address.IPv4Address) );
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql); KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
/* Complete the receive request */ /* Complete the receive request */
if (Current->BufferSize < DataSize) if (Current->BufferSize < DataSize)
@ -144,11 +148,11 @@ VOID DGDeliverData(
else else
Current->Complete(Current->Context, STATUS_SUCCESS, DataSize); Current->Complete(Current->Context, STATUS_SUCCESS, DataSize);
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql); KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
} }
} }
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql); KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
} }
else if (AddrFile->RegisteredReceiveDatagramHandler) else if (AddrFile->RegisteredReceiveDatagramHandler)
{ {
@ -157,8 +161,6 @@ VOID DGDeliverData(
ReceiveHandler = AddrFile->ReceiveDatagramHandler; ReceiveHandler = AddrFile->ReceiveDatagramHandler;
HandlerContext = AddrFile->ReceiveDatagramHandlerContext; HandlerContext = AddrFile->ReceiveDatagramHandlerContext;
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
if (SrcAddress->Type == IP_ADDRESS_V4) if (SrcAddress->Type == IP_ADDRESS_V4)
{ {
AddressLength = sizeof(IPv4_RAW_ADDRESS); AddressLength = sizeof(IPv4_RAW_ADDRESS);
@ -170,6 +172,8 @@ VOID DGDeliverData(
SourceAddress = SrcAddress->Address.IPv6Address; SourceAddress = SrcAddress->Address.IPv6Address;
} }
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
Status = (*ReceiveHandler)(HandlerContext, Status = (*ReceiveHandler)(HandlerContext,
AddressLength, AddressLength,
SourceAddress, SourceAddress,
@ -184,7 +188,7 @@ VOID DGDeliverData(
} }
else else
{ {
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql); KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
TI_DbgPrint(MAX_TRACE, ("Discarding datagram.\n")); TI_DbgPrint(MAX_TRACE, ("Discarding datagram.\n"));
} }
@ -197,7 +201,7 @@ VOID DGReceiveComplete(PVOID Context, NTSTATUS Status, ULONG Count) {
(PDATAGRAM_RECEIVE_REQUEST)Context; (PDATAGRAM_RECEIVE_REQUEST)Context;
TI_DbgPrint(MAX_TRACE,("Called (%08x:%08x)\n", Status, Count)); TI_DbgPrint(MAX_TRACE,("Called (%08x:%08x)\n", Status, Count));
ReceiveRequest->UserComplete( ReceiveRequest->UserContext, Status, Count ); ReceiveRequest->UserComplete( ReceiveRequest->UserContext, Status, Count );
exFreePool( ReceiveRequest ); ExFreePoolWithTag( ReceiveRequest, DATAGRAM_RECV_TAG );
TI_DbgPrint(MAX_TRACE,("Done\n")); TI_DbgPrint(MAX_TRACE,("Done\n"));
} }
@ -228,76 +232,68 @@ NTSTATUS DGReceiveDatagram(
* This is the high level interface for receiving DG datagrams * This is the high level interface for receiving DG datagrams
*/ */
{ {
KIRQL OldIrql;
NTSTATUS Status; NTSTATUS Status;
PDATAGRAM_RECEIVE_REQUEST ReceiveRequest; PDATAGRAM_RECEIVE_REQUEST ReceiveRequest;
KIRQL OldIrql;
TI_DbgPrint(MAX_TRACE, ("Called.\n")); TI_DbgPrint(MAX_TRACE, ("Called.\n"));
TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql); KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
if (AF_IS_VALID(AddrFile)) ReceiveRequest = ExAllocatePoolWithTag(NonPagedPool, sizeof(DATAGRAM_RECEIVE_REQUEST),
DATAGRAM_RECV_TAG);
if (ReceiveRequest)
{ {
ReceiveRequest = exAllocatePool(NonPagedPool, sizeof(DATAGRAM_RECEIVE_REQUEST)); /* Initialize a receive request */
if (ReceiveRequest)
/* Extract the remote address filter from the request (if any) */
if ((ConnInfo->RemoteAddressLength != 0) &&
(ConnInfo->RemoteAddress))
{ {
/* Initialize a receive request */ Status = AddrGetAddress(ConnInfo->RemoteAddress,
&ReceiveRequest->RemoteAddress,
/* Extract the remote address filter from the request (if any) */ &ReceiveRequest->RemotePort);
if ((ConnInfo->RemoteAddressLength != 0) && if (!NT_SUCCESS(Status))
(ConnInfo->RemoteAddress))
{ {
Status = AddrGetAddress(ConnInfo->RemoteAddress, ExFreePoolWithTag(ReceiveRequest, DATAGRAM_RECV_TAG);
&ReceiveRequest->RemoteAddress, KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
&ReceiveRequest->RemotePort); return Status;
if (!NT_SUCCESS(Status))
{
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
exFreePool(ReceiveRequest);
return Status;
}
} }
else }
{
ReceiveRequest->RemotePort = 0;
AddrInitIPv4(&ReceiveRequest->RemoteAddress, 0);
}
IoMarkIrpPending(Irp);
ReceiveRequest->ReturnInfo = ReturnInfo;
ReceiveRequest->Buffer = BufferData;
ReceiveRequest->BufferSize = ReceiveLength;
ReceiveRequest->UserComplete = Complete;
ReceiveRequest->UserContext = Context;
ReceiveRequest->Complete =
(PDATAGRAM_COMPLETION_ROUTINE)DGReceiveComplete;
ReceiveRequest->Context = ReceiveRequest;
ReceiveRequest->AddressFile = AddrFile;
ReceiveRequest->Irp = Irp;
/* Queue receive request */
InsertTailList(&AddrFile->ReceiveQueue, &ReceiveRequest->ListEntry);
AF_SET_PENDING(AddrFile, AFF_RECEIVE);
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
TI_DbgPrint(MAX_TRACE, ("Leaving (pending %08x).\n", ReceiveRequest));
return STATUS_PENDING;
}
else else
{ {
Status = STATUS_INSUFFICIENT_RESOURCES; ReceiveRequest->RemotePort = 0;
AddrInitIPv4(&ReceiveRequest->RemoteAddress, 0);
} }
IoMarkIrpPending(Irp);
ReceiveRequest->ReturnInfo = ReturnInfo;
ReceiveRequest->Buffer = BufferData;
ReceiveRequest->BufferSize = ReceiveLength;
ReceiveRequest->UserComplete = Complete;
ReceiveRequest->UserContext = Context;
ReceiveRequest->Complete =
(PDATAGRAM_COMPLETION_ROUTINE)DGReceiveComplete;
ReceiveRequest->Context = ReceiveRequest;
ReceiveRequest->AddressFile = AddrFile;
ReceiveRequest->Irp = Irp;
/* Queue receive request */
InsertTailList(&AddrFile->ReceiveQueue, &ReceiveRequest->ListEntry);
TI_DbgPrint(MAX_TRACE, ("Leaving (pending %08x).\n", ReceiveRequest));
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_PENDING;
} }
else else
{ {
Status = STATUS_INVALID_ADDRESS; KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
Status = STATUS_INSUFFICIENT_RESOURCES;
} }
TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
TI_DbgPrint(MAX_TRACE, ("Leaving with errors (0x%X).\n", Status)); TI_DbgPrint(MAX_TRACE, ("Leaving with errors (0x%X).\n", Status));
return Status; return Status;

13
lib/drivers/ip/transport/rawip/rawip.c
View file

@ -195,6 +195,9 @@ NTSTATUS RawIPSendDatagram(
USHORT RemotePort; USHORT RemotePort;
NTSTATUS Status; NTSTATUS Status;
PNEIGHBOR_CACHE_ENTRY NCE; PNEIGHBOR_CACHE_ENTRY NCE;
KIRQL OldIrql;
KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n", TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n",
AddrFile, ConnInfo, BufferData, DataSize)); AddrFile, ConnInfo, BufferData, DataSize));
@ -209,13 +212,17 @@ NTSTATUS RawIPSendDatagram(
break; break;
default: default:
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
TI_DbgPrint(MID_TRACE,("About to get route to destination\n")); TI_DbgPrint(MID_TRACE,("About to get route to destination\n"));
if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) if(!(NCE = RouteGetRouteToDestination( &RemoteAddress )))
{
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_NETWORK_UNREACHABLE; return STATUS_NETWORK_UNREACHABLE;
}
LocalAddress = AddrFile->Address; LocalAddress = AddrFile->Address;
if (AddrIsUnspecified(&LocalAddress)) if (AddrIsUnspecified(&LocalAddress))
@ -237,18 +244,24 @@ NTSTATUS RawIPSendDatagram(
DataSize ); DataSize );
if( !NT_SUCCESS(Status) ) if( !NT_SUCCESS(Status) )
{
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return Status; return Status;
}
TI_DbgPrint(MID_TRACE,("About to send datagram\n")); TI_DbgPrint(MID_TRACE,("About to send datagram\n"));
if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, RawIpSendPacketComplete, NULL ))) if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, RawIpSendPacketComplete, NULL )))
{ {
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
FreeNdisPacket(Packet.NdisPacket); FreeNdisPacket(Packet.NdisPacket);
return Status; return Status;
} }
TI_DbgPrint(MID_TRACE,("Leaving\n")); TI_DbgPrint(MID_TRACE,("Leaving\n"));
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }

31
lib/drivers/ip/transport/tcp/accept.c
View file

@ -10,6 +10,7 @@
#include "precomp.h" #include "precomp.h"
/* Listener->Lock MUST be acquired */
NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener, NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener,
PCONNECTION_ENDPOINT Connection, PCONNECTION_ENDPOINT Connection,
PTDI_REQUEST_KERNEL Request ) { PTDI_REQUEST_KERNEL Request ) {
@ -19,8 +20,6 @@ NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener,
PTA_IP_ADDRESS RequestAddressReturn; PTA_IP_ADDRESS RequestAddressReturn;
PTDI_CONNECTION_INFORMATION WhoIsConnecting; PTDI_CONNECTION_INFORMATION WhoIsConnecting;
ASSERT_LOCKED(&TCPLock);
/* Unpack TDI info -- We need the return connection information /* Unpack TDI info -- We need the return connection information
* struct to return the address so it can be filtered if needed * struct to return the address so it can be filtered if needed
* by WSAAccept -- The returned address will be passed on to * by WSAAccept -- The returned address will be passed on to
@ -31,6 +30,7 @@ NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener,
Status = TCPTranslateError Status = TCPTranslateError
( OskitTCPAccept( Listener->SocketContext, ( OskitTCPAccept( Listener->SocketContext,
&Connection->SocketContext, &Connection->SocketContext,
Connection,
&OutAddr, &OutAddr,
sizeof(OutAddr), sizeof(OutAddr),
&OutAddrLen, &OutAddrLen,
@ -69,13 +69,14 @@ NTSTATUS TCPServiceListeningSocket( PCONNECTION_ENDPOINT Listener,
NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog ) { NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog ) {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
SOCKADDR_IN AddressToBind; SOCKADDR_IN AddressToBind;
KIRQL OldIrql;
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
ASSERT(Connection); ASSERT(Connection);
ASSERT_KM_POINTER(Connection->SocketContext); ASSERT_KM_POINTER(Connection->SocketContext);
ASSERT_KM_POINTER(Connection->AddressFile); ASSERT_KM_POINTER(Connection->AddressFile);
KeAcquireSpinLock(&Connection->Lock, &OldIrql);
TI_DbgPrint(DEBUG_TCP,("TCPListen started\n")); TI_DbgPrint(DEBUG_TCP,("TCPListen started\n"));
TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext %x\n", TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext %x\n",
@ -96,18 +97,19 @@ NTSTATUS TCPListen( PCONNECTION_ENDPOINT Connection, UINT Backlog ) {
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
Status = TCPTranslateError( OskitTCPListen( Connection->SocketContext, Backlog ) ); Status = TCPTranslateError( OskitTCPListen( Connection->SocketContext, Backlog ) );
TcpipRecursiveMutexLeave( &TCPLock ); KeReleaseSpinLock(&Connection->Lock, OldIrql);
TI_DbgPrint(DEBUG_TCP,("TCPListen finished %x\n", Status)); TI_DbgPrint(DEBUG_TCP,("TCPListen finished %x\n", Status));
return Status; return Status;
} }
VOID TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener, BOOLEAN TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener,
PCONNECTION_ENDPOINT Connection ) { PCONNECTION_ENDPOINT Connection ) {
PLIST_ENTRY ListEntry; PLIST_ENTRY ListEntry;
PTDI_BUCKET Bucket; PTDI_BUCKET Bucket;
KIRQL OldIrql; KIRQL OldIrql;
BOOLEAN Found = FALSE;
KeAcquireSpinLock(&Listener->Lock, &OldIrql); KeAcquireSpinLock(&Listener->Lock, &OldIrql);
@ -117,7 +119,8 @@ VOID TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener,
if( Bucket->AssociatedEndpoint == Connection ) { if( Bucket->AssociatedEndpoint == Connection ) {
RemoveEntryList( &Bucket->Entry ); RemoveEntryList( &Bucket->Entry );
exFreePool( Bucket ); ExFreePoolWithTag( Bucket, TDI_BUCKET_TAG );
Found = TRUE;
break; break;
} }
@ -125,6 +128,8 @@ VOID TCPAbortListenForSocket( PCONNECTION_ENDPOINT Listener,
} }
KeReleaseSpinLock(&Listener->Lock, OldIrql); KeReleaseSpinLock(&Listener->Lock, OldIrql);
return Found;
} }
NTSTATUS TCPAccept ( PTDI_REQUEST Request, NTSTATUS TCPAccept ( PTDI_REQUEST Request,
@ -135,25 +140,27 @@ NTSTATUS TCPAccept ( PTDI_REQUEST Request,
{ {
NTSTATUS Status; NTSTATUS Status;
PTDI_BUCKET Bucket; PTDI_BUCKET Bucket;
KIRQL OldIrql;
TI_DbgPrint(DEBUG_TCP,("TCPAccept started\n")); TI_DbgPrint(DEBUG_TCP,("TCPAccept started\n"));
TcpipRecursiveMutexEnter( &TCPLock, TRUE ); KeAcquireSpinLock(&Listener->Lock, &OldIrql);
Status = TCPServiceListeningSocket( Listener, Connection, Status = TCPServiceListeningSocket( Listener, Connection,
(PTDI_REQUEST_KERNEL)Request ); (PTDI_REQUEST_KERNEL)Request );
TcpipRecursiveMutexLeave( &TCPLock ); KeReleaseSpinLock(&Listener->Lock, OldIrql);
if( Status == STATUS_PENDING ) { if( Status == STATUS_PENDING ) {
Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) ); Bucket = ExAllocatePoolWithTag( NonPagedPool, sizeof(*Bucket),
TDI_BUCKET_TAG );
if( Bucket ) { if( Bucket ) {
Bucket->AssociatedEndpoint = Connection; Bucket->AssociatedEndpoint = Connection;
Bucket->Request.RequestNotifyObject = Complete; Bucket->Request.RequestNotifyObject = Complete;
Bucket->Request.RequestContext = Context; Bucket->Request.RequestContext = Context;
IoMarkIrpPending((PIRP)Context); ExInterlockedInsertTailList( &Listener->ListenRequest, &Bucket->Entry,
ExInterlockedInsertTailList( &Listener->ListenRequest, &Bucket->Entry, &Listener->Lock ); &Listener->Lock );
} else } else
Status = STATUS_NO_MEMORY; Status = STATUS_NO_MEMORY;
} }

126
lib/drivers/ip/transport/tcp/event.c
View file

@ -16,36 +16,33 @@ int TCPSocketState(void *ClientData,
OSK_UINT NewState ) { OSK_UINT NewState ) {
PCONNECTION_ENDPOINT Connection = WhichConnection; PCONNECTION_ENDPOINT Connection = WhichConnection;
ASSERT_LOCKED(&TCPLock); TI_DbgPrint(DEBUG_TCP,("Connection: %x Flags: %c%c%c%c%c\n",
Connection,
TI_DbgPrint(MID_TRACE,("Flags: %c%c%c%c\n",
NewState & SEL_CONNECT ? 'C' : 'c', NewState & SEL_CONNECT ? 'C' : 'c',
NewState & SEL_READ ? 'R' : 'r', NewState & SEL_READ ? 'R' : 'r',
NewState & SEL_FIN ? 'F' : 'f', NewState & SEL_FIN ? 'F' : 'f',
NewState & SEL_ACCEPT ? 'A' : 'a')); NewState & SEL_ACCEPT ? 'A' : 'a',
NewState & SEL_WRITE ? 'W' : 'w'));
if (!Connection)
{
return 0;
}
if (ClientInfo.Unlocked)
KeAcquireSpinLockAtDpcLevel(&Connection->Lock);
TI_DbgPrint(DEBUG_TCP,("Called: NewState %x (Conn %x) (Change %x)\n", TI_DbgPrint(DEBUG_TCP,("Called: NewState %x (Conn %x) (Change %x)\n",
NewState, Connection, NewState, Connection,
Connection ? Connection->State ^ NewState : Connection->SignalState ^ NewState,
NewState)); NewState));
if( !Connection ) {
TI_DbgPrint(DEBUG_TCP,("Socket closing.\n"));
Connection = FileFindConnectionByContext( WhichSocket );
if( !Connection )
return 0;
else
TI_DbgPrint(DEBUG_TCP,("Found socket %x\n", Connection));
}
TI_DbgPrint(MID_TRACE,("Connection signalled: %d\n",
Connection->Signalled));
Connection->SignalState |= NewState; Connection->SignalState |= NewState;
if( !Connection->Signalled ) {
Connection->Signalled = TRUE; HandleSignalledConnection(Connection);
ExInterlockedInsertTailList( &SignalledConnectionsList, &Connection->SignalList, &SignalledConnectionsLock );
} if (ClientInfo.Unlocked)
KeReleaseSpinLockFromDpcLevel(&Connection->Lock);
return 0; return 0;
} }
@ -67,8 +64,6 @@ int TCPPacketSend(void *ClientData, OSK_PCHAR data, OSK_UINT len ) {
IP_ADDRESS RemoteAddress, LocalAddress; IP_ADDRESS RemoteAddress, LocalAddress;
PIPv4_HEADER Header; PIPv4_HEADER Header;
ASSERT_LOCKED(&TCPLock);
if( *data == 0x45 ) { /* IPv4 */ if( *data == 0x45 ) { /* IPv4 */
Header = (PIPv4_HEADER)data; Header = (PIPv4_HEADER)data;
LocalAddress.Type = IP_ADDRESS_V4; LocalAddress.Type = IP_ADDRESS_V4;
@ -112,74 +107,6 @@ int TCPPacketSend(void *ClientData, OSK_PCHAR data, OSK_UINT len ) {
return 0; return 0;
} }
int TCPSleep( void *ClientData, void *token, int priority, char *msg,
int tmio ) {
PSLEEPING_THREAD SleepingThread;
LARGE_INTEGER Timeout;
ASSERT_LOCKED(&TCPLock);
TI_DbgPrint(DEBUG_TCP,
("Called TSLEEP: tok = %x, pri = %d, wmesg = %s, tmio = %x\n",
token, priority, msg, tmio));
SleepingThread = exAllocatePool( NonPagedPool, sizeof( *SleepingThread ) );
if( SleepingThread ) {
KeInitializeEvent( &SleepingThread->Event, NotificationEvent, FALSE );
SleepingThread->SleepToken = token;
/* We're going to sleep and need to release the lock, otherwise
it's impossible to re-enter oskittcp to deliver the event that's
going to wake us */
TcpipRecursiveMutexLeave( &TCPLock );
TcpipAcquireFastMutex( &SleepingThreadsLock );
InsertTailList( &SleepingThreadsList, &SleepingThread->Entry );
TcpipReleaseFastMutex( &SleepingThreadsLock );
Timeout.QuadPart = Int32x32To64(tmio, -10000);
TI_DbgPrint(DEBUG_TCP,("Waiting on %x\n", token));
KeWaitForSingleObject( &SleepingThread->Event,
Executive,
KernelMode,
TRUE,
(tmio != 0) ? &Timeout : NULL );
TcpipAcquireFastMutex( &SleepingThreadsLock );
RemoveEntryList( &SleepingThread->Entry );
TcpipReleaseFastMutex( &SleepingThreadsLock );
TcpipRecursiveMutexEnter( &TCPLock, TRUE );
exFreePool( SleepingThread );
} else
return OSK_ENOBUFS;
TI_DbgPrint(DEBUG_TCP,("Waiting finished: %x\n", token));
return 0;
}
void TCPWakeup( void *ClientData, void *token ) {
PLIST_ENTRY Entry;
PSLEEPING_THREAD SleepingThread;
ASSERT_LOCKED(&TCPLock);
TcpipAcquireFastMutex( &SleepingThreadsLock );
Entry = SleepingThreadsList.Flink;
while( Entry != &SleepingThreadsList ) {
SleepingThread = CONTAINING_RECORD(Entry, SLEEPING_THREAD, Entry);
TI_DbgPrint(DEBUG_TCP,("Sleeper @ %x\n", SleepingThread));
if( SleepingThread->SleepToken == token ) {
TI_DbgPrint(DEBUG_TCP,("Setting event to wake %x\n", token));
KeSetEvent( &SleepingThread->Event, IO_NETWORK_INCREMENT, FALSE );
}
Entry = Entry->Flink;
}
TcpipReleaseFastMutex( &SleepingThreadsLock );
}
/* Memory management routines /* Memory management routines
* *
* By far the most requests for memory are either for 128 or 2048 byte blocks, * By far the most requests for memory are either for 128 or 2048 byte blocks,
@ -199,8 +126,6 @@ void TCPWakeup( void *ClientData, void *token ) {
#define SIGNATURE_LARGE 'LLLL' #define SIGNATURE_LARGE 'LLLL'
#define SIGNATURE_SMALL 'SSSS' #define SIGNATURE_SMALL 'SSSS'
#define SIGNATURE_OTHER 'OOOO' #define SIGNATURE_OTHER 'OOOO'
#define TCP_TAG ' PCT'
static NPAGED_LOOKASIDE_LIST LargeLookasideList; static NPAGED_LOOKASIDE_LIST LargeLookasideList;
static NPAGED_LOOKASIDE_LIST SmallLookasideList; static NPAGED_LOOKASIDE_LIST SmallLookasideList;
@ -212,14 +137,14 @@ TCPMemStartup( void )
NULL, NULL,
0, 0,
LARGE_SIZE + sizeof( ULONG ), LARGE_SIZE + sizeof( ULONG ),
TCP_TAG, OSK_LARGE_TAG,
0 ); 0 );
ExInitializeNPagedLookasideList( &SmallLookasideList, ExInitializeNPagedLookasideList( &SmallLookasideList,
NULL, NULL,
NULL, NULL,
0, 0,
SMALL_SIZE + sizeof( ULONG ), SMALL_SIZE + sizeof( ULONG ),
TCP_TAG, OSK_SMALL_TAG,
0 ); 0 );
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -230,8 +155,6 @@ void *TCPMalloc( void *ClientData,
void *v; void *v;
ULONG Signature; ULONG Signature;
ASSERT_LOCKED(&TCPLock);
#if 0 != MEM_PROFILE #if 0 != MEM_PROFILE
static OSK_UINT *Sizes = NULL, *Counts = NULL, ArrayAllocated = 0; static OSK_UINT *Sizes = NULL, *Counts = NULL, ArrayAllocated = 0;
static OSK_UINT ArrayUsed = 0, AllocationCount = 0; static OSK_UINT ArrayUsed = 0, AllocationCount = 0;
@ -291,13 +214,13 @@ void *TCPMalloc( void *ClientData,
v = ExAllocateFromNPagedLookasideList( &LargeLookasideList ); v = ExAllocateFromNPagedLookasideList( &LargeLookasideList );
Signature = SIGNATURE_LARGE; Signature = SIGNATURE_LARGE;
} else { } else {
v = ExAllocatePool( NonPagedPool, Bytes + sizeof(ULONG) ); v = ExAllocatePoolWithTag( NonPagedPool, Bytes + sizeof(ULONG),
OSK_OTHER_TAG );
Signature = SIGNATURE_OTHER; Signature = SIGNATURE_OTHER;
} }
if( v ) { if( v ) {
*((ULONG *) v) = Signature; *((ULONG *) v) = Signature;
v = (void *)((char *) v + sizeof(ULONG)); v = (void *)((char *) v + sizeof(ULONG));
TrackWithTag( FOURCC('f','b','s','d'), v, (PCHAR)File, Line );
} }
return v; return v;
@ -307,9 +230,6 @@ void TCPFree( void *ClientData,
void *data, OSK_PCHAR File, OSK_UINT Line ) { void *data, OSK_PCHAR File, OSK_UINT Line ) {
ULONG Signature; ULONG Signature;
ASSERT_LOCKED(&TCPLock);
UntrackFL( (PCHAR)File, Line, data, FOURCC('f','b','s','d') );
data = (void *)((char *) data - sizeof(ULONG)); data = (void *)((char *) data - sizeof(ULONG));
Signature = *((ULONG *) data); Signature = *((ULONG *) data);
if ( SIGNATURE_SMALL == Signature ) { if ( SIGNATURE_SMALL == Signature ) {
@ -317,7 +237,7 @@ void TCPFree( void *ClientData,
} else if ( SIGNATURE_LARGE == Signature ) { } else if ( SIGNATURE_LARGE == Signature ) {
ExFreeToNPagedLookasideList( &LargeLookasideList, data ); ExFreeToNPagedLookasideList( &LargeLookasideList, data );
} else if ( SIGNATURE_OTHER == Signature ) { } else if ( SIGNATURE_OTHER == Signature ) {
ExFreePool( data ); ExFreePoolWithTag( data, OSK_OTHER_TAG );
} else { } else {
ASSERT( FALSE ); ASSERT( FALSE );
} }

4
lib/drivers/ip/transport/tcp/if.c
View file

@ -37,8 +37,6 @@ POSK_IFADDR TCPGetInterfaceData( PIP_INTERFACE IF ) {
struct sockaddr_in *dstaddr_in; struct sockaddr_in *dstaddr_in;
ASSERT(ifaddr); ASSERT(ifaddr);
ASSERT_LOCKED(&TCPLock);
RtlZeroMemory(ifaddr, sizeof(OSK_IFADDR) + 2 * sizeof( struct sockaddr_in )); RtlZeroMemory(ifaddr, sizeof(OSK_IFADDR) + 2 * sizeof( struct sockaddr_in ));
addr_in = (struct sockaddr_in *)&ifaddr[1]; addr_in = (struct sockaddr_in *)&ifaddr[1];
@ -81,8 +79,6 @@ POSK_IFADDR TCPFindInterface( void *ClientData,
struct sockaddr_in *addr_in = (struct sockaddr_in *)ReqAddr; struct sockaddr_in *addr_in = (struct sockaddr_in *)ReqAddr;
POSK_IFADDR InterfaceData; POSK_IFADDR InterfaceData;
ASSERT_LOCKED(&TCPLock);
TI_DbgPrint(DEBUG_TCPIF,("called for type %d\n", FindType)); TI_DbgPrint(DEBUG_TCPIF,("called for type %d\n", FindType));
if( !ReqAddr ) { if( !ReqAddr ) {

754
lib/drivers/ip/transport/tcp/tcp.c
View file

File diff suppressed because it is too large Load diff

11
lib/drivers/ip/transport/udp/udp.c
View file

@ -172,6 +172,9 @@ NTSTATUS UDPSendDatagram(
USHORT RemotePort; USHORT RemotePort;
NTSTATUS Status; NTSTATUS Status;
PNEIGHBOR_CACHE_ENTRY NCE; PNEIGHBOR_CACHE_ENTRY NCE;
KIRQL OldIrql;
KeAcquireSpinLock(&AddrFile->Lock, &OldIrql);
TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n", TI_DbgPrint(MID_TRACE,("Sending Datagram(%x %x %x %d)\n",
AddrFile, ConnInfo, BufferData, DataSize)); AddrFile, ConnInfo, BufferData, DataSize));
@ -186,10 +189,12 @@ NTSTATUS UDPSendDatagram(
break; break;
default: default:
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) { if(!(NCE = RouteGetRouteToDestination( &RemoteAddress ))) {
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_NETWORK_UNREACHABLE; return STATUS_NETWORK_UNREACHABLE;
} }
@ -213,14 +218,20 @@ NTSTATUS UDPSendDatagram(
DataSize ); DataSize );
if( !NT_SUCCESS(Status) ) if( !NT_SUCCESS(Status) )
{
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return Status; return Status;
}
if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, UDPSendPacketComplete, NULL ))) if (!NT_SUCCESS(Status = IPSendDatagram( &Packet, NCE, UDPSendPacketComplete, NULL )))
{ {
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
FreeNdisPacket(Packet.NdisPacket); FreeNdisPacket(Packet.NdisPacket);
return Status; return Status;
} }
KeReleaseSpinLock(&AddrFile->Lock, OldIrql);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }

80
lib/drivers/oskittcp/include/memtrack.h
View file

@ -1,80 +0,0 @@
#ifndef MEMTRACK_H
#define MEMTRACK_H
#ifndef FOURCC
#define FOURCC(a,b,c,d) (((a)<<24)|((b)<<16)|((c)<<8)|(d))
#endif
#define FBSD_MALLOC FOURCC('d','s','b','f')
#define EXALLOC_TAG FOURCC('E','x','A','l')
#if DBG
#define MTMARK() TrackDumpFL(__FILE__, __LINE__)
#define NdisAllocateBuffer(x,y,z,a,b) { \
NdisAllocateBuffer(x,y,z,a,b); \
if( *x == NDIS_STATUS_SUCCESS ) { \
Track(NDIS_BUFFER_TAG, *y); \
} \
}
#define NdisAllocatePacket(x,y,z) { \
NdisAllocatePacket(x,y,z); \
if( *x == NDIS_STATUS_SUCCESS ) { \
Track(NDIS_PACKET_TAG, *y); \
} \
}
#define FreeNdisPacket(x) { TI_DbgPrint(MID_TRACE,("Deleting Packet %x\n", x)); FreeNdisPacketX(x); }
#define NdisFreePacket(x) { Untrack(x); NdisFreePacket(x); }
#define NdisFreeBuffer(x) { Untrack(x); NdisFreeBuffer(x); }
#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;
typedef struct _ALLOCATION_TRACKER {
LIST_ENTRY Entry;
DWORD Tag;
PVOID Thing;
PCHAR FileName;
DWORD LineNo;
} ALLOCATION_TRACKER, *PALLOCATION_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 );
#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 ExAllocatePoolX( POOL_TYPE type, SIZE_T size, PCHAR File, ULONG Line ) {
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);
ExFreePool(Data);
}
#define MEMTRACK_MAX_TAGS_TO_TRACK 64
#else
#define MTMARK()
#define Track(x,y)
#define TrackingInit()
#define TrackDump()
#define Untrack(x)
#define TrackTag(x)
#define FreeNdisPacket FreeNdisPacketX
#define exFreePool(x) ExFreePool(x)
#define exAllocatePool(x,y) ExAllocatePool(x,y)
#define exAllocatePoolWithTag(x,y,z) ExAllocatePoolWithTag(x,y,z)
#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*/

29
lib/drivers/oskittcp/include/oskittcp.h
View file

@ -123,7 +123,7 @@ extern int OskitTCPSend( void *socket,
OSK_UINT *OutLen, OSK_UINT *OutLen,
OSK_UINT Flags ); OSK_UINT Flags );
extern int OskitTCPConnect( void *socket, void *connection, extern int OskitTCPConnect( void *socket,
void *nam, OSK_UINT namelen ); void *nam, OSK_UINT namelen );
extern int OskitTCPClose( void *socket ); extern int OskitTCPClose( void *socket );
@ -131,7 +131,7 @@ extern int OskitTCPBind( void *socket,
void *nam, OSK_UINT namelen ); void *nam, OSK_UINT namelen );
extern int OskitTCPAccept( void *socket, void **new_socket, extern int OskitTCPAccept( void *socket, void **new_socket,
void *addr_out, void *context, void *addr_out,
OSK_UINT addr_len, OSK_UINT addr_len,
OSK_UINT *out_addr_len, OSK_UINT *out_addr_len,
OSK_UINT finish_accept ); OSK_UINT finish_accept );
@ -164,6 +164,8 @@ int OskitTCPSetSockOpt(void *socket,
int OskitTCPDisconnect(void *socket); int OskitTCPDisconnect(void *socket);
int OskitTCPGetSocketError(void *socket);
#undef errno #undef errno
void *fbsd_malloc( unsigned int bytes, char *file, unsigned line, ... ); void *fbsd_malloc( unsigned int bytes, char *file, unsigned line, ... );
@ -187,4 +189,27 @@ void fbsd_free( void *data, char *file, unsigned line, ... );
#define FREAD 0x0001 #define FREAD 0x0001
#define FWRITE 0x0002 #define FWRITE 0x0002
/* Don't define this unless your are insane or aicom */
//#define LOCK_SPAM
#ifdef LOCK_SPAM
#define OSKLock() if (!KeTryToAcquireSpinLockAtDpcLevel(&OSKLock)) \
{ \
DbgPrint("OSKLock WAIT (%s)\n", __FUNCTION__); \
KeAcquireSpinLockAtDpcLevel(&OSKLock); \
} \
DbgPrint("OSKLock >>>> (%s)\n", __FUNCTION__)
#define OSKUnlock() KeReleaseSpinLockFromDpcLevel(&OSKLock); \
DbgPrint("OSKLock <<<< (%s)\n", __FUNCTION__)
#else
#define OSKLock() KeAcquireSpinLockAtDpcLevel(&OSKLock)
#define OSKUnlock() KeReleaseSpinLockFromDpcLevel(&OSKLock)
#endif
#define OSKLockAndRaise(x) KeRaiseIrql(DISPATCH_LEVEL, x); \
OSKLock()
#define OSKUnlockAndLower(x) OSKUnlock(); \
KeLowerIrql(x)
#endif/*OSKITTCP_H*/ #endif/*OSKITTCP_H*/

159
lib/drivers/oskittcp/oskittcp/interface.c
View file

@ -23,6 +23,8 @@ OSKITTCP_EVENT_HANDLERS OtcpEvent = { 0 };
//OSK_UINT OskitDebugTraceLevel = OSK_DEBUG_ULTRA; //OSK_UINT OskitDebugTraceLevel = OSK_DEBUG_ULTRA;
OSK_UINT OskitDebugTraceLevel = 0; OSK_UINT OskitDebugTraceLevel = 0;
KSPIN_LOCK OSKLock;
/* SPL */ /* SPL */
unsigned cpl; unsigned cpl;
unsigned net_imask; unsigned net_imask;
@ -45,6 +47,7 @@ void fbsd_free( void *data, char *file, unsigned line, ... ) {
void InitOskitTCP() { void InitOskitTCP() {
OS_DbgPrint(OSK_MID_TRACE,("Init Called\n")); OS_DbgPrint(OSK_MID_TRACE,("Init Called\n"));
KeInitializeSpinLock(&OSKLock);
OS_DbgPrint(OSK_MID_TRACE,("MB Init\n")); OS_DbgPrint(OSK_MID_TRACE,("MB Init\n"));
mbinit(); mbinit();
OS_DbgPrint(OSK_MID_TRACE,("Rawip Init\n")); OS_DbgPrint(OSK_MID_TRACE,("Rawip Init\n"));
@ -66,12 +69,19 @@ void DeinitOskitTCP() {
} }
void TimerOskitTCP( int FastTimer, int SlowTimer ) { void TimerOskitTCP( int FastTimer, int SlowTimer ) {
KIRQL OldIrql;
/* This function is a special case in which we cannot use OSKLock/OSKUnlock
* because we don't enter with the connection lock held */
OSKLockAndRaise(&OldIrql);
if ( SlowTimer ) { if ( SlowTimer ) {
tcp_slowtimo(); tcp_slowtimo();
} }
if ( FastTimer ) { if ( FastTimer ) {
tcp_fasttimo(); tcp_fasttimo();
} }
OSKUnlockAndLower(OldIrql);
} }
void RegisterOskitTCPEventHandlers( POSKITTCP_EVENT_HANDLERS EventHandlers ) { void RegisterOskitTCPEventHandlers( POSKITTCP_EVENT_HANDLERS EventHandlers ) {
@ -115,12 +125,16 @@ int OskitTCPSocket( void *context,
int proto ) int proto )
{ {
struct socket *so; struct socket *so;
OSKLock();
int error = socreate(domain, &so, type, proto); int error = socreate(domain, &so, type, proto);
if( !error ) { if( !error ) {
so->so_connection = context; so->so_connection = context;
so->so_state |= SS_NBIO; so->so_state |= SS_NBIO;
*aso = so; *aso = so;
} }
OSKUnlock();
return error; return error;
} }
@ -153,8 +167,11 @@ int OskitTCPRecv( void *connection,
OS_DbgPrint(OSK_MID_TRACE,("Reading %d bytes from TCP:\n", Len)); OS_DbgPrint(OSK_MID_TRACE,("Reading %d bytes from TCP:\n", Len));
OSKLock();
error = soreceive( connection, NULL, &uio, NULL, NULL /* SCM_RIGHTS */, error = soreceive( connection, NULL, &uio, NULL, NULL /* SCM_RIGHTS */,
&tcp_flags ); &tcp_flags );
OSKUnlock();
*OutLen = Len - uio.uio_resid; *OutLen = Len - uio.uio_resid;
return error; return error;
@ -182,14 +199,15 @@ int OskitTCPBind( void *socket,
addr.sa_family = addr.sa_len; addr.sa_family = addr.sa_len;
addr.sa_len = sizeof(struct sockaddr); addr.sa_len = sizeof(struct sockaddr);
OSKLock();
error = sobind(so, &sabuf); error = sobind(so, &sabuf);
OSKUnlock();
OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error)); OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error));
return (error); return (error);
} }
int OskitTCPConnect( void *socket, void *connection, int OskitTCPConnect( void *socket, void *nam, OSK_UINT namelen ) {
void *nam, OSK_UINT namelen ) {
struct socket *so = socket; struct socket *so = socket;
int error = EFAULT; int error = EFAULT;
struct mbuf sabuf; struct mbuf sabuf;
@ -197,8 +215,7 @@ int OskitTCPConnect( void *socket, void *connection,
OS_DbgPrint(OSK_MID_TRACE,("Called, socket = %08x\n", socket)); OS_DbgPrint(OSK_MID_TRACE,("Called, socket = %08x\n", socket));
so->so_connection = connection; OSKLock();
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
error = EALREADY; error = EALREADY;
goto done; goto done;
@ -217,7 +234,9 @@ int OskitTCPConnect( void *socket, void *connection,
error = soconnect(so, &sabuf); error = soconnect(so, &sabuf);
if (error) if (error == EINPROGRESS)
goto done;
else if (error)
goto bad; goto bad;
if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) { if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
@ -232,34 +251,54 @@ bad:
error = EINTR; error = EINTR;
done: done:
OSKUnlock();
OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error)); OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error));
return (error); return (error);
} }
int OskitTCPDisconnect(void *socket) int OskitTCPDisconnect(void *socket)
{ {
int error;
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
return sodisconnect(socket); OSKLock();
error = sodisconnect(socket);
OSKUnlock();
return error;
} }
int OskitTCPShutdown( void *socket, int disconn_type ) { int OskitTCPShutdown( void *socket, int disconn_type ) {
int error;
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
return soshutdown( socket, disconn_type ); OSKLock();
error = soshutdown( socket, disconn_type );
OSKUnlock();
return error;
} }
int OskitTCPClose( void *socket ) { int OskitTCPClose( void *socket ) {
int error;
struct socket *so = socket; struct socket *so = socket;
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
so->so_connection = 0; OSKLock();
soclose( so ); /* We have to remove the socket context here otherwise we end up
return 0; * back in HandleSignalledConnection with a freed connection context
*/
so->so_connection = NULL;
error = soclose( socket );
OSKUnlock();
return error;
} }
int OskitTCPSend( void *socket, OSK_PCHAR Data, OSK_UINT Len, int OskitTCPSend( void *socket, OSK_PCHAR Data, OSK_UINT Len,
@ -281,7 +320,10 @@ int OskitTCPSend( void *socket, OSK_PCHAR Data, OSK_UINT Len,
uio.uio_rw = UIO_WRITE; uio.uio_rw = UIO_WRITE;
uio.uio_procp = NULL; uio.uio_procp = NULL;
OSKLock();
error = sosend( socket, NULL, &uio, NULL, NULL, 0 ); error = sosend( socket, NULL, &uio, NULL, NULL, 0 );
OSKUnlock();
*OutLen = Len - uio.uio_resid; *OutLen = Len - uio.uio_resid;
return error; return error;
@ -289,6 +331,7 @@ int OskitTCPSend( void *socket, OSK_PCHAR Data, OSK_UINT Len,
int OskitTCPAccept( void *socket, int OskitTCPAccept( void *socket,
void **new_socket, void **new_socket,
void *context,
void *AddrOut, void *AddrOut,
OSK_UINT AddrLen, OSK_UINT AddrLen,
OSK_UINT *OutAddrLen, OSK_UINT *OutAddrLen,
@ -317,11 +360,12 @@ int OskitTCPAccept( void *socket,
/* that's a copyin actually */ /* that's a copyin actually */
namelen = *OutAddrLen; namelen = *OutAddrLen;
OSKLock();
s = splnet(); s = splnet();
#if 0 #if 0
if ((head->so_options & SO_ACCEPTCONN) == 0) { if ((head->so_options & SO_ACCEPTCONN) == 0) {
splx(s);
OS_DbgPrint(OSK_MID_TRACE,("OSKITTCP: head->so_options = %x, wanted bit %x\n", OS_DbgPrint(OSK_MID_TRACE,("OSKITTCP: head->so_options = %x, wanted bit %x\n",
head->so_options, SO_ACCEPTCONN)); head->so_options, SO_ACCEPTCONN));
error = EINVAL; error = EINVAL;
@ -333,39 +377,10 @@ int OskitTCPAccept( void *socket,
head->so_q, head->so_state)); head->so_q, head->so_state));
if ((head->so_state & SS_NBIO) && head->so_q == NULL) { if ((head->so_state & SS_NBIO) && head->so_q == NULL) {
splx(s);
error = EWOULDBLOCK; error = EWOULDBLOCK;
goto out; goto out;
} }
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
while (head->so_q == NULL && head->so_error == 0) {
if (head->so_state & SS_CANTRCVMORE) {
head->so_error = ECONNABORTED;
break;
}
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
error = tsleep((caddr_t)&head->so_timeo, PSOCK | PCATCH,
"accept", 0);
if (error) {
splx(s);
goto out;
}
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
}
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
#if 0
if (head->so_error) {
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
error = head->so_error;
head->so_error = 0;
splx(s);
goto out;
}
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
#endif
/* /*
* At this point we know that there is at least one connection * At this point we know that there is at least one connection
* ready to be accepted. Remove it from the queue. * ready to be accepted. Remove it from the queue.
@ -384,19 +399,20 @@ int OskitTCPAccept( void *socket,
head->so_q = so->so_q; head->so_q = so->so_q;
head->so_qlen--; head->so_qlen--;
*newso = so;
/*so->so_state &= ~SS_COMP;*/
mnam.m_data = (char *)&sa; mnam.m_data = (char *)&sa;
mnam.m_len = sizeof(sa); mnam.m_len = sizeof(sa);
(void) soaccept(so, &mnam); error = soaccept(so, &mnam);
if (error)
goto out;
so->so_state = SS_NBIO | SS_ISCONNECTED; so->so_state |= SS_NBIO | SS_ISCONNECTED;
so->so_q = so->so_q0 = NULL; so->so_q = so->so_q0 = NULL;
so->so_qlen = 0; so->so_qlen = 0;
so->so_head = 0; so->so_head = 0;
so->so_connection = context;
*newso = so;
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error)); OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
if (name) { if (name) {
@ -406,9 +422,10 @@ int OskitTCPAccept( void *socket,
*OutAddrLen = namelen; /* copyout actually */ *OutAddrLen = namelen; /* copyout actually */
} }
OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error)); OS_DbgPrint(OSK_MID_TRACE,("error = %d\n", error));
splx(s);
} }
out: out:
splx(s);
OSKUnlock();
OS_DbgPrint(OSK_MID_TRACE,("OSKITTCP: Returning %d\n", error)); OS_DbgPrint(OSK_MID_TRACE,("OSKITTCP: Returning %d\n", error));
return (error); return (error);
} }
@ -421,10 +438,16 @@ out:
void OskitTCPReceiveDatagram( OSK_PCHAR Data, OSK_UINT Len, void OskitTCPReceiveDatagram( OSK_PCHAR Data, OSK_UINT Len,
OSK_UINT IpHeaderLen ) { OSK_UINT IpHeaderLen ) {
struct mbuf *Ip = m_devget( (char *)Data, Len, 0, NULL, NULL ); struct mbuf *Ip;
struct ip *iph; struct ip *iph;
if( !Ip ) return; /* drop the segment */ OSKLock();
Ip = m_devget( (char *)Data, Len, 0, NULL, NULL );
if( !Ip )
{
OSKUnlock();
return; /* drop the segment */
}
//memcpy( Ip->m_data, Data, Len ); //memcpy( Ip->m_data, Data, Len );
Ip->m_pkthdr.len = IpHeaderLen; Ip->m_pkthdr.len = IpHeaderLen;
@ -439,6 +462,7 @@ void OskitTCPReceiveDatagram( OSK_PCHAR Data, OSK_UINT Len,
IpHeaderLen)); IpHeaderLen));
tcp_input(Ip, IpHeaderLen); tcp_input(Ip, IpHeaderLen);
OSKUnlock();
/* The buffer Ip is freed by tcp_input */ /* The buffer Ip is freed by tcp_input */
} }
@ -450,6 +474,7 @@ int OskitTCPSetSockOpt(void *socket,
int size) int size)
{ {
struct mbuf *m; struct mbuf *m;
int error;
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
@ -457,16 +482,23 @@ int OskitTCPSetSockOpt(void *socket,
if (size >= MLEN) if (size >= MLEN)
return OSK_EINVAL; return OSK_EINVAL;
OSKLock();
m = m_get(M_WAIT, MT_SOOPTS); m = m_get(M_WAIT, MT_SOOPTS);
if (!m) if (!m)
{
OSKUnlock();
return OSK_ENOMEM; return OSK_ENOMEM;
}
m->m_len = size; m->m_len = size;
memcpy(m->m_data, buffer, size); memcpy(m->m_data, buffer, size);
/* m is freed by sosetopt */ /* m is freed by sosetopt */
return sosetopt(socket, level, optname, m); error = sosetopt(socket, level, optname, m);
OSKUnlock();
return error;
} }
int OskitTCPGetSockOpt(void *socket, int OskitTCPGetSockOpt(void *socket,
@ -481,6 +513,7 @@ int OskitTCPGetSockOpt(void *socket,
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
OSKLock();
error = sogetopt(socket, level, optname, &m); error = sogetopt(socket, level, optname, &m);
if (!error) if (!error)
{ {
@ -489,6 +522,7 @@ int OskitTCPGetSockOpt(void *socket,
if (!buffer || oldsize < m->m_len) if (!buffer || oldsize < m->m_len)
{ {
m_freem(m); m_freem(m);
OSKUnlock();
return OSK_EINVAL; return OSK_EINVAL;
} }
@ -496,6 +530,7 @@ int OskitTCPGetSockOpt(void *socket,
m_freem(m); m_freem(m);
} }
OSKUnlock();
return error; return error;
} }
@ -507,7 +542,11 @@ int OskitTCPListen( void *socket, int backlog ) {
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
OS_DbgPrint(OSK_MID_TRACE,("Called, socket = %08x\n", socket)); OS_DbgPrint(OSK_MID_TRACE,("Called, socket = %08x\n", socket));
OSKLock();
error = solisten( socket, backlog ); error = solisten( socket, backlog );
OSKUnlock();
OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error)); OS_DbgPrint(OSK_MID_TRACE,("Ending: %08x\n", error));
return error; return error;
@ -524,11 +563,13 @@ int OskitTCPSetAddress( void *socket,
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
OSKLock();
inp = (struct inpcb *)so->so_pcb; inp = (struct inpcb *)so->so_pcb;
inp->inp_laddr.s_addr = LocalAddress; inp->inp_laddr.s_addr = LocalAddress;
inp->inp_lport = LocalPort; inp->inp_lport = LocalPort;
inp->inp_faddr.s_addr = RemoteAddress; inp->inp_faddr.s_addr = RemoteAddress;
inp->inp_fport = RemotePort; inp->inp_fport = RemotePort;
OSKUnlock();
return 0; return 0;
} }
@ -544,15 +585,31 @@ int OskitTCPGetAddress( void *socket,
if (!socket) if (!socket)
return OSK_ESHUTDOWN; return OSK_ESHUTDOWN;
OSKLock();
inp = (struct inpcb *)so->so_pcb; inp = (struct inpcb *)so->so_pcb;
*LocalAddress = inp->inp_laddr.s_addr; *LocalAddress = inp->inp_laddr.s_addr;
*LocalPort = inp->inp_lport; *LocalPort = inp->inp_lport;
*RemoteAddress = inp->inp_faddr.s_addr; *RemoteAddress = inp->inp_faddr.s_addr;
*RemotePort = inp->inp_fport; *RemotePort = inp->inp_fport;
OSKUnlock();
return 0; return 0;
} }
int OskitTCPGetSocketError(void *socket) {
struct socket *so = socket;
int error;
if (!socket)
return OSK_ESHUTDOWN;
OSKLock();
error = so->so_error;
OSKUnlock();
return error;
}
struct ifaddr *ifa_iffind(struct sockaddr *addr, int type) struct ifaddr *ifa_iffind(struct sockaddr *addr, int type)
{ {
if( OtcpEvent.FindInterface ) if( OtcpEvent.FindInterface )
@ -566,7 +623,7 @@ struct ifaddr *ifa_iffind(struct sockaddr *addr, int type)
void oskittcp_die( const char *file, int line ) { void oskittcp_die( const char *file, int line ) {
DbgPrint("\n\n*** OSKITTCP: Panic Called at %s:%d ***\n", file, line); DbgPrint("\n\n*** OSKITTCP: Panic Called at %s:%d ***\n", file, line);
*((int *)0) = 0; ASSERT(FALSE);
} }
/* Stuff supporting the BSD network-interface interface */ /* Stuff supporting the BSD network-interface interface */