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
// jkcoxson
use crate::bindings as unsafe_bindings;
use crate::error::NpError;
use crate::idevice::Device;
use crate::services::lockdownd::LockdowndService;
/// A service to proxy notifications to the device
pub struct NotificationProxyClient<'a> {
pub(crate) pointer: unsafe_bindings::np_client_t,
phantom: std::marker::PhantomData<&'a Device>,
}
impl NotificationProxyClient<'_> {
/// Creates a new notification proxy from a lockdown 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, NpError> {
let mut pointer = std::ptr::null_mut();
let result = unsafe {
unsafe_bindings::np_client_new(device.pointer, descriptor.pointer, &mut pointer)
}
.into();
if result != NpError::Success {
return Err(result);
}
Ok(Self {
pointer,
phantom: std::marker::PhantomData,
})
}
/// Starts a new connection and adds a notification proxy to it
/// # Arguments
/// * `device` - The device to connect to
/// * `label` - The label for the connection
/// # Returns
/// A struct containing the handle to the connection
///
/// ***Verified:*** False
pub fn start_service(device: &Device, label: impl Into<String>) -> Result<Self, NpError> {
let mut pointer = std::ptr::null_mut();
let result = unsafe {
unsafe_bindings::np_client_start_service(
device.pointer,
&mut pointer,
label.into().as_ptr() as *const std::os::raw::c_char,
)
}
.into();
if result != NpError::Success {
return Err(result);
}
Ok(Self {
pointer,
phantom: std::marker::PhantomData,
})
}
/// Sends a notification to the device
/// # Arguments
/// * `notification` - The contents of the notification
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn post_notification(&self, notification: &str) -> Result<(), NpError> {
let result = unsafe {
unsafe_bindings::np_post_notification(
self.pointer,
notification.as_ptr() as *const std::os::raw::c_char,
)
}
.into();
if result != NpError::Success {
return Err(result);
}
Ok(())
}
/// Tells the proxy to send a notification when an event occurs
/// # Arguments
/// * `notification` - The contents of the notification
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn observe_notification(&self, notification: &str) -> Result<(), NpError> {
let result = unsafe {
unsafe_bindings::np_observe_notification(
self.pointer,
notification.as_ptr() as *const std::os::raw::c_char,
)
}
.into();
if result != NpError::Success {
return Err(result);
}
Ok(())
}
/// Tells the proxy to send notifications when an event occurs
/// # Arguments
/// * `notifications` - The contents of the notifications
/// # Returns
/// *none*
///
/// ***Verified:*** False
pub fn observe_notifications(&self, notifications: Vec<&str>) -> Result<(), NpError> {
let mut not_ptrs = Vec::new();
for notification in notifications {
not_ptrs.push(notification.as_ptr() as *const std::os::raw::c_char);
}
let result = unsafe {
unsafe_bindings::np_observe_notifications(self.pointer, not_ptrs.as_mut_ptr())
}
.into();
if result != NpError::Success {
return Err(result);
}
Ok(())
}
}
impl Drop for NotificationProxyClient<'_> {
fn drop(&mut self) {
unsafe {
unsafe_bindings::np_client_free(self.pointer);
}
}
}