Uprev libmtp to 1.1.12

src/libusb1-glue.c

 /*
  * \file libusb1-glue.c
  * Low-level USB interface glue towards libusb.
  *
  * Copyright (C) 2005-2007 Richard A. Low <richard@wentnet.com>
  * Copyright (C) 2005-2012 Linus Walleij <triad@df.lth.se>
  * Copyright (C) 2006-2012 Marcus Meissner
  * Copyright (C) 2007 Ted Bullock
  * Copyright (C) 2008 Chris Bagwell <chris@cnpbagwell.com>
  *
@@ skipping 59 matching lines @@
 /* Internal data types */
 struct mtpdevice_list_struct {
   libusb_device *device;
   PTPParams *params;
   PTP_USB *ptp_usb;
   uint32_t bus_location;
   struct mtpdevice_list_struct *next;
 };
 typedef struct mtpdevice_list_struct mtpdevice_list_t;
 
+struct ptp_event_cb_data {
+  PTPEventCbFn cb;
+  void *user_data;
+  PTPParams *params;
+};
+
 static const LIBMTP_device_entry_t mtp_device_table[] = {
 /* We include an .h file which is shared between us and libgphoto2 */
 #include "music-players.h"
 };
-static const int mtp_device_table_size = sizeof(mtp_device_table) / sizeof(LIBMTP_device_entry_t);
+static const int mtp_device_table_size =
+  sizeof(mtp_device_table) / sizeof(LIBMTP_device_entry_t);
 
 // Local functions
 static LIBMTP_error_number_t init_usb();
 static void close_usb(PTP_USB* ptp_usb);
 static int find_interface_and_endpoints(libusb_device *dev,
                                         uint8_t *conf,
                                         uint8_t *interface,
                                         uint8_t *altsetting,
                                         int* inep,
                                         int* inep_maxpacket,
                                         int* outep,
                                         int* outep_maxpacket,
                                         int* intep);
 static void clear_stall(PTP_USB* ptp_usb);
-static int init_ptp_usb (PTPParams* params, PTP_USB* ptp_usb, libusb_device* dev);
-static short ptp_write_func (unsigned long,PTPDataHandler*,void *data,unsigned long*);
-static short ptp_read_func (unsigned long,PTPDataHandler*,void *data,unsigned long*,int);
-static int usb_get_endpoint_status(PTP_USB* ptp_usb, int ep, uint16_t* status);
+static int init_ptp_usb(PTPParams* params,
+                PTP_USB* ptp_usb, libusb_device* dev);
+static short ptp_write_func(unsigned long,
+                PTPDataHandler*, void *data, unsigned long*);
+static short ptp_read_func (unsigned long,
+                PTPDataHandler*, void *data, unsigned long*, int);
+static int usb_get_endpoint_status(PTP_USB* ptp_usb,
+                int ep, uint16_t* status);
 
 /**
  * Get a list of the supported USB devices.
  *
  * The developers depend on users of this library to constantly
  * add in to the list of supported devices. What we need is the
  * device name, USB Vendor ID (VID) and USB Product ID (PID).
  * put this into a bug ticket at the project homepage, please.
  * The VID/PID is used to let e.g. udev lift the device to
  * console userspace access when it's plugged in.
  *
  * @param devices a pointer to a pointer that will hold a device
  *        list after the call to this function, if it was
  *        successful.
  * @param numdevs a pointer to an integer that will hold the number
  *        of devices in the device list if the call was successful.
  * @return 0 if the list was successfull retrieved, any other
  *        value means failure.
  */
-int LIBMTP_Get_Supported_Devices_List(LIBMTP_device_entry_t ** const devices, int * const numdevs)
+int LIBMTP_Get_Supported_Devices_List(LIBMTP_device_entry_t ** const devices,
+                                      int * const numdevs)
 {
   *devices = (LIBMTP_device_entry_t *) &mtp_device_table;
   *numdevs = mtp_device_table_size;
   return 0;
 }
 
 
 static LIBMTP_error_number_t init_usb()
 {
+  static int libusb1_initialized = 0;
+
   /*
    * Some additional libusb debugging please.
    * We use the same level debug between MTP and USB.
    */
+  if (libusb1_initialized)
+     return LIBMTP_ERROR_NONE;
+
   if (libusb_init(NULL) < 0) {
     LIBMTP_ERROR("Libusb1 init failed\n");
     return LIBMTP_ERROR_USB_LAYER;
   }
 
+  libusb1_initialized = 1;
+
   if ((LIBMTP_debug & LIBMTP_DEBUG_USB) != 0)
     libusb_set_debug(NULL,9);
   return LIBMTP_ERROR_NONE;
 }
 
 /**
- * Small recursive function to append a new usb_device to the linked list of
- * USB MTP devices
- * @param devlist dynamic linked list of pointers to usb devices with MTP
- *        properties, to be extended with new device.
+ * Small recursive function to append a new usb_device to the linked
+ * list of USB MTP devices
+ * @param devlist dynamic linked list of pointers to usb devices with
+ *        MTP properties, to be extended with new device.
  * @param newdevice the new device to add.
  * @param bus_location bus for this device.
  * @return an extended array or NULL on failure.
  */
 static mtpdevice_list_t *append_to_mtpdevice_list(mtpdevice_list_t *devlist,
                                                   libusb_device *newdevice,
-
                                                   uint32_t bus_location)
 {
   mtpdevice_list_t *new_list_entry;
 
   new_list_entry = (mtpdevice_list_t *) malloc(sizeof(mtpdevice_list_t));
   if (new_list_entry == NULL) {
     return NULL;
   }
   // Fill in USB device, if we *HAVE* to make a copy of the device do it here.
   new_list_entry->device = newdevice;
@@ skipping 117 matching lines @@
           /*
            * We only want to probe for the OS descriptor if the
            * device is LIBUSB_CLASS_VENDOR_SPEC or one of the interfaces
            * in it is, so flag if we find an interface like this.
            */
           if (intf->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC) {
             found_vendor_spec_interface = 1;
           }
 
           /*
-           * Check for Still Image Capture class with PIMA 15740 protocol,
-           * also known as PTP
+           * TODO: Check for Still Image Capture class with PIMA 15740
+           * protocol, also known as PTP
            */
           if (intf->bInterfaceClass == LIBUSB_CLASS_PTP
               && intf->bInterfaceSubClass == 0x01
               && intf->bInterfaceProtocol == 0x01) {
             if (dumpfile != NULL) {
               fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
               fprintf(dumpfile, "   Found PTP device, check vendor "
                       "extension...\n");
             }
             libusb_close(devh);
@@ skipping 24 matching lines @@
           if (libusb_kernel_driver_active(devh, config->interface[j].altsetting[k].iInterface))
           {
             /*
              * Specifically avoid probing anything else than USB mass storage devices
              * and non-associated drivers in Linux.
              */
             if (config->interface[j].altsetting[k].bInterfaceClass !=
                 LIBUSB_CLASS_MASS_STORAGE) {
               LIBMTP_INFO("avoid probing device using attached kernel interface\n");
               libusb_free_config_descriptor(config);
+              libusb_close(devh);
               return 0;
             }
           }
         }
      }
      libusb_free_config_descriptor(config);
   }
 
   /*
    * Only probe for OS descriptor if the device is vendor specific
@@ skipping 213 matching lines @@
   libusb_device **devs = NULL;
   int i;
   LIBMTP_error_number_t init_usb_ret;
 
   init_usb_ret = init_usb();
   if (init_usb_ret != LIBMTP_ERROR_NONE)
     return 0;
 
   nrofdevs = libusb_get_device_list (NULL, &devs);
   for (i = 0; i < nrofdevs ; i++ ) {
-
     if (libusb_get_bus_number(devs[i]) != busno)
-      continue;
+        continue;
     if (libusb_get_device_address(devs[i]) != devno)
-      continue;
-
-      if (probe_device_descriptor(devs[i], NULL))
+        continue;
+    if (probe_device_descriptor(devs[i], NULL))
         return 1;
   }
   return 0;
 }
 
 /**
  * Detect the raw MTP device descriptors and return a list of
  * of the devices found.
  *
  * @param devices a pointer to a variable that will hold
@@ skipping 73 matching lines @@
         LIBMTP_ERROR("Device %d (VID=%04x and PID=%04x) is a %s %s.\n",
                 i,
                 desc.idVendor,
                 desc.idProduct,
                 mtp_device_table[j].vendor,
                 mtp_device_table[j].product);
         break;
       }
     }
     if (!device_known) {
-      // This device is unknown to the developers
-      LIBMTP_ERROR("Device %d (VID=%04x and PID=%04x) is UNKNOWN.\n",
-              i,
-              desc.idVendor,
-              desc.idProduct);
-      LIBMTP_ERROR("Please report this VID/PID and the device model to the "
-              "libmtp development team\n");
-      /*
-       * Trying to get iManufacturer or iProduct from the device at this
-       * point would require opening a device handle, that we don't want
-       * to do right now. (Takes time for no good enough reason.)
-       */
+      device_unknown(i, desc.idVendor, desc.idProduct);
     }
     // Save the location on the bus
     retdevs[i].bus_location = libusb_get_bus_number (dev->device);
     retdevs[i].devnum = libusb_get_device_address (dev->device);
     i++;
     dev = dev->next;
   }
   *devices = retdevs;
   *numdevs = i;
   free_mtpdevice_list(devlist);
@@ skipping 121 matching lines @@
 ptp_read_func (
         unsigned long size, PTPDataHandler *handler,void *data,
         unsigned long *readbytes,
         int readzero
 ) {
   PTP_USB *ptp_usb = (PTP_USB *)data;
   unsigned long toread = 0;
   int ret = 0;
   int xread;
   unsigned long curread = 0;
-  unsigned long written;
   unsigned char *bytes;
   int expect_terminator_byte = 0;
+  unsigned long usb_inep_maxpacket_size;
+  unsigned long context_block_size_1;
+  unsigned long context_block_size_2;
+  uint16_t ptp_dev_vendor_id = ptp_usb->rawdevice.device_entry.vendor_id;
 
+  //"iRiver" device special handling
+  if (ptp_dev_vendor_id == 0x4102 || ptp_dev_vendor_id == 0x1006) {
+          usb_inep_maxpacket_size = ptp_usb->inep_maxpacket;
+          if (usb_inep_maxpacket_size == 0x400) {
+                  context_block_size_1 = CONTEXT_BLOCK_SIZE_1 - 0x200;
+                  context_block_size_2 = CONTEXT_BLOCK_SIZE_2 + 0x200;
+          }
+          else {
+                  context_block_size_1 = CONTEXT_BLOCK_SIZE_1;
+                  context_block_size_2 = CONTEXT_BLOCK_SIZE_2;
+          }
+  }
   // This is the largest block we'll need to read in.
   bytes = malloc(CONTEXT_BLOCK_SIZE);
   while (curread < size) {
 
     LIBMTP_USB_DEBUG("Remaining size to read: 0x%04lx bytes\n", size - curread);
 
     // check equal to condition here
     if (size - curread < CONTEXT_BLOCK_SIZE)
     {
       // this is the last packet
       toread = size - curread;
       // this is equivalent to zero read for these devices
       if (readzero && FLAG_NO_ZERO_READS(ptp_usb) && toread % 64 == 0) {
         toread += 1;
         expect_terminator_byte = 1;
       }
     }
-    else if (curread == 0)
-      // we are first packet, but not last packet
-      toread = CONTEXT_BLOCK_SIZE_1;
-    else if (toread == CONTEXT_BLOCK_SIZE_1)
-      toread = CONTEXT_BLOCK_SIZE_2;
-    else if (toread == CONTEXT_BLOCK_SIZE_2)
-      toread = CONTEXT_BLOCK_SIZE_1;
+    else if (ptp_dev_vendor_id == 0x4102 || ptp_dev_vendor_id == 0x1006) {
+            //"iRiver" device special handling
+            if (curread == 0)
+                    // we are first packet, but not last packet
+                    toread = context_block_size_1;
+            else if (toread == context_block_size_1)
+                    toread = context_block_size_2;
+            else if (toread == context_block_size_2)
+                    toread = context_block_size_1;
+            else
+                    LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n",
+                                (unsigned int) toread, (unsigned int) (size-curread));
+    }
     else
-      LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n", 
-             (unsigned int) toread, (unsigned int) (size-curread));
+            toread = CONTEXT_BLOCK_SIZE;
 
     LIBMTP_USB_DEBUG("Reading in 0x%04lx bytes\n", toread);
 
     ret = USB_BULK_READ(ptp_usb->handle,
                            ptp_usb->inep,
                            bytes,
                            toread,
                            &xread,
                            ptp_usb->timeout);
 
     LIBMTP_USB_DEBUG("Result of read: 0x%04x (%d bytes)\n", ret, xread);
 
     if (ret != LIBUSB_SUCCESS)
       return PTP_ERROR_IO;
 
     LIBMTP_USB_DEBUG("<==USB IN\n");
     if (xread == 0)
       LIBMTP_USB_DEBUG("Zero Read\n");
     else
       LIBMTP_USB_DATA(bytes, xread, 16);
 
     // want to discard extra byte
     if (expect_terminator_byte && xread == toread)
     {
       LIBMTP_USB_DEBUG("<==USB IN\nDiscarding extra byte\n");
 
       xread--;
     }
 
-    int putfunc_ret = handler->putfunc(NULL, handler->priv, xread, bytes, &written);
+    int putfunc_ret = handler->putfunc(NULL, handler->priv, xread, bytes);
     if (putfunc_ret != PTP_RC_OK)
       return putfunc_ret;
 
     ptp_usb->current_transfer_complete += xread;
     curread += xread;
 
     // Increase counters, call callback
     if (ptp_usb->callback_active) {
       if (ptp_usb->current_transfer_complete >= ptp_usb->current_transfer_total) {
         // send last update and disable callback.
@@ skipping 53 matching lines @@
   unsigned long curwrite = 0;
   unsigned char *bytes;
 
   // This is the largest block we'll need to read in.
   bytes = malloc(CONTEXT_BLOCK_SIZE);
   if (!bytes) {
     return PTP_ERROR_IO;
   }
   while (curwrite < size) {
     unsigned long usbwritten = 0;
-    int xwritten;
+    int xwritten = 0;
 
     towrite = size-curwrite;
     if (towrite > CONTEXT_BLOCK_SIZE) {
       towrite = CONTEXT_BLOCK_SIZE;
     } else {
       // This magic makes packets the same size that WMP send them.
       if (towrite > ptp_usb->outep_maxpacket && towrite % ptp_usb->outep_maxpacket != 0) {
         towrite -= towrite % ptp_usb->outep_maxpacket;
       }
     }
@@ skipping 88 matching lines @@
         if (priv->curoff + tocopy > priv->size)
                 tocopy = priv->size - priv->curoff;
         memcpy (data, priv->data + priv->curoff, tocopy);
         priv->curoff += tocopy;
         *gotlen = tocopy;
         return PTP_RC_OK;
 }
 
 static uint16_t
 memory_putfunc(PTPParams* params, void* private,
-               unsigned long sendlen, unsigned char *data,
-               unsigned long *putlen
+               unsigned long sendlen, unsigned char *data
 ) {
         PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)private;
 
         if (priv->curoff + sendlen > priv->size) {
                 priv->data = realloc (priv->data, priv->curoff+sendlen);
                 priv->size = priv->curoff + sendlen;
         }
         memcpy (priv->data + priv->curoff, data, sendlen);
         priv->curoff += sendlen;
-        *putlen = sendlen;
         return PTP_RC_OK;
 }
 
 /* init private struct for receiving data. */
 static uint16_t
 ptp_init_recv_memory_handler(PTPDataHandler *handler) {
         PTPMemHandlerPrivate* priv;
         priv = malloc (sizeof(PTPMemHandlerPrivate));
         handler->priv = priv;
         handler->getfunc = memory_getfunc;
@@ skipping 41 matching lines @@
         PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)handler->priv;
         *data = priv->data;
         *size = priv->size;
         free (priv);
         return PTP_RC_OK;
 }
 
 /* send / receive functions */
 
 uint16_t
-ptp_usb_sendreq (PTPParams* params, PTPContainer* req)
+ptp_usb_sendreq (PTPParams* params, PTPContainer* req, int dataphase)
 {
         uint16_t ret;
         PTPUSBBulkContainer usbreq;
         PTPDataHandler  memhandler;
         unsigned long written = 0;
         unsigned long towrite;
 
         char txt[256];
 
-        (void) ptp_render_opcode (params, req->Code, sizeof(txt), txt);
+        (void) ptp_render_ofc (params, req->Code, sizeof(txt), txt);
         LIBMTP_USB_DEBUG("REQUEST: 0x%04x, %s\n", req->Code, txt);
 
         /* build appropriate USB container */
         usbreq.length=htod32(PTP_USB_BULK_REQ_LEN-
                 (sizeof(uint32_t)*(5-req->Nparam)));
         usbreq.type=htod16(PTP_USB_CONTAINER_COMMAND);
         usbreq.code=htod16(req->Code);
         usbreq.trans_id=htod32(req->Transaction_ID);
         usbreq.payload.params.param1=htod32(req->Param1);
         usbreq.payload.params.param2=htod32(req->Param2);
@@ skipping 18 matching lines @@
                         "PTP: request code 0x%04x sending req wrote only %ld bytes instead of %d",
                         req->Code, written, towrite
                 );
                 ret = PTP_ERROR_IO;
         }
         return ret;
 }
 
 uint16_t
 ptp_usb_senddata (PTPParams* params, PTPContainer* ptp,
-                  unsigned long size, PTPDataHandler *handler
+                  uint64_t size, PTPDataHandler *handler
 ) {
         uint16_t ret;
         int wlen, datawlen;
         unsigned long written;
         PTPUSBBulkContainer usbdata;
-        uint32_t bytes_left_to_transfer;
+        uint64_t bytes_left_to_transfer;
         PTPDataHandler memhandler;
 
 
         LIBMTP_USB_DEBUG("SEND DATA PHASE\n");
 
         /* build appropriate USB container */
         usbdata.length  = htod32(PTP_USB_BULK_HDR_LEN+size);
         usbdata.type    = htod16(PTP_USB_CONTAINER_DATA);
         usbdata.code    = htod16(ptp->Code);
         usbdata.trans_id= htod32(ptp->Transaction_ID);
@@ skipping 41 matching lines @@
                 ret = PTP_ERROR_IO;
         return ret;
 }
 
 static uint16_t ptp_usb_getpacket(PTPParams *params,
                 PTPUSBBulkContainer *packet, unsigned long *rlen)
 {
         PTPDataHandler  memhandler;
         uint16_t        ret;
         unsigned char   *x = NULL;
+        unsigned long packet_size;
+        PTP_USB *ptp_usb = (PTP_USB *) params->data;
+
+        packet_size = ptp_usb->inep_maxpacket;
 
         /* read the header and potentially the first data */
         if (params->response_packet_size > 0) {
                 /* If there is a buffered packet, just use it. */
                 memcpy(packet, params->response_packet, params->response_packet_size);
                 *rlen = params->response_packet_size;
                 free(params->response_packet);
                 params->response_packet = NULL;
                 params->response_packet_size = 0;
                 /* Here this signifies a "virtual read" */
                 return PTP_RC_OK;
         }
         ptp_init_recv_memory_handler (&memhandler);
-        ret = ptp_read_func(PTP_USB_BULK_HS_MAX_PACKET_LEN_READ, &memhandler, params->data, rlen, 0);
+        ret = ptp_read_func(packet_size, &memhandler, params->data, rlen, 0);
         ptp_exit_recv_memory_handler (&memhandler, &x, rlen);
         if (x) {
                 memcpy (packet, x, *rlen);
                 free (x);
         }
         return ret;
 }
 
 uint16_t
 ptp_usb_getdata (PTPParams* params, PTPContainer* ptp, PTPDataHandler *handler)
 {
         uint16_t ret;
         PTPUSBBulkContainer usbdata;
-        unsigned long   written;
         PTP_USB *ptp_usb = (PTP_USB *) params->data;
         int putfunc_ret;
 
         LIBMTP_USB_DEBUG("GET DATA PHASE\n");
 
         memset(&usbdata,0,sizeof(usbdata));
         do {
                 unsigned long len, rlen;
 
                 ret = ptp_usb_getpacket(params, &usbdata, &rlen);
@@ skipping 21 matching lines @@
                                 // getting data. It appears Windows ignores the contents of this
                                 // field entirely.
                                 if (ret < PTP_RC_Undefined || ret > PTP_RC_SpecificationOfDestinationUnsupported) {
                                         libusb_glue_debug (params, "ptp2/ptp_usb_getdata: detected a broken "
                                                    "PTP header, code field insane.");
                                         ret = PTP_ERROR_IO;
                                 }
                                 break;
                         }
                 }
-                if (usbdata.length == 0xffffffffU) {
+                if (rlen == ptp_usb->inep_maxpacket) {
                   /* Copy first part of data to 'data' */
                   putfunc_ret =
                     handler->putfunc(
-                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data,
-                                     &written
+                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data
                                      );
                   if (putfunc_ret != PTP_RC_OK)
                     return putfunc_ret;
 
                   /* stuff data directly to passed data handler */
                   while (1) {
                     unsigned long readdata;
                     uint16_t xret;
 
                     xret = ptp_read_func(
-                                         PTP_USB_BULK_HS_MAX_PACKET_LEN_READ,
+                                         0x20000000,
                                          handler,
                                          params->data,
                                          &readdata,
                                          0
                                          );
                     if (xret != PTP_RC_OK)
                       return xret;
-                    if (readdata < PTP_USB_BULK_HS_MAX_PACKET_LEN_READ)
+                    if (readdata < 0x20000000)
                       break;
                   }
                   return PTP_RC_OK;
                 }
                 if (rlen > dtoh32(usbdata.length)) {
                         /*
                          * Buffer the surplus response packet if it is >=
                          * PTP_USB_BULK_HDR_LEN
                          * (i.e. it is probably an entire package)
                          * else discard it as erroneous surplus data.
@@ skipping 30 matching lines @@
                 len=dtoh32(usbdata.length)-PTP_USB_BULK_HDR_LEN;
 
                 /* autodetect split header/data MTP devices */
                 if (dtoh32(usbdata.length) > 12 && (rlen==12))
                         params->split_header_data = 1;
 
                 /* Copy first part of data to 'data' */
                 putfunc_ret =
                   handler->putfunc(
                                    params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN,
-                                   usbdata.payload.data,
-                                   &written
+                                   usbdata.payload.data
                                    );
                 if (putfunc_ret != PTP_RC_OK)
                   return putfunc_ret;
 
                 if (FLAG_NO_ZERO_READS(ptp_usb) &&
-                    len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ) {
+                    len+PTP_USB_BULK_HDR_LEN == ptp_usb->inep_maxpacket) {
 
                   LIBMTP_USB_DEBUG("Reading in extra terminating byte\n");
 
                   // need to read in extra byte and discard it
                   int result = 0, xread;
                   unsigned char byte = 0;
                   result = USB_BULK_READ(ptp_usb->handle,
                                          ptp_usb->inep,
                                          &byte,
                                          1,
                                          &xread,
                                          ptp_usb->timeout);
 
                   if (result != 1)
-                    LIBMTP_INFO("Could not read in extra byte for PTP_USB_BULK_HS_MAX_PACKET_LEN_READ long file, return value 0x%04x\n", result);
-                } else if (len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ && params->split_header_data == 0) {
+                    LIBMTP_INFO("Could not read in extra byte for %d byte long file, return value 0x%04x\n", ptp_usb->inep_maxpacket, result);
+                } else if (len+PTP_USB_BULK_HDR_LEN == ptp_usb->inep_maxpacket && params->split_header_data == 0) {
                   int zeroresult = 0, xread;
                   unsigned char zerobyte = 0;
 
                   LIBMTP_INFO("Reading in zero packet after header\n");
 
                   zeroresult = USB_BULK_READ(ptp_usb->handle,
                                              ptp_usb->inep,
                                              &zerobyte,
                                              0,
                                              &xread,
@@ skipping 90 matching lines @@
 #define PTP_EVENT_CHECK                 0x0000  /* waits for */
 #define PTP_EVENT_CHECK_FAST            0x0001  /* checks */
 
 static inline uint16_t
 ptp_usb_event (PTPParams* params, PTPContainer* event, int wait)
 {
         uint16_t ret;
         int result, xread;
         unsigned long rlen;
         PTPUSBEventContainer usbevent;
-        PTP_USB *ptp_usb = (PTP_USB *)(params->data);
+        PTP_USB *ptp_usb;
 
         memset(&usbevent,0,sizeof(usbevent));
 
         if ((params==NULL) || (event==NULL))
                 return PTP_ERROR_BADPARAM;
+        ptp_usb = (PTP_USB *)(params->data);
+
         ret = PTP_RC_OK;
         switch(wait) {
         case PTP_EVENT_CHECK:
                 result = USB_BULK_READ(ptp_usb->handle,
                                      ptp_usb->intep,
                                      (unsigned char *) &usbevent,
                                      sizeof(usbevent),
                                      &xread,
                                      0);
                 if (xread == 0)
@@ skipping 52 matching lines @@
 
         return ptp_usb_event (params, event, PTP_EVENT_CHECK_FAST);
 }
 
 uint16_t
 ptp_usb_event_wait (PTPParams* params, PTPContainer* event) {
 
         return ptp_usb_event (params, event, PTP_EVENT_CHECK);
 }
 
+static void
+ptp_usb_event_cb (struct libusb_transfer *t) {
+        struct ptp_event_cb_data *data = t->user_data;
+        PTPParams *params = data->params;
+        PTPUSBEventContainer *usbevent = (void *)t->buffer;
+        PTPContainer event = {0,};
+        uint16_t code;
+
+        switch (t->status) {
+        case LIBUSB_TRANSFER_COMPLETED:
+                if (t->actual_length < 8) {
+                        libusb_glue_error (params,
+                                "PTP: reading event an short read of %ld bytes occurred\n",
+                                t->actual_length);
+                        code = PTP_ERROR_IO;
+                } else {
+                        event.Code=dtoh16(usbevent->code);
+                        event.SessionID=params->session_id;
+                        event.Transaction_ID=dtoh32(usbevent->trans_id);
+                        event.Param1=dtoh32(usbevent->param1);
+                        event.Param2=dtoh32(usbevent->param2);
+                        event.Param3=dtoh32(usbevent->param3);
+                        code = PTP_RC_OK;
+                }
+                break;
+        case LIBUSB_TRANSFER_TIMED_OUT:
+                code = PTP_ERROR_TIMEOUT;
+                break;
+        case LIBUSB_TRANSFER_CANCELLED:
+                code = PTP_ERROR_CANCEL;
+                break;
+        case LIBUSB_TRANSFER_STALL:
+                code = PTP_ERROR_DATA_EXPECTED;
+                break;
+        case LIBUSB_TRANSFER_ERROR:
+        case LIBUSB_TRANSFER_NO_DEVICE:
+        case LIBUSB_TRANSFER_OVERFLOW:
+        default:
+                code = PTP_ERROR_IO;
+                break;
+        }
+        if (code != PTP_RC_OK) {
+                libusb_glue_error (params,
+                        "PTP: reading event an error 0x%02x occurred\n",
+                        t->status);
+        }
+        data->cb(params, code, &event, data->user_data);
+        free(data);
+}
+
+uint16_t
+ptp_usb_event_async (PTPParams* params, PTPEventCbFn cb, void *user_data) {
+        PTP_USB *ptp_usb;
+        PTPUSBEventContainer *usbevent;
+        struct ptp_event_cb_data *data;
+        struct libusb_transfer *t;
+        int ret;
+
+        if (params == NULL) {
+                return PTP_ERROR_BADPARAM;
+        }
+
+        usbevent = calloc(1, sizeof(*usbevent));
+        if (usbevent == NULL) {
+                return PTP_ERROR_IO;
+        }
+
+        data = malloc(sizeof(*data));
+        if (data == NULL) {
+                free(usbevent);
+                return PTP_ERROR_IO;
+        }
+
+        t = libusb_alloc_transfer(0);
+        if (t == NULL) {
+                free(data);
+                free(usbevent);
+                return PTP_ERROR_IO;
+        }
+
+        data->cb = cb;
+        data->user_data = user_data;
+        data->params = params;
+
+        ptp_usb = (PTP_USB *)(params->data);
+        libusb_fill_interrupt_transfer(t, ptp_usb->handle, ptp_usb->intep,
+                                       (unsigned char *)usbevent, sizeof(*usbevent),
+                                       ptp_usb_event_cb, data, 0);
+        t->flags = LIBUSB_TRANSFER_FREE_BUFFER | LIBUSB_TRANSFER_FREE_TRANSFER;
+
+        ret = libusb_submit_transfer(t);
+        return ret == 0 ? PTP_RC_OK : PTP_ERROR_IO;
+}
+
+/**
+ * Trivial wrapper around the most generic libusb method for polling for events.
+ * Can be used to drive asynchronous event detection.
+ */
+int LIBMTP_Handle_Events_Timeout_Completed(struct timeval *tv, int *completed) {
+        /* Pass NULL for context as libmtp always uses the default context */
+        return libusb_handle_events_timeout_completed(NULL, tv, completed);
+}
+
 uint16_t
 ptp_usb_control_cancel_request (PTPParams *params, uint32_t transactionid) {
         PTP_USB *ptp_usb = (PTP_USB *)(params->data);
         int ret;
         unsigned char buffer[6];
 
         htod16a(&buffer[0],PTP_EC_CancelTransaction);
         htod32a(&buffer[2],transactionid);
         ret = libusb_control_transfer(ptp_usb->handle,
                               LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
@@ skipping 45 matching lines @@
   ) {
       if (LIBUSB_SUCCESS != libusb_detach_kernel_driver(device_handle, ptp_usb->interface)) {
         perror("libusb_detach_kernel_driver() failed, continuing anyway...");
       }
   }
 
   /*
    * Check if the config is set to something else than what we want
    * to use. Only set the configuration if we absolutely have to.
    * Also do not bail out if we fail.
+   *
+   * Note that Darwin will not set the configuration for vendor-specific
+   * devices so we need to go in and set it.
    */
   ret = libusb_get_active_config_descriptor(dev, &config);
   if (ret != LIBUSB_SUCCESS) {
     perror("libusb_get_active_config_descriptor(1) failed");
-    return -1;
+    fprintf(stderr, "no active configuration, trying to set configuration\n");
+    if (libusb_set_configuration(device_handle, ptp_usb->config) != LIBUSB_SUCCESS) {
+      perror("libusb_set_configuration() failed, continuing anyway...");
+    }
+    ret = libusb_get_active_config_descriptor(dev, &config);
+    if (ret != LIBUSB_SUCCESS) {
+      perror("libusb_get_active_config_descriptor(2) failed");
+      return -1;
+    }
   }
   if (config->bConfigurationValue != ptp_usb->config) {
     fprintf(stderr, "desired configuration different from current, trying to set configuration\n");
     if (libusb_set_configuration(device_handle, ptp_usb->config)) {
       perror("libusb_set_configuration() failed, continuing anyway...");
     }
     /* Re-fetch the config descriptor if we changed */
     libusb_free_config_descriptor(config);
     ret = libusb_get_active_config_descriptor(dev, &config);
     if (ret != LIBUSB_SUCCESS) {
@@ skipping 95 matching lines @@
     }
   }
 
   /* check the outep status */
   status=0;
   ret = usb_get_endpoint_status(ptp_usb,ptp_usb->outep,&status);
   if (ret<0) {
     perror("outep: usb_get_endpoint_status()");
   } else if (status) {
     LIBMTP_INFO("Clearing stall on OUT endpoint\n");
-    ret = libusb_clear_halt (ptp_usb->handle, ptp_usb->outep);
+    ret = libusb_clear_halt(ptp_usb->handle, ptp_usb->outep);
     if (ret != LIBUSB_SUCCESS) {
       perror("usb_clear_stall_feature()");
     }
   }
 
   /* TODO: do we need this for INTERRUPT (ptp_usb->intep) too? */
 }
 
-static void clear_halt(PTP_USB* ptp_usb)
-{
-  int ret;
-
-  ret = libusb_clear_halt(ptp_usb->handle,ptp_usb->inep);
-  if (ret<0) {
-    perror("usb_clear_halt() on IN endpoint");
-  }
-  ret = libusb_clear_halt(ptp_usb->handle,ptp_usb->outep);
-  if (ret<0) {
-    perror("usb_clear_halt() on OUT endpoint");
-  }
-  ret = libusb_clear_halt(ptp_usb->handle,ptp_usb->intep);
-  if (ret<0) {
-    perror("usb_clear_halt() on INTERRUPT endpoint");
-  }
-}
-
 static void close_usb(PTP_USB* ptp_usb)
 {
   if (!FLAG_NO_RELEASE_INTERFACE(ptp_usb)) {
     /*
      * Clear any stalled endpoints
      * On misbehaving devices designed for Windows/Mac, quote from:
      * http://www2.one-eyed-alien.net/~mdharm/linux-usb/target_offenses.txt
      * Device does Bad Things(tm) when it gets a GET_STATUS after CLEAR_HALT
      * (...) Windows, when clearing a stall, only sends the CLEAR_HALT command,
      * and presumes that the stall has cleared.  Some devices actually choke
      * if the CLEAR_HALT is followed by a GET_STATUS (used to determine if the
      * STALL is persistant or not).
      */
     clear_stall(ptp_usb);
-    // Clear halts on any endpoints
-    clear_halt(ptp_usb);
-    // Added to clear some stuff on the OUT endpoint
-    // TODO: is this good on the Mac too?
-    // HINT: some devices may need that you comment these two out too.
-    libusb_clear_halt(ptp_usb->handle, ptp_usb->outep);
     libusb_release_interface(ptp_usb->handle, (int) ptp_usb->interface);
   }
   if (FLAG_FORCE_RESET_ON_CLOSE(ptp_usb)) {
     /*
      * Some devices really love to get reset after being
      * disconnected. Again, since Windows never disconnects
      * a device closing behaviour is seldom or never exercised
      * on devices when engineered and often error prone.
      * Reset may help some.
      */
@@ skipping 21 matching lines @@
   ret = libusb_get_device_descriptor(dev, &desc);
   if (ret != LIBUSB_SUCCESS)
     return -1;
 
   // Loop over the device configurations
   for (i = 0; i < desc.bNumConfigurations; i++) {
     uint8_t j;
     struct libusb_config_descriptor *config;
 
     ret = libusb_get_config_descriptor(dev, i, &config);
-    if (ret != 0)
+    if (ret != LIBUSB_SUCCESS)
       continue;
 
     *conf = config->bConfigurationValue;
 
-    if (ret != LIBUSB_SUCCESS) continue;
     // Loop over each configurations interfaces
     for (j = 0; j < config->bNumInterfaces; j++) {
       uint8_t k, l;
       uint8_t no_ep;
       int found_inep = 0;
       int found_outep = 0;
       int found_intep = 0;
       const struct libusb_endpoint_descriptor *ep;
 
       // Inspect the altsettings of this interface...
@@ skipping 119 matching lines @@
                                      &ptp_usb->interface,
                                      &ptp_usb->altsetting,
                                      &ptp_usb->inep,
                                      &ptp_usb->inep_maxpacket,
                                      &ptp_usb->outep,
                                      &ptp_usb->outep_maxpacket,
                                      &ptp_usb->intep);
 
   if (err) {
     libusb_free_device_list (devs, 0);
+    free (ptp_usb);
     LIBMTP_ERROR("LIBMTP PANIC: Unable to find interface & endpoints of device\n");
     return LIBMTP_ERROR_CONNECTING;
   }
 
   /* Copy USB version number */
   ptp_usb->bcdusb = desc.bcdUSB;
 
   /* Attempt to initialize this device */
   if (init_ptp_usb(params, ptp_usb, ldevice) < 0) {
+    free (ptp_usb);
     LIBMTP_ERROR("LIBMTP PANIC: Unable to initialize device\n");
     libusb_free_device_list (devs, 0);
     return LIBMTP_ERROR_CONNECTING;
   }
 
   /*
    * This works in situations where previous bad applications
    * have not used LIBMTP_Release_Device on exit
    */
   if ((ret = ptp_opensession(params, 1)) == PTP_ERROR_IO) {
     LIBMTP_ERROR("PTP_ERROR_IO: failed to open session, trying again after resetting USB interface\n");
     LIBMTP_ERROR("LIBMTP libusb: Attempt to reset device\n");
     libusb_reset_device (ptp_usb->handle);
     close_usb(ptp_usb);
 
     if(init_ptp_usb(params, ptp_usb, ldevice) <0) {
       LIBMTP_ERROR("LIBMTP PANIC: Could not init USB on second attempt\n");
       libusb_free_device_list (devs, 0);
+      free (ptp_usb);
       return LIBMTP_ERROR_CONNECTING;
     }
 
     /* Device has been reset, try again */
     if ((ret = ptp_opensession(params, 1)) == PTP_ERROR_IO) {
       LIBMTP_ERROR("LIBMTP PANIC: failed to open session on second attempt\n");
       libusb_free_device_list (devs, 0);
+      free (ptp_usb);
       return LIBMTP_ERROR_CONNECTING;
     }
   }
 
   /* Was the transaction id invalid? Try again */
   if (ret == PTP_RC_InvalidTransactionID) {
     LIBMTP_ERROR("LIBMTP WARNING: Transaction ID was invalid, increment and try again\n");
     params->transaction_id += 10;
     ret = ptp_opensession(params, 1);
   }
 
   if (ret != PTP_RC_SessionAlreadyOpened && ret != PTP_RC_OK) {
     LIBMTP_ERROR("LIBMTP PANIC: Could not open session! "
             "(Return code %d)\n  Try to reset the device.\n",
             ret);
     libusb_release_interface(ptp_usb->handle, ptp_usb->interface);
     libusb_free_device_list (devs, 0);
+    free (ptp_usb);
     return LIBMTP_ERROR_CONNECTING;
   }
 
   /* OK configured properly */
   *usbinfo = (void *) ptp_usb;
   libusb_free_device_list (devs, 0);
   return LIBMTP_ERROR_NONE;
 }
 
 
@@ skipping 47 matching lines @@
 {
   return libusb_control_transfer(ptp_usb->handle,
                           LIBUSB_ENDPOINT_IN|LIBUSB_RECIPIENT_ENDPOINT,
                           LIBUSB_REQUEST_GET_STATUS,
                           USB_FEATURE_HALT,
                           ep,
                           (unsigned char *) status,
                           2,
                           ptp_usb->timeout);
 }