able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/qos/psched/sys/timestmp.c

1301 lines
36 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996-1999 Microsoft Corporation
Module Name:
TimeStmp.c
Abstract:
TimeStamp module
Author:
Shreem, Sanjayka
Environment:
Kernel Mode
Revision History:
--*/
#include "psched.h"
#pragma hdrstop
// The pipe information
typedef struct _TS_PIPE
{
// ContextInfo - Generic context info
PS_PIPE_CONTEXT ContextInfo;
} TS_PIPE, *PTS_PIPE;
// The flow information
typedef struct _TS_FLOW
{
// ContextInfo - Generic context info
PS_FLOW_CONTEXT ContextInfo;
} TS_FLOW, *PTS_FLOW;
/* Global variables */
LIST_ENTRY TsList;
NDIS_SPIN_LOCK TsSpinLock;
ULONG TsCount;
/* Static */
/* Forward */
NDIS_STATUS
TimeStmpInitializePipe (
IN HANDLE PsPipeContext,
IN PPS_PIPE_PARAMETERS PipeParameters,
IN PPS_PIPE_CONTEXT ComponentPipeContext,
IN PPS_PROCS PsProcs,
IN PPS_UPCALLS Upcalls
);
NDIS_STATUS
TimeStmpModifyPipe (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_PIPE_PARAMETERS PipeParameters
);
VOID
TimeStmpDeletePipe (
IN PPS_PIPE_CONTEXT PipeContext
);
NDIS_STATUS
TimeStmpCreateFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN HANDLE PsFlowContext,
IN PCO_CALL_PARAMETERS CallParameters,
IN PPS_FLOW_CONTEXT ComponentFlowContext
);
NDIS_STATUS
TimeStmpModifyFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PCO_CALL_PARAMETERS CallParameters
);
VOID
TimeStmpDeleteFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext
);
VOID
TimeStmpEmptyFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext
);
VOID
TimeStmpSetInformation (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN NDIS_OID Oid,
IN ULONG Len,
IN void *Data);
VOID
TimeStmpQueryInformation (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN NDIS_OID Oid,
IN ULONG Len,
IN PVOID Data,
IN OUT PULONG BytesWritten,
IN OUT PULONG BytesNeeded,
IN OUT PNDIS_STATUS Status);
NDIS_STATUS
TimeStmpCreateClassMap (
IN PPS_PIPE_CONTEXT PipeContext,
IN HANDLE PsClassMapContext,
IN PTC_CLASS_MAP_FLOW ClassMap,
IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext
);
NDIS_STATUS
TimeStmpDeleteClassMap (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext
);
BOOLEAN
TimeStmpSubmitPacket (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PPACKET_INFO_BLOCK Packet
);
BOOLEAN
TimeStmpReceivePacket (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PNDIS_PACKET Packet,
IN NDIS_MEDIUM Medium
);
BOOLEAN
TimeStmpReceiveIndication(
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize,
IN UINT TransportHeaderOffset
);
/* End Forward */
VOID
InitializeTimeStmp( PPSI_INFO Info )
{
Info->PipeContextLength = ((sizeof(TS_PIPE)+7) & ~7);
Info->FlowContextLength = ((sizeof(TS_FLOW)+7) & ~7);
Info->ClassMapContextLength = sizeof(PS_CLASS_MAP_CONTEXT);
Info->InitializePipe = TimeStmpInitializePipe;
Info->ModifyPipe = TimeStmpModifyPipe;
Info->DeletePipe = TimeStmpDeletePipe;
Info->CreateFlow = TimeStmpCreateFlow;
Info->ModifyFlow = TimeStmpModifyFlow;
Info->DeleteFlow = TimeStmpDeleteFlow;
Info->EmptyFlow = TimeStmpEmptyFlow;
Info->CreateClassMap = TimeStmpCreateClassMap;
Info->DeleteClassMap = TimeStmpDeleteClassMap;
Info->SubmitPacket = TimeStmpSubmitPacket;
Info->ReceivePacket = NULL;
Info->ReceiveIndication = NULL;
Info->SetInformation = TimeStmpSetInformation;
Info->QueryInformation = TimeStmpQueryInformation;
NdisAllocateSpinLock(&TsSpinLock);
InitializeListHead( &TsList );
TsCount = 0;
}
NDIS_STATUS
TimeStmpInitializePipe (
IN HANDLE PsPipeContext,
IN PPS_PIPE_PARAMETERS PipeParameters,
IN PPS_PIPE_CONTEXT ComponentPipeContext,
IN PPS_PROCS PsProcs,
IN PPS_UPCALLS Upcalls
)
{
PPS_PIPE_CONTEXT Pipe = ComponentPipeContext;
return (*Pipe->NextComponent->InitializePipe)(
PsPipeContext,
PipeParameters,
Pipe->NextComponentContext,
PsProcs,
Upcalls);
}
NDIS_STATUS
TimeStmpModifyPipe (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_PIPE_PARAMETERS PipeParameters
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
return (*Pipe->NextComponent->ModifyPipe)(
Pipe->NextComponentContext, PipeParameters);
}
VOID
TimeStmpDeletePipe (
IN PPS_PIPE_CONTEXT PipeContext
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
(*Pipe->NextComponent->DeletePipe)(Pipe->NextComponentContext);
}
NDIS_STATUS
TimeStmpCreateFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN HANDLE PsFlowContext,
IN PCO_CALL_PARAMETERS CallParameters,
IN PPS_FLOW_CONTEXT ComponentFlowContext
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
return (*Pipe->NextComponent->CreateFlow)(
Pipe->NextComponentContext,
PsFlowContext,
CallParameters,
ComponentFlowContext->NextComponentContext);
}
NDIS_STATUS
TimeStmpModifyFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PCO_CALL_PARAMETERS CallParameters
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
return (*Pipe->NextComponent->ModifyFlow)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext,
CallParameters);
}
VOID
TimeStmpDeleteFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
(*Pipe->NextComponent->DeleteFlow)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext);
}
VOID
TimeStmpEmptyFlow (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
(*Pipe->NextComponent->EmptyFlow)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext);
}
VOID
TimeStmpSetInformation (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN NDIS_OID Oid,
IN ULONG Len,
IN void *Data)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
PPS_FLOW_CONTEXT Flow = FlowContext;
(*Pipe->NextComponent->SetInformation)(
Pipe->NextComponentContext,
(Flow)?Flow->NextComponentContext:0,
Oid,
Len,
Data);
}
VOID
TimeStmpQueryInformation (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN NDIS_OID Oid,
IN ULONG Len,
IN PVOID Data,
IN OUT PULONG BytesWritten,
IN OUT PULONG BytesNeeded,
IN OUT PNDIS_STATUS Status)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
PPS_FLOW_CONTEXT Flow = FlowContext;
(*Pipe->NextComponent->QueryInformation)(
Pipe->NextComponentContext,
(Flow)?Flow->NextComponentContext:0,
Oid,
Len,
Data,
BytesWritten,
BytesNeeded,
Status);
}
NDIS_STATUS
TimeStmpCreateClassMap (
IN PPS_PIPE_CONTEXT PipeContext,
IN HANDLE PsClassMapContext,
IN PTC_CLASS_MAP_FLOW ClassMap,
IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext
)
{
return (*PipeContext->NextComponent->CreateClassMap)(
PipeContext->NextComponentContext,
PsClassMapContext,
ClassMap,
ComponentClassMapContext->NextComponentContext);
}
NDIS_STATUS
TimeStmpDeleteClassMap (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext
)
{
return (*PipeContext->NextComponent->DeleteClassMap)(
PipeContext->NextComponentContext,
ComponentClassMapContext->NextComponentContext);
}
/* Routine Description:
Checks to see if there is any application requesting time-stamping for these end-points
Return Value:
MARK_NONE, MARK_IN_PKT, MARK_IN_BUF
*/
int
CheckForMatch( ULONG SrcIp,
ULONG DstIp,
USHORT SrcPort,
USHORT DstPort,
USHORT Proto,
USHORT IpId,
USHORT Size,
USHORT Direction)
{
PLIST_ENTRY ListEntry;
PTS_ENTRY pEntry;
int Status = MARK_NONE;
NdisAcquireSpinLock(&TsSpinLock);
ListEntry = TsList.Flink;
while (ListEntry != &TsList)
{
pEntry = CONTAINING_RECORD(ListEntry, TS_ENTRY, Linkage);
if( ((pEntry->SrcIp == UL_ANY) || (pEntry->SrcIp == SrcIp)) &&
((pEntry->SrcPort== US_ANY) || (pEntry->SrcPort == SrcPort)) &&
((pEntry->DstIp == UL_ANY) || (pEntry->DstIp == DstIp)) &&
((pEntry->DstPort == US_ANY) || (pEntry->DstPort == DstPort)) &&
((pEntry->Direction == US_ANY) || (pEntry->Direction == Direction)) &&
((pEntry->Proto == US_ANY) || (pEntry->Proto == Proto)))
{
if(pEntry->Type == MARK_IN_BUF)
{
LARGE_INTEGER PerfFrequency, CurrentTime;
UINT64 RecdTime, Freq;
MARK_IN_BUF_RECORD Record, *pRecord;
Status = MARK_IN_BUF;
if((int)( (char*)pEntry->pPacketStore - (char*)pEntry->pPacketStoreHead
+ sizeof(MARK_IN_BUF_RECORD) ) < PACKET_STORE_SIZE )
{
pEntry->pPacketStore->IpId = IpId;
pEntry->pPacketStore->Size = Size;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
// Convert the perffrequency into 100ns interval. //
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
pEntry->pPacketStore->TimeValue = 0;
pEntry->pPacketStore->TimeValue |= CurrentTime.HighPart;
pEntry->pPacketStore->TimeValue = pEntry->pPacketStore->TimeValue << 32;
pEntry->pPacketStore->TimeValue |= CurrentTime.LowPart;
// Normalize cycles with the frequency //
pEntry->pPacketStore->TimeValue *= 10000000;
pEntry->pPacketStore->TimeValue /= Freq;
pEntry->pPacketStore = (PMARK_IN_BUF_RECORD)((char*)pEntry->pPacketStore + sizeof(MARK_IN_BUF_RECORD));
}
else
{
pEntry->pPacketStore = pEntry->pPacketStoreHead;
}
NdisReleaseSpinLock(&TsSpinLock);
return Status;
}
else if(pEntry->Type == MARK_IN_PKT)
{
Status = MARK_IN_PKT;
NdisReleaseSpinLock(&TsSpinLock);
return Status;
}
}
else
{
ListEntry = ListEntry->Flink;
}
}
NdisReleaseSpinLock(&TsSpinLock);
return Status;
}
/* Routine Description:
Adds an end-point to the list of monitoring end-points
Return Value:
TRUE, FALSE
*/
BOOL
AddRequest( PFILE_OBJECT FileObject,
ULONG SrcIp,
USHORT SrcPort,
ULONG DstIp,
USHORT DstPort,
USHORT Proto,
USHORT Type,
USHORT Direction)
{
PTS_ENTRY pEntry = NULL;
PsAllocatePool(pEntry, sizeof(TS_ENTRY), TsTag);
if( !pEntry )
return FALSE;
InitializeListHead(&pEntry->Linkage);
pEntry->SrcIp = SrcIp;
pEntry->SrcPort = SrcPort;
pEntry->DstIp = DstIp;
pEntry->DstPort = DstPort;
pEntry->Proto = Proto;
pEntry->Type = Type;
pEntry->Direction = Direction;
pEntry->FileObject = FileObject;
pEntry->pPacketStore = NULL;
pEntry->pPacketStoreHead = NULL;
if(Type == MARK_IN_BUF)
{
PsAllocatePool( pEntry->pPacketStoreHead, PACKET_STORE_SIZE, TsTag );
if( !pEntry->pPacketStoreHead)
{
PsFreePool( pEntry );
return FALSE;
}
pEntry->pPacketStore = pEntry->pPacketStoreHead;
}
NdisAcquireSpinLock(&TsSpinLock);
/* Need to check for duplication ..*/
InsertHeadList(&TsList, &pEntry->Linkage);
InterlockedIncrement( &TsCount );
NdisReleaseSpinLock(&TsSpinLock);
return TRUE;
}
/* Routine Description:
Removes an end-point to the list of monitoring end-points
Return Value:
None
Note:
Here, 0xffffffff means, wild card => Don't have to match on that field */
void
RemoveRequest( PFILE_OBJECT FileObject,
ULONG SrcIp,
USHORT SrcPort,
ULONG DstIp,
USHORT DstPort,
USHORT Proto)
{
PLIST_ENTRY ListEntry;
PTS_ENTRY pEntry;
NdisAcquireSpinLock(&TsSpinLock);
ListEntry = TsList.Flink;
while (ListEntry != &TsList)
{
pEntry = CONTAINING_RECORD(ListEntry, TS_ENTRY, Linkage);
if( ((FileObject == ULongToPtr(UL_ANY)) || (pEntry->FileObject == FileObject)) &&
((SrcIp == UL_ANY) || (pEntry->SrcIp == SrcIp)) &&
((SrcPort == US_ANY) || (pEntry->SrcPort == SrcPort)) &&
((DstIp == UL_ANY) || (pEntry->DstIp == DstIp)) &&
((DstPort == US_ANY) || (pEntry->DstPort == SrcPort)) &&
((Proto== US_ANY) || (pEntry->Proto == Proto)))
{
RemoveEntryList(&pEntry->Linkage);
if( pEntry->pPacketStoreHead)
PsFreePool( pEntry->pPacketStoreHead );
PsFreePool( pEntry );
InterlockedDecrement( &TsCount );
/* Need to go back to the beginning of the list againg.. */
ListEntry = TsList.Flink;
}
else
{
ListEntry = ListEntry->Flink;
}
}
NdisReleaseSpinLock(&TsSpinLock);
}
int
CopyTimeStmps( PFILE_OBJECT FileObject, PVOID buf, ULONG Len)
{
PLIST_ENTRY ListEntry;
PTS_ENTRY pEntry;
ULONG DataLen;
LARGE_INTEGER LargeLen;
if( Len < PACKET_STORE_SIZE )
return 0;
NdisAcquireSpinLock(&TsSpinLock);
ListEntry = TsList.Flink;
while (ListEntry != &TsList)
{
pEntry = CONTAINING_RECORD(ListEntry, TS_ENTRY, Linkage);
if( pEntry->FileObject == FileObject)
{
// Copy the data across and rest the pointers.. //
LargeLen.QuadPart = ((char*)pEntry->pPacketStore) - ((char*)pEntry->pPacketStoreHead);
DataLen = LargeLen.LowPart;
NdisMoveMemory( buf, pEntry->pPacketStoreHead, DataLen);
pEntry->pPacketStore = pEntry->pPacketStoreHead;
NdisReleaseSpinLock(&TsSpinLock);
return DataLen;
}
else
{
ListEntry = ListEntry->Flink;
}
}
NdisReleaseSpinLock(&TsSpinLock);
return 0;
}
VOID
UnloadTimeStmp( )
{
// Clear all the Requests //
RemoveRequest( ULongToPtr(UL_ANY),
UL_ANY,
US_ANY,
UL_ANY,
US_ANY,
US_ANY);
// Free the spin lock //
NdisFreeSpinLock(&TsSpinLock);
}
BOOLEAN
TimeStmpSubmitPacket (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PPACKET_INFO_BLOCK PacketInfo
)
{
PTS_PIPE Pipe = (PTS_PIPE)PipeContext;
PTS_FLOW Flow = (PTS_FLOW)FlowContext;
PNDIS_PACKET Packet = PacketInfo->NdisPacket;
PNDIS_BUFFER ArpBuf , IpBuf , TcpBuf, UdpBuf, DataBuf;
ULONG ArpLen , IpLen , IpHdrLen , TcpLen , UdpLen, DataLen , TotalLen , TcpHeaderOffset;
VOID *ArpH;
IPHeader UNALIGNED *IPH;
TCPHeader UNALIGNED *TCPH;
UDPHeader UNALIGNED *UDPH;
IPAddr Src, Dst;
BOOLEAN bFragment;
USHORT SrcPort , DstPort , IPID, FragOffset ,Size;
PVOID GeneralVA , Data;
ULONG i, Ret;
if( (TsCount == 0) ||
(NDIS_GET_PACKET_PROTOCOL_TYPE(Packet) != NDIS_PROTOCOL_ID_TCP_IP))
{
goto SUBMIT_NEXT;
}
IpBuf = NULL;
// Steps
// Parse the IP Packet.
// Look for the appropriate ports.
// Look for the data portion and put in the Time & length there.
if(1)
{
PVOID pAddr;
PNDIS_BUFFER pNdisBuf1, pNdisBuf2;
UINT Len;
ULONG TransportHeaderOffset = 0;
TransportHeaderOffset = PacketInfo->IPHeaderOffset;
NdisGetFirstBufferFromPacket( Packet,
&ArpBuf,
&ArpH,
&ArpLen,
&TotalLen
);
pNdisBuf1 = Packet->Private.Head;
NdisQueryBuffer(pNdisBuf1, &pAddr, &Len);
while(Len <= TransportHeaderOffset)
{
TransportHeaderOffset -= Len;
NdisGetNextBuffer(pNdisBuf1, &pNdisBuf2);
NdisQueryBuffer(pNdisBuf2, &pAddr, &Len);
pNdisBuf1 = pNdisBuf2;
}
/* Buffer Descriptor corresponding to Ip Packet */
IpBuf = pNdisBuf1;
/* Length of this Buffer (IP buffer) */
IpLen = Len - TransportHeaderOffset;
/* Starting Virtual Address for this buffer */
GeneralVA = pAddr;
/* Virtual Address of the IP Header */
IPH = (IPHeader *)(((PUCHAR)pAddr) + TransportHeaderOffset);
}
if(!IpBuf)
goto SUBMIT_NEXT;
/* Let's try to parse the packet */
Src = IPH->iph_src;
Dst = IPH->iph_dest;
IPID = net_short(IPH->iph_id);
Size = net_short(IPH->iph_length);
IpHdrLen = ((IPH->iph_verlen & (uchar)~IP_VER_FLAG) << 2);
FragOffset = IPH->iph_offset & IP_OFFSET_MASK;
FragOffset = net_short(FragOffset) * 8;
bFragment = (IPH->iph_offset & IP_MF_FLAG) || (FragOffset > 0);
// Don't want to deal with Fragmented packets right now..//
if ( bFragment )
goto SUBMIT_NEXT;
switch (IPH->iph_protocol)
{
case IPPROTO_TCP :
if (IPH && ((USHORT)IpLen > IpHdrLen))
{
// We have more than the IP Header in this MDL //
TCPH = (TCPHeader *) ((PUCHAR)IPH + IpHdrLen);
TcpLen = IpLen - IpHdrLen;
TcpBuf = IpBuf;
}
else
{
// TCP Header is in the next MDL //
NdisGetNextBuffer(IpBuf, &TcpBuf);
if(!TcpBuf)
goto SUBMIT_NEXT;
GeneralVA = NULL;
NdisQueryBuffer(TcpBuf,
&GeneralVA,
&TcpLen
);
TCPH = (TCPHeader *) GeneralVA;
}
/* At this point, TcpBuf, TCPH and TcpLen contain the proper values */
// Get the port numbers out.
SrcPort = net_short(TCPH->tcp_src);
DstPort = net_short(TCPH->tcp_dest);
// We have the TCP Buffer now. Get to the DATA //
TcpHeaderOffset = TCP_HDR_SIZE(TCPH);
if (TcpLen > TcpHeaderOffset)
{
// We have the DATA right here! //
Data = (PUCHAR)TCPH + TcpHeaderOffset;
DataLen = TcpLen - TcpHeaderOffset;
}
else
{
NdisGetNextBuffer(TcpBuf, &DataBuf);
if(!DataBuf)
goto SUBMIT_NEXT;
GeneralVA = NULL;
NdisQueryBuffer(DataBuf,
&Data,
&DataLen
);
}
/* At this point, DataBuf, Data and DataLen contain the proper values */
goto TimeStamp;
break;
case IPPROTO_UDP:
if (IpLen > IpHdrLen)
{
// We have more than the IP Header in this MDL //
UDPH = (UDPHeader *) ((PUCHAR)IPH + IpHdrLen);
UdpLen = IpLen - IpHdrLen;
UdpBuf = IpBuf;
}
else
{
// UDP Header is in the next MDL //
NdisGetNextBuffer(IpBuf, &UdpBuf);
if(!UdpBuf)
goto SUBMIT_NEXT;
GeneralVA = NULL;
NdisQueryBuffer(UdpBuf,
&GeneralVA,
&UdpLen
);
UDPH = (UDPHeader *) GeneralVA;
}
/* At this point, UdpBuf, UDPH and UdpLen contain the proper values */
SrcPort = net_short(UDPH->uh_src);
DstPort = net_short(UDPH->uh_dest);
// Get to the data. //
if (UdpLen > sizeof (UDPHeader))
{
// We have the DATA right here! //
Data = (PUCHAR) UDPH + sizeof (UDPHeader);
DataLen = UdpLen - sizeof (UDPHeader);
}
else
{
NdisGetNextBuffer(UdpBuf, &DataBuf);
if(!DataBuf)
goto SUBMIT_NEXT;
GeneralVA = NULL;
NdisQueryBuffer(DataBuf,
&Data,
&DataLen
);
}
/* At this point, DataBuf, Data and DataLen contain the proper values */
goto TimeStamp;
break;
default:
goto SUBMIT_NEXT;
}
TimeStamp:
Ret = CheckForMatch( Src, Dst, SrcPort, DstPort, IPH->iph_protocol, IPID, Size, DIR_SEND);
if( Ret == MARK_IN_PKT)
{
if (DataLen >= sizeof(MARK_IN_PKT_RECORD))
{
LARGE_INTEGER PerfFrequency, CurrentTime;
UINT64 RecdTime, Freq;
PMARK_IN_PKT_RECORD pRecord;
pRecord = (PMARK_IN_PKT_RECORD) Data;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
pRecord->BufferSize = DataLen;
// Convert the perffrequency into 100ns interval //
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
// convert to uint64 //
pRecord->TimeSentWire = 0;
pRecord->TimeSentWire |= CurrentTime.HighPart;
pRecord->TimeSentWire = pRecord->TimeSentWire << 32;
pRecord->TimeSentWire |= CurrentTime.LowPart;
// Normalize cycles with the frequency.
pRecord->TimeSentWire *= 10000000;
pRecord->TimeSentWire /= Freq;
if(IPH->iph_protocol == IPPROTO_UDP)
UDPH->uh_xsum = 0;
}
}
else if( Ret == MARK_IN_BUF)
{
// Nothing more to be done..
}
SUBMIT_NEXT:
return (*Pipe->ContextInfo.NextComponent->SubmitPacket)(
Pipe->ContextInfo.NextComponentContext,
Flow->ContextInfo.NextComponentContext,
(ClassMapContext != NULL) ? ClassMapContext->NextComponentContext : NULL,
PacketInfo);
}
BOOLEAN
TimeStmpReceivePacket (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PNDIS_PACKET Packet,
IN NDIS_MEDIUM Medium
)
{
PPS_PIPE_CONTEXT Pipe;
LARGE_INTEGER CurrentTime;
IPHeader UNALIGNED *IPH;
TCPHeader UNALIGNED *TCPH;
UDPHeader UNALIGNED *UDPH;
IPAddr Src, Dst;
PUCHAR headerBuffer, pData;
PNDIS_BUFFER pFirstBuffer;
ULONG firstbufferLength, bufferLength, HeaderLength;
ULONG TotalIpLen, IPDataLength, IpHdrLen;
ULONG TotalTcpLen, TcpDataLen, TotalLen, TcpHeaderOffset, i;
int TotalUdpLen, UdpDataLen, UdpHdrLen, DataLen, Ret;
USHORT SrcPort, DstPort, IPID, FragOffset, Size;
BOOLEAN bFragment, bFirstFragment, bLastFragment;
/* This will give the size of the "media-specific" header. So, this will be the offset to IP packet */
UINT HeaderBufferSize ;
ushort type; // Protocol type
uint ProtOffset; // Offset in Data to non-media info.
if( ( TsCount == 0) ||
(NDIS_GET_PACKET_PROTOCOL_TYPE(Packet) == NDIS_PROTOCOL_ID_TCP_IP))
{
return TRUE;
}
Pipe = PipeContext;
HeaderBufferSize = NDIS_GET_PACKET_HEADER_SIZE(Packet);
NdisGetFirstBufferFromPacket(Packet, // packet
&pFirstBuffer, // first buffer descriptor
&headerBuffer, // VA of the first buffer
&firstbufferLength, // length of the header+lookahead
&bufferLength); // length of the bytes in the buffers
IPH = (IPHeader *) ((PUCHAR)headerBuffer + HeaderBufferSize);
// Check the header length and the version //
HeaderLength = ((IPH->iph_verlen & (uchar)~IP_VER_FLAG) << 2);
// If the HeaderLength seems to be incorrect, let's not try to parse //
if( (HeaderLength < sizeof(IPHeader)) ||
(HeaderLength > bufferLength) )
return TRUE;
// Get past the IP Header and get the rest of the stuff out //
TotalIpLen = (uint)net_short(IPH->iph_length);
// Make sure the version and IpData Len are correct //
if( ((IPH->iph_verlen & IP_VER_FLAG) != IP_VERSION ) ||
( TotalIpLen < HeaderLength ) ||
( TotalIpLen > bufferLength ))
return TRUE;
// Let's try to parse the packet //
Src = IPH->iph_src;
Dst = IPH->iph_dest;
IPID = net_short(IPH->iph_id);
Size = net_short(IPH->iph_length);
FragOffset = IPH->iph_offset & IP_OFFSET_MASK;
FragOffset = net_short(FragOffset) * 8;
bFragment = (IPH->iph_offset & IP_MF_FLAG) || (FragOffset > 0);
bFirstFragment = bFragment && (FragOffset == 0);
bLastFragment = bFragment && (!(IPH->iph_offset & IP_MF_FLAG));
// If this is a fragment and NOT the first one, just put the Timestamp in here.
// Otherwise, let it get to the protocols for processing.
if (bFragment )
return TRUE;
// Do the protocol specific stuff //
switch (IPH->iph_protocol)
{
case IPPROTO_TCP:
TotalTcpLen = TotalIpLen - HeaderLength;
TCPH = (TCPHeader *) (((PUCHAR)IPH) + HeaderLength);
// For TCP, the data offset is part of the TCP Header */
TcpHeaderOffset = TCP_HDR_SIZE(TCPH);
DataLen = TotalTcpLen - TcpHeaderOffset;
pData = (PUCHAR) TCPH + TcpHeaderOffset;
SrcPort = net_short(TCPH->tcp_src);
DstPort = net_short(TCPH->tcp_dest);
goto TimeStmp;
break;
case IPPROTO_UDP:
TotalUdpLen = TotalIpLen - HeaderLength;
UDPH = (UDPHeader *) (((PUCHAR)IPH) + HeaderLength);
// For UDP, the header size is fixed //
DataLen = TotalUdpLen - sizeof(UDPHeader);
pData = ((PUCHAR) UDPH) + sizeof (UDPHeader);
SrcPort = net_short(UDPH->uh_src);
DstPort = net_short(UDPH->uh_dest);
goto TimeStmp;
break;
default:
break;
}
return TRUE;
TimeStmp:
Ret = CheckForMatch( Src, Dst, SrcPort, DstPort, IPH->iph_protocol, IPID, Size, DIR_RECV);
if( Ret == MARK_IN_PKT)
{
if (DataLen >= sizeof(MARK_IN_PKT_RECORD))
{
LARGE_INTEGER PerfFrequency, CurrentTime;
UINT64 RecdTime, Freq;
PMARK_IN_PKT_RECORD pRecord;
pRecord = (PMARK_IN_PKT_RECORD) pData;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
// Convert the perffrequency into 100ns interval //
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
//convert from large_integer to uint64
pRecord->TimeReceivedWire = 0;
pRecord->TimeReceivedWire |= CurrentTime.HighPart;
pRecord->TimeReceivedWire = pRecord->TimeReceivedWire << 32;
pRecord->TimeReceivedWire |= CurrentTime.LowPart;
// Normalize cycles with the frequency.
pRecord->TimeReceivedWire *= 10000000;
pRecord->TimeReceivedWire /= Freq;
if(IPH->iph_protocol == IPPROTO_UDP)
UDPH->uh_xsum = 0;
}
}
else if( Ret == MARK_IN_BUF)
{
}
return TRUE;
}
#ifdef NEVER
//
// This function receives a buffer from NDIS which is indicated to the transport.
// We use this function and work past the headers (tcp, ip) and get to the data.
// Then, we timestamp and reset the checksum flags.
// We make the assumption that the lookahead is atleast 128.
// mac header ~ 8+8, ip header ~20, tcp/udp ~ 20+options, LOG_RECORD ~ 44
// they all add up to less than 128. If this is not a good assumption, We will need
// to get into MiniportTransferData and such.
//
BOOLEAN
TimeStmpReceiveIndication(
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PVOID HeaderBuffer,
IN UINT HeaderBufferSize,
IN PVOID LookAheadBuffer,
IN UINT LookAheadBufferSize,
IN UINT PacketSize,
IN UINT TransportHeaderOffset
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
LARGE_INTEGER CurrentTime;
IPHeader UNALIGNED *IPH = NULL;
TCPHeader UNALIGNED *TCPH = NULL;
UDPHeader UNALIGNED *UDPH = NULL;
IPAddr Src, Dst;
PUCHAR headerBuffer = NULL, pData = NULL;
PNDIS_BUFFER pFirstBuffer = NULL;
ULONG firstbufferLength = 0, bufferLength = 0, HeaderLength = 0;
ULONG TotalIpLen = 0, IPDataLength = 0, IpHdrLen = 0;
ULONG TotalTcpLen = 0, TcpDataLen = 0, TotalLen = 0, TcpHeaderOffset = 0;
ULONG TotalUdpLen = 0, UdpDataLen = 0, UdpHdrLen = 0;
USHORT SrcPort = 0, DstPort = 0, IPID = 0, FragOffset = 0, Size = 0;
BOOLEAN bFragment, bFirstFragment, bLastFragment;
ULONG i = 0;
ushort type; // Protocol type
uint ProtOffset; // Offset in Data to non-media info.
UINT MoreHeaderInLookAhead = 0;
// Don't know anything about the MAC headers, piggy back from PSCHED...
// Calculate if the header is more than the standard HeaderBufferSize (i.e. SNAP header, etc.)
//
MoreHeaderInLookAhead = TransportHeaderOffset - HeaderBufferSize;
if (MoreHeaderInLookAhead)
{
// Just munge these, so that we can actually get down to business //
((PUCHAR) LookAheadBuffer) += MoreHeaderInLookAhead;
LookAheadBufferSize -= MoreHeaderInLookAhead;
}
if (LookAheadBufferSize > sizeof(IPHeader))
{
IPH = (IPHeader *) (PUCHAR)LookAheadBuffer;
// Check the header length and the version. If any of these
// checks fail silently discard the packet.
HeaderLength = ((IPH->iph_verlen & (uchar)~IP_VER_FLAG) << 2);
if (HeaderLength >= sizeof(IPHeader) && HeaderLength <= LookAheadBufferSize)
{
// Get past the IP Header and get the rest of the stuff out//
TotalIpLen = (uint)net_short(IPH->iph_length);
if ((IPH->iph_verlen & IP_VER_FLAG) == IP_VERSION &&
TotalIpLen >= HeaderLength && TotalIpLen <= LookAheadBufferSize)
{
Src = IPH->iph_src;
Dst = IPH->iph_dest;
IPID = net_short(IPH->iph_id);
Size = net_short(IPH->iph_length );
FragOffset = IPH->iph_offset & IP_OFFSET_MASK;
FragOffset = net_short(FragOffset) * 8;
bFragment = (IPH->iph_offset & IP_MF_FLAG) || (FragOffset > 0);
bFirstFragment = bFragment && (FragOffset == 0);
bLastFragment = bFragment && (!(IPH->iph_offset & IP_MF_FLAG));
// If this is a fragment and NOT the first one, just put the Timestamp in here.
// Otherwise, let it get to the protocols for processing.
if (bFragment )
return TRUE;
// Do the protocol specific stuff.//
switch (IPH->iph_protocol)
{
case IPPROTO_TCP:
TotalTcpLen = TotalIpLen - HeaderLength;
TCPH = (TCPHeader *) (((PUCHAR)IPH) + HeaderLength);
SrcPort = net_short(TCPH->tcp_src);
DstPort = net_short(TCPH->tcp_dest);
TcpHeaderOffset = TCP_HDR_SIZE(TCPH);
pData = (PUCHAR) TCPH + TcpHeaderOffset;
TcpDataLen = TotalTcpLen - TcpHeaderOffset;
goto TimeStmp;
break;
case IPPROTO_UDP:
TotalUdpLen = TotalIpLen - HeaderLength;
UDPH = (UDPHeader *) (((PUCHAR)IPH) + HeaderLength);
UdpDataLen = TotalUdpLen - sizeof(UDPHeader);
pData = ((PUCHAR) UDPH) + sizeof (UDPHeader);
SrcPort = net_short(UDPH->uh_src);
DstPort = net_short(UDPH->uh_dest);
if (UdpDataLen < sizeof(UDPHeader))
return TRUE;
goto TimeStmp;
break;
default:
break;
}
}
}
}
TimeStmp:
CheckForMatch( Src, Dst, SrcPort, DstPort,0, IPID, Size, DIR_RECV);
/*
if (CheckInPortAndIpList(Src, DstPort))
{
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
LOG_RECORD Record;
pRecord = &Record;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
//
// Convert the perffrequency into 100ns interval.
//
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
pRecord->TimeReceivedWire = 0;
pRecord->TimeReceivedWire |= CurrentTime.HighPart;
pRecord->TimeReceivedWire = pRecord->TimeReceivedWire << 32;
pRecord->TimeReceivedWire |= CurrentTime.LowPart;
// Normalize cycles with the frequency.
pRecord->TimeReceivedWire *= 10000000;
pRecord->TimeReceivedWire /= Freq;
if( (int)( (char*)pPacketStore - (char*)pPacketStoreHead + sizeof(PACKET_RECORD) ) < PACKET_STORE_SIZE )
{
pPacketStore->IpId = IPID;
pPacketStore->cSeperator1='y';
pPacketStore->TimeValue = pRecord->TimeReceivedWire;
pPacketStore->cSeperator2 = 'm';
pPacketStore->Size = Size;
pPacketStore->cSeperator3 = 'z';
pPacketStore->cSeperator4 = 'z';
pPacketStore = (PPACKET_RECORD)((char*)pPacketStore + sizeof(PACKET_RECORD));
}
else
{
pPacketStore = pPacketStoreHead;
}
}
*/
return TRUE;
}
#endif
Reference in a new issue Copy permalink