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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
cdef class BaseError(Exception):
def __cinit__(self, int16_t errcode):
self._c_errcode = errcode
def __nonzero__(self):
return self._c_errcode != 0
property message:
def __get__(self):
return self._lookup_table[self._c_errcode]
property code:
def __get__(self):
return self._c_errcode
def __str__(self):
return '%s (%s)' % (self.message, self.code)
def __repr__(self):
return self.__str__()
cdef class Base:
cdef inline int handle_error(self, int16_t ret) except -1:
if ret == 0:
return 0
cdef BaseError err = self._error(ret)
raise err
return -1
cdef inline BaseError _error(self, int16_t ret): pass
cdef extern from "libimobiledevice/libimobiledevice.h":
int16_t IDEVICE_E_SUCCESS
int16_t IDEVICE_E_INVALID_ARG
int16_t IDEVICE_E_UNKNOWN_ERROR
int16_t IDEVICE_E_NO_DEVICE
int16_t IDEVICE_E_NOT_ENOUGH_DATA
int16_t IDEVICE_E_BAD_HEADER
int16_t IDEVICE_E_SSL_ERROR
ctypedef void (*idevice_event_cb_t) (const_idevice_event_t event, void *user_data)
cdef extern idevice_error_t idevice_event_subscribe(idevice_event_cb_t callback, void *user_data)
cdef extern idevice_error_t idevice_event_unsubscribe()
idevice_error_t idevice_get_device_list(char ***devices, int *count)
idevice_error_t idevice_device_list_free(char **devices)
void idevice_set_debug_level(int level)
idevice_error_t idevice_new(idevice_t *device, char *uuid)
idevice_error_t idevice_free(idevice_t device)
idevice_error_t idevice_get_uuid(idevice_t device, char** uuid)
idevice_error_t idevice_get_handle(idevice_t device, uint32_t *handle)
cdef class iDeviceError(BaseError):
def __cinit__(self, *args, **kwargs):
self._lookup_table = {
IDEVICE_E_SUCCESS: 'Success',
IDEVICE_E_INVALID_ARG: 'Invalid argument',
IDEVICE_E_UNKNOWN_ERROR: 'Unknown error',
IDEVICE_E_NO_DEVICE: 'No device',
IDEVICE_E_NOT_ENOUGH_DATA: 'Not enough data',
IDEVICE_E_BAD_HEADER: 'Bad header',
IDEVICE_E_SSL_ERROR: 'SSL Error'
}
BaseError.__init__(self, *args, **kwargs)
cpdef set_debug_level(int level):
idevice_set_debug_level(level)
cdef class iDeviceEvent: pass
cdef void idevice_event_cb(const_idevice_event_t c_event, void *user_data):
cdef iDeviceEvent event = iDeviceEvent()
event._c_event = c_event
(<object>user_data)(event)
cpdef event_subscribe(object callback):
cdef iDeviceError err = iDeviceError(idevice_event_subscribe(idevice_event_cb, <void*>callback))
if err: raise err
cpdef event_unsubscribe():
cdef iDeviceError err = iDeviceError(idevice_event_unsubscribe())
if err: raise err
cpdef get_device_list():
cdef:
char** devices
int count
list result
bytes device
iDeviceError err = iDeviceError(idevice_get_device_list(&devices, &count))
if err: raise err
result = []
for i from 0 <= i < count:
device = devices[i]
result.append(device)
err = iDeviceError(idevice_device_list_free(devices))
if err: raise err
return result
cdef class iDevice(Base):
def __cinit__(self, uuid=None, *args, **kwargs):
cdef:
char* c_uuid = NULL
idevice_error_t err
if uuid is not None:
c_uuid = uuid
err = idevice_new(&self._c_dev, c_uuid)
self.handle_error(err)
def __dealloc__(self):
if self._c_dev is not NULL:
self.handle_error(idevice_free(self._c_dev))
cdef inline BaseError _error(self, int16_t ret):
return iDeviceError(ret)
property uuid:
def __get__(self):
cdef:
char* uuid
idevice_error_t err
err = idevice_get_uuid(self._c_dev, &uuid)
self.handle_error(err)
return uuid
property handle:
def __get__(self):
cdef uint32_t handle
self.handle_error(idevice_get_handle(self._c_dev, &handle))
return handle
cdef extern from "libimobiledevice/lockdown.h":
cdef struct lockdownd_client_int:
pass
ctypedef lockdownd_client_int *lockdownd_client_t
ctypedef int16_t lockdownd_error_t
int16_t LOCKDOWN_E_SUCCESS
int16_t LOCKDOWN_E_INVALID_ARG
int16_t LOCKDOWN_E_INVALID_CONF
int16_t LOCKDOWN_E_PLIST_ERROR
int16_t LOCKDOWN_E_PAIRING_FAILED
int16_t LOCKDOWN_E_SSL_ERROR
int16_t LOCKDOWN_E_DICT_ERROR
int16_t LOCKDOWN_E_START_SERVICE_FAILED
int16_t LOCKDOWN_E_NOT_ENOUGH_DATA
int16_t LOCKDOWN_E_SET_VALUE_PROHIBITED
int16_t LOCKDOWN_E_GET_VALUE_PROHIBITED
int16_t LOCKDOWN_E_REMOVE_VALUE_PROHIBITED
int16_t LOCKDOWN_E_MUX_ERROR
int16_t LOCKDOWN_E_ACTIVATION_FAILED
int16_t LOCKDOWN_E_PASSWORD_PROTECTED
int16_t LOCKDOWN_E_NO_RUNNING_SESSION
int16_t LOCKDOWN_E_INVALID_HOST_ID
int16_t LOCKDOWN_E_INVALID_SERVICE
int16_t LOCKDOWN_E_INVALID_ACTIVATION_RECORD
int16_t LOCKDOWN_E_UNKNOWN_ERROR
lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, char *label)
lockdownd_error_t lockdownd_client_free(lockdownd_client_t client)
lockdownd_error_t lockdownd_start_service(lockdownd_client_t client, char *service, uint16_t *port)
cdef class LockdownError(BaseError):
def __init__(self, *args, **kwargs):
self._lookup_table = {
LOCKDOWN_E_SUCCESS: "Success",
LOCKDOWN_E_INVALID_ARG: "Invalid argument",
LOCKDOWN_E_INVALID_CONF: "Invalid configuration",
LOCKDOWN_E_PLIST_ERROR: "PList error",
LOCKDOWN_E_PAIRING_FAILED: "Pairing failed",
LOCKDOWN_E_SSL_ERROR: "SSL error",
LOCKDOWN_E_DICT_ERROR: "Dict error",
LOCKDOWN_E_START_SERVICE_FAILED: "Start service failed",
LOCKDOWN_E_NOT_ENOUGH_DATA: "Not enough data",
LOCKDOWN_E_SET_VALUE_PROHIBITED: "Set value prohibited",
LOCKDOWN_E_GET_VALUE_PROHIBITED: "Get value prohibited",
LOCKDOWN_E_REMOVE_VALUE_PROHIBITED: "Remove value prohibited",
LOCKDOWN_E_MUX_ERROR: "MUX Error",
LOCKDOWN_E_ACTIVATION_FAILED: "Activation failed",
LOCKDOWN_E_PASSWORD_PROTECTED: "Password protected",
LOCKDOWN_E_NO_RUNNING_SESSION: "No running session",
LOCKDOWN_E_INVALID_HOST_ID: "Invalid host ID",
LOCKDOWN_E_INVALID_SERVICE: "Invalid service",
LOCKDOWN_E_INVALID_ACTIVATION_RECORD: "Invalid activation record",
LOCKDOWN_E_UNKNOWN_ERROR: "Unknown error"
}
BaseError.__init__(self, *args, **kwargs)
cdef class LockdownClient(Base):
def __cinit__(self, iDevice device not None, char *label=NULL, *args, **kwargs):
cdef:
iDevice dev = device
lockdownd_error_t err = lockdownd_client_new_with_handshake(dev._c_dev, &(self._c_client), label)
self.handle_error(err)
def __dealloc__(self):
cdef lockdownd_error_t err
if self._c_client is not NULL:
err = lockdownd_client_free(self._c_client)
self.handle_error(err)
cdef inline BaseError _error(self, int16_t ret):
return LockdownError(ret)
cpdef int start_service(self, service):
cdef:
uint16_t port
lockdownd_error_t err
err = lockdownd_start_service(self._c_client, service, &port)
self.handle_error(err)
return port
cpdef goodbye(self):
pass
include "property_list_client.pxi"
include "mobilesync.pxi"
include "notification_proxy.pxi"
include "sbservices.pxi"
include "mobilebackup.pxi"
|
