//----------------------------------------------------------------------------
//
//  Copyright (C) 2022 Intel Corporation
//
//  File:       WatchdogCommand.cpp 
//
//----------------------------------------------------------------------------

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <process.h>
#include "StatusCodeDefinitions.h"
#include "HECIWin.h"
#include "StatusStrings.h"
#include "HECI_if.h"
#include "WatchdogCommand.h"
#include <iostream>


WatchdogCommand::WatchdogCommand(bool verbose) : WatchdogClient(HECI_WATCHDOG_GUID, verbose)
{
}

WatchdogCommand::~WatchdogCommand(void)
{
}

/*
 * Checks whether the Intel AMT firmware supports the new Intel AMT enabling mechanism and whether Intel AMT is enabled.
 * Arguments:
 *	changeEnabledResponse - pointer to the response message
 * Return values:
 *	PT_STATUS_SUCCESS - on success
 *	PTSDK_STATUS_INTERNAL_ERROR - on failure
 */
AMT_STATUS WatchdogCommand::IsAMTEnablingMechanismSupported(STATE_INDEPENDENCE_IS_CHANGE_ENABLED_RESPONSE* changeEnabledResponse)
{
	AMT_STATUS status = AMT_STATUS_SUCCESS;
	UCHAR command[sizeof(STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_REQUEST)];
	memset(command, 0, sizeof(STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_REQUEST));
	if (memcpy_s(command, ARRAYSIZE(command), &GET_STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_REQUEST, sizeof(GET_STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_REQUEST)))
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}

	UINT8* readBuffer;
	UINT32 command_size = sizeof(STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_REQUEST);
	UINT32 inBuffSize;
	UINT32 outBuffSize = 0;
	STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_RESPONSE* tmp_response = new STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_RESPONSE();
	
	int bytesWritten = 0;

	bytesWritten = WatchdogClient.SendMessage(command, command_size);

	if (bytesWritten != command_size)
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}
	inBuffSize = WatchdogClient.GetBufferSize();
	readBuffer = (UINT8*)malloc(sizeof(UINT8) * inBuffSize);
	if (readBuffer == NULL)
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}
	memset(readBuffer, 0, inBuffSize);

	outBuffSize = WatchdogClient.ReceiveMessage(readBuffer, inBuffSize);

	do
	{
		if (0 == outBuffSize)
		{
			status = AMT_STATUS_INTERNAL_ERROR;
			break;
		}

		STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_RESPONSE* tmp_response = (STATE_INDEPENDENCE_IS_CHANGE_TO_AMT_ENABLED_RESPONSE*)readBuffer;

		if (memcpy_s(changeEnabledResponse, sizeof(STATE_INDEPENDENCE_IS_CHANGE_ENABLED_RESPONSE), &(tmp_response->ChangeEnabledResponse), sizeof(STATE_INDEPENDENCE_IS_CHANGE_ENABLED_RESPONSE)))
		{
			status = AMT_STATUS_INTERNAL_ERROR;
			break;
		}
		if (status != AMT_STATUS_SUCCESS)
		{
			break;
		}

	} while (0);

	if (readBuffer != NULL)
	{
		free(readBuffer);
		readBuffer = NULL;
	}
	return status;
}

/*
 * Sets the AMT operational state to enabled
 * Arguments:
 *	operationalStateResponseStatus - pointer to the response status
 * Return values:
 *	PT_STATUS_SUCCESS - on success
 *	PTSDK_STATUS_INTERNAL_ERROR - on failure
 */
AMT_STATUS WatchdogCommand::SetAMTOperationalState(UINT32* operationalStateResponseStatus)
{
	AMT_STATUS status = AMT_STATUS_SUCCESS;
	UCHAR command[sizeof(MHC_SET_AMT_OPERATIONAL_STATE_REQUEST)];
	memset(command, 0, sizeof(MHC_SET_AMT_OPERATIONAL_STATE_REQUEST));
	if (memcpy_s(command, ARRAYSIZE(command), &GET_SET_AMT_OPERATIONAL_STATE_REQUEST_REQUEST, sizeof(GET_SET_AMT_OPERATIONAL_STATE_REQUEST_REQUEST)))
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}

	UINT8* readBuffer;
	UINT32 command_size = sizeof(MHC_SET_AMT_OPERATIONAL_STATE_REQUEST);
	UINT32 inBuffSize;
	UINT32 outBuffSize = 0;
	MHC_SET_AMT_OPERATIONAL_STATE_RESPONSE* tmp_response;
	
	int bytesWritten = 0;

	bytesWritten = WatchdogClient.SendMessage(command, command_size);

	if (bytesWritten != command_size)
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}
	inBuffSize = WatchdogClient.GetBufferSize();
	readBuffer = (UINT8*)malloc(sizeof(UINT8) * inBuffSize);
	if (readBuffer == NULL)
	{
		return AMT_STATUS_INTERNAL_ERROR;
	}
	memset(readBuffer, 0, inBuffSize);

	outBuffSize = WatchdogClient.ReceiveMessage(readBuffer, inBuffSize);

	do
	{
		if (0 == outBuffSize)
		{
			status = AMT_STATUS_INTERNAL_ERROR;
			break;
		}

		tmp_response = (MHC_SET_AMT_OPERATIONAL_STATE_RESPONSE*)readBuffer;

		if (memcpy_s(operationalStateResponseStatus, sizeof(UINT32), &(tmp_response->Status), sizeof(UINT32)))
		{
			status = AMT_STATUS_INTERNAL_ERROR;
			break;
		}
		if (status != AMT_STATUS_SUCCESS)
		{
			break;
		}

	} while (0);

	if (readBuffer != NULL)
	{
		free(readBuffer);
		readBuffer = NULL;
	}
	return status;
}