Function hook_patch

src/library/hookpatch.cpp:716–770

}

void hook_patch(const char* name, const char* library, void** tramp_function, void* my_function)
{
    const char* libpathstr = NULL;
    void* handle;
    
    if (library) {
        /* Find the path to the library */
        std::string libpath = find_lib(library);
        
        if (libpath.empty()) {
            LOG(LL_ERROR, LCF_HOOK, "Could not find %s path", library);
            return;
        }

        libpathstr = libpath.c_str();
    }

    /* Open library */
    NATIVECALL(handle = dlopen(libpathstr, RTLD_LAZY));

    if (!handle) {
        LOG(LL_ERROR, LCF_HOOK, "Could not load %s", library);
        return;
    }

    /* Load function */
    void *orig_fun;
    NATIVECALL(orig_fun = dlsym(handle, name));

    if (!orig_fun && !library) {
        /* If the symbol was not found, and if looking into the executable,
         * ask libtas program to get the symbol address from the program elf
         * header (much slower). We can't look into our own memory, because
         * the .symtab and .strtab sections of the executable are not loaded
         * in memory by the loader.
         * I don't really want to do it here, because it relies on spawning
         * another process to run `readelf`.
         */
        sendMessage(MSGB_SYMBOL_ADDRESS);
        std::string symstr(name);
        sendString(symstr);

        uint64_t addr;
        receiveData(&addr, sizeof(uint64_t));
        if (addr)
            memcpy(&orig_fun, &addr, sizeof(void*));
    }

    if (!orig_fun)
        return;

    LOG(LL_DEBUG, LCF_HOOK, "Patching function %s", name);

    hook_patch_addr(orig_fun, tramp_function, my_function);
}

void hook_patch_addr(void *orig_fun, void** tramp_function, void* my_function)
{