/*++
Copyright (c) 1996-1999 Microsoft Corporation
Module Name:
timestmp.c
Abstract:
Timestamper module
Author:
Shreedhar Madhavapeddi (shreem)
Revision History:
--*/
#include <timestmp.h>
//
// The following struct has to be in ssync with
// ndis\trfccntl\tools\qtcp\qtcp.c
//
typedef struct _LOG_RECORD{
UINT64 TimeSent;
UINT64 TimeReceived;
UINT64 TimeSentWire; // These fields are used by the kernel timestamper
UINT64 TimeReceivedWire; // These fields are used by the kernel timestamper
UINT64 Latency;
INT BufferSize;
INT SequenceNumber;
} LOG_RECORD, *PLOG_RECORD;
ULONG GlobalSequenceNumber = 0;
// 321618 needs checking for PSCHED's existence.
NDIS_STRING PschedDriverName = NDIS_STRING_CONST("\\Device\\PSched");
HANDLE PschedHandle;
NTSTATUS CheckForPsched(VOID);
//
// TCP Headers (redefined here, since there are no exported headers
//
#define IP_OFFSET_MASK ~0x00E0 // Mask for extracting offset field.
#define net_short(x) ((((x)&0xff) << 8) | (((x)&0xff00) >> 8))
/*
* Protocols (from winsock.h)
*/
#define IPPROTO_IP 0 /* dummy for IP */
#define IPPROTO_ICMP 1 /* control message protocol */
#define IPPROTO_IGMP 2 /* group management protocol */
#define IPPROTO_GGP 3 /* gateway^2 (deprecated) */
#define IPPROTO_TCP 6 /* tcp */
#define IPPROTO_PUP 12 /* pup */
#define IPPROTO_UDP 17 /* user datagram protocol */
#define IPPROTO_IDP 22 /* xns idp */
#define IPPROTO_ND 77 /* UNOFFICIAL net disk proto */
#define IPPROTO_IPSEC 51 /* ???????? */
#define IPPROTO_RAW 255 /* raw IP packet */
#define IPPROTO_MAX 256
#define IP_MF_FLAG 0x0020 // 'More fragments flag'
#define IP_VERSION 0x40
#define IP_VER_FLAG 0xF0
#define TCP_OFFSET_MASK 0xf0
#define TCP_HDR_SIZE(t) (uint)(((*(uchar *)&(t)->tcp_flags) & TCP_OFFSET_MASK) >> 2)
typedef int SeqNum; // A sequence number.
struct TCPHeader {
ushort tcp_src; // Source port.
ushort tcp_dest; // Destination port.
SeqNum tcp_seq; // Sequence number.
SeqNum tcp_ack; // Ack number.
ushort tcp_flags; // Flags and data offset.
ushort tcp_window; // Window offered.
ushort tcp_xsum; // Checksum.
ushort tcp_urgent; // Urgent pointer.
};
typedef struct TCPHeader TCPHeader;
struct UDPHeader {
ushort uh_src; // Source port.
ushort uh_dest; // Destination port.
ushort uh_length; // Length
ushort uh_xsum; // Checksum.
}; /* UDPHeader */
typedef struct UDPHeader UDPHeader;
#ifdef DBG
//
// Define the Trace Level.
//
#define TS_DBG_DEATH 1
#define TS_DBG_TRACE 2
//
// Masks
//
#define TS_DBG_PIPE 0x00000001
#define TS_DBG_FLOW 0x00000002
#define TS_DBG_SEND 0x00000004
#define TS_DBG_RECV 0x00000008
#define TS_DBG_INIT 0x00000010
#define TS_DBG_OID 0x00000020
#define TS_DBG_CLASS_MAP 0x00000040
ULONG DbgTraceLevel = 1;
ULONG DbgTraceMask = 0x8;
#define TimeStmpTrace(_DebugLevel, _DebugMask, _Out) \
if ((DbgTraceLevel >= _DebugLevel) && \
((_DebugMask) & DbgTraceMask)){ \
DbgPrint("TimeStamp: "); \
DbgPrint _Out; \
}
#else // DBG
#define TimeStmpTrace
#endif
#define PORT_RANGE 20
USHORT IPIDList[PORT_RANGE];
NDIS_SPIN_LOCK IPIDListLock;
#define PORT_RANGE 20
USHORT IPIDListRecv[PORT_RANGE];
NDIS_SPIN_LOCK IPIDListLockRecv;
/*
Let's create a driver unload function, so that timestmp is stoppable via net sto
p timestmp
*/
VOID
TimeStmpUnload(
IN PDRIVER_OBJECT DriverObject
)
{
IoctlCleanup();
return;
}
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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_PIPE, ("[TimeStmpIndicatePipe]: \n"));
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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_PIPE, ("[TimeStmpModifyPipe]: \n"));
return (*Pipe->NextComponent->ModifyPipe)(
Pipe->NextComponentContext, PipeParameters);
}
VOID
TimeStmpDeletePipe (
IN PPS_PIPE_CONTEXT PipeContext
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_PIPE, ("[TimeStmpDeletePipe]: \n"));
(*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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_FLOW, ("[TimeStmpCreateFlow]: \n"));
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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_FLOW, ("[TimeStmpModifyFlow]: \n"));
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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_FLOW, ("[TimeStmpDeleteFlow]: \n"));
(*Pipe->NextComponent->DeleteFlow)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext);
}
BOOLEAN
TimeStmpSubmitPacket (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_FLOW_CONTEXT FlowContext,
IN PPS_CLASS_MAP_CONTEXT ClassMapContext,
IN PPACKET_INFO_BLOCK PacketInfo
)
{
PPS_PIPE_CONTEXT Pipe = PipeContext;
LARGE_INTEGER CurrentTime;
IPHeader UNALIGNED *IPH = NULL;
TCPHeader UNALIGNED *TCPH = NULL;
UDPHeader UNALIGNED *UDPH = NULL;
PVOID ArpH = NULL, GeneralVA = NULL, Data = NULL;
IPAddr Src, Dst;
PNDIS_BUFFER ArpBuf = NULL, IpBuf = NULL, TcpBuf = NULL, DataBuf = NULL, UdpBuf = NULL;
ULONG ArpLen = 0, IpLen = 0, IpHdrLen = 0, TcpLen = 0, DataLen = 0, TotalLen = 0, TcpHeaderOffset = 0;
ULONG UdpLen = 0;
USHORT SrcPort = 0, DstPort = 0, IPID = 0, FragOffset = 0;
PLIST_ENTRY CurrentEntry = NULL, LastEntry = NULL;
BOOLEAN bFragment, bFirstFragment, bLastFragment;
ULONG i = 0;
PLOG_RECORD pRecord = NULL;
PNDIS_PACKET Packet = PacketInfo->NdisPacket;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: \n"));
//
// Steps
// Parse the IP Packet.
// Look for the appropriate ports.
// Look for the data portion and put in the Time & length there.
//
NdisGetFirstBufferFromPacket(
Packet,
&ArpBuf,
&ArpH,
&ArpLen,
&TotalLen
);
//
// We are guaranteed that the ARP buffer if always a different MDL, so
// jump to the next MDL
//
NdisGetNextBuffer(ArpBuf, &IpBuf)
if (IpBuf) {
NdisQueryBuffer(IpBuf,
&GeneralVA,
&IpLen
);
IPH = (IPHeader *) GeneralVA;
if (!IPH) {
goto FAILURE;
}
Src = net_short(IPH->iph_src);
Dst = net_short(IPH->iph_dest);
IPID = net_short(IPH->iph_id);
//IpHdrLen = 8 * 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);
bFirstFragment = bFragment && (FragOffset == 0);
bLastFragment = bFragment && (!(IPH->iph_offset & IP_MF_FLAG));
if (bFragment && (!bFirstFragment)) {
//
// Its a fragment alright and NOT the first one.
//
NdisAcquireSpinLock(&IPIDListLock);
for (i = 0; i < PORT_RANGE; i++) {
//
// Found the match...
//
if (IPIDList[i] == IPID) {
if (bLastFragment) {
//
// Since it is the last fragment, recall
// the IP ID.
//
IPIDList[i] = 0xffff;
}
NdisReleaseSpinLock(&IPIDListLock);
//
// Is the data in the same buffer?
//
if (IpLen <= IpHdrLen) {
NdisGetNextBuffer(IpBuf, &DataBuf);
if(DataBuf) {
NdisQueryBuffer(DataBuf,
&Data,
&DataLen
);
goto TimeStamp;
} else {
goto FAILURE;
}
} else {
//
// The Data Offsets need to be primed now.
//
DataLen = IpLen - FragOffset;
Data = ((PUCHAR) GeneralVA) + IpHdrLen;
goto TimeStamp;
}
}
}
NdisReleaseSpinLock(&IPIDListLock);
//
// If we are here, we dont care about this IPID for this fragment.
// Just return TRUE to continue processing.
//
//
// Ready to go.
//
PacketInfo->FlowContext = FlowContext;
PacketInfo->ClassMapContext = ClassMapContext;
return (*Pipe->NextComponent->SubmitPacket)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext,
ClassMapContext?ClassMapContext->NextComponentContext:0,
PacketInfo);
}
//
// If it is not a fragment, depending upon the protocol, process differently
//
switch (IPH->iph_protocol) {
case IPPROTO_TCP :
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Procol TCP\n"));
if (IPH && ((USHORT)IpLen > IpHdrLen)) {
//
// We have more than the IP Header in this MDL.
//
TCPH = (TCPHeader *) ((PUCHAR)GeneralVA + IpHdrLen);
TcpLen = IpLen - IpHdrLen;
TcpBuf = IpBuf;
} else {
//
// TCP Header is in the next MDL
//
NdisGetNextBuffer(IpBuf, &TcpBuf);
if(TcpBuf) {
GeneralVA = NULL;
NdisQueryBuffer(TcpBuf,
&GeneralVA,
&TcpLen
);
TCPH = (TCPHeader *) GeneralVA;
} else {
goto FAILURE;
}
}
//
// 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) {
GeneralVA = NULL;
NdisQueryBuffer(DataBuf,
&Data,
&DataLen
);
} else {
goto FAILURE;
}
}
if (CheckInPortList(DstPort) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLock);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDList[i]) {
IPIDList[i] = IPID;
break;
}
}
NdisReleaseSpinLock(&IPIDListLock);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_SEND, ("Couldn't find an empty IPID - Bailing \n"));
goto FAILURE;
}
//DbgBreakPoint();
}
//
// Let's timestmp this now.
//
if (CheckInPortList(DstPort)) {
goto TimeStamp;
} else {
//
// This is not one of our packet, get out.
//
goto FAILURE;
}
break;
case IPPROTO_UDP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Protocol UDP\n"));
if (IPH && (IpLen > IpHdrLen)) {
//
// We have more than the IP Header in this MDL.
//
UDPH = (UDPHeader *) ((PUCHAR)GeneralVA + IpHdrLen);
UdpLen = IpLen - IpHdrLen;
UdpBuf = IpBuf;
} else {
//
// UDP Header is in the next MDL
//
NdisGetNextBuffer(IpBuf, &UdpBuf);
if(UdpBuf) {
GeneralVA = NULL;
NdisQueryBuffer(UdpBuf,
&GeneralVA,
&UdpLen
);
UDPH = (UDPHeader *) GeneralVA;
} else {
goto FAILURE;
}
}
SrcPort = net_short(UDPH->uh_src); // Source port.
DstPort = net_short(UDPH->uh_dest); // Destination port.
//
// 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) {
GeneralVA = NULL;
NdisQueryBuffer(DataBuf,
&Data,
&DataLen
);
} else {
goto FAILURE;
}
}
if (CheckInPortList(DstPort) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLock);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDList[i]) {
IPIDList[i] = IPID;
break;
}
ASSERT(FALSE);
}
NdisReleaseSpinLock(&IPIDListLock);
//
// Couldnt find a free IPID place holder, lets bail.
//
if (PORT_RANGE == i) {
goto FAILURE;
}
}
//
// Let's timestmp this now.
//
if (CheckInPortList(DstPort)) {
goto TimeStamp;
} else {
//
// This is not one of our packet, get out.
//
goto FAILURE;
}
break;
case IPPROTO_RAW:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Protocol RAW\n"));
goto FAILURE;
break;
case IPPROTO_IGMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Protocol IGMP\n"));
goto FAILURE;
break;
case IPPROTO_ICMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Protocol TCMP\n"));
goto FAILURE;
break;
default:
//TimeStmpTrace(TS_DBG_DEATH, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: Protocol - UNKNOWN (%d)\n", IPH->iph_protocol));
goto FAILURE;
//DbgBreakPoint();
}
} else {
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_SEND, ("[TimeStmpSubmitPacket]: NO Buffer beyond MAC Header\n"));
goto FAILURE;
}
TimeStamp:
//
// If we get here, the Data and DataLen variables have been primed.
// Set the Time and Length.
//
if (Data) {
pRecord = (PLOG_RECORD) Data;
if (DataLen > sizeof (LOG_RECORD)) {
LARGE_INTEGER PerfFrequency;
UINT64 Freq;
//
// Set the fields accordingly
pRecord->BufferSize = DataLen;
//pRecord->SequenceNumber = InterlockedIncrement(&GlobalSequenceNumber);
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->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;
}
}
//
// Ready to go.
//
PacketInfo->FlowContext = FlowContext;
PacketInfo->ClassMapContext = ClassMapContext;
return (*Pipe->NextComponent->SubmitPacket)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext,
ClassMapContext?ClassMapContext->NextComponentContext:0,
PacketInfo);
FAILURE:
//
// Ready to go.
//
PacketInfo->FlowContext = FlowContext;
PacketInfo->ClassMapContext = ClassMapContext;
return (*Pipe->NextComponent->SubmitPacket)(
Pipe->NextComponentContext,
FlowContext->NextComponentContext,
ClassMapContext?ClassMapContext->NextComponentContext:0,
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 = 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, Size = 0;
ULONG TotalUdpLen = 0, UdpDataLen = 0, UdpHdrLen = 0;
USHORT SrcPort = 0, DstPort = 0, IPID = 0, FragOffset = 0;
BOOLEAN bFragment, bFirstFragment, bLastFragment;
ULONG i = 0;
PLOG_RECORD pRecord = NULL;
UINT HeaderBufferSize = NDIS_GET_PACKET_HEADER_SIZE(Packet);
ushort type; // Protocol type
uint ProtOffset; // Offset in Data to non-media info.
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: \n"));
NdisGetFirstBufferFromPacket(Packet, // packet
&pFirstBuffer, // first buffer descriptor
&headerBuffer, // ptr to the start of packet
&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. If any of these
// checks fail silently discard the packet.
HeaderLength = ((IPH->iph_verlen & (uchar)~IP_VER_FLAG) << 2);
if (HeaderLength >= sizeof(IPHeader) && HeaderLength <= bufferLength) {
//
// 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 <= bufferLength) {
Src = net_short(IPH->iph_src);
Dst = net_short(IPH->iph_dest);
IPID = net_short(IPH->iph_id);
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 && !bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
for (i = 0; i < PORT_RANGE; i++) {
if (IPID == IPIDListRecv[i]) {
if (bLastFragment) {
//
// If its the last fragment, release the slot.
//
IPIDListRecv[i] = 0xffff;
}
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("Couldnt find an IPID that we care about, get outta here.\n"));
goto RECV_FAILURE;
}
//
// So we found a IPID that matches - set the timestamp and get out after this.
//
TotalLen = TotalIpLen - FragOffset;
pData = ((PUCHAR) IPH) + IpHdrLen;
if (TotalLen > sizeof (LOG_RECORD)) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_RECORD *) pData;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
//
// Convert the perffrequency into 100ns interval.
//
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
//convert from Largeinteger 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;
}
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);
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: *TCP* Address: SRC = %x DST = %x, Port S : %x, Port D: %x\n",
IPH->iph_src,
IPH->iph_dest,
SrcPort,
DstPort));
TcpHeaderOffset = TCP_HDR_SIZE(TCPH);
pData = (PUCHAR) TCPH + TcpHeaderOffset;
TcpDataLen = TotalTcpLen - TcpHeaderOffset;
if ((CheckInPortList(DstPort)) && (TcpDataLen > sizeof (LOG_RECORD))) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_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;
} else if (CheckInPortList(DstPort)) {
if (TcpDataLen < sizeof(LOG_RECORD))
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("The Datagram was too small!! IpLen:%d, Tcplen:%d HeaderOff(tcp):%d log_record:%d\n", TotalIpLen, TotalTcpLen, TcpHeaderOffset, sizeof (LOG_RECORD)));
}
//
// If its the first fragment, keep a place holder so we know which
// subsequent IP fragments to timestamp.
//
if ((CheckInPortList(DstPort)) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDListRecv[i]) {
IPIDListRecv[i] = IPID;
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("Couldn't find an empty IPID - Bailing \n"));
}
}
break;
case IPPROTO_UDP:
TotalUdpLen = TotalIpLen - HeaderLength;
UDPH = (UDPHeader *) (((PUCHAR)IPH) + HeaderLength);
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("PAcket %x, IPH = %x, UDPH = %x, HeaderLength = %x\n", Packet, IPH, UDPH, HeaderLength));
UdpDataLen = TotalUdpLen - sizeof(UDPHeader);
pData = ((PUCHAR) UDPH) + sizeof (UDPHeader);
SrcPort = net_short(UDPH->uh_src); // Source port.
DstPort = net_short(UDPH->uh_dest); // Destination port.
if (UdpDataLen < sizeof(UDPHeader)) {
return TRUE;
}
if ((CheckInPortList(DstPort)) && (UdpDataLen > sizeof(LOG_RECORD))) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_RECORD *) pData;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
//
// Convert the perffrequency into 100ns interval.
//
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
// convert 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;
//
// Dont want to get rejected due to bad xsum ...
//
UDPH->uh_xsum = 0;
} else if (CheckInPortList(DstPort)) {
if ((UdpDataLen) < sizeof(LOG_RECORD))
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("The Datagram was too small (UDP)!! IpLen:%d, Size:%d log_record:%d\n",
TotalIpLen, UdpDataLen, sizeof (LOG_RECORD)));
}
if ((CheckInPortList(DstPort)) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDListRecv[i]) {
IPIDListRecv[i] = IPID;
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("Couldn't find an empty IPID - Bailing \n"));
}
}
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: *UDP* Address: SRC = %x DST = %x, Port S : %x, Port D: %x\n",
IPH->iph_src,
IPH->iph_dest,
UDPH->uh_src,
UDPH->uh_dest));
break;
case IPPROTO_RAW:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: Protocol RAW\n"));
break;
case IPPROTO_IGMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: Protocol IGMP\n"));
break;
case IPPROTO_ICMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceivePacket]: Protocol TCMP\n"));
break;
default:
;
//TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("[TimeStmpReceivePacket]: Protocol - UNKNOWN (%d)\n", IPH->iph_protocol));
//DbgBreakPoint();
}
}
}
RECV_FAILURE:
return TRUE;
}
//
// 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, Size = 0;
ULONG TotalUdpLen = 0, UdpDataLen = 0, UdpHdrLen = 0;
USHORT SrcPort = 0, DstPort = 0, IPID = 0, FragOffset = 0;
BOOLEAN bFragment, bFirstFragment, bLastFragment;
ULONG i = 0;
PLOG_RECORD pRecord = NULL;
ushort type; // Protocol type
uint ProtOffset; // Offset in Data to non-media info.
UINT MoreHeaderInLookAhead = 0;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: \n"));
//
// 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 = net_short(IPH->iph_src);
Dst = net_short(IPH->iph_dest);
IPID = net_short(IPH->iph_id);
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 && !bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
for (i = 0; i < PORT_RANGE; i++) {
if (IPID == IPIDListRecv[i]) {
if (bLastFragment) {
//
// If its the last fragment, release the slot.
//
IPIDListRecv[i] = 0xffff;
}
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("Couldnt find an IPID that we care about, get outta here.\n"));
goto RECV_FAILURE;
}
//
// So we found a IPID that matches - set the timestamp and get out after this.
//
TotalLen = TotalIpLen - FragOffset;
pData = ((PUCHAR) IPH) + IpHdrLen;
if (TotalLen >= sizeof (LOG_RECORD)) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_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;
}
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);
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: *TCP* Address: SRC = %x DST = %x, Port S : %x, Port D: %x\n",
IPH->iph_src,
IPH->iph_dest,
SrcPort,
DstPort));
TcpHeaderOffset = TCP_HDR_SIZE(TCPH);
pData = (PUCHAR) TCPH + TcpHeaderOffset;
TcpDataLen = TotalTcpLen - TcpHeaderOffset;
if ((CheckInPortList(DstPort)) && (TcpDataLen > sizeof (LOG_RECORD))) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_RECORD *) pData;
CurrentTime = KeQueryPerformanceCounter(&PerfFrequency);
//
// Convert the perffrequency into 100ns interval.
//
Freq = 0;
Freq |= PerfFrequency.HighPart;
Freq = Freq << 32;
Freq |= PerfFrequency.LowPart;
// convert 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;
//
//pRecord->TimeReceivedWire);
//
} else if (CheckInPortList(DstPort)) {
if (TcpDataLen < sizeof(LOG_RECORD))
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV,
("The Datagram was too small!! IpLen:%d, Tcplen:%d HeaderOff(tcp):%d log_record:%d\n", TotalIpLen, TotalTcpLen, TcpHeaderOffset, sizeof (LOG_RECORD)));
}
//
// If its the first fragment, keep a place holder so we know which
// subsequent IP fragments to timestamp.
//
if ((CheckInPortList(DstPort)) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDListRecv[i]) {
IPIDListRecv[i] = IPID;
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("Couldn't find an empty IPID - Bailing \n"));
}
}
break;
case IPPROTO_UDP:
TotalUdpLen = TotalIpLen - HeaderLength;
UDPH = (UDPHeader *) (((PUCHAR)IPH) + HeaderLength);
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("PAcket %x, IPH = %x, UDPH = %x, HeaderLength = %x\n", LookAheadBuffer, IPH, UDPH, HeaderLength));
UdpDataLen = TotalUdpLen - sizeof(UDPHeader);
pData = ((PUCHAR) UDPH) + sizeof (UDPHeader);
SrcPort = net_short(UDPH->uh_src); // Source port.
DstPort = net_short(UDPH->uh_dest); // Destination port.
if (UdpDataLen < sizeof(UDPHeader)) {
return TRUE;
}
if ((CheckInPortList(DstPort)) && (UdpDataLen > sizeof(LOG_RECORD))) {
LARGE_INTEGER PerfFrequency;
UINT64 RecdTime, Freq;
pRecord = (LOG_RECORD *) pData;
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;
//
// Dont want to get rejected due to bad xsum ...
//
UDPH->uh_xsum = 0;
} else if (CheckInPortList(DstPort)) {
if ((UdpDataLen) < sizeof(LOG_RECORD))
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("The Datagram was too small (UDP)!! IpLen:%d, Size:%d log_record:%d\n",
TotalIpLen, UdpDataLen, sizeof (LOG_RECORD)));
}
if ((CheckInPortList(DstPort)) && bFirstFragment) {
NdisAcquireSpinLock(&IPIDListLockRecv);
// need new Entry for IPID
for (i = 0; i < PORT_RANGE; i++) {
//
// Look for a free slot
//
if (0xffff == IPIDListRecv[i]) {
IPIDListRecv[i] = IPID;
break;
}
}
NdisReleaseSpinLock(&IPIDListLockRecv);
if (i == PORT_RANGE) {
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("Couldn't find an empty IPID - Bailing \n"));
}
}
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: *UDP* Address: SRC = %x DST = %x, Port S : %x, Port D: %x\n",
IPH->iph_src,
IPH->iph_dest,
UDPH->uh_src,
UDPH->uh_dest));
break;
case IPPROTO_RAW:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: Protocol RAW\n"));
break;
case IPPROTO_IGMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: Protocol IGMP\n"));
break;
case IPPROTO_ICMP:
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: Protocol TCMP\n"));
break;
default:
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_RECV, ("[TimeStmpReceiveIndication]: Protocol - UNKNOWN (%d)\n", IPH->iph_protocol));
//DbgBreakPoint();
}
}
}
}
RECV_FAILURE:
return TRUE;
}
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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_OID, ("[TimeStmpSetInformation]:\n"));
(*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;
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_OID, ("[TimeStmpQueryInformation]:\n"));
(*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
)
{
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_CLASS_MAP, ("[TimeStmpCreateClassMap]: \n"));
return (*PipeContext->NextComponent->CreateClassMap)(
PipeContext->NextComponentContext,
PsClassMapContext,
ClassMap,
ComponentClassMapContext->NextComponentContext);
}
NDIS_STATUS
TimeStmpDeleteClassMap (
IN PPS_PIPE_CONTEXT PipeContext,
IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext
)
{
TimeStmpTrace(TS_DBG_TRACE, TS_DBG_CLASS_MAP, ("[TimeStmpDeleteClassMap]: \n"));
return (*PipeContext->NextComponent->DeleteClassMap)(
PipeContext->NextComponentContext,
ComponentClassMapContext->NextComponentContext);
}
NTSTATUS
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath
)
{
PSI_INFO Component;
NDIS_HANDLE ConfigHandle;
NDIS_STATUS Status;
NDIS_STRING ComponentKey = NDIS_STRING_CONST("DisplayName");
NDIS_STRING ComponentName = NDIS_STRING_CONST("TimeStmp");
PNDIS_CONFIGURATION_PARAMETER pConfigParam;
NDIS_STRING PsParamKey;
PWSTR p = RegistryPath->Buffer + RegistryPath->Length;
PS_DEBUG_INFO Dbg;
ULONG i = 0;
// The last word of Registry Path points to the driver name.
// NdisOpenProtocol needs that name!
while(p != RegistryPath->Buffer && *p != L'\\')
p-- ;
p++;
RtlInitUnicodeString(&PsParamKey, p);
DbgPrint("PsParamKey:%s\n", PsParamKey);
NdisOpenProtocolConfiguration(&Status, &ConfigHandle, &PsParamKey);
DbgPrint("Status of NdisOpenProtocol:%x\n", Status);
if (!NT_SUCCESS(Status)) {
goto failure;
}
//
// Check if psched is installed by opening it.
// If it fails, we dont load either.
//
Status = CheckForPsched();
if (!NT_SUCCESS(Status)) {
DbgPrint("PSCHED is NOT installed. Timestmp is bailing too\n");
goto failure;
}
IoctlInitialize(DriverObject);
// this list maintains a list of all ports that need to be timestamped.
InitializeListHead(&PortList);
NdisAllocateSpinLock(&PortSpinLock);
DriverObject->DriverUnload = TimeStmpUnload;
//
// We need to keep track of IPIDs for dealing with fragments
// that we need to stamp...
//
for (i = 0; i < PORT_RANGE; i++) {
IPIDList[i] = 0xffff;
}
NdisAllocateSpinLock(&IPIDListLock);
//
// Do the same for the receive side.
//
for (i = 0; i < PORT_RANGE; i++) {
IPIDListRecv[i] = 0xffff;
}
NdisAllocateSpinLock(&IPIDListLockRecv);
if ( NT_SUCCESS( Status ))
{
// Read the name of the component from the registry
#if 0
NdisReadConfiguration( &Status,
&pConfigParam,
ConfigHandle,
&ComponentKey,
NdisParameterString);
if( NT_SUCCESS( Status ))
{
RtlInitUnicodeString(&Component.ComponentName,
pConfigParam->ParameterData.StringData.Buffer);
#else
RtlInitUnicodeString(&Component.ComponentName, ComponentName.Buffer);
#endif
Component.Version = PS_COMPONENT_CURRENT_VERSION;
Component.PacketReservedLength = 0;
Component.PipeContextLength = sizeof(PS_PIPE_CONTEXT);
Component.FlowContextLength = sizeof(PS_FLOW_CONTEXT);
Component.ClassMapContextLength = sizeof(PS_CLASS_MAP_CONTEXT);
Component.SupportedOidsLength = 0;
Component.SupportedOidList = 0;
Component.SupportedGuidsLength = 0;
Component.SupportedGuidList = 0;
Component.InitializePipe = TimeStmpInitializePipe;
Component.ModifyPipe = TimeStmpModifyPipe;
Component.DeletePipe = TimeStmpDeletePipe;
Component.CreateFlow = TimeStmpCreateFlow;
Component.ModifyFlow = TimeStmpModifyFlow;
Component.DeleteFlow = TimeStmpDeleteFlow;
Component.CreateClassMap = TimeStmpCreateClassMap;
Component.DeleteClassMap = TimeStmpDeleteClassMap;
Component.SubmitPacket = TimeStmpSubmitPacket;
Component.ReceivePacket = TimeStmpReceivePacket;
Component.ReceiveIndication = TimeStmpReceiveIndication;
Component.SetInformation = TimeStmpSetInformation;
Component.QueryInformation = TimeStmpQueryInformation;
//
// Call Psched's RegisterPsComponent
//
Status = RegisterPsComponent(&Component, sizeof(Component),
&Dbg);
if(Status != NDIS_STATUS_SUCCESS)
{
DbgPrint("Status of RegisterPsComponent%x\n", Status);
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_INIT,
("DriverEntry: RegisterPsComponent Failed \n"));
}
else
{
DbgPrint("Status of RegisterPsComponent:%x\n", Status);
}
#if 0
}
else
{
DbgPrint("Status of NdisReadProtocol:%x\n", Status);
DbgBreakPoint();
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_INIT,
("DriverEntry: ComponentName not specified \n"));
}
#endif
}
else
{
DbgPrint("Status of NdisOpenProtocol:%x\n", Status);
TimeStmpTrace(TS_DBG_DEATH, TS_DBG_INIT,
("DriverEntry: Can't read driver information in registry"
"\n"));
}
failure:
return Status;
}
//
// The following function checks for the existence of PSCHED on the machine.
// The assumption being that PSCHED gets loaded before TimeStmp on a system.
// If we can open the device, it means that PSCHED is on, otherwise, we bail.
// This fix is for Bug - 321618
//
NTSTATUS
CheckForPsched(
VOID
)
{
NTSTATUS status;
IO_STATUS_BLOCK ioStatusBlock;
OBJECT_ATTRIBUTES objectAttr;
InitializeObjectAttributes(
&objectAttr,
&PschedDriverName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = NtCreateFile(
&PschedHandle,
GENERIC_READ,
&objectAttr,
&ioStatusBlock,
NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ,
FILE_OPEN,
FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0L);
if (!NT_SUCCESS(status)) {
return status;
} else {
NtClose(PschedHandle);
}
return status;
}
PPORT_ENTRY
CheckInPortList(USHORT Port) {
PLIST_ENTRY ListEntry;
PPORT_ENTRY pPortEntry;
NdisAcquireSpinLock(&PortSpinLock);
ListEntry = PortList.Flink;
while (ListEntry != &PortList) {
pPortEntry = CONTAINING_RECORD(ListEntry, PORT_ENTRY, Linkage);
if (Port == pPortEntry->Port) {
//DbgPrint("Found Port%d\n", Port);
NdisReleaseSpinLock(&PortSpinLock);
return pPortEntry;
} else {
ListEntry = ListEntry->Flink;
//DbgPrint("NOT Found Trying NEXT\n");
}
}
NdisReleaseSpinLock(&PortSpinLock);
//DbgPrint("NOT Found returning from function\n");
return NULL;
}