Method spawn

src/execution/mod.rs:193–245

(
        &self,
        binary: &Path,
        extra_args: Vec<S>,
        extra_envs: Vec<(S, S)>,
        current_dir: Option<PathBuf>,
        stderr: Option<Stdio>,
        enough_timeout: bool,

    }

    pub fn spawn<S: AsRef<OsStr> + Debug>(
        &self,
        binary: &Path,
        extra_args: Vec<S>,
        extra_envs: Vec<(S, S)>,
        current_dir: Option<PathBuf>,
        stderr: Option<Stdio>,
        enough_timeout: bool,
    ) -> Child {
        let asan_options = self.deopt.get_asan_options();
        let rss_limit = format!(
            "-rss_limit_mb={}",
            self.deopt.config.rss_limit_mb.unwrap_or_default()
        );
        let current_dir = current_dir.unwrap_or(get_file_dirname(binary));
        let stderr = stderr.unwrap_or(Stdio::piped());
        let timeout = if enough_timeout {
            crate::config::SANITIZATION_TIMEOUT
        } else {
            crate::config::EXECUTION_TIMEOUT
        };

        // Prepare fuzzer arguments
        let fuzzer_args = vec![
            rss_limit,
            format!("-timeout={}", timeout),
            "-close_fd_mask=3".to_string(),
        ];

        // Try to wrap with bubblewrap for network isolation
        let mut cmd = wrap_command_with_bubblewrap(
            binary,
            &extra_args,
            &extra_envs,
            &asan_options,
            &fuzzer_args,
        );
        
        let program = cmd.get_program().to_string_lossy();
        let args: Vec<String> = cmd.get_args().map(|a| a.to_string_lossy().into_owned()).collect();

        let full_cmd_string = format!("{} {}", program, args.join(" "));
        log::trace!("Raw shell string: {}", full_cmd_string);
        
        let child = cmd
            .current_dir(current_dir)
            .stdin(Stdio::null())
            .stdout(Stdio::null())
            .stderr(stderr)
            .spawn()
            .expect("unable to spawn the fuzzer");
        child
    }

    pub fn execute<S: AsRef<OsStr> + Debug>(
        &self,