From 96101a1231a4ddfeb40fd738a24e108a3a904048 Mon Sep 17 00:00:00 2001 From: Nikias Bassen Date: Thu, 28 Jan 2010 22:18:41 +0100 Subject: Global renames due to project rename to libimobiledevice --- src/Makefile.am | 4 +- src/afc.c | 34 +-- src/afc.h | 4 +- src/debug.c | 4 +- src/device_link_service.c | 2 +- src/device_link_service.h | 2 +- src/file_relay.c | 6 +- src/file_relay.h | 2 +- src/idevice.c | 618 ++++++++++++++++++++++++++++++++++++++++++++ src/idevice.h | 54 ++++ src/installation_proxy.c | 2 +- src/installation_proxy.h | 2 +- src/iphone.c | 618 -------------------------------------------- src/iphone.h | 54 ---- src/lockdown.c | 28 +- src/lockdown.h | 2 +- src/mobilebackup.c | 6 +- src/mobilebackup.h | 2 +- src/mobilesync.c | 6 +- src/mobilesync.h | 2 +- src/notification_proxy.c | 6 +- src/notification_proxy.h | 2 +- src/property_list_service.c | 34 +-- src/property_list_service.h | 6 +- src/sbservices.c | 2 +- src/sbservices.h | 2 +- src/userpref.c | 66 ++--- 27 files changed, 785 insertions(+), 785 deletions(-) create mode 100644 src/idevice.c create mode 100644 src/idevice.h delete mode 100644 src/iphone.c delete mode 100644 src/iphone.h (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index 93cfbaf..69bbd9b 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -3,8 +3,8 @@ INCLUDES = -I$(top_srcdir)/include AM_CFLAGS = $(GLOBAL_CFLAGS) $(libusbmuxd_CFLAGS) $(libglib2_CFLAGS) $(libgnutls_CFLAGS) $(libtasn1_CFLAGS) $(libgthread2_CFLAGS) $(libplist_CFLAGS) $(LFS_CFLAGS) AM_LDFLAGS = $(libglib2_LIBS) $(libgnutls_LIBS) $(libtasn1_LIBS) $(libgthread2_LIBS) $(libplist_LIBS) $(libusbmuxd_LIBS) $(libgcrypt_LIBS) -lib_LTLIBRARIES = libiphone.la -libiphone_la_SOURCES = iphone.c iphone.h \ +lib_LTLIBRARIES = libimobiledevice.la +libimobiledevice_la_SOURCES = idevice.c idevice.h \ debug.c debug.h\ userpref.c userpref.h\ property_list_service.c property_list_service.h\ diff --git a/src/afc.c b/src/afc.c index 767e460..4367add 100644 --- a/src/afc.c +++ b/src/afc.c @@ -24,7 +24,7 @@ #include #include "afc.h" -#include "iphone.h" +#include "idevice.h" #include "debug.h" // This is the maximum size an AFC data packet can be @@ -61,7 +61,7 @@ static void afc_unlock(afc_client_t client) * is invalid, AFC_E_MUX_ERROR when the connection failed, or AFC_E_NO_MEM * when there's a memory allocation problem. */ -afc_error_t afc_client_new(iphone_device_t device, uint16_t port, afc_client_t * client) +afc_error_t afc_client_new(idevice_t device, uint16_t port, afc_client_t * client) { /* makes sure thread environment is available */ if (!g_thread_supported()) @@ -71,8 +71,8 @@ afc_error_t afc_client_new(iphone_device_t device, uint16_t port, afc_client_t * return AFC_E_INVALID_ARGUMENT; /* attempt connection */ - iphone_connection_t connection = NULL; - if (iphone_device_connect(device, port, &connection) != IPHONE_E_SUCCESS) { + idevice_connection_t connection = NULL; + if (idevice_connect(device, port, &connection) != IDEVICE_E_SUCCESS) { return AFC_E_MUX_ERROR; } @@ -82,7 +82,7 @@ afc_error_t afc_client_new(iphone_device_t device, uint16_t port, afc_client_t * /* allocate a packet */ client_loc->afc_packet = (AFCPacket *) malloc(sizeof(AFCPacket)); if (!client_loc->afc_packet) { - iphone_device_disconnect(client_loc->connection); + idevice_disconnect(client_loc->connection); free(client_loc); return AFC_E_NO_MEM; } @@ -108,7 +108,7 @@ afc_error_t afc_client_free(afc_client_t client) if (!client || !client->connection || !client->afc_packet) return AFC_E_INVALID_ARGUMENT; - iphone_device_disconnect(client->connection); + idevice_disconnect(client->connection); free(client->afc_packet); if (client->mutex) { g_mutex_free(client->mutex); @@ -169,7 +169,7 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui /* send AFC packet header */ AFCPacket_to_LE(client->afc_packet); sent = 0; - iphone_connection_send(client->connection, (void*)client->afc_packet, sizeof(AFCPacket), &sent); + idevice_connection_send(client->connection, (void*)client->afc_packet, sizeof(AFCPacket), &sent); if (sent == 0) { /* FIXME: should this be handled as success?! */ return AFC_E_SUCCESS; @@ -178,7 +178,7 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui /* send AFC packet data */ sent = 0; - iphone_connection_send(client->connection, data, offset, &sent); + idevice_connection_send(client->connection, data, offset, &sent); if (sent == 0) { return AFC_E_SUCCESS; } @@ -190,7 +190,7 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui debug_buffer(data + offset, length - offset); sent = 0; - iphone_connection_send(client->connection, data + offset, length - offset, &sent); + idevice_connection_send(client->connection, data + offset, length - offset, &sent); *bytes_sent = sent; return AFC_E_SUCCESS; @@ -203,7 +203,7 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui /* send AFC packet header */ AFCPacket_to_LE(client->afc_packet); sent = 0; - iphone_connection_send(client->connection, (void*)client->afc_packet, sizeof(AFCPacket), &sent); + idevice_connection_send(client->connection, (void*)client->afc_packet, sizeof(AFCPacket), &sent); if (sent == 0) { return AFC_E_SUCCESS; } @@ -213,7 +213,7 @@ static afc_error_t afc_dispatch_packet(afc_client_t client, const char *data, ui debug_info("packet data follows"); debug_buffer(data, length); - iphone_connection_send(client->connection, data, length, &sent); + idevice_connection_send(client->connection, data, length, &sent); *bytes_sent += sent; } return AFC_E_SUCCESS; @@ -241,7 +241,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3 *bytes_recv = 0; /* first, read the AFC header */ - iphone_connection_receive(client->connection, (char*)&header, sizeof(AFCPacket), bytes_recv); + idevice_connection_receive(client->connection, (char*)&header, sizeof(AFCPacket), bytes_recv); AFCPacket_from_LE(&header); if (*bytes_recv == 0) { debug_info("Just didn't get enough."); @@ -295,7 +295,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3 *dump_here = (char*)malloc(entire_len); if (this_len > 0) { - iphone_connection_receive(client->connection, *dump_here, this_len, bytes_recv); + idevice_connection_receive(client->connection, *dump_here, this_len, bytes_recv); if (*bytes_recv <= 0) { free(*dump_here); *dump_here = NULL; @@ -313,7 +313,7 @@ static afc_error_t afc_receive_data(afc_client_t client, char **dump_here, uint3 if (entire_len > this_len) { while (current_count < entire_len) { - iphone_connection_receive(client->connection, (*dump_here)+current_count, entire_len - current_count, bytes_recv); + idevice_connection_receive(client->connection, (*dump_here)+current_count, entire_len - current_count, bytes_recv); if (*bytes_recv <= 0) { debug_info("Error receiving data (recv returned %d)", *bytes_recv); break; @@ -701,7 +701,7 @@ afc_error_t afc_get_file_info(afc_client_t client, const char *path, char ***inf * * @return AFC_E_SUCCESS on success or an AFC_E_* error on failure. */ -iphone_error_t +idevice_error_t afc_file_open(afc_client_t client, const char *filename, afc_file_mode_t file_mode, uint64_t *handle) { @@ -760,7 +760,7 @@ afc_file_open(afc_client_t client, const char *filename, * * @return AFC_E_SUCCESS on success or an AFC_E_* error value on error. */ -iphone_error_t +idevice_error_t afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length, uint32_t *bytes_read) { char *input = NULL; @@ -833,7 +833,7 @@ afc_file_read(afc_client_t client, uint64_t handle, char *data, uint32_t length, * * @return AFC_E_SUCCESS on success, or an AFC_E_* error value on error. */ -iphone_error_t +idevice_error_t afc_file_write(afc_client_t client, uint64_t handle, const char *data, uint32_t length, uint32_t *bytes_written) { char *acknowledgement = NULL; diff --git a/src/afc.h b/src/afc.h index f8a5da3..ad518f6 100644 --- a/src/afc.h +++ b/src/afc.h @@ -26,7 +26,7 @@ #include #include -#include "libiphone/afc.h" +#include "libimobiledevice/afc.h" #define AFC_MAGIC "CFA6LPAA" #define AFC_MAGIC_LEN (8) @@ -58,7 +58,7 @@ typedef struct __AFCToken { } AFCToken; struct afc_client_int { - iphone_connection_t connection; + idevice_connection_t connection; AFCPacket *afc_packet; int file_handle; int lock; diff --git a/src/debug.c b/src/debug.c index b194b0d..a40c249 100644 --- a/src/debug.c +++ b/src/debug.c @@ -28,7 +28,7 @@ #include #include "debug.h" -#include "libiphone/libiphone.h" +#include "libimobiledevice/libimobiledevice.h" int debug_level = 0; @@ -38,7 +38,7 @@ int debug_level = 0; * * @param level Set to 0 for no debugging or 1 for debugging. */ -void iphone_set_debug_level(int level) +void idevice_set_debug_level(int level) { debug_level = level; } diff --git a/src/device_link_service.c b/src/device_link_service.c index 9998fd0..10e9e9c 100644 --- a/src/device_link_service.c +++ b/src/device_link_service.c @@ -78,7 +78,7 @@ static char *device_link_service_get_message(plist_t dl_msg) * DEVICE_LINK_SERVICE_E_INVALID_ARG when one of the parameters is invalid, * or DEVICE_LINK_SERVICE_E_MUX_ERROR when the connection failed. */ -device_link_service_error_t device_link_service_client_new(iphone_device_t device, uint16_t port, device_link_service_client_t *client) +device_link_service_error_t device_link_service_client_new(idevice_t device, uint16_t port, device_link_service_client_t *client) { if (!device || port == 0 || !client || *client) { return DEVICE_LINK_SERVICE_E_INVALID_ARG; diff --git a/src/device_link_service.h b/src/device_link_service.h index 8345d57..4fc9a9f 100644 --- a/src/device_link_service.h +++ b/src/device_link_service.h @@ -41,7 +41,7 @@ typedef struct device_link_service_client_int *device_link_service_client_t; typedef int16_t device_link_service_error_t; -device_link_service_error_t device_link_service_client_new(iphone_device_t device, uint16_t port, device_link_service_client_t *client); +device_link_service_error_t device_link_service_client_new(idevice_t device, uint16_t port, device_link_service_client_t *client); device_link_service_error_t device_link_service_client_free(device_link_service_client_t client); device_link_service_error_t device_link_service_version_exchange(device_link_service_client_t client, uint64_t version_major, uint64_t version_minor); device_link_service_error_t device_link_service_process_message(device_link_service_client_t client, plist_t message); diff --git a/src/file_relay.c b/src/file_relay.c index f0e91f7..dd94e53 100644 --- a/src/file_relay.c +++ b/src/file_relay.c @@ -36,7 +36,7 @@ * FILE_RELAY_E_INVALID_ARG when one of the parameters is invalid, * or FILE_RELAY_E_MUX_ERROR when the connection failed. */ -file_relay_error_t file_relay_client_new(iphone_device_t device, uint16_t port, file_relay_client_t *client) +file_relay_error_t file_relay_client_new(idevice_t device, uint16_t port, file_relay_client_t *client) { if (!device || port == 0 || !client || *client) { return FILE_RELAY_E_INVALID_ARG; @@ -92,7 +92,7 @@ file_relay_error_t file_relay_client_free(file_relay_client_t client) * - tmp * - SystemConfiguration * @param connection The connection that has to be used for receiving the - * data using iphone_connection_receive(). The connection will be closed + * data using idevice_connection_receive(). The connection will be closed * automatically by the device, but use file_relay_client_free() to clean * up properly. * @@ -107,7 +107,7 @@ file_relay_error_t file_relay_client_free(file_relay_client_t client) * sources are invalid, FILE_RELAY_E_STAGING_EMPTY if no data is available * for the given sources, or FILE_RELAY_E_UNKNOWN_ERROR otherwise. */ -file_relay_error_t file_relay_request_sources(file_relay_client_t client, const char **sources, iphone_connection_t *connection) +file_relay_error_t file_relay_request_sources(file_relay_client_t client, const char **sources, idevice_connection_t *connection) { if (!client || !client->parent || !sources || !sources[0]) { return FILE_RELAY_E_INVALID_ARG; diff --git a/src/file_relay.h b/src/file_relay.h index 9b2488c..7a94c89 100644 --- a/src/file_relay.h +++ b/src/file_relay.h @@ -21,7 +21,7 @@ #ifndef FILE_RELAY_H #define FILE_RELAY_H -#include "libiphone/file_relay.h" +#include "libimobiledevice/file_relay.h" #include "property_list_service.h" /* Error Codes */ 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 +#include +#include +#include + +#include +#include +#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; +} + diff --git a/src/idevice.h b/src/idevice.h new file mode 100644 index 0000000..4aab440 --- /dev/null +++ b/src/idevice.h @@ -0,0 +1,54 @@ +/* + * idevice.h + * Device discovery and communication interface -- header file. + * + * Copyright (c) 2008 Zach C. 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 + */ +#ifndef IDEVICE_H +#define IDEVICE_H + +#include +#include + +#include "libimobiledevice/libimobiledevice.h" + +enum connection_type { + CONNECTION_USBMUXD = 1 +}; + +struct ssl_data_int { + gnutls_certificate_credentials_t certificate; + gnutls_session_t session; +}; +typedef struct ssl_data_int *ssl_data_t; + +struct idevice_connection_int { + enum connection_type type; + void *data; + ssl_data_t ssl_data; +}; + +struct idevice_int { + char *uuid; + enum connection_type conn_type; + void *conn_data; +}; + +idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection); +idevice_error_t idevice_connection_disable_ssl(idevice_connection_t connection); + +#endif diff --git a/src/installation_proxy.c b/src/installation_proxy.c index e0bccd3..3a6d22a 100644 --- a/src/installation_proxy.c +++ b/src/installation_proxy.c @@ -92,7 +92,7 @@ static instproxy_error_t instproxy_error(property_list_service_error_t err) * @return INSTPROXY_E_SUCCESS on success, or an INSTPROXY_E_* error value * when an error occured. */ -instproxy_error_t instproxy_client_new(iphone_device_t device, uint16_t port, instproxy_client_t *client) +instproxy_error_t instproxy_client_new(idevice_t device, uint16_t port, instproxy_client_t *client) { /* makes sure thread environment is available */ if (!g_thread_supported()) diff --git a/src/installation_proxy.h b/src/installation_proxy.h index 0204533..78128b2 100644 --- a/src/installation_proxy.h +++ b/src/installation_proxy.h @@ -23,7 +23,7 @@ #include -#include "libiphone/installation_proxy.h" +#include "libimobiledevice/installation_proxy.h" #include "property_list_service.h" struct instproxy_client_int { diff --git a/src/iphone.c b/src/iphone.c deleted file mode 100644 index b471e35..0000000 --- a/src/iphone.c +++ /dev/null @@ -1,618 +0,0 @@ -/* - * iphone.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 -#include -#include -#include - -#include -#include -#include "iphone.h" -#include "debug.h" - -static iphone_event_cb_t event_cb = NULL; - -static void usbmux_event_cb(const usbmuxd_event_t *event, void *user_data) -{ - iphone_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 IPHONE_E_SUCCESS on success or an error value when an error occured. - */ -iphone_error_t iphone_event_subscribe(iphone_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 IPHONE_E_UNKNOWN_ERROR; - } - return IPHONE_E_SUCCESS; -} - -/** - * Release the event callback function that has been registered with - * iphone_event_subscribe(). - * - * @return IPHONE_E_SUCCESS on success or an error value when an error occured. - */ -iphone_error_t iphone_event_unsubscribe() -{ - event_cb = NULL; - int res = usbmuxd_unsubscribe(); - if (res != 0) { - debug_info("Error %d when unsubscribing usbmux event callback!", res); - return IPHONE_E_UNKNOWN_ERROR; - } - return IPHONE_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 IPHONE_E_SUCCESS on success or an error value when an error occured. - */ -iphone_error_t iphone_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 IPHONE_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 IPHONE_E_SUCCESS; -} - -/** - * Free a list of device uuids. - * - * @param devices List of uuids to free. - * - * @return Always returnes IPHONE_E_SUCCESS. - */ -iphone_error_t iphone_device_list_free(char **devices) -{ - if (devices) { - int i = 0; - while (devices[i++]) { - free(devices[i]); - } - free(devices); - } - return IPHONE_E_SUCCESS; -} - -/** - * Creates an iphone_device_t structure for the device specified by uuid, - * if the device is available. - * - * @note The resulting iphone_device_t structure has to be freed with - * iphone_device_free() if it is no longer used. - * - * @param device Upon calling this function, a pointer to a location of type - * iphone_device_t. On successful return, this location will be populated. - * @param uuid The UUID to match. - * - * @return IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_device_new(iphone_device_t * device, const char *uuid) -{ - usbmuxd_device_info_t muxdev; - int res = usbmuxd_get_device_by_uuid(uuid, &muxdev); - if (res > 0) { - iphone_device_t phone = (iphone_device_t) malloc(sizeof(struct iphone_device_int)); - phone->uuid = strdup(muxdev.uuid); - phone->conn_type = CONNECTION_USBMUXD; - phone->conn_data = (void*)muxdev.handle; - *device = phone; - return IPHONE_E_SUCCESS; - } - /* other connection types could follow here */ - - return IPHONE_E_NO_DEVICE; -} - -/** Cleans up an iPhone structure, then frees the structure itself. - * This is a library-level function; deals directly with the iPhone to tear - * down relations, but otherwise is mostly internal. - * - * @param device A pointer to an iPhone structure. - */ -iphone_error_t iphone_device_free(iphone_device_t device) -{ - if (!device) - return IPHONE_E_INVALID_ARG; - iphone_error_t ret = IPHONE_E_UNKNOWN_ERROR; - - ret = IPHONE_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 iphone_connection_t that will be filled - * with the necessary data of the connection. - * - * @return IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_device_connect(iphone_device_t device, uint16_t port, iphone_connection_t *connection) -{ - if (!device) { - return IPHONE_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 IPHONE_E_UNKNOWN_ERROR; - } - iphone_connection_t new_connection = (iphone_connection_t)malloc(sizeof(struct iphone_connection_int)); - new_connection->type = CONNECTION_USBMUXD; - new_connection->data = (void*)sfd; - new_connection->ssl_data = NULL; - *connection = new_connection; - return IPHONE_E_SUCCESS; - } else { - debug_info("Unknown connection type %d", device->conn_type); - } - - return IPHONE_E_UNKNOWN_ERROR; -} - -/** - * Disconnect from the device and clean up the connection structure. - * - * @param connection The connection to close. - * - * @return IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_device_disconnect(iphone_connection_t connection) -{ - if (!connection) { - return IPHONE_E_INVALID_ARG; - } - /* shut down ssl if enabled */ - if (connection->ssl_data) { - iphone_connection_disable_ssl(connection); - } - iphone_error_t result = IPHONE_E_UNKNOWN_ERROR; - if (connection->type == CONNECTION_USBMUXD) { - usbmuxd_disconnect((int)(connection->data)); - result = IPHONE_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 iphone_error_t internal_connection_send(iphone_connection_t connection, const char *data, uint32_t len, uint32_t *sent_bytes) -{ - if (!connection || !data) { - return IPHONE_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 IPHONE_E_UNKNOWN_ERROR; - } - return IPHONE_E_SUCCESS; - } else { - debug_info("Unknown connection type %d", connection->type); - } - return IPHONE_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 IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_connection_send(iphone_connection_t connection, const char *data, uint32_t len, uint32_t *sent_bytes) -{ - if (!connection || !data || (connection->ssl_data && !connection->ssl_data->session)) { - return IPHONE_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 IPHONE_E_SUCCESS; - } - *sent_bytes = 0; - return IPHONE_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 iphone_error_t internal_connection_receive_timeout(iphone_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes, unsigned int timeout) -{ - if (!connection) { - return IPHONE_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 IPHONE_E_UNKNOWN_ERROR; - } - return IPHONE_E_SUCCESS; - } else { - debug_info("Unknown connection type %d", connection->type); - } - return IPHONE_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 IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_connection_receive_timeout(iphone_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 IPHONE_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 IPHONE_E_SUCCESS; - } - *recv_bytes = 0; - return IPHONE_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 iphone_error_t internal_connection_receive(iphone_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes) -{ - if (!connection) { - return IPHONE_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 IPHONE_E_UNKNOWN_ERROR; - } - - return IPHONE_E_SUCCESS; - } else { - debug_info("Unknown connection type %d", connection->type); - } - return IPHONE_E_UNKNOWN_ERROR; -} - -/** - * Receive data from a device via the given connection. - * This function is like iphone_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 IPHONE_E_SUCCESS if ok, otherwise an error code. - */ -iphone_error_t iphone_connection_receive(iphone_connection_t connection, char *data, uint32_t len, uint32_t *recv_bytes) -{ - if (!connection || (connection->ssl_data && !connection->ssl_data->session)) { - return IPHONE_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 IPHONE_E_SUCCESS; - } - *recv_bytes = 0; - return IPHONE_E_SSL_ERROR; - } - return internal_connection_receive(connection, data, len, recv_bytes); -} - -iphone_error_t iphone_device_get_handle(iphone_device_t device, uint32_t *handle) -{ - if (!device) - return IPHONE_E_INVALID_ARG; - - if (device->conn_type == CONNECTION_USBMUXD) { - *handle = (uint32_t)device->conn_data; - return IPHONE_E_SUCCESS; - } else { - debug_info("Unknown connection type %d", device->conn_type); - } - return IPHONE_E_UNKNOWN_ERROR; -} - -iphone_error_t iphone_device_get_uuid(iphone_device_t device, char **uuid) -{ - if (!device) - return IPHONE_E_INVALID_ARG; - - *uuid = strdup(device->uuid); - return IPHONE_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; - iphone_error_t res; - iphone_connection_t connection = (iphone_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)) != IPHONE_E_SUCCESS) { - debug_info("ERROR: iphone_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; - iphone_connection_t connection = (iphone_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 IPHONE_E_SUCCESS on success, IPHONE_E_INVALID_ARG when connection - * is NULL or connection->ssl_data is non-NULL, or IPHONE_E_SSL_ERROR when - * SSL initialization, setup, or handshake fails. - */ -iphone_error_t iphone_connection_enable_ssl(iphone_connection_t connection) -{ - if (!connection || connection->ssl_data) - return IPHONE_E_INVALID_ARG; - - iphone_error_t ret = IPHONE_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 = IPHONE_E_SUCCESS; - debug_info("SSL mode enabled"); - } - return ret; -} - -/** - * Disable SSL for the given connection. - * - * @param connection The connection to disable SSL for. - * - * @return IPHONE_E_SUCCESS on success, IPHONE_E_INVALID_ARG when connection - * is NULL. This function also returns IPHONE_E_SUCCESS when SSL is not - * enabled and does no further error checking on cleanup. - */ -iphone_error_t iphone_connection_disable_ssl(iphone_connection_t connection) -{ - if (!connection) - return IPHONE_E_INVALID_ARG; - if (!connection->ssl_data) { - /* ignore if ssl is not enabled */ - return IPHONE_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 IPHONE_E_SUCCESS; -} - diff --git a/src/iphone.h b/src/iphone.h deleted file mode 100644 index 2755349..0000000 --- a/src/iphone.h +++ /dev/null @@ -1,54 +0,0 @@ -/* - * iphone.h - * Device discovery and communication interface -- header file. - * - * Copyright (c) 2008 Zach C. 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 - */ -#ifndef IPHONE_H -#define IPHONE_H - -#include -#include - -#include "libiphone/libiphone.h" - -enum connection_type { - CONNECTION_USBMUXD = 1 -}; - -struct ssl_data_int { - gnutls_certificate_credentials_t certificate; - gnutls_session_t session; -}; -typedef struct ssl_data_int *ssl_data_t; - -struct iphone_connection_int { - enum connection_type type; - void *data; - ssl_data_t ssl_data; -}; - -struct iphone_device_int { - char *uuid; - enum connection_type conn_type; - void *conn_data; -}; - -iphone_error_t iphone_connection_enable_ssl(iphone_connection_t connection); -iphone_error_t iphone_connection_disable_ssl(iphone_connection_t connection); - -#endif diff --git a/src/lockdown.c b/src/lockdown.c index 108b558..13f3d48 100644 --- a/src/lockdown.c +++ b/src/lockdown.c @@ -1,6 +1,6 @@ /* * lockdown.c - * libiphone built-in lockdownd client + * libimobiledevice built-in lockdownd client * * Copyright (c) 2008 Zach C. All Rights Reserved. * @@ -30,7 +30,7 @@ #include "property_list_service.h" #include "lockdown.h" -#include "iphone.h" +#include "idevice.h" #include "debug.h" #include "userpref.h" @@ -229,7 +229,7 @@ void lockdownd_client_set_label(lockdownd_client_t client, const char *label) } } -/** Polls the iPhone for lockdownd data. +/** Polls the device for lockdownd data. * * @param control The lockdownd client * @param plist The plist to store the received data @@ -254,7 +254,7 @@ lockdownd_error_t lockdownd_receive(lockdownd_client_t client, plist_t *plist) return ret; } -/** Sends lockdownd data to the iPhone +/** Sends lockdownd data to the device * * @note This function is low-level and should only be used if you need to send * a new type of message. @@ -270,7 +270,7 @@ lockdownd_error_t lockdownd_send(lockdownd_client_t client, plist_t plist) return LOCKDOWN_E_INVALID_ARG; lockdownd_error_t ret = LOCKDOWN_E_SUCCESS; - iphone_error_t err; + idevice_error_t err; err = property_list_service_send_xml_plist(client->parent, plist); if (err != PROPERTY_LIST_SERVICE_E_SUCCESS) { @@ -578,7 +578,7 @@ lockdownd_error_t lockdownd_get_device_name(lockdownd_client_t client, char **de * * @return an error code (LOCKDOWN_E_SUCCESS on success) */ -lockdownd_error_t lockdownd_client_new(iphone_device_t device, lockdownd_client_t *client, const char *label) +lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *client, const char *label) { if (!client) return LOCKDOWN_E_INVALID_ARG; @@ -619,7 +619,7 @@ lockdownd_error_t lockdownd_client_new(iphone_device_t device, lockdownd_client_ * * @return an error code (LOCKDOWN_E_SUCCESS on success) */ -lockdownd_error_t lockdownd_client_new_with_handshake(iphone_device_t device, lockdownd_client_t *client, const char *label) +lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdownd_client_t *client, const char *label) { if (!client) return LOCKDOWN_E_INVALID_ARG; @@ -644,7 +644,7 @@ lockdownd_error_t lockdownd_client_new_with_handshake(iphone_device_t device, lo free(type); } - ret = iphone_device_get_uuid(device, &client_loc->uuid); + ret = idevice_get_uuid(device, &client_loc->uuid); if (LOCKDOWN_E_SUCCESS != ret) { debug_info("failed to get device uuid."); } @@ -759,7 +759,7 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_ plist_t dict = NULL; plist_t dict_record = NULL; gnutls_datum_t public_key = { NULL, 0 }; - int pairing_mode = 0; /* 0 = libiphone, 1 = external */ + int pairing_mode = 0; /* 0 = libimobiledevice, 1 = external */ if (pair_record && pair_record->host_id) { /* valid pair_record passed? */ @@ -780,7 +780,7 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_ return ret; } debug_info("device public key follows:\n%s", public_key.data); - /* get libiphone pair_record */ + /* get libimobiledevice pair_record */ ret = generate_pair_record_plist(public_key, NULL, &dict_record); if (ret != LOCKDOWN_E_SUCCESS) { if (dict_record) @@ -795,7 +795,7 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_ plist_dict_insert_item(dict,"PairRecord", dict_record); plist_dict_insert_item(dict, "Request", plist_new_string(verb)); - /* send to iPhone */ + /* send to device */ ret = lockdownd_send(client, dict); plist_free(dict); dict = NULL; @@ -803,7 +803,7 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_ if (ret != LOCKDOWN_E_SUCCESS) return ret; - /* Now get iPhone's answer */ + /* Now get device's answer */ ret = lockdownd_receive(client, &dict); if (ret != LOCKDOWN_E_SUCCESS) @@ -1116,7 +1116,7 @@ lockdownd_error_t lockdownd_gen_pair_cert(gnutls_datum_t public_key, gnutls_datu return ret; } -/** Starts communication with lockdownd after the iPhone has been paired, +/** Starts communication with lockdownd after the device has been paired, * and if the device requires it, switches to SSL mode. * * @param client The lockdownd client @@ -1244,7 +1244,7 @@ lockdownd_error_t lockdownd_start_service(lockdownd_client_t client, const char plist_dict_insert_item(dict,"Request", plist_new_string("StartService")); plist_dict_insert_item(dict,"Service", plist_new_string(service)); - /* send to iPhone */ + /* send to device */ ret = lockdownd_send(client, dict); plist_free(dict); dict = NULL; diff --git a/src/lockdown.h b/src/lockdown.h index 82ea01f..f515f7f 100644 --- a/src/lockdown.h +++ b/src/lockdown.h @@ -25,7 +25,7 @@ #include #include -#include "libiphone/lockdown.h" +#include "libimobiledevice/lockdown.h" #include "property_list_service.h" struct lockdownd_client_int { diff --git a/src/mobilebackup.c b/src/mobilebackup.c index 5b81c7f..91b9e73 100644 --- a/src/mobilebackup.c +++ b/src/mobilebackup.c @@ -59,7 +59,7 @@ static mobilebackup_error_t mobilebackup_error(device_link_service_error_t err) return MOBILEBACKUP_E_UNKNOWN_ERROR; } -mobilebackup_error_t mobilebackup_client_new(iphone_device_t device, uint16_t port, +mobilebackup_error_t mobilebackup_client_new(idevice_t device, uint16_t port, mobilebackup_client_t * client) { if (!device || port == 0 || !client || *client) @@ -97,7 +97,7 @@ mobilebackup_error_t mobilebackup_client_free(mobilebackup_client_t client) return err; } -/** Polls the iPhone for MobileBackup data. +/** Polls the device for MobileBackup data. * * @param client The MobileBackup client * @param plist A pointer to the location where the plist should be stored @@ -112,7 +112,7 @@ mobilebackup_error_t mobilebackup_receive(mobilebackup_client_t client, plist_t return ret; } -/** Sends MobileBackup data to the iPhone +/** Sends MobileBackup data to the device * * @note This function is low-level and should only be used if you need to send * a new type of message. diff --git a/src/mobilebackup.h b/src/mobilebackup.h index 04ebc45..8f58236 100644 --- a/src/mobilebackup.h +++ b/src/mobilebackup.h @@ -21,7 +21,7 @@ #ifndef MOBILEBACKUP_H #define MOBILEBACKUP_H -#include "libiphone/mobilebackup.h" +#include "libimobiledevice/mobilebackup.h" #include "device_link_service.h" struct mobilebackup_client_int { diff --git a/src/mobilesync.c b/src/mobilesync.c index 15614b5..fec97bc 100644 --- a/src/mobilesync.c +++ b/src/mobilesync.c @@ -59,7 +59,7 @@ static mobilesync_error_t mobilesync_error(device_link_service_error_t err) return MOBILESYNC_E_UNKNOWN_ERROR; } -mobilesync_error_t mobilesync_client_new(iphone_device_t device, uint16_t port, +mobilesync_error_t mobilesync_client_new(idevice_t device, uint16_t port, mobilesync_client_t * client) { if (!device || port == 0 || !client || *client) @@ -97,7 +97,7 @@ mobilesync_error_t mobilesync_client_free(mobilesync_client_t client) return err; } -/** Polls the iPhone for MobileSync data. +/** Polls the device for MobileSync data. * * @param client The MobileSync client * @param plist A pointer to the location where the plist should be stored @@ -112,7 +112,7 @@ mobilesync_error_t mobilesync_receive(mobilesync_client_t client, plist_t * plis return ret; } -/** Sends MobileSync data to the iPhone +/** Sends MobileSync data to the device * * @note This function is low-level and should only be used if you need to send * a new type of message. diff --git a/src/mobilesync.h b/src/mobilesync.h index e69cb25..defb3f4 100644 --- a/src/mobilesync.h +++ b/src/mobilesync.h @@ -21,7 +21,7 @@ #ifndef MOBILESYNC_H #define MOBILESYNC_H -#include "libiphone/mobilesync.h" +#include "libimobiledevice/mobilesync.h" #include "device_link_service.h" struct mobilesync_client_int { diff --git a/src/notification_proxy.c b/src/notification_proxy.c index 0969985..eb5e6b2 100644 --- a/src/notification_proxy.c +++ b/src/notification_proxy.c @@ -92,7 +92,7 @@ static np_error_t np_error(property_list_service_error_t err) * or NP_E_CONN_FAILED when the connection to the device could not be * established. */ -np_error_t np_client_new(iphone_device_t device, uint16_t port, np_client_t *client) +np_error_t np_client_new(idevice_t device, uint16_t port, np_client_t *client) { /* makes sure thread environment is available */ if (!g_thread_supported()) @@ -177,7 +177,7 @@ np_error_t np_post_notification(np_client_t client, const char *notification) return res; } -/** Notifies the iphone to send a notification on the specified event. +/** Notifies the device to send a notification on the specified event. * * @param client The client to send to * @param notification The notifications that should be observed. @@ -206,7 +206,7 @@ np_error_t np_observe_notification( np_client_t client, const char *notification return res; } -/** Notifies the iphone to send a notification on specified events. +/** Notifies the device to send a notification on specified events. * * @param client The client to send to * @param notification_spec Specification of the notifications that should be diff --git a/src/notification_proxy.h b/src/notification_proxy.h index 6ff2cde..6f2dc99 100644 --- a/src/notification_proxy.h +++ b/src/notification_proxy.h @@ -23,7 +23,7 @@ #include -#include "libiphone/notification_proxy.h" +#include "libimobiledevice/notification_proxy.h" #include "property_list_service.h" struct np_client_int { diff --git a/src/property_list_service.c b/src/property_list_service.c index dbf02d6..68aa455 100644 --- a/src/property_list_service.c +++ b/src/property_list_service.c @@ -24,26 +24,26 @@ #include #include "property_list_service.h" -#include "iphone.h" +#include "idevice.h" #include "debug.h" /** - * Convert an iphone_error_t value to an property_list_service_error_t value. + * Convert an idevice_error_t value to an property_list_service_error_t value. * Used internally to get correct error codes. * - * @param err An iphone_error_t error code + * @param err An idevice_error_t error code * * @return A matching property_list_service_error_t error code, * PROPERTY_LIST_SERVICE_E_UNKNOWN_ERROR otherwise. */ -static property_list_service_error_t iphone_to_property_list_service_error(iphone_error_t err) +static property_list_service_error_t idevice_to_property_list_service_error(idevice_error_t err) { switch (err) { - case IPHONE_E_SUCCESS: + case IDEVICE_E_SUCCESS: return PROPERTY_LIST_SERVICE_E_SUCCESS; - case IPHONE_E_INVALID_ARG: + case IDEVICE_E_INVALID_ARG: return PROPERTY_LIST_SERVICE_E_INVALID_ARG; - case IPHONE_E_SSL_ERROR: + case IDEVICE_E_SSL_ERROR: return PROPERTY_LIST_SERVICE_E_SSL_ERROR; default: break; @@ -64,14 +64,14 @@ static property_list_service_error_t iphone_to_property_list_service_error(iphon * PROPERTY_LIST_SERVICE_E_INVALID_ARG when one of the arguments is invalid, * or PROPERTY_LIST_SERVICE_E_MUX_ERROR when connecting to the device failed. */ -property_list_service_error_t property_list_service_client_new(iphone_device_t device, uint16_t port, property_list_service_client_t *client) +property_list_service_error_t property_list_service_client_new(idevice_t device, uint16_t port, property_list_service_client_t *client) { if (!device || port == 0 || !client || *client) return PROPERTY_LIST_SERVICE_E_INVALID_ARG; /* Attempt connection */ - iphone_connection_t connection = NULL; - if (iphone_device_connect(device, port, &connection) != IPHONE_E_SUCCESS) { + idevice_connection_t connection = NULL; + if (idevice_connect(device, port, &connection) != IDEVICE_E_SUCCESS) { return PROPERTY_LIST_SERVICE_E_MUX_ERROR; } @@ -98,7 +98,7 @@ property_list_service_error_t property_list_service_client_free(property_list_se if (!client) return PROPERTY_LIST_SERVICE_E_INVALID_ARG; - property_list_service_error_t err = iphone_to_property_list_service_error(iphone_device_disconnect(client->connection)); + property_list_service_error_t err = idevice_to_property_list_service_error(idevice_disconnect(client->connection)); free(client); return err; } @@ -141,9 +141,9 @@ static property_list_service_error_t internal_plist_send(property_list_service_c nlen = htonl(length); debug_info("sending %d bytes", length); - iphone_connection_send(client->connection, (const char*)&nlen, sizeof(nlen), (uint32_t*)&bytes); + idevice_connection_send(client->connection, (const char*)&nlen, sizeof(nlen), (uint32_t*)&bytes); if (bytes == sizeof(nlen)) { - iphone_connection_send(client->connection, content, length, (uint32_t*)&bytes); + idevice_connection_send(client->connection, content, length, (uint32_t*)&bytes); if (bytes > 0) { debug_info("sent %d bytes", bytes); debug_plist(plist); @@ -221,7 +221,7 @@ static property_list_service_error_t internal_plist_receive_timeout(property_lis return PROPERTY_LIST_SERVICE_E_INVALID_ARG; } - iphone_connection_receive_timeout(client->connection, (char*)&pktlen, sizeof(pktlen), &bytes, timeout); + idevice_connection_receive_timeout(client->connection, (char*)&pktlen, sizeof(pktlen), &bytes, timeout); debug_info("initial read=%i", bytes); if (bytes < 4) { debug_info("initial read failed!"); @@ -235,7 +235,7 @@ static property_list_service_error_t internal_plist_receive_timeout(property_lis content = (char*)malloc(pktlen); while (curlen < pktlen) { - iphone_connection_receive(client->connection, content+curlen, pktlen-curlen, &bytes); + idevice_connection_receive(client->connection, content+curlen, pktlen-curlen, &bytes); if (bytes <= 0) { res = PROPERTY_LIST_SERVICE_E_MUX_ERROR; break; @@ -324,7 +324,7 @@ property_list_service_error_t property_list_service_enable_ssl(property_list_ser { if (!client || !client->connection) return PROPERTY_LIST_SERVICE_E_INVALID_ARG; - return iphone_to_property_list_service_error(iphone_connection_enable_ssl(client->connection)); + return idevice_to_property_list_service_error(idevice_connection_enable_ssl(client->connection)); } /** @@ -341,6 +341,6 @@ property_list_service_error_t property_list_service_disable_ssl(property_list_se { if (!client || !client->connection) return PROPERTY_LIST_SERVICE_E_INVALID_ARG; - return iphone_to_property_list_service_error(iphone_connection_disable_ssl(client->connection)); + return idevice_to_property_list_service_error(idevice_connection_disable_ssl(client->connection)); } diff --git a/src/property_list_service.h b/src/property_list_service.h index bc3122b..70d8793 100644 --- a/src/property_list_service.h +++ b/src/property_list_service.h @@ -21,7 +21,7 @@ #ifndef PROPERTY_LIST_SERVICE_H #define PROPERTY_LIST_SERVICE_H -#include "iphone.h" +#include "idevice.h" /* Error Codes */ #define PROPERTY_LIST_SERVICE_E_SUCCESS 0 @@ -33,7 +33,7 @@ #define PROPERTY_LIST_SERVICE_E_UNKNOWN_ERROR -256 struct property_list_service_client_int { - iphone_connection_t connection; + idevice_connection_t connection; }; typedef struct property_list_service_client_int *property_list_service_client_t; @@ -41,7 +41,7 @@ typedef struct property_list_service_client_int *property_list_service_client_t; typedef int16_t property_list_service_error_t; /* creation and destruction */ -property_list_service_error_t property_list_service_client_new(iphone_device_t device, uint16_t port, property_list_service_client_t *client); +property_list_service_error_t property_list_service_client_new(idevice_t device, uint16_t port, property_list_service_client_t *client); property_list_service_error_t property_list_service_client_free(property_list_service_client_t client); /* sending */ diff --git a/src/sbservices.c b/src/sbservices.c index 2254c64..8cf8b26 100644 --- a/src/sbservices.c +++ b/src/sbservices.c @@ -86,7 +86,7 @@ static sbservices_error_t sbservices_error(property_list_service_error_t err) * @return SBSERVICES_E_SUCCESS on success, SBSERVICES_E_INVALID_ARG when * client is NULL, or an SBSERVICES_E_* error code otherwise. */ -sbservices_error_t sbservices_client_new(iphone_device_t device, uint16_t port, sbservices_client_t *client) +sbservices_error_t sbservices_client_new(idevice_t device, uint16_t port, sbservices_client_t *client) { /* makes sure thread environment is available */ if (!g_thread_supported()) diff --git a/src/sbservices.h b/src/sbservices.h index 5c95eaf..4ade579 100644 --- a/src/sbservices.h +++ b/src/sbservices.h @@ -23,7 +23,7 @@ #include -#include "libiphone/sbservices.h" +#include "libimobiledevice/sbservices.h" #include "property_list_service.h" struct sbservices_client_int { diff --git a/src/userpref.c b/src/userpref.c index 6eff534..3a8a9d6 100644 --- a/src/userpref.c +++ b/src/userpref.c @@ -33,20 +33,20 @@ #include "userpref.h" #include "debug.h" -#define LIBIPHONE_CONF_DIR "libiphone" -#define LIBIPHONE_CONF_FILE "libiphonerc" +#define LIBIMOBILEDEVICE_CONF_DIR "libimobiledevice" +#define LIBIMOBILEDEVICE_CONF_FILE "libimobiledevicerc" -#define LIBIPHONE_ROOT_PRIVKEY "RootPrivateKey.pem" -#define LIBIPHONE_HOST_PRIVKEY "HostPrivateKey.pem" -#define LIBIPHONE_ROOT_CERTIF "RootCertificate.pem" -#define LIBIPHONE_HOST_CERTIF "HostCertificate.pem" +#define LIBIMOBILEDEVICE_ROOT_PRIVKEY "RootPrivateKey.pem" +#define LIBIMOBILEDEVICE_HOST_PRIVKEY "HostPrivateKey.pem" +#define LIBIMOBILEDEVICE_ROOT_CERTIF "RootCertificate.pem" +#define LIBIMOBILEDEVICE_HOST_CERTIF "HostCertificate.pem" -/** Creates a freedesktop compatible configuration directory for libiphone. +/** Creates a freedesktop compatible configuration directory. */ static void userpref_create_config_dir(void) { - gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, NULL); + gchar *config_dir = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, NULL); if (!g_file_test(config_dir, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) g_mkdir_with_parents(config_dir, 0755); @@ -112,7 +112,7 @@ static int userpref_set_host_id(const char *host_id) /* Write config file on disk */ buf = g_key_file_to_data(key_file, &length, NULL); config_file = - g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL); + g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_CONF_FILE, NULL); file = g_io_channel_new_file(config_file, "w", NULL); g_free(config_file); g_io_channel_write_chars(file, buf, length, NULL, NULL); @@ -136,7 +136,7 @@ void userpref_get_host_id(char **host_id) gchar *loc_host_id; config_file = - g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_CONF_FILE, NULL); + g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_CONF_FILE, NULL); /* now parse file to get the HostID */ key_file = g_key_file_new(); @@ -158,11 +158,11 @@ void userpref_get_host_id(char **host_id) debug_info("Using %s as HostID", *host_id); } -/** Determines whether this iPhone has been connected to this system before. +/** Determines whether this device has been connected to this system before. * - * @param uid The device uid as given by the iPhone. + * @param uid The device uid as given by the device. * - * @return 1 if the iPhone has been connected previously to this configuration + * @return 1 if the device has been connected previously to this configuration * or 0 otherwise. */ int userpref_has_device_public_key(const char *uuid) @@ -172,7 +172,7 @@ int userpref_has_device_public_key(const char *uuid) /* first get config file */ gchar *device_file = g_strconcat(uuid, ".pem", NULL); - config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL); + config_file = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL); if (g_file_test(config_file, (G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))) ret = 1; g_free(config_file); @@ -180,10 +180,10 @@ int userpref_has_device_public_key(const char *uuid) return ret; } -/** Mark the iPhone (as represented by the key) as having connected to this +/** Mark the device (as represented by the key) as having connected to this * configuration. * - * @param public_key The public key given by the iPhone + * @param public_key The public key given by the device * * @return 1 on success and 0 if no public key is given or if it has already * been marked as connected previously. @@ -201,7 +201,7 @@ userpref_error_t userpref_set_device_public_key(const char *uuid, gnutls_datum_t /* build file path */ gchar *device_file = g_strconcat(uuid, ".pem", NULL); - gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL); + gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL); /* store file */ FILE *pFile = fopen(pem, "wb"); @@ -226,7 +226,7 @@ userpref_error_t userpref_remove_device_public_key(const char *uuid) /* build file path */ gchar *device_file = g_strconcat(uuid, ".pem", NULL); - gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, device_file, NULL); + gchar *pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, device_file, NULL); /* remove file */ g_remove(pem); @@ -255,7 +255,7 @@ static int userpref_get_file_contents(const char *file, gnutls_datum_t * data) return 0; /* Read file */ - filepath = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, file, NULL); + filepath = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, file, NULL); success = g_file_get_contents(filepath, &content, &size, NULL); g_free(filepath); @@ -392,7 +392,7 @@ static userpref_error_t userpref_import_key(const char* key_name, gnutls_x509_pr * @param crt_name The filename of the certificate to import. * @param cert the gnutls certificate structure. * - * @return IPHONE_E_SUCCESS if the certificate was successfully imported. + * @return IDEVICE_E_SUCCESS if the certificate was successfully imported. */ static userpref_error_t userpref_import_crt(const char* crt_name, gnutls_x509_crt_t cert) { @@ -426,16 +426,16 @@ userpref_error_t userpref_get_keys_and_certs(gnutls_x509_privkey_t root_privkey, userpref_error_t ret = USERPREF_E_SUCCESS; if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_key(LIBIPHONE_ROOT_PRIVKEY, root_privkey); + ret = userpref_import_key(LIBIMOBILEDEVICE_ROOT_PRIVKEY, root_privkey); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_key(LIBIPHONE_HOST_PRIVKEY, host_privkey); + ret = userpref_import_key(LIBIMOBILEDEVICE_HOST_PRIVKEY, host_privkey); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_crt(LIBIPHONE_ROOT_CERTIF, root_crt); + ret = userpref_import_crt(LIBIMOBILEDEVICE_ROOT_CERTIF, root_crt); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_crt(LIBIPHONE_HOST_CERTIF, host_crt); + ret = userpref_import_crt(LIBIMOBILEDEVICE_HOST_CERTIF, host_crt); if (USERPREF_E_SUCCESS != ret) { @@ -444,16 +444,16 @@ userpref_error_t userpref_get_keys_and_certs(gnutls_x509_privkey_t root_privkey, ret = userpref_gen_keys_and_cert(); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_key(LIBIPHONE_ROOT_PRIVKEY, root_privkey); + ret = userpref_import_key(LIBIMOBILEDEVICE_ROOT_PRIVKEY, root_privkey); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_key(LIBIPHONE_HOST_PRIVKEY, host_privkey); + ret = userpref_import_key(LIBIMOBILEDEVICE_HOST_PRIVKEY, host_privkey); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_crt(LIBIPHONE_ROOT_CERTIF, root_crt); + ret = userpref_import_crt(LIBIMOBILEDEVICE_ROOT_CERTIF, root_crt); if (ret == USERPREF_E_SUCCESS) - ret = userpref_import_crt(LIBIPHONE_HOST_CERTIF, host_crt); + ret = userpref_import_crt(LIBIMOBILEDEVICE_HOST_CERTIF, host_crt); } return ret; @@ -471,7 +471,7 @@ userpref_error_t userpref_get_certs_as_pem(gnutls_datum_t *pem_root_cert, gnutls if (!pem_root_cert || !pem_host_cert) return USERPREF_E_INVALID_ARG; - if (userpref_get_file_contents(LIBIPHONE_ROOT_CERTIF, pem_root_cert) && userpref_get_file_contents(LIBIPHONE_HOST_CERTIF, pem_host_cert)) + if (userpref_get_file_contents(LIBIMOBILEDEVICE_ROOT_CERTIF, pem_root_cert) && userpref_get_file_contents(LIBIMOBILEDEVICE_HOST_CERTIF, pem_host_cert)) return USERPREF_E_SUCCESS; else { g_free(pem_root_cert->data); @@ -503,25 +503,25 @@ userpref_error_t userpref_set_keys_and_certs(gnutls_datum_t * root_key, gnutls_d userpref_create_config_dir(); /* Now write keys and certificates to disk */ - pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_ROOT_PRIVKEY, NULL); + pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_ROOT_PRIVKEY, NULL); pFile = fopen(pem, "wb"); fwrite(root_key->data, 1, root_key->size, pFile); fclose(pFile); g_free(pem); - pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_HOST_PRIVKEY, NULL); + pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_HOST_PRIVKEY, NULL); pFile = fopen(pem, "wb"); fwrite(host_key->data, 1, host_key->size, pFile); fclose(pFile); g_free(pem); - pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_ROOT_CERTIF, NULL); + pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_ROOT_CERTIF, NULL); pFile = fopen(pem, "wb"); fwrite(root_cert->data, 1, root_cert->size, pFile); fclose(pFile); g_free(pem); - pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIPHONE_CONF_DIR, LIBIPHONE_HOST_CERTIF, NULL); + pem = g_build_path(G_DIR_SEPARATOR_S, g_get_user_config_dir(), LIBIMOBILEDEVICE_CONF_DIR, LIBIMOBILEDEVICE_HOST_CERTIF, NULL); pFile = fopen(pem, "wb"); fwrite(host_cert->data, 1, host_cert->size, pFile); fclose(pFile); -- cgit v1.1-32-gdbae