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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
// jkcoxson
use crate::{
bindings as unsafe_bindings, error::PropertyListServiceError, idevice::Device,
services::lockdownd::LockdowndService,
};
pub struct PropertyListServiceClient<'a> {
pub(crate) pointer: unsafe_bindings::property_list_service_client_t,
phantom: std::marker::PhantomData<&'a Device>,
}
use plist_plus::Plist;
impl PropertyListServiceClient<'_> {
/// Creates a preboard client from a property list service
/// # Arguments
/// * `device` - The device to connect to
/// * `descriptor` - The lockdown service to connect on
/// # Returns
/// A struct containing the handle to the connection
///
/// ***Verified:*** False
pub fn new(
device: &Device,
descriptor: LockdowndService,
) -> Result<Self, PropertyListServiceError> {
let mut pointer = std::ptr::null_mut();
let result = unsafe {
unsafe_bindings::property_list_service_client_new(
device.pointer,
descriptor.pointer,
&mut pointer,
)
}
.into();
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(PropertyListServiceClient {
pointer,
phantom: std::marker::PhantomData,
})
}
/// Sends a plist to the device
/// # Arguments
/// * `data` - The plist to send
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn send_xml_plist(&self, data: Plist) -> Result<(), PropertyListServiceError> {
let result = unsafe {
unsafe_bindings::property_list_service_send_xml_plist(self.pointer, data.get_pointer())
}
.into();
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(())
}
/// Sends a plist as a binary
/// # Arguments
/// * `data` - The plist to send
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn send_binary_plist(&self, data: Plist) -> Result<(), PropertyListServiceError> {
let result = unsafe {
unsafe_bindings::property_list_service_send_binary_plist(
self.pointer,
data.get_pointer(),
)
}
.into();
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(())
}
/// Receives a plist from the service
/// # Arguments
/// * `timeout` - The timeout to wait for, 0 will wait indefinitely
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn receive_plist(&self, timeout: u32) -> Result<Plist, PropertyListServiceError> {
let mut plist_t = std::ptr::null_mut();
let result = if timeout == 0 {
unsafe {
unsafe_bindings::property_list_service_receive_plist(self.pointer, &mut plist_t)
}
.into()
} else {
unsafe {
unsafe_bindings::property_list_service_receive_plist_with_timeout(
self.pointer,
&mut plist_t,
timeout,
)
}
.into()
};
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(plist_t.into())
}
/// Enables SSL on the service connection
/// # Arguments
/// *none*
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn enable_ssl(&self) -> Result<(), PropertyListServiceError> {
let result =
unsafe { unsafe_bindings::property_list_service_enable_ssl(self.pointer) }.into();
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(())
}
/// Disables SSL on the service connection
/// # Arguments
/// *none*
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn disable_ssl(&self) -> Result<(), PropertyListServiceError> {
let result =
unsafe { unsafe_bindings::property_list_service_disable_ssl(self.pointer) }.into();
if result != PropertyListServiceError::Success {
return Err(result);
}
Ok(())
}
}
impl Drop for PropertyListServiceClient<'_> {
fn drop(&mut self) {
unsafe {
unsafe_bindings::property_list_service_client_free(self.pointer);
}
}
}