Initial commit: glibc support

Author: geofft

.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "redhook"
+version = "0.0.1"
+authors = ["Geoffrey Thomas <[email protected]>"]
+examples = []

README.md

@@ -0,0 +1,34 @@
+redhook
+=======
+
+redhook is a helper crate for writing interposition libraries
+(`LD_PRELOAD`, `DYLD_INSERT_LIBRARIES`, etc.) in Rust.
+
+To use redhook, add the lines
+
+```rust
+#[macro_use]
+extern crate redhook;
+```
+
+to your library, then use the `hook!` macro to declare the function you
+want to hook, and the name you want to give to your hook function:
+
+```rust
+hook! {
+    fn existing_function(x: i32) -> i32 => my_function {
+        42
+    }
+}
+```
+
+To access the underlying function, use `real!(existing_function)`. Then
+compile your library as a `dylib`.
+
+There are a few [examples](examples) included, as separate crates.
+
+At the moment, redhook only supports `LD_PRELOAD` on glibc, but support
+for other platforms is planned.
+
+redhook is named after the [Red Hook](http://en.wikipedia.org/wiki/Red_Hook,_Brooklyn)
+neighborhood in Brooklyn, New York.

examples/fakeroot/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "redhook_ex_fakeroot"
+version = "0.0.1"
+authors = ["Geoffrey Thomas <[email protected]>"]
+
+[lib]
+name = "fakeroot"
+crate_type = ["dylib"]
+
+[dependencies.redhook]
+path = "../.."

examples/fakeroot/src/lib.rs

@@ -0,0 +1,8 @@
+#[macro_use]
+extern crate redhook;
+
+hook! {
+    fn getuid() -> u64 => i_am_root {
+        0
+    }
+}

examples/readlinkspy/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "redhook_ex_readlinkspy"
+version = "0.0.1"
+authors = ["Geoffrey Thomas <[email protected]>"]
+
+[lib]
+name = "readlinkspy"
+crate_type = ["dylib"]
+
+[dependencies.redhook]
+path = "../.."

examples/readlinkspy/src/lib.rs

@@ -0,0 +1,20 @@
+#![feature(libc)]
+
+extern crate libc;
+
+#[macro_use]
+extern crate redhook;
+
+use libc::{size_t,ssize_t,c_char};
+
+hook! {
+    fn readlink(path: *const c_char, buf: *mut c_char, bufsiz: size_t) -> ssize_t => my_readlink {
+        if let Ok(path) = std::str::from_utf8(unsafe {std::ffi::CStr::from_ptr(path).to_bytes()}) {
+            println!("readlink(\"{}\")", path);
+        } else {
+            println!("readlink(...)");
+        }
+
+        unsafe { real!(readlink)(path, buf, bufsiz) }
+    }
+}

src/lib.rs

@@ -0,0 +1,92 @@
+#![feature(libc)]
+
+extern crate libc;
+
+use libc::{c_char, c_void};
+use std::sync::atomic;
+
+#[link(name="dl")]
+extern {
+        fn dlsym(handle: *const c_void, symbol: *const c_char) -> *const c_void;
+}
+
+const RTLD_NEXT: *const c_void = -1is as *const c_void;
+
+pub unsafe fn dlsym_next(symbol: &'static str) -> *const u8 {
+    let ptr = dlsym(RTLD_NEXT, symbol.as_ptr() as *const c_char);
+    if ptr.is_null() {
+        panic!("redhook: Unable to find underlying function for {}", symbol);
+    }
+    ptr as *const u8
+}
+
+/* Some Rust library functionality (e.g., jemalloc) initializes
+ * lazily, after the hooking library has inserted itself into the call
+ * path. If the initialization uses any hooked functions, this will lead
+ * to an infinite loop. Work around this by running some initialization
+ * code in a static constructor, and bypassing all hooks until it has
+ * completed. */
+
+static INIT_STATE: atomic::AtomicBool = atomic::ATOMIC_BOOL_INIT;
+
+pub fn initialized() -> bool {
+    INIT_STATE.load(atomic::Ordering::SeqCst)
+}
+
+extern fn initialize() {
+    Box::new(0u8);
+    INIT_STATE.store(true, atomic::Ordering::SeqCst);
+}
+
+/* Rust doesn't directly expose __attribute__((constructor)), but this
+ * is how GNU implements it. */
+#[link_section=".init_array"]
+pub static INITIALIZE_CTOR: extern fn() = initialize;
+
+#[macro_export]
+macro_rules! hook {
+    (fn $real_fn:ident ( $($v:ident : $t:ty),* ) -> $r:ty => $hook_fn:ident $body:block) => {
+        #[allow(non_camel_case_types)]
+        pub struct $real_fn {__private_field: ()}
+        #[allow(non_upper_case_globals)]
+        static $real_fn: $real_fn = $real_fn {__private_field: ()};
+
+        impl $real_fn {
+            fn get(&self) -> unsafe extern fn ( $($v : $t),* ) -> $r {
+                use std::sync::{Once, ONCE_INIT};
+
+                static mut REAL: *const u8 = 0 as *const u8;
+                static mut ONCE: Once = ONCE_INIT;
+
+                unsafe {
+                    ONCE.call_once(|| {
+                        REAL = $crate::dlsym_next(concat!(stringify!($real_fn), "\0"));
+                    });
+                    std::mem::transmute(REAL)
+                }
+            }
+
+            #[no_mangle]
+            pub unsafe fn $real_fn ( $($v : $t),* ) -> $r {
+                if $crate::initialized() {
+                    $hook_fn ( $($v),* )
+                } else {
+                    $real_fn.get() ( $($v),* )
+                }
+            }
+        }
+
+        pub fn $hook_fn ( $($v : $t),* ) -> $r {
+            $body
+        }
+    };
+
+    (fn $real_fn:ident ( $($v:ident : $t:ty),* ) => $hook_fn:ident $body:block) => {
+        hook! { fn $real_fn ( $($v : $t),* ) -> () => $hook_fn $body }
+    };
+}
+
+#[macro_export]
+macro_rules! real {
+    ($real_fn:ident) => {$real_fn.get()}
+}