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::string
ArchSystemWindows::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 patched
BOOL 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;
}