/*++

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