From 442363a01ef44e84eda3e22c71dd2de424f5121e Mon Sep 17 00:00:00 2001 From: Joshua Hill Date: Fri, 21 May 2010 04:05:32 -0400 Subject: Changed the API a bit to closer match libimobiledevice and added function to get ECID --- src/libirecovery.c | 354 +++++++++++++++++++++++++---------------------------- 1 file changed, 169 insertions(+), 185 deletions(-) (limited to 'src/libirecovery.c') diff --git a/src/libirecovery.c b/src/libirecovery.c index 0be16c6..a2ec9c9 100644 --- a/src/libirecovery.c +++ b/src/libirecovery.c @@ -25,7 +25,7 @@ #include "libirecovery.h" #define BUFFER_SIZE 0x1000 -#define debug(...) if(device->debug) fprintf(stderr, __VA_ARGS__) +#define debug(...) if(client->debug) fprintf(stderr, __VA_ARGS__) const char* irecv_error_invalid_input = "Invalid input"; const char* irecv_error_unknown = "Unknown error"; @@ -39,40 +39,22 @@ const char* irecv_error_success = "Command completed successfully"; const char* irecv_error_usb_upload = "Unable to upload data to device"; const char* irecv_error_usb_configuration = "Unable to set device configuration"; -int irecv_default_sender(irecv_device_t* device, unsigned char* data, int size); -int irecv_default_receiver(irecv_device_t* device, unsigned char* data, int size); +int irecv_default_sender(irecv_client_t client, unsigned char* data, int size); +int irecv_default_receiver(irecv_client_t client, unsigned char* data, int size); -irecv_device_t* irecv_init() { - struct libusb_context* usb_context = NULL; - - libusb_init(&usb_context); - irecv_device_t* device = (irecv_device_t*) malloc(sizeof(irecv_device_t)); - if (device == NULL) { - return NULL; - } - memset(device, '\0', sizeof(irecv_device_t)); - - //irecv_set_receiver(device, &irecv_default_receiver); - //irecv_set_sender(device, &irecv_default_sender); - device->context = usb_context; - return device; -} - -irecv_error_t irecv_open(irecv_device_t* device, const char *uuid) { +irecv_error_t irecv_open(irecv_client_t* pclient, const char* uuid) { int i = 0; - int usb_device_count = 0; char serial[256]; struct libusb_device* usb_device = NULL; + struct libusb_context* usb_context = NULL; struct libusb_device** usb_device_list = NULL; struct libusb_device_handle* usb_handle = NULL; struct libusb_device_descriptor usb_descriptor; - if (device == NULL || device->context == NULL) { - return IRECV_ERROR_NO_DEVICE; - } - - irecv_error_t error = 0; - usb_device_count = libusb_get_device_list(device->context, &usb_device_list); + *pclient = NULL; + libusb_init(&usb_context); + irecv_error_t error = IRECV_E_SUCCESS; + int usb_device_count = libusb_get_device_list(usb_context, &usb_device_list); for (i = 0; i < usb_device_count; i++) { usb_device = usb_device_list[i]; libusb_get_device_descriptor(usb_device, &usb_descriptor); @@ -86,148 +68,133 @@ irecv_error_t irecv_open(irecv_device_t* device, const char *uuid) { libusb_open(usb_device, &usb_handle); if (usb_handle == NULL) { - libusb_free_device_list(usb_device_list, 1); - return IRECV_ERROR_UNABLE_TO_CONNECT; - } - - /* get serial number */ - if (libusb_get_string_descriptor_ascii (usb_handle, usb_descriptor.iSerialNumber, serial, sizeof(serial)) < 0) { libusb_free_device_list(usb_device_list, 1); libusb_close(usb_handle); - return IRECV_ERROR_UNABLE_TO_CONNECT; - } - - /* match uuid if required */ - if (uuid != NULL) { - if (strcmp(uuid, serial)) { - libusb_close(usb_handle); - continue; - } + libusb_exit(usb_context); + return IRECV_E_UNABLE_TO_CONNECT; } + libusb_set_debug(usb_context, 3); /* identified a valid recovery device */ libusb_free_device_list(usb_device_list, 1); - device->handle = usb_handle; - device->uuid = strdup(serial); - device->mode = (irecv_mode_t) usb_descriptor.idProduct; - - debug("opening UUID \"%s\"... ", device->uuid); + irecv_client_t client = (irecv_client_t) malloc(sizeof(irecv_client_t)); + if (client == NULL) { + libusb_close(usb_handle); + libusb_exit(usb_context); + return IRECV_E_OUT_OF_MEMORY; + } + memset(client, '\0', sizeof(irecv_client_t)); + client->handle = usb_handle; + client->context = usb_context; + client->mode = (irecv_mode_t) usb_descriptor.idProduct; - error = irecv_set_configuration(device, 1); - if(error != IRECV_SUCCESS) { - debug("setting configuration... "); + error = irecv_set_configuration(client, 1); + if(error != IRECV_E_SUCCESS) { return error; } - error = irecv_set_interface(device, 1, 1); - if(error != IRECV_SUCCESS) { - debug("setting interface... "); + error = irecv_set_interface(client, 1, 1); + if(error != IRECV_E_SUCCESS) { return error; } - return IRECV_SUCCESS; + *pclient = client; + printf("done"); + return IRECV_E_SUCCESS; } } } - return IRECV_ERROR_NO_DEVICE; + return IRECV_E_UNABLE_TO_CONNECT; } -irecv_error_t irecv_set_configuration(irecv_device_t* device, int configuration) { - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_set_configuration(irecv_client_t client, int configuration) { + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } + + debug("Setting to configuration %d", configuration); int current = 0; - libusb_get_configuration(device->handle, ¤t); + libusb_get_configuration(client->handle, ¤t); if(current != configuration) { - if (libusb_set_configuration(device->handle, configuration) < 0) { - return IRECV_ERROR_USB_CONFIGURATION; + if (libusb_set_configuration(client->handle, configuration) < 0) { + return IRECV_E_USB_CONFIGURATION; } } - device->config = configuration; - return IRECV_SUCCESS; + client->config = configuration; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_set_interface(irecv_device_t* device, int interface, int alt_interface) { - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_set_interface(irecv_client_t client, int interface, int alt_interface) { + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } - if (libusb_claim_interface(device->handle, interface) < 0) { - return IRECV_ERROR_USB_INTERFACE; + debug("Setting to interface %d:%d", interface, alt_interface); + libusb_reset_device(client->handle); + + if (libusb_claim_interface(client->handle, interface) < 0) { + return IRECV_E_USB_INTERFACE; } - if(libusb_set_interface_alt_setting(device->handle, interface, alt_interface) < 0) { - return IRECV_ERROR_USB_INTERFACE; + if(libusb_set_interface_alt_setting(client->handle, interface, alt_interface) < 0) { + return IRECV_E_USB_INTERFACE; } - device->interface = interface; - device->alt_interface = alt_interface; - return IRECV_SUCCESS; + client->interface = interface; + client->alt_interface = alt_interface; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_reset(irecv_device_t* device) { - if (device == NULL || device->handle != NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_reset(irecv_client_t client) { + if (client == NULL || client->handle != NULL) { + return IRECV_E_NO_DEVICE; } - libusb_reset_device(device->handle); - return IRECV_SUCCESS; + libusb_reset_device(client->handle); + return IRECV_E_SUCCESS; } -irecv_error_t irecv_close(irecv_device_t* device) { - if (device == NULL) { - return IRECV_ERROR_NO_DEVICE; - } - - if(device->handle != NULL) { - libusb_release_interface(device->handle, 0); - libusb_release_interface(device->handle, 1); - libusb_close(device->handle); - device->handle = NULL; - } - - if(device->uuid != NULL) { - free(device->uuid); - } - - return IRECV_SUCCESS; -} +irecv_error_t irecv_close(irecv_client_t client) { + if (client != NULL) { + if (client->handle != NULL) { + libusb_release_interface(client->handle, 1); + libusb_close(client->handle); + client->handle = NULL; + } -irecv_error_t irecv_exit(irecv_device_t* device) { - if (device != NULL) { - if (device->handle != NULL) { - irecv_close(device); + if (client->context != NULL) { + libusb_exit(client->context); + client->context = NULL; } - if (device->context != NULL) { - libusb_exit(device->context); - device->context = NULL; + if(client->uuid != NULL) { + free(client->uuid); } - free(device); - device = NULL; + free(client); + client = NULL; } - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_set_debug(irecv_device_t* device, int level) { - if(device == NULL || device->context == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_set_debug(irecv_client_t client, int level) { + if(client == NULL || client->context == NULL) { + return IRECV_E_NO_DEVICE; } - libusb_set_debug(device->context, level); - device->debug = level; - return IRECV_SUCCESS; + libusb_set_debug(client->context, level); + client->debug = level; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_send(irecv_device_t* device, unsigned char* command) { - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_send(irecv_client_t client, unsigned char* command) { + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } unsigned int length = strlen(command); @@ -235,22 +202,22 @@ irecv_error_t irecv_send(irecv_device_t* device, unsigned char* command) { length = 0xFF; } - if(device->send_callback != NULL) { + if(client->send_callback != NULL) { // Call our user defined callback first, this must return a number of bytes to send // or zero to abort send. - length = device->send_callback(device, command, length); + length = client->send_callback(client, command, length); } if(length > 0) { - irecv_send_command(device, command); + irecv_send_command(client, command); } - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_send_command(irecv_device_t* device, unsigned char* command) { - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_send_command(irecv_client_t client, unsigned char* command) { + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } unsigned int length = strlen(command); @@ -259,20 +226,20 @@ irecv_error_t irecv_send_command(irecv_device_t* device, unsigned char* command) } if(length > 0) { - libusb_control_transfer(device->handle, 0x40, 0, 0, 0, command, length+1, 100); + libusb_control_transfer(client->handle, 0x40, 0, 0, 0, command, length+1, 100); } - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_send_file(irecv_device_t* device, const char* filename) { - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_send_file(irecv_client_t client, const char* filename) { + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } FILE* file = fopen(filename, "rb"); if (file == NULL) { - return IRECV_ERROR_FILE_NOT_FOUND; + return IRECV_E_FILE_NOT_FOUND; } fseek(file, 0, SEEK_END); @@ -282,7 +249,7 @@ irecv_error_t irecv_send_file(irecv_device_t* device, const char* filename) { unsigned char* buffer = (unsigned char*) malloc(length); if (buffer == NULL) { fclose(file); - return IRECV_ERROR_OUT_OF_MEMORY; + return IRECV_E_OUT_OF_MEMORY; } int bytes = fread(buffer, 1, length, file); @@ -290,36 +257,36 @@ irecv_error_t irecv_send_file(irecv_device_t* device, const char* filename) { if(bytes != length) { free(buffer); - return IRECV_ERROR_UNKNOWN; + return IRECV_E_UNKNOWN; } - irecv_error_t error = irecv_send_buffer(device, buffer, length); + irecv_error_t error = irecv_send_buffer(client, buffer, length); free(buffer); return error; } -irecv_error_t irecv_get_status(irecv_device_t* device, unsigned int* status) { - if(device == NULL || device->handle == NULL) { +irecv_error_t irecv_get_status(irecv_client_t client, unsigned int* status) { + if(client == NULL || client->handle == NULL) { *status = 0; - return IRECV_ERROR_NO_DEVICE; + return IRECV_E_NO_DEVICE; } unsigned char buffer[6]; memset(buffer, '\0', 6); - if(libusb_control_transfer(device->handle, 0xA1, 3, 0, 0, buffer, 6, 1000) != 6) { + if(libusb_control_transfer(client->handle, 0xA1, 3, 0, 0, buffer, 6, 1000) != 6) { *status = 0; - return IRECV_ERROR_USB_STATUS; + return IRECV_E_USB_STATUS; } debug("status: %d\n", (unsigned int) buffer[4]); *status = (unsigned int) buffer[4]; - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_send_buffer(irecv_device_t* device, unsigned char* buffer, unsigned int length) { +irecv_error_t irecv_send_buffer(irecv_client_t client, unsigned char* buffer, unsigned int length) { irecv_error_t error = 0; - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } int last = length % 0x800; @@ -332,61 +299,61 @@ irecv_error_t irecv_send_buffer(irecv_device_t* device, unsigned char* buffer, u unsigned int status = 0; for (i = 0; i < packets; i++) { int size = i + 1 < packets ? 0x800 : last; - int bytes = libusb_control_transfer(device->handle, 0x21, 1, 0, 0, &buffer[i * 0x800], size, 1000); + int bytes = libusb_control_transfer(client->handle, 0x21, 1, 0, 0, &buffer[i * 0x800], size, 1000); if (bytes != size) { - return IRECV_ERROR_USB_UPLOAD; + return IRECV_E_USB_UPLOAD; } debug("Sent %d bytes\n", bytes); - error = irecv_get_status(device, &status); - if (error != IRECV_SUCCESS) { + error = irecv_get_status(client, &status); + if (error != IRECV_E_SUCCESS) { return error; } if(status != 5) { - return IRECV_ERROR_USB_STATUS; + return IRECV_E_USB_STATUS; } } - libusb_control_transfer(device->handle, 0x21, 1, 0, 0, buffer, 0, 1000); + libusb_control_transfer(client->handle, 0x21, 1, 0, 0, buffer, 0, 1000); for (i = 0; i < 3; i++) { - error = irecv_get_status(device, &status); - if(error != IRECV_SUCCESS) { + error = irecv_get_status(client, &status); + if(error != IRECV_E_SUCCESS) { return error; } } - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_receive(irecv_device_t* device) { +irecv_error_t irecv_receive(irecv_client_t client) { unsigned char buffer[BUFFER_SIZE]; memset(buffer, '\0', BUFFER_SIZE); - if(device == NULL || device->handle == NULL) { - return IRECV_ERROR_NO_DEVICE; + if(client == NULL || client->handle == NULL) { + return IRECV_E_NO_DEVICE; } int bytes = 0; - while(libusb_bulk_transfer(device->handle, 0x81, buffer, BUFFER_SIZE, &bytes, 100) == 0) { + while(libusb_bulk_transfer(client->handle, 0x81, buffer, BUFFER_SIZE, &bytes, 100) == 0) { if(bytes > 0) { - if(device->receive_callback != NULL) { - if(device->receive_callback(device, buffer, bytes) != bytes) { - return IRECV_ERROR_UNKNOWN; + if(client->receive_callback != NULL) { + if(client->receive_callback(client, buffer, bytes) != bytes) { + return IRECV_E_UNKNOWN; } } } else break; } - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; } -int irecv_default_sender(irecv_device_t* device, unsigned char* data, int size) { +int irecv_default_sender(irecv_client_t client, unsigned char* data, int size) { return size; } -int irecv_default_receiver(irecv_device_t* device, unsigned char* data, int size) { +int irecv_default_receiver(irecv_client_t client, unsigned char* data, int size) { int i = 0; for(i = 0; i < size; i++) { printf("%c", data[i]); @@ -394,72 +361,89 @@ int irecv_default_receiver(irecv_device_t* device, unsigned char* data, int size return size; } -irecv_error_t irecv_set_receiver(irecv_device_t* device, irecv_receive_callback callback) { - if(device == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_set_receiver(irecv_client_t client, irecv_receive_callback callback) { + if(client == NULL) { + return IRECV_E_NO_DEVICE; } - device->receive_callback = callback; - return IRECV_SUCCESS; + client->receive_callback = callback; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_set_sender(irecv_device_t* device, irecv_send_callback callback) { - if(device == NULL) { - return IRECV_ERROR_NO_DEVICE; +irecv_error_t irecv_set_sender(irecv_client_t client, irecv_send_callback callback) { + if(client == NULL) { + return IRECV_E_NO_DEVICE; } - device->send_callback = callback; - return IRECV_SUCCESS; + client->send_callback = callback; + return IRECV_E_SUCCESS; } -irecv_error_t irecv_getenv(irecv_device_t* device, unsigned char** var) { +irecv_error_t irecv_getenv(irecv_client_t client, unsigned char** var) { unsigned char* value = (unsigned char*) malloc(0x200); if(value == NULL) { - return IRECV_ERROR_OUT_OF_MEMORY; + return IRECV_E_OUT_OF_MEMORY; } - int ret = libusb_control_transfer(device->handle, 0xC0, 0, 0, 0, value, 0x200, 500); + int ret = libusb_control_transfer(client->handle, 0xC0, 0, 0, 0, value, 0x200, 500); if(ret < 0) { - return IRECV_ERROR_UNKNOWN; + return IRECV_E_UNKNOWN; } *var = value; - return IRECV_SUCCESS; + return IRECV_E_SUCCESS; +} + + +irecv_error_t irecv_get_ecid(irecv_client_t client, unsigned long long* ecid) { + char info[256]; + memset(info, '\0', 256); + libusb_get_string_descriptor_ascii(client->handle, 3, info, 0x100); + debug("%s\n", info); + + unsigned char* ecid_string = strstr(info, "ECID:"); + if(ecid_string == NULL) { + *ecid = 0; + return IRECV_E_UNKNOWN; + } + sscanf(ecid_string, "ECID:%qX", ecid); + + return IRECV_E_SUCCESS; } const char* irecv_strerror(irecv_error_t error) { switch(error) { - case IRECV_SUCCESS: + case IRECV_E_SUCCESS: return irecv_error_success; - case IRECV_ERROR_NO_DEVICE: + case IRECV_E_NO_DEVICE: return irecv_error_no_device; - case IRECV_ERROR_OUT_OF_MEMORY: + case IRECV_E_OUT_OF_MEMORY: return irecv_error_out_of_memory; - case IRECV_ERROR_UNABLE_TO_CONNECT: + case IRECV_E_UNABLE_TO_CONNECT: return irecv_error_unable_to_connect; - case IRECV_ERROR_INVALID_INPUT: + case IRECV_E_INVALID_INPUT: return irecv_error_invalid_input; - case IRECV_ERROR_UNKNOWN: + case IRECV_E_UNKNOWN: return irecv_error_unknown; - case IRECV_ERROR_FILE_NOT_FOUND: + case IRECV_E_FILE_NOT_FOUND: return irecv_error_file_not_found; - case IRECV_ERROR_USB_UPLOAD: + case IRECV_E_USB_UPLOAD: return irecv_error_usb_upload; - case IRECV_ERROR_USB_STATUS: + case IRECV_E_USB_STATUS: return irecv_error_usb_status; - case IRECV_ERROR_USB_INTERFACE: + case IRECV_E_USB_INTERFACE: return irecv_error_usb_interface; - case IRECV_ERROR_USB_CONFIGURATION: + case IRECV_E_USB_CONFIGURATION: return irecv_error_usb_configuration; default: -- cgit v1.1-32-gdbae