C++ ModulesMap类代码示例

void
patchDescriptor(HMODULE hModule,
                const char *szModule,
                T pImportDescriptor)
{
    const char* szDescriptorName = getDescriptorName(hModule, pImportDescriptor);

    ModulesMap::const_iterator modIt = modulesMap.find(szDescriptorName);
    if (modIt != modulesMap.end()) {
        const char *szMatchModule = modIt->first; // same as szDescriptorName
        const Module & module = modIt->second;

        const FunctionMap & functionMap = module.functionMap;
        FunctionMap::const_iterator fnIt;
        for (fnIt = functionMap.begin(); fnIt != functionMap.end(); ++fnIt) {
            const char *szFunctionName = fnIt->first;
            LPVOID lpNewAddress = fnIt->second;

            BOOL bHooked;
            bHooked = patchFunction(hModule, szModule, szMatchModule, pImportDescriptor, szFunctionName, lpNewAddress);
            if (bHooked && !module.bInternal && pSharedMem) {
                pSharedMem->bReplaced = TRUE;
            }
        }
    }
}

static FARPROC WINAPI
MyGetProcAddress(HMODULE hModule, LPCSTR lpProcName) {

    if (VERBOSITY >= 3) {
        /* XXX this can cause segmentation faults */
        logGetProcAddress(hModule, lpProcName);
    }

    if (!NOOP) {
        char szModule[MAX_PATH];
        DWORD dwRet = GetModuleFileNameA(hModule, szModule, sizeof szModule);
        assert(dwRet);
        const char *szBaseName = getBaseName(szModule);

        ModulesMap::const_iterator modIt;
        modIt = modulesMap.find(szBaseName);
        if (modIt != modulesMap.end()) {
            if (VERBOSITY > 1 && VERBOSITY < 3) {
                logGetProcAddress(hModule, lpProcName);
            }

            if (HIWORD(lpProcName) == 0) {
                debugPrintf("inject: ignoring %[email protected]%u\n", szBaseName, LOWORD(lpProcName));
                return GetProcAddress(hModule, lpProcName);
            }

            const Module & module = modIt->second;
            const FunctionMap & functionMap = module.functionMap;

            FunctionMap::const_iterator fnIt;
            fnIt = functionMap.find(lpProcName);

            if (fnIt != functionMap.end()) {
                LPVOID pProcAddress = fnIt->second;
                if (VERBOSITY > 0) {
                    debugPrintf("inject: replacing %s!%s\n", szBaseName, lpProcName);
                }
                if (!module.bInternal && pSharedMem) {
                    pSharedMem->bReplaced = TRUE;
                }
                return (FARPROC)pProcAddress;
            } else {
                if (VERBOSITY > 0 && !module.bInternal) {
                    debugPrintf("inject: ignoring %s!%s\n", szBaseName, lpProcName);
                }
            }
        }
    }

    return GetProcAddress(hModule, lpProcName);
}

void
patchDescriptor(HMODULE hModule,
                const char *szModule,
                T pImportDescriptor,
                Action action)
{
    const char* szDescriptorName = getDescriptorName(hModule, pImportDescriptor);

    ModulesMap::const_iterator modIt = modulesMap.find(szDescriptorName);
    if (modIt != modulesMap.end()) {
        const char *szMatchModule = modIt->first; // same as szDescriptorName
        const Module & module = modIt->second;

        const FunctionMap & functionMap = module.functionMap;
        FunctionMap::const_iterator fnIt;
        for (fnIt = functionMap.begin(); fnIt != functionMap.end(); ++fnIt) {
            const char *szFunctionName = fnIt->first;
            LPVOID lpHookAddress = fnIt->second;

            // Knowning the real address is useful when patching imports by ordinal
            LPVOID lpRealAddress = NULL;
            HMODULE hRealModule = GetModuleHandleA(szDescriptorName);
            if (hRealModule) {
                // FIXME: this assertion can fail when the wrapper name is the same as the original DLL
                //assert(hRealModule != g_hHookModule);
                if (hRealModule != g_hHookModule) {
                    lpRealAddress = (LPVOID)GetProcAddress(hRealModule, szFunctionName);
                }
            }
            
            LPVOID lpOldAddress = lpRealAddress;
            LPVOID lpNewAddress = lpHookAddress;

            if (action == ACTION_UNHOOK) {
                std::swap(lpOldAddress, lpNewAddress);
            }

            BOOL bPatched;
            bPatched = patchFunction(hModule, szModule, szMatchModule, pImportDescriptor, szFunctionName, lpOldAddress, lpNewAddress);
            if (action == ACTION_HOOK && bPatched && !module.bInternal && pSharedMem) {
                pSharedMem->bReplaced = TRUE;
            }
        }
    }
}

static void
dumpRegisteredHooks(void)
{
    if (VERBOSITY > 1) {
        ModulesMap::const_iterator modIt;
        for (modIt = modulesMap.begin(); modIt != modulesMap.end(); ++modIt) {
            const char *szMatchModule = modIt->first;
            const Module & module = modIt->second;
            const FunctionMap & functionMap = module.functionMap;
            FunctionMap::const_iterator fnIt;
            for (fnIt = functionMap.begin(); fnIt != functionMap.end(); ++fnIt) {
                const char *szFunctionName = fnIt->first;
                debugPrintf("inject: registered hook for %s!%s%s\n",
                            szMatchModule, szFunctionName,
                            module.bInternal ? " (internal)" : "");
            }
        }
    }
}

void ModuleRegistry::unloadModules()
{
	_uninitialisedModules.clear();
    
    // greebo: It's entirely possible that the clear() method will clear the
    // last shared_ptr of a module. Module might still call this class' moduleExists()
    // method which in turn refers to a semi-destructed ModulesMap instance.
    // So, copy the contents to a temporary map before clearing it out.
    ModulesMap tempMap;
    tempMap.swap(_initialisedModules);
    
	tempMap.clear();

    // We need to delete all pending objects before unloading modules
    // wxWidgets needs a chance to delete them before memory access is denied
    if (wxTheApp != NULL)
    {
        wxTheApp->ProcessIdle();
    }

	_loader.unloadModules();
}

static inline bool
isMatchModuleName(const char *szModuleName)
{
    ModulesMap::const_iterator modIt = modulesMap.find(szModuleName);
    return modIt != modulesMap.end();
}

/**
 * Determine all loaded modules as well as the process module itself for the given process id.
 */
NaviError LinuxSystem::fillModules(pid_t pid, ModulesMap& modules) {
  std::string filename = "/proc/" + zylib::zycon::toString(pid) + "/maps";

  msglog->log(LOG_ALL, "Trying to read the modules map from file %s",
              filename.c_str());

  std::ifstream file(filename.c_str());

  if (!file) {
    msglog->log(LOG_ALWAYS, "Error: Couldn't read modules map file");

    return NaviErrors::COULDNT_READ_MEMORY;
  }

  std::vector < std::string > lines;

  std::string line;

  while (std::getline(file, line)) {
    msglog->log(LOG_ALL, "Successfully read line %s from modules map file",
                line.c_str());

    lines.push_back(line);
  }

// 08048000-08053000 r-xp 00000000 08:01 282412     /usr/bin/kdeinit
// 08053000-08054000 r--p 0000a000 08:01 282412     /usr/bin/kdeinit
// 08054000-08055000 rw-p 0000b000 08:01 282412     /usr/bin/kdeinit
// 09f73000-0a016000 rw-p 09f73000 00:00 0          [heap]
// b6638000-b6672000 rw-p b6672000 00:00 0
// b66bb000-b66d9000 r-xp 00000000 08:01 352021     /usr/lib/kde3/plugins/styles/plastik.so
// b66d9000-b66da000 r--p 0001d000 08:01 352021     /usr/lib/kde3/plugins/styles/plastik.so
// b66da000-b66db000 rw-p 0001e000 08:01 352021     /usr/lib/kde3/plugins/styles/plastik.so
// b66db000-b66e1000 r--s 00000000 08:01 396230     /var/cache/fontconfig/945677eb7aeaf62f1d50efc3fb3ec7d8-x86.cache-2
// b66e1000-b66e4000 r--s 00000000 08:01 396239     /var/cache/fontconfig/e383d7ea5fbe662a33d9b44caf393297-x86.cache-2
// b66e4000-b66e5000 r--s 00000000 08:01 396225     /var/cache/fontconfig/4c73fe0c47614734b17d736dbde7580a-x86.cache-2
// b66e5000-b66e8000 r--s 00000000 08:01 396231     /var/cache/fontconfig/a755afe4a08bf5b97852ceb7400b47bc-x86.cache-2
// b66e8000-b66ef000 r--s 00000000 08:01 396608     /var/cache/fontconfig/6d41288fd70b0be22e8c3a91e032eec0-x86.cache-2
// b66ef000-b66f7000 r--s 00000000 08:01 396240     /var/cache/fontconfig/e3de0de479f42330eadf588a55fb5bf4-x86.cache-2
// b66f7000-b6702000 r--s 00000000 08:01 396220     /var/cache/fontconfig/0f34bcd4b6ee430af32735b75db7f02b-x86.cache-2
// b6702000-b6709000 r--s 00000000 08:01 396234     /var/cache/fontconfig/d52a8644073d54c13679302ca1180695-x86.cache-2

  std::string lastName = "";
  CPUADDRESS start = 0;
  CPUADDRESS end = 0;

  for (std::vector<std::string>::iterator Iter = lines.begin();
      Iter != lines.end(); ++Iter) {
    std::string line = *Iter;

    size_t position = line.find("/");

    if (position != std::string::npos) {
      // OK, we found a line with a name; now we gotta figure out if we found a new module
      // or just with a new section in the same module.

      std::string name = line.substr(position);

      // TODO: Only works in 32bit platforms
      std::string startString = Iter->substr(0, 8);
      std::string endString = Iter->substr(9, 8);

      if (name != lastName) {
        // We found a new module, so we can take the information from the previous
        // module and add  the previous module to the list of modules.

        if (lastName != "") {
          Module newModule(getModuleName(lastName), lastName, start,
                           end - start);
          modules.insert(std::make_pair(lastName, newModule));
        }

        lastName = name;
        start = zylib::zycon::parseHexString < CPUADDRESS > (startString);
        end = zylib::zycon::parseHexString < CPUADDRESS > (endString);
      } else {
        // The module in the current line is the same module we already processed
        // in the previous line. Only the end information has to be updated in this
        // case.

        end = zylib::zycon::parseHexString < CPUADDRESS > (endString);
      }
    } else if (lastName != "") {
      // We found a line without a name and the previous module has
      // a valid name => Add the previous module to the list of modules.

      Module newModule(getModuleName(lastName), lastName, start, end - start);
      modules.insert(std::make_pair(lastName, newModule));

      lastName = "";
    }
  }

  if (lastName != "") {
    // Add the last module in the list.

    Module newModule(getModuleName(lastName), lastName, start, end - start);
//.........这里部分代码省略.........