mirror of
https://github.com/Ylianst/MeshAgent
synced 2025-12-27 05:33:31 +00:00
400 lines
12 KiB
C
400 lines
12 KiB
C
/*******************************************************************************
|
|
* Copyright (C) 2004-2008 Intel Corp. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* - Neither the name of Intel Corp. nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*******************************************************************************/
|
|
|
|
#ifndef _MINCORE
|
|
|
|
#include <windows.h>
|
|
#include <setupapi.h>
|
|
#include <initguid.h>
|
|
#include <winioctl.h>
|
|
#include "HECIWin.h"
|
|
#include "heci_if.h"
|
|
|
|
#define false 0
|
|
#define true 1
|
|
#define HECI_MAX_LINE_LEN 300
|
|
|
|
DEFINE_GUID(GUID_DEVINTERFACE_HECI, 0xE2D1FF34, 0x3458, 0x49A9, 0x88, 0xDA, 0x8E, 0x69, 0x15, 0xCE, 0x9B, 0xE5);
|
|
DEFINE_GUID(HECI_PTHI_GUID , 0x12F80028, 0xB4B7, 0x4b2d, 0xAC, 0xA8, 0x46, 0xE0, 0xFF, 0x65, 0x81, 0x4c);
|
|
DEFINE_GUID(LME_GUID , 0x6733a4db, 0x0476, 0x4e7b, 0xb3, 0xaf, 0xbc, 0xfc, 0x29, 0xbe, 0xe7, 0xa7);
|
|
|
|
//VOID _displayHECIError(UINT32 errorCode,DWORD lastError);
|
|
//VOID _displayHECIData(UINT32 messageId);
|
|
int heci_doIoctl(struct MEImodule* module, DWORD code, void *inbuf, int inlen, void *outbuf, int outlen);
|
|
|
|
struct MEImodule MEI_global;
|
|
|
|
/***************************** public functions *****************************/
|
|
|
|
unsigned int heci_GetBufferSize(struct MEImodule* module) { if (module != NULL) return module->_bufSize; else return MEI_global._bufSize; }
|
|
unsigned char heci_GetProtocolVersion(struct MEImodule* module) { if (module != NULL) return module->_protocolVersion; else return MEI_global._protocolVersion; }
|
|
bool heci_IsInitialized(struct MEImodule* module) { if (module != NULL) return module->_initialized; else return MEI_global._initialized; }
|
|
|
|
bool heci_GetHeciVersion(struct MEImodule* module, HECI_VERSION *version)
|
|
{
|
|
if (module == NULL) module = &MEI_global;
|
|
|
|
if (module->m_haveHeciVersion)
|
|
{
|
|
memcpy_s(version, sizeof(HECI_VERSION), &(module->m_heciVersion), sizeof(HECI_VERSION));
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool heci_Init(struct MEImodule* module, int client)
|
|
{
|
|
PSP_DEVICE_INTERFACE_DETAIL_DATA deviceDetail = NULL;
|
|
HDEVINFO hDeviceInfo;
|
|
DWORD bufferSize;
|
|
SP_DEVICE_INTERFACE_DATA interfaceData;
|
|
LONG ii = 0;
|
|
int result;
|
|
HECI_CLIENT properties;
|
|
GUID guid;
|
|
|
|
if (client == 0) guid = HECI_PTHI_GUID;
|
|
if (client == 1) guid = LME_GUID;
|
|
if (module == NULL) module = &MEI_global;
|
|
module->_verbose = false;
|
|
|
|
if (module->_initialized) {
|
|
heci_Deinit(module);
|
|
}
|
|
|
|
// Find all devices that have our interface
|
|
hDeviceInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVINTERFACE_HECI, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
|
if (hDeviceInfo == INVALID_HANDLE_VALUE) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(GET_CLASS_DEVS,GetLastError());
|
|
}
|
|
return false; //GET_CLASS_DEVS;
|
|
}
|
|
|
|
// Setup the interface data struct
|
|
interfaceData.cbSize = sizeof(interfaceData);
|
|
for (ii = 0;
|
|
SetupDiEnumDeviceInterfaces(hDeviceInfo, NULL, (LPGUID)&GUID_DEVINTERFACE_HECI, ii, &interfaceData);
|
|
++ii) {
|
|
// Found our device instance
|
|
if (!SetupDiGetDeviceInterfaceDetail(hDeviceInfo, &interfaceData, NULL, 0, &bufferSize, NULL)) {
|
|
DWORD err = GetLastError();
|
|
if (err != ERROR_INSUFFICIENT_BUFFER) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(GET_INTERFACE_DETAIL,err);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// Allocate a big enough buffer to get detail data
|
|
deviceDetail = (PSP_DEVICE_INTERFACE_DETAIL_DATA) malloc(bufferSize);
|
|
if (deviceDetail == NULL) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(ALLOCATE_MEMORY_ERROR,0);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Setup the device interface struct
|
|
deviceDetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
|
|
|
|
// Try again to get the device interface detail info
|
|
if (!SetupDiGetDeviceInterfaceDetail(hDeviceInfo, &interfaceData, deviceDetail, bufferSize, NULL, NULL))
|
|
{
|
|
/*
|
|
if (_verbose)
|
|
{
|
|
DWORD err = GetLastError();
|
|
_displayHECIError(GET_INTERFACE_DETAIL,err);
|
|
}
|
|
*/
|
|
free(deviceDetail);
|
|
deviceDetail = NULL;
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
SetupDiDestroyDeviceInfoList(hDeviceInfo);
|
|
|
|
if (deviceDetail == NULL) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(FIND_HECI_FAILURE,0);
|
|
}
|
|
return false; //FIND_HECI_FAILURE;
|
|
}
|
|
|
|
module->_handle = CreateFile(deviceDetail->DevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
|
|
free(deviceDetail);
|
|
|
|
if (module->_handle == INVALID_HANDLE_VALUE) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(CREATE_HECI_FILE_FAILURE,GetLastError());
|
|
}
|
|
return false; //CREATE_HECI_FILE_FAILURE;
|
|
}
|
|
module->_initialized = true;
|
|
|
|
result = heci_doIoctl(module, (DWORD)IOCTL_HECI_GET_VERSION, NULL, 0, &(module->m_heciVersion), sizeof(HECI_VERSION));
|
|
if (result != sizeof(HECI_VERSION)) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(GET_HECI_DRIVER_VERSION_FAILURE,0);
|
|
}
|
|
heci_Deinit(module);
|
|
return false; //GET_HECI_DRIVER_VERSION_FAILURE;
|
|
}
|
|
module->m_haveHeciVersion = true;
|
|
|
|
if (module->_verbose) {
|
|
//_displayHECIData(HECI_DRIVER_VERSION);
|
|
//_ftprintf(stdout,_T("%d.%d.%d.%d\n"), (m_heciVersion).major, (m_heciVersion).minor, (m_heciVersion).hotfix, (m_heciVersion).build);
|
|
}
|
|
|
|
memset(&properties, 0, sizeof(properties));
|
|
result = heci_doIoctl(module, (DWORD)IOCTL_HECI_CONNECT_CLIENT, (void*)(&guid), sizeof(GUID), &properties, sizeof(properties));
|
|
if (result != sizeof(properties))
|
|
{
|
|
if (module->_verbose) {
|
|
//_displayHECIError(HECI_CONNECT_TO_PTHI_CLIENT_FAILURE,0);
|
|
}
|
|
//Deinit();
|
|
return false; //HECI_CONNECT_TO_PTHI_CLIENT_FAILURE;
|
|
}
|
|
module->_bufSize = properties.MaxMessageLength;
|
|
|
|
return true;
|
|
}
|
|
|
|
void heci_Deinit(struct MEImodule* module)
|
|
{
|
|
if (module == NULL) module = &MEI_global;
|
|
if (module->_initialized == false) return;
|
|
module->_initialized = false;
|
|
module->_bufSize = 0;
|
|
|
|
if (module->_handle != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(module->_handle);
|
|
module->_handle = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
int heci_ReceiveMessage(struct MEImodule* module, unsigned char *buffer, int len, unsigned long timeout) // Timeout default is 2000
|
|
{
|
|
DWORD bytesRead = 0;
|
|
int res;
|
|
HANDLE h_event = NULL;
|
|
OVERLAPPED overlapped;
|
|
DWORD error;
|
|
DWORD eventRes;
|
|
|
|
if (module == NULL) module = &MEI_global;
|
|
if ((h_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == 0) goto out;
|
|
overlapped.hEvent = h_event;
|
|
overlapped.Offset = 0;
|
|
overlapped.OffsetHigh = 0;
|
|
|
|
res = ReadFile(module->_handle, buffer, len, &bytesRead, &overlapped);
|
|
error = GetLastError();
|
|
if ((0 == res) && (ERROR_IO_PENDING != error)) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(READ_FILE,GetLastError());
|
|
}
|
|
bytesRead = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
eventRes = WaitForSingleObject(h_event, timeout);
|
|
if (eventRes == WAIT_TIMEOUT) {
|
|
bytesRead = 0;
|
|
goto out;
|
|
}
|
|
|
|
res = GetOverlappedResult(module->_handle, &overlapped, &bytesRead, true);
|
|
|
|
if (res == 0) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(READ_FILE,GetLastError());
|
|
}
|
|
bytesRead = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
if (h_event != NULL) CloseHandle(h_event);
|
|
if (bytesRead <= 0) heci_Deinit(module);
|
|
|
|
return bytesRead;
|
|
}
|
|
|
|
int heci_SendMessage(struct MEImodule* module, const unsigned char *buffer, int len, unsigned long timeout) // Timeout default is 2000
|
|
{
|
|
DWORD bytesWritten = 0;
|
|
int res;
|
|
HANDLE h_event = NULL;
|
|
OVERLAPPED overlapped;
|
|
DWORD lastError;
|
|
DWORD eventRes;
|
|
|
|
if (module == NULL) module = &MEI_global;
|
|
if ((h_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == 0) goto out;
|
|
overlapped.hEvent = h_event;
|
|
overlapped.Offset = 0;
|
|
overlapped.OffsetHigh = 0;
|
|
|
|
res = WriteFile(module->_handle, buffer, len, &bytesWritten, &overlapped);
|
|
|
|
lastError = GetLastError();
|
|
if ((0 == res) && (ERROR_IO_PENDING !=lastError )) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(WRITE_FILE,GetLastError());
|
|
}
|
|
bytesWritten = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
eventRes = WaitForSingleObject(h_event, timeout);
|
|
if (eventRes == WAIT_TIMEOUT) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(WRITE_FILE_TIME_OUT,0);
|
|
}
|
|
bytesWritten = 0;
|
|
goto out;
|
|
}
|
|
|
|
res = GetOverlappedResult(module->_handle, &overlapped, &bytesWritten, false);
|
|
|
|
if (res == 0) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(WRITE_FILE,GetLastError());
|
|
}
|
|
bytesWritten = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
if (h_event != NULL) CloseHandle(h_event);
|
|
if (bytesWritten <= 0) heci_Deinit(module);
|
|
|
|
return bytesWritten;
|
|
}
|
|
|
|
int heci_doIoctl(struct MEImodule* module, DWORD code, void *inbuf, int inlen, void *outbuf, int outlen)
|
|
{
|
|
int res;
|
|
DWORD bytesRead = 0;
|
|
HANDLE h_event = NULL;
|
|
OVERLAPPED overlapped;
|
|
|
|
if (module == NULL) module = &MEI_global;
|
|
if (!module->_initialized) return -1;
|
|
|
|
if ((h_event = CreateEvent(NULL, FALSE, FALSE, NULL)) == 0) goto out;
|
|
overlapped.hEvent = h_event;
|
|
overlapped.Offset = 0;
|
|
overlapped.OffsetHigh = 0;
|
|
|
|
res = DeviceIoControl(module->_handle, code, inbuf, inlen, outbuf, outlen, &bytesRead, &overlapped);
|
|
|
|
if ((0 == res) && (ERROR_IO_PENDING != GetLastError())) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(IOCTL_COMMAND,GetLastError());
|
|
}
|
|
bytesRead = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
WaitForSingleObject(h_event, INFINITE);
|
|
|
|
res = GetOverlappedResult(module->_handle, &overlapped, &bytesRead, true);
|
|
if (res == 0) {
|
|
if (module->_verbose) {
|
|
//_displayHECIError(IOCTL_COMMAND,GetLastError());
|
|
}
|
|
bytesRead = (DWORD)-1;
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
if (h_event != NULL) CloseHandle(h_event);
|
|
if (bytesRead == (DWORD)-1) heci_Deinit(module);
|
|
|
|
return bytesRead;
|
|
}
|
|
|
|
TCHAR *_getErrMsg(DWORD err)
|
|
{
|
|
static TCHAR buffer[1024];
|
|
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
err,
|
|
0,
|
|
buffer,
|
|
sizeof(buffer) - 1,
|
|
0);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/*
|
|
// Display a HECI error message
|
|
void _displayHECIError(UINT32 errorCode, DWORD lastError)
|
|
{
|
|
TCHAR str[HECI_MAX_LINE_LEN];
|
|
TCHAR *msg;
|
|
LoadString(GetModuleHandle(NULL), HECI_ERROR_MESSAGE, str, sizeof(str)/sizeof(TCHAR));
|
|
_ftprintf(stderr, _T("%s"), str);
|
|
_ftprintf(stderr, _T("%s"), L" ");
|
|
LoadString(GetModuleHandle(NULL), errorCode , str, sizeof(str)/sizeof(TCHAR));
|
|
if(0!= lastError)
|
|
{
|
|
msg = _getErrMsg(lastError);
|
|
_ftprintf(stderr, _T("%s (%d): %s\n"),str, lastError, msg);
|
|
}
|
|
else
|
|
{
|
|
_ftprintf(stderr, _T("%s\n"),str);
|
|
}
|
|
}
|
|
|
|
// Display a HECI data message
|
|
void _displayHECIData(UINT32 messageId)
|
|
{
|
|
TCHAR str[HECI_MAX_LINE_LEN];
|
|
LoadString(GetModuleHandle(NULL), messageId , str, sizeof(str)/sizeof(TCHAR));
|
|
_ftprintf(stdout,_T("%s"),str);
|
|
_ftprintf(stdout,_T("%s"),L" ");
|
|
}
|
|
*/
|
|
|
|
#endif
|