/*
 * Copyright 2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "RemoteDebugRequest.h"

#include <stdlib.h>

#include <Message.h>

#include <debugger.h>

#include <AutoDeleter.h>

#include "Architecture.h"
#include "CpuState.h"


// #pragma mark - RemoteDebugRequest


RemoteDebugRequest::RemoteDebugRequest()
        :
        BReferenceable(),
        fArchitecture(NULL)
{
}


RemoteDebugRequest::~RemoteDebugRequest()
{
        if (fArchitecture != NULL)
                fArchitecture->ReleaseReference();
}


status_t
RemoteDebugRequest::LoadFromMessage(const BMessage& data)
{
        if (data.FindInt32("type") != Type())
                return B_BAD_VALUE;

        return LoadSpecificInfoFromMessage(data);
}


status_t
RemoteDebugRequest::SaveToMessage(BMessage& _output) const
{
        _output.MakeEmpty();

        status_t error = _output.AddInt32("type", Type());
        if (error != B_OK)
                return error;

        return SaveSpecificInfoToMessage(_output);
}


void
RemoteDebugRequest::SetArchitecture(Architecture* architecture)
{
        fArchitecture = architecture;
        fArchitecture->AcquireReference();
}


// #pragma mark - RemoteDebugResponse


RemoteDebugResponse::RemoteDebugResponse()
        :
        BReferenceable(),
        fRequest(NULL),
        fResult(B_OK)
{
}


RemoteDebugResponse::~RemoteDebugResponse()
{
        if (fRequest != NULL)
                fRequest->ReleaseReference();
}


void
RemoteDebugResponse::SetRequestInfo(RemoteDebugRequest* request,
        status_t result)
{
        fRequest = request;
        fRequest->AcquireReference();
        fResult = result;
}


status_t
RemoteDebugResponse::LoadFromMessage(const BMessage& data)
{
        if (data.FindInt32("type") != Request()->Type())
                return B_BAD_VALUE;

        if (!Succeeded())
                return B_OK;

        return LoadSpecificInfoFromMessage(data);
}


status_t
RemoteDebugResponse::SaveToMessage(BMessage& _output) const
{
        _output.MakeEmpty();

        status_t error = _output.AddInt32("type", Request()->Type());
        if (error != B_OK)
                return error;

        error = _output.AddInt32("result", Result());
        if (error != B_OK)
                return error;

        if (!Succeeded())
                return B_OK;

        return SaveSpecificInfoToMessage(_output);
}


status_t
RemoteDebugResponse::LoadSpecificInfoFromMessage(const BMessage& data)
{
        return B_OK;
}


status_t
RemoteDebugResponse::SaveSpecificInfoToMessage(BMessage& _output) const
{
        return B_OK;
}


// #pragma mark - RemoteDebugReadMemoryRequest


RemoteDebugReadMemoryRequest::RemoteDebugReadMemoryRequest()
        :
        RemoteDebugRequest(),
        fAddress(0),
        fSize(0)
{
}


RemoteDebugReadMemoryRequest::~RemoteDebugReadMemoryRequest()
{
}


void
RemoteDebugReadMemoryRequest::SetTo(target_addr_t address, target_size_t size)
{
        fAddress = address;
        fSize = size;
}


remote_request_type
RemoteDebugReadMemoryRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_READ_MEMORY;
}


status_t
RemoteDebugReadMemoryRequest::LoadSpecificInfoFromMessage(const BMessage& data)
{
        if (data.FindUInt64("address", &fAddress) != B_OK)
                return B_BAD_VALUE;

        if (data.FindUInt64("size", &fSize) != B_OK)
                return B_BAD_VALUE;

        return B_OK;
}


status_t
RemoteDebugReadMemoryRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        status_t error = _output.AddUInt64("address", fAddress);
        if (error != B_OK)
                return error;

        return _output.AddUInt64("size", fSize);
}


// #pragma mark - RemoteDebugWriteMemoryRequest


RemoteDebugWriteMemoryRequest::RemoteDebugWriteMemoryRequest()
        :
        RemoteDebugRequest(),
        fAddress(0),
        fData(NULL),
        fSize(0)
{
}


RemoteDebugWriteMemoryRequest::~RemoteDebugWriteMemoryRequest()
{
        if (fData != NULL)
                free(fData);
}


status_t
RemoteDebugWriteMemoryRequest::SetTo(target_addr_t address, const void* data,
        target_size_t size)
{
        if (size == 0 || data == NULL)
                return B_BAD_VALUE;

        fAddress = address;
        fSize = size;
        fData = malloc(fSize);
        if (fData == NULL)
                return B_NO_MEMORY;


        memcpy(fData, data, fSize);
        return B_OK;
}


remote_request_type
RemoteDebugWriteMemoryRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_WRITE_MEMORY;
}


status_t
RemoteDebugWriteMemoryRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (data.FindUInt64("address", &fAddress) != B_OK)
                return B_BAD_VALUE;

        if (data.FindUInt64("size", &fSize) != B_OK)
                return B_BAD_VALUE;

        fData = malloc(fSize);
        if (fData == NULL)
                return B_NO_MEMORY;

        const void* messageData = NULL;
        ssize_t numBytes = -1;
        status_t error = data.FindData("data", B_RAW_TYPE, &messageData,
                &numBytes);
        if (error != B_OK)
                return error;

        if ((size_t)numBytes != fSize)
                return B_MISMATCHED_VALUES;

        memcpy(fData, messageData, numBytes);

        return B_OK;
}


status_t
RemoteDebugWriteMemoryRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        status_t error = _output.AddUInt64("address", fAddress);
        if (error != B_OK)
                return error;

        error = _output.AddUInt64("size", fSize);
        if (error != B_OK)
                return error;

        return _output.AddData("data", B_RAW_TYPE, fData, (ssize_t)fSize);
}


// #pragma mark - RemoteDebugSetTeamFlagsRequest


RemoteDebugSetTeamFlagsRequest::RemoteDebugSetTeamFlagsRequest()
        :
        RemoteDebugRequest(),
        fFlags(0)
{
}


RemoteDebugSetTeamFlagsRequest::~RemoteDebugSetTeamFlagsRequest()
{
}


void
RemoteDebugSetTeamFlagsRequest::SetTo(int32 flags)
{
        fFlags = flags;
}


remote_request_type
RemoteDebugSetTeamFlagsRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_SET_TEAM_FLAGS;
}


status_t
RemoteDebugSetTeamFlagsRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (data.FindInt32("flags", &fFlags) != B_OK)
                return B_BAD_VALUE;

        return B_OK;
}


status_t
RemoteDebugSetTeamFlagsRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        return _output.AddInt32("flags", fFlags);
}


// #pragma mark - RemoteDebugSetThreadFlagsRequest


RemoteDebugSetThreadFlagsRequest::RemoteDebugSetThreadFlagsRequest()
        :
        RemoteDebugRequest(),
        fThread(-1),
        fFlags(0)
{
}


RemoteDebugSetThreadFlagsRequest::~RemoteDebugSetThreadFlagsRequest()
{
}


void
RemoteDebugSetThreadFlagsRequest::SetTo(thread_id thread, int32 flags)
{
        fThread = thread;
        fFlags = flags;
}


remote_request_type
RemoteDebugSetThreadFlagsRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_SET_THREAD_FLAGS;
}


status_t
RemoteDebugSetThreadFlagsRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (data.FindInt32("thread", &fThread) != B_OK)
                return B_BAD_VALUE;

        if (data.FindInt32("flags", &fFlags) != B_OK)
                return B_BAD_VALUE;

        return B_OK;
}


status_t
RemoteDebugSetThreadFlagsRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        status_t error = _output.AddInt32("thread", fThread);
        if (error != B_OK)
                return error;

        return _output.AddInt32("flags", fFlags);
}


// #pragma mark - RemoteDebugThreadActionRequest


RemoteDebugThreadActionRequest::RemoteDebugThreadActionRequest()
        :
        RemoteDebugRequest(),
        fThread(-1)
{
}


RemoteDebugThreadActionRequest::~RemoteDebugThreadActionRequest()
{
}


void
RemoteDebugThreadActionRequest::SetTo(thread_id thread)
{
        fThread = thread;
}


status_t
RemoteDebugThreadActionRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (data.FindInt32("thread", &fThread) != B_OK)
                return B_BAD_VALUE;

        return B_OK;
}


status_t
RemoteDebugThreadActionRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        return _output.AddInt32("thread", fThread);
}


// #pragma mark - RemoteDebugContinueThreadRequest


RemoteDebugContinueThreadRequest::RemoteDebugContinueThreadRequest()
        :
        RemoteDebugThreadActionRequest()
{
}


RemoteDebugContinueThreadRequest::~RemoteDebugContinueThreadRequest()
{
}

remote_request_type
RemoteDebugContinueThreadRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_CONTINUE_THREAD;
}


// #pragma mark - RemoteDebugStopThreadRequest


RemoteDebugStopThreadRequest::RemoteDebugStopThreadRequest()
        :
        RemoteDebugThreadActionRequest()
{
}


RemoteDebugStopThreadRequest::~RemoteDebugStopThreadRequest()
{
}

remote_request_type
RemoteDebugStopThreadRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_STOP_THREAD;
}


// #pragma mark - RemoteDebugSingleStepThreadRequest


RemoteDebugSingleStepThreadRequest::RemoteDebugSingleStepThreadRequest()
        :
        RemoteDebugThreadActionRequest()
{
}


RemoteDebugSingleStepThreadRequest::~RemoteDebugSingleStepThreadRequest()
{
}

remote_request_type
RemoteDebugSingleStepThreadRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_SINGLE_STEP_THREAD;
}


// #pragma mark - RemoteDebugGetCpuStateRequest


RemoteDebugGetCpuStateRequest::RemoteDebugGetCpuStateRequest()
        :
        RemoteDebugThreadActionRequest()
{
}


RemoteDebugGetCpuStateRequest::~RemoteDebugGetCpuStateRequest()
{
}


remote_request_type
RemoteDebugGetCpuStateRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_GET_CPU_STATE;
}


// #pragma mark - RemoteDebugSetCpuStateRequest


RemoteDebugSetCpuStateRequest::RemoteDebugSetCpuStateRequest()
        :
        RemoteDebugRequest(),
        fThread(-1),
        fCpuState(NULL)
{
}


RemoteDebugSetCpuStateRequest::~RemoteDebugSetCpuStateRequest()
{
        if (fCpuState != NULL)
                fCpuState->ReleaseReference();
}


void
RemoteDebugSetCpuStateRequest::SetTo(thread_id thread, CpuState* state)
{
        fThread = thread;
        fCpuState = state;
        if (fCpuState != NULL)
                fCpuState->AcquireReference();
}


remote_request_type
RemoteDebugSetCpuStateRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_SET_CPU_STATE;
}


status_t
RemoteDebugSetCpuStateRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (data.FindInt32("thread", &fThread) != B_OK)
                return B_BAD_VALUE;

        if (fCpuState != NULL) {
                fCpuState->ReleaseReference();
                fCpuState = NULL;
        }

        const uint8* buffer = NULL;
        ssize_t numBytes = 0;
        size_t stateSize = GetArchitecture()->DebugCpuStateSize();
        status_t error = data.FindData("state", B_RAW_TYPE, (const void**)&buffer,
                &numBytes);
        if (error != B_OK || (size_t)numBytes != stateSize)
                return B_BAD_VALUE;

        return GetArchitecture()->CreateCpuState(buffer, stateSize, fCpuState);
}


status_t
RemoteDebugSetCpuStateRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        status_t error = _output.AddInt32("thread", fThread);
        if (error != B_OK)
                return error;

        size_t stateSize = GetArchitecture()->DebugCpuStateSize();
        uint8* buffer = new(std::nothrow) uint8[stateSize];
        if (buffer == NULL)
                return B_NO_MEMORY;

        ArrayDeleter<uint8> deleter(buffer);
        error = fCpuState->UpdateDebugState(buffer, stateSize);
        if (error != B_OK)
                return error;

        return _output.AddData("state", B_RAW_TYPE, buffer, (ssize_t)stateSize);
}


// #pragma mark - RemoteDebugAddressActionRequest


RemoteDebugAddressActionRequest::RemoteDebugAddressActionRequest()
        :
        RemoteDebugRequest(),
        fAddress(0)
{
}


RemoteDebugAddressActionRequest::~RemoteDebugAddressActionRequest()
{
}


void
RemoteDebugAddressActionRequest::SetTo(target_addr_t address)
{
        fAddress = address;
}


status_t
RemoteDebugAddressActionRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        return data.FindUInt64("address", &fAddress);
}


status_t
RemoteDebugAddressActionRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        return _output.AddUInt64("address", fAddress);
}


// #pragma mark - RemoteDebugInstallBreakpointRequest


RemoteDebugInstallBreakpointRequest::RemoteDebugInstallBreakpointRequest()
        :
        RemoteDebugAddressActionRequest()
{
}


RemoteDebugInstallBreakpointRequest::~RemoteDebugInstallBreakpointRequest()
{
}


remote_request_type
RemoteDebugInstallBreakpointRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_INSTALL_BREAKPOINT;
}


// #pragma mark - RemoteDebugUninstallBreakpointRequest


RemoteDebugUninstallBreakpointRequest::RemoteDebugUninstallBreakpointRequest()
        :
        RemoteDebugAddressActionRequest()
{
}


RemoteDebugUninstallBreakpointRequest::~RemoteDebugUninstallBreakpointRequest()
{
}

remote_request_type
RemoteDebugUninstallBreakpointRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_UNINSTALL_BREAKPOINT;
}


// #pragma mark - RemoteDebugInstallWatchpointRequest


RemoteDebugInstallWatchpointRequest::RemoteDebugInstallWatchpointRequest()
        :
        RemoteDebugRequest(),
        fAddress(0),
        fWatchType(B_DATA_READ_WATCHPOINT),
        fLength(0)
{
}


RemoteDebugInstallWatchpointRequest::~RemoteDebugInstallWatchpointRequest()
{
}


void
RemoteDebugInstallWatchpointRequest::SetTo(target_addr_t address, uint32 type,
        int32 length)
{
        fAddress = address;
        fWatchType = type;
        fLength = length;
}


remote_request_type
RemoteDebugInstallWatchpointRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_INSTALL_WATCHPOINT;
}


status_t
RemoteDebugInstallWatchpointRequest::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        status_t error = data.FindUInt64("address", &fAddress);
        if (error != B_OK)
                return error;

        error = data.FindUInt32("watchtype", &fWatchType);
        if (error != B_OK)
                return error;

        return data.FindInt32("length", &fLength);
}


status_t
RemoteDebugInstallWatchpointRequest::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        status_t error = _output.AddUInt64("address", fAddress);
        if (error != B_OK)
                return error;

        error = _output.AddUInt32("watchtype", fWatchType);
        if (error != B_OK)
                return error;

        return _output.AddInt32("length", fLength);
}


// #pragma mark - RemoteDebugUninstallWatchpointRequest


RemoteDebugUninstallWatchpointRequest::RemoteDebugUninstallWatchpointRequest()
        :
        RemoteDebugAddressActionRequest()
{
}


RemoteDebugUninstallWatchpointRequest::~RemoteDebugUninstallWatchpointRequest()
{
}


remote_request_type
RemoteDebugUninstallWatchpointRequest::Type() const
{
        return REMOTE_REQUEST_TYPE_UNINSTALL_WATCHPOINT;
}


// #pragma mark - RemoteDebugReadMemoryResponse


RemoteDebugReadMemoryResponse::RemoteDebugReadMemoryResponse()
        :
        RemoteDebugResponse(),
        fData(NULL),
        fSize(0)
{
}


RemoteDebugReadMemoryResponse::~RemoteDebugReadMemoryResponse()
{
        if (fData != NULL)
                free(fData);
}


void
RemoteDebugReadMemoryResponse::SetTo(void* data, target_size_t size)
{
        fData = data;
        fSize = size;
}


status_t
RemoteDebugReadMemoryResponse::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        status_t error = data.FindUInt64("size", &fSize);
        if (error != B_OK)
                return error;

        fData = malloc(fSize);
        if (fData == NULL)
                return B_NO_MEMORY;

        const void* messageData = NULL;
        ssize_t numBytes = -1;
        error = data.FindData("data", B_RAW_TYPE, &messageData, &numBytes);
        if (error != B_OK)
                return error;

        if ((size_t)numBytes != fSize)
                return B_MISMATCHED_VALUES;

        memcpy(fData, messageData, numBytes);
        return B_OK;
}


status_t
RemoteDebugReadMemoryResponse::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        if (fData == NULL)
                return B_OK;

        status_t error = _output.AddUInt64("size", fSize);
        if (error != B_OK)
                return error;

        return _output.AddData("data", B_RAW_TYPE, fData, (ssize_t)fSize);
}


// #pragma mark - RemoteDebugGetCpuStateResponse


RemoteDebugGetCpuStateResponse::RemoteDebugGetCpuStateResponse()
        :
        RemoteDebugResponse(),
        fCpuState(NULL)
{
}


RemoteDebugGetCpuStateResponse::~RemoteDebugGetCpuStateResponse()
{
        if (fCpuState != NULL)
                fCpuState->ReleaseReference();
}


void
RemoteDebugGetCpuStateResponse::SetTo(CpuState* state)
{
        fCpuState = state;
        if (fCpuState != NULL)
                fCpuState->AcquireReference();
}


status_t
RemoteDebugGetCpuStateResponse::LoadSpecificInfoFromMessage(
        const BMessage& data)
{
        if (fCpuState != NULL) {
                fCpuState->ReleaseReference();
                fCpuState = NULL;
        }

        const uint8* buffer = NULL;
        ssize_t numBytes = 0;
        size_t stateSize = GetArchitecture()->DebugCpuStateSize();
        status_t error = data.FindData("state", B_RAW_TYPE, (const void**)&buffer,
                &numBytes);
        if (error != B_OK || (size_t)numBytes != stateSize)
                return B_BAD_VALUE;

        return GetArchitecture()->CreateCpuState(buffer, stateSize, fCpuState);
}


status_t
RemoteDebugGetCpuStateResponse::SaveSpecificInfoToMessage(
        BMessage& _output) const
{
        size_t stateSize = GetArchitecture()->DebugCpuStateSize();
        uint8* buffer = new(std::nothrow) uint8[stateSize];
        if (buffer == NULL)
                return B_NO_MEMORY;

        ArrayDeleter<uint8> deleter(buffer);
        status_t error = fCpuState->UpdateDebugState(buffer, stateSize);
        if (error != B_OK)
                return error;

        return _output.AddData("state", B_RAW_TYPE, buffer, (ssize_t)stateSize);
}