Make header compatible with C

As such, it is also renamed dlhook.h
Build compatibility has been expanded to C++14
Test compatibility has been expanded to Clang

Author: AeroStun

CMakeLists.txt

@@ -3,10 +3,9 @@ cmake_minimum_required (VERSION 3.16)
 project (dlhook)
 
 add_library (dlhook SHARED)
-target_compile_features (dlhook PRIVATE cxx_std_17)
+target_compile_features (dlhook PRIVATE cxx_std_14)
 target_include_directories (dlhook PUBLIC include)
-target_compile_options (dlhook PRIVATE -Wno-pointer-arith)
-target_sources (dlhook PRIVATE src/dlhook.cxx include/dlhook.hxx)
+target_sources (dlhook PRIVATE src/dlhook.cxx include/dlhook.h)
 
 if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
   include (CTest)

README.md

@@ -2,8 +2,7 @@
 
 An extension to the dlfcn.h family, for attaching hooks to functions from DSOs.
 
-Requires C++17 to build, but also to interface.
-Interface will be switched over to C-compat eventually.
+Requires C++14 to build, but the interface is C compatible.
 
 Supported platforms:
 - Linux amd64 (manually tested), aarch64 (untested yet)
@@ -21,14 +20,14 @@ Synopsis:
 /// @param hook replacement entry for @a symbol.
 /// @return the original address found in the PLT
 /// @note if an error occurs, the program will be aborted
-void* dlhook_sym(void* handle, std::string_view symbol, void* hook);
+void* dlhook_sym(void* handle, const char* symbol, void* hook);
 
 /// Hooks the PLT entries of @a symbol with @a hook in all currently loaded objects.
 ///
 /// @param symbol which symbol to hook in the PLT of @a handle.
 /// @param hook replacement entry for @a symbol.
 /// @note if an error occurs, it will be safely ignored.
-void dlhook_sym_all(std::string_view symbol, void* hook);
+void dlhook_sym_all(const char* symbol, void* hook);
 
 // Hook by address
 

include/dlhook.hxx include/dlhook.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 AeroStun
+ * Copyright 2023-2024 AeroStun
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,9 @@
 #ifndef DLHOOK_HXX
 #define DLHOOK_HXX
 
-#include <string_view>
+#ifdef __cplusplus
+extern "C" {
+#endif
 
 // Hook by symbol
 
@@ -28,14 +30,14 @@
 /// @param hook replacement entry for @a symbol.
 /// @return the original address found in the PLT
 /// @note if an error occurs, the program will be aborted
-void* dlhook_sym(void* handle, std::string_view symbol, void* hook);
+void* dlhook_sym(void* handle, const char* symbol, void* hook);
 
 /// Hooks the PLT entries of @a symbol with @a hook in all currently loaded objects.
 ///
 /// @param symbol which symbol to hook in the PLT of @a handle.
 /// @param hook replacement entry for @a symbol.
 /// @note if an error occurs, it will be safely ignored.
-void dlhook_sym_all(std::string_view symbol, void* hook);
+void dlhook_sym_all(const char* symbol, void* hook);
 
 // Hook by address
 
@@ -55,4 +57,8 @@ void dlhook_addr(void* handle, void* original, void* hook);
 /// @note if an error occurs, the program will be aborted.
 void dlhook_addr_all(void* original, void* hook);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

src/dlhook.cxx

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 AeroStun
+ * Copyright 2023-2024 AeroStun
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,8 +16,8 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <cstring>
 #include <map>
-#include <string>
 
 #if defined(__linux__) && !defined(_GNU_SOURCE)
 #    define _GNU_SOURCE
@@ -38,7 +38,7 @@
 
 #include <unistd.h>
 
-#include "dlhook.hxx"
+#include "dlhook.h"
 
 #if !defined(R_X86_64_JUMP_SLOT) && defined(R_X86_64_JMP_SLOT)
 #    define R_X86_64_JUMP_SLOT R_X86_64_JMP_SLOT
@@ -68,7 +68,7 @@ struct MaybeAddr {
 using DlLinkMap = struct link_map;
 
 struct ObjectPltData {
-    void* plt_addr_base{nullptr};
+    std::uintptr_t plt_addr_base{0U};
 
     const Elf64_Sym* dynsym{nullptr};
 
@@ -138,7 +138,7 @@ static const DlLinkMap* get_lmap_for_handle(void* const handle) {
 }
 
 template <class T>
-void force_write(T& dst, const T value) {
+static void force_write(T& dst, const T value) {
 #if defined(__linux__)
     // Set new target using FOLL_FORCE
     const int proc_self_mem = get_state().proc_self_mem;
@@ -170,7 +170,7 @@ void force_write(T& dst, const T value) {
 static ObjectPltData inspect_object(DlLinkMap const* obj_lmap) {
     ObjectPltData ret{};
 
-    ret.plt_addr_base = reinterpret_cast<void*>(obj_lmap->l_addr);
+    ret.plt_addr_base = reinterpret_cast<std::uintptr_t>(obj_lmap->l_addr);
 
     // Locate symbol table
     const Elf64_Dyn* dyn_symtab = find_dyn_by_tag(obj_lmap->l_ld, DT_SYMTAB);
@@ -242,15 +242,15 @@ static ObjectPltData inspect_object(DlLinkMap const* obj_lmap) {
 
 template <class Callback>
 static void foreach_plt_or_got(const ObjectPltData& obj, Callback&& callback) {
-    auto filter_relas = [&](const auto& rela, const Elf64_Xword reloc_type) -> bool {
+    auto const filter_relas = [&](const auto& rela, const Elf64_Xword reloc_type) -> bool {
         if (ELF64_R_TYPE(rela.r_info) == reloc_type) {
             // Sanity check of the symbol name's index
             const std::size_t idx = obj.dynsym[ELF64_R_SYM(rela.r_info)].st_name;
             if (idx + 1 > obj.dynstr_size) {
                 return false;
             }
 
-            return callback(obj.dynstr + idx, *static_cast<void**>(obj.plt_addr_base + rela.r_offset));
+            return callback(obj.dynstr + idx, *reinterpret_cast<void**>(obj.plt_addr_base + rela.r_offset));
         }
 
         return true;
@@ -275,7 +275,7 @@ static ObjectPltData get_object(const DlLinkMap* lmap) {
     ObjectPltData object{};
     if (it == obj_cache.end()) {
         object = inspect_object(lmap);
-        if (object.plt_addr_base == nullptr) {
+        if (object.plt_addr_base == 0U) {
             return {};
         }
         obj_cache.emplace(lmap, object);
@@ -286,20 +286,21 @@ static ObjectPltData get_object(const DlLinkMap* lmap) {
     return object;
 }
 
-static MaybeAddr dlhook_sym(const DlLinkMap* lmap, const std::string_view symbol, void* const hook) {
+static MaybeAddr dlhook_sym(const DlLinkMap* lmap, const char* const symbol, void* const hook) {
     if (lmap == nullptr) {
         return {};
     }
 
+    auto const symbol_length = std::strlen(symbol);
+
     MaybeAddr result{};
-    const auto callback = [symbol, hook, &result](std::string_view name, void*& ptr) -> bool {
+    const auto callback = [symbol, symbol_length, hook, &result](const char* const name, void*& ptr) -> bool {
         // if (!name.starts_with(symbol))
-        if (name.substr(0, symbol.size()) != symbol) {
+        if (std::strncmp(name, symbol, symbol_length) != 0) {
             // Keep going
             return true;
         }
-        name.remove_prefix(symbol.size());
-        if (!name.empty() && name.front() != '@') {
+        if (name[symbol_length] != '\0' && name[symbol_length] != '@') {
             // Keep going
             return true;
         }
@@ -318,13 +319,13 @@ static MaybeAddr dlhook_sym(const DlLinkMap* lmap, const std::string_view symbol
     return result;
 }
 
-void* dlhook_sym(void* const handle, const std::string_view symbol, void* const hook) {
+extern "C" void* dlhook_sym(void* const handle, const char* const symbol, void* const hook) {
     const auto result = dlhook_sym(get_lmap_for_handle(handle), symbol, hook);
     assert(result.valid);
     return result.addr;
 }
 
-void dlhook_sym_all(const std::string_view symbol, void* hook) {
+extern "C" void dlhook_sym_all(const char* symbol, void* hook) {
     for (auto it = _r_debug.r_map; it != nullptr; it = it->l_next) {
         const auto result = dlhook_sym(it, symbol, hook);
         if (!result.valid) {
@@ -338,7 +339,7 @@ static void dlhook_addr(const DlLinkMap* lmap, void* original, void* hook) {
         return;
     }
 
-    const auto callback = [original, hook](std::string_view, void*& ptr) -> bool {
+    const auto callback = [original, hook](const char*, void*& ptr) -> bool {
         if (ptr != original) {
             // Keep going
             return true;
@@ -352,9 +353,11 @@ static void dlhook_addr(const DlLinkMap* lmap, void* original, void* hook) {
     foreach_plt_or_got(get_object(lmap), callback);
 }
 
-void dlhook_addr(void* handle, void* original, void* hook) { dlhook_addr(get_lmap_for_handle(handle), original, hook); }
+extern "C" void dlhook_addr(void* handle, void* original, void* hook) {
+    dlhook_addr(get_lmap_for_handle(handle), original, hook);
+}
 
-void dlhook_addr_all(void* original, void* hook) {
+extern "C" void dlhook_addr_all(void* original, void* hook) {
     for (auto it = _r_debug.r_map; it != nullptr; it = it->l_next) {
         dlhook_addr(it, original, hook);
     }

test/test.cxx

@@ -1,20 +1,17 @@
 #include <cassert>
-#include "dlhook.hxx"
+#include "dlhook.h"
 #include "test.hxx"
 
-extern "C" int hook() {
-    return 0xF00L;
-}
+extern "C" int hook() { return 0xF00L; }
 
 int main() {
-    const auto direct_addr = reinterpret_cast<void*>(&direct);
     const auto hook_addr = reinterpret_cast<void*>(&hook);
 
     assert(direct() == 0xBEEF);
     assert(indirect() == 0xBEEF);
 
     auto* real = dlhook_sym(nullptr, "direct", hook_addr);
-    assert(reinterpret_cast<int(*)()>(real)() == 0xBEEF);
+    assert(reinterpret_cast<int (*)()>(real)() == 0xBEEF);
     assert(direct() == 0xF00L);
     assert(indirect() == 0xBEEF);
 
@@ -23,19 +20,19 @@ int main() {
     assert(direct() == 0xBEEF);
     assert(indirect() == 0xBEEF);
 
-    //dlhook_sym_all("direct", hook_addr);
-    //assert(direct() == 0xF00L);
-    //assert(indirect() == 0xF00L);
+    // dlhook_sym_all("direct", hook_addr);
+    // assert(direct() == 0xF00L);
+    // assert(indirect() == 0xF00L);
 
-    dlhook_addr(nullptr, direct_addr, hook_addr);
+    dlhook_addr(nullptr, real, hook_addr);
     assert(direct() == 0xF00L);
     assert(indirect() == 0xBEEF);
 
-    dlhook_addr(nullptr, hook_addr, direct_addr);
+    dlhook_addr(nullptr, hook_addr, real);
     assert(direct() == 0xBEEF);
     assert(indirect() == 0xBEEF);
 
-    dlhook_addr_all(direct_addr, hook_addr);
+    dlhook_addr_all(real, hook_addr);
     assert(direct() == 0xF00L);
     assert(indirect() == 0xF00L);
 }