HelperFunctions.cpp

//#include "StdAfx.h"

#include "HelperFunctions.h"

//#include "mru.cpp"
#include "dumper.h"
#include "version.h"

#include <iostream>
#include <algorithm>

using std::cout;
using std::endl;
using std::transform;

// -------------------------------------------------------------------------------
// HELPER FUNCTIONS
// -------------------------------------------------------------------------------

DWORD getPluginDirectory(wstring& directory)
{
	DWORD result;
	HINSTANCE hinst = (HINSTANCE)GetModuleHandleW(PLUGIN_NAME L".dll");
	wchar_t* p;
	wchar_t buffer[TEXTLEN] = {0};
	result = GetModuleFileNameW(hinst, buffer, TEXTLEN);
	p = wcsrchr(buffer, '\\');
	if (p)
	{
		*p = '\0';
		directory.assign(buffer);
		return 1;
	}
	else
		return 0;
}

void MsgBox(wstring sMsg, wstring sTitle)
{
	HWND hw = hwollymain;
	MessageBox(hw, sMsg.c_str(), sTitle.c_str(), MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST | MB_SETFOREGROUND);
}

void DbgMsg(int n, wchar_t* title)
{
#ifdef _DEBUG
	wchar_t data[32];
	HWND hw = hwollymain;
	wsprintf(data, L"%d", n);
	MessageBox(hw, data, title, MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST | MB_SETFOREGROUND);
#endif
}

void DbgMsg(int n, wstring title)
{
#ifdef _DEBUG
	wchar_t data[32];
	HWND hw = hwollymain;
	wsprintf(data, L"%d", n);
	MessageBox(hw, data, title.c_str(), MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST);
#endif
}

void DbgMsgHex(int n, wchar_t* title)
{
#ifdef _DEBUG
	wchar_t data[32];
	HWND hw = hwollymain;
	_itow_s( n, data, 16 );
	MessageBox(hw, data, title, MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST);
#endif
}

void DbgMsgHex(int n, wstring title)
{
#ifdef _DEBUG
	wchar_t data[32];
	HWND hw = hwollymain;
	_itow_s( n, data, 16 );
	MessageBox(hw, data, title.c_str(), MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST);
#endif
}

wstring ToLower(wstring in)
{
	in = w_trim(in);
	int (*pf)(int) = tolower;
	transform(in.begin(), in.end(), in.begin(), pf);
	return in;
}

int searchx(char* SearchBuff, int BuffSize, char* SearchString, int StringLen, wchar_t wc)
{
	int i, j;

	if (BuffSize < StringLen) return -1;

	for(i = 0; i < (BuffSize - StringLen); i++)
	{
		for(j = 0; j < StringLen; j++)
		{
			if ((SearchString[j] != wc)
			        && (SearchString[j] != SearchBuff[i + j]))
				break;
		}
		if (j == StringLen) return i;
	}
	return -1;
}

bool split(vector<wstring>& vec, const wstring& str, const wchar_t delim)
{
	vector<int> pos;
	bool inQuotes = false;

	for(uint i = 0; i < str.size(); i++)
	{
		if(str[i] == '"')
			inQuotes = !inQuotes;

		if(str[i] == delim && !inQuotes)
			pos.push_back(i);
	}

	vector<int>::iterator iter = pos.begin();

	if(iter == pos.end())
	{
		vec.push_back(str);
		return false;
	}

	uint start = 0, end = 0;

	while(iter != pos.end())
	{
		end = *iter;
		vec.push_back(w_trim(str.substr(start, end - start)));
		start = end + 1;
		iter++;
	}

	if(start != str.size())
		vec.push_back(w_trim(str.substr(start)));

	return true;
}

//reverse dword bytes
DWORD rev(DWORD dw)
{
	__asm
	{
		push eax
		push ebx

		mov eax, dw
		xchg ah, al
		mov ebx, eax
		rol ebx, 16

		xchg bh, bl
		mov dw, ebx

		pop ebx
		pop eax
	}
	return dw;
}

bool is_hex(wstring& s)
{
	if(s.find_first_not_of(L"0123456789abcdefABCDEF-") != wstring::npos)
		return false;

	return true;
}

bool is_dec(wstring& s)
{
	int len = s.length();

	if (len < 2)
		return false;

	if (s[len - 1] != '.')
		return false;

	for(uint i = 0; i < len - 1; i++)
	{
		if (s[i] < '0' || s[i] > '9')
			return false;
	}
	return true;
}

bool is_float(wstring& s)
{
	int p = s.find('.');
	if (p == wstring::npos || p == s.length() - 1)
		return false;

	for(uint i = 0; i < s.length() - 1; i++)
	{
		if ((s[i] < '0' && s[i] != '.' ) || s[i] > '9')
			return false;
	}
	return true;
}

void ReplaceString(wstring& s, wchar_t* what, wchar_t* with)
{
	int p = 0;
	int li = wcslen(with);
	int la = wcslen(what);
	p = s.find(what, p);
	while (p != wstring::npos)
	{
		s.erase(p, la);
		s.insert(p, with);
		p = s.find(what, p + li);
	}
}

//Remove characters in string for display
wstring CleanString(wstring& s)
{
	wstring str = s;
	size_t p;
	for (p = 0; p < s.length(); p++)
		if (str[p] == 0)
			str[p] = ' ';
	//while ((p = str_display.find_first_of("\0")) != wstring::npos)
	//	str_display[p]=' ';
	return str;
}

wstring Str2Unicode(char* s, ulong len)
{
	wstring sOut;
	sOut.resize(len * 2);
	for(ulong i = 0; i < len; i++)
	{
		sOut[i * 2] = s[i];
	}
	return sOut;
}

wstring Str2Unicode(string& s)
{
	wstring sOut;
	ulong len = s.size();
	sOut.resize(len * 2);
	for(ulong i = 0; i < len; i++)
	{
		sOut[i] = (wchar_t) s[i];
	}
	return sOut;
}

bool is_hexwild(wstring& s)
{
	wstring s2 = s;
	ReplaceString(s2, L"?", L"");
	return is_hex(s2);
}

bool UnquoteString(wstring& s, wchar_t cstart, wchar_t cend)
{
	//using namespace regex;
	if(s.length() == 0)
		return false;

	if( s.at(0) == cstart && s.at(s.length() - 1) == cend)
	{
		s = s.substr(1, s.length() - 2);
		if (cstart == '"')
		{
			ReplaceString(s, L"\\r\\n", L"\r\n");
		}
		return true;
	}
	else
		return false;
}

int Str2Hex(wstring& s, wstring& dst)
{
	return Str2Hex(s, dst, s.length());
}

int Str2Hex(wstring& s, wstring& dst, ulong size)
{
	uint i = 0;
	wchar_t c[3] = {0};
	dst = L"";
	dst.resize(size * 2);
	wchar_t* p = (wchar_t*)dst.c_str();
	while(i < size)
	{
		wsprintf(p + (i * 2), L"%02X", s.at(i));
		//dst.append(c);
		i++;
	}
	return i;
}

int Int2Hex(DWORD dw, wstring& dst)
{
	wchar_t buffer [10];
	dw = wsprintf(buffer, L"%X", dw);
	dst = buffer;
	return dw;
}

int Str2Rgch(wstring& s, wchar_t* arr, uint size)
{
	uint i = 0;
	ZeroMemory(arr, size);
	while(i < s.length() / 2)
	{
		arr[i] = (BYTE) wcstoul(s.substr(i * 2, 2).c_str(), 0, 16);
		i++;
	}
	return i;
}

int Str2RgchWithWC(wstring& s, wchar_t* arr, uint size, wchar_t wc)
{
	uint i = 0;
	ZeroMemory(arr, size);
	while(i < s.length() / 2)
	{
		if(s[i * 2] != '?')
			arr[i] = (BYTE) wcstoul(s.substr(i * 2, 2).c_str(), 0, 16);
		else
			arr[i] = wc;
		i++;
	}
	return i;
}

long double strtof(wstring& s)
{
	long double result = 0;
	swscanf_s(s.c_str(), L"%lf", &result);
	return result;
}

char GetWildcard(wstring& s)
{
	vector<BYTE> stringchars;
	int i = 0;

	while(i < s.length() / 2)
	{
		char current = (char)s[i * 2];
		if(current != '?')
			stringchars.push_back((BYTE) wcstoul(s.substr(i * 2, 2).c_str(), 0, 16));
		i++;
	}

	// Find wildcard
	for(BYTE c = 1; i <= 0xFF; i++)
	{
		if(find(stringchars.begin(), stringchars.end(), c) == stringchars.end())
			return (char)c;
	}
	return '\0';
}

bool RgchContains(char* container, uint containerlen, char* containee, uint containeelen)
{
	if(containerlen < containeelen)
		return false;

	for(uint i = 0; i < containeelen; i++)
	{
		if(container[i] != containee[i])
			return false;
	}
	return true;
}

bool GetWildcardBytePositions(wstring bytestring, vector<int>* wildcardpos)
{
	int ix = 0;
	do
	{
		ix = bytestring.find(L"??", ix);
		if(ix != -1)
		{
			wildcardpos->push_back(((int)ix / 2));
			ix++;
		}
	}
	while(ix != -1);

	for(int i = 0; i < wildcardpos->size(); i++)
		cout << wildcardpos->at(i) << endl;

	return true;
}

bool SaveDump(wstring fileName, DWORD ep)
{
	strCurEIP = ep;
	//OPENFILENAME ofn;
	HANDLE hHeap, hFile;
	PIMAGE_DOS_HEADER idosh;
	PIMAGE_NT_HEADERS ipeh;
	PIMAGE_SECTION_HEADER isech;
	LPBYTE lpDumpData;
	DWORD dwFrom, dwSize, dwAccBytes;
	unsigned int i;
	dwFrom = PEFileInfo.dwImageBase;
	dwSize = PEFileInfo.dwSizeOfImage;
	hHeap = HeapCreate(HEAP_NO_SERIALIZE, 1, 0);
	lpDumpData = (LPBYTE)HeapAlloc(hHeap, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, dwSize);
	dwSize = Readmemory(lpDumpData, dwFrom, dwSize, MM_REPORT); //MM_RESTORE in v1.1
	idosh = (PIMAGE_DOS_HEADER)lpDumpData;
	if(idosh->e_magic != IMAGE_DOS_SIGNATURE)
	{
		MessageBoxW(0, L"DUMP: Bad DOS Signature!!", PNAME, MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap, HEAP_NO_SERIALIZE, lpDumpData);
		return false;
	}
	ipeh = (PIMAGE_NT_HEADERS)(lpDumpData + idosh->e_lfanew);
	if(ipeh->Signature != IMAGE_NT_SIGNATURE)
	{
		MessageBoxW(0, L"DUMP: Bad PE Signature!!", PNAME, MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap, HEAP_NO_SERIALIZE, lpDumpData);
		return false;
	}
	ipeh->FileHeader.NumberOfSections        = PEFileInfo.woNumOfSect;
	ipeh->OptionalHeader.ImageBase           = PEFileInfo.dwImageBase;
	ipeh->OptionalHeader.SizeOfImage         = PEFileInfo.dwSizeOfImage;
	ipeh->OptionalHeader.BaseOfCode          = PEFileInfo.dwBaseOfCode;
	ipeh->OptionalHeader.BaseOfData          = PEFileInfo.dwBaseOfData;
	ipeh->OptionalHeader.AddressOfEntryPoint = (strCurEIP - PEFileInfo.dwImageBase) ;
	isech = IMAGE_FIRST_SECTION(ipeh);
	if(FixSect)
	{
		for(i = 0; i < (int)PEFileInfo.woNumOfSect; i++)
		{
			memcpy((char*)(isech + i)->Name, (char*)(lpSectInfo + i)->byName, 8);
			(isech + i)->Misc.VirtualSize = (lpSectInfo + i)->dwVSize;
			(isech + i)->VirtualAddress   = (lpSectInfo + i)->dwVOffset;
			(isech + i)->SizeOfRawData    = (lpSectInfo + i)->dwVSize;
			(isech + i)->PointerToRawData = (lpSectInfo + i)->dwVOffset;
			(isech + i)->Characteristics  = (lpSectInfo + i)->dwCharacteristics;
		}
	}

	wcscpy_s( szFileName, fileName.c_str() );
	hFile = CreateFile(szFileName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if(hFile != INVALID_HANDLE_VALUE)
	{
		SetFilePointer(hFile, 0, 0, FILE_BEGIN);
		WriteFile(hFile, lpDumpData, dwSize, &dwAccBytes, NULL);
		CloseHandle(hFile);
	}
	HeapFree(hHeap, HEAP_NO_SERIALIZE, lpDumpData);
	return true;
}

/*ODBG2 : TODO...
bool GetPEInfo(DWORD ep)
{
	unsigned int i;
	HANDLE hFile,hHeap;
	PIMAGE_DOS_HEADER idosh;
	PIMAGE_NT_HEADERS ipeh;
	PIMAGE_SECTION_HEADER isech;
	LPBYTE fbuf;
	HWND hwmain=hwollymain;
	DWORD dwFsiz,dwRsiz;
	strCurEIP = ep;
	DbgePath = _executable;
	DbgeName = (LPTSTR)wcsrchr(DbgePath,'\\');
	memset(szWorkPath,0,sizeof(szWorkPath));
	wcsncpy(szWorkPath,DbgePath,(DbgeName-DbgePath));
	DbgeName++;

	//Read Debuggee
	hFile = CreateFile(DbgePath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
	if(hFile == INVALID_HANDLE_VALUE)
	{
		MessageBox(hwmain,L"DUMP: Can\'t Access File",PNAME,MB_OK);
		return false;
	}
	dwFsiz = GetFileSize(hFile,NULL);
	hHeap = HeapCreate(HEAP_NO_SERIALIZE,1,0);
	fbuf = (LPBYTE)HeapAlloc(hHeap, 0, dwFsiz);
	if(ReadFile(hFile,fbuf,dwFsiz,&dwRsiz,NULL) == 0)
	{
		MessageBox(hwmain,L"DUMP: Can\'t Read File ",PNAME,MB_OK);
		CloseHandle(hFile);
		HeapFree(hHeap,HEAP_NO_SERIALIZE,fbuf);
		return false;
	}
	CloseHandle(hFile);
	idosh = (PIMAGE_DOS_HEADER)fbuf;
	if(idosh->e_magic != IMAGE_DOS_SIGNATURE)
	{
		MessageBox(hwmain,L"DUMP: Bad DOS Signature!!",PNAME,MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap,HEAP_NO_SERIALIZE,fbuf);
		return false;
	}
	ipeh = (PIMAGE_NT_HEADERS)(fbuf + idosh->e_lfanew);
	if(ipeh->Signature != IMAGE_NT_SIGNATURE)
	{
		MessageBox(hwmain,L"DUMP: Bad PE Signature!!",PNAME,MB_OK | MB_ICONEXCLAMATION);
		HeapFree(hHeap,HEAP_NO_SERIALIZE,fbuf);
		return false;
	}
	PEFileInfo.woNumOfSect   = ipeh->FileHeader.NumberOfSections;
	PEFileInfo.dwImageBase   = ipeh->OptionalHeader.ImageBase;
	PEFileInfo.dwSizeOfImage = ipeh->OptionalHeader.SizeOfImage;
	PEFileInfo.dwBaseOfCode  = ipeh->OptionalHeader.BaseOfCode ;
	PEFileInfo.dwBaseOfData  = ipeh->OptionalHeader.BaseOfData ;
	PEFileInfo.dwAddrOfEP    = ipeh->OptionalHeader.AddressOfEntryPoint;
	lpSectInfo = (LPSECTIONINFO)malloc(sizeof(SECTIONINFO)*PEFileInfo.woNumOfSect+1);
	isech = IMAGE_FIRST_SECTION(ipeh);
	for(i=0; i<(int)PEFileInfo.woNumOfSect; i++)
	{
		strcpy((char *)(lpSectInfo+i)->byName,(char *)(isech+i)->Name);
		(lpSectInfo+i)->dwVSize            = (isech+i)->Misc.VirtualSize;
		(lpSectInfo+i)->dwVOffset          = (isech+i)->VirtualAddress;
		(lpSectInfo+i)->dwRSize            = (isech+i)->SizeOfRawData;
		(lpSectInfo+i)->dwROffset          = (isech+i)->PointerToRawData;
		(lpSectInfo+i)->dwCharacteristics  = (isech+i)->Characteristics;
	}
	HeapFree(hHeap,HEAP_NO_SERIALIZE,fbuf);
	return true;
}
*/
BOOL CALLBACK EnumThreadWndProc(HWND hwnd, LPARAM lParam)
{
	memcpy((void*)lParam, &hwnd, 4);
	if (IsWindowVisible(hwnd))
		return 0;
	return 1;
}

HWND FindHandle(DWORD dwThreadId, wstring wdwClass, long x, long y)
{

	int size, cnt = 0;
	wstring str;
	wchar_t buffer[256] = {0};
	HWND handle;
	EnumThreadWindows(dwThreadId, EnumThreadWndProc, (LPARAM) &handle);
	do
	{
		if (GetParent(handle) != NULL && GetParent(handle) != handle && GetParent(handle) != GetDesktopWindow() )
			handle = GetParent(handle);
		else
			break;
	}
	while (true);

	POINT Point;
	Point.x = x;
	Point.y = y;

	handle = ChildWindowFromPoint(handle, Point);
	if (handle != NULL)
	{
		GetClassName(handle, buffer, 256);
		if (_wcsnicmp(buffer, wdwClass.c_str(), wdwClass.length()) == 0)
		{
			return handle;
		}
	}
	return 0;
}

DWORD resizeDW(DWORD dw, DWORD size)
{

	if (size != 0)
	{
		switch (size)
		{
			case 1:
					dw = dw & 0xFF;
				break;
			case 2:
					dw = dw & 0xFFFF;
				break;
			case 3:
					dw = dw & 0xFFFFFF;
				break;
		}
	}

	return dw;
}

void resizeSTR(wstring& str, DWORD size)
{
	if (size > 0 && size < str.length())
		str = str.substr(0, size);
}

bool ESPRun(void)
{
	DWORD EIP, ESP, ESP2;
	ulong cpuid;

	cpuid = Getcputhreadid();

	t_thread* pt = Findthread(cpuid);
	EIP = pt->reg.ip;
	ESP = pt->reg.r[4];

	ESP = ESP - 0x04;

//2.Sethardwarebreakpoint(ESP, 1, HB_WRITE);
	Sendshortcut(PM_MAIN, 0, WM_KEYDOWN, 0, 1, VK_F9);

	return true;
}

wstring StrLastError(void)
{
	LPVOID lpMsgBuf;
	LPVOID lpDisplayBuf;
	DWORD dw = GetLastError();

	wstring sError;

	FormatMessage(
	    FORMAT_MESSAGE_ALLOCATE_BUFFER |
	    FORMAT_MESSAGE_FROM_SYSTEM,
	    NULL,
	    dw,
	    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	    (LPTSTR) &lpMsgBuf,
	    0, NULL );

	sError = (wchar_t*)lpMsgBuf;

	int len = sError.length();
	if (len > 2)
		if (sError.substr(len - 3, 2) == L"\r\n")
			sError.erase(len - 3, 2);

	LocalFree(lpMsgBuf);

	return sError;
}

// microsec
LARGE_INTEGER MyGetTickCount(ULONGLONG timeref, bool bUseTickCount)
{
	LARGE_INTEGER result, *lpPerformanceCount, *Frequency;
	lpPerformanceCount = (LARGE_INTEGER*) malloc(8);
	if (bUseTickCount || !QueryPerformanceCounter(lpPerformanceCount))
	{
		// il n'y a pas d'horloge haute précision sur le micro. On se contente de GetTickCount
		result.QuadPart = (GetTickCount() * 1000) - timeref;
	}
	else
	{
		// il y en a une. On va l'utiliser
		Frequency = (LARGE_INTEGER*) malloc(8);
		QueryPerformanceFrequency(Frequency);
		if (Frequency->QuadPart != 0)
			result.QuadPart = ((lpPerformanceCount->QuadPart * 1000000) / Frequency->QuadPart) - timeref;
		else
			result.QuadPart = (GetTickCount() * 1000) - timeref;
		free(Frequency);
	}
	free(lpPerformanceCount);
	return result;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Thanks Pedram Amini for this function (From Olly BP Manager).
//
BOOL get_filename_from_handle (HANDLE h_file, wchar_t* target_filename)
{
	HANDLE h_filemap;
	DWORD  file_size_hi = 0;
	wchar_t filename[MAX_PATH + 1];
	wchar_t* stripped;
	void*   mem;

	HMODULE h_psapi = NULL;
	lpfGetMappedFileName pGetMappedFileName = NULL;

	//dynamically resolve function pointer.
	//if (!pGetMappedFileName) {
	// resolve function pointers.
	if ((h_psapi = LoadLibraryExW(L"psapi.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH)) != NULL)
		pGetMappedFileName = (lpfGetMappedFileName)  GetProcAddress(h_psapi, "GetMappedFileNameA");

	if (!pGetMappedFileName)
		return FALSE;
	//}

	// initialize the filename variable.
	// memset(filename, 0, sizeof(filename));
	ZeroMemory(filename, sizeof(filename));

	// get the file size and ensure it's not zero.
	if (GetFileSize(h_file, &file_size_hi) == 0)
		return FALSE;

	// create a file mapping object.
	if ((h_filemap = CreateFileMapping(h_file, NULL, PAGE_READONLY, 0, 1, NULL)) == NULL)
		return FALSE;

	// create a file mapping to get the file name.
	if ((mem = MapViewOfFile(h_filemap, FILE_MAP_READ, 0, 0, 1)) == NULL)
		return FALSE;

	// get the mapped file's name.
	if (!pGetMappedFileName (GetCurrentProcess(), mem, filename, MAX_PATH))
		return FALSE;

	// strip the device path and copy the name to the target buffer.
	stripped = wcsrchr(filename, '\\');
	wcsncpy(target_filename, stripped + 1, 256);

	// cleanup.
	UnmapViewOfFile(mem);
	CloseHandle(h_filemap);

	return TRUE;
}

BOOL str_filename_from_handle (HANDLE h_file, wstring& target_filename)
{
	wchar_t strbuf[256];
	bool result;
	result = get_filename_from_handle(h_file, strbuf) == TRUE;
	target_filename.assign(strbuf);
	return result;
}

/* need ntdll.h, http://www.koders.com/c/fid189758E75BE39CF44E8BE174A7E0CC4605194FDE.aspx
BOOL str_filename_from_handle2 (HANDLE h_file, wstring &target_filename)
{
    UNICODE_STRING AdjustedName;
    UNICODE_STRING FullDosName;
    NTSTATUS Status;
    PLDR_DATA_TABLE_ENTRY tmpModule;
    HANDLE SectionHandle;
    ULONG ViewSize;
    PVOID ImageBase;
    PIMAGE_NT_HEADERS NtHeaders;
    BOOLEAN MappedAsDataFile;
    PVOID ArbitraryUserPointer;

	// Map the dll into the process

    ViewSize = 0;
    ImageBase = 0;
    ArbitraryUserPointer = NtCurrentTeb()->Tib.ArbitraryUserPointer;
    NtCurrentTeb()->Tib.ArbitraryUserPointer = FullDosName.Buffer;
    Status = NtMapViewOfSection(SectionHandle,
                                NtCurrentProcess(),
                                &ImageBase,
                                0,
                                0,
                                NULL,
                                &ViewSize,
                                0,
                                MEM_COMMIT,
                                PAGE_READONLY);
    NtCurrentTeb()->Tib.ArbitraryUserPointer = ArbitraryUserPointer;
    if (!NT_SUCCESS(Status))
      {
        DPRINT1("map view of section failed (Status 0x%08lx)\n", Status);
        RtlFreeUnicodeString(&FullDosName);
        NtClose(SectionHandle);
        return(Status);
      }
    if (NULL != BaseAddress)
      {
        *BaseAddress = ImageBase;
      }

    //Get and check the NT headers
    NtHeaders = RtlImageNtHeader(ImageBase);
    if (NtHeaders == NULL)
      {
        DPRINT1("RtlImageNtHeaders() failed\n");
        NtUnmapViewOfSection (NtCurrentProcess (), ImageBase);
        NtClose (SectionHandle);
        RtlFreeUnicodeString(&FullDosName);
        return STATUS_UNSUCCESSFUL;
      }
}
*/

HWND GetODBGWindow(wstring& title, wstring& classname)
{

	HWND main, hwnd = 0;
	main = hwclient; //(HWND) Plugingetvalue(VAL_HWCLIENT);
	hwnd = FindWindowEx(main, NULL, classname.c_str(), title.c_str());

	return hwnd;
}

HWND GetODBGWindow(wchar_t* title, wchar_t* classname)
{

	HWND main, hwnd = 0;
	main = hwclient; //(HWND) Plugingetvalue(VAL_HWCLIENT);
	hwnd = FindWindowEx(main, NULL, classname, title);

	return hwnd;
}

// -------------------------------------------------------------------------------
// UNICODE FUNCTIONS
// -------------------------------------------------------------------------------

wstring w_trim(const wstring& s)
{
	wstring::size_type left = s.find_first_not_of(L" \t\f\n\r");
	if( left == wstring::npos )
	{
		return wstring();
	}

	wstring::size_type right = s.find_last_not_of(L" \t\f\n\r");
	return s.substr( left, right - left + 1 );
}

wstring w_strtow(string str)
{
	wstring wstr(str.length(), L' ');
	std::copy(str.begin(), str.end(), wstr.begin());
	return wstr;
}

string w_wstrto(wstring wstr)
{
	string str(wstr.length(), ' ');
	std::copy(wstr.begin(), wstr.end(), str.begin());
	return str;
}

// -------------------------------------------------------------------------------
// ODBG 1.1 COMPAT
// -------------------------------------------------------------------------------


void Selectandscroll(t_table* t, int index, int mode)
{
	Settableselection(t, index);
}
/*
stdapi (int)     Movetableselection(t_table *pt,int n);
stdapi (int)     Settableselection(t_table *pt,int selected);
stdapi (void)    Updatetable(t_table *pt,int force);
stdapi (void)    Delayedtableredraw(t_table *pt);
*/

//Sendshortcut(PM_MAIN,0,WM_SYSKEYDOWN,0,0,'E');

void Sendshortcut(ulong win, ulong addr, int msg, int ctrl, int shift, int vkcode)
{
	//WM_SYSKEYDOWN
	LPARAM lp = 0;
	HWND hw = hwollymain;
	switch (win)
	{
		case PM_MAIN:
				SendMessageA(hw, (DWORD) msg, (WPARAM) vkcode, lp);
			break;
		case PM_DISASM:
				hw = Getcpudisasmtable()->hw;
			SendMessageA(hw, (DWORD) msg, (WPARAM) vkcode, lp);
			break;
		default:
				SendMessageA(hw, (DWORD) msg, (WPARAM) vkcode, lp);
			break;
	}
}

void Sendshortcut(wstring win, ulong addr, int msg, int ctrl, int shift, int vkcode)
{
	ulong w = PM_MAIN;
	if (win == PWM_DISASM)
	{
		w = PM_DISASM;
	}
	else if (win == PWM_DUMP)
	{
		w = PM_DUMP;
	}
	Sendshortcut(w, addr, msg, ctrl, shift, vkcode);
}