Cleaning a rusty_trap.

[package]
name = "rusty_trap"
version = "0.1.0"
authors = ["Joseph Kain <joekain@gmail.com>"]

[dependencies]
libc     = "0.1.8"

[dependencies.nix]
git = "https://github.com/joekain/nix-rust.git"
version = "0.3.8"
branch = "WaitStatus"

[lib]
name = "rusty_trap"
path = "src/lib.rs"

[[bin]]
name = "twelve"
path = "tests/inferiors/twelve.rs"

[[bin]]
name = "loop"
path = "tests/inferiors/loop.rs"

@@ -4,12 +4,8 @@ version = "0.1.0"
 authors = ["Joseph Kain <joekain@gmail.com>"]
 
 [dependencies]
-libc     = "0.1.8"
-
-[dependencies.nix]
-git = "https://github.com/joekain/nix-rust.git"
-version = "0.3.8"
-branch = "WaitStatus"
+libc = "0.2.174"
+nix = "0.30.1"

use nix::{sys::wait::waitpid,unistd::{fork, ForkResult, write}};

modified   Cargo.toml
@@ -5,7 +5,7 @@ authors = ["Joseph Kain <joekain@gmail.com>"]
 
 [dependencies]
 libc = "0.2.174"
-nix = "0.30.1"
+nix = {version = "0.30.1", features = ["process", "ptrace"]}
 
 [lib]
 name = "rusty_trap"

modified   Cargo.toml
@@ -5,7 +5,7 @@ authors = ["Joseph Kain <joekain@gmail.com>"]
 
 [dependencies]
 libc = "0.2.174"
-nix = "0.30.1"
+nix = {version = "0.30.1", features = ["process", "ptrace"]}
 
 [lib]
 name = "rusty_trap"

modified   src/ptrace_util/mod.rs
@@ -1,8 +1,6 @@
 use libc::pid_t;
-use nix::sys::ptrace::*;
-use nix::sys::ptrace::ptrace::*;
-use std::ptr;
-use libc::c_void;
+use nix::sys::ptrace;
+use nix::unistd::Pid;
 
 use inferior::InferiorPointer;
 
@@ -39,44 +37,49 @@ pub mod user {
 }
 
 pub fn trace_me() -> () {
-    ptrace(PTRACE_TRACEME, 0, ptr::null_mut(), ptr::null_mut())
+    ptrace::traceme()
         .ok()
         .expect("Failed PTRACE_TRACEME");
 }
 
 pub fn get_instruction_pointer(pid: pid_t) -> InferiorPointer {
-    let raw = ptrace(PTRACE_PEEKUSER, pid, user::regs::RIP as * mut c_void, ptr::null_mut())
+    let raw = ptrace::read_user(Pid::from_raw(pid), user::regs::RIP as ptrace::AddressType)
         .ok()
         .expect("Failed PTRACE_PEEKUSER");
     InferiorPointer(raw as u64)
 }
 
 pub fn set_instruction_pointer(pid: pid_t, ip: InferiorPointer) -> () {
-    ptrace(PTRACE_POKEUSER, pid, user::regs::RIP as * mut c_void, ip.as_voidptr())
+    ptrace::write_user(Pid::from_raw(pid), user::regs::RIP as ptrace::AddressType, ip.as_i64())
         .ok()
         .expect("Failed PTRACE_POKEUSER");
 }
 
 pub fn cont(pid: pid_t) -> () {
-    ptrace(PTRACE_CONT, pid, ptr::null_mut(), ptr::null_mut())
+    ptrace::cont(Pid::from_raw(pid), None)
         .ok()
         .expect("Failed PTRACE_CONTINUE");
 }
 
 pub fn peek_text(pid: pid_t, address: InferiorPointer) -> i64 {
-    ptrace(PTRACE_PEEKTEXT, pid, address.as_voidptr(), ptr::null_mut())
-        .ok()
-        .expect("Failed PTRACE_PEEKTEXT")
+    // From ptrace(2) regarding PTRACE_PEEKTEXT and PTRACE_PEEKDATA
+    //   Linux does not have separate text and data address spaces,
+    //   so these two operations are currently equivalent.
+    // So use ptrace::read which is ptrace(PTRACE_PEEKDATA, ...)
+    // An alterantive would be to use libc::ptrace.
+    ptrace::read(Pid::from_raw(pid),  address.as_voidptr())
+	.ok()
+	.expect("Failed PTRACE_PEEKTEXT")
 }
 
 pub fn poke_text(pid: pid_t, address: InferiorPointer, value: i64) -> () {
-    ptrace(PTRACE_POKETEXT, pid, address.as_voidptr(), value as * mut c_void)
-        .ok()
-        .expect("Failed PTRACE_POKETEXT");
+    ptrace::write(Pid::from_raw(pid), address.as_voidptr(), value)
+	.ok()
+	.expect("Failed PTRACE_POKETEXT")
 }
 
 pub fn single_step(pid: pid_t) -> () {
-    ptrace(PTRACE_SINGLESTEP, pid, ptr::null_mut(), ptr::null_mut())
+    ptrace::step(Pid::from_raw(pid), None)
         .ok()
         .expect("Failed PTRACE_SINGLESTEP");
 }

fn exec_inferior(filename: &Path, args: &[&str]) -> () {
    // let c_filename = &CStr::from_ptr(filename.to_str().unwrap().as_ptr() as *const i8);
    let cstring_filename = CString::new(filename.to_str()
					.expect("Failed to get string from filename"))
	.expect("Failed to create CString from filename");
    let cstr_filename = CStr::from_ptr(cstring_filename.as_ptr());

    disable_address_space_layout_randomization();
    ptrace_util::trace_me();
    execve::<CString, CString>(cstr_filename, &[], &[])
        .ok()
        .expect("Failed execve");
    unreachable!();
}

@@ -37,35 +34,32 @@ static mut global_breakpoint : Breakpoint = Breakpoint {
 };
 static mut global_inferior : Inferior = Inferior { pid: 0, state: InferiorState::Stopped };
 
-mod ffi {
-    use libc::{c_int, c_long};
-
-    extern {
-        pub fn personality(persona: c_long) -> c_int;
-    }
-}
-
 fn disable_address_space_layout_randomization() -> () {
     unsafe {
-        let old = ffi::personality(0xffffffff);
-        ffi::personality((old | 0x0040000) as i64);
+	let old = libc::personality(0xffffffff);
+	libc::personality((old | libc::ADDR_NO_RANDOMIZE) as u64);
     }
 }
 

modified   src/lib.rs
@@ -1,15 +1,12 @@
 extern crate nix;
 extern crate libc;
 
-use nix::unistd::*;
-use nix::unistd::Fork::*;
+use nix::{Error, sys::wait::waitpid,unistd::{execve, fork, ForkResult}, sys::signal};
 use libc::pid_t;
-use nix::Error;
-use nix::errno;
 use nix::sys::wait::*;
-use std::ffi::CString;
+use nix::unistd::Pid;
+use std::ffi::{CString, CStr};
 use std::path::Path;
-use nix::sys::signal;
 
 mod ptrace_util;
 
@@ -19,7 +16,7 @@ use inferior::*;
 mod breakpoint;
 
 pub use self::breakpoint::trap_inferior_set_breakpoint;
-use breakpoint::{handle, TrapBreakpoint};
+use breakpoint::{TrapBreakpoint};
 
 #[derive(Copy, Clone)]
 struct Breakpoint {
@@ -37,35 +34,32 @@ static mut global_breakpoint : Breakpoint = Breakpoint {
 };
 static mut global_inferior : Inferior = Inferior { pid: 0, state: InferiorState::Stopped };
 
-mod ffi {
-    use libc::{c_int, c_long};
-
-    extern {
-        pub fn personality(persona: c_long) -> c_int;
-    }
-}
-
 fn disable_address_space_layout_randomization() -> () {
     unsafe {
-        let old = ffi::personality(0xffffffff);
-        ffi::personality((old | 0x0040000) as i64);
+	let old = libc::personality(0xffffffff);
+	libc::personality((old | libc::ADDR_NO_RANDOMIZE) as u64);
     }
 }
 
 fn exec_inferior(filename: &Path, args: &[&str]) -> () {
-    let c_filename = &CString::new(filename.to_str().unwrap()).unwrap();
+    // let c_filename = &CStr::from_ptr(filename.to_str().unwrap().as_ptr() as *const i8);
+    let cstring_filename = CString::new(filename.to_str()
+					.expect("Failed to get string from filename"))
+	.expect("Failed to create CString from filename");
     disable_address_space_layout_randomization();
     ptrace_util::trace_me();
-    execve(c_filename, &[], &[])
+    let cstr_filename = unsafe { CStr::from_ptr(cstring_filename.as_ptr()) };
+    execve::<CString, CString>(cstr_filename, &[], &[])
         .ok()
         .expect("Failed execve");
     unreachable!();
 }
 
-fn attach_inferior(pid: pid_t) -> Result<Inferior, Error> {
-    match waitpid(pid, None) {
-        Ok(WaitStatus::Stopped(pid, signal::SIGTRAP)) =>
-            return Ok(Inferior {pid: pid, state: InferiorState::Running}),
+fn attach_inferior(raw_pid: pid_t) -> Result<Inferior, Error> {
+    let nix_pid = Pid::from_raw(raw_pid);
+    match waitpid(nix_pid, None) {
+        Ok(WaitStatus::Stopped(pid, signal::Signal::SIGTRAP)) =>
+            return Ok(Inferior {pid: pid.into(), state: InferiorState::Running}),
         Ok(_) => panic!("Unexpected stop in attach_inferior"),
         Err(e) => return Err(e)
     }
@@ -73,25 +67,25 @@ fn attach_inferior(pid: pid_t) -> Result<Inferior, Error> {
 
 pub fn trap_inferior_exec(filename: &Path, args: &[&str]) -> Result<TrapInferior, Error> {
     loop {
-        match fork() {
-            Ok(Child)                      => exec_inferior(filename, args),
-            Ok(Parent(pid))                => {
-                unsafe { global_inferior = attach_inferior(pid).ok().unwrap() };
-                return Ok(pid)
+        match unsafe { fork() } {
+            Ok(ForkResult::Child)                      => exec_inferior(filename, args),
+            Ok(ForkResult::Parent{child: pid})         => {
+                unsafe { global_inferior = attach_inferior(pid.into()).ok().unwrap() };
+                return Ok(pid.into())
             },
-            Err(Error::Sys(errno::EAGAIN)) => continue,
-            Err(e)                         => return Err(e)
+            Err(Error::EAGAIN) => continue,
+            Err(e)             => return Err(e)
         }
     }
 }
 
-pub fn trap_inferior_continue<F>(inferior: TrapInferior, callback: &mut F) -> i8
+pub fn trap_inferior_continue<F>(inferior: TrapInferior, callback: &mut F) -> i32
     where F: FnMut(TrapInferior, TrapBreakpoint) -> () {
 
     let mut inf = unsafe { global_inferior };
     ptrace_util::cont(inf.pid);
     loop {
-        inf.state = match waitpid(inf.pid, None) {
+        inf.state = match waitpid(Pid::from_raw(inf.pid), None) {
             Ok(WaitStatus::Exited(_pid, code)) => return code,
             Ok(WaitStatus::Stopped(_pid, signal::SIGTRAP)) =>
                 breakpoint::handle(inf, callback),

modified   src/breakpoint/mod.rs
@@ -27,7 +27,7 @@ fn step_over(inferior: TrapInferior, bp: Breakpoint) -> () {

 fn set(inferior: TrapInferior, bp: Breakpoint) -> () {
     let mut modified = bp.original_breakpoint_word;
-    modified &= !0xFFi64 << bp.shift;
+    modified &= !(0xFFi64 << bp.shift);
  
  modified |= 0xCCi64 << bp.shift;
     poke_text(inferior, bp.aligned_address, modified);