Revert "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;
           }
 
           /*
-           * TODO: Check for Still Image Capture class with PIMA 15740
-           * protocol, also known as PTP
+           * 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) {
-      device_unknown(i, desc.idVendor, desc.idProduct);
+      // 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.)
+       */
     }
     // 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 (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 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
-            toread = CONTEXT_BLOCK_SIZE;
+      LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n", 
+             (unsigned int) toread, (unsigned int) (size-curread));
 
     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);
+    int putfunc_ret = handler->putfunc(NULL, handler->priv, xread, bytes, &written);
     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 = 0;
+    int xwritten;
 
     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 sendlen, unsigned char *data,
+               unsigned long *putlen
 ) {
         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, int dataphase)
+ptp_usb_sendreq (PTPParams* params, PTPContainer* req)
 {
         uint16_t ret;
         PTPUSBBulkContainer usbreq;
         PTPDataHandler  memhandler;
         unsigned long written = 0;
         unsigned long towrite;
 
         char txt[256];
 
-        (void) ptp_render_ofc (params, req->Code, sizeof(txt), txt);
+        (void) ptp_render_opcode (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,
-                  uint64_t size, PTPDataHandler *handler
+                  unsigned long size, PTPDataHandler *handler
 ) {
         uint16_t ret;
         int wlen, datawlen;
         unsigned long written;
         PTPUSBBulkContainer usbdata;
-        uint64_t bytes_left_to_transfer;
+        uint32_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(packet_size, &memhandler, params->data, rlen, 0);
+        ret = ptp_read_func(PTP_USB_BULK_HS_MAX_PACKET_LEN_READ, &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 (rlen == ptp_usb->inep_maxpacket) {
+                if (usbdata.length == 0xffffffffU) {
                   /* Copy first part of data to 'data' */
                   putfunc_ret =
                     handler->putfunc(
-                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data
+                                     params, handler->priv, rlen - PTP_USB_BULK_HDR_LEN, usbdata.payload.data,
+                                     &written
                                      );
                   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(
-                                         0x20000000,
+                                         PTP_USB_BULK_HS_MAX_PACKET_LEN_READ,
                                          handler,
                                          params->data,
                                          &readdata,
                                          0
                                          );
                     if (xret != PTP_RC_OK)
                       return xret;
-                    if (readdata < 0x20000000)
+                    if (readdata < PTP_USB_BULK_HS_MAX_PACKET_LEN_READ)
                       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
+                                   usbdata.payload.data,
+                                   &written
                                    );
                 if (putfunc_ret != PTP_RC_OK)
                   return putfunc_ret;
 
                 if (FLAG_NO_ZERO_READS(ptp_usb) &&
-                    len+PTP_USB_BULK_HDR_LEN == ptp_usb->inep_maxpacket) {
+                    len+PTP_USB_BULK_HDR_LEN == PTP_USB_BULK_HS_MAX_PACKET_LEN_READ) {
 
                   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 %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) {
+                    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) {
                   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 *ptp_usb = (PTP_USB *)(params->data);
 
         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");
-    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;
-    }
+    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 != LIBUSB_SUCCESS)
+    if (ret != 0)
       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);
 }