Uprev libmtp to 1.1.12

src/libmtp.c

 /**
  * \file libmtp.c
  *
  * Copyright (C) 2005-2011 Linus Walleij <triad@df.lth.se>
  * Copyright (C) 2005-2008 Richard A. Low <richard@wentnet.com>
  * Copyright (C) 2007 Ted Bullock <tbullock@canada.com>
  * Copyright (C) 2007 Tero Saarni <tero.saarni@gmail.com>
  * Copyright (C) 2008 Florent Mertens <flomertens@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 98 matching lines @@
  * otherwise the libmtp.h device has to be dependent on ptp.h
  * to be installed too, and we don't want that.
  */
 typedef struct propertymap_struct {
   char *description; /**< Text description for the property */
   LIBMTP_property_t id; /**< LIBMTP internal type for the property */
   uint16_t ptp_id; /**< PTP ID for the property */
   struct propertymap_struct *next;
 } propertymap_t;
 
+/*
+ * This is a simple container for holding our callback and user_data
+ * for parsing onwards to the usb_event_async function.
+ */
+typedef struct event_cb_data_struct {
+  LIBMTP_event_cb_fn cb;
+  void *user_data;
+} event_cb_data_t;
+
 // Global variables
 // This holds the global filetype mapping table
-static filemap_t *filemap = NULL;
+static filemap_t *g_filemap = NULL;
 // This holds the global property mapping table
-static propertymap_t *propertymap = NULL;
+static propertymap_t *g_propertymap = NULL;
 
 /*
  * Forward declarations of local (static) functions.
  */
 static int register_filetype(char const * const description, LIBMTP_filetype_t const id,
                              uint16_t const ptp_id);
 static void init_filemap();
 static int register_property(char const * const description, LIBMTP_property_t const id,
                              uint16_t const ptp_id);
 static void init_propertymap();
 static void add_error_to_errorstack(LIBMTP_mtpdevice_t *device,
                                     LIBMTP_error_number_t errornumber,
                                     char const * const error_text);
 static void add_ptp_error_to_errorstack(LIBMTP_mtpdevice_t *device,
                                         uint16_t ptp_error,
                                         char const * const error_text);
 static void flush_handles(LIBMTP_mtpdevice_t *device);
 static void get_handles_recursively(LIBMTP_mtpdevice_t *device,
                                     PTPParams *params,
                                     uint32_t storageid,
                                     uint32_t parent);
 static void free_storage_list(LIBMTP_mtpdevice_t *device);
 static int sort_storage_by(LIBMTP_mtpdevice_t *device, int const sortby);
-static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device, uint64_t fitsize);
+static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device,
+                                        uint64_t fitsize);
 static int get_storage_freespace(LIBMTP_mtpdevice_t *device,
                                  LIBMTP_devicestorage_t *storage,
                                  uint64_t *freespace);
 static int check_if_file_fits(LIBMTP_mtpdevice_t *device,
                               LIBMTP_devicestorage_t *storage,
                               uint64_t const filesize);
 static uint16_t map_libmtp_type_to_ptp_type(LIBMTP_filetype_t intype);
 static LIBMTP_filetype_t map_ptp_type_to_libmtp_type(uint16_t intype);
 static uint16_t map_libmtp_property_to_ptp_property(LIBMTP_property_t inproperty);
 static LIBMTP_property_t map_ptp_property_to_libmtp_property(uint16_t intype);
@@ skipping 46 matching lines @@
                                 uint32_t const no_tracks);
 static int send_file_object_info(LIBMTP_mtpdevice_t *device, LIBMTP_file_t *filedata);
 static void add_object_to_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id);
 static void update_metadata_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id);
 static int set_object_filename(LIBMTP_mtpdevice_t *device,
                 uint32_t object_id,
                 uint16_t ptp_type,
                 const char **newname);
 static char *generate_unique_filename(PTPParams* params, char const * const filename);
 static int check_filename_exists(PTPParams* params, char const * const filename);
+static void LIBMTP_Handle_Event(PTPContainer *ptp_event,
+                                LIBMTP_event_t *event, uint32_t *out1);
 
 /**
  * These are to wrap the get/put handlers to convert from the MTP types to PTP types
  * in a reliable way
  */
 typedef struct _MTPDataHandler {
         MTPDataGetFunc          getfunc;
         MTPDataPutFunc          putfunc;
         void                    *priv;
 } MTPDataHandler;
 
 static uint16_t get_func_wrapper(PTPParams* params, void* priv, unsigned long wantlen, unsigned char *data, unsigned long *gotlen);
-static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data, unsigned long *putlen);
+static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data);
 
 /**
  * Checks if a filename ends with ".ogg". Used in various
  * situations when the device has no idea that it support
  * OGG but still does.
  *
  * @param name string to be checked.
  * @return 0 if this does not end with ogg, any other
  *           value means it does.
  */
@@ skipping 61 matching lines @@
  * @param id libmtp internal filetype id
  * @param ptp_id PTP filetype id
  * @return 0 for success any other value means error.
 */
 static int register_filetype(char const * const description, LIBMTP_filetype_t const id,
                              uint16_t const ptp_id)
 {
   filemap_t *new = NULL, *current;
 
   // Has this LIBMTP filetype been registered before ?
-  current = filemap;
+  current = g_filemap;
   while (current != NULL) {
     if(current->id == id) {
       break;
     }
     current = current->next;
   }
 
   // Create the entry
   if(current == NULL) {
     new = new_filemap_entry();
     if(new == NULL) {
       return 1;
     }
 
     new->id = id;
     if(description != NULL) {
       new->description = strdup(description);
     }
     new->ptp_id = ptp_id;
 
     // Add the entry to the list
-    if(filemap == NULL) {
-      filemap = new;
+    if(g_filemap == NULL) {
+      g_filemap = new;
     } else {
-      current = filemap;
+      current = g_filemap;
       while (current->next != NULL ) current=current->next;
       current->next = new;
     }
     // Update the existing entry
   } else {
     if (current->description != NULL) {
       free(current->description);
     }
     current->description = NULL;
     if(description != NULL) {
@@ skipping 56 matching lines @@
 
 /**
  * Returns the PTP filetype that maps to a certain libmtp internal file type.
  * @param intype the MTP library interface type
  * @return the PTP (libgphoto2) interface type
  */
 static uint16_t map_libmtp_type_to_ptp_type(LIBMTP_filetype_t intype)
 {
   filemap_t *current;
 
-  current = filemap;
+  current = g_filemap;
 
   while (current != NULL) {
     if(current->id == intype) {
       return current->ptp_id;
     }
     current = current->next;
   }
   // printf("map_libmtp_type_to_ptp_type: unknown filetype.\n");
   return PTP_OFC_Undefined;
 }
 
 
 /**
  * Returns the MTP internal interface type that maps to a certain ptp
  * interface type.
  * @param intype the PTP (libgphoto2) interface type
  * @return the MTP library interface type
  */
 static LIBMTP_filetype_t map_ptp_type_to_libmtp_type(uint16_t intype)
 {
   filemap_t *current;
 
-  current = filemap;
+  current = g_filemap;
 
   while (current != NULL) {
     if(current->ptp_id == intype) {
       return current->id;
     }
     current = current->next;
   }
   // printf("map_ptp_type_to_libmtp_type: unknown filetype.\n");
   return LIBMTP_FILETYPE_UNKNOWN;
 }
@@ skipping 25 matching lines @@
  * @param id libmtp internal property id
  * @param ptp_id PTP property id
  * @return 0 for success any other value means error.
 */
 static int register_property(char const * const description, LIBMTP_property_t const id,
                              uint16_t const ptp_id)
 {
   propertymap_t *new = NULL, *current;
 
   // Has this LIBMTP propety been registered before ?
-  current = propertymap;
+  current = g_propertymap;
   while (current != NULL) {
     if(current->id == id) {
       break;
     }
     current = current->next;
   }
 
   // Create the entry
   if(current == NULL) {
     new = new_propertymap_entry();
     if(new == NULL) {
       return 1;
     }
 
     new->id = id;
     if(description != NULL) {
       new->description = strdup(description);
     }
     new->ptp_id = ptp_id;
 
     // Add the entry to the list
-    if(propertymap == NULL) {
-      propertymap = new;
+    if(g_propertymap == NULL) {
+      g_propertymap = new;
     } else {
-      current = propertymap;
+      current = g_propertymap;
       while (current->next != NULL ) current=current->next;
       current->next = new;
     }
     // Update the existing entry
   } else {
     if (current->description != NULL) {
       free(current->description);
     }
     current->description = NULL;
     if(description != NULL) {
@@ skipping 179 matching lines @@
 
 /**
  * Returns the PTP property that maps to a certain libmtp internal property type.
  * @param inproperty the MTP library interface property
  * @return the PTP (libgphoto2) property type
  */
 static uint16_t map_libmtp_property_to_ptp_property(LIBMTP_property_t inproperty)
 {
   propertymap_t *current;
 
-  current = propertymap;
+  current = g_propertymap;
 
   while (current != NULL) {
     if(current->id == inproperty) {
       return current->ptp_id;
     }
     current = current->next;
   }
   return 0;
 }
 
 
 /**
  * Returns the MTP internal interface property that maps to a certain ptp
  * interface property.
  * @param inproperty the PTP (libgphoto2) interface property
  * @return the MTP library interface property
  */
 static LIBMTP_property_t map_ptp_property_to_libmtp_property(uint16_t inproperty)
 {
   propertymap_t *current;
 
-  current = propertymap;
+  current = g_propertymap;
 
   while (current != NULL) {
     if(current->ptp_id == inproperty) {
       return current->id;
     }
     current = current->next;
   }
   // printf("map_ptp_type_to_libmtp_type: unknown filetype.\n");
   return LIBMTP_PROPERTY_UNKNOWN;
 }
@@ skipping 52 matching lines @@
  * This helper function returns a textual description for a libmtp
  * file type to be used in dialog boxes etc.
  * @param intype the libmtp internal filetype to get a description for.
  * @return a string representing the filetype, this must <b>NOT</b>
  *         be free():ed by the caller!
  */
 char const * LIBMTP_Get_Filetype_Description(LIBMTP_filetype_t intype)
 {
   filemap_t *current;
 
-  current = filemap;
+  current = g_filemap;
 
   while (current != NULL) {
     if(current->id == intype) {
       return current->description;
     }
     current = current->next;
   }
 
   return "Unknown filetype";
 }
 
 /**
  * This helper function returns a textual description for a libmtp
  * property to be used in dialog boxes etc.
  * @param inproperty the libmtp internal property to get a description for.
  * @return a string representing the filetype, this must <b>NOT</b>
  *         be free():ed by the caller!
  */
 char const * LIBMTP_Get_Property_Description(LIBMTP_property_t inproperty)
 {
   propertymap_t *current;
 
-  current = propertymap;
+  current = g_propertymap;
 
   while (current != NULL) {
     if(current->id == inproperty) {
       return current->description;
     }
     current = current->next;
   }
 
   return "Unknown property";
 }
@@ skipping 488 matching lines @@
  * @param attribute_id PTP attribute ID
  * @return valid string or NULL on failure. The returned string
  *         must bee <code>free()</code>:ed by the caller after
  *         use.
  */
 static char *get_string_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                                     uint16_t const attribute_id)
 {
   PTPPropertyValue propval;
   char *retstring = NULL;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
   MTPProperties *prop;
 
-  if ( device == NULL || object_id == 0) {
+  if (!device || !object_id)
     return NULL;
-  }
+
+  params = (PTPParams *) device->params;
 
   prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
   if (prop) {
     if (prop->propval.str != NULL)
       return strdup(prop->propval.str);
     else
       return NULL;
   }
 
   ret = ptp_mtp_getobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_STR);
@@ skipping 16 matching lines @@
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value_default Default value to return on failure
  * @return the value
  */
 static uint64_t get_u64_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
                                     uint16_t const attribute_id, uint64_t const value_default)
 {
   PTPPropertyValue propval;
   uint64_t retval = value_default;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
   MTPProperties *prop;
 
-  if ( device == NULL ) {
+  if (!device)
     return value_default;
-  }
+
+  params = (PTPParams *) device->params;
 
   prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
   if (prop)
     return prop->propval.u64;
 
   ret = ptp_mtp_getobjectpropvalue(params, object_id,
                                    attribute_id,
                                    &propval,
                                    PTP_DTC_UINT64);
   if (ret == PTP_RC_OK) {
@@ skipping 12 matching lines @@
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value_default Default value to return on failure
  * @return the value
  */
 static uint32_t get_u32_from_object(LIBMTP_mtpdevice_t *device,uint32_t const object_id,
                                     uint16_t const attribute_id, uint32_t const value_default)
 {
   PTPPropertyValue propval;
   uint32_t retval = value_default;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
   MTPProperties *prop;
 
-  if ( device == NULL ) {
+  if (!device)
     return value_default;
-  }
+
+  params = (PTPParams *) device->params;
 
   prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
   if (prop)
     return prop->propval.u32;
 
   ret = ptp_mtp_getobjectpropvalue(params, object_id,
                                    attribute_id,
                                    &propval,
                                    PTP_DTC_UINT32);
   if (ret == PTP_RC_OK) {
@@ skipping 11 matching lines @@
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value_default Default value to return on failure
  * @return a value
  */
 static uint16_t get_u16_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                                     uint16_t const attribute_id, uint16_t const value_default)
 {
   PTPPropertyValue propval;
   uint16_t retval = value_default;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
   MTPProperties *prop;
 
-  if ( device == NULL ) {
+  if (!device)
     return value_default;
-  }
+
+  params = (PTPParams *) device->params;
 
   // This O(n) search should not be used so often, since code
   // using the cached properties don't usually call this function.
   prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
   if (prop)
     return prop->propval.u16;
 
   ret = ptp_mtp_getobjectpropvalue(params, object_id,
                                    attribute_id,
                                    &propval,
@@ skipping 14 matching lines @@
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value_default Default value to return on failure
  * @return a value
  */
 static uint8_t get_u8_from_object(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                                   uint16_t const attribute_id, uint8_t const value_default)
 {
   PTPPropertyValue propval;
   uint8_t retval = value_default;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
   MTPProperties *prop;
 
-  if ( device == NULL ) {
+  if (!device)
     return value_default;
-  }
+
+  params = (PTPParams *) device->params;
 
   // This O(n) search should not be used so often, since code
   // using the cached properties don't usually call this function.
   prop = ptp_find_object_prop_in_cache(params, object_id, attribute_id);
   if (prop)
     return prop->propval.u8;
 
   ret = ptp_mtp_getobjectpropvalue(params, object_id,
                                    attribute_id,
                                    &propval,
@@ skipping 13 matching lines @@
  * @param device a pointer to an MTP device.
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param string string value to set
  * @return 0 on success, any other value means failure
  */
 static int set_object_string(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                              uint16_t const attribute_id, char const * const string)
 {
   PTPPropertyValue propval;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
 
-  if (device == NULL || string == NULL) {
+  if (!device || !string)
     return -1;
-  }
+
+  params = (PTPParams *) device->params;
 
   if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_string(): could not set object string: "
                                 "PTP_OC_MTP_SetObjectPropValue not supported.");
     return -1;
   }
   propval.str = (char *) string;
   ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_STR);
   if (ret != PTP_RC_OK) {
     add_ptp_error_to_errorstack(device, ret, "set_object_string(): could not set object string.");
@@ skipping 10 matching lines @@
  * @param device a pointer to an MTP device.
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value 32-bit unsigned integer to set
  * @return 0 on success, any other value means failure
  */
 static int set_object_u32(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                           uint16_t const attribute_id, uint32_t const value)
 {
   PTPPropertyValue propval;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
 
-  if (device == NULL) {
+  if (!device)
     return -1;
-  }
+
+  params = (PTPParams *) device->params;
 
   if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u32(): could not set unsigned 32bit integer property: "
                                 "PTP_OC_MTP_SetObjectPropValue not supported.");
     return -1;
   }
 
   propval.u32 = value;
   ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT32);
   if (ret != PTP_RC_OK) {
@@ skipping 10 matching lines @@
  * @param device a pointer to an MTP device.
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value 16-bit unsigned integer to set
  * @return 0 on success, any other value means failure
  */
 static int set_object_u16(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                           uint16_t const attribute_id, uint16_t const value)
 {
   PTPPropertyValue propval;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
 
-  if (device == NULL) {
+  if (!device)
     return 1;
-  }
+
+  params = (PTPParams *) device->params;
 
   if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u16(): could not set unsigned 16bit integer property: "
                                 "PTP_OC_MTP_SetObjectPropValue not supported.");
     return -1;
   }
   propval.u16 = value;
   ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT16);
   if (ret != PTP_RC_OK) {
     add_ptp_error_to_errorstack(device, ret, "set_object_u16(): could not set unsigned 16bit integer property.");
     return 1;
   }
 
   return 0;
 }
 
 /**
  * Sets an object attribute from an unsigned 8-bit integer
  *
  * @param device a pointer to an MTP device.
  * @param object_id Object reference
  * @param attribute_id PTP attribute ID
  * @param value 8-bit unsigned integer to set
  * @return 0 on success, any other value means failure
  */
 static int set_object_u8(LIBMTP_mtpdevice_t *device, uint32_t const object_id,
                          uint16_t const attribute_id, uint8_t const value)
 {
   PTPPropertyValue propval;
-  PTPParams *params = (PTPParams *) device->params;
+  PTPParams *params;
   uint16_t ret;
 
-  if (device == NULL) {
+  if (!device)
     return 1;
-  }
+
+  params = (PTPParams *) device->params;
 
   if (!ptp_operation_issupported(params,PTP_OC_MTP_SetObjectPropValue)) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "set_object_u8(): could not set unsigned 8bit integer property: "
                             "PTP_OC_MTP_SetObjectPropValue not supported.");
     return -1;
   }
   propval.u8 = value;
   ret = ptp_mtp_setobjectpropvalue(params, object_id, attribute_id, &propval, PTP_DTC_UINT8);
   if (ret != PTP_RC_OK) {
     add_ptp_error_to_errorstack(device, ret, "set_object_u8(): could not set unsigned 8bit integer property.");
@@ skipping 14 matching lines @@
   LIBMTP_raw_device_t *devices;
   int numdevs;
   LIBMTP_error_number_t ret;
 
   ret = LIBMTP_Detect_Raw_Devices(&devices, &numdevs);
   if (ret != LIBMTP_ERROR_NONE) {
     return NULL;
   }
 
   if (devices == NULL || numdevs == 0) {
+    free(devices);
     return NULL;
   }
 
   first_device = LIBMTP_Open_Raw_Device(&devices[0]);
   free(devices);
   return first_device;
 }
 
 /**
  * Overriding debug function.
@@ skipping 50 matching lines @@
   int start = 0;
   int end = 0;
 
   /* NULL on Canon A70 */
   if (!desc)
     return;
 
   /* descriptors are divided by semicolons */
   while (end < strlen(desc)) {
     /* Skip past initial whitespace */
-    while (desc[start] == ' ' && end < strlen(desc)) {
+    while ((end < strlen(desc)) && (desc[start] == ' ' )) {
       start++;
       end++;
     }
     /* Detect extension */
-    while (desc[end] != ';' && end < strlen(desc))
+    while ((end < strlen(desc)) && (desc[end] != ';'))
       end++;
     if (end < strlen(desc)) {
       char *element = strndup(desc + start, end-start);
       if (element) {
         int i = 0;
         // printf("  Element: \"%s\"\n", element);
 
         /* Parse for an extension */
-        while (element[i] != ':' && i < strlen(element))
+        while ((i < strlen(element)) && (element[i] != ':'))
           i++;
         if (i < strlen(element)) {
           char *name = strndup(element, i);
           int majstart = i+1;
           // printf("    Extension: \"%s\"\n", name);
 
           /* Parse for minor/major punctuation mark for this extension */
-          while (element[i] != '.' && i < strlen(element))
+          while ((i < strlen(element)) && (element[i] != '.'))
             i++;
           if (i > majstart && i < strlen(element)) {
             LIBMTP_device_extension_t *extension;
             int major = 0;
             int minor = 0;
             char *majorstr = strndup(element + majstart, i - majstart);
             char *minorstr = strndup(element + i + 1, strlen(element) - i - 1);
             major = atoi(majorstr);
             minor = atoi(minorstr);
+            // printf("    Major: \"%s\" (parsed %d) Minor: \"%s\" (parsed %d)\n",
+            //      majorstr, major, minorstr, minor);
             free(majorstr);
             free(minorstr);
             extension = malloc(sizeof(LIBMTP_device_extension_t));
             extension->name = name;
             extension->major = major;
             extension->minor = minor;
             extension->next = NULL;
             if (mtpdevice->extensions == NULL) {
               mtpdevice->extensions = extension;
             } else {
               LIBMTP_device_extension_t *tmp = mtpdevice->extensions;
               while (tmp->next != NULL)
                 tmp = tmp->next;
               tmp->next = extension;
             }
-            // printf("    Major: \"%s\" (parsed %d) Minor: \"%s\" (parsed %d)\n",
-            //      majorstr, major, minorstr, minor);
           } else {
             LIBMTP_ERROR("LIBMTP ERROR: couldnt parse extension %s\n",
                          element);
           }
         }
         free(element);
       }
     }
     end++;
     start = end;
@@ skipping 12 matching lines @@
 {
   LIBMTP_mtpdevice_t *mtp_device;
   uint8_t bs = 0;
   PTPParams *current_params;
   PTP_USB *ptp_usb;
   LIBMTP_error_number_t err;
   int i;
 
   /* Allocate dynamic space for our device */
   mtp_device = (LIBMTP_mtpdevice_t *) malloc(sizeof(LIBMTP_mtpdevice_t));
-  memset(mtp_device, 0, sizeof(LIBMTP_mtpdevice_t));
   /* Check if there was a memory allocation error */
   if(mtp_device == NULL) {
     /* There has been an memory allocation error. We are going to ignore this
        device and attempt to continue */
 
     /* TODO: This error statement could probably be a bit more robust */
     LIBMTP_ERROR("LIBMTP PANIC: connect_usb_devices encountered a memory "
             "allocation error with device %d on bus %d, trying to continue",
             rawdevice->devnum, rawdevice->bus_location);
 
     return NULL;
   }
+  memset(mtp_device, 0, sizeof(LIBMTP_mtpdevice_t));
   // Non-cached by default
   mtp_device->cached = 0;
 
   /* Create PTP params */
   current_params = (PTPParams *) malloc(sizeof(PTPParams));
   if (current_params == NULL) {
     free(mtp_device);
     return NULL;
   }
   memset(current_params, 0, sizeof(PTPParams));
@@ skipping 293 matching lines @@
    * FIXME: Potential race-condition here, if client deallocs device
    * while we're *not* waiting for input. As we'll be waiting for
    * input most of the time, it's unlikely but still worth considering
    * for improvement. Also we cannot affect the state of the cache etc
    * unless we know we are the sole user on the device. A spinlock or
    * mutex in the LIBMTP_mtpdevice_t is needed for this to work.
    */
   PTPParams *params = (PTPParams *) device->params;
   PTPContainer ptp_event;
   uint16_t ret = ptp_usb_event_wait(params, &ptp_event);
-  uint16_t code;
-  uint32_t session_id;
-  uint32_t transaction_id;
-  uint32_t param1;
-  uint32_t param2;
-  uint32_t param3;
 
   if (ret != PTP_RC_OK) {
     /* Device is closing down or other fatal stuff, exit thread */
     return -1;
   }
+  LIBMTP_Handle_Event(&ptp_event, event, out1);
+  return 0;
+}
+
+void LIBMTP_Handle_Event(PTPContainer *ptp_event,
+                         LIBMTP_event_t *event, uint32_t *out1) {
+  uint16_t code;
+  uint32_t session_id;
+  uint32_t param1;
 
   *event = LIBMTP_EVENT_NONE;
 
   /* Process the event */
-  code = ptp_event.Code;
-  session_id = ptp_event.SessionID;
-  transaction_id = ptp_event.Transaction_ID;
-  param1 = ptp_event.Param1;
-  param2 = ptp_event.Param2;
-  param3 = ptp_event.Param3;
+  code = ptp_event->Code;
+  session_id = ptp_event->SessionID;
+  param1 = ptp_event->Param1;
 
   switch(code) {
     case PTP_EC_Undefined:
       LIBMTP_INFO("Received event PTP_EC_Undefined in session %u\n", session_id);
       break;
     case PTP_EC_CancelTransaction:
       LIBMTP_INFO("Received event PTP_EC_CancelTransaction in session %u\n", session_id);
       break;
     case PTP_EC_ObjectAdded:
       LIBMTP_INFO("Received event PTP_EC_ObjectAdded in session %u\n", session_id);
+      *event = LIBMTP_EVENT_OBJECT_ADDED;
+      *out1 = param1;
       break;
     case PTP_EC_ObjectRemoved:
       LIBMTP_INFO("Received event PTP_EC_ObjectRemoved in session %u\n", session_id);
+      *event = LIBMTP_EVENT_OBJECT_REMOVED;
+      *out1 = param1;
       break;
     case PTP_EC_StoreAdded:
       LIBMTP_INFO("Received event PTP_EC_StoreAdded in session %u\n", session_id);
       /* TODO: rescan storages */
       *event = LIBMTP_EVENT_STORE_ADDED;
       *out1 = param1;
       break;
     case PTP_EC_StoreRemoved:
       LIBMTP_INFO("Received event PTP_EC_StoreRemoved in session %u\n", session_id);
       /* TODO: rescan storages */
+      *event = LIBMTP_EVENT_STORE_REMOVED;
+      *out1 = param1;
       break;
     case PTP_EC_DevicePropChanged:
       LIBMTP_INFO("Received event PTP_EC_DevicePropChanged in session %u\n", session_id);
       /* TODO: update device properties */
       break;
     case PTP_EC_ObjectInfoChanged:
       LIBMTP_INFO("Received event PTP_EC_ObjectInfoChanged in session %u\n", session_id);
       /* TODO: rescan object cache or just for this one object */
       break;
     case PTP_EC_DeviceInfoChanged:
@@ skipping 16 matching lines @@
     case PTP_EC_CaptureComplete :
       LIBMTP_INFO( "Received event PTP_EC_CaptureComplete in session %u\n", session_id);
       break;
     case PTP_EC_UnreportedStatus :
       LIBMTP_INFO( "Received event PTP_EC_UnreportedStatus in session %u\n", session_id);
       break;
     default :
       LIBMTP_INFO( "Received unknown event in session %u\n", session_id);
       break;
   }
+}
 
-  return 0;
+static void LIBMTP_Read_Event_Cb(PTPParams *params, uint16_t ret_code,
+                                 PTPContainer *ptp_event, void *user_data) {
+  event_cb_data_t *data = user_data;
+  LIBMTP_event_t event = LIBMTP_EVENT_NONE;
+  uint32_t param1 = 0;
+  int handler_ret;
+
+  switch (ret_code) {
+  case PTP_RC_OK:
+    handler_ret = LIBMTP_HANDLER_RETURN_OK;
+    LIBMTP_Handle_Event(ptp_event, &event, &param1);
+    break;
+  case PTP_ERROR_CANCEL:
+    handler_ret = LIBMTP_HANDLER_RETURN_CANCEL;
+    break;
+  default:
+    handler_ret = LIBMTP_HANDLER_RETURN_ERROR;
+    break;
+  }
+
+  data->cb(handler_ret, event, param1, data->user_data);
+  free(data);
 }
 
 /**
+ * This function reads events sent by the device, in a non-blocking manner.
+ * The callback function will be called when an event is received, but for the function
+ * to make progress, polling must take place, using LIBMTP_Handle_Events_Timeout_Completed.
+ *
+ * After an event is received, this function should be called again to listen for the next
+ * event.
+ *
+ * For now, this non-blocking mechanism only works with libusb-1.0, and not any of the
+ * other usb library backends. Attempting to call this method with another backend will
+ * always return an error.
+ *
+ * @param device a pointer to the MTP device to poll for events.
+ * @param cb a callback to be invoked when an event is received.
+ * @param user_data arbitrary user data passed to the callback.
+ * @return 0 on success, any other value means that the callback was not registered and
+ *         no event notification will take place.
+ */
+int LIBMTP_Read_Event_Async(LIBMTP_mtpdevice_t *device, LIBMTP_event_cb_fn cb, void *user_data) {
+  PTPParams *params = (PTPParams *) device->params;
+  event_cb_data_t *data =  malloc(sizeof(event_cb_data_t));
+  uint16_t ret;
+
+  data->cb = cb;
+  data->user_data = user_data;
+
+  ret = ptp_usb_event_async(params, LIBMTP_Read_Event_Cb, data);
+  return ret == PTP_RC_OK ? 0 : -1;
+}
+
+/**
  * Recursive function that adds MTP devices to a linked list
  * @param devices a list of raw devices to have real devices created for.
  * @return a device pointer to a newly created mtpdevice (used in linked
  * list creation).
  */
 static LIBMTP_mtpdevice_t * create_usb_mtp_devices(LIBMTP_raw_device_t *devices, int numdevs)
 {
   uint8_t i;
   LIBMTP_mtpdevice_t *mtp_device_list = NULL;
   LIBMTP_mtpdevice_t *current_device = NULL;
@@ skipping 50 matching lines @@
 
   ret = LIBMTP_Detect_Raw_Devices(&devices, &numdevs);
   if (ret != LIBMTP_ERROR_NONE) {
     *device_list = NULL;
     return ret;
   }
 
   /* Assign linked list of devices */
   if (devices == NULL || numdevs == 0) {
     *device_list = NULL;
+    free(devices);
     return LIBMTP_ERROR_NO_DEVICE_ATTACHED;
   }
 
   *device_list = create_usb_mtp_devices(devices, numdevs);
   free(devices);
 
   /* TODO: Add wifi device access here */
 
   /* We have found some devices but create failed */
   if (*device_list == NULL)
@@ skipping 87 matching lines @@
   }
 }
 
 /**
  * Adds an error from the PTP layer to the error stack.
  */
 static void add_ptp_error_to_errorstack(LIBMTP_mtpdevice_t *device,
                                         uint16_t ptp_error,
                                         char const * const error_text)
 {
+  PTPParams      *params = (PTPParams *) device->params;
+
   if (device == NULL) {
     LIBMTP_ERROR("LIBMTP PANIC: Trying to add PTP error to a NULL device!\n");
     return;
   } else {
     char outstr[256];
     snprintf(outstr, sizeof(outstr), "PTP Layer error %04x: %s", ptp_error, error_text);
     outstr[sizeof(outstr)-1] = '\0';
     add_error_to_errorstack(device, LIBMTP_ERROR_PTP_LAYER, outstr);
 
-    snprintf(outstr, sizeof(outstr), "Error %04x: %s", ptp_error, ptp_strerror(ptp_error));
+    snprintf(outstr, sizeof(outstr), "Error %04x: %s", ptp_error, ptp_strerror(ptp_error, params->deviceinfo.VendorExtensionID));
     outstr[sizeof(outstr)-1] = '\0';
     add_error_to_errorstack(device, LIBMTP_ERROR_PTP_LAYER, outstr);
   }
 }
 
 /**
  * This returns the error stack for a device in case you
  * need to either reference the error numbers (e.g. when
  * creating multilingual apps with multiple-language text
  * representations for each error number) or when you need
@@ skipping 135 matching lines @@
    */
   prop = props;
   for (i=0;i<nrofprops;i++) {
       if (lasthandle != prop->ObjectHandle) {
         cnt++;
         lasthandle = prop->ObjectHandle;
       }
       prop++;
   }
   lasthandle = 0xffffffff;
-  params->objects = calloc (sizeof(PTPObject),cnt);
+  params->objects = calloc (cnt, sizeof(PTPObject));
   prop = props;
   i = -1;
   for (j=0;j<nrofprops;j++) {
     if (lasthandle != prop->ObjectHandle) {
       if (i >= 0) {
         params->objects[i].flags |= PTPOBJECT_OBJECTINFO_LOADED;
         if (!params->objects[i].oi.Filename) {
           /* I have one such file on my Creative (Marcus) */
           params->objects[i].oi.Filename = strdup("<null>");
         }
@@ skipping 29 matching lines @@
         params->objects[i].oi.Filename = strdup(prop->propval.str);
       break;
     default: {
       MTPProperties *newprops;
 
       /* Copy all of the other MTP oprierties into the per-object proplist */
       if (params->objects[i].nrofmtpprops) {
         newprops = realloc(params->objects[i].mtpprops,
                 (params->objects[i].nrofmtpprops+1)*sizeof(MTPProperties));
       } else {
-        newprops = calloc(sizeof(MTPProperties),1);
+        newprops = calloc(1,sizeof(MTPProperties));
       }
       if (!newprops) return 0; /* FIXME: error handling? */
       params->objects[i].mtpprops = newprops;
       memcpy(&params->objects[i].mtpprops[params->objects[i].nrofmtpprops],
              &props[j],sizeof(props[j]));
       params->objects[i].nrofmtpprops++;
       params->objects[i].flags |= PTPOBJECT_MTPPROPLIST_LOADED;
       break;
     }
     }
     prop++;
   }
   /* mark last entry also */
   params->objects[i].flags |= PTPOBJECT_OBJECTINFO_LOADED;
   params->nrofobjects = i+1;
+  free (props);
   /* The device might not give the list in linear ascending order */
   ptp_objects_sort (params);
   return 0;
 }
 
 /**
  * This function will recurse through all the directories on the device,
  * starting at the root directory, gathering metadata as it moves along.
  * It works better on some devices that will only return data for a
  * certain directory and does not respect the option to get all metadata
@@ skipping 263 matching lines @@
   return 0;
 }
 
 /**
  * This function grabs the first writeable storageid from the
  * device storage list.
  * @param device a pointer to the MTP device to locate writeable
  *        storage for.
  * @param fitsize a file of this file must fit on the device.
  */
-static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device, uint64_t fitsize)
+static uint32_t get_writeable_storageid(LIBMTP_mtpdevice_t *device,
+                                        uint64_t fitsize)
 {
   LIBMTP_devicestorage_t *storage;
   uint32_t store = 0x00000000; //Should this be 0xffffffffu instead?
   int subcall_ret;
 
   // See if there is some storage we can fit this file on.
   storage = device->storage;
   if (storage == NULL) {
     // Sometimes the storage just cannot be detected.
     store = 0x00000000U;
@@ skipping 32 matching lines @@
                               "all device storage is full or corrupt.");
       return -1;
     }
     store = storage->id;
   }
 
   return store;
 }
 
 /**
+ * Tries to suggest a storage_id of a given ID when we have a parent
+ * @param device a pointer to the device where to search for the storage ID
+ * @param fitsize a file of this file must fit on the device.
+ * @param parent_id look for this ID
+ * @ret storageID
+ */
+static int get_suggested_storage_id(LIBMTP_mtpdevice_t *device,
+                                    uint64_t fitsize,
+                                    uint32_t parent_id)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  PTPObject *ob;
+  uint16_t ret;
+
+  ret = ptp_object_want(params, parent_id, PTPOBJECT_MTPPROPLIST_LOADED, &ob);
+  if ((ret != PTP_RC_OK) || (ob->oi.StorageID == 0)) {
+    add_ptp_error_to_errorstack(device, ret, "get_suggested_storage_id(): "
+                                "could not get storage id from parent id.");
+    return get_writeable_storageid(device, fitsize);
+  } else {
+    /* OK we know the parent storage, then use that */
+    return ob->oi.StorageID;
+  }
+}
+
+/**
  * This function grabs the freespace from a certain storage in
  * device storage list.
  * @param device a pointer to the MTP device to free the storage
  * list for.
  * @param storageid the storage ID for the storage to flush and
  * get free space for.
  * @param freespace the free space on this storage will be returned
  * in this variable.
  */
 static int get_storage_freespace(LIBMTP_mtpdevice_t *device,
@@ skipping 68 matching lines @@
     printf("        %s: %d.%d\n",
            tmpext->name,
            tmpext->major,
            tmpext->minor);
     tmpext = tmpext->next;
   }
   printf("Supported operations:\n");
   for (i=0;i<params->deviceinfo.OperationsSupported_len;i++) {
     char txt[256];
 
-    (void) ptp_render_opcode(params, params->deviceinfo.OperationsSupported[i],
+    (void) ptp_render_ofc(params, params->deviceinfo.OperationsSupported[i],
                              sizeof(txt), txt);
     printf("   %04x: %s\n", params->deviceinfo.OperationsSupported[i], txt);
   }
   printf("Events supported:\n");
   if (params->deviceinfo.EventsSupported_len == 0) {
     printf("   None.\n");
   } else {
     for (i=0;i<params->deviceinfo.EventsSupported_len;i++) {
       printf("   0x%04x\n", params->deviceinfo.EventsSupported[i]);
     }
@@ skipping 824 matching lines @@
     localtypelen++;
   }
 
   *filetypes = localtypes;
   *length = localtypelen;
 
   return 0;
 }
 
 /**
+ * This function checks if the device has some specific capabilities, in
+ * order to avoid calling APIs that may disturb the device.
+ *
+ * @param device a pointer to the device to check the capability on.
+ * @param cap the capability to check.
+ * @return 0 if not supported, any other value means the device has the
+ * requested capability.
+ */
+int LIBMTP_Check_Capability(LIBMTP_mtpdevice_t *device, LIBMTP_devicecap_t cap)
+{
+  switch (cap) {
+  case LIBMTP_DEVICECAP_GetPartialObject:
+    return (ptp_operation_issupported(device->params,
+                                      PTP_OC_GetPartialObject) ||
+            ptp_operation_issupported(device->params,
+                                      PTP_OC_ANDROID_GetPartialObject64));
+  case LIBMTP_DEVICECAP_SendPartialObject:
+    return ptp_operation_issupported(device->params,
+                                     PTP_OC_ANDROID_SendPartialObject);
+  case LIBMTP_DEVICECAP_EditObjects:
+    return (ptp_operation_issupported(device->params,
+                                      PTP_OC_ANDROID_TruncateObject) &&
+            ptp_operation_issupported(device->params,
+                                      PTP_OC_ANDROID_BeginEditObject) &&
+            ptp_operation_issupported(device->params,
+                                      PTP_OC_ANDROID_EndEditObject));
+  /*
+   * Handle other capabilities here, this is also a good place to
+   * blacklist some advanced operations on specific devices if need
+   * be.
+   */
+
+  default:
+    break;
+  }
+  return 0;
+}
+
+/**
  * This function updates all the storage id's of a device and their
  * properties, then creates a linked list and puts the list head into
  * the device struct. It also optionally sorts this list. If you want
  * to display storage information in your application you should call
  * this function, then dereference the device struct
  * (<code>device-&gt;storage</code>) to get out information on the storage.
  *
  * You need to call this everytime you want to update the
  * <code>device-&gt;storage</code> list, for example anytime you need
  * to check available storage somewhere.
@@ skipping 1189 matching lines @@
       return PTP_ERROR_CANCEL;
     default:
       return PTP_ERROR_IO;
   }
 }
 
 /**
  * This is a manual conversion from MTPDataPutFunc to PTPDataPutFunc
  * to isolate the internal type.
  */
-static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data, unsigned long *putlen)
+static uint16_t put_func_wrapper(PTPParams* params, void* priv, unsigned long sendlen, unsigned char *data)
 {
   MTPDataHandler *handler = (MTPDataHandler *)priv;
   uint16_t ret;
   uint32_t local_putlen = 0;
+
   ret = handler->putfunc(params, handler->priv, sendlen, data, &local_putlen);
-  *putlen = local_putlen;
+
   switch (ret)
   {
     case LIBMTP_HANDLER_RETURN_OK:
+      if (local_putlen != sendlen)
+        return PTP_ERROR_IO;
       return PTP_RC_OK;
     case LIBMTP_HANDLER_RETURN_ERROR:
       return PTP_ERROR_IO;
     case LIBMTP_HANDLER_RETURN_CANCEL:
       return PTP_ERROR_CANCEL;
     default:
       return PTP_ERROR_IO;
   }
 }
 
@@ skipping 935 matching lines @@
 #if 0
   // Sanity check: no zerolength files on some devices?
   // If the zerolength files cause problems on some devices,
   // then add a bug flag for this.
   if (filedata->filesize == 0) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "send_file_object_info(): "
                             "File of zero size.");
     return -1;
   }
 #endif
-
   if (filedata->storage_id != 0) {
     store = filedata->storage_id;
   } else {
-    store = get_writeable_storageid(device, filedata->filesize);
+    store = get_suggested_storage_id(device, filedata->filesize, localph);
   }
+
   // Detect if something non-primary is in use.
   storage = device->storage;
   if (storage != NULL && store != storage->id) {
     use_primary_storage = 0;
   }
 
   /*
    * If no destination folder was given, look up a default
    * folder if possible. Perhaps there is some way of retrieveing
    * the default folder for different forms of content, what
@@ skipping 194 matching lines @@
     }
   } else if (ptp_operation_issupported(params,PTP_OC_SendObjectInfo)) {
     PTPObjectInfo new_file;
 
     memset(&new_file, 0, sizeof(PTPObjectInfo));
 
     new_file.Filename = filedata->filename;
     if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
       strip_7bit_from_utf8(new_file.Filename);
     }
-    // We lose precision here.
-    new_file.ObjectCompressedSize = (uint32_t) filedata->filesize;
+    if (filedata->filesize > 0xFFFFFFFFL) {
+      // This is a kludge in the MTP standard for large files.
+      new_file.ObjectCompressedSize = (uint32_t) 0xFFFFFFFF;
+    } else {
+      new_file.ObjectCompressedSize = (uint32_t) filedata->filesize;
+    }
     new_file.ObjectFormat = of;
     new_file.StorageID = store;
     new_file.ParentObject = localph;
     new_file.ModificationDate = time(NULL);
 
     // Create the object
     ret = ptp_sendobjectinfo(params, &store, &localph, &filedata->item_id, &new_file);
 
     if (ret != PTP_RC_OK) {
       add_ptp_error_to_errorstack(device, ret, "send_file_object_info(): "
@@ skipping 983 matching lines @@
  * for a folder is "association". The PTP/MTP devices does not
  * have an internal "folder" concept really, it contains a flat
  * list of all files and some file are "associations" that other
  * files and folders may refer to as its "parent".
  *
  * @param device a pointer to the device to create the folder on.
  * @param name the name of the new folder. Note this can be modified
  *        if the device does not support all the characters in the
  *        name.
  * @param parent_id id of parent folder to add the new folder to,
- *        or 0 to put it in the root directory.
+ *        or 0xFFFFFFFF to put it in the root directory.
  * @param storage_id id of the storage to add this new folder to.
  *        notice that you cannot mismatch storage id and parent id:
  *        they must both be on the same storage! Pass in 0 if you
  *        want to create this folder on the default storage.
  * @return id to new folder or 0 if an error occured
  */
 uint32_t LIBMTP_Create_Folder(LIBMTP_mtpdevice_t *device, char *name,
                               uint32_t parent_id, uint32_t storage_id)
 {
   PTPParams *params = (PTPParams *) device->params;
   PTP_USB *ptp_usb = (PTP_USB*) device->usbinfo;
   uint32_t parenthandle = 0;
   uint32_t store;
   PTPObjectInfo new_folder;
   uint16_t ret;
   uint32_t new_id = 0;
 
   if (storage_id == 0) {
     // I'm just guessing that a folder may require 512 bytes
-    store = get_writeable_storageid(device, 512);
+    store = get_suggested_storage_id(device, 512, parent_id);
   } else {
     store = storage_id;
   }
   parenthandle = parent_id;
 
   memset(&new_folder, 0, sizeof(new_folder));
   new_folder.Filename = name;
   if (FLAG_ONLY_7BIT_FILENAMES(ptp_usb)) {
     strip_7bit_from_utf8(new_folder.Filename);
   }
@@ skipping 286 matching lines @@
   //uint8_t data[2];
 
   // NULL check
   if (!name) {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "create_new_abstract_list(): list name was NULL, using default name \"Unknown\"");
     return -1;
   }
 
   if (storageid == 0) {
     // I'm just guessing that an abstract list may require 512 bytes
-    store = get_writeable_storageid(device, 512);
+    store = get_suggested_storage_id(device, 512, localph);
   } else {
     store = storageid;
   }
 
   // Check if we can create an object of this type
   for ( i=0; i < params->deviceinfo.ImageFormats_len; i++ ) {
     if (params->deviceinfo.ImageFormats[i] == objectformat) {
       supported = 1;
       break;
     }
@@ skipping 421 matching lines @@
                                   "could not set album artist name.");
         }
         break;
       case PTP_OPC_Artist:
         // Update artist
         ret = set_object_string(device, objecthandle, PTP_OPC_Artist, artist);
         if (ret != 0) {
           add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
                                   "could not set artist name.");
         }
+        break;
       case PTP_OPC_Composer:
         // Update composer
         ret = set_object_string(device, objecthandle, PTP_OPC_Composer, composer);
         if (ret != 0) {
           add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
                                   "could not set composer name.");
         }
         break;
       case PTP_OPC_Genre:
         // Update genre (but only if valid)
         if(genre) {
           ret = set_object_string(device, objecthandle, PTP_OPC_Genre, genre);
           if (ret != 0) {
             add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
                                     "could not set genre.");
           }
         }
         break;
       case PTP_OPC_DateModified:
         // Update date modified
         if (!FLAG_CANNOT_HANDLE_DATEMODIFIED(ptp_usb)) {
           char *tmpdate = get_iso8601_stamp();
           ret = set_object_string(device, objecthandle, PTP_OPC_DateModified, tmpdate);
           if (ret != 0) {
             add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
                                     "could not set modification date.");
           }
           free(tmpdate);
         }
+        break;
       default:
         break;
       }
     }
   } else {
     add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL, "update_abstract_list(): "
                             "Your device doesn't seem to support any known way of setting metadata.");
     free(properties);
     return -1;
   }
@@ skipping 829 matching lines @@
 {
   PTPParams *params = (PTPParams *) device->params;
   uint16_t ret;
 
   ret = ptp_getthumb(params, id, data, size);
   if (ret == PTP_RC_OK)
       return 0;
   return -1;
 }
 
+
+int LIBMTP_GetPartialObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
+                            uint64_t offset, uint32_t maxbytes,
+                            unsigned char **data, unsigned int *size)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  uint16_t ret;
+
+  if (!ptp_operation_issupported(params, PTP_OC_ANDROID_GetPartialObject64)) {
+    if  (!ptp_operation_issupported(params, PTP_OC_GetPartialObject)) {
+      add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+        "LIBMTP_GetPartialObject: PTP_OC_GetPartialObject not supported");
+      return -1;
+    }
+
+    if (offset >> 32 != 0) {
+      add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+        "LIBMTP_GetPartialObject: PTP_OC_GetPartialObject only supports 32bit offsets");
+      return -1;
+    }
+
+    ret = ptp_getpartialobject(params, id, (uint32_t)offset, maxbytes, data, size);
+  } else {
+    ret = ptp_android_getpartialobject64(params, id, offset, maxbytes, data, size);
+  }
+  if (ret == PTP_RC_OK)
+      return 0;
+  return -1;
+}
+
+
+int LIBMTP_SendPartialObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
+                             uint64_t offset, unsigned char *data, unsigned int size)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  uint16_t ret;
+
+  if (!ptp_operation_issupported(params, PTP_OC_ANDROID_SendPartialObject)) {
+    add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+      "LIBMTP_SendPartialObject: PTP_OC_ANDROID_SendPartialObject not supported");
+    return -1;
+  }
+
+  ret = ptp_android_sendpartialobject(params, id, offset, data, size);
+  if (ret == PTP_RC_OK)
+      return 0;
+  return -1;
+}
+
+
+int LIBMTP_BeginEditObject(LIBMTP_mtpdevice_t *device, uint32_t const id)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  uint16_t ret;
+
+  if (!ptp_operation_issupported(params, PTP_OC_ANDROID_BeginEditObject)) {
+    add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+      "LIBMTP_BeginEditObject: PTP_OC_ANDROID_BeginEditObject not supported");
+    return -1;
+  }
+
+  ret = ptp_android_begineditobject(params, id);
+  if (ret == PTP_RC_OK)
+      return 0;
+  return -1;
+}
+
+
+int LIBMTP_EndEditObject(LIBMTP_mtpdevice_t *device, uint32_t const id)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  uint16_t ret;
+
+  if (!ptp_operation_issupported(params, PTP_OC_ANDROID_EndEditObject)) {
+    add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+      "LIBMTP_EndEditObject: PTP_OC_ANDROID_EndEditObject not supported");
+    return -1;
+  }
+
+  ret = ptp_android_endeditobject(params, id);
+  if (ret == PTP_RC_OK) {
+      // update cached object properties if metadata cache exists
+      update_metadata_cache(device, id);
+      return 0;
+  }
+  return -1;
+}
+
+
+int LIBMTP_TruncateObject(LIBMTP_mtpdevice_t *device, uint32_t const id,
+                          uint64_t offset)
+{
+  PTPParams *params = (PTPParams *) device->params;
+  uint16_t ret;
+
+  if (!ptp_operation_issupported(params, PTP_OC_ANDROID_TruncateObject)) {
+    add_error_to_errorstack(device, LIBMTP_ERROR_GENERAL,
+      "LIBMTP_TruncateObject: PTP_OC_ANDROID_TruncateObject not supported");
+    return -1;
+  }
+
+  ret = ptp_android_truncate(params, id, offset);
+  if (ret == PTP_RC_OK)
+      return 0;
+  return -1;
+}
+
+
 /**
  * Get thumbnail format of a file.
  * @param device a pointer to the device to get thumbnail format of.
  * @param id the object ID of the file to get thumbnail format of.
  * @return 0 on success, any other value means failure.
  */
 int LIBMTP_Get_Thumbnail_Format(LIBMTP_mtpdevice_t *device, uint32_t const id,
                                 uint16_t *format)
 {
   PTPParams *params = (PTPParams *) device->params;
@@ skipping 66 matching lines @@
  * @param device the device which may have a cache to which the object should be updated.
  * @param object_id the object to update.
  */
 static void update_metadata_cache(LIBMTP_mtpdevice_t *device, uint32_t object_id)
 {
   PTPParams *params = (PTPParams *)device->params;
 
   ptp_remove_object_from_cache(params, object_id);
   add_object_to_cache(device, object_id);
 }