summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/irecovery.c90
-rw-r--r--src/libirecovery.c354
2 files changed, 207 insertions, 237 deletions
diff --git a/src/irecovery.c b/src/irecovery.c
index 56b0453..00db72d 100644
--- a/src/irecovery.c
+++ b/src/irecovery.c
@@ -35,12 +35,12 @@ static unsigned int verbose = 0;
void print_shell_usage() {
printf("Usage:\n");
- printf("\t/upload <file>\tSend file to device.\n");
+ printf("\t/upload <file>\tSend file to client.\n");
printf("\t/help\t\tShow this help.\n");
printf("\t/exit\t\tExit interactive shell.\n");
}
-void parse_command(irecv_device_t* device, unsigned char* command, unsigned int size) {
+void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) {
char* cmd = strtok(strdup(command), " ");
debug("Executing %s %s\n", cmd, command);
if(!strcmp(cmd, "/exit")) {
@@ -50,25 +50,18 @@ void parse_command(irecv_device_t* device, unsigned char* command, unsigned int
if(!strcmp(cmd, "/help")) {
print_shell_usage();
} else
-
- if(!strcmp(cmd, "/reconnect")) {
- char* uuid = strdup(device->uuid);
- irecv_close(device);
- irecv_open(device, uuid);
- free(uuid);
- } else
if(!strcmp(cmd, "/upload")) {
char* filename = strtok(NULL, " ");
debug("Sending %s\n", filename);
if(filename != NULL) {
- irecv_send_file(device, filename);
+ irecv_send_file(client, filename);
}
}
free(cmd);
}
-int recv_callback(irecv_device_t* device, unsigned char* data, int size) {
+int recv_callback(irecv_client_t client, unsigned char* data, int size) {
int i = 0;
for(i = 0; i < size; i++) {
printf("%c", data[i]);
@@ -76,23 +69,23 @@ int recv_callback(irecv_device_t* device, unsigned char* data, int size) {
return size;
}
-int send_callback(irecv_device_t* device, unsigned char* command, int size) {
+int send_callback(irecv_client_t client, unsigned char* command, int size) {
irecv_error_t error = 0;
if(command[0] == '/') {
- parse_command(device, command, size);
+ parse_command(client, command, size);
return 0;
}
if(strstr(command, "getenv") != NULL) {
unsigned char* value = NULL;
- error = irecv_send_command(device, command);
- if(error != IRECV_SUCCESS) {
+ error = irecv_send_command(client, command);
+ if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
return error;
}
- error = irecv_getenv(device, &value);
- if(error != IRECV_SUCCESS) {
+ error = irecv_getenv(client, &value);
+ if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
return error;
}
@@ -103,8 +96,8 @@ int send_callback(irecv_device_t* device, unsigned char* command, int size) {
}
if(!strcmp(command, "reboot")) {
- error = irecv_send_command(device, command);
- if(error != IRECV_SUCCESS) {
+ error = irecv_send_command(client, command);
+ if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
return error;
}
@@ -124,22 +117,22 @@ void append_command_to_history(char* cmd) {
write_history(FILE_HISTORY_PATH);
}
-void init_shell(irecv_device_t* device) {
+void init_shell(irecv_client_t client) {
irecv_error_t error = 0;
load_command_history();
- irecv_set_sender(device, &send_callback);
- irecv_set_receiver(device, &recv_callback);
+ irecv_set_sender(client, &send_callback);
+ irecv_set_receiver(client, &recv_callback);
while(!quit) {
- error = irecv_receive(device);
- if(error != IRECV_SUCCESS) {
+ error = irecv_receive(client);
+ if(error != IRECV_E_SUCCESS) {
debug("%s\n", irecv_strerror(error));
break;
}
char* cmd = readline("> ");
if(cmd && *cmd) {
- error = irecv_send(device, cmd);
- if(error != IRECV_SUCCESS) {
+ error = irecv_send(client, cmd);
+ if(error != IRECV_E_SUCCESS) {
quit = 1;
}
@@ -153,16 +146,17 @@ void print_usage() {
printf("iRecovery - iDevice Recovery Utility\n");
printf("Usage: ./irecovery [args]\n");
printf("\t-v\t\tStart irecovery in verbose mode.\n");
- printf("\t-u <uuid>\ttarget specific device by its 40-digit device UUID\n");
- printf("\t-c <cmd>\tSend command to device.\n");
- printf("\t-f <file>\tSend file to device.\n");
+ printf("\t-u <uuid>\ttarget specific client by its 40-digit client UUID\n");
+ printf("\t-c <cmd>\tSend command to client.\n");
+ printf("\t-f <file>\tSend file to client.\n");
printf("\t-h\t\tShow this help.\n");
- printf("\t-r\t\tReset device.\n");
+ printf("\t-r\t\tReset client.\n");
printf("\t-s\t\tStart interactive shell.\n");
exit(1);
}
int main(int argc, char** argv) {
+ int i = 0;
int opt = 0;
int action = 0;
char* argument = NULL;
@@ -179,14 +173,14 @@ int main(int argc, char** argv) {
print_usage();
break;
- case 'r':
- action = kResetDevice;
- break;
-
case 'u':
uuid = optarg;
break;
+ case 'r':
+ action = kResetDevice;
+ break;
+
case 's':
action = kStartShell;
break;
@@ -207,45 +201,37 @@ int main(int argc, char** argv) {
}
}
- irecv_device_t* device = irecv_init();
- if(device == NULL) {
- fprintf(stderr, "Unable to initialize libirecovery\n");
- return -1;
- }
- if(verbose) irecv_set_debug(device, verbose);
-
- int i = 0;
+ irecv_client_t client = NULL;
for(i = 0; i <= 5; i++) {
- debug("Attempting to connect... ");
+ debug("Attempting to connect... \n");
- if(irecv_open(device, uuid) < 0) sleep(1);
+ if(irecv_open(&client, uuid) != IRECV_E_SUCCESS) sleep(1);
else break;
- debug("failed. No recovery device found.\n");
-
if(i == 5) {
- irecv_exit(device);
return -1;
}
}
+ if(verbose) irecv_set_debug(client, verbose);
+
switch(action) {
case kResetDevice:
- irecv_reset(device);
+ irecv_reset(client);
break;
case kSendFile:
- error = irecv_send_file(device, argument);
+ error = irecv_send_file(client, argument);
debug("%s\n", irecv_strerror(error));
break;
case kSendCommand:
- error = irecv_send_command(device, argument);
+ error = irecv_send_command(client, argument);
debug("%s\n", irecv_strerror(error));
break;
case kStartShell:
- init_shell(device);
+ init_shell(client);
break;
default:
@@ -253,7 +239,7 @@ int main(int argc, char** argv) {
break;
}
- irecv_exit(device);
+ irecv_close(client);
return 0;
}
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);
@@ -87,147 +69,132 @@ 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, &current);
+ libusb_get_configuration(client->handle, &current);
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:
© 2009-2020 libimobiledevice.org - All rights reserved - Generated by cgit - Icons from Tango - Uses Google Analytics