自学教程：C++ GetModuleFileNameEx函数代码示例

void CExceptionHandler::Register(){// (( scope )){	ASSERT(g_lpExceptionHandler == NULL);	// Build our required extra information.	g_szExtraInformation = GetVersionInformation();	if (g_szExtraInformation == NULL)	{		goto __failed;	}	// Find the path to create the dump files in and ensure it exists.	wstring szCrashDumpPath(GetDirname(GetModuleFileNameEx()) + L"//" + CRASH_DUMP_PATH);	SetEnvironmentVariable(L"MOZ_CRASHREPORTER_DATA_DIRECTORY", szCrashDumpPath.c_str());	DWORD dwAttr = GetFileAttributes(szCrashDumpPath.c_str());	if (dwAttr == INVALID_FILE_ATTRIBUTES)	{		BOOL fResult = CreateDirectory(szCrashDumpPath.c_str(), NULL);		if (!fResult)		{			goto __failed;		}	}	// Set the module name as the first restart parameter so the crash	// reporter displays the restart button.	SetEnvironmentVariable(L"MOZ_CRASHREPORTER_RESTART_ARG_0", GetModuleFileNameEx().c_str());	// Create the exception handler.	g_lpExceptionHandler = new google_breakpad::ExceptionHandler(		GetDirname(GetModuleFileNameEx()).c_str(),		NULL,		MinidumpCallback,		NULL,		google_breakpad::ExceptionHandler::HANDLER_ALL	);	return;}__failed:	if (g_szExtraInformation != NULL)	{		free(g_szExtraInformation);		g_szExtraInformation = NULL;	}}

bool FindInjectedModule(DWORD processID){	HMODULE hMods[1024];	HANDLE hProcess;	DWORD cbNeeded;	hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID);	if (hProcess == NULL)		return false;	if(EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))	{		for (unsigned int i = 0; i < (cbNeeded / sizeof(HMODULE)); i++)		{			TCHAR szModName[MAX_PATH];			if (GetModuleFileNameEx(hProcess, hMods[i], szModName, sizeof(szModName) / sizeof(TCHAR))) {				char buf[MAX_PATH];				WideCharToMultiByte(CP_ACP, 0, szModName, -1, buf, MAX_PATH, "?", NULL);				string s(buf);				if (s.compare(s.length() - 6, 6, "BH.dll") == 0) {					return true;				}			}		}	}	CloseHandle(hProcess);	return false;}

int ProcessMap::BuildUdpProcDict(){	//清空processtcpdict	ClearUdpProcessDict();	portdict.clear();	//构建tcpportdict	MIB_UDPTABLE_OWNER_PID udptable;	udptable.dwNumEntries = sizeof(udptable)/sizeof(udptable.table[0]);	DWORD udptablesize = sizeof(udptable);	if(GetExtendedUdpTable((void *)&udptable, &udptablesize, FALSE, AF_INET, UDP_TABLE_OWNER_PID, 0) == NO_ERROR)	{		for(unsigned int i =0 ; i< udptable.dwNumEntries; i++)		{			int port = ntohs((unsigned short)udptable.table[i].dwLocalPort);			int pid = udptable.table[i].dwOwningPid;			portdict.insert(pair<int ,int>(port,pid));		}	}	//构建UdpProcessDict	// Take a snapshot	HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);	PROCESSENTRY32 p;	p.dwSize = sizeof(PROCESSENTRY32);	// Traverse Process List	for(BOOL ret = Process32First(hSnapShot, &p); ret != 0; ret = Process32Next(hSnapShot, &p))	{		// Get pid and file name		int pid = p.th32ProcessID;		for(portdictit=portdict.begin();portdictit!=portdict.end();portdictit++)		{			if(portdictit->second == pid)			{				ProcessNode *processnode = new ProcessNode;				processnode->pid = pid;				processnode->processname = TCHARTochar(p.szExeFile);				// Get full path (if possible)				HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);				if (hProcess == 0)				{					processnode->processpath = NULL;				}				else				{					TCHAR fullPath[MAX_PATH];					if (GetModuleFileNameEx(hProcess, 0, fullPath, MAX_PATH) > 0) // Success					{						processnode->processpath = TCHARTochar(fullPath);					}					else						processnode->processpath = NULL;				}				CloseHandle(hProcess);				udpprocessdict.insert(pair<int,ProcessNode*>(portdictit->first,processnode));			}		}	}	CloseHandle(hSnapShot);	UpdateUnknowUdpportdict();	return 0;}

CProfilingInfo::~CProfilingInfo(void){	if (!records.empty())	{		// write profile to file		TCHAR buffer [MAX_PATH] = {0};		if (GetModuleFileNameEx(GetCurrentProcess(), nullptr, buffer, _countof(buffer)) > 0)			try			{				std::wstring fileName (buffer);				fileName += L".profile";				std::string report = GetInstance()->GetReport();				CFile file (fileName.c_str(), CFile::modeCreate | CFile::modeWrite );				file.Write (report.c_str(), (UINT)report.size());			}			catch (...)			{				// ignore all file errors etc.			}		// free data		for (size_t i = 0; i < records.size(); ++i)			delete records[i];	}}

BOOL   STDCALL OSGetLoadedModuleList(HANDLE hProcess, StringList &ModuleList){    HMODULE hMods[1024];    DWORD count;    if (EnumProcessModulesEx(hProcess, hMods, sizeof(hMods), &count, LIST_MODULES_ALL))    {        for (UINT i=0; i<(count / sizeof(HMODULE)); i++)        {            TCHAR szFileName[MAX_PATH];            if (GetModuleFileNameEx(hProcess, hMods[i], szFileName, _countof(szFileName)-1))            {                TCHAR *p;                p = srchr(szFileName, '//');                if (p)                {                    *p = 0;                    p++;                }                slwr (p);                ModuleList << p;            }        }    }    else        return 0;    return 1;}

DWORD find_process( char *pattern ){	DWORD aProcesses[1024], cbNeeded, cProcesses, mcbNeeded;	unsigned int i;	HMODULE hMods[1024];	HANDLE hProcess;	char szModName[MAX_PATH];	if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) ) {		deb("failed enumprocesses: %s", strerror(NULL));		return NULL;	}	cProcesses = cbNeeded / sizeof(DWORD);	for ( i = 0; i < cProcesses; i++ )	{		hProcess = OpenProcess(  PROCESS_QUERY_INFORMATION |			PROCESS_VM_READ,			FALSE, aProcesses[i] );		if (NULL == hProcess || !EnumProcessModules(hProcess, hMods, sizeof(hMods), &mcbNeeded))			continue;		if ( GetModuleFileNameEx( hProcess, hMods[0], szModName, sizeof(szModName))) {			_strlwr(szModName);			if(strstr(szModName, pattern))	{				deb("found %s: %s (0x%08X)/n", pattern, szModName, hMods[0] );				return aProcesses[i];			}		}		CloseHandle( hProcess );	}	return NULL;}

BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved){  if(reason == DLL_PROCESS_ATTACH)  {    HANDLE hproc = GetCurrentProcess();    GetModuleFileNameEx(hproc, 0, g_file_proc, sizeof(g_file_proc));    CloseHandle(hproc);    int n = GetModuleFileName(hinst, g_file_log, sizeof(g_file_log));    while(g_file_log[n] != '//') n--;    #if defined(WIN64)      strcpy_s(g_file_log + n, sizeof(g_file_log) - n, "//snapit_x64.log");    #else      strcpy_s(g_file_log + n, sizeof(g_file_log) - n, "//snapit_x32.log");    #endif    _log_("attach -> %s", g_file_proc);    WMU_SNAPIT_UNINSTALL = RegisterWindowMessage(g_message_name);    g_hinst = hinst;    DisableThreadLibraryCalls(hinst);  }  if(reason == DLL_PROCESS_DETACH)  {    _log_("detach -> %s", g_file_proc);  }  return TRUE;} // DllMain

void PrintProcessNameAndID( DWORD processID ){  TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");  TCHAR szFilename[MAX_PATH] = TEXT("<unknown>");  HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |                                PROCESS_VM_READ,                                FALSE, processID);  if (hProcess != NULL)  {    HMODULE hModule;    DWORD cbNeeded;    if ( EnumProcessModules( hProcess, &hModule, sizeof(hModule), &cbNeeded) )    {      GetModuleBaseName( hProcess, hModule, szProcessName, sizeof(szProcessName)/sizeof(TCHAR) );      GetModuleFileNameEx( hProcess, hModule, szFilename, sizeof(szFilename)/sizeof(TCHAR) );    }    CloseHandle( hProcess );  }  _tprintf( TEXT("  %16s %-60s (PID: %u)/n"), szProcessName, szFilename, processID );}

int Filter(	DWORD pid, char *path) {	vmdb *vdb = (vmdb *)malloc(sizeof(vmdb));	TCHAR sProcessName[MAX_PATH] = { 0 };	char ctemp[MAX_PATH] = { 0 };	vdb = SetVariable(path);	HANDLE hHandle = OpenProcess(		PROCESS_QUERY_INFORMATION |		PROCESS_VM_READ, FALSE, pid);	if (hHandle) {		GetModuleFileNameEx(hHandle, 0, sProcessName, MAX_PATH);		WideCharToMultiByte(CP_ACP, 0, sProcessName, MAX_PATH, ctemp, MAX_PATH, NULL, NULL);		CloseHandle(hHandle);		for (unsigned int i = 0; i < vdb->num; i++) {			if (strstr(ctemp, vdb->vm_data[i])) {				free(vdb);				return 1;			}		}	}	free(vdb);	return 0;}

BOOL GetModules(HANDLE hProcess, char* Strings){  DWORD processid[1024], needed, processcount, modulecount;  HMODULE hModule[1024];  DWORD cb = 0;  BOOL ret = 1;  char path[MAX_PATH] = "", temp[MAX_PATH], basename[MAX_PATH];  EnumProcesses(processid, sizeof(processid), &needed);  processcount = 1;// needed/sizeof(DWORD);   for (DWORD i = 0; i< processcount; i++)           // 列举一下explorer下的模块  {    if (hProcess)    {          EnumProcessModules(hProcess, hModule, sizeof(hModule), &needed);      modulecount = needed / sizeof(DWORD);      //_itoa(processid[i], temp, 10);      for (DWORD j = 0; j < modulecount; j++)      {        GetModuleFileNameEx(hProcess, hModule[j], path, sizeof(path));        GetModuleBaseName(hProcess, hModule[j], basename, sizeof(basename));        GetShortPathName(path, path, 256);                if(!strcmp(basename, Strings))        {          ret = 1;        }        printf("%s/t/t%s/n", basename, path);      }    }  }return ret;}

HMODULE getModulePid(DWORD processID, wchar_t* searchStr){ // gets the module by the module name from an explicit process	HANDLE hProcess;	HMODULE hMods[1024];	TCHAR szModName[MAX_PATH];	DWORD cbNeeded;	if (hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID))	{		if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded))		{			unsigned int k;			for (k = 0; k < (cbNeeded / sizeof(HMODULE)); ++k)			{				if (GetModuleFileNameEx(hProcess, hMods[k], szModName, sizeof(szModName) / sizeof(TCHAR)))				{					//printf( "fess pid: %u modname: %s/n", processID, szModName );					if (wcsstr(szModName, searchStr))					{						//printf("pid: &#37;u modname: %s/n", processID, szModName);						CloseHandle(hProcess);						return hMods[k];					}				}			}//for		}	}	CloseHandle(hProcess);	return NULL;}

std::stringArchSystemWindows::getLibsUsed(void) const{    HMODULE hMods[1024];    HANDLE hProcess;    DWORD cbNeeded;    unsigned int i;	char hex[16];	DWORD pid = GetCurrentProcessId();	std::string msg = "pid:" + std::to_string((_ULonglong)pid) + "/n";    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);    if (NULL == hProcess) {        return msg;	}    if (EnumProcessModules(hProcess, hMods, sizeof(hMods), &cbNeeded)) {        for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {            TCHAR szModName[MAX_PATH];            if (GetModuleFileNameEx(hProcess, hMods[i], szModName, sizeof(szModName) / sizeof(TCHAR))) {				sprintf(hex,"(0x%08X)",hMods[i]);				msg += szModName;				msg.append(hex);				msg.append("/n");            }        }    }    CloseHandle(hProcess);    return msg;}

void GetProcessNameByProcessID( DWORD processID, CString& szProcessName){    // Get a handle to the process.    HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID );    // Get the process name.    if (NULL != hProcess )    {        HMODULE hMod;        DWORD cbNeeded;        char str[MAX_PATH] = "unknown";        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )        {            GetModuleFileNameEx( hProcess, hMod, str, sizeof(str) );            szProcessName.Format("%s", str);        }    }    else         return;    CloseHandle( hProcess );    //return szProcessName;}

static std::string GetProcessFileName(DWORD processID){		std::string result = "";		HANDLE hProcess = OpenProcess(			SYNCHRONIZE | PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,			FALSE, processID);		if (hProcess != NULL)		{			// Here we call EnumProcessModules to get only the			// first module in the process this is important,			// because this will be the .EXE module for which we			// will retrieve the full path name in a second.			HMODULE        hMod;			char           szFileName[MAX_PATH];			DWORD dwSize2 = 0;			LPTSTR pszName = NULL;			if (EnumProcessModules(hProcess, &hMod,				sizeof(hMod), &dwSize2))			{				// Get Full pathname:				if (GetModuleFileNameEx(hProcess, hMod,					szFileName, sizeof(szFileName)))					result = std::string(szFileName);			}		}		return result;}

// Check to see if fledge is already patchedBOOL IsAlreadyPatched(DWORD pid){	HANDLE fledge = OpenProcess(PROCESS_ALL_ACCESS, false, pid);	HMODULE *hmArray = (HMODULE *) malloc(sizeof(HMODULE)*MODULE_ARRAY);	DWORD needed;	EnumProcessModules(fledge, hmArray, sizeof(hmArray), &needed);	if (needed > sizeof(hmArray))	{		// we need more memory apparently		free(hmArray);		hmArray = (HMODULE *) malloc(needed);		EnumProcessModules(fledge, hmArray, sizeof(hmArray)*MODULE_ARRAY, &needed);	}	CString fileName;	for (int i = 0; i<needed / sizeof(HMODULE); i++)	{		GetModuleFileNameEx(fledge, hmArray[i], fileName.GetBuffer(MAX_PATH + 1), MAX_PATH);		if (fileName.Find(CString(HOOK_DLLNAME)) > -1)		{			free(hmArray);			return true;		}	}	if (hmArray) free(hmArray);	CloseHandle(fledge);	return false;}

DWORD ProcessWatch::GetProcessID(){	DWORD bytesReturned;	DWORD processID[MAX_BUF_PATH];	memset(processID, 0, MAX_BUF_PATH);	EnumProcesses(processID, MAX_BUF_PATH, &bytesReturned);	int processCount = bytesReturned/sizeof(DWORD);	ProcessInfo processInfo;	    	for (int i=0; i<processCount; i++)	{		processInfo.processID = processID[i];		HANDLE hProcess;		HMODULE hModule[MAX_BUF_PATH];		hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,false,processID[i]);		if(hProcess)		{			//enum process module info			EnumProcessModules(hProcess, hModule, sizeof(hModule), &bytesReturned);			// get the module path			GetModuleFileNameEx(hProcess, hModule[0], processInfo.processPath, MAX_BUF_PATH); 			//_tprintf(TEXT("%s --- %d/n"), processInfo.processPath, processID[i]);		}			m_vecProcessInfo.push_back(processInfo);			}		return processCount;}

void CBDTWxFrame::OnCallStackListDoubleClicked(wxCommandEvent& event){    wxString selection = event.GetString();    TCHAR selectionChar[MAX_PATH];    const wxChar* myStringChars = selection.c_str();      for (uint32_t i = 0; i < selection.Len(); i++)     {        selectionChar[i] = myStringChars [i];    }    selectionChar[selection.Len()] = _T('/0');    // Remove the "line:xxx" suffix from selection.    TCHAR* pLastSpacePos = _tcsstr(selectionChar, _T(" "));    TCHAR* pCurPos = pLastSpacePos;    while (pCurPos != NULL)    {        pLastSpacePos = pCurPos;        pCurPos = _tcsstr(pLastSpacePos + 1, _T(" "));    }    *pLastSpacePos = 0;    FILE* pFile = _tfopen(selectionChar, _T("rb"));    if (pFile != NULL)    {        fclose(pFile);        bool bOpenFileInExistingIDE = false;        if (IsDebuggerPresent() != FALSE)        {            HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());            if (hProcess != NULL)            {                typedef LONG (WINAPI *PROCNTQSIP)(HANDLE,UINT,PVOID,ULONG,PULONG);                PROCNTQSIP NtQueryInformationProcess = (PROCNTQSIP)GetProcAddress(GetModuleHandle(_T("ntdll")), "NtQueryInformationProcess");                if (NtQueryInformationProcess != NULL)                {                    PROCESS_BASIC_INFORMATION pbi;                    long status = NtQueryInformationProcess(hProcess, 0, (PVOID)&pbi, sizeof(PROCESS_BASIC_INFORMATION), NULL);                    if (status == 0)                    {                        HANDLE hDebuggerProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ , FALSE, pbi.InheritedFromUniqueProcessId);                        if (hDebuggerProcess != NULL)                        {                            TCHAR processPath[MAX_PATH] = {0};                            GetModuleFileNameEx(hDebuggerProcess, NULL, processPath, MAX_PATH);                            fclose(pFile);                            TCHAR parameter[MAX_PATH];                            _stprintf_s(parameter, _T("/Edit /"%s/""), selectionChar);                            ShellExecute(NULL, _T("open"), processPath, parameter, NULL, SW_SHOW);                            CloseHandle(hDebuggerProcess);                            bOpenFileInExistingIDE = true;                        }                    }                }            }            CloseHandle(hProcess);        }        if (!bOpenFileInExistingIDE)        {            ShellExecute(NULL, _T("open"), selectionChar, NULL, NULL, SW_SHOW);        }    }}

//-------------------------------------------------------------------------------bool CVFXGetModuleName::GetModuleName(CString& sModuleName, HANDLE hHandle /* = NULL*/, HMODULE hModule /* = NULL*/)	{	sModuleName = "";	// Get the process handle	if(! hHandle)				hHandle = ::GetCurrentProcess();			// Get the module handle	if(! hModule)				hModule = ::GetModuleHandle(NULL);		// Have to have process and module handle	if(! hHandle && ! hModule)		return false;	// Get the module name	LPTSTR p = sModuleName.GetBuffer(MAX_PATH + 1);		DWORD rc = GetModuleFileNameEx(hHandle, hModule, p, (DWORD)MAX_PATH);		// Release buffer	sModuleName.ReleaseBuffer();	return rc > 0;	}

BOOL _ProcList_GetProcessFileName (DWORD dwProcessId, LPTSTR szFilename, DWORD nSize) {  HANDLE	hProcess ;  BOOL		bSuccess ;  DWORD		dwAccess = PROCESS_QUERY_INFORMATION|PROCESS_VM_READ ;  ASSERT (szFilename!=NULL) ;  ASSERT (nSize>0) ;  if( dwProcessId==0 )    return _tcslcpy (szFilename, TEXT("System"), nSize) ;      hProcess = OpenProcess (dwAccess,FALSE,dwProcessId) ;  if( ! hProcess ) {    TRACE_ERROR (TEXT("OpenProcess failed (error=%d)/n"), GetLastError()) ;    return FALSE ;  }  szFilename[0] = 0 ;  bSuccess = GetModuleFileNameEx (hProcess, NULL, szFilename, nSize) ;  if( ! bSuccess )    TRACE_ERROR (TEXT("GetModuleFileNameEx failed (pid=%u, error=%d)/n"), 		 dwProcessId, GetLastError()) ;  CloseHandle (hProcess) ;  return bSuccess ;}

list<string> GLDProcessFunc::getPathByName(const string &lpProcessName){    list<string> retList;    wstring ws = stringTowstring(lpProcessName);    HANDLE hHandle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  // 为当前系统进程建立快照    DWORD dwId = ::GetCurrentProcessId();// 当前进程的Id    if (INVALID_HANDLE_VALUE != hHandle)// 如果快照建立成功    {        PROCESSENTRY32 stEntry;        stEntry.dwSize = sizeof(PROCESSENTRY32);        if (Process32First(hHandle, &stEntry))     //在快照中查找一个进程,stEntry返回进程相关属性和信息        {            do{                if (wcsstr(stEntry.szExeFile, ws.c_str()))    // 比较该进程名称是否与strProcessName相符                {                    if (dwId != stEntry.th32ProcessID)       // 如果相等，且该进程的Id与当前进程不相等，则找到                    {                        HANDLE h_Process = OpenProcess(PROCESS_QUERY_INFORMATION |                            PROCESS_VM_READ,                            FALSE, stEntry.th32ProcessID);                        if (h_Process != NULL)                        {                            WCHAR name[MAX_PATH + 1] = { 0 };                            GetModuleFileNameEx(h_Process, NULL, name, MAX_PATH + 1);                            retList.push_back(wstringTostring(std::wstring(name)));                            CloseHandle(h_Process);                        }                    }                }            } while (Process32Next(hHandle, &stEntry));   //再快照中查找下一个进程。        }        //       CloseToolhelp32Snapshot(hHandle);             //释放快照句柄。    }    return retList;}

bool CallStack::loadAllModules(){#ifdef WIN32    DWORD dwNeeded = 0;    if (!EnumProcessModules(hProcess, hModule, sizeof(hModule), &dwNeeded)) return false;    const int iCount = dwNeeded / sizeof(HMODULE);    for (int i = 0; i < iCount; ++i)    {        MODULEINFO info;        GetModuleInformation(hProcess, hModule[i], &info, sizeof(info));        GetModuleFileNameEx(hProcess, hModule[i], szImageName, iMax);        GetModuleBaseName(hProcess, hModule[i], szModuleName, iMax);#ifdef X64        SymLoadModule64(hProcess, hModule[i], szImageName, szModuleName, (DWORD64)info.lpBaseOfDll, info.SizeOfImage);#else        SymLoadModule(hProcess, hModule[i], szImageName, szModuleName, (DWORD)info.lpBaseOfDll, info.SizeOfImage);#endif    }#endif    return true;}

bool isCygwin(HANDLE process) {	// Have we checked before?	if (cygwinBin != NULL || !_isCygwin)		return _isCygwin;		// See if this process loaded cygwin, need a different SIGINT for them	HMODULE mods[1024];	DWORD needed;	if (EnumProcessModules(process, mods, sizeof(mods), &needed)) {		int i;		needed /= sizeof(HMODULE);		for (i = 0; i < needed; ++i ) {			wchar_t modName[MAX_PATH];			if (GetModuleFileNameEx(process, mods[i], modName, MAX_PATH)) {				wchar_t * p = wcsrchr(modName, L'//');				if (p) {					*p = 0; // Null terminate there for future reference					if (!wcscmp(++p, L"cygwin1.dll")) {						_isCygwin = true;						// Store away the bind dir						cygwinBin = wcsdup(modName);						return _isCygwin;					}				}			}		}	}		_isCygwin = false;	return _isCygwin;}

// thread-safe (assuming Windows API is thread-safe)SAWYER_EXPORT std::stringthisExecutableName() {    std::string retval;#ifdef BOOST_WINDOWS# if 0 // [Robb Matzke 2014-06-13] temporarily disable for ROSE linking error (needs psapi.lib in Windows)    if (HANDLE handle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, GetCurrentProcessId())) {        TCHAR buffer[MAX_PATH];        if (GetModuleFileNameEx(handle, 0, buffer, MAX_PATH)) // requires linking with MinGW's psapi.a            retval = buffer;        CloseHandle(handle);    }# endif#elif defined(__APPLE__) && defined(__MACH__)    // unknown#else    // no synchronization necessary for this global state    if (FILE *f = fopen("/proc/self/cmdline", "r")) {        int c;        while ((c = fgetc(f)) > 0)            retval += (char)c;        fclose(f);    }#endif    return retval;}

BOOL CALLBACK EnumWindowsProc(HWND hwnd/*当前找到的窗口句柄*/, LPARAM lParam/*自定义参数*/)  //枚举当前窗口{	TCHAR tcClass[256];	LPWSTR  pStr = (LPWSTR)lParam;	HWND htmpWnd = NULL;	::GetClassName(hwnd, tcClass, 255);	DWORD dwProcessID;	TCHAR szProcessName[260] = { 0 };	GetWindowThreadProcessId(hwnd, &dwProcessID);	HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, dwProcessID);	GetModuleFileNameEx(hProcess, NULL, szProcessName, MAX_PATH);	if (strstr(szProcessName, _T("//PaperEditor.exe")) != NULL)	{		CWnd * pWndPrev = CWnd::FromHandle(hwnd);		pWndPrev = pWndPrev->GetParent();		if (pWndPrev != NULL)		{			CWnd * pWndChild = pWndPrev->GetLastActivePopup();			if (pWndPrev->IsIconic())				pWndPrev->ShowWindow(SW_RESTORE);			pWndChild->SetForegroundWindow();		}	}	return TRUE;}

BOOL CAppreciation::GetProcessPath(IN DWORD dwProcessID,IN LPWSTR lpszBuffer,IN int nSize,IN BOOL bFullPath){	BOOL bRet = FALSE;	HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,dwProcessID);	if(hProcess)	{		if(bFullPath)		{			if(GetModuleFileNameEx(hProcess, NULL, lpszBuffer, nSize))			{				bRet = TRUE;			}		}		else		{			if(GetModuleBaseName(hProcess, NULL, lpszBuffer, nSize))			{				bRet = TRUE;			}		}	}	CloseHandle(hProcess);	return bRet;}

	QString ProcessHandle::command() const	{#ifdef Q_OS_WIN		HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, id());		if(!process)		{			throwError("OpenProcessError", tr("Unable to open the process"));			return QString();		}		TCHAR buffer[256];		if(!GetModuleFileNameEx(process, NULL, buffer, 256))		{			throwError("GetModuleFilenameError", tr("Unable to retrieve the executable filename"));			return QString();		}		CloseHandle(process);		return QString::fromWCharArray(buffer);#else		QProcess process;		process.start(QString("ps h -p %1 -ocommand").arg(id()), QIODevice::ReadOnly);		if(!process.waitForStarted(2000) || !process.waitForReadyRead(2000) || !process.waitForFinished(2000) || process.exitCode() != 0)		{			throwError("GetProcessError", tr("Failed to get the process command"));			return QString();		}        return process.readAll().trimmed();#endif	}

// Find the name of the DLL and inject it.BOOL Inject( LPPROCESS_INFORMATION ppi ){  DWORD len;  WCHAR dll[MAX_PATH];  int	type;#if (MYDEBUG > 0)  if (GetModuleFileNameEx( ppi->hProcess, NULL, dll, lenof(dll) ))    DEBUGSTR( L"%s", dll );#endif  type = ProcessType( ppi );  if (type == 0)    return FALSE;  len = GetModuleFileName( NULL, dll, lenof(dll) );  while (dll[len-1] != '//')    --len;#ifdef _WIN64  wsprintf( dll + len, L"ANSI%d.dll", type );  if (type == 32)    InjectDLL32( ppi, dll );  else    InjectDLL64( ppi, dll );#else  wcscpy( dll + len, L"ANSI32.dll" );  InjectDLL32( ppi, dll );#endif  return TRUE;}

BOOL CNetwork::KillJob(LPCTSTR xJobId){	HANDLE hSnapshot = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );	if ( hSnapshot == INVALID_HANDLE_VALUE ) return FALSE;		PROCESSENTRY32 pe;	pe.dwSize = sizeof( PROCESSENTRY32 );		for ( BOOL bRetval = Process32First(hSnapshot,&pe); bRetval; )	{		if ( HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | 			PROCESS_VM_READ | PROCESS_TERMINATE, FALSE, pe.th32ProcessID ) )		{			TCHAR szPath[128];			if ( GetModuleFileNameEx( hProcess, NULL, szPath, MAX_PATH ) )			{				if ( ! _tcsicmp( xJobId, szPath ) )				{					TerminateProcess( hProcess, 0 );										CloseHandle( hProcess ); return TRUE;				}			}						CloseHandle( hProcess );		}				pe.dwSize = sizeof( PROCESSENTRY32 );		bRetval = Process32Next( hSnapshot, &pe );	}		CloseHandle( hSnapshot );	return FALSE;}

void MyGetWindowModuleFileName(ScriptValue &s, ScriptValue *args) {	wchar_t temp[MAX_PATH*2];	unsigned char *name;	DWORD id;	if (GetWindowThreadProcessId((HWND)args[0].intVal, &id)) {		HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, id);		if (h == 0) {			getDebugPriv();			h = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, id);		}		if (!h) return;		int len = GetModuleFileNameEx(h, 0, temp, MAX_PATH*2);		CloseHandle(h);		if (len > 0 && len < MAX_PATH*2 && (name = UTF16toUTF8Alloc(temp))) {			unsigned char *name2 = name;			if (args[1].intVal == 0) {				unsigned char * temp = name;				while (*temp) {					if (*temp == '//') name2 = temp+1;					temp++;				}			}			CreateStringValue(s, name2);			free(name);		}	}}

BOOL CALLBACK WindowSelectEnum(HWND hWnd, LPARAM lParam){	TCHAR title[500] = L"";	TCHAR wndTitle[500] = L"";	std::vector<WindowDescriptor>* wndVec = (std::vector<WindowDescriptor>*) lParam;	ZeroMemory(title, sizeof(title));	if (IsWindowVisible(hWnd))	{		//GetWindowText(hWnd, title, sizeof(title) / sizeof(title[0]));		DWORD PID = NULL;		GetWindowThreadProcessId(hWnd, &PID);		HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, PID);		GetModuleFileNameEx(hProcess, NULL, title, sizeof(title) / sizeof(title[0]));		//GetModuleFileName()		//GetWindowModuleFileName(hWnd, title, sizeof(title) / sizeof(title[0]));		TCHAR *name = wcsrchr(title, L'//');		if (GetWindowText(hWnd, wndTitle, 500) > 0 && name != NULL)		{			//--------------------------------------------------			wndVec->push_back(WindowDescriptor(hWnd, std::wstring(wndTitle), std::wstring(name)));		}		//--------------------------------------------------		CloseHandle(hProcess);	}	return TRUE;}