adb-utils 0.6.0

Rust implementation of commonly used ADB commands
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
80
81
82
83
84
85
86
87
88
89
90
91
92

use std::{fmt::Display, process::Command};

use crate::{ADBCommand, ADBResult};

/// List all forward socket connections
pub struct ADBForward {
    shell: Command,
}

pub enum ForwardMethodLocal {
    /// May be 0 to pick any open port
    Tcp(u32),
    LocalAbstract(UDS),
    LocalReserved(UDS),
    LocalFilesystem(UDS),
}

pub enum ForwardMethodRemote {
    Tcp(u32),
    // LocalAbstract(UDS),
    // LocalReserved(UDS),
    // LocalFilesystem(UDS),
    /// PID
    Jdwp(u32),
    /// CID, PID
    Vsock(u32, u32),
}

impl ADBForward {
    /// List all forward socket connections
    pub fn list() -> Self {
        let mut cmd = Command::new("adb");
        cmd.arg("forward").arg("--list");

        ADBForward { shell: cmd }
    }

    /// Forward socket connection using a local and remote method
    pub fn using(local: ForwardMethodLocal, remote: ForwardMethodRemote) -> Self {
        let mut cmd = Command::new("adb");
        cmd.arg(match local {
            ForwardMethodLocal::Tcp(port) => format!("tcp:{port}"),
            ForwardMethodLocal::LocalAbstract(uds) => format!("localabstract:{uds}"),
            ForwardMethodLocal::LocalReserved(uds) => format!("localreserved:{uds}"),
            ForwardMethodLocal::LocalFilesystem(uds) => format!("localfilesystem:{uds}"),
        });
        cmd.arg(match remote {
            ForwardMethodRemote::Tcp(port) => format!("tcp:{port}"),
            // ForwardMethodRemote::LocalAbstract(_) => todo!(),
            // ForwardMethodRemote::LocalReserved(_) => todo!(),
            // ForwardMethodRemote::LocalFilesystem(_) => todo!(),
            ForwardMethodRemote::Jdwp(pid) => format!("jdwp:{pid}"),
            ForwardMethodRemote::Vsock(cid, pid) => format!("vsock:{cid}:{pid}"),
        });

        ADBForward { shell: cmd }
    }
}

impl ADBCommand for ADBForward {
    fn build(&mut self) -> Result<&mut Command, String> {
        Ok(&mut self.shell)
    }

    fn process_output(&self, output: ADBResult) -> ADBResult {
        output
    }
}

/// Unix domain socket or IPC (https://en.wikipedia.org/wiki/Unix_domain_socket)
pub enum UDS {
    /// stream oriented
    SockStream,
    // datagram oriented, preserves message boundaries
    SockDgram,
    // connection oriented, sequenced-packet
    SockSeqpacket,
}

impl Display for UDS {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}",
            match self {
                UDS::SockStream => "SOCK_STREAM",
                UDS::SockDgram => "SOCK_DGRAM",
                UDS::SockSeqpacket => "SOCK_SEQPACKET",
            }
        )
    }
}