//////////////////////////////////////////////////////////////
//
//	パイプ　テスト　サーバー側
//	http://www.softist.com/
//////////////////////////////////////////////////////////////
#define NMAXINSTANCES 3
HANDLE g_hPipeListen[NMAXINSTANCES] = {INVALID_HANDLE_VALUE,INVALID_HANDLE_VALUE,INVALID_HANDLE_VALUE};
HANDLE hThreadListen[NMAXINSTANCES] = {NULL,NULL,NULL};
BOOL bListening[NMAXINSTANCES] = {FALSE,FALSE,FALSE};
HANDLE hThreadWrite[NMAXINSTANCES] = {NULL,NULL,NULL};
HANDLE hEventWrite[NMAXINSTANCES] = {NULL,NULL,NULL};
char send_buff[NMAXINSTANCES][1024] = {"", "", ""};
void WritePipe(int iNo, char* buff);
BOOL bEndProc = FALSE;
DWORD WINAPI WritePipeThread(LPVOID lpParam);

void ReadPipe(int iNo)
{
	while (!bEndProc && bListening[iNo])
	{
		OVERLAPPED	ovlp;
		HANDLE hEvent;
		memset(&ovlp, 0, sizeof(OVERLAPPED));
		hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		ovlp.hEvent = hEvent;
			
		DWORD nBytes = 0;
		char buff[1024];
		memset(buff, NULL, sizeof(buff));

		BOOL bRet = ReadFile(g_hPipeListen[iNo], buff, 10, &nBytes, &ovlp);
		if (!bRet)
		{
			if (GetLastError() == ERROR_IO_PENDING)
			{
				WaitForSingleObject(hEvent, INFINITE);
				bRet = GetOverlappedResult(g_hPipeListen[iNo], &ovlp, &nBytes, TRUE);
			}
		}
		CloseHandle(hEvent);
		if (bRet)
		{
			if (nBytes)
			{
				TRACE("受信%d: %s\r\n", iNo, buff);

				for (int i = 0; i < NMAXINSTANCES; i ++)
				{
					if (i != iNo && g_hPipeListen[i] != INVALID_HANDLE_VALUE)
					{
						strcpy(send_buff[i], buff);
						SetEvent(hEventWrite[i]);
						Sleep(10);
					}	
				}
			}
		}
		else
		{
			break;
		}
	}
}

void WritePipe(int iNo, char* buff)
{
	if (g_hPipeListen[iNo] == INVALID_HANDLE_VALUE || !bListening[iNo])
		return;

	OVERLAPPED ovlp;
	HANDLE hEvent;
	memset(&ovlp, 0, sizeof(OVERLAPPED));
	hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	ovlp.hEvent = hEvent;

	DWORD nBytes = 0;
	if (!WriteFile(g_hPipeListen[iNo], buff, strlen(buff), &nBytes, &ovlp))
	{
		if (GetLastError() == ERROR_IO_PENDING)
		{
			GetOverlappedResult(g_hPipeListen[iNo], &ovlp, &nBytes, TRUE);
		}
	}
}

DWORD WINAPI WritePipeThread(LPVOID lpParam)
{
	int iNo = (int)lpParam;
	while(!bEndProc)
	{
		WaitForSingleObject(hEventWrite[iNo], INFINITE);
		WritePipe(iNo, send_buff[iNo]);
		ResetEvent(hEventWrite[iNo]);
	}
	return 0;
}

DWORD WINAPI ListenPipeThread(LPVOID lpParam)
{
	int iNo = (int)lpParam;
	while (!bEndProc)
	{
		OVERLAPPED	ovlp;
		HANDLE hEvent;
		memset(&ovlp, 0, sizeof(OVERLAPPED));
		hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		ovlp.hEvent = hEvent;
		if (!ConnectNamedPipe(g_hPipeListen[iNo], &ovlp))
		{
			if (GetLastError() == ERROR_IO_PENDING)
			{
				WaitForSingleObject(hEvent, INFINITE);
			}
			else if (GetLastError() == ERROR_PIPE_CONNECTED)
			{
				CloseHandle(hEvent);
				continue;
			}
			bListening[iNo] = TRUE;					
			ReadPipe(iNo);	
		}
		DisconnectNamedPipe(g_hPipeListen[iNo]);
		bListening[iNo] = FALSE;					
	}
	return 0;
}

void CreateListenPipeThread()
{
	bEndProc = FALSE;
	for (int i = 0; i < NMAXINSTANCES; i ++)
	{
		g_hPipeListen[i] = CreateNamedPipe("\\\\.\\pipe\\test", 
											PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, 
											PIPE_TYPE_BYTE | PIPE_WAIT, 
											NMAXINSTANCES, 0, 0, NMPWAIT_WAIT_FOREVER, 0);
		if(g_hPipeListen[i] == INVALID_HANDLE_VALUE)
			return;
		hThreadListen[i] = CreateThread(NULL, 0, ListenPipeThread, (LPVOID)i, 0, NULL);
		hThreadWrite[i] = CreateThread(NULL, 0, WritePipeThread, (LPVOID)i, 0, NULL);
		hEventWrite[i] = CreateEvent(NULL, TRUE, FALSE, NULL);
	}
}

void DestroyListenPipe()
{
	bEndProc = TRUE;
	for (int i = 0; i < NMAXINSTANCES; i ++)
	{
		if (hThreadListen[i])
		{
			if (WaitForSingleObject(hThreadListen[i], 1000) != WAIT_TIMEOUT)
				TerminateThread(hThreadListen[i], 0);
			CloseHandle(hThreadListen[i]);
			hThreadListen[i] = NULL;
		}


		if (hThreadWrite[i])
		{
			if (WaitForSingleObject(hThreadWrite[i], 1000) != WAIT_TIMEOUT)
				TerminateThread(hThreadWrite[i], 0);
			CloseHandle(hThreadWrite[i]);
			hThreadWrite[i] = NULL;
		}

		if (g_hPipeListen[i] != INVALID_HANDLE_VALUE)
		{
			CloseHandle(g_hPipeListen[i]);
			g_hPipeListen[i] = INVALID_HANDLE_VALUE;
		}

		if (hEventWrite[i])
		{
			CloseHandle(hEventWrite[i]);
			hEventWrite[i] = NULL;
		}
	}
}
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////
//
//	パイプ　テスト　クライアント側
//	http://www.softist.com/
//////////////////////////////////////////////////////////////
HANDLE hPipe = INVALID_HANDLE_VALUE;
HANDLE hPipeThread = NULL;
BOOL bPipeThreadEnd = FALSE;
DWORD WINAPI PipeThread(LPVOID lpContext);
void ReadPipe();
DWORD WritePipe(char* lpStr);
DWORD WINAPI PipeThread(LPVOID lpParameter);
void ProcReceivedData(char* buff);
CEdit* g_pEdit = NULL;

BOOL CreatePipeThread(CEdit* pEdit)
{
	g_pEdit = pEdit;
	bPipeThreadEnd = FALSE;
	hPipeThread = CreateThread(NULL, 0, PipeThread, NULL, 0, NULL);

	return TRUE;
}

void ClosePipeThread() 
{
	if (hPipe != INVALID_HANDLE_VALUE) 
	{
		CloseHandle(hPipe);
		hPipe = INVALID_HANDLE_VALUE;
	}

	bPipeThreadEnd = TRUE;
	if (hPipeThread) 
	{
		WaitForSingleObject(hPipeThread, INFINITE);
		CloseHandle(hPipeThread);
		hPipeThread = NULL;
	}
}

DWORD WINAPI PipeThread(LPVOID lpParameter) 
{
	while (!bPipeThreadEnd) 
	{
		BOOL bRet = WaitNamedPipe("\\\\.\\pipe\\test", 1000);
		if (!bRet) 
		{
			Sleep(1000);
			continue;
		}

		hPipe = CreateFile("\\\\.\\pipe\\test", 
							GENERIC_READ | GENERIC_WRITE, 
							0, 
							NULL, 
							OPEN_EXISTING, 
							FILE_FLAG_OVERLAPPED, 
							NULL);

		if (hPipe == INVALID_HANDLE_VALUE) 
		{
			continue;
		}

		ReadPipe();
	}
	return 0;
}

void ReadPipe()
{
	if (hPipe == INVALID_HANDLE_VALUE)
		return;

	while (!bPipeThreadEnd) 
	{
		OVERLAPPED ovlp;
		HANDLE hEvent;
		memset(&ovlp, 0, sizeof(OVERLAPPED));
		hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		ovlp.hEvent = hEvent;

		char buff[MAX_PATH];
		DWORD dwNumOfRead = 0;
		ZeroMemory(buff, MAX_PATH);
		BOOL bRet = ReadFile(hPipe, buff, 10, &dwNumOfRead, &ovlp);
		if (!bRet && GetLastError() == ERROR_IO_PENDING) 
		{
			GetOverlappedResult(hPipe, &ovlp, &dwNumOfRead, TRUE);
		}
		CloseHandle(hEvent);

		if (dwNumOfRead)
		{
			ProcReceivedData(buff);
		}
		else
		{
			CloseHandle(hPipe);
			hPipe = INVALID_HANDLE_VALUE;
			break;
		}
	}
}

void ProcReceivedData(char* buff)
{
	TRACE("Client Pipe Received: %s\r\n", buff);
	if (g_pEdit)
	{
		CString strText;
		g_pEdit->GetWindowText(strText);
		strText += CString(buff) + "\r\n";
		g_pEdit->SetWindowText(strText);
	}
}

DWORD WritePipe(char* lpStr)
{
	if (hPipe == INVALID_HANDLE_VALUE)
		return 0;

	HANDLE		hEvent;
	OVERLAPPED	ovlp;
	hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
	DWORD dwNumOfWriten = 0;
	memset(&ovlp, 0, sizeof(OVERLAPPED));
	ovlp.hEvent = hEvent;

	BOOL bRet = WriteFile(hPipe, lpStr, strlen(lpStr), &dwNumOfWriten, &ovlp);
	if (!bRet && GetLastError() == ERROR_IO_PENDING)
	{
		WaitForSingleObject(hEvent, INFINITE);
		bRet = GetOverlappedResult(hPipe, &ovlp, &dwNumOfWriten, TRUE);
	}
	CloseHandle(hEvent);
	return dwNumOfWriten;
}