ios-core 0.1.7

High-level device API, pairing transport, and discovery for iOS devices
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! DeviceInfo service – query sysmon attributes for sysmontap configuration.

use tokio::io::{AsyncRead, AsyncWrite};

use crate::services::dtx::codec::{DtxConnection, DtxError};
use crate::services::dtx::types::{DtxPayload, NSObject};

/// Info about a running process from `runningProcesses`.
#[derive(Debug, Clone)]
pub struct RunningProcess {
    pub pid: u64,
    pub name: String,
    pub real_app_name: String,
    pub is_application: bool,
}

/// Fetch sysmon system/process attributes needed for sysmontap setConfig:.
pub struct DeviceInfoClient<S> {
    conn: DtxConnection<S>,
    channel_code: i32,
}

impl<S: AsyncRead + AsyncWrite + Unpin + Send> DeviceInfoClient<S> {
    pub async fn connect(stream: S) -> Result<Self, DtxError> {
        let mut conn = DtxConnection::new(stream);
        let ch = conn.request_channel(super::DEVICE_INFO_SVC).await?;
        Ok(Self {
            conn,
            channel_code: ch,
        })
    }

    pub async fn system_attributes(&mut self) -> Result<Vec<plist::Value>, DtxError> {
        self.get_attrs("sysmonSystemAttributes").await
    }

    pub async fn process_attributes(&mut self) -> Result<Vec<plist::Value>, DtxError> {
        self.get_attrs("sysmonProcessAttributes").await
    }

    /// List all running processes on the device.
    pub async fn running_processes(&mut self) -> Result<Vec<RunningProcess>, DtxError> {
        let msg = self
            .conn
            .method_call(self.channel_code, "runningProcesses", &[])
            .await?;
        tracing::debug!("runningProcesses response: {:?}", msg.payload);

        let arr = match &msg.payload {
            DtxPayload::Response(NSObject::Array(a)) => a.clone(),
            DtxPayload::MethodInvocation { args, .. } => {
                // Some iOS versions return it as a method invocation arg
                args.iter()
                    .find_map(|a| {
                        if let NSObject::Array(arr) = a {
                            Some(arr.clone())
                        } else {
                            None
                        }
                    })
                    .unwrap_or_default()
            }
            _ => return Ok(vec![]),
        };

        let mut result = Vec::with_capacity(arr.len());
        for item in &arr {
            if let NSObject::Dict(d) = item {
                let pid = match d.get("pid") {
                    Some(NSObject::Uint(n)) => *n,
                    Some(NSObject::Int(n)) => *n as u64,
                    _ => continue,
                };
                let name = d
                    .get("name")
                    .and_then(|v| {
                        if let NSObject::String(s) = v {
                            Some(s.clone())
                        } else {
                            None
                        }
                    })
                    .unwrap_or_default();
                let real_app_name = d
                    .get("realAppName")
                    .and_then(|v| {
                        if let NSObject::String(s) = v {
                            Some(s.clone())
                        } else {
                            None
                        }
                    })
                    .unwrap_or_default();
                let is_application = d
                    .get("isApplication")
                    .and_then(|v| {
                        if let NSObject::Bool(b) = v {
                            Some(*b)
                        } else {
                            None
                        }
                    })
                    .unwrap_or(false);
                result.push(RunningProcess {
                    pid,
                    name,
                    real_app_name,
                    is_application,
                });
            }
        }
        Ok(result)
    }

    async fn get_attrs(&mut self, method: &str) -> Result<Vec<plist::Value>, DtxError> {
        let msg = self
            .conn
            .method_call(self.channel_code, method, &[])
            .await?;
        tracing::debug!("{method} response: {:?}", msg.payload);
        match &msg.payload {
            DtxPayload::Response(NSObject::Array(arr)) => Ok(arr
                .iter()
                .map(|v| match v {
                    NSObject::String(s) => plist::Value::String(s.clone()),
                    NSObject::Int(n) => plist::Value::Integer((*n).into()),
                    NSObject::Uint(n) => plist::Value::Integer((*n as i64).into()),
                    _ => plist::Value::String(format!("{v:?}")),
                })
                .collect()),
            _ => Ok(vec![]),
        }
    }
}