bash-interop 0.1.0

Run bash under instrumentation and hear what it says: a session per run, a pipe and a task per shell, words a script speaks and answers it runs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

//! The account a shell gives of itself, built by hand.
//!
//! One builder, so a test that needs the words and a test that needs the shell
//! read the same one. The numbers are a real 5.3.9's: what is under test
//! wherever this is used is the arrangement or the walk, never the reading of
//! this payload — that is tested against a live shell.

use std::sync::Arc;

use bash_strings::emit_array;

use crate::rig::wire::Account;
use crate::rig::{Micros, Shell, Stamp};

/// The pairs an announcement carries. `zero` is the shell's `$0` and `flags`
/// its `$-`, which between them decide how a walk taken in it reads.
pub fn account(pid: u32, zero: &str, flags: &str) -> Vec<String> {
    let versinfo = emit_array(&["5", "3", "9", "1", "release", "x86_64-pc-linux-gnu"].map(String::from));
    let command = if flags.contains('c') { "true" } else { "" };
    let pid = pid.to_string();

    [
        "pid",
        pid.as_str(),
        "shlvl",
        "5",
        "subshell",
        "0",
        "versinfo",
        versinfo.as_str(),
        "bash",
        "/usr/bin/bash",
        "zero",
        zero,
        "flags",
        flags,
        "shellopts",
        "braceexpand:hashall",
        "bashopts",
        "checkwinsize",
        "command",
        command,
        "brought",
        "()",
    ]
    .iter()
    .map(ToString::to_string)
    .collect()
}

/// A shell, as one would arrive.
pub fn shell(nth: usize, pid: u32, zero: &str, flags: &str) -> Arc<Shell> {
    let stamp = Stamp {
        sent_at: Micros(100),
        heard_at: Micros(101),
    };

    Arc::new(
        Shell::of(
            nth,
            Account {
                stamp,
                words: account(pid, zero, flags),
            },
        )
        .expect("an account"),
    )
}

/// A shell bash was handed a file to read.
pub fn reading(zero: &str) -> Arc<Shell> {
    shell(0, 7, zero, "hB")
}

/// A shell bash was given its code directly, where `$0` is a word and not a
/// path.
pub fn given(zero: &str) -> Arc<Shell> {
    shell(0, 7, zero, "hBc")
}