E:/PROJECTS/cvsed/mixed/VIRTUA~1/rpcdispatch/kdcomdisp.h

Go to the documentation of this file.

#pragma once
#include "pipesrv.h"
#include "trassist.h"
#include "PacketLog.h"

#ifdef _DEBUG
static const int KdTraceEnabled = 1;
#else
static const int KdTraceEnabled = 0;
#endif


class KdComDispatcher : public IKdComDispatcher
{
private:
        PipeServer<false, true, true> m_Pipe;

        unsigned KdCompNumberRetries;
        unsigned KdCompRetryCount;

        unsigned KdCompNextPacketIdToSend;
        unsigned KdCompPacketIdExpected;

        bool KD_DEBUGGER_NOT_PRESENT;

        enum {KdMaxBufferSize = 0xFA0};

        //The following members are used in synchronization bug workaround
        enum {KdMinPacketCountForSuccessfulLink = 5};

        unsigned m_PacketsSentFromLastReset;
        unsigned m_PacketsGotFromLastReset;
        
        unsigned m_SequentialResetCount;

        TraceAssistant m_TraceAssistant;

        PacketLogger m_PacketLogger;

public:
        KdComDispatcher(const TCHAR *pszPipeName)
                : m_Pipe(pszPipeName, 1000)
                , m_PacketLogger(pszPipeName)
                , KdCompNumberRetries(0)
                , KdCompRetryCount(10)
                , m_SequentialResetCount(0)
                , m_TraceAssistant(pszPipeName)
        {
                KdResetPacketNumbering(true);
                m_TraceAssistant.ReloadParams();
        }

        void KdResetPacketNumbering(bool InitialSetting)
        {
          KdCompNextPacketIdToSend = InitialSetting ? 0x80800800 : 0x80800000;
      KdCompPacketIdExpected = 0x80800000;
          m_PacketsSentFromLastReset = m_PacketsGotFromLastReset = 0;
        }

        void SetKdDebuggerNotPresent(bool Value)
        {
                KD_DEBUGGER_NOT_PRESENT = Value;
        }

        bool GetKdDebuggerNotPresent()
        {
                return KD_DEBUGGER_NOT_PRESENT;
        }

        void KdpSendControlPacket(ULONG PacketType, ULONG NextPacketId);

        KD_RECV_CODE KdCompReceivePacketLeader(ULONG /*PacketType*/,
                                                                                   ULONG *pSignature,
                                                                                   PKD_CONTEXT pContext);

        unsigned KdpComputeChecksum(const void *pBuffer, unsigned Size)
        {
                unsigned char *p = (unsigned char *)pBuffer;
                unsigned sum = 0;
                for (unsigned i = 0; i < Size; i++)
                        sum += p[i];
                return sum;
        }

        KD_RECV_CODE __stdcall KdReceivePacket(ULONG PacketType,
                                                                                   PKD_BUFFER FirstBuffer,
                                                                                   PKD_BUFFER SecondBuffer,
                                                                                   PULONG PayloadBytes,
                                                                                   PKD_CONTEXT KdContext);

        bool __stdcall  KdSendPacket(ULONG PacketType,
                                                                 PKD_BUFFER FirstBuffer,
                                                                 PKD_BUFFER SecondBuffer,
                                                                 PKD_CONTEXT KdContext);
        
        virtual void ReportProtocolVersionError(int GuestVersion, int HostVersion);


        void SimulateWindowsTermination();

        ~KdComDispatcher()
        {
                SimulateWindowsTermination();
        }
};