diff options
Diffstat (limited to 'src/idevice.c')
| -rw-r--r-- | src/idevice.c | 618 |
1 files changed, 618 insertions, 0 deletions
diff --git a/src/idevice.c b/src/idevice.c new file mode 100644 index 0000000..c5050d5 --- /dev/null +++ b/src/idevice.c @@ -0,0 +1,618 @@ +/* + * idevice.c + * Device discovery and communication interface. + * + * Copyright (c) 2008 Zach C. All Rights Reserved. + * Copyright (c) 2009 Nikias Bassen. All Rights Reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <arpa/inet.h> + +#include <usbmuxd.h> +#include <gnutls/gnutls.h> +#include "idevice.h" +#include "debug.h" + +static idevice_event_cb_t event_cb = NULL; + +static void usbmux_event_cb(const usbmuxd_event_t *event, void *user_data) +{ + idevice_event_t ev; + + ev.event = event->event; + ev.uuid = event->device.uuid; + ev.conn_type = CONNECTION_USBMUXD; + + if (event_cb) { + event_cb(&ev, user_data); + } +} + +/** + * Register a callback function that will be called when device add/remove + * events occur. + * + * @param callback Callback function to call. + * @param user_data Application-specific data passed as parameter + * to the registered callback function. + * + * @return IDEVICE_E_SUCCESS on success or an error value when an error occured. + */ +idevice_error_t idevice_event_subscribe(idevice_event_cb_t callback, void *user_data) +{ + event_cb = callback; + int res = usbmuxd_subscribe(usbmux_event_cb, user_data); + if (res != 0) { + event_cb = NULL; + debug_info("Error %d when subscribing usbmux event callback!", res); + return IDEVICE_E_UNKNOWN_ERROR; + } + return IDEVICE_E_SUCCESS; +} + +/** + * Release the event callback function that has been registered with + * idevice_event_subscribe(). + * + * @return IDEVICE_E_SUCCESS on success or an error value when an error occured. + */ +idevice_error_t idevice_event_unsubscribe() +{ + event_cb = NULL; + int res = usbmuxd_unsubscribe(); + if (res != 0) { + debug_info("Error %d when unsubscribing usbmux event callback!", res); + return IDEVICE_E_UNKNOWN_ERROR; + } + return IDEVICE_E_SUCCESS; +} + +/** + * Get a list of currently available devices. + * + * @param devices List of uuids of devices that are currently available. + * This list is terminated by a NULL pointer. + * @param count Number of devices found. + * + * @return IDEVICE_E_SUCCESS on success or an error value when an error occured. + */ +idevice_error_t idevice_get_device_list(char ***devices, int *count) +{ + usbmuxd_device_info_t *dev_list; + + *devices = NULL; + *count = 0; + + if (usbmuxd_get_device_list(&dev_list) < 0) { + debug_info("ERROR: usbmuxd is not running!\n", __func__); + return IDEVICE_E_NO_DEVICE; + } + + char **newlist = NULL; + int i, newcount = 0; + + for (i = 0; dev_list[i].handle > 0; i++) { + newlist = realloc(*devices, sizeof(char*) * (newcount+1)); + newlist[newcount++] = strdup(dev_list[i].uuid); + *devices = newlist; + } + usbmuxd_device_list_free(&dev_list); + + *count = newcount; + newlist = realloc(*devices, sizeof(char*) * (newcount+1)); + newlist[newcount] = NULL; + *devices = newlist; + + return IDEVICE_E_SUCCESS; +} + +/** + * Free a list of device uuids. + * + * @param devices List of uuids to free. + * + * @return Always returnes IDEVICE_E_SUCCESS. + */ +idevice_error_t idevice_device_list_free(char **devices) +{ + if (devices) { + int i = 0; + while (devices[i++]) { + free(devices[i]); + } + free(devices); + } + return IDEVICE_E_SUCCESS; +} + +/** + * Creates an idevice_t structure for the device specified by uuid, + * if the device is available. + * + * @note The resulting idevice_t structure has to be freed with + * idevice_free() if it is no longer used. + * + * @param device Upon calling this function, a pointer to a location of type + * idevice_t. On successful return, this location will be populated. + * @param uuid The UUID to match. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_new(idevice_t * device, const char *uuid) +{ + usbmuxd_device_info_t muxdev; + int res = usbmuxd_get_device_by_uuid(uuid, &muxdev); + if (res > 0) { + idevice_t phone = (idevice_t) malloc(sizeof(struct idevice_int)); + phone->uuid = strdup(muxdev.uuid); + phone->conn_type = CONNECTION_USBMUXD; + phone->conn_data = (void*)muxdev.handle; + *device = phone; + return IDEVICE_E_SUCCESS; + } + /* other connection types could follow here */ + + return IDEVICE_E_NO_DEVICE; +} + +/** Cleans up an idevice structure, then frees the structure itself. + * This is a library-level function; deals directly with the device to tear + * down relations, but otherwise is mostly internal. + * + * @param device idevice_t to free. + */ +idevice_error_t idevice_free(idevice_t device) +{ + if (!device) + return IDEVICE_E_INVALID_ARG; + idevice_error_t ret = IDEVICE_E_UNKNOWN_ERROR; + + ret = IDEVICE_E_SUCCESS; + + free(device->uuid); + + if (device->conn_type == CONNECTION_USBMUXD) { + device->conn_data = 0; + } + if (device->conn_data) { + free(device->conn_data); + } + free(device); + return ret; +} + +/** + * Set up a connection to the given device. + * + * @param device The device to connect to. + * @param port The destination port to connect to. + * @param connection Pointer to an idevice_connection_t that will be filled + * with the necessary data of the connection. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_connect(idevice_t device, uint16_t port, idevice_connection_t *connection) +{ + if (!device) { + return IDEVICE_E_INVALID_ARG; + } + + if (device->conn_type == CONNECTION_USBMUXD) { + int sfd = usbmuxd_connect((uint32_t)(device->conn_data), port); + if (sfd < 0) { + debug_info("ERROR: Connecting to usbmuxd failed: %d (%s)", sfd, strerror(-sfd)); + return IDEVICE_E_UNKNOWN_ERROR; + } + idevice_connection_t new_connection = (idevice_connection_t)malloc(sizeof(struct idevice_connection_int)); + new_connection->type = CONNECTION_USBMUXD; + new_connection->data = (void*)sfd; + new_connection->ssl_data = NULL; + *connection = new_connection; + return IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", device->conn_type); + } + + return IDEVICE_E_UNKNOWN_ERROR; +} + +/** + * Disconnect from the device and clean up the connection structure. + * + * @param connection The connection to close. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_disconnect(idevice_connection_t connection) +{ + if (!connection) { + return IDEVICE_E_INVALID_ARG; + } + /* shut down ssl if enabled */ + if (connection->ssl_data) { + idevice_connection_disable_ssl(connection); + } + idevice_error_t result = IDEVICE_E_UNKNOWN_ERROR; + if (connection->type == CONNECTION_USBMUXD) { + usbmuxd_disconnect((int)(connection->data)); + result = IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", connection->type); + } + free(connection); + return result; +} + +/** + * Internally used function to send raw data over the given connection. + */ +static idevice_error_t internal_connection_send(idevice_connection_t connection, const char *data, uint32_t len, uint32_t *sent_bytes) +{ + if (!connection || !data) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->type == CONNECTION_USBMUXD) { + int res = usbmuxd_send((int)(connection->data), data, len, sent_bytes); + if (res < 0) { + debug_info("ERROR: usbmuxd_send returned %d (%s)", res, strerror(-res)); + return IDEVICE_E_UNKNOWN_ERROR; + } + return IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", connection->type); + } + return IDEVICE_E_UNKNOWN_ERROR; + +} + +/** + * Send data to a device via the given connection. + * + * @param connection The connection to send data over. + * @param data Buffer with data to send. + * @param len Size of the buffer to send. + * @param sent_bytes Pointer to an uint32_t that will be filled + * with the number of bytes actually sent. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_connection_send(idevice_connection_t connection, const char *data, uint32_t len, uint32_t *sent_bytes) +{ + if (!connection || !data || (connection->ssl_data && !connection->ssl_data->session)) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->ssl_data) { + ssize_t sent = gnutls_record_send(connection->ssl_data->session, (void*)data, (size_t)len); + if ((uint32_t)sent == (uint32_t)len) { + *sent_bytes = sent; + return IDEVICE_E_SUCCESS; + } + *sent_bytes = 0; + return IDEVICE_E_SSL_ERROR; + } + return internal_connection_send(connection, data, len, sent_bytes); +} + +/** + * Internally used function for receiving raw data over the given connection + * using a timeout. + */ +static idevice_error_t internal_connection_receive_timeout(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes, unsigned int timeout) +{ + if (!connection) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->type == CONNECTION_USBMUXD) { + int res = usbmuxd_recv_timeout((int)(connection->data), data, len, recv_bytes, timeout); + if (res < 0) { + debug_info("ERROR: usbmuxd_recv_timeout returned %d (%s)", res, strerror(-res)); + return IDEVICE_E_UNKNOWN_ERROR; + } + return IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", connection->type); + } + return IDEVICE_E_UNKNOWN_ERROR; +} + +/** + * Receive data from a device via the given connection. + * This function will return after the given timeout even if no data has been + * received. + * + * @param connection The connection to receive data from. + * @param data Buffer that will be filled with the received data. + * This buffer has to be large enough to hold len bytes. + * @param len Buffer size or number of bytes to receive. + * @param recv_bytes Number of bytes actually received. + * @param timeout Timeout in milliseconds after which this function should + * return even if no data has been received. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_connection_receive_timeout(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes, unsigned int timeout) +{ + if (!connection || (connection->ssl_data && !connection->ssl_data->session)) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->ssl_data) { + ssize_t received = gnutls_record_recv(connection->ssl_data->session, (void*)data, (size_t)len); + if (received > 0) { + *recv_bytes = received; + return IDEVICE_E_SUCCESS; + } + *recv_bytes = 0; + return IDEVICE_E_SSL_ERROR; + } + return internal_connection_receive_timeout(connection, data, len, recv_bytes, timeout); +} + +/** + * Internally used function for receiving raw data over the given connection. + */ +static idevice_error_t internal_connection_receive(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes) +{ + if (!connection) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->type == CONNECTION_USBMUXD) { + int res = usbmuxd_recv((int)(connection->data), data, len, recv_bytes); + if (res < 0) { + debug_info("ERROR: usbmuxd_recv returned %d (%s)", res, strerror(-res)); + return IDEVICE_E_UNKNOWN_ERROR; + } + + return IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", connection->type); + } + return IDEVICE_E_UNKNOWN_ERROR; +} + +/** + * Receive data from a device via the given connection. + * This function is like idevice_connection_receive_timeout, but with a + * predefined reasonable timeout. + * + * @param connection The connection to receive data from. + * @param data Buffer that will be filled with the received data. + * This buffer has to be large enough to hold len bytes. + * @param len Buffer size or number of bytes to receive. + * @param recv_bytes Number of bytes actually received. + * + * @return IDEVICE_E_SUCCESS if ok, otherwise an error code. + */ +idevice_error_t idevice_connection_receive(idevice_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes) +{ + if (!connection || (connection->ssl_data && !connection->ssl_data->session)) { + return IDEVICE_E_INVALID_ARG; + } + + if (connection->ssl_data) { + ssize_t received = gnutls_record_recv(connection->ssl_data->session, (void*)data, (size_t)len); + if (received > 0) { + *recv_bytes = received; + return IDEVICE_E_SUCCESS; + } + *recv_bytes = 0; + return IDEVICE_E_SSL_ERROR; + } + return internal_connection_receive(connection, data, len, recv_bytes); +} + +idevice_error_t idevice_get_handle(idevice_t device, uint32_t *handle) +{ + if (!device) + return IDEVICE_E_INVALID_ARG; + + if (device->conn_type == CONNECTION_USBMUXD) { + *handle = (uint32_t)device->conn_data; + return IDEVICE_E_SUCCESS; + } else { + debug_info("Unknown connection type %d", device->conn_type); + } + return IDEVICE_E_UNKNOWN_ERROR; +} + +idevice_error_t idevice_get_uuid(idevice_t device, char **uuid) +{ + if (!device) + return IDEVICE_E_INVALID_ARG; + + *uuid = strdup(device->uuid); + return IDEVICE_E_SUCCESS; +} + +/** + * Internally used gnutls callback function for receiving encrypted data. + */ +static ssize_t internal_ssl_read(gnutls_transport_ptr_t transport, char *buffer, size_t length) +{ + int bytes = 0, pos_start_fill = 0; + size_t tbytes = 0; + int this_len = length; + idevice_error_t res; + idevice_connection_t connection = (idevice_connection_t)transport; + char *recv_buffer; + + debug_info("pre-read client wants %zi bytes", length); + + recv_buffer = (char *) malloc(sizeof(char) * this_len); + + /* repeat until we have the full data or an error occurs */ + do { + if ((res = internal_connection_receive(connection, recv_buffer, this_len, (uint32_t*)&bytes)) != IDEVICE_E_SUCCESS) { + debug_info("ERROR: idevice_connection_receive returned %d", res); + return res; + } + debug_info("post-read we got %i bytes", bytes); + + // increase read count + tbytes += bytes; + + // fill the buffer with what we got right now + memcpy(buffer + pos_start_fill, recv_buffer, bytes); + pos_start_fill += bytes; + + if (tbytes >= length) { + break; + } + + this_len = length - tbytes; + debug_info("re-read trying to read missing %i bytes", this_len); + } while (tbytes < length); + + if (recv_buffer) { + free(recv_buffer); + } + return tbytes; +} + +/** + * Internally used gnutls callback function for sending encrypted data. + */ +static ssize_t internal_ssl_write(gnutls_transport_ptr_t transport, char *buffer, size_t length) +{ + uint32_t bytes = 0; + idevice_connection_t connection = (idevice_connection_t)transport; + debug_info("pre-send length = %zi", length); + internal_connection_send(connection, buffer, length, &bytes); + debug_info("post-send sent %i bytes", bytes); + return bytes; +} + +/** + * Internally used function for cleaning up SSL stuff. + */ +static void internal_ssl_cleanup(ssl_data_t ssl_data) +{ + if (!ssl_data) + return; + + if (ssl_data->session) { + gnutls_deinit(ssl_data->session); + } + if (ssl_data->certificate) { + gnutls_certificate_free_credentials(ssl_data->certificate); + } +} + +/** + * Enables SSL for the given connection. + * + * @param connection The connection to enable SSL for. + * + * @return IDEVICE_E_SUCCESS on success, IDEVICE_E_INVALID_ARG when connection + * is NULL or connection->ssl_data is non-NULL, or IDEVICE_E_SSL_ERROR when + * SSL initialization, setup, or handshake fails. + */ +idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection) +{ + if (!connection || connection->ssl_data) + return IDEVICE_E_INVALID_ARG; + + idevice_error_t ret = IDEVICE_E_SSL_ERROR; + uint32_t return_me = 0; + + ssl_data_t ssl_data_loc = (ssl_data_t)malloc(sizeof(struct ssl_data_int)); + + // Set up GnuTLS... + debug_info("enabling SSL mode"); + errno = 0; + gnutls_global_init(); + gnutls_certificate_allocate_credentials(&ssl_data_loc->certificate); + gnutls_certificate_set_x509_trust_file(ssl_data_loc->certificate, "hostcert.pem", GNUTLS_X509_FMT_PEM); + gnutls_init(&ssl_data_loc->session, GNUTLS_CLIENT); + { + int protocol_priority[16] = { GNUTLS_SSL3, 0 }; + int kx_priority[16] = { GNUTLS_KX_ANON_DH, GNUTLS_KX_RSA, 0 }; + int cipher_priority[16] = { GNUTLS_CIPHER_AES_128_CBC, GNUTLS_CIPHER_AES_256_CBC, 0 }; + int mac_priority[16] = { GNUTLS_MAC_SHA1, GNUTLS_MAC_MD5, 0 }; + int comp_priority[16] = { GNUTLS_COMP_NULL, 0 }; + + gnutls_cipher_set_priority(ssl_data_loc->session, cipher_priority); + gnutls_compression_set_priority(ssl_data_loc->session, comp_priority); + gnutls_kx_set_priority(ssl_data_loc->session, kx_priority); + gnutls_protocol_set_priority(ssl_data_loc->session, protocol_priority); + gnutls_mac_set_priority(ssl_data_loc->session, mac_priority); + } + gnutls_credentials_set(ssl_data_loc->session, GNUTLS_CRD_CERTIFICATE, ssl_data_loc->certificate); // this part is killing me. + + debug_info("GnuTLS step 1..."); + gnutls_transport_set_ptr(ssl_data_loc->session, (gnutls_transport_ptr_t)connection); + debug_info("GnuTLS step 2..."); + gnutls_transport_set_push_function(ssl_data_loc->session, (gnutls_push_func) & internal_ssl_write); + debug_info("GnuTLS step 3..."); + gnutls_transport_set_pull_function(ssl_data_loc->session, (gnutls_pull_func) & internal_ssl_read); + debug_info("GnuTLS step 4 -- now handshaking..."); + if (errno) + debug_info("WARN: errno says %s before handshake!", strerror(errno)); + return_me = gnutls_handshake(ssl_data_loc->session); + debug_info("GnuTLS handshake done..."); + + if (return_me != GNUTLS_E_SUCCESS) { + internal_ssl_cleanup(ssl_data_loc); + free(ssl_data_loc); + debug_info("GnuTLS reported something wrong."); + gnutls_perror(return_me); + debug_info("oh.. errno says %s", strerror(errno)); + } else { + connection->ssl_data = ssl_data_loc; + ret = IDEVICE_E_SUCCESS; + debug_info("SSL mode enabled"); + } + return ret; +} + +/** + * Disable SSL for the given connection. + * + * @param connection The connection to disable SSL for. + * + * @return IDEVICE_E_SUCCESS on success, IDEVICE_E_INVALID_ARG when connection + * is NULL. This function also returns IDEVICE_E_SUCCESS when SSL is not + * enabled and does no further error checking on cleanup. + */ +idevice_error_t idevice_connection_disable_ssl(idevice_connection_t connection) +{ + if (!connection) + return IDEVICE_E_INVALID_ARG; + if (!connection->ssl_data) { + /* ignore if ssl is not enabled */ + return IDEVICE_E_SUCCESS; + } + + if (connection->ssl_data->session) { + gnutls_bye(connection->ssl_data->session, GNUTLS_SHUT_RDWR); + } + internal_ssl_cleanup(connection->ssl_data); + free(connection->ssl_data); + connection->ssl_data = NULL; + + debug_info("SSL mode disabled"); + + return IDEVICE_E_SUCCESS; +} + |