Uprev libmtp to 1.1.12

src/libopenusb1-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-2011 Marcus Meissner
  * Copyright (C) 2007 Ted Bullock
  * Copyright (C) 2008 Chris Bagwell <chris@cnpbagwell.com>
  *
@@ skipping 643 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 = 0;
         retdevs[i].devnum = openusb_get_devid(libmtp_openusb_handle, &dev->device);
         i++;
         dev = dev->next;
     }
     *devices = retdevs;
     *numdevs = i;
     free_mtpdevice_list(devlist);
@@ skipping 111 matching lines @@
         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;
+            }
+    }
     struct openusb_bulk_request bulk;
     // 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
-            LIBMTP_INFO("unexpected toread size 0x%04x, 0x%04x remaining bytes\n",
-                (unsigned int) toread, (unsigned int) (size - curread));
+        } 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
+                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);
@@ skipping 16 matching lines @@
         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);
         LIBMTP_USB_DEBUG("handler->putfunc ret = 0x%x\n", putfunc_ret);
         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) {
@@ skipping 187 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 42 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 43 matching lines @@
     if (ret != PTP_RC_OK && ret != PTP_ERROR_CANCEL)
         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) {
@@ skipping 36 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);
              */
 
             bulk.payload = &byte;
             bulk.length = 1;
             bulk.timeout = ptp_usb->timeout;
             bulk.flags = 0;
             bulk.next = NULL;
             result = openusb_bulk_xfer(*ptp_usb->handle, ptp_usb->interface, ptp_usb->inep, &bulk);
             xread = bulk.result.transferred_bytes;
 
             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 bytes 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 215 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);
 }
 
 uint16_t
+ptp_usb_event_async (PTPParams* params, PTPEventCbFn cb, void *user_data) {
+        /* Unsupported */
+        return PTP_ERROR_CANCEL;
+}
+
+int LIBMTP_Handle_Events_Timeout_Completed(struct timeval *tv, int *completed) {
+        /* Unsupported */
+        return -12;
+}
+
+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 526 matching lines @@
     ctrl.timeout = ptp_usb->timeout;
     ctrl.next = NULL;
     ctrl.setup.bRequest = USB_REQ_GET_STATUS;
     ctrl.setup.bmRequestType = USB_ENDPOINT_IN | USB_RECIP_ENDPOINT;
     ctrl.setup.wIndex = ep;
     ctrl.setup.wValue = USB_FEATURE_HALT;
     openusb_ctrl_xfer(*ptp_usb->handle, ptp_usb->interface, ep, &ctrl);
     return ctrl.result.status;
 
 }