2298 lines
55 KiB
C
2298 lines
55 KiB
C
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
|
|
Module Name:
|
|
|
|
routing\ip\ipinip\tdix.c
|
|
|
|
Abstract:
|
|
|
|
Interface to TDI
|
|
|
|
Revision History:
|
|
|
|
Derived from Steve Cobb's ndis\l2tp code
|
|
|
|
|
|
About ALLOCATEIRPS:
|
|
|
|
This driver is lower level code than typical TDI drivers. It has locked
|
|
MDL-mapped input buffers readily available and does not need to provide any
|
|
mapping to user mode client requests on completion. This allows a
|
|
performance gain from allocating and deallocating IRPs directly, thus
|
|
avoiding unnecessary setup in TdiBuildInternalDeviceControlIrp and
|
|
unnecessary APC queuing in IoCompleteRequest. Define ALLOCATEIRPs=1 to
|
|
make this optimization, or define it 0 to use the strictly TDI-compliant
|
|
TdiBuildInternalDeviceControlIrp method.
|
|
|
|
|
|
About NDISBUFFERISMDL:
|
|
|
|
Calls to TdiBuildSendDatagram assume the NDIS_BUFFER can be passed in place
|
|
of an MDL which avoids a pointless copy. If this is not the case, an
|
|
explicit MDL buffer would need to be allocated and caller's buffer copied
|
|
to the MDL buffer before sending. Same issue for TdiBuildReceiveDatagram,
|
|
except of course that the copy would be from the MDL buffer to caller's
|
|
buffer after receiving.
|
|
|
|
--*/
|
|
|
|
|
|
#define __FILE_SIG__ TDIX_SIG
|
|
|
|
#include "inc.h"
|
|
|
|
#if NDISBUFFERISMDL
|
|
#else
|
|
#error Additional code to copy NDIS_BUFFER to/from MDL NYI.
|
|
#endif
|
|
|
|
|
|
//
|
|
// The Handle for the IP in IP (proto 4) transport address
|
|
//
|
|
|
|
HANDLE g_hIpIpHandle;
|
|
|
|
//
|
|
// The pointer to the file object for the above handle
|
|
//
|
|
|
|
PFILE_OBJECT g_pIpIpFileObj;
|
|
|
|
|
|
//
|
|
// The Handle for the ICMP (proto 1) transport address
|
|
//
|
|
|
|
HANDLE g_hIcmpHandle;
|
|
|
|
//
|
|
// The pointer to the file object for the above handle
|
|
//
|
|
|
|
PFILE_OBJECT g_pIcmpFileObj;
|
|
|
|
|
|
//
|
|
// Handle for address changes
|
|
//
|
|
|
|
HANDLE g_hAddressChange;
|
|
|
|
|
|
NPAGED_LOOKASIDE_LIST g_llSendCtxtBlocks;
|
|
NPAGED_LOOKASIDE_LIST g_llTransferCtxtBlocks;
|
|
NPAGED_LOOKASIDE_LIST g_llQueueNodeBlocks;
|
|
|
|
#pragma alloc_text(PAGE, TdixInitialize)
|
|
|
|
VOID
|
|
TdixInitialize(
|
|
PVOID pvContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Initialize the TDI related globals.
|
|
Open the TDI transport address for Raw IP, protocol number 4.
|
|
Sets the address object for HEADER_INCLUDE
|
|
Also opens Raw IP for ICMP (used to manager TUNNEL MTU)
|
|
Register to receive datagrams at the selected handler
|
|
|
|
Locks
|
|
|
|
This call must be made at PASSIVE IRQL.
|
|
|
|
Arguments
|
|
|
|
None
|
|
|
|
Return Value
|
|
|
|
STATUS_SUCCESS if successful
|
|
STATUS_UNSUCCESSFUL otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
PIRP pIrp;
|
|
|
|
IO_STATUS_BLOCK iosb;
|
|
NTSTATUS nStatus;
|
|
TDIObjectID *pTdiObjId;
|
|
KEVENT keWait;
|
|
POPEN_CONTEXT pOpenCtxt;
|
|
|
|
PIO_STACK_LOCATION pIrpSp;
|
|
TCP_REQUEST_SET_INFORMATION_EX tcpSetInfo;
|
|
TDI_CLIENT_INTERFACE_INFO tdiInterface;
|
|
|
|
TraceEnter(TDI, "TdixInitialize");
|
|
|
|
PAGED_CODE();
|
|
|
|
pOpenCtxt = (POPEN_CONTEXT)pvContext;
|
|
|
|
//
|
|
// Init the Handle and pointer to file object for RAW IP
|
|
//
|
|
|
|
g_hIpIpHandle = NULL;
|
|
g_pIpIpFileObj = NULL;
|
|
|
|
g_hIcmpHandle = NULL;
|
|
g_pIcmpFileObj = NULL;
|
|
|
|
|
|
//
|
|
// Initialize lookaside lists for our send and receive contexts
|
|
//
|
|
|
|
ExInitializeNPagedLookasideList(&g_llSendCtxtBlocks,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
sizeof(SEND_CONTEXT),
|
|
SEND_CONTEXT_TAG,
|
|
SEND_CONTEXT_LOOKASIDE_DEPTH);
|
|
|
|
ExInitializeNPagedLookasideList(&g_llTransferCtxtBlocks,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
sizeof(TRANSFER_CONTEXT),
|
|
TRANSFER_CONTEXT_TAG,
|
|
TRANSFER_CONTEXT_LOOKASIDE_DEPTH);
|
|
|
|
ExInitializeNPagedLookasideList(&g_llQueueNodeBlocks,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
sizeof(QUEUE_NODE),
|
|
QUEUE_NODE_TAG,
|
|
QUEUE_NODE_LOOKASIDE_DEPTH);
|
|
|
|
InitializeListHead(&g_leAddressList);
|
|
|
|
//
|
|
// Open file and handle objects for both IP in IP and ICMP
|
|
//
|
|
|
|
nStatus = TdixOpenRawIp(PROTO_IPINIP,
|
|
&g_hIpIpHandle,
|
|
&g_pIpIpFileObj);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInitialize: Couldnt open raw IP for IP in IP\n"));
|
|
|
|
TdixDeinitialize(g_pIpIpDevice,
|
|
NULL);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
pOpenCtxt->nStatus = nStatus;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
nStatus = TdixOpenRawIp(PROTO_ICMP,
|
|
&g_hIcmpHandle,
|
|
&g_pIcmpFileObj);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInitialize: Couldnt open raw IP for ICMP\n"));
|
|
|
|
TdixDeinitialize(g_pIpIpDevice,
|
|
NULL);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
pOpenCtxt->nStatus = nStatus;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Set HeaderInclude option on this AddressObject
|
|
//
|
|
|
|
tcpSetInfo.BufferSize = 1;
|
|
tcpSetInfo.Buffer[0] = TRUE;
|
|
|
|
pTdiObjId = &tcpSetInfo.ID;
|
|
|
|
pTdiObjId->toi_entity.tei_entity = CL_TL_ENTITY;
|
|
pTdiObjId->toi_entity.tei_instance = 0;
|
|
|
|
pTdiObjId->toi_class = INFO_CLASS_PROTOCOL;
|
|
pTdiObjId->toi_type = INFO_TYPE_ADDRESS_OBJECT;
|
|
pTdiObjId->toi_id = AO_OPTION_IP_HDRINCL;
|
|
|
|
//
|
|
// Init the event needed to wait on the IRP
|
|
//
|
|
|
|
KeInitializeEvent(&keWait,
|
|
SynchronizationEvent,
|
|
FALSE);
|
|
|
|
pIrp = IoBuildDeviceIoControlRequest(IOCTL_TCP_SET_INFORMATION_EX,
|
|
g_pIpIpFileObj->DeviceObject,
|
|
(PVOID)&tcpSetInfo,
|
|
sizeof(TCP_REQUEST_SET_INFORMATION_EX),
|
|
NULL,
|
|
0,
|
|
FALSE,
|
|
&keWait,
|
|
&iosb);
|
|
|
|
if (pIrp is NULL)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInitialize: Couldnt build Irp for IP\n"));
|
|
|
|
nStatus = STATUS_UNSUCCESSFUL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Io subsystem doesnt do anything for us in kernel mode
|
|
// so we need to set up the IRP ourselves
|
|
//
|
|
|
|
pIrpSp = IoGetNextIrpStackLocation(pIrp);
|
|
|
|
pIrpSp->FileObject = g_pIpIpFileObj;
|
|
|
|
//
|
|
// Submit the request to the forwarder
|
|
//
|
|
|
|
nStatus = IoCallDriver(g_pIpIpFileObj->DeviceObject,
|
|
pIrp);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
if(nStatus is STATUS_PENDING)
|
|
{
|
|
Trace(TDI, INFO,
|
|
("TdixInitialize: IP returned pending when setting HDRINCL option\n"));
|
|
|
|
KeWaitForSingleObject(&keWait,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
0);
|
|
|
|
nStatus = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInitialize: IOCTL to IP Forwarder for HDRINCL failed %x\n",
|
|
nStatus));
|
|
|
|
TdixDeinitialize(g_pIpIpDevice,
|
|
NULL);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
pOpenCtxt->nStatus = nStatus;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Install our receive datagram handler. Caller's 'pReceiveHandler' will
|
|
// be called by our handler when a datagram arrives and TDI business is
|
|
// out of the way.
|
|
//
|
|
|
|
nStatus = TdixInstallEventHandler(g_pIpIpFileObj,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
TdixReceiveIpIpDatagram,
|
|
NULL);
|
|
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixOpen: Status %x installing IpIpReceiveDatagram Event\n",
|
|
nStatus));
|
|
|
|
TdixDeinitialize(g_pIpIpDevice,
|
|
NULL);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
pOpenCtxt->nStatus = nStatus;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
nStatus = TdixInstallEventHandler(g_pIcmpFileObj,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
TdixReceiveIcmpDatagram,
|
|
NULL);
|
|
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixOpen: Status %x installing IcmpReceiveDatagram Event\n",
|
|
nStatus));
|
|
|
|
TdixDeinitialize(g_pIpIpDevice,
|
|
NULL);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
pOpenCtxt->nStatus = nStatus;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
RtlZeroMemory(&tdiInterface,
|
|
sizeof(TDI_CLIENT_INTERFACE_INFO));
|
|
|
|
tdiInterface.MajorTdiVersion = TDI_CURRENT_MAJOR_VERSION;
|
|
tdiInterface.MinorTdiVersion = TDI_CURRENT_MINOR_VERSION;
|
|
|
|
tdiInterface.AddAddressHandlerV2 = TdixAddressArrival;
|
|
tdiInterface.DelAddressHandlerV2 = TdixAddressDeletion;
|
|
|
|
TdiRegisterPnPHandlers(&tdiInterface,
|
|
sizeof(TDI_CLIENT_INTERFACE_INFO),
|
|
&g_hAddressChange);
|
|
|
|
pOpenCtxt->nStatus = STATUS_SUCCESS;
|
|
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
|
|
TraceLeave(TDI, "TdixInitialize");
|
|
|
|
return;
|
|
}
|
|
|
|
#pragma alloc_text(PAGE, TdixOpenRawIp)
|
|
|
|
NTSTATUS
|
|
TdixOpenRawIp(
|
|
IN DWORD dwProtoId,
|
|
OUT HANDLE *phAddrHandle,
|
|
OUT FILE_OBJECT **ppAddrFileObj
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
This routine opens a Raw IP transport address for a given protocol
|
|
|
|
Locks
|
|
|
|
None
|
|
|
|
Arguments
|
|
|
|
dwProtoId Protocol to be opened
|
|
phAddrHandle Pointer to transport Address Handle opened
|
|
ppAddrFileObject Pointer to pointer to file object for transport address
|
|
handle
|
|
|
|
|
|
Return Value
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG ulEaLength;
|
|
BYTE rgbyEa[100];
|
|
WCHAR rgwcRawIpDevice[sizeof(DD_RAW_IP_DEVICE_NAME) + 10];
|
|
WCHAR rgwcProtocolNumber[10];
|
|
|
|
NTSTATUS nStatus;
|
|
OBJECT_ATTRIBUTES oa;
|
|
IO_STATUS_BLOCK iosb;
|
|
PTA_IP_ADDRESS pTaIp;
|
|
PTDI_ADDRESS_IP pTdiIp;
|
|
UNICODE_STRING usDevice;
|
|
UNICODE_STRING usProtocolNumber;
|
|
HANDLE hTransportAddrHandle;
|
|
PFILE_OBJECT pTransportAddrFileObj;
|
|
|
|
PFILE_FULL_EA_INFORMATION pEa;
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
TraceEnter(TDI, "TdixOpenRawIp");
|
|
|
|
*phAddrHandle = NULL;
|
|
*ppAddrFileObj = NULL;
|
|
|
|
//
|
|
// FILE_FULL_EA_INFORMATION wants null terminated buffers now
|
|
//
|
|
|
|
RtlZeroMemory(rgbyEa,
|
|
sizeof(rgbyEa));
|
|
|
|
RtlZeroMemory(rgwcRawIpDevice,
|
|
sizeof(rgwcRawIpDevice));
|
|
|
|
RtlZeroMemory(rgwcProtocolNumber,
|
|
sizeof(rgwcProtocolNumber));
|
|
|
|
|
|
//
|
|
// Set up parameters needed to open the transport address. First, the
|
|
// object attributes.
|
|
//
|
|
|
|
//
|
|
// Build the raw IP device name as a counted string. The device name
|
|
// is followed by a path separator then the protocol number of
|
|
// interest.
|
|
//
|
|
|
|
usDevice.Buffer = rgwcRawIpDevice;
|
|
usDevice.Length = 0;
|
|
usDevice.MaximumLength = sizeof(rgwcRawIpDevice);
|
|
|
|
RtlAppendUnicodeToString(&usDevice,
|
|
DD_RAW_IP_DEVICE_NAME);
|
|
|
|
usDevice.Buffer[usDevice.Length/sizeof(WCHAR)] = OBJ_NAME_PATH_SEPARATOR;
|
|
|
|
usDevice.Length += sizeof(WCHAR);
|
|
|
|
usProtocolNumber.Buffer = rgwcProtocolNumber;
|
|
usProtocolNumber.MaximumLength = sizeof(rgwcProtocolNumber);
|
|
|
|
RtlIntegerToUnicodeString((ULONG)dwProtoId,
|
|
10,
|
|
&usProtocolNumber);
|
|
|
|
RtlAppendUnicodeStringToString(&usDevice,
|
|
&usProtocolNumber);
|
|
|
|
RtAssert(usDevice.Length < sizeof(rgwcRawIpDevice));
|
|
|
|
InitializeObjectAttributes(&oa,
|
|
&usDevice,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
//
|
|
// Set up the extended attribute that tells the IP stack the IP
|
|
// address/port on which we want to receive.
|
|
// We "bind" to INADDR_ANY
|
|
//
|
|
|
|
RtAssert((sizeof(FILE_FULL_EA_INFORMATION) +
|
|
TDI_TRANSPORT_ADDRESS_LENGTH +
|
|
sizeof(TA_IP_ADDRESS))
|
|
<= 100);
|
|
|
|
pEa = (PFILE_FULL_EA_INFORMATION)rgbyEa;
|
|
|
|
pEa->NextEntryOffset = 0;
|
|
pEa->Flags = 0;
|
|
pEa->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
|
|
pEa->EaValueLength = sizeof(TA_IP_ADDRESS);
|
|
|
|
NdisMoveMemory(pEa->EaName,
|
|
TdiTransportAddress,
|
|
TDI_TRANSPORT_ADDRESS_LENGTH);
|
|
|
|
//
|
|
// Note: The unused byte represented by the "+ 1" below is to match up
|
|
// with what the IP stack expects, though it doesn't appear in the
|
|
// current docs.
|
|
//
|
|
|
|
pTaIp = (PTA_IP_ADDRESS)(pEa->EaName + TDI_TRANSPORT_ADDRESS_LENGTH + 1);
|
|
|
|
pTaIp->TAAddressCount = 1;
|
|
|
|
pTaIp->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
|
|
pTaIp->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
|
|
|
|
pTdiIp = &(pTaIp->Address[0].Address[0]);
|
|
|
|
pTdiIp->sin_port = 0;
|
|
pTdiIp->in_addr = 0;
|
|
|
|
NdisZeroMemory(pTdiIp->sin_zero,
|
|
sizeof(pTdiIp->sin_zero));
|
|
|
|
ulEaLength = (ULONG) ((UINT_PTR)(pTaIp + 1) - (UINT_PTR)pEa);
|
|
|
|
//
|
|
// Open the transport address.
|
|
// Settin FILE_SHARE_READ|FILE_SHARE_WRITE is equivalent to the
|
|
// SO_REUSEADDR option
|
|
//
|
|
|
|
|
|
nStatus = ZwCreateFile(&hTransportAddrHandle,
|
|
FILE_READ_DATA | FILE_WRITE_DATA,
|
|
&oa,
|
|
&iosb,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FILE_OPEN,
|
|
0,
|
|
pEa,
|
|
ulEaLength);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixOpenRawIp: Unable to open %S. Status %x\n",
|
|
usDevice.Buffer,
|
|
nStatus));
|
|
|
|
TraceLeave(TDI, "TdixOpenRawIp");
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Get the object address from the handle. This also checks our
|
|
// permissions on the object.
|
|
//
|
|
|
|
nStatus = ObReferenceObjectByHandle(hTransportAddrHandle,
|
|
0,
|
|
NULL,
|
|
KernelMode,
|
|
&pTransportAddrFileObj,
|
|
NULL);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixOpenRawIp: Unable to open object for handle %x. Status %x\n",
|
|
hTransportAddrHandle,
|
|
nStatus));
|
|
|
|
TraceLeave(TDI, "TdixOpenRawIp");
|
|
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
*phAddrHandle = hTransportAddrHandle;
|
|
*ppAddrFileObj = pTransportAddrFileObj;
|
|
|
|
TraceLeave(TDI, "TdixOpenRawIp");
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
#pragma alloc_text(PAGE, TdixDeinitialize)
|
|
|
|
VOID
|
|
TdixDeinitialize(
|
|
IN PDEVICE_OBJECT pDeviceObject,
|
|
IN PVOID pvContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Undo TdixInitialize actions
|
|
|
|
Locks
|
|
|
|
This call must be made at PASSIVE IRQL in the context of the system process
|
|
|
|
Arguments
|
|
|
|
pvContext
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
POPEN_CONTEXT pOpenCtxt;
|
|
|
|
PAGED_CODE();
|
|
|
|
TraceEnter(TDI, "TdixDeinitialize");
|
|
|
|
UNREFERENCED_PARAMETER(pDeviceObject);
|
|
|
|
pOpenCtxt = (POPEN_CONTEXT)pvContext;
|
|
|
|
if(g_hAddressChange isnot NULL)
|
|
{
|
|
TdiDeregisterPnPHandlers(g_hAddressChange);
|
|
}
|
|
|
|
ExDeleteNPagedLookasideList(&g_llSendCtxtBlocks);
|
|
|
|
ExDeleteNPagedLookasideList(&g_llTransferCtxtBlocks);
|
|
|
|
ExDeleteNPagedLookasideList(&g_llQueueNodeBlocks);
|
|
|
|
if(g_pIpIpFileObj)
|
|
{
|
|
//
|
|
// Install a NULL handler, effectively uninstalling.
|
|
//
|
|
|
|
TdixInstallEventHandler(g_pIpIpFileObj,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
NULL,
|
|
NULL);
|
|
|
|
ObDereferenceObject(g_pIpIpFileObj);
|
|
|
|
g_pIpIpFileObj = NULL;
|
|
}
|
|
|
|
if(g_hIpIpHandle)
|
|
{
|
|
ZwClose(g_hIpIpHandle);
|
|
|
|
g_hIpIpHandle = NULL;
|
|
}
|
|
|
|
if(g_pIcmpFileObj)
|
|
{
|
|
TdixInstallEventHandler(g_pIcmpFileObj,
|
|
TDI_EVENT_RECEIVE_DATAGRAM,
|
|
NULL,
|
|
NULL);
|
|
|
|
ObDereferenceObject(g_pIcmpFileObj);
|
|
|
|
g_pIcmpFileObj = NULL;
|
|
}
|
|
|
|
if(g_hIcmpHandle)
|
|
{
|
|
ZwClose(g_hIcmpHandle);
|
|
|
|
g_hIcmpHandle = NULL;
|
|
}
|
|
|
|
if(pOpenCtxt)
|
|
{
|
|
KeSetEvent(pOpenCtxt->pkeEvent,
|
|
0,
|
|
FALSE);
|
|
}
|
|
|
|
TraceLeave(TDI, "TdixDeinitialize");
|
|
}
|
|
|
|
|
|
#pragma alloc_text(PAGE, TdixInstallEventHandler)
|
|
|
|
NTSTATUS
|
|
TdixInstallEventHandler(
|
|
IN PFILE_OBJECT pAddrFileObj,
|
|
IN INT iEventType,
|
|
IN PVOID pfnEventHandler,
|
|
IN PVOID pvEventContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Install a TDI event handler routine
|
|
|
|
Locks
|
|
|
|
The call must be made at PASSIVE
|
|
|
|
Arguments
|
|
|
|
iEventType The event for which the handler is to be set
|
|
pfnEventHandler The event handler
|
|
pvEventContext The context passed to the event handler
|
|
|
|
Return Value
|
|
|
|
STATUS_INSUFFICIENT_RESOURCES
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS nStatus;
|
|
PIRP pIrp;
|
|
|
|
PAGED_CODE();
|
|
|
|
TraceEnter(TDI, "TdixInstallEventHandler");
|
|
|
|
//
|
|
// Allocate a "set event" IRP with base initialization.
|
|
//
|
|
|
|
pIrp = TdiBuildInternalDeviceControlIrp(
|
|
TDI_SET_EVENT_HANDLER,
|
|
pAddrFileObj->DeviceObject,
|
|
pAddrFileObj,
|
|
NULL,
|
|
NULL);
|
|
|
|
if(pIrp is NULL)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInstallEventHandler: Could not allocate IRP\n"));
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Complete the "set event" IRP initialization.
|
|
//
|
|
|
|
TdiBuildSetEventHandler(pIrp,
|
|
pAddrFileObj->DeviceObject,
|
|
pAddrFileObj,
|
|
NULL,
|
|
NULL,
|
|
iEventType,
|
|
pfnEventHandler,
|
|
pvEventContext);
|
|
|
|
/*
|
|
Trace(GLOBAL, ERROR,
|
|
("**FileObj 0x%x Irp 0x%x fscontext to callee 0x%x\n",
|
|
pAddrFileObj,
|
|
pIrp,
|
|
IoGetNextIrpStackLocation(pIrp)->FileObject));
|
|
*/
|
|
//
|
|
// Tell the I/O manager to pass our IRP to the transport for processing.
|
|
//
|
|
|
|
nStatus = IoCallDriver(pAddrFileObj->DeviceObject,
|
|
pIrp);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixInstallEventHandler: Error %X sending IRP\n",
|
|
nStatus));
|
|
}
|
|
|
|
TraceLeave(TDI, "TdixInstallEventHandler");
|
|
|
|
return nStatus;
|
|
}
|
|
|
|
VOID
|
|
TdixAddressArrival(
|
|
PTA_ADDRESS pAddr,
|
|
PUNICODE_STRING pusDeviceName,
|
|
PTDI_PNP_CONTEXT pContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Our handler called by TDI whenever a new address is added to the
|
|
system
|
|
We see if this is an IP Address and if we have any tunnels that
|
|
use this address as an endpoint. If any do, then we mark all those
|
|
tunnels as up
|
|
|
|
Locks
|
|
|
|
Acquires the g_rwlTunnelLock as WRITER.
|
|
Also locks each of the tunnels
|
|
|
|
Arguments
|
|
|
|
pAddr
|
|
pusDeviceName
|
|
pContext
|
|
|
|
Return Value
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
KIRQL kiIrql;
|
|
PADDRESS_BLOCK pAddrBlock;
|
|
PTDI_ADDRESS_IP pTdiIpAddr;
|
|
PLIST_ENTRY pleNode;
|
|
|
|
TraceEnter(TDI, "TdixAddressArrival");
|
|
|
|
if(pAddr->AddressType isnot TDI_ADDRESS_TYPE_IP)
|
|
{
|
|
TraceLeave(TDI, "TdixAddressArrival");
|
|
|
|
return;
|
|
}
|
|
|
|
RtAssert(pAddr->AddressLength >= sizeof(TDI_ADDRESS_IP));
|
|
|
|
pTdiIpAddr = (PTDI_ADDRESS_IP)pAddr->Address;
|
|
|
|
Trace(TDI, TRACE,
|
|
("TdixAddressArrival: New address %d.%d.%d.%d\n",
|
|
PRINT_IPADDR(pTdiIpAddr->in_addr)));
|
|
|
|
EnterWriter(&g_rwlTunnelLock,
|
|
&kiIrql);
|
|
|
|
pAddrBlock = GetAddressBlock(pTdiIpAddr->in_addr);
|
|
|
|
if(pAddrBlock isnot NULL)
|
|
{
|
|
RtAssert(pAddrBlock->dwAddress is pTdiIpAddr->in_addr);
|
|
|
|
if(pAddrBlock->bAddressPresent is TRUE)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixAddressArrival: Multiple notification on %d.%d.%d.%d\n",
|
|
PRINT_IPADDR(pTdiIpAddr->in_addr)));
|
|
|
|
ExitWriter(&g_rwlTunnelLock,
|
|
kiIrql);
|
|
|
|
TraceLeave(TDI, "TdixAddressArrival");
|
|
|
|
return;
|
|
}
|
|
|
|
pAddrBlock->bAddressPresent = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pAddrBlock = RtAllocate(NonPagedPool,
|
|
sizeof(ADDRESS_BLOCK),
|
|
TUNNEL_TAG);
|
|
|
|
if(pAddrBlock is NULL)
|
|
{
|
|
Trace(TDI, ERROR,
|
|
("TdixAddressArrival: Unable to allocate address block\n"));
|
|
|
|
ExitWriter(&g_rwlTunnelLock,
|
|
kiIrql);
|
|
|
|
TraceLeave(TDI, "TdixAddressArrival");
|
|
|
|
return;
|
|
}
|
|
|
|
pAddrBlock->dwAddress = pTdiIpAddr->in_addr;
|
|
pAddrBlock->bAddressPresent = TRUE;
|
|
|
|
InitializeListHead(&(pAddrBlock->leTunnelList));
|
|
|
|
InsertHeadList(&g_leAddressList,
|
|
&(pAddrBlock->leAddressLink));
|
|
}
|
|
|
|
//
|
|
// Walk the list of tunnels on this address and
|
|
// set them up
|
|
//
|
|
|
|
for(pleNode = pAddrBlock->leTunnelList.Flink;
|
|
pleNode isnot &(pAddrBlock->leTunnelList);
|
|
pleNode = pleNode->Flink)
|
|
{
|
|
PTUNNEL pTunnel;
|
|
DWORD dwLocalNet;
|
|
RouteCacheEntry *pDummyRce;
|
|
BYTE byType;
|
|
USHORT usMtu;
|
|
IPOptInfo OptInfo;
|
|
|
|
pTunnel = CONTAINING_RECORD(pleNode,
|
|
TUNNEL,
|
|
leAddressLink);
|
|
|
|
RtAcquireSpinLockAtDpcLevel(&(pTunnel->rlLock));
|
|
|
|
RtAssert(pTunnel->LOCALADDR is pTdiIpAddr->in_addr);
|
|
RtAssert(pTunnel->dwOperState is IF_OPER_STATUS_NON_OPERATIONAL);
|
|
|
|
pTunnel->dwAdminState |= TS_ADDRESS_PRESENT;
|
|
|
|
if(GetAdminState(pTunnel) is IF_ADMIN_STATUS_UP)
|
|
{
|
|
pTunnel->dwOperState = IF_OPER_STATUS_OPERATIONAL;
|
|
|
|
//
|
|
// See if the remote address is reachable and what the MTU is.
|
|
//
|
|
|
|
UpdateMtuAndReachability(pTunnel);
|
|
}
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
}
|
|
|
|
ExitWriter(&g_rwlTunnelLock,
|
|
kiIrql);
|
|
|
|
TraceLeave(TDI, "TdixAddressArrival");
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
VOID
|
|
TdixAddressDeletion(
|
|
PTA_ADDRESS pAddr,
|
|
PUNICODE_STRING pusDeviceName,
|
|
PTDI_PNP_CONTEXT pContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Our handler called by TDI whenever an address is removed from to the
|
|
system
|
|
We see if this is an IP Address and if we have any tunnels that
|
|
use this address as an endpoint. If any do, then we mark all those
|
|
tunnels as down
|
|
|
|
Locks
|
|
|
|
Acquires the g_rwlTunnelLock as WRITER.
|
|
Also locks each of the tunnels
|
|
|
|
Arguments
|
|
|
|
pAddr
|
|
pusDeviceName
|
|
pContext
|
|
|
|
Return Value
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
KIRQL kiIrql;
|
|
PADDRESS_BLOCK pAddrBlock;
|
|
PTDI_ADDRESS_IP pTdiIpAddr;
|
|
PLIST_ENTRY pleNode;
|
|
|
|
TraceEnter(TDI, "TdixAddressDeletion");
|
|
|
|
if(pAddr->AddressType isnot TDI_ADDRESS_TYPE_IP)
|
|
{
|
|
TraceLeave(TDI, "TdixAddressDeletion");
|
|
|
|
return;
|
|
}
|
|
|
|
RtAssert(pAddr->AddressLength >= sizeof(TDI_ADDRESS_IP));
|
|
|
|
pTdiIpAddr = (PTDI_ADDRESS_IP)pAddr->Address;
|
|
|
|
Trace(TDI, TRACE,
|
|
("TdixAddressDeletion: Address %d.%d.%d.%d\n",
|
|
PRINT_IPADDR(pTdiIpAddr->in_addr)));
|
|
|
|
EnterWriter(&g_rwlTunnelLock,
|
|
&kiIrql);
|
|
|
|
pAddrBlock = GetAddressBlock(pTdiIpAddr->in_addr);
|
|
|
|
if(pAddrBlock is NULL)
|
|
{
|
|
ExitWriter(&g_rwlTunnelLock,
|
|
kiIrql);
|
|
|
|
TraceLeave(TDI, "TdixAddressDeletion");
|
|
|
|
return;
|
|
}
|
|
|
|
RtAssert(pAddrBlock->dwAddress is pTdiIpAddr->in_addr);
|
|
RtAssert(pAddrBlock->bAddressPresent);
|
|
|
|
//
|
|
// Walk the list of tunnels on this address and
|
|
// set them down
|
|
//
|
|
|
|
for(pleNode = pAddrBlock->leTunnelList.Flink;
|
|
pleNode isnot &(pAddrBlock->leTunnelList);
|
|
pleNode = pleNode->Flink)
|
|
{
|
|
PTUNNEL pTunnel;
|
|
|
|
pTunnel = CONTAINING_RECORD(pleNode,
|
|
TUNNEL,
|
|
leAddressLink);
|
|
|
|
RtAcquireSpinLockAtDpcLevel(&(pTunnel->rlLock));
|
|
|
|
RtAssert(pTunnel->LOCALADDR is pTdiIpAddr->in_addr);
|
|
RtAssert(pTunnel->dwAdminState & TS_ADDRESS_PRESENT);
|
|
RtAssert(IsTunnelMapped(pTunnel));
|
|
|
|
pTunnel->dwOperState = IF_OPER_STATUS_NON_OPERATIONAL;
|
|
|
|
//
|
|
// Reset the admin state to UP/DOWN|MAPPED (It has to be mapped)
|
|
//
|
|
|
|
pTunnel->dwAdminState = GetAdminState(pTunnel);
|
|
MarkTunnelMapped(pTunnel);
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
}
|
|
|
|
ExitWriter(&g_rwlTunnelLock,
|
|
kiIrql);
|
|
|
|
TraceLeave(TDI, "TdixAddressDeletion");
|
|
|
|
return;
|
|
}
|
|
|
|
NTSTATUS
|
|
TdixReceiveIpIpDatagram(
|
|
IN PVOID pvTdiEventContext,
|
|
IN LONG lSourceAddressLen,
|
|
IN PVOID pvSourceAddress,
|
|
IN LONG plOptionsLen,
|
|
IN PVOID pvOptions,
|
|
IN ULONG ulReceiveDatagramFlags,
|
|
IN ULONG ulBytesIndicated,
|
|
IN ULONG ulBytesAvailable,
|
|
OUT PULONG pulBytesTaken,
|
|
IN PVOID pvTsdu,
|
|
OUT IRP **ppIoRequestPacket
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
ClientEventReceiveDatagram indication handler. We figure out the
|
|
tunnel with which to associate the lookahead data. We increment some
|
|
stats and then indicate the data to IP (taking care to skip over the
|
|
outer IP header) along with a receive context.
|
|
If all the data is there, IP copies the data out and returns.
|
|
Otherwise IP requests a TransferData.
|
|
In our TransferData function, we set a flag in the receive context (the
|
|
same one is being passed around) to indicate the IP requested a
|
|
TransferData, and return PENDING.
|
|
The control then returns back to this function. We look at the pXferCtxt
|
|
to see if IP requested a transfer, and if so, we call
|
|
TdiBuildReceiveDatagram() to create the IRP to pass back to complete
|
|
the receive.
|
|
|
|
There is some funky stuff that needs to be done with offsets into the
|
|
lookahead as well as destination buffers and care should be taken to
|
|
understand those before change is made to the code.
|
|
|
|
Locks
|
|
|
|
Runs at DISPATCH IRQL.
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PTRANSFER_CONTEXT pXferCtxt;
|
|
PNDIS_BUFFER pnbFirstBuffer;
|
|
PVOID pvData;
|
|
PIRP pIrp;
|
|
PIP_HEADER pOutHeader, pInHeader;
|
|
ULARGE_INTEGER uliTunnelId;
|
|
PTA_IP_ADDRESS ptiaAddress;
|
|
PTUNNEL pTunnel;
|
|
ULONG ulOutHdrLen, ulDataLen;
|
|
BOOLEAN bNonUnicast;
|
|
|
|
TraceEnter(RCV, "TdixReceiveIpIp");
|
|
|
|
//
|
|
// The TSDU is the data and NOT the MDL
|
|
//
|
|
|
|
pvData = (PVOID)pvTsdu;
|
|
|
|
//
|
|
// Figure out the tunnel for this receive
|
|
// Since the transport indicates atleast 128 bytes, we can safely read out
|
|
// the IP Header
|
|
//
|
|
|
|
RtAssert(ulBytesIndicated > sizeof(IP_HEADER));
|
|
|
|
pOutHeader = (PIP_HEADER)pvData;
|
|
|
|
RtAssert(pOutHeader->byProtocol is PROTO_IPINIP);
|
|
RtAssert((pOutHeader->byVerLen >> 4) is IP_VERSION_4);
|
|
|
|
//
|
|
// These defines depend upon a variable being named "uliTunnelId"
|
|
//
|
|
|
|
REMADDR = pOutHeader->dwSrc;
|
|
LOCALADDR = pOutHeader->dwDest;
|
|
|
|
//
|
|
// Make sure that the source address given and the IP Header are in
|
|
// synch
|
|
//
|
|
|
|
ptiaAddress = (PTA_IP_ADDRESS)pvSourceAddress;
|
|
|
|
//
|
|
// Bunch of checks to make sure the packet and the handler
|
|
// are telling us the same thing
|
|
//
|
|
|
|
RtAssert(lSourceAddressLen is sizeof(TA_IP_ADDRESS));
|
|
|
|
RtAssert(ptiaAddress->TAAddressCount is 1);
|
|
|
|
RtAssert(ptiaAddress->Address[0].AddressType is TDI_ADDRESS_TYPE_IP);
|
|
|
|
RtAssert(ptiaAddress->Address[0].AddressLength is TDI_ADDRESS_LENGTH_IP);
|
|
|
|
RtAssert(ptiaAddress->Address[0].Address[0].in_addr is pOutHeader->dwSrc);
|
|
|
|
//
|
|
// Get a pointer to the inside header. By TDI spec we should get
|
|
// enough data to get at the inner header
|
|
//
|
|
|
|
ulDataLen = RtlUshortByteSwap(pOutHeader->wLength);
|
|
ulOutHdrLen = LengthOfIPHeader(pOutHeader);
|
|
|
|
if(ulDataLen < ulOutHdrLen + MIN_IP_HEADER_LENGTH)
|
|
{
|
|
//
|
|
// Malformed packet. Doesnt have a inner header
|
|
//
|
|
|
|
Trace(RCV, ERROR,
|
|
("TdixReceiveIpIp: Packet %d.%d.%d.%d -> %d.%d.%d.%d had size %d\n",
|
|
PRINT_IPADDR(pOutHeader->dwSrc),
|
|
PRINT_IPADDR(pOutHeader->dwDest),
|
|
ulDataLen));
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// This cant be more than 128 (60 + 20)
|
|
//
|
|
|
|
RtAssert(ulBytesIndicated > ulOutHdrLen + MIN_IP_HEADER_LENGTH);
|
|
|
|
pInHeader = (PIP_HEADER)((PBYTE)pOutHeader + ulOutHdrLen);
|
|
|
|
//
|
|
// If the inside header is also IP in IP and is for one of our tunnels,
|
|
// drop the packet. If we dont, someone could build a series of
|
|
// encapsulated headers which would cause this function to be called
|
|
// recursively making us overflow our stack. Ofcourse, a better fix
|
|
// would be to switch processing to another thread at this point
|
|
// for multiply encapsulated packets, but that is too much work; so
|
|
// currently we just dont allow an IP in IP tunnel within an IP in IP
|
|
// tunnel
|
|
//
|
|
|
|
if(pInHeader->byProtocol is PROTO_IPINIP)
|
|
{
|
|
ULARGE_INTEGER uliInsideId;
|
|
PTUNNEL pInTunnel;
|
|
|
|
//
|
|
// See if this is for us
|
|
//
|
|
|
|
uliInsideId.LowPart = pInHeader->dwSrc;
|
|
uliInsideId.HighPart = pInHeader->dwDest;
|
|
|
|
//
|
|
// Find the TUNNEL. We need to acquire the tunnel lock
|
|
//
|
|
|
|
EnterReaderAtDpcLevel(&g_rwlTunnelLock);
|
|
|
|
pInTunnel = FindTunnel(&uliInsideId);
|
|
|
|
ExitReaderFromDpcLevel(&g_rwlTunnelLock);
|
|
|
|
if(pInTunnel isnot NULL)
|
|
{
|
|
RtReleaseSpinLockFromDpcLevel(&(pInTunnel->rlLock));
|
|
|
|
DereferenceTunnel(pInTunnel);
|
|
|
|
Trace(RCV, WARN,
|
|
("TdixReceiveIpIp: Packet on tunnel for %d.%d.%d.%d/%d.%d.%d.%d contained another IPinIP packet for tunnel %d.%d.%d.%d/%d.%d.%d.%d\n",
|
|
PRINT_IPADDR(REMADDR),
|
|
PRINT_IPADDR(LOCALADDR),
|
|
PRINT_IPADDR(uliInsideId.LowPart),
|
|
PRINT_IPADDR(uliInsideId.HighPart)));
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
}
|
|
|
|
#if DBG
|
|
|
|
//
|
|
// The size of the inner data must be total bytes - outer header
|
|
//
|
|
|
|
ulDataLen = RtlUshortByteSwap(pInHeader->wLength);
|
|
|
|
RtAssert((ulDataLen + ulOutHdrLen) is ulBytesAvailable);
|
|
|
|
//
|
|
// The outer header should also give a good length
|
|
//
|
|
|
|
ulDataLen = RtlUshortByteSwap(pOutHeader->wLength);
|
|
|
|
//
|
|
// Data length and bytes available must match
|
|
//
|
|
|
|
RtAssert(ulDataLen is ulBytesAvailable);
|
|
|
|
#endif
|
|
|
|
//
|
|
// Find the TUNNEL. We need to acquire the tunnel lock
|
|
//
|
|
|
|
EnterReaderAtDpcLevel(&g_rwlTunnelLock);
|
|
|
|
pTunnel = FindTunnel(&uliTunnelId);
|
|
|
|
ExitReaderFromDpcLevel(&g_rwlTunnelLock);
|
|
|
|
if(pTunnel is NULL)
|
|
{
|
|
Trace(RCV, WARN,
|
|
("TdixReceiveIpIp: Couldnt find tunnel for %d.%d.%d.%d/%d.%d.%d.%d\n",
|
|
PRINT_IPADDR(REMADDR),
|
|
PRINT_IPADDR(LOCALADDR)));
|
|
|
|
//
|
|
// Could not find a matching tunnel
|
|
//
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// Ok, so we have the tunnel and it is ref counted and locked
|
|
//
|
|
|
|
//
|
|
// The number of octets received
|
|
//
|
|
|
|
pTunnel->ulInOctets += ulBytesAvailable;
|
|
|
|
//
|
|
// Check the actual (inside) destination
|
|
//
|
|
|
|
if(IsUnicastAddr(pInHeader->dwDest))
|
|
{
|
|
//
|
|
// TODO: should we check to see that the address is not 0.0.0.0?
|
|
//
|
|
|
|
pTunnel->ulInUniPkts++;
|
|
|
|
bNonUnicast = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pTunnel->ulInNonUniPkts++;
|
|
|
|
if(IsClassEAddr(pInHeader->dwDest))
|
|
{
|
|
//
|
|
// Bad address - throw it away
|
|
//
|
|
|
|
pTunnel->ulInErrors++;
|
|
|
|
//
|
|
// Releaselock, free buffer chain
|
|
//
|
|
|
|
}
|
|
|
|
bNonUnicast = TRUE;
|
|
}
|
|
|
|
if(pTunnel->dwOperState isnot IF_OPER_STATUS_OPERATIONAL)
|
|
{
|
|
Trace(RCV, WARN,
|
|
("TdixReceiveIpIp: Tunnel %x is not up\n",
|
|
pTunnel));
|
|
|
|
pTunnel->ulInDiscards++;
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// Allocate a receive context
|
|
//
|
|
|
|
pXferCtxt = AllocateTransferContext();
|
|
|
|
if(pXferCtxt is NULL)
|
|
{
|
|
Trace(RCV, ERROR,
|
|
("TdixReceiveIpIp: Couldnt allocate transfer context\n"));
|
|
|
|
//
|
|
// Could not allocate context, free the data, unlock and deref
|
|
// the tunnel
|
|
//
|
|
|
|
pTunnel->ulInDiscards++;
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
|
|
//
|
|
// Fill in the read-datagram context with the information that won't
|
|
// otherwise be available in the completion routine.
|
|
//
|
|
|
|
pXferCtxt->pTunnel = pTunnel;
|
|
|
|
//
|
|
// Ok, all statistics are done.
|
|
// Release the lock on the tunnel and indicate the data (or part
|
|
// thereof) to IP
|
|
//
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
//
|
|
// The data starts at pInHeader
|
|
// We indicate (ulBytesIndicated - outer header length) up to IP
|
|
// The total data is the (ulBytesAvailable - outer header)
|
|
// We associate a TRANSFER_CONTEXT with this indication,
|
|
// The Protocol Offset is just our outer header
|
|
//
|
|
|
|
pXferCtxt->bRequestTransfer = FALSE;
|
|
|
|
#if PROFILE
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&(pXferCtxt->llRcvTime));
|
|
|
|
#endif
|
|
|
|
g_pfnIpRcv(pTunnel->pvIpContext,
|
|
pInHeader,
|
|
ulBytesIndicated - ulOutHdrLen,
|
|
ulBytesAvailable - ulOutHdrLen,
|
|
pXferCtxt,
|
|
ulOutHdrLen,
|
|
bNonUnicast,
|
|
NULL);
|
|
|
|
//
|
|
// IP calls our TransferData synchronously, and since we also handle
|
|
// that call synchronously. If IP requests a data transfer, we set
|
|
// bRequestTransfer to true in the pXferCtxt
|
|
//
|
|
|
|
if(pXferCtxt->bRequestTransfer is FALSE)
|
|
{
|
|
|
|
#if PROFILE
|
|
|
|
LONGLONG llTime;
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llTime);
|
|
|
|
llTime -= pXferCtxt->llRcvTime;
|
|
|
|
llTime *= KeQueryTimeIncrement();
|
|
|
|
Trace(RCV, ERROR,
|
|
("Profile: Rcv took %d.%d units\n",
|
|
((PLARGE_INTEGER)&llTime)->HighPart,
|
|
((PLARGE_INTEGER)&llTime)->LowPart));
|
|
|
|
#endif
|
|
|
|
Trace(RCV, TRACE,
|
|
("TdixReceiveIpIp: IP did not request transfer\n"));
|
|
|
|
//
|
|
// For some reason or another IP did not want this packet
|
|
// We are done with it
|
|
//
|
|
|
|
FreeTransferContext(pXferCtxt);
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Make sure that the things looks the same before and after the call
|
|
//
|
|
|
|
RtAssert(pXferCtxt->pvContext is pTunnel);
|
|
RtAssert(pXferCtxt->uiProtoOffset is ulOutHdrLen);
|
|
|
|
//
|
|
// Should not be asking to transfer more than was indicated
|
|
//
|
|
|
|
RtAssert(pXferCtxt->uiTransferLength <= ulBytesAvailable);
|
|
|
|
//
|
|
// So IP did want it transferred
|
|
//
|
|
|
|
#if ALLOCATEIRPS
|
|
|
|
//
|
|
// Allocate the IRP directly.
|
|
//
|
|
|
|
pIrp = IoAllocateIrp(g_pIpIpFileObj->DeviceObject->StackSize,
|
|
FALSE);
|
|
|
|
#else
|
|
|
|
//
|
|
// Allocate a "receive datagram" IRP with base initialization.
|
|
//
|
|
|
|
pIrp = TdiBuildInternalDeviceControlIrp(TDI_RECEIVE_DATAGRAM,
|
|
g_pIpIpFileObj->DeviceObject,
|
|
g_pIpIpFileObj,
|
|
NULL,
|
|
NULL);
|
|
|
|
#endif
|
|
|
|
if(!pIrp)
|
|
{
|
|
Trace(RCV, ERROR,
|
|
("TdixReceiveIpIp: Unable to build IRP for receive\n"));
|
|
|
|
pTunnel->ulInDiscards++;
|
|
|
|
FreeTransferContext(pXferCtxt);
|
|
|
|
//
|
|
// Call IP's TDComplete to signal the failure of this
|
|
// transfer
|
|
//
|
|
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
|
|
//
|
|
// IP gives us an NDIS_PACKET to which to transfer data
|
|
// TDI wants just an MDL chain
|
|
//
|
|
|
|
#if NDISBUFFERISMDL
|
|
|
|
NdisQueryPacket(pXferCtxt->pnpTransferPacket,
|
|
NULL,
|
|
NULL,
|
|
&pnbFirstBuffer,
|
|
NULL);
|
|
|
|
#else
|
|
#error "Fix This"
|
|
#endif
|
|
|
|
//
|
|
// Complete the "receive datagram" IRP initialization.
|
|
//
|
|
|
|
TdiBuildReceiveDatagram(pIrp,
|
|
g_pIpIpFileObj->DeviceObject,
|
|
g_pIpIpFileObj,
|
|
TdixReceiveIpIpDatagramComplete,
|
|
pXferCtxt,
|
|
pnbFirstBuffer,
|
|
pXferCtxt->uiTransferLength,
|
|
NULL,
|
|
NULL,
|
|
0);
|
|
|
|
|
|
//
|
|
// Adjust the IRP's stack location to make the transport's stack current.
|
|
// Normally IoCallDriver handles this, but this IRP doesn't go thru
|
|
// IoCallDriver. Seems like it would be the transport's job to make this
|
|
// adjustment, but IP for one doesn't seem to do it. There is a similar
|
|
// adjustment in both the redirector and PPTP.
|
|
//
|
|
|
|
IoSetNextIrpStackLocation(pIrp);
|
|
|
|
*ppIoRequestPacket = pIrp;
|
|
*pulBytesTaken = pXferCtxt->uiTransferOffset + ulOutHdrLen;
|
|
|
|
//
|
|
// we DONT dereference the TUNNEL here
|
|
// That is done in the completion routine
|
|
//
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIp");
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
TdixReceiveIpIpDatagramComplete(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Standard I/O completion routine.
|
|
Called to signal the completion of a receive. The context is the
|
|
TRANSFER_CONTEXT setup with TdiBuildReceiveDatagram.
|
|
|
|
Locks
|
|
|
|
Takes the TUNNEL's lock.
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
|
|
STATUS_SUCCESS
|
|
|
|
--*/
|
|
|
|
{
|
|
PTRANSFER_CONTEXT pXferCtxt;
|
|
PTUNNEL pTunnel;
|
|
LONGLONG llTime;
|
|
|
|
TraceEnter(RCV, "TdixReceiveIpIpDatagramComplete");
|
|
|
|
pXferCtxt = (PTRANSFER_CONTEXT) Context;
|
|
|
|
//
|
|
// The tunnel has been referenced but not locked
|
|
//
|
|
|
|
pTunnel = pXferCtxt->pTunnel;
|
|
|
|
RtAssert(pXferCtxt->uiTransferLength is Irp->IoStatus.Information);
|
|
|
|
g_pfnIpTDComplete(pTunnel->pvIpContext,
|
|
pXferCtxt->pnpTransferPacket,
|
|
Irp->IoStatus.Status,
|
|
(ULONG)(Irp->IoStatus.Information));
|
|
|
|
#if PROFILE
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llTime);
|
|
|
|
Trace(RCV, ERROR,
|
|
("Profile: %d.%d %d.%d\n",
|
|
((PLARGE_INTEGER)&llTime)->HighPart,
|
|
((PLARGE_INTEGER)&llTime)->LowPart,
|
|
((PLARGE_INTEGER)&pXferCtxt->llRcvTime)->HighPart,
|
|
((PLARGE_INTEGER)&pXferCtxt->llRcvTime)->LowPart));
|
|
|
|
llTime -= pXferCtxt->llRcvTime;
|
|
|
|
llTime *= KeQueryTimeIncrement();
|
|
|
|
Trace(RCV, ERROR,
|
|
("Profile: Rcv took %d.%d units\n",
|
|
((PLARGE_INTEGER)&llTime)->HighPart,
|
|
((PLARGE_INTEGER)&llTime)->LowPart));
|
|
|
|
#endif
|
|
|
|
FreeTransferContext(pXferCtxt);
|
|
|
|
//
|
|
// Deref the tunnel (finally)
|
|
//
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
#if ALLOCATEIRPS
|
|
|
|
//
|
|
// Releae the IRP resources and tell the I/O manager to forget it existed
|
|
// in the standard way.
|
|
//
|
|
|
|
IoFreeIrp(Irp);
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIpDatagramComplete");
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
#else
|
|
|
|
//
|
|
// Let the I/O manager release the IRP resources.
|
|
//
|
|
|
|
TraceLeave(RCV, "TdixReceiveIpIpDatagramComplete");
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
#pragma alloc_text(PAGE, TdixSendDatagram)
|
|
|
|
#if PROFILE
|
|
|
|
NTSTATUS
|
|
TdixSendDatagram(
|
|
IN PTUNNEL pTunnel,
|
|
IN PNDIS_PACKET pnpPacket,
|
|
IN PNDIS_BUFFER pnbFirstBuffer,
|
|
IN ULONG ulBufferLength,
|
|
IN LONGLONG llSendTime,
|
|
IN LONGLONG llCallTime,
|
|
IN LONGLONG llTransmitTime
|
|
)
|
|
|
|
#else
|
|
|
|
NTSTATUS
|
|
TdixSendDatagram(
|
|
IN PTUNNEL pTunnel,
|
|
IN PNDIS_PACKET pnpPacket,
|
|
IN PNDIS_BUFFER pnbFirstBuffer,
|
|
IN ULONG ulBufferLength
|
|
)
|
|
|
|
#endif
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
Sends a datagram over a tunnel. The remote endpoint is that of the tunnel
|
|
and the send complete handler is TdixSendCompleteHandler
|
|
A SendContext is associated with the send
|
|
|
|
Locks
|
|
|
|
This call needs to be at PASSIVE level
|
|
The TUNNEL needs to be ref counted but not locked
|
|
|
|
Arguments
|
|
|
|
pTunnel TUNNEL over which the datagram is to be sent
|
|
pnpPacket Packet descriptor allocate from PACKET_POOL of the tunnel
|
|
pnbFirstBuffer The first buffer in the chain (the outer IP header)
|
|
ulBufferLength The lenght of the complete packet (including outer header)
|
|
|
|
Return Value
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS nStatus;
|
|
PSEND_CONTEXT pSendCtxt;
|
|
PIRP pIrp;
|
|
|
|
TraceEnter(SEND, "TdixSendDatagram");
|
|
|
|
do
|
|
{
|
|
//
|
|
// Allocate a context for this send-datagram from our lookaside list.
|
|
//
|
|
|
|
pSendCtxt = AllocateSendContext();
|
|
|
|
if(pSendCtxt is NULL)
|
|
{
|
|
Trace(SEND, ERROR,
|
|
("TdixSendDatagram: Unable to allocate send context\n"));
|
|
|
|
nStatus = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
break;
|
|
}
|
|
|
|
|
|
#if ALLOCATEIRPS
|
|
|
|
//
|
|
// Allocate the IRP directly.
|
|
//
|
|
|
|
pIrp = IoAllocateIrp(g_pIpIpFileObj->DeviceObject->StackSize,
|
|
FALSE);
|
|
|
|
// Trace(GLOBAL, ERROR,
|
|
// ("TdixSendDatagram: irp = 0x%x\n",pIrp));
|
|
|
|
#else
|
|
|
|
//
|
|
// Allocate a "send datagram" IRP with base initialization.
|
|
//
|
|
|
|
pIrp = TdiBuildInternalDeviceControlIrp(TDI_SEND_DATAGRAM,
|
|
g_pIpIpFileObj->DeviceObject,
|
|
g_pIpIpFileObj,
|
|
NULL,
|
|
NULL);
|
|
|
|
#endif
|
|
|
|
if(!pIrp)
|
|
{
|
|
Trace(SEND, ERROR,
|
|
("TdixSendDatagram: Unable to build IRP\n"));
|
|
|
|
nStatus = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Fill in the send-datagram context.
|
|
//
|
|
|
|
pSendCtxt->pTunnel = pTunnel;
|
|
pSendCtxt->pnpPacket = pnpPacket;
|
|
pSendCtxt->ulOutOctets = ulBufferLength;
|
|
|
|
#if PROFILE
|
|
|
|
pSendCtxt->llSendTime = llSendTime;
|
|
pSendCtxt->llCallTime = llCallTime;
|
|
pSendCtxt->llTransmitTime = llTransmitTime;
|
|
|
|
#endif
|
|
|
|
//
|
|
// Complete the "send datagram" IRP initialization.
|
|
//
|
|
|
|
TdiBuildSendDatagram(pIrp,
|
|
g_pIpIpFileObj->DeviceObject,
|
|
g_pIpIpFileObj,
|
|
TdixSendDatagramComplete,
|
|
pSendCtxt,
|
|
pnbFirstBuffer,
|
|
ulBufferLength,
|
|
&(pTunnel->tciConnInfo));
|
|
|
|
//
|
|
// Tell the I/O manager to pass our IRP to the transport for
|
|
// processing.
|
|
//
|
|
|
|
#if PROFILE
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&pSendCtxt->llCall2Time);
|
|
|
|
#endif
|
|
|
|
nStatus = IoCallDriver(g_pIpIpFileObj->DeviceObject,
|
|
pIrp);
|
|
|
|
RtAssert(nStatus is STATUS_PENDING);
|
|
|
|
nStatus = STATUS_SUCCESS;
|
|
|
|
}while (FALSE);
|
|
|
|
if(nStatus isnot STATUS_SUCCESS)
|
|
{
|
|
Trace(SEND, ERROR,
|
|
("TdixSendDatagram: Status %X sending\n",
|
|
nStatus));
|
|
|
|
//
|
|
// Pull a half Jameel, i.e. convert a synchronous failure to an
|
|
// asynchronous failure from client's perspective. However, clean up
|
|
// context here.
|
|
//
|
|
|
|
if(pSendCtxt)
|
|
{
|
|
FreeSendContext(pSendCtxt);
|
|
}
|
|
|
|
IpIpSendComplete(nStatus,
|
|
pTunnel,
|
|
pnpPacket,
|
|
ulBufferLength);
|
|
|
|
}
|
|
|
|
TraceLeave(SEND, "TdixSendDatagram");
|
|
|
|
return STATUS_PENDING;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
TdixSendDatagramComplete(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PVOID Context
|
|
)
|
|
{
|
|
PSEND_CONTEXT pSendCtxt;
|
|
PTUNNEL pTunnel;
|
|
PNDIS_PACKET pnpPacket;
|
|
PNDIS_BUFFER pnbFirstBuffer;
|
|
ULONG ulBufferLength;
|
|
KIRQL irql;
|
|
LONGLONG llTime, llSendTime, llQTime, llTxTime, llCallTime;
|
|
ULONG ulInc;
|
|
|
|
TraceEnter(SEND, "TdixSendDatagramComplete");
|
|
|
|
pSendCtxt = (PSEND_CONTEXT) Context;
|
|
|
|
#if PROFILE
|
|
|
|
KeQueryTickCount((PLARGE_INTEGER)&llTime);
|
|
|
|
ulInc = KeQueryTimeIncrement();
|
|
|
|
llSendTime = pSendCtxt->llCallTime - pSendCtxt->llSendTime;
|
|
llSendTime *= ulInc;
|
|
|
|
llQTime = pSendCtxt->llTransmitTime - pSendCtxt->llCallTime;
|
|
llQTime *= ulInc;
|
|
|
|
llTxTime = pSendCtxt->llCall2Time - pSendCtxt->llTransmitTime;
|
|
llTxTime *= ulInc;
|
|
|
|
llCallTime = llTime - pSendCtxt->llCall2Time;
|
|
llCallTime *= ulInc;
|
|
|
|
llTime = llTime - pSendCtxt->llSendTime;
|
|
llTime *= ulInc;
|
|
|
|
DbgPrint("SendProfile: Send %d.%d Q %d.%d Tx %d.%d Call %d.%d \nTotal %d.%d\n",
|
|
((PLARGE_INTEGER)&llSendTime)->HighPart,
|
|
((PLARGE_INTEGER)&llSendTime)->LowPart,
|
|
((PLARGE_INTEGER)&llQTime)->HighPart,
|
|
((PLARGE_INTEGER)&llQTime)->LowPart,
|
|
((PLARGE_INTEGER)&llTxTime)->HighPart,
|
|
((PLARGE_INTEGER)&llTxTime)->LowPart,
|
|
((PLARGE_INTEGER)&llCallTime)->HighPart,
|
|
((PLARGE_INTEGER)&llCallTime)->LowPart,
|
|
((PLARGE_INTEGER)&llTime)->HighPart,
|
|
((PLARGE_INTEGER)&llTime)->LowPart);
|
|
|
|
#endif
|
|
|
|
//
|
|
// Just call our SendComplete function with the right args
|
|
//
|
|
|
|
pTunnel = pSendCtxt->pTunnel;
|
|
pnpPacket = pSendCtxt->pnpPacket;
|
|
ulBufferLength = pSendCtxt->ulOutOctets;
|
|
|
|
//
|
|
// Free the send-complete context.
|
|
//
|
|
|
|
FreeSendContext(pSendCtxt);
|
|
|
|
IpIpSendComplete(Irp->IoStatus.Status,
|
|
pTunnel,
|
|
pnpPacket,
|
|
ulBufferLength);
|
|
|
|
#if ALLOCATEIRPS
|
|
|
|
//
|
|
// Release the IRP resources and tell the I/O manager to forget it existed
|
|
// in the standard way.
|
|
//
|
|
|
|
IoFreeIrp(Irp);
|
|
|
|
TraceLeave(SEND, "TdixSendDatagramComplete");
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
#else
|
|
|
|
//
|
|
// Let the I/O manager release the IRP resources.
|
|
//
|
|
|
|
TraceLeave(SEND, "TdixSendDatagramComplete");
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
TdixReceiveIcmpDatagram(
|
|
IN PVOID pvTdiEventContext,
|
|
IN LONG lSourceAddressLen,
|
|
IN PVOID pvSourceAddress,
|
|
IN LONG plOptionsLeng,
|
|
IN PVOID pvOptions,
|
|
IN ULONG ulReceiveDatagramFlags,
|
|
IN ULONG ulBytesIndicated,
|
|
IN ULONG ulBytesAvailable,
|
|
OUT PULONG pulBytesTaken,
|
|
IN PVOID pvTsdu,
|
|
OUT IRP **ppIoRequestPacket
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description
|
|
|
|
ClientEventReceiveDatagram indication handler for ICMP messages.
|
|
ICMP messages are used to monitor the state of the tunnel
|
|
|
|
We currently only look for Type 3 Code 4 messages (fragmentation
|
|
needed, but don't fragment bit is set). This is done to support
|
|
PATH MTU over tunnels.
|
|
|
|
We look at the IP header inside the ICMP packet. We see if it was an
|
|
IP in IP packet that caused this ICMP message, and if so we try and match
|
|
it to one of our TUNNELS.
|
|
|
|
Locks
|
|
|
|
Runs at DISPATCH IRQL.
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
|
|
{
|
|
PVOID pvData;
|
|
PIRP pIrp;
|
|
PIP_HEADER pOutHeader, pInHeader;
|
|
PICMP_HEADER pIcmpHdr;
|
|
ULARGE_INTEGER uliTunnelId;
|
|
PTA_IP_ADDRESS ptiaAddress;
|
|
PTUNNEL pTunnel;
|
|
ULONG ulOutHdrLen, ulDataLen, ulIcmpLen;
|
|
BOOLEAN bNonUnicast;
|
|
PICMP_HANDLER pfnHandler;
|
|
NTSTATUS nStatus;
|
|
|
|
pfnHandler = NULL;
|
|
|
|
//
|
|
// The TSDU is the data and NOT the MDL
|
|
//
|
|
|
|
pvData = (PVOID)pvTsdu;
|
|
|
|
//
|
|
// Figure out the tunnel for this receive
|
|
// Since the transport indicates atleast 128 bytes, we can safely read out
|
|
// the IP Header
|
|
//
|
|
|
|
RtAssert(ulBytesIndicated > sizeof(IP_HEADER));
|
|
|
|
pOutHeader = (PIP_HEADER)pvData;
|
|
|
|
RtAssert(pOutHeader->byProtocol is PROTO_ICMP);
|
|
|
|
RtAssert(pOutHeader->byVerLen >> 4 is IP_VERSION_4);
|
|
|
|
//
|
|
// Since the ICMP packet is small, we expect all the data to be
|
|
// give to us, instead of having to do a transfer data
|
|
//
|
|
|
|
ulDataLen = RtlUshortByteSwap(pOutHeader->wLength);
|
|
ulOutHdrLen = LengthOfIPHeader(pOutHeader);
|
|
|
|
if(ulDataLen < ulOutHdrLen + sizeof(ICMP_HEADER))
|
|
{
|
|
//
|
|
// Malformed packet. Doesnt have a inner header
|
|
//
|
|
|
|
Trace(RCV, ERROR,
|
|
("TdixReceiveIcmp: Packet %d.%d.%d.%d -> %d.%d.%d.%d had size %d\n",
|
|
PRINT_IPADDR(pOutHeader->dwSrc),
|
|
PRINT_IPADDR(pOutHeader->dwDest),
|
|
ulDataLen));
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// This cant be more than 128 (60 + 4)
|
|
//
|
|
|
|
RtAssert(ulBytesIndicated > ulOutHdrLen + sizeof(ICMP_HEADER));
|
|
|
|
pIcmpHdr = (PICMP_HEADER)((PBYTE)pOutHeader + ulOutHdrLen);
|
|
|
|
ulIcmpLen = ulDataLen - ulOutHdrLen;
|
|
|
|
//
|
|
// See if this is one of the types we are interested in
|
|
//
|
|
|
|
switch(pIcmpHdr->byType)
|
|
{
|
|
case ICMP_TYPE_DEST_UNREACHABLE:
|
|
{
|
|
//
|
|
// Only interested in codes 0 - 4
|
|
//
|
|
|
|
if(pIcmpHdr->byCode > ICMP_CODE_DGRAM_TOO_BIG)
|
|
{
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
if(ulIcmpLen < (DEST_UNREACH_LENGTH + MIN_IP_HEADER_LENGTH))
|
|
{
|
|
//
|
|
// Not enough data to get at the tunnel
|
|
//
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
pInHeader = (PIP_HEADER)((ULONG_PTR)pIcmpHdr + DEST_UNREACH_LENGTH);
|
|
|
|
pfnHandler = HandleDestUnreachable;
|
|
|
|
break;
|
|
}
|
|
|
|
case ICMP_TYPE_TIME_EXCEEDED:
|
|
{
|
|
if(ulIcmpLen < (TIME_EXCEED_LENGTH + MIN_IP_HEADER_LENGTH))
|
|
{
|
|
//
|
|
// Not enough data to get at the tunnel
|
|
//
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
pInHeader = (PIP_HEADER)((PBYTE)pIcmpHdr + TIME_EXCEED_LENGTH);
|
|
|
|
pfnHandler = HandleTimeExceeded;
|
|
|
|
break;
|
|
}
|
|
|
|
case ICMP_TYPE_PARAM_PROBLEM:
|
|
default:
|
|
{
|
|
//
|
|
// Not interested in this
|
|
//
|
|
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
}
|
|
|
|
//
|
|
// See if the packet that caused the ICMP was an IP in IP packet
|
|
//
|
|
|
|
if(pInHeader->byProtocol isnot PROTO_IPINIP)
|
|
{
|
|
//
|
|
// Someother packet caused this
|
|
//
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// See if we can find a tunnel associated with the original packet
|
|
// These defines depend upon a variable being named "uliTunnelId"
|
|
//
|
|
|
|
REMADDR = pInHeader->dwDest;
|
|
LOCALADDR = pInHeader->dwSrc;
|
|
|
|
//
|
|
// Make sure that the source address given and the IP Header are in
|
|
// synch
|
|
//
|
|
|
|
ptiaAddress = (PTA_IP_ADDRESS)pvSourceAddress;
|
|
|
|
//
|
|
// Bunch of checks to make sure the packet and the handler
|
|
// are telling us the same thing
|
|
//
|
|
|
|
RtAssert(lSourceAddressLen is sizeof(TA_IP_ADDRESS));
|
|
|
|
RtAssert(ptiaAddress->TAAddressCount is 1);
|
|
|
|
RtAssert(ptiaAddress->Address[0].AddressType is TDI_ADDRESS_TYPE_IP);
|
|
|
|
RtAssert(ptiaAddress->Address[0].AddressLength is TDI_ADDRESS_LENGTH_IP);
|
|
|
|
RtAssert(ptiaAddress->Address[0].Address[0].in_addr is pOutHeader->dwSrc);
|
|
|
|
//
|
|
// Find the TUNNEL. We need to acquire the tunnel lock
|
|
//
|
|
|
|
EnterReaderAtDpcLevel(&g_rwlTunnelLock);
|
|
|
|
pTunnel = FindTunnel(&uliTunnelId);
|
|
|
|
ExitReaderFromDpcLevel(&g_rwlTunnelLock);
|
|
|
|
if(pTunnel is NULL)
|
|
{
|
|
//
|
|
// Could not find a matching tunnel
|
|
//
|
|
|
|
return STATUS_DATA_NOT_ACCEPTED;
|
|
}
|
|
|
|
//
|
|
// Ok, so we have the tunnel and it is ref counted and locked
|
|
//
|
|
|
|
nStatus = pfnHandler(pTunnel,
|
|
pIcmpHdr,
|
|
pInHeader);
|
|
|
|
RtReleaseSpinLockFromDpcLevel(&(pTunnel->rlLock));
|
|
|
|
DereferenceTunnel(pTunnel);
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|