summaryrefslogtreecommitdiffstats
path: root/cython/imobiledevice.pyx
blob: 7190defffbc91da8c11c67f365de49416acadf31 (plain)
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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
cdef extern from *:
    ctypedef unsigned char uint8_t
    ctypedef short int int16_t
    ctypedef unsigned short int uint16_t
    ctypedef unsigned int uint32_t
    ctypedef int int32_t
IF UNAME_MACHINE == 'x86_64':
    ctypedef unsigned long int uint64_t
ELSE:
    ctypedef unsigned long long int uint64_t

cimport plist

cdef extern from "pyerrors.h":
    ctypedef class __builtin__.Exception [object PyBaseExceptionObject]:
        pass

cdef class BaseError(Exception):
    cdef dict _lookup_table
    cdef int16_t _c_errcode
    cpdef get_message(self)

    def __cinit__(self, int16_t errcode):
        self._c_errcode = errcode
        Exception.__init__(self, errcode)
    
    def __nonzero__(self):
        return self._c_errcode != 0

    cpdef get_message(self):
        return '%s (%s)' % (self._lookup_table[self._c_errcode], self._c_errcode)

    def __str__(self):
        return self.get_message()

    def __repr__(self):
        return self.__str__()

cdef extern from "libimobiledevice/libimobiledevice.h":
    cdef struct idevice_int:
        pass
    ctypedef idevice_int* idevice_t
    ctypedef int16_t idevice_error_t
    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
    cdef enum idevice_event_type:
        IDEVICE_DEVICE_ADD = 1,
        IDEVICE_DEVICE_REMOVE
    ctypedef struct idevice_event_t:
        idevice_event_type event
        char *uuid
        int conn_type
    ctypedef void (*idevice_event_cb_t) (idevice_event_t *event, void *user_data)
    cdef extern idevice_error_t c_idevice_event_subscribe "idevice_event_subscribe" (idevice_event_cb_t callback, void *user_data)
    cdef extern idevice_error_t c_idevice_event_unsubscribe "idevice_event_unsubscribe" ()
    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)

def set_debug_level(level):
    idevice_set_debug_level(level)

#cdef void idevice_event_cb(idevice_event_t *c_event, void *user_data):
    #event = iDeviceEvent()
    #event._c_event = c_event
    #(<object>user_data)(event)

#def idevice_event_subscribe(callback):
    #c_idevice_event_subscribe(idevice_event_cb, <void*>callback)

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)

cdef class iDeviceEvent:
    cdef idevice_event_t* _c_event

cdef class iDevice:
    cdef idevice_t _c_dev

    def __cinit__(self, uuid=None, *args, **kwargs):
        cdef char* c_uuid = NULL
        if uuid is not None:
            c_uuid = uuid
        err = iDeviceError(idevice_new(&(self._c_dev), c_uuid))
        if err: raise err

    def __dealloc__(self):
        if self._c_dev is not NULL:
            err = iDeviceError(idevice_free(self._c_dev))
            if err: raise err

    property uuid:
        def __get__(self):
            cdef char* uuid
            err = iDeviceError(idevice_get_uuid(self._c_dev, &uuid))
            if err: raise err
            return uuid
    property handle:
        def __get__(self):
            cdef uint32_t handle
            err = iDeviceError(idevice_get_handle(self._c_dev, &handle))
            if err: raise err
            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:
    cdef lockdownd_client_t _c_client

    def __cinit__(self, iDevice device not None, char *label=NULL, *args, **kwargs):
        cdef iDevice dev = device
        err = LockdownError(lockdownd_client_new_with_handshake(dev._c_dev, &(self._c_client), label))
        if err: raise err
    
    def __dealloc__(self):
        if self._c_client is not NULL:
            err = LockdownError(lockdownd_client_free(self._c_client))
            if err: raise err
    
    cpdef start_service(self, service):
        cdef uint16_t port
        err = LockdownError(lockdownd_start_service(self._c_client, service, &port))
        if err: raise err
        return port
    
    def goodbye(self):
        pass
        

cdef extern from "libimobiledevice/mobilesync.h":
    cdef struct mobilesync_client_int:
        pass
    ctypedef mobilesync_client_int *mobilesync_client_t

    ctypedef int16_t mobilesync_error_t
    int16_t MOBILESYNC_E_SUCCESS
    int16_t MOBILESYNC_E_INVALID_ARG
    int16_t MOBILESYNC_E_PLIST_ERROR
    int16_t MOBILESYNC_E_MUX_ERROR
    int16_t MOBILESYNC_E_BAD_VERSION
    int16_t MOBILESYNC_E_UNKNOWN_ERROR

    mobilesync_error_t mobilesync_client_new(idevice_t device, uint16_t port, mobilesync_client_t * client)
    mobilesync_error_t mobilesync_client_free(mobilesync_client_t client)
    mobilesync_error_t mobilesync_receive(mobilesync_client_t client, plist.plist_t *plist)
    mobilesync_error_t mobilesync_send(mobilesync_client_t client, plist.plist_t plist)

cdef class MobileSyncError(BaseError):
    def __init__(self, *args, **kwargs):
        self._lookup_table = {
            MOBILESYNC_E_SUCCESS: "Success",
            MOBILESYNC_E_INVALID_ARG: "Invalid argument",
            MOBILESYNC_E_PLIST_ERROR: "PList Error",
            MOBILESYNC_E_MUX_ERROR: "MUX Error",
            MOBILESYNC_E_BAD_VERSION: "Bad Version",
            MOBILESYNC_E_UNKNOWN_ERROR: "Unknown error"
        }
        BaseError.__init__(self, *args, **kwargs)

cdef class MobileSyncClient:
    cdef mobilesync_client_t _c_client

    def __cinit__(self, iDevice device not None, LockdownClient lockdown not None, *args, **kwargs):
        cdef iDevice dev = device
        cdef LockdownClient lckd = lockdown
        port = lckd.start_service("com.apple.mobilesync")
        err = MobileSyncError(mobilesync_client_new(dev._c_dev, port, &(self._c_client)))
        if err: raise err
    
    def __dealloc__(self):
        if self._c_client is not NULL:
            err = MobileSyncError(mobilesync_client_free(self._c_client))
            if err: raise err
    
    cpdef send(self, object obj):
        cdef plist.Node node
        cdef plist.plist_t c_node
        if isinstance(obj, plist.Node):
            node = obj
            c_node = node._c_node
        else:
            c_node = plist.native_to_plist_t(obj)
        err = MobileSyncError(mobilesync_send(self._c_client, c_node))
        if err: raise err

    cpdef receive(self):
        cdef plist.plist_t c_node = NULL
        err = MobileSyncError(mobilesync_receive(self._c_client, &(c_node)))
        if err: raise err

        return plist.plist_t_to_node(c_node)

cdef extern from *:
    ctypedef char* const_char_ptr "const char*"

cdef extern from "libimobiledevice/notification_proxy.h":
    cdef struct np_client_int:
        pass
    ctypedef np_client_int *np_client_t
    ctypedef int16_t np_error_t
    ctypedef void (*np_notify_cb_t) (const_char_ptr notification, void *userdata)
    np_error_t np_client_new(idevice_t device, uint16_t port, np_client_t *client)
    np_error_t np_client_free(np_client_t client)
    np_error_t np_post_notification(np_client_t client, char *notification)
    np_error_t np_observe_notification(np_client_t client, char *notification)
    np_error_t np_observe_notifications(np_client_t client, char **notification_spec)
    np_error_t np_set_notify_callback(np_client_t client, np_notify_cb_t notify_cb, void *userdata)

cdef void np_notify_cb(const_char_ptr notification, void *py_callback):
    (<object>py_callback)(notification)

cdef class NotificationProxyError(BaseError):
    pass

cdef class NotificationProxy:
    cdef np_client_t _c_client

    def __cinit__(self, iDevice device not None, LockdownClient lockdown not None, *args, **kwargs):
        cdef iDevice dev = device
        cdef LockdownClient lckd = lockdown
        port = lckd.start_service("com.apple.mobile.notification_proxy")
        err = NotificationProxyError(np_client_new(dev._c_dev, port, &(self._c_client)))
        if err: raise err

    def __dealloc__(self):
        if self._c_client is not NULL:
            err = NotificationProxyError(np_client_free(self._c_client))
            if err: raise err
    
    def set_notify_callback(self, callback):
        err = NotificationProxyError(np_set_notify_callback(self._c_client, np_notify_cb, <void*>callback))
        if err: raise err
    
    def observe_notification(self, notification):
        err = NotificationProxyError(np_observe_notification(self._c_client, notification))
        if err: raise err

cdef extern from "libimobiledevice/sbservices.h":
    cdef struct sbservices_client_int:
        pass
    ctypedef sbservices_client_int *sbservices_client_t
    ctypedef int16_t sbservices_error_t
    sbservices_error_t sbservices_client_new(idevice_t device, uint16_t port, sbservices_client_t *client)
    sbservices_error_t sbservices_client_free(sbservices_client_t client)
    sbservices_error_t sbservices_get_icon_state(sbservices_client_t client, plist.plist_t *state)
    sbservices_error_t sbservices_set_icon_state(sbservices_client_t client, plist.plist_t newstate)
    sbservices_error_t sbservices_get_icon_pngdata(sbservices_client_t client, char *bundleId, char **pngdata, uint64_t *pngsize)

cdef class SpringboardServicesError(BaseError):
    pass

cdef class SpringboardServices:
    cdef sbservices_client_t _c_client

    def __cinit__(self, iDevice device not None, LockdownClient lockdown not None, *args, **kwargs):
        cdef iDevice dev = device
        cdef LockdownClient lckd = lockdown
        port = lockdown.start_service("com.apple.springboardservices")
        err = SpringboardServicesError(sbservices_client_new(dev._c_dev, port, &(self._c_client)))
        if err: raise err
    
    def __dealloc__(self):
        if self._c_client is not NULL:
            err = SpringboardServicesError(sbservices_client_free(self._c_client))
            if err: raise err