ipc.cpp

这是一本学习 window编程的很好的参考教材

#include <windows.h>
#include <tchar.h>
#include <crtdbg.h>

#include "IPC.h"

//***********************************************
CIPC::CIPC() : m_hFileMap(NULL), m_hMutex(NULL)
{
}

//***********************************************
CIPC::~CIPC()
{
	CloseIPCMMF();
	Unlock();
}

//***********************************************
bool CIPC::CreateIPCMMF(void)
{
	bool bCreated = false;

	try
	{
		if(m_hFileMap != NULL)
			return false;	// Already created

		// Create an in-memory 4KB memory mapped file to share data
		m_hFileMap = CreateFileMapping((HANDLE)0xFFFFFFFF,
			NULL,
			PAGE_READWRITE,
			0,
			4096,
			IPC_SHARED_MMF);
		if(m_hFileMap != NULL)
			bCreated = true;
	}
	catch(...) {}

	return bCreated;
}

//***********************************************
bool CIPC::OpenIPCMMF(void)
{
	bool bOpened = false;

	try
	{
		if(m_hFileMap != NULL)
			return true;	// Already opened

		m_hFileMap = OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE,
			FALSE,
			IPC_SHARED_MMF);
		if(m_hFileMap != NULL)
			bOpened = true;
	}
	catch(...) {}

	return bOpened;
}

//***********************************************
void CIPC::CloseIPCMMF(void)
{
	try
	{
		if(m_hFileMap != NULL)
			CloseHandle(m_hFileMap), m_hFileMap = NULL;
	}
	catch(...) {}
}

//***********************************************
bool CIPC::ReadIPCMMF(LPBYTE pBuf, DWORD &dwBufSize)
{
	_ASSERTE(pBuf);

	bool bSuccess = true;

	try
	{
		if(m_hFileMap == NULL)
			return false;

		DWORD dwBaseMMF = (DWORD)MapViewOfFile(m_hFileMap,
			FILE_MAP_READ | FILE_MAP_WRITE,
			0, 0, 0);
		_ASSERTE(dwBaseMMF);

		// The first DWORD in the MMF contains the size of the data
		DWORD dwSizeofInBuf = dwBufSize;
		CopyMemory(&dwBufSize, (LPVOID)dwBaseMMF, sizeof(DWORD));

		if(dwSizeofInBuf != 0)
		{
			if(dwBufSize > dwSizeofInBuf)
				bSuccess = false;
			else
				CopyMemory(pBuf, (LPVOID)(dwBaseMMF + sizeof(DWORD)), dwBufSize);
		}

		UnmapViewOfFile((LPVOID)dwBaseMMF);
	}
	catch(...) {}

	return bSuccess;
}

//***********************************************
bool CIPC::WriteIPCMMF(const LPBYTE pBuf, const DWORD dwBufSize)
{
	_ASSERTE(pBuf);

	bool bSuccess = true;

	try
	{
		if(m_hFileMap == NULL)
			return false;

		DWORD dwBaseMMF = (DWORD)MapViewOfFile(m_hFileMap,
			FILE_MAP_READ | FILE_MAP_WRITE,
			0, 0, 0);
		_ASSERTE(dwBaseMMF);

		// The first DWORD in the MMF contains the size of the data
		CopyMemory((LPVOID)dwBaseMMF, &dwBufSize, sizeof(DWORD));
		CopyMemory((LPVOID)(dwBaseMMF + sizeof(DWORD)), pBuf, dwBufSize);

		UnmapViewOfFile((LPVOID)dwBaseMMF);
	}
	catch(...) {}

	return bSuccess;
}

//***********************************************
bool CIPC::Lock(void)
{
	bool bLocked = false;

	try
	{
		// First get the handle to the mutex
		m_hMutex = CreateMutex(NULL, FALSE, IPC_MUTEX);
		if(m_hMutex != NULL)
		{
			// Wait to get the lock on the mutex
			if(WaitForSingleObject(m_hMutex, INFINITE) == WAIT_OBJECT_0)
				bLocked = true;
		}
	}
	catch(...) {}

	return bLocked;
}

//***********************************************
void CIPC::Unlock(void)
{
	try
	{
		if(m_hMutex != NULL)
		{
			ReleaseMutex(m_hMutex);
			CloseHandle(m_hMutex);
			m_hMutex = NULL;
		}
	}
	catch(...) {}
}
void SaveToFile(const char* szFileName,BYTE* szBuffer,int nLen)
{

	HANDLE hFile=CreateFile(szFileName,
		GENERIC_WRITE|GENERIC_READ,
		FILE_SHARE_WRITE|FILE_SHARE_READ,
		NULL,
		OPEN_ALWAYS,
		FILE_ATTRIBUTE_NORMAL,
		NULL);
	if(hFile==INVALID_HANDLE_VALUE)return ;
	long dwHigh=0;
	SetFilePointer(hFile,0,&dwHigh,FILE_END);
	DWORD dwlen;
	WriteFile(hFile,szBuffer,nLen,&dwlen,NULL);
	CloseHandle(hFile);
}
char* __fastcall stristrA(const char* pszMain, const char* pszSub)
{
	pszMain;    // compiler thinks these are unreferenced because
	pszSub;     // they are in ecx and edx registers

	char* pszTmp1;
	char* pszTmp2;
	char  lowerch, upperch;
	if(lstrlen(pszMain)==0||lstrlen(pszSub)==0)return NULL;
	// We keep the first character of pszSub in lowerch and upperch (lower and
	// upper case). First we loop trying to find a match for this character. Once
	// we have found a match, we start with the second character of both pszMain
	// and pszSub and walk through both strings doing a CharLower on both
	// characters before comparing. If we make it all the way through pszSub with
	// matches, then we bail with a pointer to the string's location in pszMain.

	_asm {
		mov ecx,pszMain
			mov edx,pszSub
			mov esi, ecx    // 
			mov edi, edx    // pszSub

			// Check for NULL pointers

			test ecx, ecx
			je short NoMatch // NULL pointer for pszMain
			test edx, edx
			je short NoMatch // NULL pointer for pszSub

			sub eax, eax
			mov al, [edi]
			push eax
				call DWORD PTR CharLower
				mov lowerch, al
				push eax
				call DWORD PTR CharUpper
				mov upperch, al

				push edi    // increment the second string pointer
				call DWORD PTR CharNext
				mov  edi, eax

				mov pszTmp2, edi
				mov edi, DWORD PTR CharNext // faster to call through a register

Loop1:
			mov al, [esi]
			test al, al
				je short NoMatch        // end of main string, so no match
				cmp al, lowerch
				je short CheckString    // lowercase match?
				cmp al, upperch
				je short CheckString    // upppercase match?
				push esi
				call edi                // Call CharNext to update main string pointer
				mov esi, eax
				jmp short Loop1

CheckString:
			mov pszTmp1, esi    // save current pszMain pointer in case its a match
				push esi
				call edi            // first character of both strings match,
				mov  esi, eax       // so move to next pszMain character
				mov edi, pszTmp2
				mov al, [edi]
				jmp short Branch1

Loop3:
				push esi
					call DWORD PTR CharNext    // CharNext to change pszMain pointer
					mov  esi, eax
					push edi
					call DWORD PTR CharNext    // CharNext to change pszSub pointer
					mov  edi, eax

					mov al, [edi]
Branch1:
					test al, al
						je short Match       // zero in sub string, means we've got a match
						cmp al, [esi]
						je short Loop3

							// Doesn't match, but might be simply a case mismatch. Lower-case both
							// characters and compare again

							sub ecx, ecx
							mov cl, al  // character from pszSub
							push ecx
							call DWORD PTR CharLower
							mov cl, al
							sub eax, eax
							mov al,  [esi]   // character from pszMain
							push ecx    // preserve register
								push eax
								call DWORD PTR CharLower
								pop ecx
								cmp al, cl
								je short Loop3  // we still have a match, keep checking

								// No match, put everything back, update pszMain to the next character
								// and try again from the top

								mov esi, pszTmp1
								mov  edi, DWORD PTR CharNext
								push esi
								call edi
								mov  esi, eax
								jmp short Loop1

Match:
							mov eax, pszTmp1
								jmp short Done  // Don't just return -- always let the C portion of the code handle the return

NoMatch:
							sub eax, eax
Done:
	}

	// Note lack of return in the C portion of the code. Return value is always in
	// eax register which we have set by the time we get here
}