#include "kdgdb.h"

Include dependency graph for kdpacket.c:

Functions
static BOOLEAN	FirstSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

static BOOLEAN	GetContextSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

static KDSTATUS	GetContextManipulateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

static BOOLEAN	SetContextSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

KDSTATUS	SetContextManipulateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

static void	send_kd_state_change (DBGKD_ANY_WAIT_STATE_CHANGE *StateChange)

static void	send_kd_debug_io (_In_ DBGKD_DEBUG_IO *DebugIO, _In_ PSTRING String)

static void	send_kd_state_manipulate (_In_ DBGKD_MANIPULATE_STATE64 *State, _In_ PSTRING MessageData)

KDSTATUS	ContinueManipulateStateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

static BOOLEAN	GetVersionSendHandler (_In_ ULONG PacketType, _In_ PSTRING MessageHeader, _In_ PSTRING MessageData)

static KDSTATUS	GetVersionManipulateStateHandler (_Out_ DBGKD_MANIPULATE_STATE64 *State, _Out_ PSTRING MessageData, _Out_ PULONG MessageLength, _Inout_ PKD_CONTEXT KdContext)

KDSTATUS NTAPI	KdReceivePacket (_In_ ULONG PacketType, _Out_ PSTRING MessageHeader, _Out_ PSTRING MessageData, _Out_ PULONG DataLength, _Inout_ PKD_CONTEXT KdContext)

VOID NTAPI	KdSendPacket (IN ULONG PacketType, IN PSTRING MessageHeader, IN PSTRING MessageData, IN OUT PKD_CONTEXT KdContext)

Function Documentation

◆ ContinueManipulateStateHandler()

KDSTATUS ContinueManipulateStateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 213 of file kdpacket.c.

{
    /* Let's go on */
    State->ApiNumber = DbgKdContinueApi;
    State->ReturnStatus = STATUS_SUCCESS; /* ? */
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    if (MessageData)
        MessageData->Length = 0;
    *MessageLength = 0;
    State->u.Continue.ContinueStatus = STATUS_SUCCESS;
 
    /* We definitely are at the end of the send <-> receive loop, if any */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = NULL;
    /* We're not handling an exception anymore */
    InException = FALSE;
 
    return KdPacketReceived;
}

Referenced by handle_gdb_c(), and handle_gdb_s().

◆ FirstSendHandler()

static BOOLEAN FirstSendHandler	(	_In_ ULONG	PacketType,
		_In_ PSTRING	MessageHeader,
		_In_ PSTRING	MessageData
	)

static

Definition at line 293 of file kdpacket.c.

{
    DBGKD_ANY_WAIT_STATE_CHANGE* StateChange = (DBGKD_ANY_WAIT_STATE_CHANGE*)MessageHeader->Buffer;
    PETHREAD Thread;
 
    if (PacketType != PACKET_TYPE_KD_STATE_CHANGE64)
    {
        KDDBGPRINT("First KD packet is not a state change!\n");
        return FALSE;
    }
 
    KDDBGPRINT("KDGDB: START!\n");
 
    Thread = (PETHREAD)(ULONG_PTR)StateChange->Thread;
 
    /* Set up the current state */
    CurrentStateChange = *StateChange;
    gdb_dbg_tid = handle_to_gdb_tid(PsGetThreadId(Thread));
#if MONOPROCESS
    gdb_dbg_pid = 0;
#else
    gdb_dbg_pid = handle_to_gdb_pid(PsGetThreadProcessId(Thread));
#endif
    /* This is the idle process. Save it! */
    TheIdleThread = Thread;
    TheIdleProcess = (PEPROCESS)Thread->Tcb.ApcState.Process;
 
    KDDBGPRINT("Pid Tid of the first message: %" PRIxPTR", %" PRIxPTR ".\n", gdb_dbg_pid, gdb_dbg_tid);
 
    /* The next receive call will be asking for the version data */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = GetVersionManipulateStateHandler;
    return TRUE;
}

◆ GetContextManipulateHandler()

static KDSTATUS GetContextManipulateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

static

Definition at line 62 of file kdpacket.c.

{
    State->ApiNumber = DbgKdGetContextApi;
    State->Processor = CurrentStateChange.Processor;
    State->ReturnStatus = STATUS_SUCCESS;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    MessageData->Length = 0;
 
    /* Update the send <-> receive loop handler */
    KdpSendPacketHandler = GetContextSendHandler;
    KdpManipulateStateHandler = NULL;
 
    return KdPacketReceived;
}

Referenced by GetVersionSendHandler(), and send_kd_state_change().

◆ GetContextSendHandler()

static BOOLEAN GetContextSendHandler	(	_In_ ULONG	PacketType,
		_In_ PSTRING	MessageHeader,
		_In_ PSTRING	MessageData
	)

static

Definition at line 37 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
    const CONTEXT* Context = (const CONTEXT*)MessageData->Buffer;
 
    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdGetContextApi)
            || (MessageData->Length < sizeof(*Context)))
    {
        KDDBGPRINT("ERROR: Received wrong packet from KD.\n");
        return FALSE;
    }
 
    /* Just copy it */
    RtlCopyMemory(&CurrentContext, Context, sizeof(*Context));
    KdpSendPacketHandler = NULL;
    return TRUE;
}

Referenced by GetContextManipulateHandler().

◆ GetVersionManipulateStateHandler()

static KDSTATUS GetVersionManipulateStateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

static

Definition at line 273 of file kdpacket.c.

{
    /* Ask for the version data */
    State->ApiNumber = DbgKdGetVersionApi;
    State->Processor = CurrentStateChange.Processor;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
 
    /* The next send call will serve this query */
    KdpSendPacketHandler = GetVersionSendHandler;
    KdpManipulateStateHandler = NULL;
 
    return KdPacketReceived;
}

Referenced by FirstSendHandler().

◆ GetVersionSendHandler()

static BOOLEAN GetVersionSendHandler	(	_In_ ULONG	PacketType,
		_In_ PSTRING	MessageHeader,
		_In_ PSTRING	MessageData
	)

static

Definition at line 241 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
    PLIST_ENTRY DebuggerDataList;
 
    /* Confirm that all went well */
    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdGetVersionApi)
            || !NT_SUCCESS(State->ReturnStatus))
    {
        KDDBGPRINT("Wrong packet received after asking for data.\n");
        return FALSE;
    }
 
    /* Copy the relevant data */
    RtlCopyMemory(&KdVersion, &State->u.GetVersion64, sizeof(KdVersion));
    DebuggerDataList = *(PLIST_ENTRY*)&KdVersion.DebuggerDataList;
    KdDebuggerDataBlock = CONTAINING_RECORD(DebuggerDataList->Flink, KDDEBUGGER_DATA64, Header.List);
    ProcessListHead = *(PLIST_ENTRY*)&KdDebuggerDataBlock->PsActiveProcessHead;
    ModuleListHead = *(PLIST_ENTRY*)&KdDebuggerDataBlock->PsLoadedModuleList;
 
    /* Now we can get the context for the current state */
    KdpSendPacketHandler = NULL;
    KdpManipulateStateHandler = GetContextManipulateHandler;
    return TRUE;
}

Referenced by GetVersionManipulateStateHandler().

◆ KdReceivePacket()

KDSTATUS NTAPI KdReceivePacket	(	_In_ ULONG	PacketType,
		_Out_ PSTRING	MessageHeader,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	DataLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 350 of file kdpacket.c.

{
    KDDBGPRINT("KdReceivePacket --> ");
 
    if (PacketType == PACKET_TYPE_KD_POLL_BREAKIN)
    {
        static BOOLEAN firstTime = TRUE;
        KDDBGPRINT("Polling break in.\n");
        if (firstTime)
        {
            /* Force debug break on init */
            firstTime = FALSE;
            return KdPacketReceived;
        }
 
        return KdpPollBreakIn();
    }
 
    if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
    {
        static BOOLEAN ignore = 0;
        KDDBGPRINT("Debug prompt.\n");
        /* HACK ! Debug prompt asks for break or ignore. First break, then ignore. */
        MessageData->Length = 1;
        MessageData->Buffer[0] = ignore ? 'i' : 'b';
        ignore = !ignore;
        return KdPacketReceived;
    }
 
    if (PacketType == PACKET_TYPE_KD_STATE_MANIPULATE)
    {
        DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
 
        KDDBGPRINT("State manipulation: ");
 
        /* Maybe we are in a send<->receive loop that GDB doesn't need to know about */
        if (KdpManipulateStateHandler != NULL)
        {
            KDDBGPRINT("We have a manipulate state handler.\n");
            return KdpManipulateStateHandler(State, MessageData, DataLength, KdContext);
        }
 
        /* Receive data from GDB  and interpret it */
        KDDBGPRINT("Receiving data from GDB.\n");
        return gdb_receive_and_interpret_packet(State, MessageData, DataLength, KdContext);
    }
 
    /* What should we do ? */
    while (1);
    return KdPacketNeedsResend;
}

◆ KdSendPacket()

VOID NTAPI KdSendPacket	(	IN ULONG	PacketType,
		IN PSTRING	MessageHeader,
		IN PSTRING	MessageData,
		IN OUT PKD_CONTEXT	KdContext
	)

Definition at line 409 of file kdpacket.c.

{
    /* Override if we have some debug print from KD. */
    if (PacketType == PACKET_TYPE_KD_DEBUG_IO)
    {
        send_kd_debug_io((DBGKD_DEBUG_IO*)MessageHeader->Buffer, MessageData);
        return;
    }
 
    /* Maybe we are in a send <-> receive loop that GDB doesn't need to know about */
    if (KdpSendPacketHandler
        && KdpSendPacketHandler(PacketType, MessageHeader, MessageData))
    {
        return;
    }
 
    switch (PacketType)
    {
    case PACKET_TYPE_KD_STATE_CHANGE64:
        send_kd_state_change((DBGKD_ANY_WAIT_STATE_CHANGE*)MessageHeader->Buffer);
        return;
    case PACKET_TYPE_KD_DEBUG_IO:
        send_kd_debug_io((DBGKD_DEBUG_IO*)MessageHeader->Buffer, MessageData);
        break;
    case PACKET_TYPE_KD_STATE_MANIPULATE:
        send_kd_state_manipulate((DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer, MessageData);
        break;
    default:
        KDDBGPRINT("Unknown packet type %u.\n", PacketType);
        while (1);
    }
}

◆ send_kd_debug_io()

static void send_kd_debug_io	(	_In_ DBGKD_DEBUG_IO *	DebugIO,
		_In_ PSTRING	String
	)

static

Definition at line 173 of file kdpacket.c.

{
    if (InException)
        return;
 
    switch (DebugIO->ApiNumber)
    {
    case DbgKdPrintStringApi:
    case DbgKdGetStringApi:
        gdb_send_debug_io(String, TRUE);
        break;
    default:
        KDDBGPRINT("Unknown ApiNumber %u.\n", DebugIO->ApiNumber);
        while (1);
    }
}

Referenced by KdSendPacket().

◆ send_kd_state_change()

static void send_kd_state_change ( DBGKD_ANY_WAIT_STATE_CHANGE * StateChange )

static

Definition at line 137 of file kdpacket.c.

{
    InException = TRUE;
 
    switch (StateChange->NewState)
    {
    case DbgKdLoadSymbolsStateChange:
    case DbgKdExceptionStateChange:
    {
        PETHREAD Thread = (PETHREAD)(ULONG_PTR)StateChange->Thread;
        /* Save current state for later GDB queries */
        CurrentStateChange = *StateChange;
        KDDBGPRINT("Exception 0x%08x in thread p%p.%p.\n",
            StateChange->u.Exception.ExceptionRecord.ExceptionCode,
            PsGetThreadProcessId(Thread),
            PsGetThreadId(Thread));
        /* Set the current debugged process/thread accordingly */
        gdb_dbg_tid = handle_to_gdb_tid(PsGetThreadId(Thread));
#if MONOPROCESS
        gdb_dbg_pid = 0;
#else
        gdb_dbg_pid = handle_to_gdb_pid(PsGetThreadProcessId(Thread));
#endif
        gdb_send_exception();
        /* Next receive call will ask for the context */
        KdpManipulateStateHandler = GetContextManipulateHandler;
        break;
    }
    default:
        KDDBGPRINT("Unknown StateChange %u.\n", StateChange->NewState);
        while (1);
    }
}

Referenced by KdSendPacket().

◆ send_kd_state_manipulate()

static void send_kd_state_manipulate	(	_In_ DBGKD_MANIPULATE_STATE64 *	State,
		_In_ PSTRING	MessageData
	)

static

Definition at line 194 of file kdpacket.c.

{
    switch (State->ApiNumber)
    {
#if 0
    case DbgKdGetContextApi:
        /* This is an answer to a 'g' GDB request */
        gdb_send_registers((CONTEXT*)MessageData->Buffer);
        return;
#endif
    default:
        KDDBGPRINT("Unknown ApiNumber %u.\n", State->ApiNumber);
        while (1);
    }
}

Referenced by KdSendPacket().

◆ SetContextManipulateHandler()

KDSTATUS SetContextManipulateHandler	(	_Out_ DBGKD_MANIPULATE_STATE64 *	State,
		_Out_ PSTRING	MessageData,
		_Out_ PULONG	MessageLength,
		_Inout_ PKD_CONTEXT	KdContext
	)

Definition at line 107 of file kdpacket.c.

{
    State->ApiNumber = DbgKdSetContextApi;
    State->Processor = CurrentStateChange.Processor;
    State->ReturnStatus = STATUS_SUCCESS;
    State->ProcessorLevel = CurrentStateChange.ProcessorLevel;
    MessageData->Length = sizeof(CurrentContext);
 
    if (MessageData->MaximumLength < sizeof(CurrentContext))
    {
        KDDBGPRINT("Wrong message length %u.\n", MessageData->MaximumLength);
        while (1);
    }
 
    RtlCopyMemory(MessageData->Buffer, &CurrentContext, sizeof(CurrentContext));
 
    /* Update the send <-> receive loop handlers */
    KdpSendPacketHandler = SetContextSendHandler;
    KdpManipulateStateHandler = NULL;
 
    return KdPacketReceived;
}

Referenced by handle_gdb_c(), and handle_gdb_s().

◆ SetContextSendHandler()

static BOOLEAN SetContextSendHandler	(	_In_ ULONG	PacketType,
		_In_ PSTRING	MessageHeader,
		_In_ PSTRING	MessageData
	)

static

Definition at line 84 of file kdpacket.c.

{
    DBGKD_MANIPULATE_STATE64* State = (DBGKD_MANIPULATE_STATE64*)MessageHeader->Buffer;
 
    /* We just confirm that all went well */
    if ((PacketType != PACKET_TYPE_KD_STATE_MANIPULATE)
            || (State->ApiNumber != DbgKdSetContextApi)
            || (State->ReturnStatus != STATUS_SUCCESS))
    {
        /* Should we bugcheck ? */
        KDDBGPRINT("BAD BAD BAD not manipulating state for sending context.\n");
        return FALSE;
    }
 
    KdpSendPacketHandler = NULL;
    return TRUE;
}

Referenced by SetContextManipulateHandler().

Variable Documentation

◆ CurrentContext

CONTEXT CurrentContext

Definition at line 29 of file kdpacket.c.

Referenced by gdb_send_register(), gdb_send_registers(), GetContextSendHandler(), handle_gdb_c(), handle_gdb_s(), and SetContextManipulateHandler().

◆ CurrentStateChange

DBGKD_ANY_WAIT_STATE_CHANGE CurrentStateChange

Definition at line 28 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), find_thread(), FirstSendHandler(), gdb_send_exception(), gdb_send_register(), gdb_send_registers(), GetContextManipulateHandler(), GetVersionManipulateStateHandler(), handle_gdb_c(), handle_gdb_insert_breakpoint(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_remove_breakpoint(), handle_gdb_write_mem(), send_kd_state_change(), and SetContextManipulateHandler().

◆ InException

BOOLEAN InException = FALSE

static

Definition at line 17 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), send_kd_debug_io(), and send_kd_state_change().

◆ KdDebuggerDataBlock

KDDEBUGGER_DATA64* KdDebuggerDataBlock

Definition at line 21 of file kdpacket.c.

Referenced by GetVersionSendHandler().

◆ KdpManipulateStateHandler

KDP_MANIPULATESTATE_HANDLER KdpManipulateStateHandler = NULL

Definition at line 26 of file kdpacket.c.

Referenced by ContinueManipulateStateHandler(), FirstSendHandler(), GetContextManipulateHandler(), GetVersionManipulateStateHandler(), GetVersionSendHandler(), handle_gdb_c(), handle_gdb_s(), KdReceivePacket(), ReadMemorySendHandler(), RestoreBreakPointSendHandler(), send_kd_state_change(), SetContextManipulateHandler(), WriteBreakPointSendHandler(), and WriteMemorySendHandler().

◆ KdpSendPacketHandler

◆ KdVersion

DBGKD_GET_VERSION64 KdVersion

Definition at line 20 of file kdpacket.c.

Referenced by GetVersionSendHandler().

◆ ModuleListHead

LIST_ENTRY* ModuleListHead

Definition at line 23 of file kdpacket.c.

Referenced by GetModuleFileNameW(), GetVersionSendHandler(), handle_gdb_query(), LdrQueryProcessModuleInformationEx(), MmCallDllInitialize(), PeLdrAllocateDataTableEntry(), PeLdrCheckForLoadedDll(), PeLdrpBindImportName(), PeLdrpLoadAndScanReferencedDll(), PeLdrpScanImportAddressTable(), PeLdrScanImportDescriptorTable(), RtlPcToFileHeader(), and UserpGetClientFileName().

◆ ProcessListHead

LIST_ENTRY* ProcessListHead

Definition at line 22 of file kdpacket.c.

Referenced by find_process(), find_thread(), GetVersionSendHandler(), handle_gdb_query(), handle_gdb_read_mem(), handle_gdb_write_mem(), ReadMemorySendHandler(), and WriteMemorySendHandler().

◆ TheIdleProcess

PEPROCESS TheIdleProcess

Definition at line 30 of file kdpacket.c.

Referenced by find_process(), find_thread(), FirstSendHandler(), and QSI_DEF().

◆ TheIdleThread

PETHREAD TheIdleThread

Definition at line 31 of file kdpacket.c.

Referenced by find_thread(), and FirstSendHandler().

Variables
static BOOLEAN	InException = FALSE

DBGKD_GET_VERSION64	KdVersion

KDDEBUGGER_DATA64 *	KdDebuggerDataBlock

LIST_ENTRY *	ProcessListHead

LIST_ENTRY *	ModuleListHead

KDP_SEND_HANDLER	KdpSendPacketHandler = FirstSendHandler

KDP_MANIPULATESTATE_HANDLER	KdpManipulateStateHandler = NULL

DBGKD_ANY_WAIT_STATE_CHANGE	CurrentStateChange

CONTEXT	CurrentContext

PEPROCESS	TheIdleProcess

PETHREAD	TheIdleThread

Functions

Variables

Function Documentation

◆ ContinueManipulateStateHandler()

◆ FirstSendHandler()

◆ GetContextManipulateHandler()

◆ GetContextSendHandler()

◆ GetVersionManipulateStateHandler()

◆ GetVersionSendHandler()

◆ KdReceivePacket()

◆ KdSendPacket()

◆ send_kd_debug_io()

◆ send_kd_state_change()

◆ send_kd_state_manipulate()

◆ SetContextManipulateHandler()

◆ SetContextSendHandler()

Variable Documentation

◆ CurrentContext

◆ CurrentStateChange

◆ InException

◆ KdDebuggerDataBlock

◆ KdpManipulateStateHandler

◆ KdpSendPacketHandler

◆ KdVersion

◆ ModuleListHead

◆ ProcessListHead

◆ TheIdleProcess

◆ TheIdleThread