Added support to spawn a process, rather than just attach

Author: mxms0

Cargo.lock

@@ -24,28 +24,34 @@ use winapi::um::debugapi::DebugActiveProcessStop;
 use winapi::um::debugapi::DebugActiveProcess;
 use winapi::um::debugapi::ContinueDebugEvent;
 use winapi::um::winbase::InitializeContext;
+use winapi::um::processthreadsapi::GetProcessId;
 use winapi::um::processthreadsapi::GetCurrentProcess;
 use winapi::um::processthreadsapi::SetThreadContext;
 use winapi::um::processthreadsapi::GetThreadContext;
 use winapi::um::processthreadsapi::FlushInstructionCache;
 use winapi::um::processthreadsapi::TerminateProcess;
 use winapi::um::processthreadsapi::OpenProcess;
+use winapi::um::processthreadsapi::CreateProcessA;
 use winapi::um::wow64apiset::IsWow64Process;
 use winapi::um::winnt::PROCESS_QUERY_LIMITED_INFORMATION;
 use winapi::um::psapi::GetMappedFileNameW;
 use winapi::um::winnt::HANDLE;
 use winapi::um::minwinbase::DEBUG_EVENT;
+use winapi::um::winbase::DEBUG_PROCESS;
+use winapi::um::winbase::DEBUG_ONLY_THIS_PROCESS;
 
 use std::time::{Duration, Instant};
 use std::collections::{HashSet, HashMap};                                                                                                           
 use std::path::Path;
 use std::sync::Arc;
 use std::fs::File;
+use std::ffi::CString;
 use std::io::Write;
 use std::io::BufWriter;
 use std::sync::atomic::{AtomicBool, Ordering};
 use winapi::um::consoleapi::SetConsoleCtrlHandler;
 
+
 use crate::minidump::dump;
 use crate::handles::Handle;
 
@@ -201,6 +207,47 @@ macro_rules! mprint {
 impl<'a> Debugger<'a> {
     /// Create a new debugger and attach to `pid`
     pub fn attach(pid: u32) -> Debugger<'a> {
+        Debugger::attach_internal(pid, false)
+    }
+
+    /// Create a new process argv[0], with arguments argv[1..] and attach to it
+    pub fn spawn_proc(argv: &[String], follow_fork: bool) -> Debugger<'a> {
+        let mut startup_info = unsafe { std::mem::zeroed() };
+        let mut proc_info = unsafe { std::mem::zeroed() };
+
+        let cmdline = CString::new(argv.join(" ")).unwrap();
+
+        let cmdline_ptr = cmdline.into_raw();
+
+        let flags = if follow_fork {
+            DEBUG_PROCESS 
+        }
+        else {
+            DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS
+        };
+
+        unsafe {
+            assert!(CreateProcessA(
+                std::ptr::null_mut(), // lpApplicationName
+                cmdline_ptr, // lpCommandLine
+                std::ptr::null_mut(), // lpProcessAttributes
+                std::ptr::null_mut(), // lpThreadAttributes
+                0, // bInheritHandles
+                flags, // dwCreationFlags
+                std::ptr::null_mut(), // lpEnvironment
+                std::ptr::null_mut(), // lpCurrentDirectory
+                &mut startup_info, // lpStartupInfo
+                &mut proc_info) != 0,  // lpProcessInformation
+                "Failed to create process.");
+        }
+
+        let pid = unsafe { GetProcessId(proc_info.hProcess) };
+        
+        Debugger::attach_internal(pid, true)
+    }
+
+    /// Create a new debugger
+    pub fn attach_internal(pid: u32, attached: bool) -> Debugger<'a> {
         // Save the start time
         let start_time = Instant::now();
 
@@ -238,10 +285,12 @@ impl<'a> Debugger<'a> {
             assert!(cur_is_wow64 == target_is_wow64,
                 "Target process does not match mesos bitness");
 
-            // Attach to the target!
-            assert!(DebugActiveProcess(pid) != 0,
-                "Failed to attach to process, is your PID valid \
-                 and do you have correct permissions?");
+            if !attached {
+                // Attach to the target!
+                assert!(DebugActiveProcess(pid) != 0,
+                        "Failed to attach to process, is your PID valid \
+                        and do you have correct permissions?");
+             }
         }
 
         // Correctly initialize a context so it's aligned. We overcommit

libs/debugger/src/debugger.rs

@@ -15,56 +15,90 @@ fn modload_handler(dbg: &mut Debugger, modname: &str, base: usize) {
 }
 
 fn main() {
+
+    // mesos.exe -p pid mesos_file0 mesos_file1 mesos_file2 
+    // or mesos.exe mesos_file0 mesos_file1 mesos_file2 -- ./exe arg0 arg1 arg2
+
     // Usage and argument parsing
     let args: Vec<String> = std::env::args().collect();
     if args.len() < 2 {
-        print!("Usage: mesos.exe <pid> [--freq | --verbose | --print] \
-               <explicit meso file 1> <explicit meso file ...>\n");
+        print!("Usage: mesos.exe -p <pid> <options> <mesos files>\n");
+        print!("    or mesos.exe <options> <mesos files> -- program.exe <arguments>\n");
         print!("    --freq               - \
                Treats all breakpoints as frequency breakpoints\n");
         print!("    --verbose            - \
                Enables verbose prints for debugging\n");
         print!("    --print              - \
                Prints breakpoint info on every single breakpoint\n");
+        print!("    --follow-fork        - \
+               Capture coverage for child processes\n");
         print!("    [explicit meso file] - \
                Load a specific meso file regardless of loaded modules\n\n");
 
-        print!("Standard usage: mesos.exe <pid>\n");
         return;
     }
 
-    // Attach to process
-    let mut dbg = Debugger::attach(args[1].parse().unwrap());
 
-    // Register callback routine for module loads so we can attempt to apply
-    // breakpoints to it from the meso file cache
-    dbg.register_modload_callback(Box::new(modload_handler));
+    let mut pid: i32 = -1;
+    let mut frequency_mode_enabled = false;
+    let mut verbose_mode_enabled = false;
+    let mut follow_fork_enabled = false;
+    let mut print_breakpoints_enabled = false;
+    let mut mesos: Vec<&Path> = Vec::new();
+
+    let mut argv: Vec<String> = Vec::new();
 
-    // Process arguments
     if args.len() > 2 {
-        for meso in &args[2..] {
-            if meso == "--freq" {
-                // Always do frequency
-                print!("Always frequency mode enabled\n");
-                dbg.set_always_freq(true);
-                continue;
-            } else if meso == "--verbose" {
-                // Enable verbose mode
-                print!("Verbose mode enabled\n");
-                dbg.set_verbose(true);
-                continue;
-            } else if meso == "--print" {
-                // Enable breakpoint print mode
-                print!("Breakpoint print mode enabled\n");
-                dbg.set_bp_print(true);
-                continue;
+        for (i, arg) in args[1..].iter().enumerate() {
+            if arg == "-p" {
+                pid = arg.parse().unwrap();
+            }
+            else if arg == "--verbose" {
+                verbose_mode_enabled = true;
+            }
+            else if arg == "--print" { 
+                print_breakpoints_enabled = true;
+            }
+            else if arg == "--freq" { 
+                frequency_mode_enabled = true;
+            }
+            else if arg == "--follow-fork" {
+                follow_fork_enabled = true;
+            }
+            else if arg == "--" {
+                argv.extend_from_slice(&args[i + 2..]);
+                break;
+            }
+            else { // Has to be a mesofile
+                //mesofile::load_meso(&mut dbg, Path::new(arg));
+                mesos.push(Path::new(arg));
             }
-
-            // Load explicit meso file
-            mesofile::load_meso(&mut dbg, Path::new(meso));
         }
     }
 
+    let mut dbg:Debugger;
+    if pid == -1 && argv.len() > 0 {
+        dbg = Debugger::spawn_proc(&argv, follow_fork_enabled);
+    }
+    else {
+        dbg = Debugger::attach(args[1].parse().unwrap());
+    }
+
+    // Attach to process
+
+    dbg.set_always_freq(frequency_mode_enabled);
+    dbg.set_verbose(verbose_mode_enabled);
+    dbg.set_bp_print(print_breakpoints_enabled);
+
+    for mesofile in mesos {
+        mesofile::load_meso(&mut dbg, mesofile);
+    }
+
+    // Register callback routine for module loads so we can attempt to apply
+    // breakpoints to it from the meso file cache
+    dbg.register_modload_callback(Box::new(modload_handler));
+
     // Debug forever
     dbg.run();
 }
+