Added detection of stalled pipes for IOKIT and added functions for async requests

1 files changed, 179 insertions, 0 deletions

diff --git a/src/libirecovery.c b/src/libirecovery.c
index bf9a0d6..390f5cc 100644
--- a/src/libirecovery.c
+++ b/src/libirecovery.c
@@ -98,6 +98,18 @@
         static void f(void)
 #endif
 
+#ifndef WIN32
+struct irecv_async_transfer {
+        uint32_t len;
+ #ifdef HAVE_IOKIT
+        kern_return_t ret;
+ #else
+        enum libusb_transfer_status ret;
+ #endif
+};
+
+#endif
+
 struct irecv_client_private {
         int debug;
         int usb_config;
@@ -113,6 +125,7 @@ struct irecv_client_private {
 #else
         IOUSBDeviceInterface320 **handle;
         IOUSBInterfaceInterface300 **usbInterface;
+        CFRunLoopSourceRef async_event_source;
 #endif
 #else
         HANDLE handle;
@@ -1402,6 +1415,7 @@ static int iokit_usb_control_transfer(irecv_client_t client, uint8_t bm_request_
         result = (*client->handle)->DeviceRequestTO(client->handle, &req);
         switch (result) {
                 case kIOReturnSuccess:         return req.wLenDone;
+                case kIOUSBPipeStalled:        return IRECV_E_PIPE;
                 case kIOReturnTimeout:         return IRECV_E_TIMEOUT;
                 case kIOUSBTransactionTimeout: return IRECV_E_TIMEOUT;
                 case kIOReturnNotResponding:   return IRECV_E_NO_DEVICE;
@@ -1472,6 +1486,158 @@ int irecv_usb_control_transfer(irecv_client_t client, uint8_t bm_request_type, u
 #endif
 }
 
+#ifndef WIN32
+#ifdef HAVE_IOKIT
+
+static void iokit_async_cb(void *refcon, kern_return_t ret, void *arg_0)
+{
+        struct irecv_async_transfer* transfer = refcon;
+
+        if(transfer != NULL) {
+                transfer->ret = ret;
+                memcpy(&transfer->len, &arg_0, sizeof(transfer->len));
+                CFRunLoopStop(CFRunLoopGetCurrent());
+        }
+}
+
+static int iokit_async_usb_control_transfer(irecv_client_t client, uint8_t bm_request_type, uint8_t b_request, uint16_t w_value, uint16_t w_index, unsigned char *data, uint16_t w_length, struct irecv_async_transfer* transfer)
+{
+        IOReturn result;
+        IOUSBDevRequest req;
+
+        bzero(&req, sizeof(req));
+        req.bmRequestType     = bm_request_type;
+        req.bRequest          = b_request;
+        req.wValue            = OSSwapLittleToHostInt16(w_value);
+        req.wIndex            = OSSwapLittleToHostInt16(w_index);
+        req.wLength           = OSSwapLittleToHostInt16(w_length);
+        req.pData             = data;
+        result = (*client->handle)->DeviceRequestAsync(client->handle, &req, iokit_async_cb, transfer);
+        switch (result) {
+                case kIOReturnSuccess:         return IRECV_E_SUCCESS;
+                case kIOUSBPipeStalled:        return IRECV_E_PIPE;
+                case kIOReturnTimeout:         return IRECV_E_TIMEOUT;
+                case kIOUSBTransactionTimeout: return IRECV_E_TIMEOUT;
+                case kIOReturnNotResponding:   return IRECV_E_NO_DEVICE;
+                case kIOReturnNoDevice:        return IRECV_E_NO_DEVICE;
+                default:
+                        return IRECV_E_UNKNOWN_ERROR;
+        }
+}
+
+#else
+
+static void async_cb(struct libusb_transfer* usb_transfer) {
+        struct irecv_async_transfer* transfer = usb_transfer->user_data;
+        transfer->ret = usb_transfer->status;
+        transfer->len += usb_transfer->actual_length;
+}
+
+#endif
+#endif
+
+IRECV_API int irecv_async_usb_control_transfer(irecv_client_t client, uint8_t bm_request_type, uint8_t b_request, uint16_t w_value, uint16_t w_index, unsigned char *data, uint16_t w_length) {
+#ifdef USE_DUMMY
+        return IRECV_E_UNSUPPORTED;
+#else
+#ifndef _WIN32
+#ifdef HAVE_IOKIT
+        return iokit_async_usb_control_transfer(client, bm_request_type, b_request, w_value, w_index, data, w_length, NULL);
+#else
+        irecv_error_t error;
+
+        unsigned char* buffer = malloc(w_length + 8);
+        if(!buffer) {
+                return IRECV_E_OUT_OF_MEMORY;
+        }
+        struct libusb_transfer* usb_transfer = libusb_alloc_transfer(0);
+        if(!usb_transfer) {
+                free(buffer);
+                return IRECV_E_OUT_OF_MEMORY;
+        }
+        memcpy((buffer + 8), data, w_length);
+        libusb_fill_control_setup(buffer, bm_request_type, b_request, w_value, w_index, w_length);
+        libusb_fill_control_transfer(usb_transfer, client->handle, buffer, NULL, NULL, 0);
+        usb_transfer->flags |= LIBUSB_TRANSFER_FREE_BUFFER;
+        error = libusb_submit_transfer(usb_transfer);
+        if(error != 0) {
+                free(buffer);
+                return error;
+        }
+        free(buffer);
+        return IRECV_E_SUCCESS;
+#endif
+#else
+        return IRECV_E_UNSUPPORTED;
+#endif
+#endif
+
+}
+
+IRECV_API int irecv_async_usb_control_transfer_with_cancel(irecv_client_t client, uint8_t bm_request_type, uint8_t b_request, uint16_t w_value, uint16_t w_index, unsigned char *data, uint16_t w_length, unsigned int u_time) {
+#ifdef USE_DUMMY
+        return IRECV_E_UNSUPPORTED;
+#else
+#ifndef _WIN32
+        irecv_error_t error;
+        struct irecv_async_transfer transfer;
+        bzero(&transfer, sizeof(struct irecv_async_transfer));
+
+#ifdef HAVE_IOKIT
+
+        error = iokit_async_usb_control_transfer(client, bm_request_type, b_request, w_value, w_index, data, w_length, &transfer);
+        if(error != IRECV_E_SUCCESS) {
+                return error;
+        }
+        usleep(u_time);
+        error = (*client->handle)->USBDeviceAbortPipeZero(client->handle);
+        if(error != kIOReturnSuccess) {
+                return IRECV_E_UNKNOWN_ERROR;
+        }
+        while(transfer.ret != kIOReturnAborted){
+                CFRunLoopRun();
+        }
+        return transfer.len;
+#else
+        unsigned char* buffer = malloc(w_length + 8);
+        if(!buffer) {
+                return IRECV_E_OUT_OF_MEMORY;
+        }
+        struct libusb_transfer* usb_transfer = libusb_alloc_transfer(0);
+        if(!usb_transfer) {
+                free(buffer);
+                return IRECV_E_OUT_OF_MEMORY;
+        }
+        memcpy((buffer + 8), data, w_length);
+        libusb_fill_control_setup(buffer, bm_request_type, b_request, w_value, w_index, w_length);
+        libusb_fill_control_transfer(usb_transfer, client->handle, buffer, async_cb, &transfer, 0);
+        usb_transfer->flags |= LIBUSB_TRANSFER_FREE_BUFFER;
+        error = libusb_submit_transfer(usb_transfer);
+        if(error != 0) {
+                free(buffer);
+                return error;
+        }
+
+        usleep(u_time);
+
+        error = libusb_cancel_transfer(usb_transfer);
+        if(error != 0) {
+                free(buffer);
+                return error;
+        }
+        free(buffer);
+
+        while(transfer.ret != LIBUSB_TRANSFER_CANCELLED){
+                libusb_handle_events_completed(libirecovery_context, NULL);
+        }
+        return transfer.len;
+#endif
+#else
+        return IRECV_E_UNSUPPORTED;
+#endif
+#endif
+}
+
 #ifndef USE_DUMMY
 #ifdef HAVE_IOKIT
 static int iokit_usb_bulk_transfer(irecv_client_t client,
@@ -1978,6 +2144,15 @@ irecv_error_t irecv_open_with_ecid(irecv_client_t* pclient, uint64_t ecid)
                 return error;
         }
 
+#ifdef HAVE_IOKIT
+        error = (*client->handle)->CreateDeviceAsyncEventSource(client->handle, &client->async_event_source);
+        if (error != IRECV_E_SUCCESS) {
+                free(client);
+                return error;
+        }
+        CFRunLoopAddSource(CFRunLoopGetCurrent(), client->async_event_source, kCFRunLoopDefaultMode);
+#endif
+
         if (client->mode == IRECV_K_DFU_MODE || client->mode == IRECV_K_PORT_DFU_MODE || client->mode == IRECV_K_WTF_MODE || client->mode == KIS_PRODUCT_ID) {
                 error = irecv_usb_set_interface(client, 0, 0);
         } else {
@@ -3196,6 +3371,10 @@ static irecv_error_t irecv_cleanup(irecv_client_t client)
                         (*client->handle)->Release(client->handle);
                         client->handle = NULL;
                 }
+                if(client->async_event_source) {
+                        CFRunLoopRemoveSource(CFRunLoopGetCurrent(), client->async_event_source, kCFRunLoopDefaultMode);
+                        CFRelease(client->async_event_source);
+                }
 #else
                 if (client->handle != NULL) {
                         if ((client->mode != IRECV_K_DFU_MODE) && (client->mode != IRECV_K_PORT_DFU_MODE) && (client->mode != IRECV_K_WTF_MODE) && (client->isKIS == 0)) {