2022-07-26 05:52:12 +00:00
|
|
|
|
#include "HGNamedPipe.h"
|
|
|
|
|
#include "HGInc.h"
|
2022-08-10 02:22:13 +00:00
|
|
|
|
#include "HGThread.h"
|
2022-07-27 02:18:44 +00:00
|
|
|
|
#include <string>
|
2022-07-26 05:52:12 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
struct HGNamedPipeServerImpl
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeServerImpl()
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
m_hConnectEvent = NULL;
|
|
|
|
|
m_hWriteEvent = NULL;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
m_hReadEvent = NULL;
|
|
|
|
|
m_hProcessEvent = NULL;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
m_hPipe = INVALID_HANDLE_VALUE;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
m_clientPid = 0;
|
|
|
|
|
m_thread = NULL;
|
|
|
|
|
m_error = HGFALSE;
|
|
|
|
|
m_break = HGFALSE;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
~HGNamedPipeServerImpl()
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGBase_CloseThread(m_thread);
|
|
|
|
|
m_thread = NULL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(m_hPipe);
|
|
|
|
|
m_hPipe = INVALID_HANDLE_VALUE;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(m_hProcessEvent);
|
|
|
|
|
m_hProcessEvent = NULL;
|
|
|
|
|
CloseHandle(m_hReadEvent);
|
|
|
|
|
m_hReadEvent = NULL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(m_hWriteEvent);
|
|
|
|
|
m_hWriteEvent = NULL;
|
|
|
|
|
CloseHandle(m_hConnectEvent);
|
|
|
|
|
m_hConnectEvent = NULL;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
HANDLE m_hConnectEvent;
|
|
|
|
|
HANDLE m_hWriteEvent;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE m_hReadEvent;
|
|
|
|
|
HANDLE m_hProcessEvent;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
HANDLE m_hPipe;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
DWORD m_clientPid;
|
|
|
|
|
HGThread m_thread;
|
|
|
|
|
HGBool m_error;
|
|
|
|
|
HGBool m_break;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
struct HGNamedPipeClientImpl
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeClientImpl()
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
m_hWriteEvent = NULL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
m_hReadEvent = NULL;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
m_hProcessEvent = NULL;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
m_hPipe = INVALID_HANDLE_VALUE;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
m_serverPid = 0;
|
|
|
|
|
m_thread = NULL;
|
|
|
|
|
m_error = HGFALSE;
|
|
|
|
|
m_break = HGFALSE;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
~HGNamedPipeClientImpl()
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGBase_CloseThread(m_thread);
|
|
|
|
|
m_thread = NULL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(m_hPipe);
|
|
|
|
|
m_hPipe = INVALID_HANDLE_VALUE;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(m_hProcessEvent);
|
|
|
|
|
m_hProcessEvent = NULL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(m_hReadEvent);
|
|
|
|
|
m_hReadEvent = NULL;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(m_hWriteEvent);
|
|
|
|
|
m_hWriteEvent = NULL;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE m_hWriteEvent;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
HANDLE m_hReadEvent;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE m_hProcessEvent;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
HANDLE m_hPipe;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
DWORD m_serverPid;
|
|
|
|
|
HGThread m_thread;
|
|
|
|
|
HGBool m_error;
|
|
|
|
|
HGBool m_break;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
static void NamedPipeServerFunc(HGThread thread, HGPointer param)
|
|
|
|
|
{
|
|
|
|
|
HGNamedPipeServerImpl* p = (HGNamedPipeServerImpl*)param;
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
|
|
|
HANDLE handles[2];
|
|
|
|
|
handles[0] = OpenProcess(SYNCHRONIZE, FALSE, p->m_clientPid);
|
|
|
|
|
handles[1] = p->m_hProcessEvent;
|
|
|
|
|
if (WAIT_OBJECT_0 == WaitForMultipleObjects(2, handles, FALSE, INFINITE))
|
|
|
|
|
{
|
|
|
|
|
p->m_error = HGTRUE;
|
|
|
|
|
SetEvent(p->m_hWriteEvent);
|
|
|
|
|
SetEvent(p->m_hReadEvent);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CloseHandle(handles[0]);
|
|
|
|
|
#else
|
|
|
|
|
// TODO
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void NamedPipeClientFunc(HGThread thread, HGPointer param)
|
|
|
|
|
{
|
|
|
|
|
HGNamedPipeClientImpl* p = (HGNamedPipeClientImpl*)param;
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
|
|
|
HANDLE handles[2];
|
|
|
|
|
handles[0] = OpenProcess(SYNCHRONIZE, FALSE, p->m_serverPid);
|
|
|
|
|
handles[1] = p->m_hProcessEvent;
|
|
|
|
|
if (WAIT_OBJECT_0 == WaitForMultipleObjects(2, handles, FALSE, INFINITE))
|
|
|
|
|
{
|
|
|
|
|
p->m_error = HGTRUE;
|
|
|
|
|
SetEvent(p->m_hWriteEvent);
|
|
|
|
|
SetEvent(p->m_hReadEvent);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CloseHandle(handles[0]);
|
|
|
|
|
#else
|
|
|
|
|
// TODO
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGBase_OpenNamedPipeServer(const HGChar* pipeName, HGNamedPipeServer* server)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == pipeName || NULL == server)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
HANDLE hConnectEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hConnectEvent);
|
|
|
|
|
HANDLE hWriteEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hWriteEvent);
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE hReadEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hReadEvent);
|
|
|
|
|
HANDLE hProcessEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hProcessEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
|
2022-07-26 05:52:12 +00:00
|
|
|
|
char name[256];
|
|
|
|
|
sprintf(name, "\\\\.\\pipe\\%s", pipeName);
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE hPipe = CreateNamedPipeA(name, PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | FILE_FLAG_OVERLAPPED,
|
2022-07-26 10:22:02 +00:00
|
|
|
|
0, 1, 1024, 1024, 0, NULL);
|
2022-07-26 05:52:12 +00:00
|
|
|
|
if (INVALID_HANDLE_VALUE == hPipe)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(hWriteEvent);
|
|
|
|
|
CloseHandle(hConnectEvent);
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
}
|
2022-07-26 05:52:12 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeServerImpl* pipeServerImpl = new HGNamedPipeServerImpl;
|
|
|
|
|
pipeServerImpl->m_hConnectEvent = hConnectEvent;
|
|
|
|
|
pipeServerImpl->m_hWriteEvent = hWriteEvent;
|
|
|
|
|
pipeServerImpl->m_hReadEvent = hReadEvent;
|
|
|
|
|
pipeServerImpl->m_hProcessEvent = hProcessEvent;
|
|
|
|
|
pipeServerImpl->m_hPipe = hPipe;
|
|
|
|
|
*server = (HGNamedPipeServer)pipeServerImpl;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_CloseNamedPipeServer(HGNamedPipeServer server)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == server)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeServerImpl* pipeServerImpl = (HGNamedPipeServerImpl*)server;
|
|
|
|
|
delete pipeServerImpl;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_NamedPipeServerWrite(HGNamedPipeServer server, const HGByte* data, HGUInt size, HGUInt* writeSize)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == server || NULL == data || 0 == size)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeServerImpl* pipeServerImpl = (HGNamedPipeServerImpl*)server;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == pipeServerImpl->m_thread || pipeServerImpl->m_error || pipeServerImpl->m_break)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
2022-08-10 02:22:13 +00:00
|
|
|
|
overlapped.hEvent = pipeServerImpl->m_hWriteEvent;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
DWORD dwNumerOfWriteBytes = 0;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (!WriteFile(pipeServerImpl->m_hPipe, data, size, &dwNumerOfWriteBytes, &overlapped))
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
WaitForSingleObject(pipeServerImpl->m_hWriteEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeServerImpl->m_hPipe, &overlapped, &dwNumerOfWriteBytes, TRUE))
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-26 05:52:12 +00:00
|
|
|
|
if (NULL != writeSize)
|
|
|
|
|
*writeSize = dwNumerOfWriteBytes;
|
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_NamedPipeServerRead(HGNamedPipeServer server, HGByte* data, HGUInt size, HGUInt* readSize)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == server || NULL == data || 0 == size)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeServerImpl* pipeServerImpl = (HGNamedPipeServerImpl*)server;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == pipeServerImpl->m_thread) // δ<><CEB4><EFBFBD><EFBFBD>
|
|
|
|
|
{
|
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
|
|
|
|
overlapped.hEvent = pipeServerImpl->m_hConnectEvent;
|
|
|
|
|
if (!ConnectNamedPipe(pipeServerImpl->m_hPipe, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
DWORD err = GetLastError();
|
|
|
|
|
if (ERROR_IO_PENDING != err && ERROR_PIPE_CONNECTED != err)
|
|
|
|
|
{
|
|
|
|
|
// <20>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD>ӳ<EFBFBD><D3B3><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ERROR_IO_PENDING == err)
|
|
|
|
|
{
|
|
|
|
|
// <20>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
WaitForSingleObject(pipeServerImpl->m_hConnectEvent, INFINITE);
|
|
|
|
|
DWORD dwTransferBytes = 0; // <20><>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
if (!GetOverlappedResult(pipeServerImpl->m_hPipe, &overlapped, &dwTransferBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// <20><>ȡ<EFBFBD>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
memset(&overlapped, 0, sizeof(OVERLAPPED));
|
|
|
|
|
overlapped.hEvent = pipeServerImpl->m_hReadEvent;
|
|
|
|
|
DWORD dwNumerOfReadBytes = 0;
|
|
|
|
|
DWORD clientPid = 0;
|
|
|
|
|
if (!ReadFile(pipeServerImpl->m_hPipe, &clientPid, sizeof(DWORD), &dwNumerOfReadBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(pipeServerImpl->m_hReadEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeServerImpl->m_hPipe, &overlapped, &dwNumerOfReadBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (sizeof(DWORD) != dwNumerOfReadBytes || 0 == clientPid)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// <20><><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
memset(&overlapped, 0, sizeof(OVERLAPPED));
|
|
|
|
|
overlapped.hEvent = pipeServerImpl->m_hWriteEvent;
|
|
|
|
|
DWORD dwNumerOfWriteBytes = 0;
|
|
|
|
|
DWORD serverPid = GetCurrentProcessId();
|
|
|
|
|
if (!WriteFile(pipeServerImpl->m_hPipe, &serverPid, sizeof(DWORD), &dwNumerOfWriteBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(pipeServerImpl->m_hWriteEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeServerImpl->m_hPipe, &overlapped, &dwNumerOfWriteBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (sizeof(DWORD) != dwNumerOfWriteBytes)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// <20><><EFBFBD><EFBFBD><EFBFBD>̵߳ȴ<CCB5><C8B4>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
pipeServerImpl->m_clientPid = clientPid;
|
|
|
|
|
HGBase_OpenThread(NamedPipeServerFunc, pipeServerImpl, &pipeServerImpl->m_thread);
|
|
|
|
|
assert(NULL != pipeServerImpl->m_thread);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pipeServerImpl->m_error || pipeServerImpl->m_break)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
|
|
|
|
overlapped.hEvent = pipeServerImpl->m_hReadEvent;
|
|
|
|
|
DWORD dwNumerOfReadBytes = 0;
|
|
|
|
|
if (!ReadFile(pipeServerImpl->m_hPipe, data, size, &dwNumerOfReadBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(pipeServerImpl->m_hReadEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeServerImpl->m_hPipe, &overlapped, &dwNumerOfReadBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL != readSize)
|
|
|
|
|
*readSize = dwNumerOfReadBytes;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
|
|
|
|
#endif
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGBase_NamedPipeServerStop(HGNamedPipeServer server)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == server)
|
2022-07-27 01:18:52 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
2022-07-27 01:18:52 +00:00
|
|
|
|
}
|
2022-08-10 02:22:13 +00:00
|
|
|
|
|
|
|
|
|
HGNamedPipeServerImpl* pipeServerImpl = (HGNamedPipeServerImpl*)server;
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
|
|
|
pipeServerImpl->m_break = HGTRUE;
|
|
|
|
|
SetEvent(pipeServerImpl->m_hConnectEvent);
|
|
|
|
|
SetEvent(pipeServerImpl->m_hWriteEvent);
|
|
|
|
|
SetEvent(pipeServerImpl->m_hReadEvent);
|
|
|
|
|
SetEvent(pipeServerImpl->m_hProcessEvent);
|
|
|
|
|
#else
|
|
|
|
|
// TODO
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#endif
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_OpenNamedPipeClient(const HGChar* pipeName, HGNamedPipeClient* client)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == pipeName || NULL == client)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE hWriteEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hWriteEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
HANDLE hReadEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hReadEvent);
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE hProcessEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
|
|
|
|
|
assert(NULL != hProcessEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
|
2022-07-26 05:52:12 +00:00
|
|
|
|
char name[256];
|
|
|
|
|
sprintf(name, "\\\\.\\pipe\\%s", pipeName);
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HANDLE hPipe = CreateFileA(name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
|
|
|
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
|
|
|
|
|
if (INVALID_HANDLE_VALUE == hPipe)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
}
|
2022-07-27 02:18:44 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// <20><><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
|
|
|
|
overlapped.hEvent = hWriteEvent;
|
|
|
|
|
DWORD dwNumerOfWriteBytes = 0;
|
|
|
|
|
DWORD clientPid = GetCurrentProcessId();
|
|
|
|
|
if (!WriteFile(hPipe, &clientPid, sizeof(DWORD), &dwNumerOfWriteBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(hWriteEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(hPipe, &overlapped, &dwNumerOfWriteBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (sizeof(DWORD) != dwNumerOfWriteBytes)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
CloseHandle(hReadEvent);
|
2022-08-10 02:22:13 +00:00
|
|
|
|
CloseHandle(hWriteEvent);
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
}
|
2022-07-26 05:52:12 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// <20><>ȡ<EFBFBD>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
memset(&overlapped, 0, sizeof(OVERLAPPED));
|
|
|
|
|
overlapped.hEvent = hReadEvent;
|
|
|
|
|
DWORD dwNumerOfReadBytes = 0;
|
|
|
|
|
DWORD serverPid = 0;
|
|
|
|
|
if (!ReadFile(hPipe, &serverPid, sizeof(DWORD), &dwNumerOfReadBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
|
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(hReadEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(hPipe, &overlapped, &dwNumerOfReadBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (sizeof(DWORD) != dwNumerOfReadBytes || 0 == serverPid)
|
|
|
|
|
{
|
|
|
|
|
CloseHandle(hPipe);
|
|
|
|
|
CloseHandle(hProcessEvent);
|
|
|
|
|
CloseHandle(hReadEvent);
|
|
|
|
|
CloseHandle(hWriteEvent);
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
}
|
2022-07-26 05:52:12 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// <20><><EFBFBD><EFBFBD><EFBFBD>̵߳ȴ<CCB5><C8B4>Է<EFBFBD><D4B7><EFBFBD><EFBFBD><EFBFBD>ID
|
|
|
|
|
|
|
|
|
|
HGNamedPipeClientImpl* pipeClientImpl = new HGNamedPipeClientImpl;
|
|
|
|
|
pipeClientImpl->m_hWriteEvent = hWriteEvent;
|
|
|
|
|
pipeClientImpl->m_hReadEvent = hReadEvent;
|
|
|
|
|
pipeClientImpl->m_hProcessEvent = hProcessEvent;
|
|
|
|
|
pipeClientImpl->m_hPipe = hPipe;
|
|
|
|
|
pipeClientImpl->m_serverPid = serverPid;
|
|
|
|
|
HGBase_OpenThread(NamedPipeServerFunc, pipeClientImpl, &pipeClientImpl->m_thread);
|
|
|
|
|
assert(NULL != pipeClientImpl->m_thread);
|
|
|
|
|
*client = (HGNamedPipeClient)pipeClientImpl;
|
|
|
|
|
#else
|
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
2022-08-10 02:22:13 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGBase_CloseNamedPipeClient(HGNamedPipeClient client)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == client)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
2022-07-26 05:52:12 +00:00
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeClientImpl* pipeClientImpl = (HGNamedPipeClientImpl*)client;
|
|
|
|
|
delete pipeClientImpl;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_NamedPipeClientWrite(HGNamedPipeClient client, const HGByte* data, HGUInt size, HGUInt* writeSize)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == client)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeClientImpl* pipeClientImpl = (HGNamedPipeClientImpl*)client;
|
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
|
|
|
assert(NULL != pipeClientImpl->m_thread);
|
|
|
|
|
|
|
|
|
|
if (pipeClientImpl->m_error || pipeClientImpl->m_break)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
|
|
|
|
overlapped.hEvent = pipeClientImpl->m_hWriteEvent;
|
|
|
|
|
DWORD dwNumerOfWriteBytes = 0;
|
|
|
|
|
if (!WriteFile(pipeClientImpl->m_hPipe, data, size, &dwNumerOfWriteBytes, &overlapped))
|
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
WaitForSingleObject(pipeClientImpl->m_hWriteEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeClientImpl->m_hPipe, &overlapped, &dwNumerOfWriteBytes, TRUE))
|
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (NULL != writeSize)
|
|
|
|
|
*writeSize = dwNumerOfWriteBytes;
|
|
|
|
|
#else
|
|
|
|
|
// TODO
|
|
|
|
|
#endif
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_NamedPipeClientRead(HGNamedPipeClient client, HGByte* data, HGUInt size, HGUInt* readSize)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == client)
|
2022-07-26 05:52:12 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeClientImpl* pipeClientImpl = (HGNamedPipeClientImpl*)client;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
assert(NULL != pipeClientImpl->m_thread);
|
|
|
|
|
|
|
|
|
|
if (pipeClientImpl->m_error || pipeClientImpl->m_break)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-26 10:22:02 +00:00
|
|
|
|
OVERLAPPED overlapped = { 0 };
|
2022-08-10 02:22:13 +00:00
|
|
|
|
overlapped.hEvent = pipeClientImpl->m_hReadEvent;
|
2022-07-26 05:52:12 +00:00
|
|
|
|
DWORD dwNumerOfReadBytes = 0;
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (!ReadFile(pipeClientImpl->m_hPipe, data, size, &dwNumerOfReadBytes, &overlapped))
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
if (ERROR_IO_PENDING != GetLastError())
|
|
|
|
|
{
|
|
|
|
|
// <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
WaitForSingleObject(pipeClientImpl->m_hReadEvent, INFINITE);
|
|
|
|
|
if (!GetOverlappedResult(pipeClientImpl->m_hPipe, &overlapped, &dwNumerOfReadBytes, TRUE))
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
// <20>ֶ<EFBFBD>ֹͣ
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-26 05:52:12 +00:00
|
|
|
|
if (NULL != readSize)
|
|
|
|
|
*readSize = dwNumerOfReadBytes;
|
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 05:52:12 +00:00
|
|
|
|
#endif
|
2022-07-26 10:22:02 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGResult HGAPI HGBase_NamedPipeClientStop(HGNamedPipeClient client)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
2022-08-10 02:22:13 +00:00
|
|
|
|
if (NULL == client)
|
2022-07-26 10:22:02 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-08-10 02:22:13 +00:00
|
|
|
|
HGNamedPipeClientImpl* pipeClientImpl = (HGNamedPipeClientImpl*)client;
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#if defined(HG_CMP_MSC)
|
2022-08-10 02:22:13 +00:00
|
|
|
|
pipeClientImpl->m_break = HGTRUE;
|
|
|
|
|
SetEvent(pipeClientImpl->m_hWriteEvent);
|
|
|
|
|
SetEvent(pipeClientImpl->m_hReadEvent);
|
|
|
|
|
SetEvent(pipeClientImpl->m_hProcessEvent);
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#else
|
2022-08-10 02:22:13 +00:00
|
|
|
|
// TODO
|
2022-07-26 10:22:02 +00:00
|
|
|
|
#endif
|
2022-07-26 05:52:12 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
2022-07-27 02:18:44 +00:00
|
|
|
|
}
|