Uprev libmtp to 1.1.12

src/ptp.c

 /* ptp.c
  *
  * Copyright (C) 2001-2004 Mariusz Woloszyn <emsi@ipartners.pl>
  * Copyright (C) 2003-2012 Marcus Meissner <marcus@jet.franken.de>
  * Copyright (C) 2006-2008 Linus Walleij <triad@df.lth.se>
  * Copyright (C) 2007 Tero Saarni <tero.saarni@gmail.com>
  * Copyright (C) 2009 Axel Waggershauser <awagger@web.de>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA  02110-1301  USA
  */
 
-#define _BSD_SOURCE
+#define _DEFAULT_SOURCE
 #include "config.h"
 #include "ptp.h"
 
+#ifdef HAVE_LIBXML2
+# include <libxml/parser.h>
+#endif
+
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
-#include <unistd.h>
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
 
 #ifdef ENABLE_NLS
 #  include <libintl.h>
 #  undef _
 #  define _(String) dgettext (PACKAGE, String)
 #  ifdef gettext_noop
 #    define N_(String) gettext_noop (String)
 #  else
 #    define N_(String) (String)
 #  endif
 #else
 #  define textdomain(String) (String)
 #  define gettext(String) (String)
 #  define dgettext(Domain,Message) (Message)
 #  define dcgettext(Domain,Message,Type) (Message)
 #  define bindtextdomain(Domain,Directory) (Domain)
 #  define _(String) (String)
 #  define N_(String) (String)
 #endif
 
-#define CHECK_PTP_RC(result)    {uint16_t r=(result); if (r!=PTP_RC_OK) return r;}
+#define CHECK_PTP_RC(RESULT) do { uint16_t r = (RESULT); if (r != PTP_RC_OK) return r; } while(0)
 
-#define PTP_CNT_INIT(cnt) {memset(&cnt,0,sizeof(cnt));}
+static inline void
+ptp_init_container(PTPContainer* ptp, uint16_t code, int n_param, ...)
+{
+        va_list args;
+        int     i;
+
+        memset(ptp, 0, sizeof(*ptp));
+        ptp->Code = code;
+        ptp->Nparam = n_param;
+
+        va_start(args, n_param);
+        for (i=0; i<n_param; ++i)
+                (&ptp->Param1)[i] = va_arg(args, uint32_t);
+        va_end(args);
+}
+
+#define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
+#define NARGS(...) NARGS_SEQ(-1, ##__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1, 0)
+
+#define PTP_CNT_INIT(PTP, CODE, ...) \
+        ptp_init_container(&PTP, CODE, NARGS(__VA_ARGS__), ##__VA_ARGS__)
 
 static uint16_t ptp_exit_recv_memory_handler (PTPDataHandler*,unsigned char**,unsigned long*);
 static uint16_t ptp_init_recv_memory_handler(PTPDataHandler*);
 static uint16_t ptp_init_send_memory_handler(PTPDataHandler*,unsigned char*,unsigned long len);
 static uint16_t ptp_exit_send_memory_handler (PTPDataHandler *handler);
 
 void
 ptp_debug (PTPParams *params, const char *format, ...)
 {  
         va_list args;
@@ skipping 26 matching lines @@
         }
         va_end (args);
 }
 
 /* Pack / unpack functions */
 
 #include "ptp-pack.c"
 
 /* major PTP functions */
 
-/* Transaction data phase description */
-#define PTP_DP_NODATA           0x0000  /* no data phase */
-#define PTP_DP_SENDDATA         0x0001  /* sending data */
-#define PTP_DP_GETDATA          0x0002  /* receiving data */
-#define PTP_DP_DATA_MASK        0x00ff  /* data phase mask */
-
 /**
  * ptp_transaction:
  * params:      PTPParams*
  *              PTPContainer* ptp       - general ptp container
  *              uint16_t flags          - lower 8 bits - data phase description
  *              unsigned int sendlen    - senddata phase data length
  *              char** data             - send or receive data buffer pointer
  *              int* recvlen            - receive data length
  *
  * Performs PTP transaction. ptp is a PTPContainer with appropriate fields
  * filled in (i.e. operation code and parameters). It's up to caller to do
  * so.
  * The flags decide thether the transaction has a data phase and what is its
  * direction (send or receive). 
  * If transaction is sending data the sendlen should contain its length in
  * bytes, otherwise it's ignored.
  * The data should contain an address of a pointer to data going to be sent
  * or is filled with such a pointer address if data are received depending
  * od dataphase direction (send or received) or is beeing ignored (no
  * dataphase).
  * The memory for a pointer should be preserved by the caller, if data are
  * beeing retreived the appropriate amount of memory is beeing allocated
  * (the caller should handle that!).
  *
  * Return values: Some PTP_RC_* code.
  * Upon success PTPContainer* ptp contains PTP Response Phase container with
  * all fields filled in.
  **/
-static uint16_t
+uint16_t
 ptp_transaction_new (PTPParams* params, PTPContainer* ptp, 
-                uint16_t flags, unsigned int sendlen,
-                PTPDataHandler *handler
+                     uint16_t flags, uint64_t sendlen,
+                     PTPDataHandler *handler
 ) {
         int             tries;
         uint16_t        cmd;
 
         if ((params==NULL) || (ptp==NULL)) 
                 return PTP_ERROR_BADPARAM;
 
         cmd = ptp->Code;
         ptp->Transaction_ID=params->transaction_id++;
         ptp->SessionID=params->session_id;
         /* send request */
-        CHECK_PTP_RC(params->sendreq_func (params, ptp));
+        CHECK_PTP_RC(params->sendreq_func (params, ptp, flags));
         /* is there a dataphase? */
         switch (flags&PTP_DP_DATA_MASK) {
         case PTP_DP_SENDDATA:
                 {
-                        uint16_t ret;
-                        ret = params->senddata_func(params, ptp,
-                                                    sendlen, handler);
-                        if (ret == PTP_ERROR_CANCEL) {
-                                ret = params->cancelreq_func(params, 
-                                                             params->transaction_id-1);
-                                if (ret == PTP_RC_OK)
-                                        ret = PTP_ERROR_CANCEL;
-                        }
-                        if (ret != PTP_RC_OK)
-                                return ret;
+                        uint16_t ret = params->senddata_func(params, ptp, sendlen, handler);
+                        if (ret == PTP_ERROR_CANCEL)
+                                CHECK_PTP_RC(params->cancelreq_func(params, params->transaction_id-1));
+                        CHECK_PTP_RC(ret);
                 }
                 break;
         case PTP_DP_GETDATA:
                 {
-                        uint16_t ret;
-                        ret = params->getdata_func(params, ptp, handler);
-                        if (ret == PTP_ERROR_CANCEL) {
-                                ret = params->cancelreq_func(params, 
-                                                             params->transaction_id-1);
-                                if (ret == PTP_RC_OK)
-                                        ret = PTP_ERROR_CANCEL;
-                        }
-                        if (ret != PTP_RC_OK)
-                                return ret;
+                        uint16_t ret = params->getdata_func(params, ptp, handler);
+                        if (ret == PTP_ERROR_CANCEL)
+                                CHECK_PTP_RC(params->cancelreq_func(params, params->transaction_id-1));
+                        CHECK_PTP_RC(ret);
                 }
                 break;
         case PTP_DP_NODATA:
                 break;
         default:
                 return PTP_ERROR_BADPARAM;
         }
         tries = 3;
         while (tries--) {
                 uint16_t ret;
                 /* get response */
                 ret = params->getresp_func(params, ptp);
                 if (ret == PTP_ERROR_RESP_EXPECTED) {
                         ptp_debug (params,"PTP: response expected but not got, retrying.");
                         tries++;
                         continue;
                 }
-                if (ret != PTP_RC_OK)
-                        return ret;
-                
+                CHECK_PTP_RC(ret);
+
                 if (ptp->Transaction_ID < params->transaction_id-1) {
+                        /* The Leica uses Transaction ID 0 on result from CloseSession. */
+                        if (cmd == PTP_OC_CloseSession)
+                                break;
                         tries++;
                         ptp_debug (params,
                                 "PTP: Sequence number mismatch %d vs expected %d, suspecting old reply.",
                                 ptp->Transaction_ID, params->transaction_id-1
                         );
                         continue;
                 }
                 if (ptp->Transaction_ID != params->transaction_id-1) {
                         /* try to clean up potential left overs from previous session */
                         if ((cmd == PTP_OC_OpenSession) && tries)
@@ skipping 26 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);
                 if (!priv->data)
                         return PTP_RC_GeneralError;
                 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) {
+ptp_init_recv_memory_handler(PTPDataHandler *handler)
+{
         PTPMemHandlerPrivate* priv;
         priv = malloc (sizeof(PTPMemHandlerPrivate));
         if (!priv)
                 return PTP_RC_GeneralError;
         handler->priv = priv;
         handler->getfunc = memory_getfunc;
         handler->putfunc = memory_putfunc;
         priv->data = NULL;
         priv->size = 0;
         priv->curoff = 0;
@@ skipping 15 matching lines @@
         handler->getfunc = memory_getfunc;
         handler->putfunc = memory_putfunc;
         priv->data = data;
         priv->size = len;
         priv->curoff = 0;
         return PTP_RC_OK;
 }
 
 /* free private struct + data */
 static uint16_t
-ptp_exit_send_memory_handler (PTPDataHandler *handler) {
+ptp_exit_send_memory_handler (PTPDataHandler *handler)
+{
         PTPMemHandlerPrivate* priv = (PTPMemHandlerPrivate*)handler->priv;
         /* data is owned by caller */
         free (priv);
         return PTP_RC_OK;
 }
 
 /* hand over our internal data to caller */
 static uint16_t
 ptp_exit_recv_memory_handler (PTPDataHandler *handler,
         unsigned char **data, unsigned long *size
@@ skipping 21 matching lines @@
         got = read (priv->fd, data, wantlen);
         if (got != -1)
                 *gotlen = got;
         else
                 return PTP_RC_GeneralError;
         return PTP_RC_OK;
 }
 
 static uint16_t
 fd_putfunc(PTPParams* params, void* private,
-               unsigned long sendlen, unsigned char *data,
-               unsigned long *putlen
+               unsigned long sendlen, unsigned char *data
 ) {
-        int             written;
+        ssize_t         written;
         PTPFDHandlerPrivate* priv = (PTPFDHandlerPrivate*)private;
 
         written = write (priv->fd, data, sendlen);
-        if (written != -1)
-                *putlen = written;
-        else
-                return PTP_RC_GeneralError;
+        if (written != sendlen)
+                return PTP_ERROR_IO;
         return PTP_RC_OK;
 }
 
 static uint16_t
-ptp_init_fd_handler(PTPDataHandler *handler, int fd) {
+ptp_init_fd_handler(PTPDataHandler *handler, int fd)
+{
         PTPFDHandlerPrivate* priv;
         priv = malloc (sizeof(PTPFDHandlerPrivate));
         if (!priv)
                 return PTP_RC_GeneralError;
         handler->priv = priv;
         handler->getfunc = fd_getfunc;
         handler->putfunc = fd_putfunc;
         priv->fd = fd;
         return PTP_RC_OK;
 }
 
 static uint16_t
-ptp_exit_fd_handler (PTPDataHandler *handler) {
+ptp_exit_fd_handler (PTPDataHandler *handler)
+{
         PTPFDHandlerPrivate* priv = (PTPFDHandlerPrivate*)handler->priv;
         free (priv);
         return PTP_RC_OK;
 }
 
 /* Old style transaction, based on memory */
-static uint16_t
+/* A note on memory management:
+ * If called with the flag PTP_DP_GETDATA, this function will internally
+ * allocate memory as much as necessary. The caller has to free the memory
+ * returned in *data. If the function returns an error, it will free any
+ * memory it might have allocated. The recvlen may be NULL. After the
+ * function returns, *data will be initialized (valid memory pointer or NULL),
+ * i.e. it is not necessary to initialize *data or *recvlen beforehand.
+ */
+uint16_t
 ptp_transaction (PTPParams* params, PTPContainer* ptp, 
-                uint16_t flags, unsigned int sendlen,
+                uint16_t flags, uint64_t sendlen,
                 unsigned char **data, unsigned int *recvlen
 ) {
         PTPDataHandler  handler;
         uint16_t        ret;
 
         switch (flags & PTP_DP_DATA_MASK) {
         case PTP_DP_SENDDATA:
-                ptp_init_send_memory_handler (&handler, *data, sendlen);
+                if (!data)
+                        return PTP_ERROR_BADPARAM;
+                CHECK_PTP_RC(ptp_init_send_memory_handler (&handler, *data, sendlen));
                 break;
         case PTP_DP_GETDATA:
-                ptp_init_recv_memory_handler (&handler);
+                if (!data)
+                        return PTP_ERROR_BADPARAM;
+                *data = NULL;
+                if (recvlen)
+                        *recvlen = 0;
+                CHECK_PTP_RC(ptp_init_recv_memory_handler (&handler));
                 break;
         default:break;
         }
         ret = ptp_transaction_new (params, ptp, flags, sendlen, &handler);
         switch (flags & PTP_DP_DATA_MASK) {
         case PTP_DP_SENDDATA:
                 ptp_exit_send_memory_handler (&handler);
                 break;
         case PTP_DP_GETDATA: {
                 unsigned long len;
                 ptp_exit_recv_memory_handler (&handler, data, &len);
+                if (ret != PTP_RC_OK) {
+                        len = 0;
+                        free(*data);
+                        *data = NULL;
+                }
                 if (recvlen)
                         *recvlen = len;
                 break;
         }
         default:break;
         }
         return ret;
 }
 
 
 /**
  * PTP operation functions
  *
  * all ptp_ functions should take integer parameters
  * in host byte order!
  **/
 
 
 /**
  * ptp_getdeviceinfo:
  * params:      PTPParams*
  *
  * Gets device info dataset and fills deviceinfo structure.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getdeviceinfo (PTPParams* params, PTPDeviceInfo* deviceinfo)
 {
-        uint16_t        ret;
-        unsigned long   len;
         PTPContainer    ptp;
-        unsigned char*  di=NULL;
-        PTPDataHandler  handler;
-
-        ptp_init_recv_memory_handler (&handler);
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetDeviceInfo;
-        ptp.Nparam=0;
-        len=0;
-        ret=ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, &handler);
-        ptp_exit_recv_memory_handler (&handler, &di, &len);
-        if (!di) ret = PTP_RC_GeneralError;
-        if (ret == PTP_RC_OK) ptp_unpack_DI(params, di, deviceinfo, len);
-        free(di);
-        return ret;
+        unsigned char   *data;
+        unsigned int    size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_GetDeviceInfo);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_DI(params, data, deviceinfo, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_canon_eos_getdeviceinfo (PTPParams* params, PTPCanonEOSDeviceInfo*di)
 {
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetDeviceInfoEx);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_EOS_DI(params, data, di, size);
+        free (data);
+        return PTP_RC_OK;
+}
+
+#ifdef HAVE_LIBXML2
+static int
+traverse_tree (PTPParams *params, int depth, xmlNodePtr node)
+{
+        xmlNodePtr      next;
+        xmlChar         *xchar;
+        int             n;
+        char            *xx;
+
+
+        if (!node) return 0;
+        xx = malloc (depth * 4 + 1);
+        memset (xx, ' ', depth*4);
+        xx[depth*4] = 0;
+
+        n = xmlChildElementCount (node);
+
+        next = node;
+        do {
+                fprintf(stderr,"%snode %s\n", xx,next->name);
+                fprintf(stderr,"%selements %d\n", xx,n);
+                xchar = xmlNodeGetContent (next);
+                fprintf(stderr,"%scontent %s\n", xx,xchar);
+                traverse_tree (params, depth+1,xmlFirstElementChild (next));
+        } while ((next = xmlNextElementSibling (next)));
+        free (xx);
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_cmd_tree (PTPParams *params, xmlNodePtr node, PTPDeviceInfo *di)
+{
+        xmlNodePtr      next;
+        int             cnt;
+
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                cnt++;
+                next = xmlNextElementSibling (next);
+        }
+        di->OperationsSupported_len = cnt;
+        di->OperationsSupported = malloc (cnt*sizeof(di->OperationsSupported[0]));
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                unsigned int p;
+
+                sscanf((char*)next->name, "c%04x", &p);
+                ptp_debug( params, "cmd %s / 0x%04x", next->name, p);
+                di->OperationsSupported[cnt++] = p;
+                next = xmlNextElementSibling (next);
+        }
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_value (PTPParams *params, const char *str, uint16_t type, PTPPropertyValue *propval)
+{
+        switch (type) {
+        case 6: { /*UINT32*/
+                unsigned int x;
+                if (!sscanf(str,"%08x", &x)) {
+                        ptp_debug( params, "could not parse uint32 %s", str);
+                        return PTP_RC_GeneralError;
+                }
+                ptp_debug( params, "\t%d", x);
+                propval->u32 = x;
+                break;
+        }
+        case 5: { /*INT32*/
+                int x;
+                if (!sscanf(str,"%08x", &x)) {
+                        ptp_debug( params, "could not parse int32 %s", str);
+                        return PTP_RC_GeneralError;
+                }
+                ptp_debug( params, "\t%d", x);
+                propval->i32 = x;
+                break;
+        }
+        case 4: { /*UINT16*/
+                unsigned int x;
+                if (!sscanf(str,"%04x", &x)) {
+                        ptp_debug( params, "could not parse uint16 %s", str);
+                        return PTP_RC_GeneralError;
+                }
+                ptp_debug( params, "\t%d", x);
+                propval->u16 = x;
+                break;
+        }
+        case 3: { /*INT16*/
+                int x;
+                if (!sscanf(str,"%04x", &x)) {
+                        ptp_debug( params, "could not parse int16 %s", str);
+                        return PTP_RC_GeneralError;
+                }
+                ptp_debug( params, "\t%d", x);
+                propval->i16 = x;
+                break;
+        }
+        case 2: { /*UINT8*/
+                unsigned int x;
+                if (!sscanf(str,"%02x", &x)) {
+                        ptp_debug( params, "could not parse uint8 %s", str);
+                        return PTP_RC_GeneralError;
+                }
+                ptp_debug( params, "\t%d", x);
+                propval->u8 = x;
+                break;
+        }
+        case 1: { /*INT8*/
+                int x;
+                if (!sscanf(str,"%02x", &x)) {
+                        ptp_debug( params, "could not parse int8 %s", str);
+                        return PTP_RC_GeneralError;
+                } 
+                ptp_debug( params, "\t%d", x);
+                propval->i8 = x;
+                break;
+        }
+        case 65535: { /* string */
+                int len;
+
+                /* ascii ptp string, 1 byte length, little endian 16 bit chars */
+                if (sscanf(str,"%02x", &len)) {
+                        int i;
+                        char *xstr = malloc(len+1);
+                        for (i=0;i<len;i++) {
+                                int xc;
+                                if (sscanf(str+2+i*4,"%04x", &xc)) {
+                                        int cx;
+
+                                        cx = ((xc>>8) & 0xff) | ((xc & 0xff) << 8);
+                                        xstr[i] = cx;
+                                }
+                                xstr[len] = 0;
+                        }
+                        ptp_debug( params, "\t%s", xstr);
+                        propval->str = xstr;
+                        break;
+                }
+                ptp_debug( params, "string %s not parseable!", str);
+                return PTP_RC_GeneralError;
+        }
+        case 7: /*INT64*/
+        case 8: /*UINT64*/
+        case 9: /*INT128*/
+        case 10: /*UINT128*/
+        default:
+                ptp_debug( params, "unhandled data type %d!", type);
+                return PTP_RC_GeneralError;
+        }
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_propdesc (PTPParams *params, xmlNodePtr next, PTPDevicePropDesc *dpd)
+{
+        int type = -1;
+
+        if (!next)
+                return PTP_RC_GeneralError;
+
+        ptp_debug (params, "parse_9301_propdesc");
+        dpd->FormFlag   = PTP_DPFF_None;
+        dpd->GetSet     = PTP_DPGS_Get;
+        do {
+                if (!strcmp((char*)next->name,"type")) {        /* propdesc.DataType */
+                        if (!sscanf((char*)xmlNodeGetContent (next), "%04x", &type)) {
+                                ptp_debug( params, "\ttype %s not parseable?",xmlNodeGetContent (next));
+                                return 0;
+                        }
+                        ptp_debug( params, "type 0x%x", type);
+                        dpd->DataType = type;
+                        continue;
+                }
+                if (!strcmp((char*)next->name,"attribute")) {   /* propdesc.GetSet */
+                        int attr;
+
+                        if (!sscanf((char*)xmlNodeGetContent (next), "%02x", &attr)) {
+                                ptp_debug( params, "\tattr %s not parseable",xmlNodeGetContent (next));
+                                return 0;
+                        }
+                        ptp_debug( params, "attribute 0x%x", attr);
+                        dpd->GetSet = attr;
+                        continue;
+                }
+                if (!strcmp((char*)next->name,"default")) {     /* propdesc.FactoryDefaultValue */
+                        ptp_debug( params, "default value");
+                        parse_9301_value (params, (char*)xmlNodeGetContent (next), type, &dpd->FactoryDefaultValue);
+                        continue;
+                }
+                if (!strcmp((char*)next->name,"value")) {       /* propdesc.CurrentValue */
+                        ptp_debug( params, "current value");
+                        parse_9301_value (params, (char*)xmlNodeGetContent (next), type, &dpd->CurrentValue);
+                        continue;
+                }
+                if (!strcmp((char*)next->name,"enum")) {        /* propdesc.FORM.Enum */
+                        int n,i;
+                        char *s;
+
+                        ptp_debug( params, "enum");
+                        dpd->FormFlag = PTP_DPFF_Enumeration;
+                        s = (char*)xmlNodeGetContent (next);
+                        n = 0;
+                        do {
+                                s = strchr(s,' ');
+                                if (s) s++;
+                                n++;
+                        } while (s);
+                        dpd->FORM.Enum.NumberOfValues = n;
+                        dpd->FORM.Enum.SupportedValue = malloc (n * sizeof(PTPPropertyValue));
+                        s = (char*)xmlNodeGetContent (next);
+                        i = 0;
+                        do {
+                                parse_9301_value (params, s, type, &dpd->FORM.Enum.SupportedValue[i]); /* should turn ' ' into \0? */
+                                i++;
+                                s = strchr(s,' ');
+                                if (s) s++;
+                        } while (s && (i<n));
+                        continue;
+                }
+                if (!strcmp((char*)next->name,"range")) {       /* propdesc.FORM.Enum */
+                        char *s = (char*)xmlNodeGetContent (next);
+                        dpd->FormFlag = PTP_DPFF_Range;
+                        ptp_debug( params, "range");
+                        parse_9301_value (params, s, type, &dpd->FORM.Range.MinimumValue); /* should turn ' ' into \0? */
+                        s = strchr(s,' ');
+                        if (!s) continue;
+                        s++;
+                        parse_9301_value (params, s, type, &dpd->FORM.Range.MaximumValue); /* should turn ' ' into \0? */
+                        s = strchr(s,' ');
+                        if (!s) continue;
+                        s++;
+                        parse_9301_value (params, s, type, &dpd->FORM.Range.StepSize); /* should turn ' ' into \0? */
+
+                        continue;
+                }
+                ptp_debug (params, "\tpropdescvar: %s", next->name);
+                traverse_tree (params, 3, next);
+        } while ((next = xmlNextElementSibling (next)));
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_prop_tree (PTPParams *params, xmlNodePtr node, PTPDeviceInfo *di)
+{
+        xmlNodePtr      next;
+        int             cnt;
+        unsigned int    i;
+
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                cnt++;
+                next = xmlNextElementSibling (next);
+        }
+
+        di->DevicePropertiesSupported_len = cnt;
+        di->DevicePropertiesSupported = malloc (cnt*sizeof(di->DevicePropertiesSupported[0]));
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                unsigned int p;
+                PTPDevicePropDesc       dpd;
+
+                sscanf((char*)next->name, "p%04x", &p);
+                ptp_debug( params, "prop %s / 0x%04x", next->name, p);
+                parse_9301_propdesc (params, xmlFirstElementChild (next), &dpd);
+                dpd.DevicePropertyCode = p;
+                di->DevicePropertiesSupported[cnt++] = p;
+
+                /* add to cache of device propdesc */
+                for (i=0;i<params->nrofdeviceproperties;i++)
+                        if (params->deviceproperties[i].desc.DevicePropertyCode == p)
+                                break;
+                if (i == params->nrofdeviceproperties) {
+                        params->deviceproperties = realloc(params->deviceproperties,(i+1)*sizeof(params->deviceproperties[0]));
+                        memset(&params->deviceproperties[i],0,sizeof(params->deviceproperties[0]));
+                        params->nrofdeviceproperties++;
+                } else {
+                        ptp_free_devicepropdesc (&params->deviceproperties[i].desc);
+                }
+                /* FIXME: free old entry */
+                /* we are not using dpd, so copy it directly to the cache */
+                time( &params->deviceproperties[i].timestamp);
+                params->deviceproperties[i].desc = dpd;
+
+                next = xmlNextElementSibling (next);
+        }
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_event_tree (PTPParams *params, xmlNodePtr node, PTPDeviceInfo *di)
+{
+        xmlNodePtr      next;
+        int             cnt;
+
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                cnt++;
+                next = xmlNextElementSibling (next);
+        }
+        di->EventsSupported_len = cnt;
+        di->EventsSupported = malloc (cnt*sizeof(di->EventsSupported[0]));
+        cnt = 0;
+        next = xmlFirstElementChild (node);
+        while (next) {
+                unsigned int p;
+
+                sscanf((char*)next->name, "e%04x", &p);
+                ptp_debug( params, "event %s / 0x%04x", next->name, p);
+                di->EventsSupported[cnt++] = p;
+                next = xmlNextElementSibling (next);
+        }
+        return PTP_RC_OK;
+}
+
+static int
+parse_9301_tree (PTPParams *params, xmlNodePtr node, PTPDeviceInfo *di)
+{
+        xmlNodePtr      next;
+
+        next = xmlFirstElementChild (node);
+        while (next) {
+                if (!strcmp ((char*)next->name, "cmd")) {
+                        parse_9301_cmd_tree (params, next, di);
+                        next = xmlNextElementSibling (next);
+                        continue;
+                }
+                if (!strcmp ((char*)next->name, "prop")) {
+                        parse_9301_prop_tree (params, next, di);
+                        next = xmlNextElementSibling (next);
+                        continue;
+                }
+                if (!strcmp ((char*)next->name, "event")) {
+                        parse_9301_event_tree (params, next, di);
+                        next = xmlNextElementSibling (next);
+                        continue;
+                }
+                fprintf (stderr,"9301: unhandled type %s\n", next->name);
+                next = xmlNextElementSibling (next);
+        }
+        /*traverse_tree (0, node);*/
+        return PTP_RC_OK;
+}
+
+static uint16_t
+ptp_olympus_parse_output_xml(PTPParams* params, char*data, int len, xmlNodePtr *code)
+{
+        xmlDocPtr       docin;
+        xmlNodePtr      docroot, output, next;
+        int             result, xcode;
+
+        *code = NULL;
+
+        docin = xmlReadMemory ((char*)data, len, "http://gphoto.org/", "utf-8", 0);
+        if (!docin) return PTP_RC_GeneralError;
+        docroot = xmlDocGetRootElement (docin);
+        if (!docroot) {
+                xmlFreeDoc (docin);
+                return PTP_RC_GeneralError;
+        }
+
+        if (strcmp((char*)docroot->name,"x3c")) {
+                ptp_debug (params, "olympus: docroot is not x3c, but %s", docroot->name);
+                xmlFreeDoc (docin);
+                return PTP_RC_GeneralError;
+        }
+        if (xmlChildElementCount(docroot) != 1) {
+                ptp_debug (params, "olympus: x3c: expected 1 child, got %ld", xmlChildElementCount(docroot));
+                xmlFreeDoc (docin);
+                return PTP_RC_GeneralError;
+        }
+        output = xmlFirstElementChild (docroot);
+        if (strcmp((char*)output->name, "output") != 0) {
+                ptp_debug (params, "olympus: x3c node: expected child 'output', but got %s", (char*)output->name);
+                xmlFreeDoc (docin);
+                return PTP_RC_GeneralError;
+        }
+        next = xmlFirstElementChild (output);
+
+        result = PTP_RC_GeneralError;
+
+        while (next) {
+                if (!strcmp((char*)next->name,"result")) {
+                        xmlChar  *xchar;
+
+                        xchar = xmlNodeGetContent (next);
+                        if (!sscanf((char*)xchar,"%04x",&result))
+                                ptp_debug (params, "failed scanning result from %s", xchar);
+                        ptp_debug (params,  "ptp result is 0x%04x", result);
+                        next = xmlNextElementSibling (next);
+                        continue;
+                }
+                if (sscanf((char*)next->name,"c%x", &xcode)) {
+                        ptp_debug (params,  "ptp code node found %s", (char*)next->name);
+                        *code = next;
+                        next = xmlNextElementSibling (next);
+                        continue;
+                }
+                ptp_debug (params, "unhandled node %s", (char*)next->name);
+                next = xmlNextElementSibling (next);
+        }
+
+        if (result != PTP_RC_OK) {
+                *code = NULL;
+                xmlFreeDoc (docin);
+        }
+        return result;
+}
+#endif
+
+uint16_t
+ptp_olympus_getdeviceinfo (PTPParams* params, PTPDeviceInfo *di)
+{
+#ifdef HAVE_LIBXML2
+        PTPContainer    ptp;
         uint16_t        ret;
+        unsigned char   *data;
+        unsigned int    size;
+        xmlNodePtr      code;
+
+        memset (di, 0, sizeof(PTPDeviceInfo));
+
+        PTP_CNT_INIT(ptp, PTP_OC_OLYMPUS_GetDeviceInfo);
+        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
+        /* TODO: check for error, only parse_output_xml if ret == PTP_RC_OK?
+         * where is 'data' going to be deallocated? */
+        ret = ptp_olympus_parse_output_xml(params,(char*)data,size,&code);
+        if (ret != PTP_RC_OK)
+                return ret;
+
+        ret = parse_9301_tree (params, code, di);
+
+        xmlFreeDoc(code->doc);
+        return ret;
+#else
+        return PTP_RC_GeneralError;
+#endif
+}
+
+uint16_t
+ptp_olympus_opensession (PTPParams* params, unsigned char**data, unsigned int *len)
+{
         PTPContainer    ptp;
-        PTPDataHandler  handler;
-        unsigned long   len;
-        unsigned char   *data;
-
-        ptp_init_recv_memory_handler (&handler);
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_EOS_GetDeviceInfoEx;
-        ptp.Nparam=0;
-        len=0;
-        data=NULL;
-        ret=ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, &handler);
-        ptp_exit_recv_memory_handler (&handler, &data, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_EOS_DI(params, data, di, len);
-        free (data);
-        return ret;
+
+        PTP_CNT_INIT(ptp, PTP_OC_OLYMPUS_OpenSession);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, len);
+}
+
+uint16_t
+ptp_olympus_getcameraid (PTPParams* params, unsigned char**data, unsigned int *len)
+{
+        PTPContainer    ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_OLYMPUS_GetCameraID);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, len);
 }
 
 /**
  * ptp_generic_no_data:
  * params:      PTPParams*
  *              code    PTP OP Code
  *              n_param count of parameters
  *              ... variable argument list ...
  *
  * Emits a generic PTP command without any data transfer.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_generic_no_data (PTPParams* params, uint16_t code, unsigned int n_param, ...)
 {
-        PTPContainer ptp;
-        va_list args;
-        int i;
+        PTPContainer    ptp;
+        va_list         args;
+        unsigned int    i;
 
         if( n_param > 5 )
-                return PTP_RC_InvalidParameter;
+                return PTP_ERROR_BADPARAM;
 
-        PTP_CNT_INIT(ptp);
+        memset(&ptp, 0, sizeof(ptp));
         ptp.Code=code;
         ptp.Nparam=n_param;
 
         va_start(args, n_param);
         for( i=0; i<n_param; ++i )
                 (&ptp.Param1)[i] = va_arg(args, uint32_t);
         va_end(args);
 
         return ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
 }
 
 /**
  * ptp_opensession:
  * params:      PTPParams*
  *              session                 - session number 
  *
  * Establishes a new session.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_opensession (PTPParams* params, uint32_t session)
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
+        uint16_t        ret;
 
         ptp_debug(params,"PTP: Opening session");
 
         /* SessonID field of the operation dataset should always
            be set to 0 for OpenSession request! */
         params->session_id=0x00000000;
         /* TransactionID should be set to 0 also! */
         params->transaction_id=0x0000000;
         /* zero out response packet buffer */
         params->response_packet = NULL;
         params->response_packet_size = 0;
         /* no split headers */
         params->split_header_data = 0;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_OpenSession;
-        ptp.Param1=session;
-        ptp.Nparam=1;
+        PTP_CNT_INIT(ptp, PTP_OC_OpenSession, session);
         ret=ptp_transaction_new(params, &ptp, PTP_DP_NODATA, 0, NULL);
+        /* TODO: check for error */
         /* now set the global session id to current session number */
         params->session_id=session;
         return ret;
 }
 
+void
+ptp_free_devicepropvalue(uint16_t dt, PTPPropertyValue* dpd)
+{
+        switch (dt) {
+        case PTP_DTC_INT8:      case PTP_DTC_UINT8:
+        case PTP_DTC_UINT16:    case PTP_DTC_INT16:
+        case PTP_DTC_UINT32:    case PTP_DTC_INT32:
+        case PTP_DTC_UINT64:    case PTP_DTC_INT64:
+        case PTP_DTC_UINT128:   case PTP_DTC_INT128:
+                /* Nothing to free */
+                break;
+        case PTP_DTC_AINT8:     case PTP_DTC_AUINT8:
+        case PTP_DTC_AUINT16:   case PTP_DTC_AINT16:
+        case PTP_DTC_AUINT32:   case PTP_DTC_AINT32:
+        case PTP_DTC_AUINT64:   case PTP_DTC_AINT64:
+        case PTP_DTC_AUINT128:  case PTP_DTC_AINT128:
+                free(dpd->a.v);
+                break;
+        case PTP_DTC_STR:
+                free(dpd->str);
+                break;
+        }
+}
+
+void
+ptp_free_devicepropdesc(PTPDevicePropDesc* dpd)
+{
+        uint16_t i;
+
+        ptp_free_devicepropvalue (dpd->DataType, &dpd->FactoryDefaultValue);
+        ptp_free_devicepropvalue (dpd->DataType, &dpd->CurrentValue);
+        switch (dpd->FormFlag) {
+        case PTP_DPFF_Range:
+                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.MinimumValue);
+                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.MaximumValue);
+                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.StepSize);
+                break;
+        case PTP_DPFF_Enumeration:
+                if (dpd->FORM.Enum.SupportedValue) {
+                        for (i=0;i<dpd->FORM.Enum.NumberOfValues;i++)
+                                ptp_free_devicepropvalue (dpd->DataType, dpd->FORM.Enum.SupportedValue+i);
+                        free (dpd->FORM.Enum.SupportedValue);
+                }
+        }
+        dpd->DataType = PTP_DTC_UNDEF;
+        dpd->FormFlag = PTP_DPFF_None;
+}
+
+
+void
+ptp_free_objectpropdesc(PTPObjectPropDesc* opd)
+{
+        uint16_t i;
+
+        ptp_free_devicepropvalue (opd->DataType, &opd->FactoryDefaultValue);
+        switch (opd->FormFlag) {
+        case PTP_OPFF_None:
+                break;
+        case PTP_OPFF_Range:
+                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.MinimumValue);
+                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.MaximumValue);
+                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.StepSize);
+                break;
+        case PTP_OPFF_Enumeration:
+                if (opd->FORM.Enum.SupportedValue) {
+                        for (i=0;i<opd->FORM.Enum.NumberOfValues;i++)
+                                ptp_free_devicepropvalue (opd->DataType, opd->FORM.Enum.SupportedValue+i);
+                        free (opd->FORM.Enum.SupportedValue);
+                }
+                break;
+        case PTP_OPFF_DateTime:
+        case PTP_OPFF_FixedLengthArray:
+        case PTP_OPFF_RegularExpression:
+        case PTP_OPFF_ByteArray:
+        case PTP_OPFF_LongString:
+                /* Ignore these presently, we cannot unpack them, so there is nothing to be freed. */
+                break;
+        default:
+                fprintf (stderr, "Unknown OPFF type %d\n", opd->FormFlag);
+                break;
+        }
+}
+
+
 /**
  * ptp_free_params:
  * params:      PTPParams*
  *
  * Frees all data within the PTPParams struct.
  *
  * Return values: Some PTP_RC_* code.
  **/
 void
-ptp_free_params (PTPParams *params) {
-        int i;
+ptp_free_params (PTPParams *params)
+{
+        unsigned int i;
 
-        if (params->cameraname) free (params->cameraname);
-        if (params->wifi_profiles) free (params->wifi_profiles);
+        free (params->cameraname);
+        free (params->wifi_profiles);
         for (i=0;i<params->nrofobjects;i++)
                 ptp_free_object (&params->objects[i]);
         free (params->objects);
         free (params->events);
         for (i=0;i<params->nrofcanon_props;i++) {
                 free (params->canon_props[i].data);
                 ptp_free_devicepropdesc (&params->canon_props[i].dpd);
         }
         free (params->canon_props);
         free (params->backlogentries);
+
+        for (i=0;i<params->nrofdeviceproperties;i++)
+                ptp_free_devicepropdesc (&params->deviceproperties[i].desc);
+        free (params->deviceproperties);
+
         ptp_free_DI (&params->deviceinfo);
 }
 
 /**
  * ptp_getststorageids:
  * params:      PTPParams*
  *
  * Gets array of StorageIDs and fills the storageids structure.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getstorageids (PTPParams* params, PTPStorageIDs* storageids)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned int len;
-        unsigned char* sids=NULL;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetStorageIDs;
-        ptp.Nparam=0;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &sids, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_SIDs(params, sids, storageids, len);
-        free(sids);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_GetStorageIDs);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_SIDs(params, data, storageids, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_getststorageinfo:
  * params:      PTPParams*
  *              storageid               - StorageID
  *
  * Gets StorageInfo dataset of desired storage and fills storageinfo
  * structure.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getstorageinfo (PTPParams* params, uint32_t storageid,
                         PTPStorageInfo* storageinfo)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* si=NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetStorageInfo;
-        ptp.Param1=storageid;
-        ptp.Nparam=1;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &si, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_SI(params, si, storageinfo, len);
-        free(si);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_GetStorageInfo, storageid);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_SI(params, data, storageinfo, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_getobjecthandles:
  * params:      PTPParams*
  *              storage                 - StorageID
  *              objectformatcode        - ObjectFormatCode (optional)
  *              associationOH           - ObjectHandle of Association for
  *                                        wich a list of children is desired
  *                                        (optional)
  *              objecthandles           - pointer to structute
  *
  * Fills objecthandles with structure returned by device.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getobjecthandles (PTPParams* params, uint32_t storage,
                         uint32_t objectformatcode, uint32_t associationOH,
                         PTPObjectHandles* objecthandles)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* oh=NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetObjectHandles;
-        ptp.Param1=storage;
-        ptp.Param2=objectformatcode;
-        ptp.Param3=associationOH;
-        ptp.Nparam=3;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &oh, &len);
+        PTP_CNT_INIT(ptp, PTP_OC_GetObjectHandles, storage, objectformatcode, associationOH);
+        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
         if (ret == PTP_RC_OK) {
-                ptp_unpack_OH(params, oh, objecthandles, len);
+                ptp_unpack_OH(params, data, objecthandles, size);
         } else {
                 if (    (storage == 0xffffffff) &&
                         (objectformatcode == 0) &&
                         (associationOH == 0)
                 ) {
                         /* When we query all object handles on all stores and
                          * get an error -> just handle it as "0 handles".
                          */
                         objecthandles->Handler = NULL;
                         objecthandles->n = 0;
                         ret = PTP_RC_OK;
                 }
         }
-        free(oh);
+        free(data);
         return ret;
 }
 
 uint16_t
 ptp_getfilesystemmanifest (PTPParams* params, uint32_t storage,
                         uint32_t objectformatcode, uint32_t associationOH,
                         unsigned char** data)
 {
-        uint16_t ret;
         PTPContainer ptp;
-        unsigned int len;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetFilesystemManifest;
-        ptp.Param1=storage;
-        ptp.Param2=objectformatcode;
-        ptp.Param3=associationOH;
-        ptp.Nparam=3;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, &len);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_GetFilesystemManifest, storage, objectformatcode, associationOH);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, NULL);
 }
 
 /**
  * ptp_getnumobjects:
  * params:      PTPParams*
  *              storage                 - StorageID
  *              objectformatcode        - ObjectFormatCode (optional)
  *              associationOH           - ObjectHandle of Association for
  *                                        wich a list of children is desired
  *                                        (optional)
  *              numobs                  - pointer to uint32_t that takes number of objects
  *
  * Fills numobs with number of objects on device.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getnumobjects (PTPParams* params, uint32_t storage,
                         uint32_t objectformatcode, uint32_t associationOH,
                         uint32_t* numobs)
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetNumObjects;
-        ptp.Param1=storage;
-        ptp.Param2=objectformatcode;
-        ptp.Param3=associationOH;
-        ptp.Nparam=3;
-        ret=ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if (ret == PTP_RC_OK) {
-                if (ptp.Nparam >= 1)
-                        *numobs = ptp.Param1;
-                else
-                        ret = PTP_RC_GeneralError;
-        }
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_GetNumObjects, storage, objectformatcode, associationOH);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        if (ptp.Nparam >= 1)
+                *numobs = ptp.Param1;
+        else
+                return PTP_RC_GeneralError;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_eos_bulbstart:
  * params:      PTPParams*
  *
  * Starts EOS Bulb capture.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_canon_eos_bulbstart (PTPParams* params)
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_EOS_BulbStart;
-        ptp.Nparam = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if ((ret == PTP_RC_OK) && (ptp.Nparam >= 1) && ((ptp.Param1 & 0x7000) == 0x2000))
-                ret = ptp.Param1;
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_BulbStart);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        if ((ptp.Nparam >= 1) && ((ptp.Param1 & 0x7000) == 0x2000))
+                return ptp.Param1;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_eos_capture:
  * params:      PTPParams*
  *              uint32_t*       result
  *
  * This starts a EOS400D style capture. You have to use the
  * get_eos_events to find out what resulted.
  * The return value is "0" for all OK, and "1" for capture failed. (not fully confirmed)
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_canon_eos_capture (PTPParams* params, uint32_t *result)
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_EOS_RemoteRelease;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_RemoteRelease);
         *result = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if ((ret == PTP_RC_OK) && (ptp.Nparam >= 1))
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        if (ptp.Nparam >= 1)
                 *result = ptp.Param1;
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_canon_eos_bulbend:
  * params:      PTPParams*
  *
  * Starts EOS Bulb capture.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_canon_eos_bulbend (PTPParams* params)
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_EOS_BulbEnd;
-        ptp.Nparam = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if ((ret == PTP_RC_OK) && (ptp.Nparam >= 1) && ((ptp.Param1 & 0x7000) == 0x2000))
-                ret = ptp.Param1;
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_BulbEnd);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        if ((ptp.Nparam >= 1) && ((ptp.Param1 & 0x7000) == 0x2000))
+                return ptp.Param1;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_getobjectinfo:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              objectinfo              - pointer to objectinfo that is returned
  *
  * Get objectinfo structure for handle from device.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getobjectinfo (PTPParams* params, uint32_t handle,
                         PTPObjectInfo* objectinfo)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* oi=NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetObjectInfo;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &oi, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_OI(params, oi, objectinfo, len);
-        free(oi);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_GetObjectInfo, handle);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_OI(params, data, objectinfo, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_getobject:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              object                  - pointer to data area
  *
  * Get object 'handle' from device and store the data in newly
  * allocated 'object'.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getobject (PTPParams* params, uint32_t handle, unsigned char** object)
 {
         PTPContainer ptp;
-        unsigned int len;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetObject;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
-        len=0;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, object, &len);
+        PTP_CNT_INIT(ptp, PTP_OC_GetObject, handle);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, object, NULL);
 }
 
 /**
  * ptp_getobject_to_handler:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              PTPDataHandler*         - pointer datahandler
  *
  * Get object 'handle' from device and store the data in newly
  * allocated 'object'.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getobject_to_handler (PTPParams* params, uint32_t handle, PTPDataHandler *handler)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetObject;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
+        PTP_CNT_INIT(ptp, PTP_OC_GetObject, handle);
         return ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, handler);
 }
 
 /**
  * ptp_getobject_tofd:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              fd                      - File descriptor to write() to
  *
  * Get object 'handle' from device and write the data to the 
  * given file descriptor.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getobject_tofd (PTPParams* params, uint32_t handle, int fd)
 {
         PTPContainer    ptp;
         PTPDataHandler  handler;
         uint16_t        ret;
 
+        PTP_CNT_INIT(ptp, PTP_OC_GetObject, handle);
         ptp_init_fd_handler (&handler, fd);
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetObject;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
         ret = ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, &handler);
         ptp_exit_fd_handler (&handler);
         return ret;
 }
 
 /**
  * ptp_getpartialobject:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              offset                  - Offset into object
  *              maxbytes                - Maximum of bytes to read
  *              object                  - pointer to data area
  *              len                     - pointer to returned length
  *
  * Get object 'handle' from device and store the data in newly
  * allocated 'object'. Start from offset and read at most maxbytes.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getpartialobject (PTPParams* params, uint32_t handle, uint32_t offset,
                         uint32_t maxbytes, unsigned char** object,
                         uint32_t *len)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetPartialObject;
-        ptp.Param1=handle;
-        ptp.Param2=offset;
-        ptp.Param3=maxbytes;
-        ptp.Nparam=3;
-        *len=0;
+        PTP_CNT_INIT(ptp, PTP_OC_GetPartialObject, handle, offset, maxbytes);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, object, len);
 }
 
 /**
+ * ptp_getpartialobject_to_handler:
+ * params:      PTPParams*
+ *              handle                  - Object handle
+ *              offset                  - Offset into object
+ *              maxbytes                - Maximum of bytes to read
+ *              handler                 - a ptp data handler
+ *
+ * Get object 'handle' from device and send the data to the
+ * data handler. Start from offset and read at most maxbytes.
+ *
+ * Return values: Some PTP_RC_* code.
+ **/
+uint16_t
+ptp_getpartialobject_to_handler (PTPParams* params, uint32_t handle, uint32_t offset,
+                        uint32_t maxbytes, PTPDataHandler *handler)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_GetPartialObject, handle, offset, maxbytes);
+        return ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, handler);
+}
+
+/**
  * ptp_getthumb:
  * params:      PTPParams*
  *              handle                  - Object handle
  *              object                  - pointer to data area
  *
  * Get thumb for object 'handle' from device and store the data in newly
  * allocated 'object'.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_getthumb (PTPParams* params, uint32_t handle, unsigned char** object, unsigned int *len)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetThumb;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
-        *len = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_GetThumb, handle);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, object, len);
 }
 
 /**
  * ptp_deleteobject:
  * params:      PTPParams*
  *              handle                  - object handle
  *              ofc                     - object format code (optional)
  * 
  * Deletes desired objects.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
 ptp_deleteobject (PTPParams* params, uint32_t handle, uint32_t ofc)
 {
         PTPContainer ptp;
-        uint16_t ret;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_DeleteObject;
-        ptp.Param1=handle;
-        ptp.Param2=ofc;
-        ptp.Nparam=2;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if (ret != PTP_RC_OK) {
-                return ret;
-        }
+        PTP_CNT_INIT(ptp, PTP_OC_DeleteObject, handle, ofc);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
         /* If the object is cached and could be removed, cleanse cache. */
         ptp_remove_object_from_cache(params, handle);
         return PTP_RC_OK;
 }
 
 /**
  * ptp_sendobjectinfo:
  * params:      PTPParams*
  *              uint32_t* store         - destination StorageID on Responder
  *              uint32_t* parenthandle  - Parent ObjectHandle on responder
  *              uint32_t* handle        - see Return values
  *              PTPObjectInfo* objectinfo- ObjectInfo that is to be sent
  * 
  * Sends ObjectInfo of file that is to be sent via SendFileObject.
  *
  * Return values: Some PTP_RC_* code.
  * Upon success : uint32_t* store       - Responder StorageID in which
  *                                        object will be stored
  *                uint32_t* parenthandle- Responder Parent ObjectHandle
  *                                        in which the object will be stored
  *                uint32_t* handle      - Responder's reserved ObjectHandle
  *                                        for the incoming object
  **/
 uint16_t
 ptp_sendobjectinfo (PTPParams* params, uint32_t* store, 
                         uint32_t* parenthandle, uint32_t* handle,
                         PTPObjectInfo* objectinfo)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* oidata=NULL;
-        uint32_t size;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_SendObjectInfo;
-        ptp.Param1=*store;
-        ptp.Param2=*parenthandle;
-        ptp.Nparam=2;
-        
-        size=ptp_pack_OI(params, objectinfo, &oidata);
-        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &oidata, NULL); 
-        free(oidata);
+        PTP_CNT_INIT(ptp, PTP_OC_SendObjectInfo, *store, *parenthandle);
+        size = ptp_pack_OI(params, objectinfo, &data);
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
         *store=ptp.Param1;
         *parenthandle=ptp.Param2;
         *handle=ptp.Param3; 
         return ret;
 }
 
 /**
  * ptp_sendobject:
  * params:      PTPParams*
  *              char*   object          - contains the object that is to be sent
- *              uint32_t size           - object size
+ *              uint64_t size           - object size
  *              
  * Sends object to Responder.
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
-ptp_sendobject (PTPParams* params, unsigned char* object, uint32_t size)
+ptp_sendobject (PTPParams* params, unsigned char* object, uint64_t size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_SendObject;
-        ptp.Nparam=0;
-
+        PTP_CNT_INIT(ptp, PTP_OC_SendObject);
         return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &object, NULL);
 }
 
 /**
  * ptp_sendobject_from_handler:
  * params:      PTPParams*
  *              PTPDataHandler*         - File descriptor to read() object from
- *              uint32_t size           - File/object size
+ *              uint64_t size           - File/object size
  *
  * Sends object from file descriptor by consecutive reads from this
  * descriptor.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
-ptp_sendobject_from_handler (PTPParams* params, PTPDataHandler *handler, uint32_t size)
+ptp_sendobject_from_handler (PTPParams* params, PTPDataHandler *handler, uint64_t size)
 {
-        PTPContainer    ptp;
+        PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_SendObject;
-        ptp.Nparam=0;
+        PTP_CNT_INIT(ptp, PTP_OC_SendObject);
         return ptp_transaction_new(params, &ptp, PTP_DP_SENDDATA, size, handler);
 }
 
 
 /**
  * ptp_sendobject_fromfd:
  * params:      PTPParams*
  *              fd                      - File descriptor to read() object from
- *              uint32_t size           - File/object size
+ *              uint64_t size           - File/object size
  *
  * Sends object from file descriptor by consecutive reads from this
  * descriptor.
  *
  * Return values: Some PTP_RC_* code.
  **/
 uint16_t
-ptp_sendobject_fromfd (PTPParams* params, int fd, uint32_t size)
+ptp_sendobject_fromfd (PTPParams* params, int fd, uint64_t size)
 {
         PTPContainer    ptp;
         PTPDataHandler  handler;
         uint16_t        ret;
 
+        PTP_CNT_INIT(ptp, PTP_OC_SendObject);
         ptp_init_fd_handler (&handler, fd);
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_SendObject;
-        ptp.Nparam=0;
         ret = ptp_transaction_new(params, &ptp, PTP_DP_SENDDATA, size, &handler);
         ptp_exit_fd_handler (&handler);
         return ret;
 }
 
+#define PROPCACHE_TIMEOUT 5     /* seconds */
 
 uint16_t
 ptp_getdevicepropdesc (PTPParams* params, uint16_t propcode, 
                         PTPDevicePropDesc* devicepropertydesc)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned int len;
-        unsigned char* dpd=NULL;
+        PTPContainer    ptp;
+        uint16_t        ret = PTP_RC_OK;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetDevicePropDesc;
-        ptp.Param1=propcode;
-        ptp.Nparam=1;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &dpd, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_DPD(params, dpd, devicepropertydesc, len);
-        free(dpd);
+        PTP_CNT_INIT(ptp, PTP_OC_GetDevicePropDesc, propcode);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+
+        if (params->device_flags & DEVICE_FLAG_OLYMPUS_XML_WRAPPED) {
+#ifdef HAVE_LIBXML2
+                xmlNodePtr      code;
+
+                ret = ptp_olympus_parse_output_xml (params,(char*)data,size,&code);
+                if (ret == PTP_RC_OK) {
+                        int x;
+
+                        if (    (xmlChildElementCount(code) == 1) &&
+                                        (!strcmp((char*)code->name,"c1014"))
+                                        ) {
+                                code = xmlFirstElementChild (code);
+
+                                if (    (sscanf((char*)code->name,"p%x", &x)) &&
+                                                (x == propcode)
+                                                ) {
+                                        ret = parse_9301_propdesc (params, xmlFirstElementChild (code), devicepropertydesc);
+                                        xmlFreeDoc(code->doc);
+                                }
+                        }
+                } else {
+                        ptp_debug(params,"failed to parse output xml, ret %x?", ret);
+                }
+#endif
+        } else {
+                ptp_unpack_DPD(params, data, devicepropertydesc, size);
+        }
+        free(data);
         return ret;
 }
 
 
 uint16_t
 ptp_getdevicepropvalue (PTPParams* params, uint16_t propcode,
                         PTPPropertyValue* value, uint16_t datatype)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned int len;
-        int offset;
-        unsigned char* dpv=NULL;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size, offset = 0;
+        uint16_t        ret;
 
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_GetDevicePropValue;
-        ptp.Param1=propcode;
-        ptp.Nparam=1;
-        len=offset=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &dpv, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_DPV(params, dpv, &offset, len, value, datatype);
-        free(dpv);
+        PTP_CNT_INIT(ptp, PTP_OC_GetDevicePropValue, propcode);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ret = ptp_unpack_DPV(params, data, &offset, size, value, datatype) ? PTP_RC_OK : PTP_RC_GeneralError;
+        if (ret != PTP_RC_OK)
+                ptp_debug (params, "ptp_getdevicepropvalue: unpacking DPV failed");
+        free(data);
         return ret;
 }
 
 uint16_t
 ptp_setdevicepropvalue (PTPParams* params, uint16_t propcode,
                         PTPPropertyValue *value, uint16_t datatype)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        uint32_t size;
-        unsigned char* dpv=NULL;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_SetDevicePropValue;
-        ptp.Param1=propcode;
-        ptp.Nparam=1;
-        size=ptp_pack_DPV(params, value, &dpv, datatype);
-        ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &dpv, NULL);
-        free(dpv);
+        PTP_CNT_INIT(ptp, PTP_OC_SetDevicePropValue, propcode);
+        size=ptp_pack_DPV(params, value, &data, datatype);
+        ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
         return ret;
 }
 
 /**
  * ptp_ek_sendfileobjectinfo:
  * params:      PTPParams*
  *              uint32_t* store         - destination StorageID on Responder
  *              uint32_t* parenthandle  - Parent ObjectHandle on responder
  *              uint32_t* handle        - see Return values
  *              PTPObjectInfo* objectinfo- ObjectInfo that is to be sent
  * 
  * Sends ObjectInfo of file that is to be sent via SendFileObject.
  *
  * Return values: Some PTP_RC_* code.
  * Upon success : uint32_t* store       - Responder StorageID in which
  *                                        object will be stored
  *                uint32_t* parenthandle- Responder Parent ObjectHandle
  *                                        in which the object will be stored
  *                uint32_t* handle      - Responder's reserved ObjectHandle
  *                                        for the incoming object
  **/
 uint16_t
 ptp_ek_sendfileobjectinfo (PTPParams* params, uint32_t* store, 
                         uint32_t* parenthandle, uint32_t* handle,
                         PTPObjectInfo* objectinfo)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* oidata=NULL;
-        uint32_t size;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_EK_SendFileObjectInfo;
-        ptp.Param1=*store;
-        ptp.Param2=*parenthandle;
-        ptp.Nparam=2;
-        
-        size=ptp_pack_OI(params, objectinfo, &oidata);
-        ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &oidata, NULL); 
-        free(oidata);
+        PTP_CNT_INIT(ptp, PTP_OC_EK_SendFileObjectInfo, *store, *parenthandle);
+        size=ptp_pack_OI(params, objectinfo, &data);
+        ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
         *store=ptp.Param1;
         *parenthandle=ptp.Param2;
         *handle=ptp.Param3; 
         return ret;
 }
 
 /**
  * ptp_ek_getserial:
  * params:      PTPParams*
  *              char**  serial          - contains the serial number of the camera
  *              uint32_t* size          - contains the string length
  *              
  * Gets the serial number from the device. (ptp serial)
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_ek_getserial (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_EK_GetSerial;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_EK_GetSerial);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
 }
 
 /**
  * ptp_ek_setserial:
  * params:      PTPParams*
  *              char*   serial          - contains the new serial number
  *              uint32_t size           - string length
  *              
  * Sets the serial number of the device. (ptp serial)
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_ek_setserial (PTPParams* params, unsigned char *data, unsigned int size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_EK_SetSerial;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_EK_SetSerial);
         return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL); 
 }
 
 /* unclear what it does yet */
 uint16_t
 ptp_ek_9007 (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = 0x9007;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, 0x9007);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
 }
 
 /* unclear what it does yet */
 uint16_t
 ptp_ek_9009 (PTPParams* params, uint32_t *p1, uint32_t *p2)
 {
         PTPContainer    ptp;
-        uint16_t        ret;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = 0x9009;
-        ptp.Nparam = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL); 
+        PTP_CNT_INIT(ptp, 0x9009);
+        *p1 = *p2 = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
         *p1 = ptp.Param1;
         *p2 = ptp.Param2;
-        return ret;
+        return PTP_RC_OK;
 }
 
 /* unclear yet, but I guess it returns the info from 9008 */
 uint16_t
 ptp_ek_900c (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = 0x900c;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, 0x900c);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
         /* returned data is 16bit,16bit,32bit,32bit */
 }
 
 /**
  * ptp_ek_settext:
  * params:      PTPParams*
  *              PTPEKTextParams*        - contains the texts to display.
  *              
  * Displays the specified texts on the TFT of the camera.
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_ek_settext (PTPParams* params, PTPEKTextParams *text)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned int size;
-        unsigned char *data;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = 0;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_EK_SetText;
-        ptp.Nparam = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_EK_SetText);
         if (0 == (size = ptp_pack_EK_text(params, text, &data)))
                 return PTP_ERROR_BADPARAM;
-        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL); 
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
         free(data);
         return ret;
 }
 
 /**
  * ptp_ek_sendfileobject:
  * params:      PTPParams*
  *              char*   object          - contains the object that is to be sent
  *              uint32_t size           - object size
  *              
  * Sends object to Responder.
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_ek_sendfileobject (PTPParams* params, unsigned char* object, uint32_t size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_EK_SendFileObject;
-        ptp.Nparam=0;
-
+        PTP_CNT_INIT(ptp, PTP_OC_EK_SendFileObject);
         return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &object, NULL);
 }
 
 /**
  * ptp_ek_sendfileobject_from_handler:
  * params:      PTPParams*
  *              PTPDataHandler* handler - contains the handler of the object that is to be sent
  *              uint32_t size           - object size
  *              
  * Sends object to Responder.
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_ek_sendfileobject_from_handler (PTPParams* params, PTPDataHandler*handler, uint32_t size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_EK_SendFileObject;
-        ptp.Nparam=0;
+        PTP_CNT_INIT(ptp, PTP_OC_EK_SendFileObject);
         return ptp_transaction_new(params, &ptp, PTP_DP_SENDDATA, size, handler);
 }
 
 /*************************************************************************
  *
  * Canon PTP extensions support
  *
  * (C) Nikolai Kopanygin 2003
  *
  *************************************************************************/
@@ skipping 13 matching lines @@
  * Upon success : uint32_t* size        - The object size
  *                uint32_t* rp2         - Still unknown return parameter
  *                                        (perhaps upper 32bit of size)
  *
  *
  **/
 uint16_t
 ptp_canon_getpartialobjectinfo (PTPParams* params, uint32_t handle, uint32_t p2, 
                         uint32_t* size, uint32_t* rp2) 
 {
-        uint16_t ret;
-        PTPContainer ptp;
+        PTPContainer    ptp;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetPartialObjectInfo;
-        ptp.Param1=handle;
-        ptp.Param2=p2;
-        ptp.Nparam=2;
-        ret=ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetPartialObjectInfo, handle, p2);
+        *size = *rp2 = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
         *size=ptp.Param1;
         *rp2=ptp.Param2;
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_canon_get_mac_address:
  * params:      PTPParams*
  *                                        value 0 works.
  * Gets the MAC address of the wireless transmitter.
  *
  * Return values: Some PTP_RC_* code.
  * Upon success : unsigned char* mac    - The MAC address
  *
  **/
 uint16_t
 ptp_canon_get_mac_address (PTPParams* params, unsigned char **mac)
 {
         PTPContainer ptp;
-        unsigned int size = 0;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetMACAddress;
-        ptp.Nparam=0;
-        *mac = NULL;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, mac, &size);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetMACAddress);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, mac, NULL);
 }
 
 /**
  * ptp_canon_get_directory:
  * params:      PTPParams*
 
  * Gets the full directory of the camera.
  *
  * Return values: Some PTP_RC_* code.
  * Upon success : PTPObjectHandles        *handles      - filled out with handles
  *                PTPObjectInfo           **oinfos      - allocated array of PTP Object Infos
  *                uint32_t                **flags       - allocated array of CANON Flags
  *
  **/
 uint16_t
 ptp_canon_get_directory (PTPParams* params,
         PTPObjectHandles        *handles,
         PTPObjectInfo           **oinfos,       /* size(handles->n) */
         uint32_t                **flags         /* size(handles->n) */
 ) {
         PTPContainer    ptp;
-        unsigned char   *dir = NULL;
-        unsigned int    size = 0;
+        unsigned char   *data;
         uint16_t        ret;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetDirectory;
-        ptp.Nparam=0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &dir, &size);
-        if (ret != PTP_RC_OK)
-                return ret;
-        ret = ptp_unpack_canon_directory(params, dir, ptp.Param1, handles, oinfos, flags);
-        free (dir);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetDirectory);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, NULL));
+        ret = ptp_unpack_canon_directory(params, data, ptp.Param1, handles, oinfos, flags);
+        free (data);
         return ret;
 }
 
 /**
  * ptp_canon_gettreeinfo:
  * params:      PTPParams*
  *              uint32_t *out
  * 
  * Switches the camera display to on and lets the user
  * select what to transfer. Sends a 0xc011 event when started 
  * and 0xc013 if direct transfer aborted.
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_canon_gettreeinfo (PTPParams* params, uint32_t *out)
 {
-        PTPContainer ptp;
-        uint16_t ret;
+        PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_GetTreeInfo;
-        ptp.Nparam = 1;
-        ptp.Param1 = 0xf;
-        ret = ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL);
-        if ((ret == PTP_RC_OK) && (ptp.Nparam>0))
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetTreeInfo, 0xf);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        if (ptp.Nparam > 0)
                 *out = ptp.Param1;
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_canon_getpairinginfo:
  * params:      PTPParams*
  *              int nr
  * 
  * Get the pairing information.
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_canon_getpairinginfo (PTPParams* params, uint32_t nr, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
-        uint16_t ret;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_GetPairingInfo;
-        ptp.Nparam = 1;
-        ptp.Param1 = nr;
-        *data = NULL;
-        *size = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
-        if (ret != PTP_RC_OK)
-                return ret;
-        return PTP_RC_OK;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetPairingInfo, nr);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
 }
 
 /**
  * ptp_canon_get_target_handles:
  * params:      PTPParams*
  *              PTPCanon_directtransfer_entry **out
  *              unsigned int *outsize
  * 
  * Retrieves direct transfer entries specifying the images to transfer
  * from the camera (to be retrieved after 0xc011 event).
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_canon_gettreesize (PTPParams* params,
         PTPCanon_directtransfer_entry **entries, unsigned int *cnt)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *out = NULL, *cur;
-        int i;
-        unsigned int size;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_CANON_GetTreeSize;
-        ptp.Nparam = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &out, &size);
-        if (ret != PTP_RC_OK)
-                return ret;
-        *cnt = dtoh32a(out);
+        PTPContainer    ptp;
+        uint16_t        ret = PTP_RC_OK;
+        unsigned char   *data, *cur;
+        unsigned int    size, i;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetTreeSize);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        *cnt = dtoh32a(data);
         *entries = malloc(sizeof(PTPCanon_directtransfer_entry)*(*cnt));
         if (!*entries) {
-                free (out);
-                return PTP_RC_GeneralError;
+                ret = PTP_RC_GeneralError;
+                goto exit;
         }
-        cur = out+4;
+        cur = data+4;
         for (i=0;i<*cnt;i++) {
                 unsigned char len;
                 (*entries)[i].oid = dtoh32a(cur);
                 (*entries)[i].str = ptp_unpack_string(params, cur, 4, &len);
                 cur += 4+(cur[4]*2+1);
         }
-        free (out);
-        return PTP_RC_OK;
+exit:
+        free (data);
+        return ret;
 }
 
 /**
  * ptp_canon_checkevent:
  * params:      PTPParams*
  * 
  * The camera has a FIFO stack, in which it accumulates events.
  * Partially these events are communicated also via the USB interrupt pipe
  * according to the PTP USB specification, partially not.
  * This operation returns from the device a block of data, empty,
  * if the event stack is empty, or filled with an event's data otherwise.
  * The event is removed from the stack in the latter case.
  * The Remote Capture app sends this command to the camera all the time
  * of connection, filling with it the gaps between other operations. 
  *
  * Return values: Some PTP_RC_* code.
  * Upon success : PTPUSBEventContainer* event   - is filled with the event data
  *                                                if any
  *                int *isevent                  - returns 1 in case of event
  *                                                or 0 otherwise
  **/
 uint16_t
 ptp_canon_checkevent (PTPParams* params, PTPContainer* event, int* isevent)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char *evdata = NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
         
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_CheckEvent);
         *isevent=0;
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_CheckEvent;
-        ptp.Nparam=0;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &evdata, &len);
-        if (evdata!=NULL) {
-                if (ret == PTP_RC_OK) {
-                        ptp_unpack_EC(params, evdata, event, len);
-                        *isevent=1;
-                }
-                free(evdata);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        if (data && size) { /* check if we had a successfull call with data */
+                ptp_unpack_EC(params, data, event, size);
+                *isevent=1;
+                free(data);
         }
-        return ret;
+        return PTP_RC_OK;
 }
 
 uint16_t
-ptp_check_event (PTPParams *params) {
-        PTPContainer            event;
-        uint16_t                ret;
+ptp_add_event (PTPParams *params, PTPContainer *evt)
+{
+        params->events = realloc(params->events, sizeof(PTPContainer)*(params->nrofevents+1));
+        memcpy (&params->events[params->nrofevents],evt,1*sizeof(PTPContainer));
+        params->nrofevents += 1;
+        return PTP_RC_OK;
+}
 
+uint16_t
+ptp_check_event (PTPParams *params)
+{
+        PTPContainer    event;
+        uint16_t        ret;
+
+        /* Method offered by Nikon DSLR, Nikon 1, and some older Nikon Coolpix P*
+         * The Nikon Coolpix P2 however does not return anything. So if we never get
+         * events from here, use the ptp "interrupt" method */
         if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_NIKON) &&
                 ptp_operation_issupported(params, PTP_OC_NIKON_CheckEvent)
         ) {
-                int evtcnt;
-                PTPContainer    *xevent = NULL;
+                unsigned int evtcnt = 0;
+                PTPContainer *xevent = NULL;
 
                 ret = ptp_nikon_check_event(params, &xevent, &evtcnt);
-                if (ret != PTP_RC_OK)
-                        return ret;
+                if (ret != PTP_RC_OperationNotSupported)
+                        CHECK_PTP_RC(ret);
 
                 if (evtcnt) {
-                        if (params->nrofevents)
-                                params->events = realloc(params->events, sizeof(PTPContainer)*(evtcnt+params->nrofevents));
-                        else
-                                params->events = malloc(sizeof(PTPContainer)*evtcnt);
+                        params->events = realloc(params->events, sizeof(PTPContainer)*(evtcnt+params->nrofevents));
                         memcpy (&params->events[params->nrofevents],xevent,evtcnt*sizeof(PTPContainer));
                         params->nrofevents += evtcnt;
                         free (xevent);
+                        params->event90c7works = 1;
                 }
-                return PTP_RC_OK;
+                if (params->event90c7works)
+                        return PTP_RC_OK;
+                /* fall through to generic event handling */
         }
         /* should not get here ... EOS has no normal PTP events and another queue handling. */
         if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_CANON) &&
                 ptp_operation_issupported(params, PTP_OC_CANON_EOS_GetEvent)
         ) {
                 return PTP_RC_OK;
         }
 
         if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_CANON) &&
                 ptp_operation_issupported(params, PTP_OC_CANON_CheckEvent)
         ) {
                 int isevent;
 
-                ret = ptp_canon_checkevent (params,&event,&isevent);
-                if (ret!=PTP_RC_OK)
-                        return ret;
-                if (isevent)
+                CHECK_PTP_RC(ptp_canon_checkevent (params,&event,&isevent));
+
+                if (isevent) {
+                        ret = PTP_RC_OK;
                         goto store_event;
+                }
                 /* Event Emulate Mode 0 (unset) and 1-5 get interrupt events. 6-7 does not. */
                 if (params->canon_event_mode > 5)
-                        return ret;
+                        return PTP_RC_OK;
 
                 /* FIXME: fallthrough or return? */
 #ifdef __APPLE__
                 /* the libusb 1 on darwin currently does not like polling
                  * for interrupts, they have no timeout for it. 2010/08/23
                  * Check back in 2011 or so. -Marcus
                  */
-                return ret;
+                return PTP_RC_OK;
 #endif
         }
         ret = params->event_check(params,&event);
 
 store_event:
         if (ret == PTP_RC_OK) {
                 ptp_debug (params, "event: nparams=0x%X, code=0x%X, trans_id=0x%X, p1=0x%X, p2=0x%X, p3=0x%X", event.Nparam,event.Code,event.Transaction_ID, event.Param1, event.Param2, event.Param3);
-                if (params->nrofevents)
-                        params->events = realloc(params->events, sizeof(PTPContainer)*(params->nrofevents+1));
-                else
-                        params->events = malloc(sizeof(PTPContainer)*1);
-                memcpy (&params->events[params->nrofevents],&event,1*sizeof(PTPContainer));
-                params->nrofevents += 1;
+                ptp_add_event (params, &event);
+
+                /* handle some PTP stack internal events */
+                switch (event.Code) {
+                case PTP_EC_DevicePropChanged: {
+                        unsigned int i;
+
+                        /* mark the property for a forced refresh on the next query */
+                        for (i=0;i<params->nrofdeviceproperties;i++)
+                                if (params->deviceproperties[i].desc.DevicePropertyCode == event.Param1) {
+                                        params->deviceproperties[i].timestamp = 0;
+                                        break;
+                                }
+                        break;
+                }
+                default: /* check if we should handle it internally too */
+                        break;
+                }
+        
         }
         if (ret == PTP_ERROR_TIMEOUT) /* ok, just new events */
                 ret = PTP_RC_OK;
         return ret;
 }
 
+uint16_t
+ptp_wait_event (PTPParams *params)
+{
+        PTPContainer    event;
+        uint16_t        ret;
+
+        ret = params->event_wait(params,&event);
+        if (ret == PTP_RC_OK) {
+                ptp_debug (params, "event: nparams=0x%X, code=0x%X, trans_id=0x%X, p1=0x%X, p2=0x%X, p3=0x%X", event.Nparam,event.Code,event.Transaction_ID, event.Param1, event.Param2, event.Param3);
+                ptp_add_event (params, &event);
+
+                /* handle some PTP stack internal events */
+                switch (event.Code) {
+                case PTP_EC_DevicePropChanged: {
+                        unsigned int i;
+
+                        /* mark the property for a forced refresh on the next query */
+                        for (i=0;i<params->nrofdeviceproperties;i++)
+                                if (params->deviceproperties[i].desc.DevicePropertyCode == event.Param1) {
+                                        params->deviceproperties[i].timestamp = 0;
+                                        break;
+                                }
+                        break;
+                }
+                default: /* check if we should handle it internally too */
+                        break;
+                }
+        }
+        if (ret == PTP_ERROR_TIMEOUT) /* ok, just new events */
+                ret = PTP_RC_OK;
+        return ret;
+}
+
+
 int
-ptp_get_one_event(PTPParams *params, PTPContainer *event) {
+ptp_get_one_event(PTPParams *params, PTPContainer *event)
+{
         if (!params->nrofevents)
                 return 0;
         memcpy (event, params->events, sizeof(PTPContainer));
         memmove (params->events, params->events+1, sizeof(PTPContainer)*(params->nrofevents-1));
         /* do not realloc on shrink. */
         params->nrofevents--;
         if (!params->nrofevents) {
                 free (params->events);
                 params->events = NULL;
         }
         return 1;
 }
 
 /**
  * ptp_canon_eos_getevent:
  * 
  * This retrieves configuration status/updates/changes
  * on EOS cameras. It reads a datablock which has a list of variable
  * sized structures.
  *
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_canon_eos_getevent (PTPParams* params, PTPCanon_changes_entry **entries, int *nrofentries)
 {
-        PTPContainer ptp;
-        uint16_t        ret;
-        unsigned int    size = 0;
-        unsigned char   *data = NULL;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetEvent);
         *nrofentries = 0;
         *entries = NULL;
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_CANON_EOS_GetEvent;
-        ptp.Nparam = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret != PTP_RC_OK) return ret;
-        *nrofentries = ptp_unpack_CANON_changes(params,data,size,entries);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        *nrofentries = ptp_unpack_CANON_changes(params,data,size,entries);
         free (data);
         return PTP_RC_OK;
 }
 
 uint16_t
-ptp_check_eos_events (PTPParams *params) {
-        uint16_t                ret;
+ptp_check_eos_events (PTPParams *params)
+{
         PTPCanon_changes_entry  *entries = NULL, *nentries;
         int                     nrofentries = 0;
 
         while (1) { /* call it repeatedly until the camera does not report any */
-                ret = ptp_canon_eos_getevent (params, &entries, &nrofentries);
-                if (ret != PTP_RC_OK)
-                        return ret;
+                CHECK_PTP_RC(ptp_canon_eos_getevent (params, &entries, &nrofentries));
                 if (!nrofentries)
                         return PTP_RC_OK;
 
                 if (params->nrofbacklogentries) {
                         nentries = realloc(params->backlogentries,sizeof(entries[0])*(params->nrofbacklogentries+nrofentries));
                         if (!nentries)
                                 return PTP_RC_GeneralError;
                         params->backlogentries = nentries;
                         memcpy (nentries+params->nrofbacklogentries, entries, nrofentries*sizeof(entries[0]));
                         params->nrofbacklogentries += nrofentries;
                         free (entries);
                 } else {
                         params->backlogentries = entries;
                         params->nrofbacklogentries = nrofentries;
                 }
         }
         return PTP_RC_OK;
 }
 
 int
-ptp_get_one_eos_event (PTPParams *params, PTPCanon_changes_entry *entry) {
+ptp_get_one_eos_event (PTPParams *params, PTPCanon_changes_entry *entry)
+{
         if (!params->nrofbacklogentries)
                 return 0;
         memcpy (entry, params->backlogentries, sizeof(*entry));
         if (params->nrofbacklogentries > 1) {
                 memmove (params->backlogentries,params->backlogentries+1,sizeof(*entry)*(params->nrofbacklogentries-1));
                 params->nrofbacklogentries--;
         } else {
                 free (params->backlogentries);
                 params->backlogentries = NULL;
                 params->nrofbacklogentries = 0;
         }
         return 1;
 }
 
 
 uint16_t
 ptp_canon_eos_getdevicepropdesc (PTPParams* params, uint16_t propcode,
         PTPDevicePropDesc *dpd)
 {
-        int i;
+        unsigned int i;
 
         for (i=0;i<params->nrofcanon_props;i++)
                 if (params->canon_props[i].proptype == propcode)
                         break;
         if (params->nrofcanon_props == i)
                 return PTP_RC_Undefined;
         memcpy (dpd, &params->canon_props[i].dpd, sizeof (*dpd));
         if (dpd->FormFlag == PTP_DPFF_Enumeration) {
                 /* need to duplicate the Enumeration alloc */
                 dpd->FORM.Enum.SupportedValue = malloc (sizeof (PTPPropertyValue)*dpd->FORM.Enum.NumberOfValues);
                 memcpy (dpd->FORM.Enum.SupportedValue,
                         params->canon_props[i].dpd.FORM.Enum.SupportedValue,
                         sizeof (PTPPropertyValue)*dpd->FORM.Enum.NumberOfValues
                 );
         }
         if (dpd->DataType == PTP_DTC_STR) {
                 dpd->FactoryDefaultValue.str = strdup( params->canon_props[i].dpd.FactoryDefaultValue.str );
                 dpd->CurrentValue.str = strdup( params->canon_props[i].dpd.CurrentValue.str );
         }
 
         return PTP_RC_OK;
 }
 
 
 uint16_t
 ptp_canon_eos_getstorageids (PTPParams* params, PTPStorageIDs* storageids)
 {
         PTPContainer    ptp;
-        unsigned int    len = 0;
-        uint16_t        ret;
-        unsigned char*  sids=NULL;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_GetStorageIDs;
-        ptp.Nparam      = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &sids, &len);
-        if (ret == PTP_RC_OK) ptp_unpack_SIDs(params, sids, storageids, len);
-        free(sids);
-        return ret;
+        unsigned char   *data;
+        unsigned int    size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetStorageIDs);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_SIDs(params, data, storageids, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_canon_eos_getstorageinfo (PTPParams* params, uint32_t p1, unsigned char **data, unsigned int *size)
 {
-        PTPContainer ptp;
-        uint16_t        ret;
+        PTPContainer    ptp;
         
-        *size = 0;
-        *data = NULL;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_GetStorageInfo;
-        ptp.Nparam      = 1;
-        ptp.Param1      = p1;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetStorageInfo, p1);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
         /* FIXME: do stuff with data */
-        return ret;
 }
 
 uint16_t
 ptp_canon_eos_getobjectinfoex (
         PTPParams* params, uint32_t storageid, uint32_t oid, uint32_t unk,
         PTPCANONFolderEntry **entries, unsigned int *nrofentries
 ) {
         PTPContainer    ptp;
-        unsigned int    i, size = 0;
+        uint16_t        ret = PTP_RC_OK;
         unsigned char   *data, *xdata;
-        uint16_t        ret;
+        unsigned int    size, i;
 
-        data = NULL;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_GetObjectInfoEx;
-        ptp.Nparam      = 3;
-        ptp.Param1      = storageid;
-        ptp.Param2      = oid;
-        ptp.Param3      = unk;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret != PTP_RC_OK)
-                return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetObjectInfoEx, storageid, oid, unk);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        if (!data) {
+                *nrofentries = 0;
+                return PTP_RC_OK;
+        }
 
         *nrofentries = dtoh32a(data);
         *entries = malloc(*nrofentries * sizeof(PTPCANONFolderEntry));
-        if (!*entries)
-                return PTP_RC_GeneralError;
+        if (!*entries) {
+                ret = PTP_RC_GeneralError;
+                goto exit;
+        }
 
         xdata = data+sizeof(uint32_t);
         for (i=0;i<*nrofentries;i++) {
                 ptp_unpack_Canon_EOS_FE (params, &xdata[4], &((*entries)[i]));
                 xdata += dtoh32a(xdata);
         }
-        return PTP_RC_OK;
+exit:
+        free (data);
+        return ret;
 }
 
 /**
  * ptp_canon_eos_getpartialobject:
  * 
  * This retrieves a part of an PTP object which you specify as object id.
  * The id originates from 0x9116 call.
  * After finishing it, we seem to need to call ptp_canon_eos_enddirecttransfer.
  *
  * params:      PTPParams*
  *              oid             Object ID
  *              offset          The offset where to start the data transfer 
  *              xsize           Size in bytes of the transfer to do
  *              data            Pointer that receives the malloc()ed memory of the transfer.
  *
  * Return values: Some PTP_RC_* code.
  *
  */
 uint16_t
 ptp_canon_eos_getpartialobject (PTPParams* params, uint32_t oid, uint32_t offset, uint32_t xsize, unsigned char**data)
 {
         PTPContainer    ptp;
-        unsigned int    size = 0;
 
-        *data = NULL;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_GetPartialObject;
-        ptp.Nparam      = 3;
-        ptp.Param1      = oid;
-        ptp.Param2      = offset;
-        ptp.Param3      = xsize;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, &size);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetPartialObject, oid, offset, xsize);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, NULL);
 }
 
 uint16_t
 ptp_canon_eos_setdevicepropvalueex (PTPParams* params, unsigned char* data, unsigned int size)
 {
         PTPContainer    ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_SetDevicePropValueEx;
-        ptp.Nparam      = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_SetDevicePropValueEx);
         return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
 }
 
 #if 0
 uint16_t
 ptp_canon_eos_setdevicepropvalue (PTPParams* params,
         uint16_t propcode, PTPPropertyValue *value, uint16_t datatype
 ) {
         PTPContainer    ptp;
         uint16_t        ret;
-        int             i;
-        unsigned char   *data;
-        unsigned int    size;
+        unsigned char   *data = NULL;
+        unsigned int    i, size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_EOS_SetDevicePropValueEx;
-        ptp.Nparam      = 0;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_SetDevicePropValueEx);
+
         for (i=0;i<params->nrofcanon_props;i++)
                 if (params->canon_props[i].proptype == propcode)
                         break;
         if (params->nrofcanon_props == i)
                 return PTP_RC_Undefined;
 
         switch (propcode) {
         case PTP_DPC_CANON_EOS_ImageFormat:
         case PTP_DPC_CANON_EOS_ImageFormatCF:
         case PTP_DPC_CANON_EOS_ImageFormatSD:
         case PTP_DPC_CANON_EOS_ImageFormatExtHD:
                 /* special handling of ImageFormat properties */
                 size = 8 + ptp_pack_EOS_ImageFormat( params, NULL, value->u16 );
                 data = malloc( size );
                 if (!data) return PTP_RC_GeneralError;
                 params->canon_props[i].dpd.CurrentValue.u16 = value->u16;
                 ptp_pack_EOS_ImageFormat( params, data + 8, value->u16 );
                 break;
         case PTP_DPC_CANON_EOS_CustomFuncEx:
                 /* special handling of CustomFuncEx properties */
                 ptp_debug (params, "ptp2/ptp_canon_eos_setdevicepropvalue: setting EOS prop %x to %s",propcode,value->str);
                 size = 8 + ptp_pack_EOS_CustomFuncEx( params, NULL, value->str );
                 data = malloc( size );
                 if (!data) return PTP_RC_GeneralError;
                 params->canon_props[i].dpd.CurrentValue.str = strdup( value->str );
                 ptp_pack_EOS_CustomFuncEx( params, data + 8, value->str );
                 break;
         default:
                 if (datatype != PTP_DTC_STR) {
-                        data = calloc(sizeof(uint32_t),3);
+                        data = calloc(3,sizeof(uint32_t));
                         if (!data) return PTP_RC_GeneralError;
                         size = sizeof(uint32_t)*3;
                 } else {
                         size = strlen(value->str) + 1 + 8;
-                        data = calloc(sizeof(char),size);
+                        data = calloc(size,sizeof(char));
                         if (!data) return PTP_RC_GeneralError;
                 }
                 switch (datatype) {
                 case PTP_DTC_INT8:
                 case PTP_DTC_UINT8:
                         /*fprintf (stderr, "%x -> %d\n", propcode, value->u8);*/
                         htod8a(&data[8], value->u8);
                         params->canon_props[i].dpd.CurrentValue.u8 = value->u8;
                         break;
                 case PTP_DTC_UINT16:
@@ skipping 42 matching lines @@
  *      char **block - the pointer to the block of data read
  *      uint32_t* readnum - the number of bytes read
  *
  **/
 uint16_t
 ptp_canon_getpartialobject (PTPParams* params, uint32_t handle, 
                                 uint32_t offset, uint32_t size,
                                 uint32_t pos, unsigned char** block, 
                                 uint32_t* readnum)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char *data=NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetPartialObjectEx;
-        ptp.Param1=handle;
-        ptp.Param2=offset;
-        ptp.Param3=size;
-        ptp.Param4=pos;
-        ptp.Nparam=4;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &len);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetPartialObjectEx, handle, offset, size, pos);
+        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, NULL);
         if (ret==PTP_RC_OK) {
                 *block=data;
                 *readnum=ptp.Param1;
         }
+        free (data);
         return ret;
 }
 
 /**
  * ptp_canon_getviewfinderimage:
  *
  * This operation can be used to read the image which is currently
  * in the camera's viewfinder. The image size is 320x240, format is JPEG.
  * Of course, prior to calling this operation, one must turn the viewfinder
  * on with the CANON_ViewfinderOn command.
  * Invoking this operation many times, one can get live video from the camera!
  * 
  * params:      PTPParams*
  * 
  * Return values: Some PTP_RC_* code.
  *      char **image - the pointer to the read image
  *      unit32_t *size - the size of the image in bytes
  *
  **/
 uint16_t
 ptp_canon_getviewfinderimage (PTPParams* params, unsigned char** image, uint32_t* size)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned int len;
+        PTPContainer    ptp;
+        uint16_t        ret;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetViewfinderImage;
-        ptp.Nparam=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, image, &len);
-        if (ret==PTP_RC_OK) *size=ptp.Param1;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetViewfinderImage);
+        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, image, NULL);
+        if (ret==PTP_RC_OK)
+                *size=ptp.Param1;
         return ret;
 }
 
 /**
  * ptp_canon_getchanges:
  *
  * This is an interesting operation, about the effect of which I am not sure.
  * This command is called every time when a device property has been changed 
  * with the SetDevicePropValue operation, and after some other operations.
  * This operation reads the array of Device Properties which have been changed
  * by the previous operation.
  * Probably, this operation is even required to make those changes work.
  *
  * params:      PTPParams*
  * 
  * Return values: Some PTP_RC_* code.
  *      uint16_t** props - the pointer to the array of changed properties
  *      uint32_t* propnum - the number of elements in the *props array
  *
  **/
 uint16_t
 ptp_canon_getchanges (PTPParams* params, uint16_t** props, uint32_t* propnum)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* data=NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetChanges;
-        ptp.Nparam=0;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &len);
-        if (ret == PTP_RC_OK)
-                *propnum=ptp_unpack_uint16_t_array(params,data,0,props);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetChanges);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        *propnum=ptp_unpack_uint16_t_array(params,data,0,size,props);
         free(data);
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_canon_getobjectinfo:
  *
  * This command reads a specified object's record in a device's filesystem,
  * or the records of all objects belonging to a specified folder (association).
  *  
  * params:      PTPParams*
  *      uint32_t store - StorageID,
@@ skipping 10 matching lines @@
  * Return values: Some PTP_RC_* code.
  *      PTPCANONFolderEntry** entries - the pointer to the folder entry array
  *      uint32_t* entnum - the number of elements of the array
  *
  **/
 uint16_t
 ptp_canon_getobjectinfo (PTPParams* params, uint32_t store, uint32_t p2, 
                             uint32_t parent, uint32_t handle, 
                             PTPCANONFolderEntry** entries, uint32_t* entnum)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char *data = NULL;
-        unsigned int len;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        unsigned int    i;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_GetObjectInfoEx;
-        ptp.Param1=store;
-        ptp.Param2=p2;
-        ptp.Param3=parent;
-        ptp.Param4=handle;
-        ptp.Nparam=4;
-        len=0;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &len);
-        if (ret == PTP_RC_OK) {
-                int i;
-                *entnum=ptp.Param1;
-                *entries=calloc(*entnum, sizeof(PTPCANONFolderEntry));
-                if (*entries!=NULL) {
-                        for(i=0; i<(*entnum); i++)
-                                ptp_unpack_Canon_FE(params,
-                                        data+i*PTP_CANON_FolderEntryLen,
-                                        &((*entries)[i]) );
-                } else {
-                        ret=PTP_ERROR_IO; /* Cannot allocate memory */
-                }
-        }
-        free(data);
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetObjectInfoEx, store, p2, parent, handle);
+        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, NULL);
+        if (ret != PTP_RC_OK)
+                goto exit;
+
+        *entnum=ptp.Param1;
+        *entries=calloc(*entnum, sizeof(PTPCANONFolderEntry));
+        if (*entries==NULL) {
+                ret=PTP_RC_GeneralError;
+                goto exit;
+        }
+        for(i=0; i<(*entnum); i++)
+                ptp_unpack_Canon_FE(params,
+                                    data+i*PTP_CANON_FolderEntryLen,
+                                    &((*entries)[i]) );
+
+exit:
+        free (data);
         return ret;
 }
 
 /**
  * ptp_canon_get_objecthandle_by_name:
  *
  * This command looks up the specified object on the camera.
  *
  * Format is "A:\\PATH".
  *
  * The 'A' is the VolumeLabel from GetStorageInfo,
  * my IXUS has "A" for the card and "V" for internal memory.
  *  
  * params:      PTPParams*
  *      char* name - path name
  *
  * Return values: Some PTP_RC_* code.
  *      uint32_t *oid - PTP object id.
  *
  **/
 uint16_t
 ptp_canon_get_objecthandle_by_name (PTPParams* params, char* name, uint32_t* objectid)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char *data = NULL;
-        uint8_t len;
-
-        PTP_CNT_INIT (ptp);
-        ptp.Code=PTP_OC_CANON_GetObjectHandleByName;
-        ptp.Nparam=0;
-        len=0;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        uint8_t         len = 0;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetObjectHandleByName);
         data = malloc (2*(strlen(name)+1)+2);
+        if (!data) return PTP_RC_GeneralError;
         memset (data, 0, 2*(strlen(name)+1)+2);
         ptp_pack_string (params, name, data, 0, &len);
         ret=ptp_transaction (params, &ptp, PTP_DP_SENDDATA, (len+1)*2+1, &data, NULL);
         free (data);
         *objectid = ptp.Param1;
         return ret;
 }
 
 /**
  * ptp_canon_get_customize_data:
  *
  * This command downloads the specified theme slot, including jpegs
  * and wav files.
  *  
  * params:      PTPParams*
  *      uint32_t themenr - nr of theme
  *
  * Return values: Some PTP_RC_* code.
  *      unsigned char **data - pointer to data pointer
  *      unsigned int  *size - size of data returned
  *
  **/
 uint16_t
 ptp_canon_get_customize_data (PTPParams* params, uint32_t themenr,
                 unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
 
-        *data = NULL;
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_GetCustomizeData, themenr);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
+}
+
+
+uint16_t
+ptp_nikon_curve_download (PTPParams* params, unsigned char **data, unsigned int *size)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_CurveDownload);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
+}
+
+/**
+ * ptp_sony_sdioconnect:
+ *
+ * This changes modes of the camera
+ *  
+ * params:      PTPParams*
+ *
+ * Return values: Some PTP_RC_* code.
+ *
+ **/
+uint16_t
+ptp_sony_sdioconnect (PTPParams* params, uint32_t p1, uint32_t p2, uint32_t p3)
+{
+        PTPContainer    ptp;
+        unsigned char   *data;
+
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_SDIOConnect, p1, p2, p3);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, NULL));
+        free (data);
+        return PTP_RC_OK;
+}
+/**
+ * ptp_sony_get_vendorpropcodes:
+ *
+ * This command downloads the vendor specific property codes.
+ *  
+ * params:      PTPParams*
+ *
+ * Return values: Some PTP_RC_* code.
+ *      unsigned char **data - pointer to data pointer
+ *      unsigned int  *size - size of data returned
+ *
+ **/
+uint16_t
+ptp_sony_get_vendorpropcodes (PTPParams* params, uint16_t **props, unsigned int *size)
+{
+        PTPContainer    ptp;
+        unsigned char   *xdata;
+        unsigned int    xsize, psize1 = 0, psize2 = 0;
+        uint16_t        *props1 = NULL,*props2 = NULL;
+
+        *props = NULL;
         *size = 0;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_CANON_GetCustomizeData;
-        ptp.Param1      = themenr;
-        ptp.Nparam      = 1;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
-}
-
-
-uint16_t
-ptp_nikon_curve_download (PTPParams* params, unsigned char **data, unsigned int *size) {
-        PTPContainer ptp;
-        *data = NULL;
-        *size = 0;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_NIKON_CurveDownload;
-        ptp.Nparam      = 0;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
-}
-
-/**
- * ptp_canon_get_vendorpropcodes:
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_GetSDIOGetExtDeviceInfo, 0xc8 /* unclear */);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &xdata, &xsize));
+        if (xsize == 0) {
+                ptp_debug (params, "No special operations sent?");
+                return PTP_RC_OK;
+        }
+
+        psize1 = ptp_unpack_uint16_t_array (params, xdata+2, 0, xsize, &props1);
+        ptp_debug (params, "xsize %d, got size %d\n", xsize, psize1*2 + 2 + 4);
+        if (psize1*2 + 2 + 4 < xsize) {
+                psize2 = ptp_unpack_uint16_t_array(params,xdata+2+psize1*2+4, 0, xsize, &props2);
+        }
+        *size = psize1+psize2;
+        *props = malloc((psize1+psize2)*sizeof(uint16_t));
+        memcpy (*props, props1, psize1*sizeof(uint16_t));
+        memcpy ((*props)+psize1, props2, psize2*sizeof(uint16_t));
+        free (props1);
+        free (props2);
+        free (xdata);
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_sony_getdevicepropdesc (PTPParams* params, uint16_t propcode, PTPDevicePropDesc *dpd)
+{
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size, len = 0;
+        uint16_t        ret;
+
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_GetDevicePropdesc, propcode);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        /* first 16 bit is 0xc8 0x00, then an array of 16 bit PTP ids */
+        ret = ptp_unpack_Sony_DPD(params,data,dpd,size,&len) ? PTP_RC_OK : PTP_RC_GeneralError;
+        free (data);
+        return ret;
+}
+
+uint16_t
+ptp_sony_getalldevicepropdesc (PTPParams* params)
+{
+        PTPContainer            ptp;
+        unsigned char           *data, *dpddata;
+        unsigned int            size, readlen;
+        PTPDevicePropDesc       dpd;
+
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_GetAllDevicePropData);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        dpddata = data+8; /* nr of entries 32bit, 0 32bit */
+        size -= 8;
+        while (size>0) {
+                unsigned int    i;
+                uint16_t        propcode;
+
+                if (!ptp_unpack_Sony_DPD (params, dpddata, &dpd, size, &readlen))
+                        break;
+
+                propcode = dpd.DevicePropertyCode;
+
+                for (i=0;i<params->nrofdeviceproperties;i++)
+                        if (params->deviceproperties[i].desc.DevicePropertyCode == propcode)
+                                break;
+
+                if (i == params->nrofdeviceproperties) {
+                        params->deviceproperties = realloc(params->deviceproperties,(i+1)*sizeof(params->deviceproperties[0]));
+                        memset(&params->deviceproperties[i],0,sizeof(params->deviceproperties[0]));
+                        params->nrofdeviceproperties++;
+                } else {
+                        ptp_free_devicepropdesc (&params->deviceproperties[i].desc);
+                }
+                params->deviceproperties[i].desc = dpd;
+#if 0
+                ptp_debug (params, "dpd.DevicePropertyCode %04x, readlen %d, getset %d", dpd.DevicePropertyCode, readlen, dpd.GetSet);
+                switch (dpd.DataType) {
+                case PTP_DTC_INT8:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.i8, dpd.CurrentValue.i8);
+                        break;
+                case PTP_DTC_UINT8:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.u8, dpd.CurrentValue.u8);
+                        break;
+                case PTP_DTC_UINT16:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.u16, dpd.CurrentValue.u16);
+                        break;
+                case PTP_DTC_INT16:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.i16, dpd.CurrentValue.i16);
+                        break;
+                case PTP_DTC_INT32:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.i32, dpd.CurrentValue.i32);
+                        break;
+                case PTP_DTC_UINT32:
+                        ptp_debug (params, "value %d/%x", dpd.CurrentValue.u32, dpd.CurrentValue.u32);
+                        break;
+                default:
+                        ptp_debug (params, "unknown type %x", dpd.DataType);
+                        break;
+                }
+#endif
+                dpddata += readlen;
+                size -= readlen;
+        }
+        free(data);
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_sony_setdevicecontrolvaluea (PTPParams* params, uint16_t propcode,
+                        PTPPropertyValue *value, uint16_t datatype)
+{
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        uint32_t        size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_SetControlDeviceA, propcode);
+        size = ptp_pack_DPV(params, value, &data, datatype);
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
+        return ret;
+}
+
+uint16_t
+ptp_sony_setdevicecontrolvalueb (PTPParams* params, uint16_t propcode,
+                        PTPPropertyValue *value, uint16_t datatype)
+{
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        uint32_t        size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_SONY_SetControlDeviceB, propcode);
+        size = ptp_pack_DPV(params, value, &data , datatype);
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
+        return ret;
+}
+
+uint16_t
+ptp_sony_9280 (PTPParams* params, uint32_t param1,
+        uint32_t additional, uint32_t data2, uint32_t data3, uint32_t data4, uint8_t x, uint8_t y)
+{
+        PTPContainer    ptp;
+        unsigned char   buf[18];
+        unsigned char   *buffer;
+
+        PTP_CNT_INIT(ptp, 0x9280, param1);
+
+        if ((additional != 0) && (additional != 2))
+                return PTP_RC_GeneralError;
+
+        htod32a(&buf[0], additional);
+        htod32a(&buf[4], data2);
+        htod32a(&buf[8], data3);
+        htod32a(&buf[12], data4);
+
+        /* only sent in the case where additional is 2 */
+        buf[16]= x; buf[17]= y;
+
+        buffer=buf;
+        return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, 16+additional, &buffer, NULL);
+}
+
+uint16_t
+ptp_sony_9281 (PTPParams* params, uint32_t param1) {
+        PTPContainer    ptp;
+        unsigned int    size = 0;
+        unsigned char   *buffer = NULL;
+        uint16_t        ret;
+
+        PTP_CNT_INIT(ptp, 0x9281, param1);
+        ret =  ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &buffer, &size);
+        free (buffer);
+        return ret;
+}
+
+/**
+ * ptp_generic_getdevicepropdesc:
+ *
+ * This command gets a propertydesc.
+ * If a vendor specific property desc query is available, it uses that.
+ * If not, it falls back to the generic PTP getdevicepropdesc.
+ *  
+ * params:      PTPParams*
+ *      uint16_t propcode 
+ *      PTPDevicePropDesc *dpd
+ *
+ * Return values: Some PTP_RC_* code.
+ *
+ **/
+/* Cache time in seconds. Should perhaps be more granular... */
+#define CACHETIME 2
+
+uint16_t
+ptp_generic_getdevicepropdesc (PTPParams *params, uint16_t propcode, PTPDevicePropDesc *dpd)
+{
+        unsigned int    i;
+        time_t          now;
+
+        for (i=0;i<params->nrofdeviceproperties;i++)
+                if (params->deviceproperties[i].desc.DevicePropertyCode == propcode)
+                        break;
+        if (i == params->nrofdeviceproperties) {
+                params->deviceproperties = realloc(params->deviceproperties,(i+1)*sizeof(params->deviceproperties[0]));
+                memset(&params->deviceproperties[i],0,sizeof(params->deviceproperties[0]));
+                params->nrofdeviceproperties++;
+        }
+
+        if (params->deviceproperties[i].desc.DataType != PTP_DTC_UNDEF) {
+                time(&now);
+                if ((now - params->deviceproperties[i].timestamp) <= CACHETIME) {
+                        duplicate_DevicePropDesc(&params->deviceproperties[i].desc, dpd);
+                        return PTP_RC_OK;
+                }
+                /* free cached entry as we will refetch it. */
+                ptp_free_devicepropdesc (&params->deviceproperties[i].desc);
+        }
+
+        if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_SONY) &&
+                ptp_operation_issupported(params, PTP_OC_SONY_GetAllDevicePropData)
+        ) {
+                CHECK_PTP_RC(ptp_sony_getalldevicepropdesc (params));
+
+                for (i=0;i<params->nrofdeviceproperties;i++)
+                        if (params->deviceproperties[i].desc.DevicePropertyCode == propcode)
+                                break;
+                if (i == params->nrofdeviceproperties) {
+                        ptp_debug (params, "property 0x%04x not found?\n", propcode);
+                        return PTP_RC_GeneralError;
+                }
+                time(&now);
+                params->deviceproperties[i].timestamp = now;
+                duplicate_DevicePropDesc(&params->deviceproperties[i].desc, dpd);
+                return PTP_RC_OK;
+        }
+        if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_SONY) &&
+                ptp_operation_issupported(params, PTP_OC_SONY_GetDevicePropdesc)
+        ) {
+                CHECK_PTP_RC(ptp_sony_getdevicepropdesc (params, propcode, &params->deviceproperties[i].desc));
+
+                time(&now);
+                params->deviceproperties[i].timestamp = now;
+                duplicate_DevicePropDesc(&params->deviceproperties[i].desc, dpd);
+                return PTP_RC_OK;
+        }
+
+
+        if (ptp_operation_issupported(params, PTP_OC_GetDevicePropDesc)) {
+                CHECK_PTP_RC(ptp_getdevicepropdesc (params, propcode, &params->deviceproperties[i].desc));
+
+                time(&now);
+                params->deviceproperties[i].timestamp = now;
+                duplicate_DevicePropDesc(&params->deviceproperties[i].desc, dpd);
+                return PTP_RC_OK;
+        }
+
+        return PTP_RC_OK;
+}
+
+/**
+ * ptp_generic_setdevicepropvalue:
+ *
+ * This command sets a property value, device specific.
+ *  
+ * params:      PTPParams*
+ *      uint16_t propcode 
+ *      PTPDevicePropertyValue *value
+ *      uint16_t datatype
+ *
+ * Return values: Some PTP_RC_* code.
+ *
+ **/
+uint16_t
+ptp_generic_setdevicepropvalue (PTPParams* params, uint16_t propcode,
+        PTPPropertyValue *value, uint16_t datatype)
+{
+        unsigned int i;
+
+        /* reset the cache entry */
+        for (i=0;i<params->nrofdeviceproperties;i++)
+                if (params->deviceproperties[i].desc.DevicePropertyCode == propcode)
+                        break;
+        if (i != params->nrofdeviceproperties)
+                params->deviceproperties[i].timestamp = 0;
+
+        /* FIXME: change the cache? hmm */
+        /* this works for some methods, but not for all */
+        if (    (params->deviceinfo.VendorExtensionID == PTP_VENDOR_SONY) &&
+                ptp_operation_issupported(params, PTP_OC_SONY_SetControlDeviceA)
+        )
+                return ptp_sony_setdevicecontrolvaluea (params, propcode, value, datatype);
+        return ptp_setdevicepropvalue (params, propcode, value, datatype);
+}
+
+/**
+ * ptp_nikon_get_vendorpropcodes:
  *
  * This command downloads the vendor specific property codes.
  *  
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *      unsigned char **data - pointer to data pointer
  *      unsigned int  *size - size of data returned
  *
  **/
 uint16_t
-ptp_nikon_get_vendorpropcodes (PTPParams* params, uint16_t **props, unsigned int *size) {
+ptp_nikon_get_vendorpropcodes (PTPParams* params, uint16_t **props, unsigned int *size)
+{
         PTPContainer    ptp;
-        uint16_t        ret;
-        unsigned char   *xdata = NULL;
-        unsigned int    xsize;
+        unsigned char   *data = NULL;
+        unsigned int    xsize = 0;
 
         *props = NULL;
         *size = 0;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_NIKON_GetVendorPropCodes;
-        ptp.Nparam      = 0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &xdata, &xsize); 
-        if (ret == PTP_RC_OK)
-                *size = ptp_unpack_uint16_t_array(params,xdata,0,props);
-        free (xdata);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetVendorPropCodes);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &xsize));
+        *size = ptp_unpack_uint16_t_array(params,data,0,xsize,props);
+        free (data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_nikon_getfileinfoinblock ( PTPParams* params,
         uint32_t p1, uint32_t p2, uint32_t p3,
         unsigned char **data, unsigned int *size
 ) {
         PTPContainer ptp;
-        *data = NULL;
-        *size = 0;
-        PTP_CNT_INIT(ptp);
-        ptp.Code        = PTP_OC_NIKON_GetFileInfoInBlock;
-        ptp.Nparam      = 3;
-        ptp.Param1      = p1;
-        ptp.Param2      = p2;
-        ptp.Param3      = p3;
+
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetFileInfoInBlock, p1, p2, p3);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size); 
 }
 
 /**
  * ptp_nikon_get_liveview_image:
  *
  * This command gets a LiveView image from newer Nikons DSLRs.
  *  
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_nikon_get_liveview_image (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_GetLiveViewImg;
-        ptp.Nparam=0;
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetLiveViewImg);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
 }
 
 /**
  * ptp_nikon_get_preview_image:
  *
  * This command gets a Preview image from newer Nikons DSLRs.
  *  
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_nikon_get_preview_image (PTPParams* params, unsigned char **xdata, unsigned int *xsize,
         uint32_t *handle)
 {
-        PTPContainer    ptp;
-        uint16_t        ret;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_GetPreviewImg;
-        ptp.Nparam=0;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, xdata, xsize);
-        if (ret == PTP_RC_OK) {
-                if (ptp.Nparam > 0)
-                        *handle = ptp.Param1;
-        }
-        return ret;
+        PTPContainer    ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetPreviewImg);
+
+        /* FIXME:
+         * pdslrdashboard passes 3 parameters:
+         * objectid, minimum size, maximum size
+         */
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, xdata, xsize));
+        if (ptp.Nparam > 0)
+                *handle = ptp.Param1;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_canon_eos_get_viewfinder_image:
  *
  * This command gets a Viewfinder image from newer Nikons DSLRs.
  *  
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_canon_eos_get_viewfinder_image (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_EOS_GetViewFinderData;
-        ptp.Nparam=1;
-        ptp.Param1=0x00100000; /* from trace */
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetViewFinderData, 0x00100000 /* from trace */);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
 }
 
 uint16_t
 ptp_canon_eos_get_viewfinder_image_handler (PTPParams* params, PTPDataHandler*handler)
 {
         PTPContainer ptp;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CANON_EOS_GetViewFinderData;
-        ptp.Nparam=1;
-        ptp.Param1=0x00100000; /* from trace */
+        PTP_CNT_INIT(ptp, PTP_OC_CANON_EOS_GetViewFinderData, 0x00100000 /* from trace */);
         return ptp_transaction_new(params, &ptp, PTP_DP_GETDATA, 0, handler);
 }
 
 /**
  * ptp_nikon_check_event:
  *
  * This command checks the event queue on the Nikon.
  *  
  * params:      PTPParams*
  *      PTPUSBEventContainer **event - list of usb events.
  *      int *evtcnt - number of usb events in event structure.
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
-ptp_nikon_check_event (PTPParams* params, PTPContainer** event, int* evtcnt)
+ptp_nikon_check_event (PTPParams* params, PTPContainer** event, unsigned int* evtcnt)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *data = NULL;
-        unsigned int size = 0;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_CheckEvent;
-        ptp.Nparam=0;
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_CheckEvent);
         *evtcnt = 0;
-        ret = ptp_transaction (params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret == PTP_RC_OK) {
-                ptp_unpack_Nikon_EC (params, data, size, event, evtcnt);
-                free (data);
-        }
-        return ret;
+        CHECK_PTP_RC(ptp_transaction (params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_Nikon_EC (params, data, size, event, evtcnt);
+        free (data);
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_nikon_getptpipinfo:
  *
  * This command gets the ptpip info data.
  *  
  * params:      PTPParams*
  *      unsigned char *data     - data
  *      unsigned int size       - size of returned data
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_nikon_getptpipinfo (PTPParams* params, unsigned char **data, unsigned int *size)
 {
         PTPContainer ptp;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_GetDevicePTPIPInfo;
-        ptp.Nparam=0;
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetDevicePTPIPInfo);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, size);
 }
 
 /**
  * ptp_nikon_getwifiprofilelist:
  *
  * This command gets the wifi profile list.
  *  
  * params:      PTPParams*
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_nikon_getwifiprofilelist (PTPParams* params)
 {
-        PTPContainer ptp;
-        unsigned char* data;
-        unsigned int size;
-        unsigned int pos;
-        unsigned int profn;
-        unsigned int n;
-        char* buffer;
-        uint8_t len;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_GetProfileAllData;
-        ptp.Nparam=0;
-        size = 0;
-        data = NULL;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data;
+        unsigned int    size, pos, profn, n;
+        char            *buffer;
+        uint8_t         len;
+
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_GetProfileAllData);
         CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
 
-        if (size < 2) return PTP_RC_Undefined; /* FIXME: Add more precise error code */
+        ret = PTP_RC_Undefined; /* FIXME: Add more precise error code */
+
+        if (size < 2)
+                goto exit;
 
         params->wifi_profiles_version = data[0];
         params->wifi_profiles_number = data[1];
-        if (params->wifi_profiles)
-                free(params->wifi_profiles);
+        free(params->wifi_profiles);
         
         params->wifi_profiles = malloc(params->wifi_profiles_number*sizeof(PTPNIKONWifiProfile));
         memset(params->wifi_profiles, 0, params->wifi_profiles_number*sizeof(PTPNIKONWifiProfile));
 
         pos = 2;
         profn = 0;
         while (profn < params->wifi_profiles_number && pos < size) {
-                if (pos+6 >= size) return PTP_RC_Undefined;
+                if (pos+6 >= size)
+                        goto exit;
                 params->wifi_profiles[profn].id = data[pos++];
                 params->wifi_profiles[profn].valid = data[pos++];
 
                 n = dtoh32a(&data[pos]);
                 pos += 4;
-                if (pos+n+4 >= size) return PTP_RC_Undefined;
+                if (pos+n+4 >= size)
+                        goto exit;
                 strncpy(params->wifi_profiles[profn].profile_name, (char*)&data[pos], n);
                 params->wifi_profiles[profn].profile_name[16] = '\0';
                 pos += n;
 
                 params->wifi_profiles[profn].display_order = data[pos++];
                 params->wifi_profiles[profn].device_type = data[pos++];
                 params->wifi_profiles[profn].icon_type = data[pos++];
 
                 buffer = ptp_unpack_string(params, data, pos, &len);
                 strncpy(params->wifi_profiles[profn].creation_date, buffer, sizeof(params->wifi_profiles[profn].creation_date));
                 free (buffer);
                 pos += (len*2+1);
-                if (pos+1 >= size) return PTP_RC_Undefined;
+                if (pos+1 >= size)
+                        goto exit;
                 /* FIXME: check if it is really last usage date */
                 buffer = ptp_unpack_string(params, data, pos, &len);
                 strncpy(params->wifi_profiles[profn].lastusage_date, buffer, sizeof(params->wifi_profiles[profn].lastusage_date));
                 free (buffer);
                 pos += (len*2+1);
-                if (pos+5 >= size) return PTP_RC_Undefined;
+                if (pos+5 >= size)
+                        goto exit;
                 
                 n = dtoh32a(&data[pos]);
                 pos += 4;
-                if (pos+n >= size) return PTP_RC_Undefined;
+                if (pos+n >= size)
+                        goto exit;
                 strncpy(params->wifi_profiles[profn].essid, (char*)&data[pos], n);
                 params->wifi_profiles[profn].essid[32] = '\0';
                 pos += n;
                 pos += 1;
                 profn++;
         }
 
 #if 0
         PTPNIKONWifiProfile test;
         memset(&test, 0, sizeof(PTPNIKONWifiProfile));
         strcpy(test.profile_name, "MyTest");
         test.icon_type = 1;
         strcpy(test.essid, "nikon");
         test.ip_address = 10 + 11 << 16 + 11 << 24;
         test.subnet_mask = 24;
         test.access_mode = 1;
         test.wifi_channel = 1;
         test.key_nr = 1;
 
         ptp_nikon_writewifiprofile(params, &test);
 #endif
-
-        return PTP_RC_OK;
+        /* everything went Ok */
+        ret = PTP_RC_OK;
+exit:
+        free (data);
+        return ret;
 }
 
 /**
  * ptp_nikon_writewifiprofile:
  *
  * This command gets the ptpip info data.
  *  
  * params:      PTPParams*
  *      unsigned int profilenr  - profile number
  *      unsigned char *data     - data
  *      unsigned int size       - size of returned data
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_nikon_writewifiprofile (PTPParams* params, PTPNIKONWifiProfile* profile)
 {
-        unsigned char guid[16];
-        
         PTPContainer ptp;
         unsigned char buffer[1024];
         unsigned char* data = buffer;
         int size = 0;
         int i;
         uint8_t len;
         int profilenr = -1;
-        
+        unsigned char guid[16];
+
         ptp_nikon_getptpipguid(guid);
 
         if (!params->wifi_profiles)
                 CHECK_PTP_RC(ptp_nikon_getwifiprofilelist(params));
         
         for (i = 0; i < params->wifi_profiles_number; i++) {
                 if (!params->wifi_profiles[i].valid) {
                         profilenr = params->wifi_profiles[i].id;
                         break;
                 }
@@ skipping 14 matching lines @@
         strncpy((char*)&buffer[0x05], profile->profile_name, 16);
         
         buffer[0x16] = 0x00; /* Display order */
         buffer[0x17] = profile->device_type;
         buffer[0x18] = profile->icon_type;
         
         /* FIXME: Creation date: put a real date here */
         ptp_pack_string(params, "19990909T090909", data, 0x19, &len);
         
         /* IP parameters */
-        *((unsigned int*)&buffer[0x3A]) = profile->ip_address; /* Do not reverse bytes */
+        memcpy(&buffer[0x3A],&profile->ip_address,sizeof(profile->ip_address));
+        /**((unsigned int*)&buffer[0x3A]) = profile->ip_address; *//* Do not reverse bytes */
         buffer[0x3E] = profile->subnet_mask;
-        *((unsigned int*)&buffer[0x3F]) = profile->gateway_address; /* Do not reverse bytes */
+        memcpy(&buffer[0x3F],&profile->gateway_address,sizeof(profile->gateway_address));
+        /**((unsigned int*)&buffer[0x3F]) = profile->gateway_address; */ /* Do not reverse bytes */
         buffer[0x43] = profile->address_mode;
         
         /* Wifi parameters */
         buffer[0x44] = profile->access_mode;
         buffer[0x45] = profile->wifi_channel;
         
         htod32a(&buffer[0x46], 33); /* essid */
          /* 32 as third parameter, so there will always be a null-byte in the end */
         strncpy((char*)&buffer[0x4A], profile->essid, 32);
         
@@ skipping 11 matching lines @@
                 htod16a(&buffer[0xC2], 5); /* (64-24)/8 = 5 */
                 break;
         case 2: /* WEP 128bit */
                 htod16a(&buffer[0xC2], 13); /* (128-24)/8 = 13 */
                 break;
         default:
                 htod16a(&buffer[0xC2], 0);
         }
         size = 0xC4;
                
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_NIKON_SendProfileData;
-        ptp.Nparam=1;
-        ptp.Param1=profilenr;
+        PTP_CNT_INIT(ptp, PTP_OC_NIKON_SendProfileData, profilenr);
         return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
 }
 
 /**
  * ptp_mtp_getobjectpropssupported:
  *
  * This command gets the object properties possible from the device.
  *  
  * params:      PTPParams*
  *      uint ofc                - object format code
  *      unsigned int *propnum   - number of elements in returned array
  *      uint16_t *props         - array of supported properties
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_mtp_getobjectpropssupported (PTPParams* params, uint16_t ofc,
                  uint32_t *propnum, uint16_t **props
 ) {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *data = NULL;
-        unsigned int size = 0;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_GetObjectPropsSupported;
-        ptp.Nparam = 1;
-        ptp.Param1 = ofc;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret == PTP_RC_OK)
-                *propnum=ptp_unpack_uint16_t_array(params,data,0,props);
+        PTPContainer    ptp;
+        unsigned char   *data = NULL;
+        unsigned int    xsize = 0;
+
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjectPropsSupported, ofc);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &xsize));
+        *propnum=ptp_unpack_uint16_t_array (params, data, 0, xsize, props);
         free(data);
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_mtp_getobjectpropdesc:
  *
  * This command gets the object property description.
  *  
  * params:      PTPParams*
  *      uint16_t opc    - object property code
  *      uint16_t ofc    - object format code
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_mtp_getobjectpropdesc (
         PTPParams* params, uint16_t opc, uint16_t ofc, PTPObjectPropDesc *opd
 ) {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *data = NULL;
-        unsigned int size = 0;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_GetObjectPropDesc;
-        ptp.Nparam = 2;
-        ptp.Param1 = opc;
-        ptp.Param2 = ofc;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret == PTP_RC_OK)
-                ptp_unpack_OPD (params, data, opd, size);
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjectPropDesc, opc, ofc);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        ptp_unpack_OPD (params, data, opd, size);
         free(data);
-        return ret;
+        return PTP_RC_OK;
 }
 
 /**
  * ptp_mtp_getobjectpropvalue:
  *
  * This command gets the object properties of an object handle.
  *  
  * params:      PTPParams*
  *      uint32_t objectid       - object format code
  *      uint16_t opc            - object prop code
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_mtp_getobjectpropvalue (
         PTPParams* params, uint32_t oid, uint16_t opc,
         PTPPropertyValue *value, uint16_t datatype
 ) {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *data = NULL;
-        unsigned int size = 0;
-        int offset = 0;
+        PTPContainer    ptp;
+        uint16_t        ret = PTP_RC_OK;
+        unsigned char   *data;
+        unsigned int    size, offset = 0;
         
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_GetObjectPropValue;
-        ptp.Nparam = 2;
-        ptp.Param1 = oid;
-        ptp.Param2 = opc;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size);
-        if (ret == PTP_RC_OK)
-                ptp_unpack_DPV(params, data, &offset, size, value, datatype);
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjectPropValue, oid, opc);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        if (!ptp_unpack_DPV(params, data, &offset, size, value, datatype)) {
+                ptp_debug (params, "ptp_mtp_getobjectpropvalue: unpacking DPV failed");
+                ret = PTP_RC_GeneralError;
+        }
         free(data);
         return ret;
 }
 
 /**
  * ptp_mtp_setobjectpropvalue:
  *
  * This command gets the object properties of an object handle.
  *  
  * params:      PTPParams*
  *      uint32_t objectid       - object format code
  *      uint16_t opc            - object prop code
  *
  * Return values: Some PTP_RC_* code.
  *
  **/
 uint16_t
 ptp_mtp_setobjectpropvalue (
         PTPParams* params, uint32_t oid, uint16_t opc,
         PTPPropertyValue *value, uint16_t datatype
 ) {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char *data = NULL;
-        unsigned int size ;
-        
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_SetObjectPropValue;
-        ptp.Nparam = 2;
-        ptp.Param1 = oid;
-        ptp.Param2 = opc;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
+
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_SetObjectPropValue, oid, opc);
         size = ptp_pack_DPV(params, value, &data, datatype);
         ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
         free(data);
         return ret;
 }
 
 uint16_t
 ptp_mtp_getobjectreferences (PTPParams* params, uint32_t handle, uint32_t** ohArray, uint32_t* arraylen)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        unsigned char* dpv=NULL;
-        unsigned int dpvlen = 0;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_GetObjectReferences;
-        ptp.Param1=handle;
-        ptp.Nparam=1;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &dpv, &dpvlen);
-        if (ret == PTP_RC_OK) {
-                /* Sandisk Sansa skips the DATA phase, but returns OK as response.
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjectReferences, handle);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data , &size));
+        /* Sandisk Sansa skips the DATA phase, but returns OK as response.
                  * this will gives us a NULL here. Handle it. -Marcus */
-                if ((dpv == NULL) || (dpvlen == 0)) {
-                        *arraylen = 0;
-                        *ohArray = NULL;
-                } else {
-                        *arraylen = ptp_unpack_uint32_t_array(params, dpv, 0, ohArray);
-                }
+        if ((data == NULL) || (size == 0)) {
+                *arraylen = 0;
+                *ohArray = NULL;
+        } else {
+                *arraylen = ptp_unpack_uint32_t_array(params, data , 0, size, ohArray);
         }
-        free(dpv);
-        return ret;
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_mtp_setobjectreferences (PTPParams* params, uint32_t handle, uint32_t* ohArray, uint32_t arraylen)
 {
-        PTPContainer ptp;
-        uint16_t ret;
-        uint32_t size;
-        unsigned char* dpv=NULL;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code   = PTP_OC_MTP_SetObjectReferences;
-        ptp.Param1 = handle;
-        ptp.Nparam = 1;
-        size = ptp_pack_uint32_t_array(params, ohArray, arraylen, &dpv);
-        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, (unsigned char **)&dpv, NULL);
-        free(dpv);
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_SetObjectReferences, handle);
+        size = ptp_pack_uint32_t_array(params, ohArray, arraylen, &data);
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
         return ret;
 }
 
 uint16_t
 ptp_mtp_getobjectproplist (PTPParams* params, uint32_t handle, MTPProperties **props, int *nrofprops)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* opldata = NULL;
-        unsigned int oplsize;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_MTP_GetObjPropList;
-        ptp.Param1 = handle;
-        ptp.Param2 = 0x00000000U;  /* 0x00000000U should be "all formats" */
-        ptp.Param3 = 0xFFFFFFFFU;  /* 0xFFFFFFFFU should be "all properties" */
-        ptp.Param4 = 0x00000000U;
-        ptp.Param5 = 0xFFFFFFFFU;  /* means - return full tree below the Param1 handle */
-        ptp.Nparam = 5;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &opldata, &oplsize);  
-        if (ret == PTP_RC_OK) *nrofprops = ptp_unpack_OPL(params, opldata, props, oplsize);
-        if (opldata != NULL)
-                free(opldata);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjPropList, handle,
+                     0x00000000U,  /* 0x00000000U should be "all formats" */
+                     0xFFFFFFFFU,  /* 0xFFFFFFFFU should be "all properties" */
+                     0x00000000U,
+                     0xFFFFFFFFU  /* means - return full tree below the Param1 handle */
+        );
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        *nrofprops = ptp_unpack_OPL(params, data, props, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_mtp_getobjectproplist_single (PTPParams* params, uint32_t handle, MTPProperties **props, int *nrofprops)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* opldata = NULL;
-        unsigned int oplsize;
+        PTPContainer    ptp;
+        unsigned char   *data;
+        unsigned int    size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_MTP_GetObjPropList;
-        ptp.Param1 = handle;
-        ptp.Param2 = 0x00000000U;  /* 0x00000000U should be "all formats" */
-        ptp.Param3 = 0xFFFFFFFFU;  /* 0xFFFFFFFFU should be "all properties" */
-        ptp.Param4 = 0x00000000U;
-        ptp.Param5 = 0x00000000U;  /* means - return single tree below the Param1 handle */
-        ptp.Nparam = 5;
-        ret = ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &opldata, &oplsize);  
-        if (ret == PTP_RC_OK) *nrofprops = ptp_unpack_OPL(params, opldata, props, oplsize);
-        if (opldata != NULL)
-                free(opldata);
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_GetObjPropList, handle,
+                     0x00000000U,  /* 0x00000000U should be "all formats" */
+                     0xFFFFFFFFU,  /* 0xFFFFFFFFU should be "all properties" */
+                     0x00000000U,
+                     0x00000000U  /* means - return single tree below the Param1 handle */
+        );
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, &size));
+        *nrofprops = ptp_unpack_OPL(params, data, props, size);
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_mtp_sendobjectproplist (PTPParams* params, uint32_t* store, uint32_t* parenthandle, uint32_t* handle,
                             uint16_t objecttype, uint64_t objectsize, MTPProperties *props, int nrofprops)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* opldata=NULL;
-        uint32_t oplsize;
+        PTPContainer    ptp;
+        uint16_t        ret;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_MTP_SendObjectPropList;
-        ptp.Param1 = *store;
-        ptp.Param2 = *parenthandle;
-        ptp.Param3 = (uint32_t) objecttype;
-        ptp.Param4 = (uint32_t) (objectsize >> 32);
-        ptp.Param5 = (uint32_t) (objectsize & 0xffffffffU);
-        ptp.Nparam = 5;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_SendObjectPropList, *store, *parenthandle, (uint32_t) objecttype,
+                     (uint32_t) (objectsize >> 32), (uint32_t) (objectsize & 0xffffffffU)
+        );
 
         /* Set object handle to 0 for a new object */
-        oplsize = ptp_pack_OPL(params,props,nrofprops,&opldata);
-        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, oplsize, &opldata, NULL); 
-        free(opldata);
+        size = ptp_pack_OPL(params,props,nrofprops,&data);
+        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL);
+        free(data);
         *store = ptp.Param1;
         *parenthandle = ptp.Param2;
         *handle = ptp.Param3; 
 
         return ret;
 }
 
 uint16_t
 ptp_mtp_setobjectproplist (PTPParams* params, MTPProperties *props, int nrofprops)
 {
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* opldata=NULL;
-        uint32_t oplsize;
-  
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_MTP_SetObjPropList;
-        ptp.Nparam = 0;
-  
-        oplsize = ptp_pack_OPL(params,props,nrofprops,&opldata);
-        ret = ptp_transaction(params, &ptp, PTP_DP_SENDDATA, oplsize, &opldata, NULL); 
-        free(opldata);
+        PTPContainer    ptp;
+        unsigned char   *data = NULL;
+        uint32_t        size;
 
-        return ret;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_SetObjPropList);
+        size = ptp_pack_OPL(params,props,nrofprops,&data);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, &data, NULL));
+        free(data);
+        return PTP_RC_OK;
 }
 
 uint16_t
 ptp_mtpz_sendwmdrmpdapprequest (PTPParams* params, unsigned char *appcertmsg, uint32_t size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_MTP_WMDRMPD_SendWMDRMPDAppRequest;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_WMDRMPD_SendWMDRMPDAppRequest);
         return ptp_transaction (params, &ptp, PTP_DP_SENDDATA, size, &appcertmsg, NULL);
 }
 
 uint16_t
 ptp_mtpz_getwmdrmpdappresponse (PTPParams* params, unsigned char **response, uint32_t *size)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code = PTP_OC_MTP_WMDRMPD_GetWMDRMPDAppResponse;
+        PTP_CNT_INIT(ptp, PTP_OC_MTP_WMDRMPD_GetWMDRMPDAppResponse);
         *size = 0;
         *response = NULL;
         return ptp_transaction (params, &ptp, PTP_DP_GETDATA, 0, response, size);
 }
 
 /****** CHDK interface ******/
 
 uint16_t
-ptp_chdk_get_memory(PTPParams* params, int start, int num, unsigned char **buf )
+ptp_chdk_get_memory(PTPParams* params, int start, int num, unsigned char **buf)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=3;
-        ptp.Param1=PTP_CHDK_GetMemory;
-        ptp.Param2=start;
-        ptp.Param3=num;
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_GetMemory, start, num);
         return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, buf, NULL);
 }
 
+uint16_t
+ptp_chdk_set_memory_long(PTPParams* params, int addr, int val)
+{
+        PTPContainer ptp;
+        unsigned char *buf = (unsigned char *) &val; /* FIXME ... endianness? */
 
-uint16_t
-ptp_chdk_call(PTPParams* params, int *args, int size, int *ret)
-{
-        uint16_t r;
-        PTPContainer ptp;
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=1;
-        ptp.Param1=PTP_CHDK_CallFunction;
-
-        /* FIXME: check int packing */
-        r=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size*sizeof(int), (unsigned char **) &args, NULL);
-        if ( r == PTP_RC_OK )
-                return r;
-        if ( ret )
-                *ret = ptp.Param1;
-        return r;
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_SetMemory, addr, 4);
+        return ptp_transaction(params, &ptp, PTP_DP_SENDDATA, 4, &buf, NULL);
 }
 
 uint16_t
-ptp_chdk_get_propcase(PTPParams* params, int start, int num, int* ints)
+ptp_chdk_download(PTPParams* params, char *remote_fn, PTPDataHandler *handler)
 {
         PTPContainer ptp;
 
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=3;
-        ptp.Param1=PTP_CHDK_GetPropCase;
-        ptp.Param2=start;
-        ptp.Param3=num;
-        /* FIXME: unpack ints correctly */
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, (unsigned char**)ints, NULL);
-}
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_TempData, 0);
+        CHECK_PTP_RC (ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(remote_fn), (unsigned char**)&remote_fn, NULL));
 
-uint16_t
-ptp_chdk_get_paramdata(PTPParams* params, int start, int num, unsigned char **buf)
-{
-        PTPContainer ptp;
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=3;
-        ptp.Param1=PTP_CHDK_GetParamData;
-        ptp.Param2=start;
-        ptp.Param3=num;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, buf, NULL);
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_DownloadFile);
+        return ptp_transaction_new (params, &ptp, PTP_DP_GETDATA, 0, handler);
 }
 
 #if 0
-int ptp_chdk_upload(char *local_fn, char *remote_fn, PTPParams* params, PTPDeviceInfo* deviceinfo)
+int ptp_chdk_upload(PTPParams* params, char *local_fn, char *remote_fn)
 {
   uint16_t ret;
   PTPContainer ptp;
   char *buf = NULL;
   FILE *f;
-  int s,l;
-  struct stat st_buf;
+  unsigned file_len,data_len,file_name_len;
 
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=2;
-  ptp.Param1=PTP_CHDK_UploadFile;
-
-  if (stat(local_fn, &st_buf)==0) ptp.Param2=st_buf.st_mtime-_timezone-_daylight; else ptp.Param2=0;
+  PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_UploadFile);
 
   f = fopen(local_fn,"rb");
   if ( f == NULL )
   {
     ptp_error(params,"could not open file \'%s\'",local_fn);
     return 0;
   }
 
-
   fseek(f,0,SEEK_END);
-  s = ftell(f);
+  file_len = ftell(f);
   fseek(f,0,SEEK_SET);
 
-  l = strlen(remote_fn);
-  buf = malloc(4+l+s);
-  memcpy(buf,&l,4);
-  memcpy(buf+4,remote_fn,l);
-  fread(buf+4+l,1,s,f);
+  file_name_len = strlen(remote_fn);
+  data_len = 4 + file_name_len + file_len;
+  buf = malloc(data_len);
+  memcpy(buf,&file_name_len,4);
+  memcpy(buf+4,remote_fn,file_name_len);
+  fread(buf+4+file_name_len,1,file_len,f);
 
   fclose(f);
 
-  ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, 4+l+s, &buf);
+  ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, data_len, &buf, NULL);
 
   free(buf);
 
-  if ( ret != 0x2001 )
+  if ( ret != PTP_RC_OK )
   {
     ptp_error(params,"unexpected return code 0x%x",ret);
     return 0;
   }
   return 1;
 }
 
-int ptp_chdk_download(char *remote_fn, char *local_fn, PTPParams* params, PTPDeviceInfo* deviceinfo)
-{
-  uint16_t ret;
-  PTPContainer ptp;
-  char *buf = NULL;
-  FILE *f;
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_TempData;
-  ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(remote_fn), &remote_fn);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return 0;
-  }
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_DownloadFile;
-
-  ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &buf);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return 0;
-  }
-
-  f = fopen(local_fn,"wb");
-  if ( f == NULL )
-  {
-    ptp_error(params,"could not open file \'%s\'",local_fn);
-    free(buf);
-    return 0;
-  }
-
-  fwrite(buf,1,ptp.Param1,f);
-  fclose(f);
-
-  free(buf);
-
-  return 1;
-}
 #endif
 
-uint16_t
-ptp_chdk_exec_lua(PTPParams* params, char *script, uint32_t *ret)
-{
-        uint16_t r;
-        PTPContainer ptp;
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=1;
-        ptp.Param1=PTP_CHDK_ExecuteLUA;
-        r=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(script)+1, (unsigned char**)&script, NULL);
-        if ( r != PTP_RC_OK )
-                return r;
-        *ret = ptp.Param1;
-        return r;
-}
-
-uint16_t
-ptp_chdk_get_script_output(PTPParams* params, char** scriptoutput) {
-        PTPContainer ptp;
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=1;
-        ptp.Param1=PTP_CHDK_GetScriptOutput;
-        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, (unsigned char **)scriptoutput, NULL);
-}
-
-#if 0
-void ptp_chdk_opendir(char *dir, PTPParams* params, PTPDeviceInfo* deviceinfo){
-  uint16_t ret;
-  PTPContainer ptp;
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_OpenDir;
-  ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(dir)+1, (char*)&dir);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return;
-  }
-}
-
-void ptp_chdk_closedir(PTPParams* params, PTPDeviceInfo* deviceinfo){
-  uint16_t ret;
-  PTPContainer ptp;
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_CloseDir;
-  ret=ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return;
-  }
-}
-
-struct fileinfo* ptp_chdk_readdir(PTPParams* params, PTPDeviceInfo* deviceinfo){
-  uint16_t ret;
-  PTPContainer ptp;
-  char* buf=NULL;
-  static struct fileinfo fi;
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_ReadDir;
-  ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &buf);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return NULL;
-  }
-  if (buf){
-   memcpy(&fi, buf, sizeof(fi));
-   free(buf);
-  }
-
-  return &fi;
-
-}
-
-void ptp_chdk_download_alt_end(PTPParams* params, PTPDeviceInfo* deviceinfo){ // internal use
-  uint16_t ret;
-  PTPContainer ptp;
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_EndDownloadFile;
-  ret=ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL);
-  if ( ret != 0x2001 ) ptp_error(params,"unexpected return code 0x%x",ret);
-}
-
-int ptp_chdk_download_alt(char *remote_fn, char *local_fn, PTPParams* params, PTPDeviceInfo* deviceinfo)
-{
-  uint16_t ret;
-  PTPContainer ptp;
-  char *buf = NULL;
-  FILE *f;
-
-  PTP_CNT_INIT(ptp);
-  ptp.Code=PTP_OC_CHDK;
-  ptp.Nparam=1;
-  ptp.Param1=PTP_CHDK_StartDownloadFile;
-  ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(remote_fn)+1, &remote_fn);
-  if ( ret != 0x2001 )
-  {
-    ptp_error(params,"unexpected return code 0x%x",ret);
-    return 0;
-  }
-  f = fopen(local_fn,"wb");
-  if ( f == NULL )
-  {
-    ptp_error(params,"could not open file \'%s\'",local_fn);
-    return 0;
-  }
-
-  while(1) {
-   PTP_CNT_INIT(ptp);
-   ptp.Code=PTP_OC_CHDK;
-   ptp.Nparam=1;
-   ptp.Param1=PTP_CHDK_ResumeDownloadFile;
-   buf=NULL;
-   ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &buf);
-   if ( ret != 0x2001 )
-   {
-     ptp_error(params,"unexpected return code 0x%x",ret);
-     ptp_chdk_download_alt_end(params, deviceinfo);
-     fclose(f);
-     return 0;
-   }
-
-   if (ptp.Param1<=0){free(buf); break;}
-   fwrite(buf, 1, ptp.Param1, f);
-   free(buf);
-  }
-  fclose(f);
-  ptp_chdk_download_alt_end(params, deviceinfo);
-  return 1;
-}
-#endif
-
-uint16_t
-ptp_chdk_get_video_settings(PTPParams* params, ptp_chdk_videosettings* vsettings)
-{
-        uint16_t ret;
-        PTPContainer ptp;
-        unsigned char* buf=NULL;
-
-        PTP_CNT_INIT(ptp);
-        ptp.Code=PTP_OC_CHDK;
-        ptp.Nparam=1;
-        ptp.Param1=PTP_CHDK_GetVideoSettings;
-        ret=ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &buf, NULL);
-        if ( ret != PTP_RC_OK )
-                return ret;
-        if (buf) {
-                /* FIXME: endian convert */
-                memcpy(vsettings, buf, sizeof(ptp_chdk_videosettings));
-                free(buf);
+/*
+ * Preliminary remote capture over USB code. Corresponding CHDK code is in the ptp-remote-capture-test
+ * This is under development and should not be included in builds for general distribution
+ */
+/*
+ * isready: 0: not ready, lowest 2 bits: available image formats, 0x10000000: error
+ */
+uint16_t
+ptp_chdk_rcisready(PTPParams* params, int *isready, int *imgnum)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_RemoteCaptureIsReady);
+        *isready = *imgnum = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        *isready=ptp.Param1;
+        *imgnum=ptp.Param2;
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_rcgetchunk(PTPParams* params, int fmt, ptp_chdk_rc_chunk *chunk)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_RemoteCaptureGetData, fmt); //get chunk
+
+        chunk->data = NULL;
+        chunk->size = 0;
+        chunk->offset = 0;
+        chunk->last = 0;
+        // TODO should allow ptp_getdata_transaction to send chunks directly to file, or to mem
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &chunk->data, NULL));
+        chunk->size = ptp.Param1;
+        chunk->last = (ptp.Param2 == 0);
+        chunk->offset = ptp.Param3; //-1 for none
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_exec_lua(PTPParams* params, char *script, int flags, int *script_id, int *status)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_ExecuteScript, PTP_CHDK_SL_LUA | flags);
+        *script_id = 0;
+        *status = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_SENDDATA, strlen(script)+1, (unsigned char**)&script, NULL));
+        *script_id = ptp.Param1;
+        *status = ptp.Param2;
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_get_version(PTPParams* params, int *major, int *minor)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_Version);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        *major = ptp.Param1;
+        *minor = ptp.Param2;
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_get_script_status(PTPParams* params, unsigned *status)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_ScriptStatus);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        *status = ptp.Param1;
+        return PTP_RC_OK;
+}
+uint16_t
+ptp_chdk_get_script_support(PTPParams* params, unsigned *status)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_ScriptSupport);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_NODATA, 0, NULL, NULL));
+        *status = ptp.Param1;
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_write_script_msg(PTPParams* params, char *data, unsigned size, int target_script_id, int *status)
+{
+        PTPContainer ptp;
+
+        // a zero length data phase appears to do bad things, camera stops responding to PTP
+        if(!size) {
+                ptp_error(params,"zero length message not allowed");
+                *status = 0;
+                return PTP_ERROR_BADPARAM;
         }
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_WriteScriptMsg, target_script_id);
+        *status = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size, (unsigned char**)&data, NULL));
+        *status = ptp.Param1;
+        return PTP_RC_OK;
+}
+uint16_t
+ptp_chdk_read_script_msg(PTPParams* params, ptp_chdk_script_msg **msg)
+{
+        PTPContainer    ptp;
+        unsigned char   *data;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_ReadScriptMsg);
+
+        *msg = NULL;
+
+        /* camera will always send data, otherwise getdata will cause problems */
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, &data, NULL));
+
+        /* for convenience, always allocate an extra byte and null it*/
+        *msg = malloc(sizeof(ptp_chdk_script_msg) + ptp.Param4 + 1);
+        (*msg)->type = ptp.Param1;
+        (*msg)->subtype = ptp.Param2;
+        (*msg)->script_id = ptp.Param3;
+        (*msg)->size = ptp.Param4;
+        memcpy((*msg)->data,data,(*msg)->size);
+        (*msg)->data[(*msg)->size] = 0;
+        free(data);
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_get_live_data(PTPParams* params, unsigned flags, unsigned char **data, unsigned int *data_size)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_GetDisplayData, flags);
+        *data_size = 0;
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, data, NULL));
+        *data_size = ptp.Param1;
+        return PTP_RC_OK;
+}
+
+uint16_t
+ptp_chdk_call_function(PTPParams* params, int *args, int size, int *ret)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_CHDK, PTP_CHDK_CallFunction);
+        CHECK_PTP_RC(ptp_transaction(params, &ptp, PTP_DP_SENDDATA, size*sizeof(int), (unsigned char **) &args, NULL));
+        if (ret)
+                *ret = ptp.Param1;
+        return PTP_RC_OK;
+}
+
+
+
+
+/**
+ * Android MTP Extensions
+ */
+
+/**
+ * ptp_android_getpartialobject64:
+ * params:      PTPParams*
+ *              handle                  - Object handle
+ *              offset                  - Offset into object
+ *              maxbytes                - Maximum of bytes to read
+ *              object                  - pointer to data area
+ *              len                     - pointer to returned length
+ *
+ * Get object 'handle' from device and store the data in newly
+ * allocated 'object'. Start from offset and read at most maxbytes.
+ *
+ * This is a 64bit offset version of the standard GetPartialObject.
+ *
+ * Return values: Some PTP_RC_* code.
+ **/
+uint16_t
+ptp_android_getpartialobject64 (PTPParams* params, uint32_t handle, uint64_t offset,
+                                uint32_t maxbytes, unsigned char** object,
+                                uint32_t *len)
+{
+        PTPContainer ptp;
+
+        PTP_CNT_INIT(ptp, PTP_OC_ANDROID_GetPartialObject64, handle, offset & 0xFFFFFFFF, offset >> 32, maxbytes);
+        return ptp_transaction(params, &ptp, PTP_DP_GETDATA, 0, object, len);
+}
+
+uint16_t
+ptp_android_sendpartialobject (PTPParams* params, uint32_t handle, uint64_t offset,
+                                unsigned char* object,  uint32_t len)
+{
+        PTPContainer    ptp;
+        uint16_t        ret;
+
+        PTP_CNT_INIT(ptp, PTP_OC_ANDROID_SendPartialObject, handle, offset & 0xFFFFFFFF, offset >> 32, len);
+
+        /*
+         * MtpServer.cpp is buggy: it uses write() without offset
+         * rather than pwrite to send the data for data coming with
+         * the header packet
+         */
+        params->split_header_data = 1;
+        ret=ptp_transaction(params, &ptp, PTP_DP_SENDDATA, len, &object, NULL);
+        params->split_header_data = 0;
+
         return ret;
 }
 
 
-
 /* Non PTP protocol functions */
 /* devinfo testing functions */
 
 int
 ptp_event_issupported(PTPParams* params, uint16_t event)
 {
-        int i=0;
+        unsigned int i=0;
 
         for (;i<params->deviceinfo.EventsSupported_len;i++) {
                 if (params->deviceinfo.EventsSupported[i]==event)
                         return 1;
         }
         return 0;
 }
 
 
 int
 ptp_property_issupported(PTPParams* params, uint16_t property)
 {
-        int i;
+        unsigned int i;
 
         for (i=0;i<params->deviceinfo.DevicePropertiesSupported_len;i++)
                 if (params->deviceinfo.DevicePropertiesSupported[i]==property)
                         return 1;
         return 0;
 }
 
-/* ptp structures freeing functions */
-void
-ptp_free_devicepropvalue(uint16_t dt, PTPPropertyValue* dpd) {
-        switch (dt) {
-        case PTP_DTC_INT8:      case PTP_DTC_UINT8:
-        case PTP_DTC_UINT16:    case PTP_DTC_INT16:
-        case PTP_DTC_UINT32:    case PTP_DTC_INT32:
-        case PTP_DTC_UINT64:    case PTP_DTC_INT64:
-        case PTP_DTC_UINT128:   case PTP_DTC_INT128:
-                /* Nothing to free */
-                break;
-        case PTP_DTC_AINT8:     case PTP_DTC_AUINT8:
-        case PTP_DTC_AUINT16:   case PTP_DTC_AINT16:
-        case PTP_DTC_AUINT32:   case PTP_DTC_AINT32:
-        case PTP_DTC_AUINT64:   case PTP_DTC_AINT64:
-        case PTP_DTC_AUINT128:  case PTP_DTC_AINT128:
-                if (dpd->a.v)
-                        free(dpd->a.v);
-                break;
-        case PTP_DTC_STR:
-                if (dpd->str)
-                        free(dpd->str);
-                break;
-        }
-}
-
-void
-ptp_free_devicepropdesc(PTPDevicePropDesc* dpd)
-{
-        uint16_t i;
-
-        ptp_free_devicepropvalue (dpd->DataType, &dpd->FactoryDefaultValue);
-        ptp_free_devicepropvalue (dpd->DataType, &dpd->CurrentValue);
-        switch (dpd->FormFlag) {
-        case PTP_DPFF_Range:
-                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.MinimumValue);
-                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.MaximumValue);
-                ptp_free_devicepropvalue (dpd->DataType, &dpd->FORM.Range.StepSize);
-                break;
-        case PTP_DPFF_Enumeration:
-                if (dpd->FORM.Enum.SupportedValue) {
-                        for (i=0;i<dpd->FORM.Enum.NumberOfValues;i++)
-                                ptp_free_devicepropvalue (dpd->DataType, dpd->FORM.Enum.SupportedValue+i);
-                        free (dpd->FORM.Enum.SupportedValue);
-                }
-        }
-}
-
-void
-ptp_free_objectpropdesc(PTPObjectPropDesc* opd)
-{
-        uint16_t i;
-
-        ptp_free_devicepropvalue (opd->DataType, &opd->FactoryDefaultValue);
-        switch (opd->FormFlag) {
-        case PTP_OPFF_None:
-                break;
-        case PTP_OPFF_Range:
-                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.MinimumValue);
-                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.MaximumValue);
-                ptp_free_devicepropvalue (opd->DataType, &opd->FORM.Range.StepSize);
-                break;
-        case PTP_OPFF_Enumeration:
-                if (opd->FORM.Enum.SupportedValue) {
-                        for (i=0;i<opd->FORM.Enum.NumberOfValues;i++)
-                                ptp_free_devicepropvalue (opd->DataType, opd->FORM.Enum.SupportedValue+i);
-                        free (opd->FORM.Enum.SupportedValue);
-                }
-                break;
-        case PTP_OPFF_DateTime:
-        case PTP_OPFF_FixedLengthArray:
-        case PTP_OPFF_RegularExpression:
-        case PTP_OPFF_ByteArray:
-        case PTP_OPFF_LongString:
-                /* Ignore these presently, we cannot unpack them, so there is nothing to be freed. */
-                break;
-        default:
-                fprintf (stderr, "Unknown OPFF type %d\n", opd->FormFlag);
-                break;
-        }
-}
-
 void
 ptp_free_objectinfo (PTPObjectInfo *oi)
 {
         if (!oi) return;
         free (oi->Filename); oi->Filename = NULL;
         free (oi->Keywords); oi->Keywords = NULL;
 }
 
 void
 ptp_free_object (PTPObject *ob)
 {
-        int i;
+        unsigned int i;
         if (!ob) return;
 
         ptp_free_objectinfo (&ob->oi);
         for (i=0;i<ob->nrofmtpprops;i++)
                 ptp_destroy_object_prop(&ob->mtpprops[i]);
         ob->flags = 0;
 }
 
-const char *
-ptp_strerror(uint16_t error) {
+/* PTP error descriptions */
+static struct {
+        uint16_t rc;
+        uint16_t vendor;
+        const char *txt;
+} ptp_errors[] = {
+        {PTP_RC_Undefined,              0, N_("PTP Undefined Error")},
+        {PTP_RC_OK,                     0, N_("PTP OK!")},
+        {PTP_RC_GeneralError,           0, N_("PTP General Error")},
+        {PTP_RC_SessionNotOpen,         0, N_("PTP Session Not Open")},
+        {PTP_RC_InvalidTransactionID,   0, N_("PTP Invalid Transaction ID")},
+        {PTP_RC_OperationNotSupported,  0, N_("PTP Operation Not Supported")},
+        {PTP_RC_ParameterNotSupported,  0, N_("PTP Parameter Not Supported")},
+        {PTP_RC_IncompleteTransfer,     0, N_("PTP Incomplete Transfer")},
+        {PTP_RC_InvalidStorageId,       0, N_("PTP Invalid Storage ID")},
+        {PTP_RC_InvalidObjectHandle,    0, N_("PTP Invalid Object Handle")},
+        {PTP_RC_DevicePropNotSupported, 0, N_("PTP Device Prop Not Supported")},
+        {PTP_RC_InvalidObjectFormatCode,0, N_("PTP Invalid Object Format Code")},
+        {PTP_RC_StoreFull,              0, N_("PTP Store Full")},
+        {PTP_RC_ObjectWriteProtected,   0, N_("PTP Object Write Protected")},
+        {PTP_RC_StoreReadOnly,          0, N_("PTP Store Read Only")},
+        {PTP_RC_AccessDenied,           0, N_("PTP Access Denied")},
+        {PTP_RC_NoThumbnailPresent,     0, N_("PTP No Thumbnail Present")},
+        {PTP_RC_SelfTestFailed,         0, N_("PTP Self Test Failed")},
+        {PTP_RC_PartialDeletion,        0, N_("PTP Partial Deletion")},
+        {PTP_RC_StoreNotAvailable,      0, N_("PTP Store Not Available")},
+        {PTP_RC_SpecificationByFormatUnsupported, 0, N_("PTP Specification By Format Unsupported")},
+        {PTP_RC_NoValidObjectInfo,      0, N_("PTP No Valid Object Info")},
+        {PTP_RC_InvalidCodeFormat,      0, N_("PTP Invalid Code Format")},
+        {PTP_RC_UnknownVendorCode,      0, N_("PTP Unknown Vendor Code")},
+        {PTP_RC_CaptureAlreadyTerminated, 0, N_("PTP Capture Already Terminated")},
+        {PTP_RC_DeviceBusy,             0, N_("PTP Device Busy")},
+        {PTP_RC_InvalidParentObject,    0, N_("PTP Invalid Parent Object")},
+        {PTP_RC_InvalidDevicePropFormat,0, N_("PTP Invalid Device Prop Format")},
+        {PTP_RC_InvalidDevicePropValue, 0, N_("PTP Invalid Device Prop Value")},
+        {PTP_RC_InvalidParameter,       0, N_("PTP Invalid Parameter")},
+        {PTP_RC_SessionAlreadyOpened,   0, N_("PTP Session Already Opened")},
+        {PTP_RC_TransactionCanceled,    0, N_("PTP Transaction Canceled")},
+        {PTP_RC_SpecificationOfDestinationUnsupported, 0, N_("PTP Specification Of Destination Unsupported")},
 
-        int i;
-        /* PTP error descriptions */
-        static struct {
-                short n;
-                const char *txt;
-        } ptp_errors[] = {
-        {PTP_RC_Undefined,              N_("PTP: Undefined Error")},
-        {PTP_RC_OK,                     N_("PTP: OK!")},
-        {PTP_RC_GeneralError,           N_("PTP: General Error")},
-        {PTP_RC_SessionNotOpen,         N_("PTP: Session Not Open")},
-        {PTP_RC_InvalidTransactionID,   N_("PTP: Invalid Transaction ID")},
-        {PTP_RC_OperationNotSupported,  N_("PTP: Operation Not Supported")},
-        {PTP_RC_ParameterNotSupported,  N_("PTP: Parameter Not Supported")},
-        {PTP_RC_IncompleteTransfer,     N_("PTP: Incomplete Transfer")},
-        {PTP_RC_InvalidStorageId,       N_("PTP: Invalid Storage ID")},
-        {PTP_RC_InvalidObjectHandle,    N_("PTP: Invalid Object Handle")},
-        {PTP_RC_DevicePropNotSupported, N_("PTP: Device Prop Not Supported")},
-        {PTP_RC_InvalidObjectFormatCode, N_("PTP: Invalid Object Format Code")},
-        {PTP_RC_StoreFull,              N_("PTP: Store Full")},
-        {PTP_RC_ObjectWriteProtected,   N_("PTP: Object Write Protected")},
-        {PTP_RC_StoreReadOnly,          N_("PTP: Store Read Only")},
-        {PTP_RC_AccessDenied,           N_("PTP: Access Denied")},
-        {PTP_RC_NoThumbnailPresent,     N_("PTP: No Thumbnail Present")},
-        {PTP_RC_SelfTestFailed,         N_("PTP: Self Test Failed")},
-        {PTP_RC_PartialDeletion,        N_("PTP: Partial Deletion")},
-        {PTP_RC_StoreNotAvailable,      N_("PTP: Store Not Available")},
-        {PTP_RC_SpecificationByFormatUnsupported,
-                                N_("PTP: Specification By Format Unsupported")},
-        {PTP_RC_NoValidObjectInfo,      N_("PTP: No Valid Object Info")},
-        {PTP_RC_InvalidCodeFormat,      N_("PTP: Invalid Code Format")},
-        {PTP_RC_UnknownVendorCode,      N_("PTP: Unknown Vendor Code")},
-        {PTP_RC_CaptureAlreadyTerminated,
-                                        N_("PTP: Capture Already Terminated")},
-        {PTP_RC_DeviceBusy,             N_("PTP: Device Busy")},
-        {PTP_RC_InvalidParentObject,    N_("PTP: Invalid Parent Object")},
-        {PTP_RC_InvalidDevicePropFormat, N_("PTP: Invalid Device Prop Format")},
-        {PTP_RC_InvalidDevicePropValue, N_("PTP: Invalid Device Prop Value")},
-        {PTP_RC_InvalidParameter,       N_("PTP: Invalid Parameter")},
-        {PTP_RC_SessionAlreadyOpened,   N_("PTP: Session Already Opened")},
-        {PTP_RC_TransactionCanceled,    N_("PTP: Transaction Canceled")},
-        {PTP_RC_SpecificationOfDestinationUnsupported,
-                        N_("PTP: Specification Of Destination Unsupported")},
-        {PTP_RC_EK_FilenameRequired,    N_("PTP: EK Filename Required")},
-        {PTP_RC_EK_FilenameConflicts,   N_("PTP: EK Filename Conflicts")},
-        {PTP_RC_EK_FilenameInvalid,     N_("PTP: EK Filename Invalid")},
+        {PTP_RC_EK_FilenameRequired,    PTP_VENDOR_EASTMAN_KODAK, N_("Filename Required")},
+        {PTP_RC_EK_FilenameConflicts,   PTP_VENDOR_EASTMAN_KODAK, N_("Filename Conflicts")},
+        {PTP_RC_EK_FilenameInvalid,     PTP_VENDOR_EASTMAN_KODAK, N_("Filename Invalid")},
 
-        {PTP_ERROR_IO,            N_("PTP: I/O error")},
-        {PTP_ERROR_BADPARAM,      N_("PTP: Error: bad parameter")},
-        {PTP_ERROR_DATA_EXPECTED, N_("PTP: Protocol error, data expected")},
-        {PTP_ERROR_RESP_EXPECTED, N_("PTP: Protocol error, response expected")},
-        {0, NULL}
+        {PTP_RC_NIKON_HardwareError,            PTP_VENDOR_NIKON, N_("Hardware Error")},
+        {PTP_RC_NIKON_OutOfFocus,               PTP_VENDOR_NIKON, N_("Out of Focus")},
+        {PTP_RC_NIKON_ChangeCameraModeFailed,   PTP_VENDOR_NIKON, N_("Change Camera Mode Failed")},
+        {PTP_RC_NIKON_InvalidStatus,            PTP_VENDOR_NIKON, N_("Invalid Status")},
+        {PTP_RC_NIKON_SetPropertyNotSupported,  PTP_VENDOR_NIKON, N_("Set Property Not Supported")},
+        {PTP_RC_NIKON_WbResetError,             PTP_VENDOR_NIKON, N_("Whitebalance Reset Error")},
+        {PTP_RC_NIKON_DustReferenceError,       PTP_VENDOR_NIKON, N_("Dust Reference Error")},
+        {PTP_RC_NIKON_ShutterSpeedBulb,         PTP_VENDOR_NIKON, N_("Shutter Speed Bulb")},
+        {PTP_RC_NIKON_MirrorUpSequence,         PTP_VENDOR_NIKON, N_("Mirror Up Sequence")},
+        {PTP_RC_NIKON_CameraModeNotAdjustFNumber, PTP_VENDOR_NIKON, N_("Camera Mode Not Adjust FNumber")},
+        {PTP_RC_NIKON_NotLiveView,              PTP_VENDOR_NIKON, N_("Not in Liveview")},
+        {PTP_RC_NIKON_MfDriveStepEnd,           PTP_VENDOR_NIKON, N_("Mf Drive Step End")},
+        {PTP_RC_NIKON_MfDriveStepInsufficiency, PTP_VENDOR_NIKON, N_("Mf Drive Step Insufficiency")},
+        {PTP_RC_NIKON_AdvancedTransferCancel,   PTP_VENDOR_NIKON, N_("Advanced Transfer Cancel")},
+
+        {PTP_RC_CANON_UNKNOWN_COMMAND,  PTP_VENDOR_CANON, N_("Unknown Command")},
+        {PTP_RC_CANON_OPERATION_REFUSED,PTP_VENDOR_CANON, N_("Operation Refused")},
+        {PTP_RC_CANON_LENS_COVER,       PTP_VENDOR_CANON, N_("Lens Cover Present")},
+        {PTP_RC_CANON_BATTERY_LOW,      PTP_VENDOR_CANON, N_("Battery Low")},
+        {PTP_RC_CANON_NOT_READY,        PTP_VENDOR_CANON, N_("Camera Not Ready")},
+
+        {PTP_ERROR_TIMEOUT,             0, N_("PTP Timeout")},
+        {PTP_ERROR_CANCEL,              0, N_("PTP Cancel Request")},
+        {PTP_ERROR_BADPARAM,            0, N_("PTP Invalid Parameter")},
+        {PTP_ERROR_RESP_EXPECTED,       0, N_("PTP Response Expected")},
+        {PTP_ERROR_DATA_EXPECTED,       0, N_("PTP Data Expected")},
+        {PTP_ERROR_IO,                  0, N_("PTP I/O Error")},
+        {0, 0, NULL}
 };
 
-        for (i=0; ptp_errors[i].txt!=NULL; i++)
-                if (ptp_errors[i].n == error)
+const char *
+ptp_strerror(uint16_t ret, uint16_t vendor)
+{
+        int i;
+
+        for (i=0; ptp_errors[i].txt != NULL; i++)
+                if ((ptp_errors[i].rc == ret) && ((ptp_errors[i].vendor == 0) || (ptp_errors[i].vendor == vendor)))
                         return ptp_errors[i].txt;
         return NULL;
 }
 
-void
-ptp_perror(PTPParams* params, uint16_t error) {
-        const char *txt = ptp_strerror(error);
-        if (txt != NULL)
-                ptp_error(params, txt);
-}
-
 const char*
 ptp_get_property_description(PTPParams* params, uint16_t dpc)
 {
         int i;
         /* Device Property descriptions */
         struct {
                 uint16_t dpc;
                 const char *txt;
         } ptp_device_properties[] = {
                 {PTP_DPC_Undefined,             N_("Undefined PTP Property")},
@@ skipping 23 matching lines @@
                 {PTP_DPC_DigitalZoom,           N_("Digital Zoom")},
                 {PTP_DPC_EffectMode,            N_("Effect Mode")},
                 {PTP_DPC_BurstNumber,           N_("Burst Number")},
                 {PTP_DPC_BurstInterval,         N_("Burst Interval")},
                 {PTP_DPC_TimelapseNumber,       N_("Timelapse Number")},
                 {PTP_DPC_TimelapseInterval,     N_("Timelapse Interval")},
                 {PTP_DPC_FocusMeteringMode,     N_("Focus Metering Mode")},
                 {PTP_DPC_UploadURL,             N_("Upload URL")},
                 {PTP_DPC_Artist,                N_("Artist")},
                 {PTP_DPC_CopyrightInfo,         N_("Copyright Info")},
+                {PTP_DPC_SupportedStreams,      N_("Supported Streams")},
+                {PTP_DPC_EnabledStreams,        N_("Enabled Streams")},
+                {PTP_DPC_VideoFormat,           N_("Video Format")},
+                {PTP_DPC_VideoResolution,       N_("Video Resolution")},
+                {PTP_DPC_VideoQuality,          N_("Video Quality")},
+                {PTP_DPC_VideoFrameRate,        N_("Video Framerate")},
+                {PTP_DPC_VideoContrast,         N_("Video Contrast")},
+                {PTP_DPC_VideoBrightness,       N_("Video Brightness")},
+                {PTP_DPC_AudioFormat,           N_("Audio Format")},
+                {PTP_DPC_AudioBitrate,          N_("Audio Bitrate")},
+                {PTP_DPC_AudioSamplingRate,     N_("Audio Samplingrate")},
+                {PTP_DPC_AudioBitPerSample,     N_("Audio Bits per sample")},
+                {PTP_DPC_AudioVolume,           N_("Audio Volume")},
                 {0,NULL}
         };
         struct {
                 uint16_t dpc;
                 const char *txt;
         } ptp_device_properties_EK[] = {
                 {PTP_DPC_EK_ColorTemperature,   N_("Color Temperature")},
                 {PTP_DPC_EK_DateTimeStampFormat,
                                         N_("Date Time Stamp Format")},
                 {PTP_DPC_EK_BeepMode,           N_("Beep Mode")},
@@ skipping 151 matching lines @@
                 {PTP_DPC_NIKON_NonCPULensDataMaximumAperture,   /* 0xD02f */
                  N_("Lens Maximum Aperture (Non CPU)")},
                 {PTP_DPC_NIKON_ShootingMode,                    /* 0xD030 */
                  N_("Shooting Mode")},
                 {PTP_DPC_NIKON_JPEG_Compression_Policy,         /* 0xD031 */
                  N_("JPEG Compression Policy")},
                 {PTP_DPC_NIKON_ColorSpace,                      /* 0xD032 */
                  N_("Color Space")},
                 {PTP_DPC_NIKON_AutoDXCrop,                      /* 0xD033 */
                  N_("Auto DX Crop")},
+                {PTP_DPC_NIKON_FlickerReduction,                /* 0xD034 */
+                 N_("Flicker Reduction")},
+                {PTP_DPC_NIKON_RemoteMode,                      /* 0xD035 */
+                 N_("Remote Mode")},
+                {PTP_DPC_NIKON_VideoMode,                       /* 0xD036 */
+                 N_("Video Mode")},
+                {PTP_DPC_NIKON_EffectMode,                      /* 0xD037 */
+                 N_("Effect Mode")},
                 {PTP_DPC_NIKON_CSMMenuBankSelect,               /* 0xD040 */
                  "PTP_DPC_NIKON_CSMMenuBankSelect"},
                 {PTP_DPC_NIKON_MenuBankNameA,                   /* 0xD041 */
                  N_("Menu Bank Name A")},
                 {PTP_DPC_NIKON_MenuBankNameB,                   /* 0xD042 */
                  N_("Menu Bank Name B")},
                 {PTP_DPC_NIKON_MenuBankNameC,                   /* 0xD043 */
                  N_("Menu Bank Name C")},
                 {PTP_DPC_NIKON_MenuBankNameD,                   /* 0xD044 */
                  N_("Menu Bank Name D")},
@@ skipping 125 matching lines @@
                 {PTP_DPC_NIKON_NoCFCard,                        /* 0xD08A */
                  N_("No CF Card Release")},
                 {PTP_DPC_NIKON_CenterButtonZoomRatio,           /* 0xD08B */
                  N_("Center Button Zoom Ratio")},
                 {PTP_DPC_NIKON_FunctionButton2,                 /* 0xD08C */
                  N_("Function Button 2")},
                 {PTP_DPC_NIKON_AFAreaPoint,                     /* 0xD08D */
                  N_("AF Area Point")},
                 {PTP_DPC_NIKON_NormalAFOn,                      /* 0xD08E */
                  N_("Normal AF On")},
+                {PTP_DPC_NIKON_CleanImageSensor,                /* 0xD08F */
+                 N_("Clean Image Sensor")},
                 {PTP_DPC_NIKON_ImageCommentString,              /* 0xD090 */
                  N_("Image Comment String")},
                 {PTP_DPC_NIKON_ImageCommentEnable,              /* 0xD091 */
                  N_("Image Comment Enable")},
                 {PTP_DPC_NIKON_ImageRotation,                   /* 0xD092 */
                  N_("Image Rotation")},
                 {PTP_DPC_NIKON_ManualSetLensNo,                 /* 0xD093 */
                  N_("Manual Set Lens Number")},
                 {PTP_DPC_NIKON_MovScreenSize,                   /* 0xD0A0 */
                  N_("Movie Screen Size")},
                 {PTP_DPC_NIKON_MovVoice,                        /* 0xD0A1 */
                  N_("Movie Voice")},
+                {PTP_DPC_NIKON_MovMicrophone,                   /* 0xD0A2 */
+                 N_("Movie Microphone")},
+                {PTP_DPC_NIKON_MovFileSlot,                     /* 0xD0A3 */
+                 N_("Movie Card Slot")},
+                {PTP_DPC_NIKON_ManualMovieSetting,              /* 0xD0A6 */
+                 N_("Manual Movie Setting")},
+                {PTP_DPC_NIKON_MovQuality,                      /* 0xD0A7 */
+                 N_("Movie Quality")},
+                {PTP_DPC_NIKON_MonitorOffDelay,                 /* 0xD0B3 */
+                 N_("Monitor Off Delay")},
                 {PTP_DPC_NIKON_Bracketing,                      /* 0xD0C0 */
                  N_("Bracketing Enable")},
                 {PTP_DPC_NIKON_AutoExposureBracketStep,         /* 0xD0C1 */
                  N_("Exposure Bracketing Step")},
                 {PTP_DPC_NIKON_AutoExposureBracketProgram,      /* 0xD0C2 */
                  N_("Exposure Bracketing Program")},
                 {PTP_DPC_NIKON_AutoExposureBracketCount,        /* 0xD0C3 */
                  N_("Auto Exposure Bracket Count")},
                 {PTP_DPC_NIKON_WhiteBalanceBracketStep, N_("White Balance Bracket Step")}, /* 0xD0C4 */
                 {PTP_DPC_NIKON_WhiteBalanceBracketProgram, N_("White Balance Bracket Program")}, /* 0xD0C5 */
@@ skipping 18 matching lines @@
                 {PTP_DPC_NIKON_AutoOffMenu,                     /* 0xD0F3 */
                  N_("Auto Off Menu")},
                 {PTP_DPC_NIKON_AutoOffInfo,                     /* 0xD0F4 */
                  N_("Auto Off Info")},
                 {PTP_DPC_NIKON_SelfTimerShootNum,               /* 0xD0F5 */
                  N_("Self Timer Shot Number")},
                 {PTP_DPC_NIKON_VignetteCtrl,                    /* 0xD0F7 */
                  N_("Vignette Control")},
                 {PTP_DPC_NIKON_AutoDistortionControl,           /* 0xD0F8 */
                  N_("Auto Distortion Control")},
+                {PTP_DPC_NIKON_SceneMode,                       /* 0xD0F9 */
+                 N_("Scene Mode")},
                 {PTP_DPC_NIKON_ExposureTime,                    /* 0xD100 */
                  N_("Nikon Exposure Time")},
                 {PTP_DPC_NIKON_ACPower, N_("AC Power")},        /* 0xD101 */
                 {PTP_DPC_NIKON_WarningStatus, N_("Warning Status")},/* 0xD102 */
                 {PTP_DPC_NIKON_MaximumShots,                    /* 0xD103 */
                  N_("Maximum Shots")},
                 {PTP_DPC_NIKON_AFLockStatus, N_("AF Locked")},/* 0xD104 */
                 {PTP_DPC_NIKON_AELockStatus, N_("AE Locked")},/* 0xD105 */
                 {PTP_DPC_NIKON_FVLockStatus, N_("FV Locked")},/* 0xD106 */
                 {PTP_DPC_NIKON_AutofocusLCDTopMode2,            /* 0xD107 */
@@ skipping 55 matching lines @@
                 {PTP_DPC_NIKON_BW_Sharpness,                    /* 0xD144 */
                  N_("BW Sharpness")},
                 {PTP_DPC_NIKON_BW_Contrast,                     /* 0xD145 */
                  N_("BW Contrast")},
                 {PTP_DPC_NIKON_BW_Setting_Type,                 /* 0xD146 */
                  N_("BW Setting Type")},
                 {PTP_DPC_NIKON_Slot2SaveMode,                   /* 0xD148 */
                  N_("Slot 2 Save Mode")},
                 {PTP_DPC_NIKON_RawBitMode,                      /* 0xD149 */
                  N_("Raw Bit Mode")},
-                {PTP_DPC_NIKON_ISOAutoTime,                     /* 0xD14E */
-                 N_("ISO Auto Time")},
+                {PTP_DPC_NIKON_ActiveDLighting,                 /* 0xD14E */
+                 N_("Active D-Lighting")},
                 {PTP_DPC_NIKON_FlourescentType,                 /* 0xD14F */
                  N_("Flourescent Type")},
                 {PTP_DPC_NIKON_TuneColourTemperature,           /* 0xD150 */
                  N_("Tune Colour Temperature")},
                 {PTP_DPC_NIKON_TunePreset0,                     /* 0xD151 */
                  N_("Tune Preset 0")},
                 {PTP_DPC_NIKON_TunePreset1,                     /* 0xD152 */
                  N_("Tune Preset 1")},
                 {PTP_DPC_NIKON_TunePreset2,                     /* 0xD153 */
                  N_("Tune Preset 2")},
@@ skipping 12 matching lines @@
                 {PTP_DPC_NIKON_ImageReview,                     /* 0xD165 */
                  N_("Image Review")},
                 {PTP_DPC_NIKON_AFAreaIllumination,              /* 0xD166 */
                  N_("AF Area Illumination")},
                 {PTP_DPC_NIKON_FlashMode,                       /* 0xD167 */
                  N_("Flash Mode")},
                 {PTP_DPC_NIKON_FlashCommanderMode,              /* 0xD168 */
                  N_("Flash Commander Mode")},
                 {PTP_DPC_NIKON_FlashSign,                       /* 0xD169 */
                  N_("Flash Sign")},
-                {PTP_DPC_NIKON_ISOAuto,                         /* 0xD16A */
+                {PTP_DPC_NIKON_ISO_Auto,                        /* 0xD16A */
                  N_("ISO Auto")},
                 {PTP_DPC_NIKON_RemoteTimeout,                   /* 0xD16B */
                  N_("Remote Timeout")},
                 {PTP_DPC_NIKON_GridDisplay,                     /* 0xD16C */
                  N_("Viewfinder Grid Display")},
                 {PTP_DPC_NIKON_FlashModeManualPower,            /* 0xD16D */
                  N_("Flash Mode Manual Power")},
                 {PTP_DPC_NIKON_FlashModeCommanderPower,         /* 0xD16E */
                  N_("Flash Mode Commander Power")},
                 {PTP_DPC_NIKON_AutoFP,                          /* 0xD16F */
@@ skipping 31 matching lines @@
                 {PTP_DPC_NIKON_LiveViewStatus,                  /* 0xD1A2 */
                  N_("Live View Status")},
                 {PTP_DPC_NIKON_LiveViewImageZoomRatio,          /* 0xD1A3 */
                  N_("Live View Image Zoom Ratio")},
                 {PTP_DPC_NIKON_LiveViewProhibitCondition,       /* 0xD1A4 */
                  N_("Live View Prohibit Condition")},
                 {PTP_DPC_NIKON_ExposureDisplayStatus,           /* 0xD1B0 */
                  N_("Exposure Display Status")},
                 {PTP_DPC_NIKON_ExposureIndicateStatus,          /* 0xD1B1 */
                  N_("Exposure Indicate Status")},
-                {PTP_DPC_NIKON_ExposureIndicateLightup,         /* 0xD1B2 */
+                {PTP_DPC_NIKON_InfoDispErrStatus,               /* 0xD1B2 */
+                 N_("Info Display Error Status")},
+                {PTP_DPC_NIKON_ExposureIndicateLightup,         /* 0xD1B3 */
                  N_("Exposure Indicate Lightup")},
                 {PTP_DPC_NIKON_FlashOpen,                       /* 0xD1C0 */
                  N_("Flash Open")},
                 {PTP_DPC_NIKON_FlashCharged,                    /* 0xD1C1 */
                  N_("Flash Charged")},
                 {PTP_DPC_NIKON_FlashMRepeatValue,               /* 0xD1D0 */
                  N_("Flash MRepeat Value")},
                 {PTP_DPC_NIKON_FlashMRepeatCount,               /* 0xD1D1 */
                  N_("Flash MRepeat Count")},
                 {PTP_DPC_NIKON_FlashMRepeatInterval,            /* 0xD1D2 */
@@ skipping 15 matching lines @@
                 {PTP_DPC_NIKON_FlashCommandBMode,               /* 0xD1DA */
                  N_("Flash Command B Mode")},
                 {PTP_DPC_NIKON_FlashCommandBCompensation,       /* 0xD1DB */
                  N_("Flash Command B Compensation")},
                 {PTP_DPC_NIKON_FlashCommandBValue,              /* 0xD1DC */
                  N_("Flash Command B Value")},
                 {PTP_DPC_NIKON_ActivePicCtrlItem,               /* 0xD200 */
                  N_("Active Pic Ctrl Item")},
                 {PTP_DPC_NIKON_ChangePicCtrlItem,               /* 0xD201 */
                  N_("Change Pic Ctrl Item")},
+                /* nikon 1 stuff */
+                {PTP_DPC_NIKON_1_ISO,                           /* 0xf002 */
+                 N_("ISO")},
+                {PTP_DPC_NIKON_1_ImageSize,                     /* 0xf00a */
+                 N_("Image Size")},
+                {PTP_DPC_NIKON_1_LongExposureNoiseReduction,    /* 0xF00D */
+                 N_("Long Exposure Noise Reduction")},
+                {PTP_DPC_NIKON_1_MovQuality,                    /* 0xF01C */
+                 N_("Movie Quality")},
+                {PTP_DPC_NIKON_1_HiISONoiseReduction,           /* 0xF00E */
+                 N_("High ISO Noise Reduction")},
+                {PTP_DPC_NIKON_1_WhiteBalance,                  /* 0xF00C */
+                 N_("White Balance")},
+                {PTP_DPC_NIKON_1_ImageCompression,              /* 0xF009 */
+                 N_("Image Compression")},
+                {PTP_DPC_NIKON_1_ActiveDLighting,               /* 0xF00F */
+                 N_("Active D-Lighting")},
                 {0,NULL}
         };
         struct {
                 uint16_t dpc;
                 const char *txt;
         } ptp_device_properties_MTP[] = {
                 {PTP_DPC_MTP_SecureTime,        N_("Secure Time")},             /* D101 */
                 {PTP_DPC_MTP_DeviceCertificate, N_("Device Certificate")},      /* D102 */
                 {PTP_DPC_MTP_RevocationInfo,    N_("Revocation Info")},         /* D103 */
                 {PTP_DPC_MTP_SynchronizationPartner,                            /* D401 */
@@ skipping 19 matching lines @@
                 {PTP_DPC_FUJI_ColorTemperature, N_("Color Temperature")},       /* 0xD017 */
                 {PTP_DPC_FUJI_Quality, N_("Quality")},                          /* 0xD018 */
                 {PTP_DPC_FUJI_Quality, N_("Release Mode")},                     /* 0xD201 */
                 {PTP_DPC_FUJI_Quality, N_("Focus Areas")},                      /* 0xD206 */
                 {PTP_DPC_FUJI_Quality, N_("AE Lock")},                          /* 0xD213 */
                 {PTP_DPC_FUJI_Quality, N_("Aperture")},                         /* 0xD218 */
                 {PTP_DPC_FUJI_Quality, N_("Shutter Speed")},                    /* 0xD219 */
                 {0,NULL}
         };
 
+        struct {
+                uint16_t dpc;
+                const char *txt;
+        } ptp_device_properties_SONY[] = {
+                {PTP_DPC_SONY_DPCCompensation, ("DOC Compensation")},   /* 0xD200 */
+                {PTP_DPC_SONY_DRangeOptimize, ("DRangeOptimize")},      /* 0xD201 */
+                {PTP_DPC_SONY_ImageSize, N_("Image size")},             /* 0xD203 */
+                {PTP_DPC_SONY_ShutterSpeed, N_("Shutter speed")},       /* 0xD20D */
+                {PTP_DPC_SONY_ColorTemp, N_("Color temperature")},      /* 0xD20F */
+                {PTP_DPC_SONY_CCFilter, ("CC Filter")},                 /* 0xD210 */
+                {PTP_DPC_SONY_AspectRatio, N_("Aspect Ratio")},         /* 0xD211 */
+                {PTP_DPC_SONY_ExposeIndex, N_("Expose Index")},         /* 0xD216 */
+                {PTP_DPC_SONY_PictureEffect, N_("Picture Effect")},     /* 0xD21B */
+                {PTP_DPC_SONY_ABFilter, N_("AB Filter")},               /* 0xD21C */
+                {PTP_DPC_SONY_ISO, N_("ISO")},                          /* 0xD21E */
+                {PTP_DPC_SONY_Movie, N_("Movie")},                      /* 0xD2C8 */
+                {PTP_DPC_SONY_StillImage, N_("Still Image")},           /* 0xD2C7 */
+                {0,NULL}
+        };
+
+
         for (i=0; ptp_device_properties[i].txt!=NULL; i++)
                 if (ptp_device_properties[i].dpc==dpc)
                         return (ptp_device_properties[i].txt);
 
         if (params->deviceinfo.VendorExtensionID==PTP_VENDOR_MICROSOFT
             || params->deviceinfo.VendorExtensionID==PTP_VENDOR_MTP)
                 for (i=0; ptp_device_properties_MTP[i].txt!=NULL; i++)
                         if (ptp_device_properties_MTP[i].dpc==dpc)
                                 return (ptp_device_properties_MTP[i].txt);
 
@@ skipping 10 matching lines @@
         if (params->deviceinfo.VendorExtensionID==PTP_VENDOR_NIKON)
                 for (i=0; ptp_device_properties_Nikon[i].txt!=NULL; i++)
                         if (ptp_device_properties_Nikon[i].dpc==dpc)
                                 return (ptp_device_properties_Nikon[i].txt);
 
         if (params->deviceinfo.VendorExtensionID==PTP_VENDOR_FUJI)
                 for (i=0; ptp_device_properties_FUJI[i].txt!=NULL; i++)
                         if (ptp_device_properties_FUJI[i].dpc==dpc)
                                 return (ptp_device_properties_FUJI[i].txt);
 
+        if (params->deviceinfo.VendorExtensionID==PTP_VENDOR_SONY)
+                for (i=0; ptp_device_properties_SONY[i].txt!=NULL; i++)
+                        if (ptp_device_properties_SONY[i].dpc==dpc)
+                                return (ptp_device_properties_SONY[i].txt);
+
         return NULL;
 }
 
 static int64_t
 _value_to_num(PTPPropertyValue *data, uint16_t dt) {
         if (dt == PTP_DTC_STR) {
                 if (!data->str)
                         return 0;
                 return atol(data->str);
         }
@@ skipping 29 matching lines @@
         return 0;
 }
 
 #define PTP_VAL_BOOL(dpc) {dpc, 0, N_("Off")}, {dpc, 1, N_("On")}
 #define PTP_VENDOR_VAL_BOOL(dpc,vendor) {dpc, vendor, 0, N_("Off")}, {dpc, vendor, 1, N_("On")}
 #define PTP_VENDOR_VAL_RBOOL(dpc,vendor) {dpc, vendor, 0, N_("On")}, {dpc, vendor, 1, N_("Off")}
 #define PTP_VENDOR_VAL_YN(dpc,vendor) {dpc, vendor, 0, N_("No")}, {dpc, vendor, 1, N_("Yes")}
 
 int
 ptp_render_property_value(PTPParams* params, uint16_t dpc,
-                          PTPDevicePropDesc *dpd, int length, char *out)
+                          PTPDevicePropDesc *dpd, unsigned int length, char *out)
 {
-        int i;
+        unsigned int i;
         int64_t kval;
 
         struct {
                 uint16_t dpc;
                 uint16_t vendor;
                 double coef;
                 double bias;
                 const char *format;
         } ptp_value_trans[] = {
                 {PTP_DPC_BatteryLevel, 0, 1.0, 0.0, "%.0f%%"},          /* 5001 */
@@ skipping 10 matching lines @@
                 /* Nikon device properties */
                 {PTP_DPC_NIKON_LightMeter, PTP_VENDOR_NIKON, 0.08333, 0.0, N_("%.1f stops")},/* D10A */
                 {PTP_DPC_NIKON_FlashExposureCompensation, PTP_VENDOR_NIKON, 0.16666, 0.0, N_("%.1f stops")}, /* D126 */
                 {PTP_DPC_NIKON_CenterWeightArea, PTP_VENDOR_NIKON, 2.0, 6.0, N_("%.0f mm")},/* D059 */
                 {PTP_DPC_NIKON_FocalLengthMin, PTP_VENDOR_NIKON, 0.01, 0.0, "%.0f mm"}, /* D0E3 */
                 {PTP_DPC_NIKON_FocalLengthMax, PTP_VENDOR_NIKON, 0.01, 0.0, "%.0f mm"}, /* D0E4 */
                 {PTP_DPC_NIKON_MaxApAtMinFocalLength, PTP_VENDOR_NIKON, 0.01, 0.0, "f/%.2g"}, /* D0E5 */
                 {PTP_DPC_NIKON_MaxApAtMaxFocalLength, PTP_VENDOR_NIKON, 0.01, 0.0, "f/%.2g"}, /* D0E6 */
                 {PTP_DPC_NIKON_ExternalFlashCompensation, PTP_VENDOR_NIKON, 1.0/6.0, 0.0,"%.0f"}, /* D124 */
                 {PTP_DPC_NIKON_ExposureIndicateStatus, PTP_VENDOR_NIKON, 0.08333, 0.0, N_("%.1f stops")},/* D1B1 - FIXME: check if correct. */
+                {PTP_DPC_NIKON_AngleLevel, PTP_VENDOR_NIKON, 1.0/65536, 0.0, "%.1f'"},/* 0xD067 */
                 {0, 0, 0.0, 0.0, NULL}
         };
 
         struct {
                 uint16_t dpc;
                 uint16_t vendor;
                 int64_t key;
                 char *value;
         } ptp_value_list[] = {
                 {PTP_DPC_CompressionSetting, 0, 0, N_("JPEG Basic")},   /* 5004 */
@@ skipping 189 matching lines @@
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 118, "AF Nikkor 50mm 1:1.8 D"},
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 127, "AF-S Nikkor 18-70mm 1:3.5-4.5G ED DX"},
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 139, "AF-S Nikkor 18-200mm 1:3.5-5.6 GED DX VR"},
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 147, "AF-S Nikkor 24-70mm 1:2.8G ED DX"},
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 154, "AF-S Nikkor 18-55mm 1:3.5-F5.6G DX VR"},
                 {PTP_DPC_NIKON_LensID, PTP_VENDOR_NIKON, 159, "AF-S Nikkor 35mm 1:1.8G DX"},
                 {PTP_DPC_NIKON_FinderISODisp, PTP_VENDOR_NIKON, 0, "Show ISO sensitivity"},/* 0xD0F0 */
                 {PTP_DPC_NIKON_FinderISODisp, PTP_VENDOR_NIKON, 1, "Show ISO/Easy ISO"},
                 {PTP_DPC_NIKON_FinderISODisp, PTP_VENDOR_NIKON, 2, "Show frame count"},
 
+                {PTP_DPC_NIKON_RawCompression, PTP_VENDOR_NIKON, 0, N_("Lossless")},    /* D016 */
+                {PTP_DPC_NIKON_RawCompression, PTP_VENDOR_NIKON, 1, N_("Lossy")},
+
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_ACPower,PTP_VENDOR_NIKON),              /* D101 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_AFLockStatus,PTP_VENDOR_NIKON),         /* D104 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_AELockStatus,PTP_VENDOR_NIKON),         /* D105 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_FVLockStatus,PTP_VENDOR_NIKON),         /* D106 */
 
                 {PTP_DPC_NIKON_AutofocusArea, PTP_VENDOR_NIKON, 0, N_("Centre")},       /* D108 */
                 {PTP_DPC_NIKON_AutofocusArea, PTP_VENDOR_NIKON, 1, N_("Top")},
                 {PTP_DPC_NIKON_AutofocusArea, PTP_VENDOR_NIKON, 2, N_("Bottom")},
                 {PTP_DPC_NIKON_AutofocusArea, PTP_VENDOR_NIKON, 3, N_("Left")},
                 {PTP_DPC_NIKON_AutofocusArea, PTP_VENDOR_NIKON, 4, N_("Right")},
@@ skipping 118 matching lines @@
 
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_LiveViewStatus,PTP_VENDOR_NIKON),       /* D1A2 */
 
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_ExposureDisplayStatus,PTP_VENDOR_NIKON),/* D1B0 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_InfoDispErrStatus,PTP_VENDOR_NIKON),    /* D1B2 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_ExposureIndicateLightup,PTP_VENDOR_NIKON),/* D1B3 */
 
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_FlashOpen,PTP_VENDOR_NIKON),            /* D1C0 */
                 PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_FlashCharged,PTP_VENDOR_NIKON),         /* D1C1 */
 
+                PTP_VENDOR_VAL_YN(PTP_DPC_NIKON_ManualMovieSetting,PTP_VENDOR_NIKON),   /* 0xD0A6 */
+
+                {PTP_DPC_NIKON_FlickerReduction, PTP_VENDOR_NIKON, 0, "50Hz"},          /* 0xD034 */
+                {PTP_DPC_NIKON_FlickerReduction, PTP_VENDOR_NIKON, 1, "60Hz"},
+
+                {PTP_DPC_NIKON_RemoteMode, PTP_VENDOR_NIKON, 0, N_("Delayed Remote")},  /* 0xD035 */
+                {PTP_DPC_NIKON_RemoteMode, PTP_VENDOR_NIKON, 1, N_("Quick Response")},  /* 0xD035 */
+                {PTP_DPC_NIKON_RemoteMode, PTP_VENDOR_NIKON, 2, N_("Remote Mirror Up")},/* 0xD035 */
+
+                {PTP_DPC_NIKON_MonitorOffDelay, PTP_VENDOR_NIKON, 0, "5min"},   /* 0xD0b3 */
+                {PTP_DPC_NIKON_MonitorOffDelay, PTP_VENDOR_NIKON, 1, "10min"},  /* 0xD0b3 */
+                {PTP_DPC_NIKON_MonitorOffDelay, PTP_VENDOR_NIKON, 2, "15min"},  /* 0xD0b3 */
+                {PTP_DPC_NIKON_MonitorOffDelay, PTP_VENDOR_NIKON, 3, "20min"},  /* 0xD0b3 */
+                {PTP_DPC_NIKON_MonitorOffDelay, PTP_VENDOR_NIKON, 4, "30min"},  /* 0xD0b3 */
+
+
                 /* Canon stuff */
                 PTP_VENDOR_VAL_BOOL(PTP_DPC_CANON_AssistLight,PTP_VENDOR_CANON),
                 PTP_VENDOR_VAL_RBOOL(PTP_DPC_CANON_RotationScene,PTP_VENDOR_CANON),
                 PTP_VENDOR_VAL_RBOOL(PTP_DPC_CANON_BeepMode,PTP_VENDOR_CANON),
                 PTP_VENDOR_VAL_BOOL(PTP_DPC_CANON_Beep,PTP_VENDOR_CANON),
 
                 {PTP_DPC_CANON_RotationAngle, PTP_VENDOR_CANON, 0, "0'"},
                 {PTP_DPC_CANON_RotationAngle, PTP_VENDOR_CANON, 3, "270'"},
                 {PTP_DPC_CANON_RotationAngle, PTP_VENDOR_CANON, 1, "90'"},
 
@@ skipping 343 matching lines @@
         {PTP_OFC_MTP_vCalendar1,N_("vCalendar1")},
         {PTP_OFC_MTP_vCalendar2,N_("vCalendar2")},
         {PTP_OFC_MTP_UndefinedWindowsExecutable,N_("Undefined Windows Executable")},
         {PTP_OFC_MTP_MediaCast,N_("Media Cast")},
         {PTP_OFC_MTP_Section,N_("Section")},
 };
 
 int
 ptp_render_ofc(PTPParams* params, uint16_t ofc, int spaceleft, char *txt)
 {
-        int i;
-        
+        unsigned int i;
+
         if (!(ofc & 0x8000)) {
                 for (i=0;i<sizeof(ptp_ofc_trans)/sizeof(ptp_ofc_trans[0]);i++)
                         if (ofc == ptp_ofc_trans[i].ofc)
                                 return snprintf(txt, spaceleft, "%s", _(ptp_ofc_trans[i].format));
         } else {
                 switch (params->deviceinfo.VendorExtensionID) {
                 case PTP_VENDOR_EASTMAN_KODAK:
                         switch (ofc) {
                         case PTP_OFC_EK_M3U:
                                 return snprintf (txt, spaceleft,"M3U");
@@ skipping 14 matching lines @@
                         for (i=0;i<sizeof(ptp_ofc_mtp_trans)/sizeof(ptp_ofc_mtp_trans[0]);i++)
                                 if (ofc == ptp_ofc_mtp_trans[i].ofc)
                                         return snprintf(txt, spaceleft, "%s", _(ptp_ofc_mtp_trans[i].format));
                         break;
                 default:break;
                 }
         }
         return snprintf (txt, spaceleft,_("Unknown(%04x)"), ofc);
 }
 
-struct {
+typedef struct {
         uint16_t opcode;
         const char *name;
-} ptp_opcode_trans[] = {
+} ptp_opcode_trans_t;
+
+ptp_opcode_trans_t ptp_opcode_trans[] = {
         {PTP_OC_Undefined,N_("Undefined")},
-        {PTP_OC_GetDeviceInfo,N_("get device info")},
+        {PTP_OC_GetDeviceInfo,N_("Get device info")},
         {PTP_OC_OpenSession,N_("Open session")},
         {PTP_OC_CloseSession,N_("Close session")},
         {PTP_OC_GetStorageIDs,N_("Get storage IDs")},
         {PTP_OC_GetStorageInfo,N_("Get storage info")},
         {PTP_OC_GetNumObjects,N_("Get number of objects")},
         {PTP_OC_GetObjectHandles,N_("Get object handles")},
         {PTP_OC_GetObjectInfo,N_("Get object info")},
         {PTP_OC_GetObject,N_("Get object")},
         {PTP_OC_GetThumb,N_("Get thumbnail")},
         {PTP_OC_DeleteObject,N_("Delete object")},
         {PTP_OC_SendObjectInfo,N_("Send object info")},
         {PTP_OC_SendObject,N_("Send object")},
         {PTP_OC_InitiateCapture,N_("Initiate capture")},
         {PTP_OC_FormatStore,N_("Format storage")},
         {PTP_OC_ResetDevice,N_("Reset device")},
         {PTP_OC_SelfTest,N_("Self test device")},
         {PTP_OC_SetObjectProtection,N_("Set object protection")},
         {PTP_OC_PowerDown,N_("Power down device")},
         {PTP_OC_GetDevicePropDesc,N_("Get device property description")},
         {PTP_OC_GetDevicePropValue,N_("Get device property value")},
         {PTP_OC_SetDevicePropValue,N_("Set device property value")},
         {PTP_OC_ResetDevicePropValue,N_("Reset device property value")},
         {PTP_OC_TerminateOpenCapture,N_("Terminate open capture")},
         {PTP_OC_MoveObject,N_("Move object")},
         {PTP_OC_CopyObject,N_("Copy object")},
         {PTP_OC_GetPartialObject,N_("Get partial object")},
-        {PTP_OC_InitiateOpenCapture,N_("Initiate open capture")}
+        {PTP_OC_InitiateOpenCapture,N_("Initiate open capture")},
+        /* PTP v1.1 operation codes */
+        {PTP_OC_StartEnumHandles,N_("Start Enumerate Handles")},
+        {PTP_OC_EnumHandles,N_("Enumerate Handles")},
+        {PTP_OC_StopEnumHandles,N_("Stop Enumerate Handles")},
+        {PTP_OC_GetVendorExtensionMaps,N_("Get Vendor Extension Maps")},
+        {PTP_OC_GetVendorDeviceInfo,N_("Get Vendor Device Info")},
+        {PTP_OC_GetResizedImageObject,N_("Get Resized Image Object")},
+        {PTP_OC_GetFilesystemManifest,N_("Get Filesystem Manifest")},
+        {PTP_OC_GetStreamInfo,N_("Get Stream Info")},
+        {PTP_OC_GetStream,N_("Get Stream")},
 };
 
-struct {
-        uint16_t opcode;
-        const char *name;
-} ptp_opcode_mtp_trans[] = {
+ptp_opcode_trans_t ptp_opcode_mtp_trans[] = {
         {PTP_OC_MTP_GetObjectPropsSupported,N_("Get object properties supported")},
         {PTP_OC_MTP_GetObjectPropDesc,N_("Get object property description")},
         {PTP_OC_MTP_GetObjectPropValue,N_("Get object property value")},
         {PTP_OC_MTP_SetObjectPropValue,N_("Set object property value")},
         {PTP_OC_MTP_GetObjPropList,N_("Get object property list")},
         {PTP_OC_MTP_SetObjPropList,N_("Set object property list")},
         {PTP_OC_MTP_GetInterdependendPropdesc,N_("Get interdependent property description")},
         {PTP_OC_MTP_SendObjectPropList,N_("Send object property list")},
         {PTP_OC_MTP_GetObjectReferences,N_("Get object references")},
         {PTP_OC_MTP_SetObjectReferences,N_("Set object references")},
@@ skipping 33 matching lines @@
 
         /* WMDRMND Extensions */
         {PTP_OC_MTP_WMDRMND_SendRegistrationRequest,N_("Send Registration Request")},
         {PTP_OC_MTP_WMDRMND_GetRegistrationResponse,N_("Get Registration Response")},
         {PTP_OC_MTP_WMDRMND_GetProximityChallenge,N_("Get Proximity Challenge")},
         {PTP_OC_MTP_WMDRMND_SendProximityResponse,N_("Send Proximity Response")},
         {PTP_OC_MTP_WMDRMND_SendWMDRMNDLicenseRequest,N_("Send WMDRM-ND License Request")},
         {PTP_OC_MTP_WMDRMND_GetWMDRMNDLicenseResponse,N_("Get WMDRM-ND License Response")},
 
         /* WiFi Provisioning MTP Extension Codes (microsoft.com/WPDWCN: 1.0) */
-        {PTP_OC_MTP_WPDWCN_ProcessWFCObject,N_("Process WFC Object")}
-};
-
-int
-ptp_render_opcode(PTPParams* params, uint16_t opcode, int spaceleft, char *txt)
+        {PTP_OC_MTP_WPDWCN_ProcessWFCObject,N_("Process WFC Object")},
+
+        /* Android Direct I/O Extensions */
+        {PTP_OC_ANDROID_GetPartialObject64,N_("Get Partial Object (64bit Offset)")},
+        {PTP_OC_ANDROID_SendPartialObject,N_("Send Partial Object")},
+        {PTP_OC_ANDROID_TruncateObject,N_("Truncate Object")},
+        {PTP_OC_ANDROID_BeginEditObject,N_("Begin Edit Object")},
+        {PTP_OC_ANDROID_EndEditObject,N_("End Edit Object")},
+};
+
+ptp_opcode_trans_t ptp_opcode_nikon_trans[] = {
+        {PTP_OC_NIKON_GetProfileAllData,"PTP_OC_NIKON_GetProfileAllData"},
+        {PTP_OC_NIKON_SendProfileData,"PTP_OC_NIKON_SendProfileData"},
+        {PTP_OC_NIKON_DeleteProfile,"PTP_OC_NIKON_DeleteProfile"},
+        {PTP_OC_NIKON_SetProfileData,"PTP_OC_NIKON_SetProfileData"},
+        {PTP_OC_NIKON_AdvancedTransfer,"PTP_OC_NIKON_AdvancedTransfer"},
+        {PTP_OC_NIKON_GetFileInfoInBlock,"PTP_OC_NIKON_GetFileInfoInBlock"},
+        {PTP_OC_NIKON_Capture,"PTP_OC_NIKON_Capture"},
+        {PTP_OC_NIKON_AfDrive,"PTP_OC_NIKON_AfDrive"},
+        {PTP_OC_NIKON_SetControlMode,"PTP_OC_NIKON_SetControlMode"},
+        {PTP_OC_NIKON_DelImageSDRAM,"PTP_OC_NIKON_DelImageSDRAM"},
+        {PTP_OC_NIKON_GetLargeThumb,"PTP_OC_NIKON_GetLargeThumb"},
+        {PTP_OC_NIKON_CurveDownload,"PTP_OC_NIKON_CurveDownload"},
+        {PTP_OC_NIKON_CurveUpload,"PTP_OC_NIKON_CurveUpload"},
+        {PTP_OC_NIKON_CheckEvent,"PTP_OC_NIKON_CheckEvent"},
+        {PTP_OC_NIKON_DeviceReady,"PTP_OC_NIKON_DeviceReady"},
+        {PTP_OC_NIKON_SetPreWBData,"PTP_OC_NIKON_SetPreWBData"},
+        {PTP_OC_NIKON_GetVendorPropCodes,"PTP_OC_NIKON_GetVendorPropCodes"},
+        {PTP_OC_NIKON_AfCaptureSDRAM,"PTP_OC_NIKON_AfCaptureSDRAM"},
+        {PTP_OC_NIKON_GetPictCtrlData,"PTP_OC_NIKON_GetPictCtrlData"},
+        {PTP_OC_NIKON_SetPictCtrlData,"PTP_OC_NIKON_SetPictCtrlData"},
+        {PTP_OC_NIKON_DelCstPicCtrl,"PTP_OC_NIKON_DelCstPicCtrl"},
+        {PTP_OC_NIKON_GetPicCtrlCapability,"PTP_OC_NIKON_GetPicCtrlCapability"},
+        {PTP_OC_NIKON_GetPreviewImg,"PTP_OC_NIKON_GetPreviewImg"},
+        {PTP_OC_NIKON_StartLiveView,"PTP_OC_NIKON_StartLiveView"},
+        {PTP_OC_NIKON_EndLiveView,"PTP_OC_NIKON_EndLiveView"},
+        {PTP_OC_NIKON_GetLiveViewImg,"PTP_OC_NIKON_GetLiveViewImg"},
+        {PTP_OC_NIKON_MfDrive,"PTP_OC_NIKON_MfDrive"},
+        {PTP_OC_NIKON_ChangeAfArea,"PTP_OC_NIKON_ChangeAfArea"},
+        {PTP_OC_NIKON_AfDriveCancel,"PTP_OC_NIKON_AfDriveCancel"},
+        {PTP_OC_NIKON_InitiateCaptureRecInMedia,"PTP_OC_NIKON_InitiateCaptureRecInMedia"},
+        {PTP_OC_NIKON_GetVendorStorageIDs,"PTP_OC_NIKON_GetVendorStorageIDs"},
+        {PTP_OC_NIKON_StartMovieRecInCard,"PTP_OC_NIKON_StartMovieRecInCard"},
+        {PTP_OC_NIKON_EndMovieRec,"PTP_OC_NIKON_EndMovieRec"},
+        {PTP_OC_NIKON_TerminateCapture,"PTP_OC_NIKON_TerminateCapture"},
+        {PTP_OC_NIKON_GetDevicePTPIPInfo,"PTP_OC_NIKON_GetDevicePTPIPInfo"},
+        {PTP_OC_NIKON_GetPartialObjectHiSpeed,"PTP_OC_NIKON_GetPartialObjectHiSpeed"},
+        {PTP_OC_NIKON_GetDevicePropEx,"PTP_OC_NIKON_GetDevicePropEx"},
+};
+
+ptp_opcode_trans_t ptp_opcode_canon_trans[] = {
+        {PTP_OC_CANON_GetPartialObjectInfo,"PTP_OC_CANON_GetPartialObjectInfo"},
+        {PTP_OC_CANON_SetObjectArchive,"PTP_OC_CANON_SetObjectArchive"},
+        {PTP_OC_CANON_KeepDeviceOn,"PTP_OC_CANON_KeepDeviceOn"},
+        {PTP_OC_CANON_LockDeviceUI,"PTP_OC_CANON_LockDeviceUI"},
+        {PTP_OC_CANON_UnlockDeviceUI,"PTP_OC_CANON_UnlockDeviceUI"},
+        {PTP_OC_CANON_GetObjectHandleByName,"PTP_OC_CANON_GetObjectHandleByName"},
+        {PTP_OC_CANON_InitiateReleaseControl,"PTP_OC_CANON_InitiateReleaseControl"},
+        {PTP_OC_CANON_TerminateReleaseControl,"PTP_OC_CANON_TerminateReleaseControl"},
+        {PTP_OC_CANON_TerminatePlaybackMode,"PTP_OC_CANON_TerminatePlaybackMode"},
+        {PTP_OC_CANON_ViewfinderOn,"PTP_OC_CANON_ViewfinderOn"},
+        {PTP_OC_CANON_ViewfinderOff,"PTP_OC_CANON_ViewfinderOff"},
+        {PTP_OC_CANON_DoAeAfAwb,"PTP_OC_CANON_DoAeAfAwb"},
+        {PTP_OC_CANON_GetCustomizeSpec,"PTP_OC_CANON_GetCustomizeSpec"},
+        {PTP_OC_CANON_GetCustomizeItemInfo,"PTP_OC_CANON_GetCustomizeItemInfo"},
+        {PTP_OC_CANON_GetCustomizeData,"PTP_OC_CANON_GetCustomizeData"},
+        {PTP_OC_CANON_SetCustomizeData,"PTP_OC_CANON_SetCustomizeData"},
+        {PTP_OC_CANON_GetCaptureStatus,"PTP_OC_CANON_GetCaptureStatus"},
+        {PTP_OC_CANON_CheckEvent,"PTP_OC_CANON_CheckEvent"},
+        {PTP_OC_CANON_FocusLock,"PTP_OC_CANON_FocusLock"},
+        {PTP_OC_CANON_FocusUnlock,"PTP_OC_CANON_FocusUnlock"},
+        {PTP_OC_CANON_GetLocalReleaseParam,"PTP_OC_CANON_GetLocalReleaseParam"},
+        {PTP_OC_CANON_SetLocalReleaseParam,"PTP_OC_CANON_SetLocalReleaseParam"},
+        {PTP_OC_CANON_AskAboutPcEvf,"PTP_OC_CANON_AskAboutPcEvf"},
+        {PTP_OC_CANON_SendPartialObject,"PTP_OC_CANON_SendPartialObject"},
+        {PTP_OC_CANON_InitiateCaptureInMemory,"PTP_OC_CANON_InitiateCaptureInMemory"},
+        {PTP_OC_CANON_GetPartialObjectEx,"PTP_OC_CANON_GetPartialObjectEx"},
+        {PTP_OC_CANON_SetObjectTime,"PTP_OC_CANON_SetObjectTime"},
+        {PTP_OC_CANON_GetViewfinderImage,"PTP_OC_CANON_GetViewfinderImage"},
+        {PTP_OC_CANON_GetObjectAttributes,"PTP_OC_CANON_GetObjectAttributes"},
+        {PTP_OC_CANON_ChangeUSBProtocol,"PTP_OC_CANON_ChangeUSBProtocol"},
+        {PTP_OC_CANON_GetChanges,"PTP_OC_CANON_GetChanges"},
+        {PTP_OC_CANON_GetObjectInfoEx,"PTP_OC_CANON_GetObjectInfoEx"},
+        {PTP_OC_CANON_InitiateDirectTransfer,"PTP_OC_CANON_InitiateDirectTransfer"},
+        {PTP_OC_CANON_TerminateDirectTransfer ,"PTP_OC_CANON_TerminateDirectTransfer "},
+        {PTP_OC_CANON_SendObjectInfoByPath ,"PTP_OC_CANON_SendObjectInfoByPath "},
+        {PTP_OC_CANON_SendObjectByPath ,"PTP_OC_CANON_SendObjectByPath "},
+        {PTP_OC_CANON_InitiateDirectTansferEx,"PTP_OC_CANON_InitiateDirectTansferEx"},
+        {PTP_OC_CANON_GetAncillaryObjectHandles,"PTP_OC_CANON_GetAncillaryObjectHandles"},
+        {PTP_OC_CANON_GetTreeInfo ,"PTP_OC_CANON_GetTreeInfo "},
+        {PTP_OC_CANON_GetTreeSize ,"PTP_OC_CANON_GetTreeSize "},
+        {PTP_OC_CANON_NotifyProgress ,"PTP_OC_CANON_NotifyProgress "},
+        {PTP_OC_CANON_NotifyCancelAccepted,"PTP_OC_CANON_NotifyCancelAccepted"},
+        {PTP_OC_CANON_902C,"PTP_OC_CANON_902C"},
+        {PTP_OC_CANON_GetDirectory,"PTP_OC_CANON_GetDirectory"},
+        {PTP_OC_CANON_SetPairingInfo,"PTP_OC_CANON_SetPairingInfo"},
+        {PTP_OC_CANON_GetPairingInfo,"PTP_OC_CANON_GetPairingInfo"},
+        {PTP_OC_CANON_DeletePairingInfo,"PTP_OC_CANON_DeletePairingInfo"},
+        {PTP_OC_CANON_GetMACAddress,"PTP_OC_CANON_GetMACAddress"},
+        {PTP_OC_CANON_SetDisplayMonitor,"PTP_OC_CANON_SetDisplayMonitor"},
+        {PTP_OC_CANON_PairingComplete,"PTP_OC_CANON_PairingComplete"},
+        {PTP_OC_CANON_GetWirelessMAXChannel,"PTP_OC_CANON_GetWirelessMAXChannel"},
+        {PTP_OC_CANON_GetWebServiceSpec,"PTP_OC_CANON_GetWebServiceSpec"},
+        {PTP_OC_CANON_GetWebServiceData,"PTP_OC_CANON_GetWebServiceData"},
+        {PTP_OC_CANON_SetWebServiceData,"PTP_OC_CANON_SetWebServiceData"},
+        {PTP_OC_CANON_GetRootCertificateSpec,"PTP_OC_CANON_GetRootCertificateSpec"},
+        {PTP_OC_CANON_GetRootCertificateData,"PTP_OC_CANON_GetRootCertificateData"},
+        {PTP_OC_CANON_SetRootCertificateData,"PTP_OC_CANON_SetRootCertificateData"},
+        {PTP_OC_CANON_EOS_GetStorageIDs,"PTP_OC_CANON_EOS_GetStorageIDs"},
+        {PTP_OC_CANON_EOS_GetStorageInfo,"PTP_OC_CANON_EOS_GetStorageInfo"},
+        {PTP_OC_CANON_EOS_GetObjectInfo,"PTP_OC_CANON_EOS_GetObjectInfo"},
+        {PTP_OC_CANON_EOS_GetObject,"PTP_OC_CANON_EOS_GetObject"},
+        {PTP_OC_CANON_EOS_DeleteObject,"PTP_OC_CANON_EOS_DeleteObject"},
+        {PTP_OC_CANON_EOS_FormatStore,"PTP_OC_CANON_EOS_FormatStore"},
+        {PTP_OC_CANON_EOS_GetPartialObject,"PTP_OC_CANON_EOS_GetPartialObject"},
+        {PTP_OC_CANON_EOS_GetDeviceInfoEx,"PTP_OC_CANON_EOS_GetDeviceInfoEx"},
+        {PTP_OC_CANON_EOS_GetObjectInfoEx,"PTP_OC_CANON_EOS_GetObjectInfoEx"},
+        {PTP_OC_CANON_EOS_GetThumbEx,"PTP_OC_CANON_EOS_GetThumbEx"},
+        {PTP_OC_CANON_EOS_SendPartialObject,"PTP_OC_CANON_EOS_SendPartialObject"},
+        {PTP_OC_CANON_EOS_SetObjectAttributes,"PTP_OC_CANON_EOS_SetObjectAttributes"},
+        {PTP_OC_CANON_EOS_GetObjectTime,"PTP_OC_CANON_EOS_GetObjectTime"},
+        {PTP_OC_CANON_EOS_SetObjectTime,"PTP_OC_CANON_EOS_SetObjectTime"},
+        {PTP_OC_CANON_EOS_RemoteRelease,"PTP_OC_CANON_EOS_RemoteRelease"},
+        {PTP_OC_CANON_EOS_SetDevicePropValueEx,"PTP_OC_CANON_EOS_SetDevicePropValueEx"},
+        {PTP_OC_CANON_EOS_GetRemoteMode,"PTP_OC_CANON_EOS_GetRemoteMode"},
+        {PTP_OC_CANON_EOS_SetRemoteMode,"PTP_OC_CANON_EOS_SetRemoteMode"},
+        {PTP_OC_CANON_EOS_SetEventMode,"PTP_OC_CANON_EOS_SetEventMode"},
+        {PTP_OC_CANON_EOS_GetEvent,"PTP_OC_CANON_EOS_GetEvent"},
+        {PTP_OC_CANON_EOS_TransferComplete,"PTP_OC_CANON_EOS_TransferComplete"},
+        {PTP_OC_CANON_EOS_CancelTransfer,"PTP_OC_CANON_EOS_CancelTransfer"},
+        {PTP_OC_CANON_EOS_ResetTransfer,"PTP_OC_CANON_EOS_ResetTransfer"},
+        {PTP_OC_CANON_EOS_PCHDDCapacity,"PTP_OC_CANON_EOS_PCHDDCapacity"},
+        {PTP_OC_CANON_EOS_SetUILock,"PTP_OC_CANON_EOS_SetUILock"},
+        {PTP_OC_CANON_EOS_ResetUILock,"PTP_OC_CANON_EOS_ResetUILock"},
+        {PTP_OC_CANON_EOS_KeepDeviceOn,"PTP_OC_CANON_EOS_KeepDeviceOn"},
+        {PTP_OC_CANON_EOS_SetNullPacketMode,"PTP_OC_CANON_EOS_SetNullPacketMode"},
+        {PTP_OC_CANON_EOS_UpdateFirmware,"PTP_OC_CANON_EOS_UpdateFirmware"},
+        {PTP_OC_CANON_EOS_TransferCompleteDT,"PTP_OC_CANON_EOS_TransferCompleteDT"},
+        {PTP_OC_CANON_EOS_CancelTransferDT,"PTP_OC_CANON_EOS_CancelTransferDT"},
+        {PTP_OC_CANON_EOS_SetWftProfile,"PTP_OC_CANON_EOS_SetWftProfile"},
+        {PTP_OC_CANON_EOS_GetWftProfile,"PTP_OC_CANON_EOS_GetWftProfile"},
+        {PTP_OC_CANON_EOS_SetProfileToWft,"PTP_OC_CANON_EOS_SetProfileToWft"},
+        {PTP_OC_CANON_EOS_BulbStart,"PTP_OC_CANON_EOS_BulbStart"},
+        {PTP_OC_CANON_EOS_BulbEnd,"PTP_OC_CANON_EOS_BulbEnd"},
+        {PTP_OC_CANON_EOS_RequestDevicePropValue,"PTP_OC_CANON_EOS_RequestDevicePropValue"},
+        {PTP_OC_CANON_EOS_RemoteReleaseOn,"PTP_OC_CANON_EOS_RemoteReleaseOn"},
+        {PTP_OC_CANON_EOS_RemoteReleaseOff,"PTP_OC_CANON_EOS_RemoteReleaseOff"},
+        {PTP_OC_CANON_EOS_RegistBackgroundImage,"PTP_OC_CANON_EOS_RegistBackgroundImage"},
+        {PTP_OC_CANON_EOS_ChangePhotoStudioMode,"PTP_OC_CANON_EOS_ChangePhotoStudioMode"},
+        {PTP_OC_CANON_EOS_GetPartialObjectEx,"PTP_OC_CANON_EOS_GetPartialObjectEx"},
+        {PTP_OC_CANON_EOS_ResetMirrorLockupState,"PTP_OC_CANON_EOS_ResetMirrorLockupState"},
+        {PTP_OC_CANON_EOS_PopupBuiltinFlash,"PTP_OC_CANON_EOS_PopupBuiltinFlash"},
+        {PTP_OC_CANON_EOS_EndGetPartialObjectEx,"PTP_OC_CANON_EOS_EndGetPartialObjectEx"},
+        {PTP_OC_CANON_EOS_MovieSelectSWOn,"PTP_OC_CANON_EOS_MovieSelectSWOn"},
+        {PTP_OC_CANON_EOS_MovieSelectSWOff,"PTP_OC_CANON_EOS_MovieSelectSWOff"},
+        {PTP_OC_CANON_EOS_GetCTGInfo,"PTP_OC_CANON_EOS_GetCTGInfo"},
+        {PTP_OC_CANON_EOS_GetLensAdjust,"PTP_OC_CANON_EOS_GetLensAdjust"},
+        {PTP_OC_CANON_EOS_SetLensAdjust,"PTP_OC_CANON_EOS_SetLensAdjust"},
+        {PTP_OC_CANON_EOS_GetMusicInfo,"PTP_OC_CANON_EOS_GetMusicInfo"},
+        {PTP_OC_CANON_EOS_CreateHandle,"PTP_OC_CANON_EOS_CreateHandle"},
+        {PTP_OC_CANON_EOS_SendPartialObjectEx,"PTP_OC_CANON_EOS_SendPartialObjectEx"},
+        {PTP_OC_CANON_EOS_EndSendPartialObjectEx,"PTP_OC_CANON_EOS_EndSendPartialObjectEx"},
+        {PTP_OC_CANON_EOS_SetCTGInfo,"PTP_OC_CANON_EOS_SetCTGInfo"},
+        {PTP_OC_CANON_EOS_SetRequestOLCInfoGroup,"PTP_OC_CANON_EOS_SetRequestOLCInfoGroup"},
+        {PTP_OC_CANON_EOS_SetRequestRollingPitchingLevel,"PTP_OC_CANON_EOS_SetRequestRollingPitchingLevel"},
+        {PTP_OC_CANON_EOS_GetCameraSupport,"PTP_OC_CANON_EOS_GetCameraSupport"},
+        {PTP_OC_CANON_EOS_SetRating,"PTP_OC_CANON_EOS_SetRating"},
+        {PTP_OC_CANON_EOS_RequestInnerDevelopStart,"PTP_OC_CANON_EOS_RequestInnerDevelopStart"},
+        {PTP_OC_CANON_EOS_RequestInnerDevelopParamChange,"PTP_OC_CANON_EOS_RequestInnerDevelopParamChange"},
+        {PTP_OC_CANON_EOS_RequestInnerDevelopEnd,"PTP_OC_CANON_EOS_RequestInnerDevelopEnd"},
+        {PTP_OC_CANON_EOS_GpsLoggingDataMode,"PTP_OC_CANON_EOS_GpsLoggingDataMode"},
+        {PTP_OC_CANON_EOS_GetGpsLogCurrentHandle,"PTP_OC_CANON_EOS_GetGpsLogCurrentHandle"},
+        {PTP_OC_CANON_EOS_InitiateViewfinder,"PTP_OC_CANON_EOS_InitiateViewfinder"},
+        {PTP_OC_CANON_EOS_TerminateViewfinder,"PTP_OC_CANON_EOS_TerminateViewfinder"},
+        {PTP_OC_CANON_EOS_GetViewFinderData,"PTP_OC_CANON_EOS_GetViewFinderData"},
+        {PTP_OC_CANON_EOS_DoAf,"PTP_OC_CANON_EOS_DoAf"},
+        {PTP_OC_CANON_EOS_DriveLens,"PTP_OC_CANON_EOS_DriveLens"},
+        {PTP_OC_CANON_EOS_DepthOfFieldPreview,"PTP_OC_CANON_EOS_DepthOfFieldPreview"},
+        {PTP_OC_CANON_EOS_ClickWB,"PTP_OC_CANON_EOS_ClickWB"},
+        {PTP_OC_CANON_EOS_Zoom,"PTP_OC_CANON_EOS_Zoom"},
+        {PTP_OC_CANON_EOS_ZoomPosition,"PTP_OC_CANON_EOS_ZoomPosition"},
+        {PTP_OC_CANON_EOS_SetLiveAfFrame,"PTP_OC_CANON_EOS_SetLiveAfFrame"},
+        {PTP_OC_CANON_EOS_TouchAfPosition,"PTP_OC_CANON_EOS_TouchAfPosition"},
+        {PTP_OC_CANON_EOS_SetLvPcFlavoreditMode,"PTP_OC_CANON_EOS_SetLvPcFlavoreditMode"},
+        {PTP_OC_CANON_EOS_SetLvPcFlavoreditParam,"PTP_OC_CANON_EOS_SetLvPcFlavoreditParam"},
+        {PTP_OC_CANON_EOS_AfCancel,"PTP_OC_CANON_EOS_AfCancel"},
+        {PTP_OC_CANON_EOS_SetDefaultCameraSetting,"PTP_OC_CANON_EOS_SetDefaultCameraSetting"},
+        {PTP_OC_CANON_EOS_GetAEData,"PTP_OC_CANON_EOS_GetAEData"},
+        {PTP_OC_CANON_EOS_NotifyNetworkError,"PTP_OC_CANON_EOS_NotifyNetworkError"},
+        {PTP_OC_CANON_EOS_AdapterTransferProgress,"PTP_OC_CANON_EOS_AdapterTransferProgress"},
+        {PTP_OC_CANON_EOS_TransferComplete2,"PTP_OC_CANON_EOS_TransferComplete2"},
+        {PTP_OC_CANON_EOS_CancelTransfer2,"PTP_OC_CANON_EOS_CancelTransfer2"},
+        {PTP_OC_CANON_EOS_FAPIMessageTX,"PTP_OC_CANON_EOS_FAPIMessageTX"},
+        {PTP_OC_CANON_EOS_FAPIMessageRX,"PTP_OC_CANON_EOS_FAPIMessageRX"},
+};
+
+ptp_opcode_trans_t ptp_opcode_sony_trans[] = {
+        {PTP_OC_SONY_SDIOConnect,"PTP_OC_SONY_SDIOConnect"},
+        {PTP_OC_SONY_GetSDIOGetExtDeviceInfo,"PTP_OC_SONY_GetSDIOGetExtDeviceInfo"},
+        {PTP_OC_SONY_GetDevicePropdesc,"PTP_OC_SONY_GetDevicePropdesc"},
+        {PTP_OC_SONY_GetDevicePropertyValue,"PTP_OC_SONY_GetDevicePropertyValue"},
+        {PTP_OC_SONY_SetControlDeviceA,"PTP_OC_SONY_SetControlDeviceA"},
+        {PTP_OC_SONY_GetControlDeviceDesc,"PTP_OC_SONY_GetControlDeviceDesc"},
+        {PTP_OC_SONY_SetControlDeviceB,"PTP_OC_SONY_SetControlDeviceB"},
+        {PTP_OC_SONY_GetAllDevicePropData,"PTP_OC_SONY_GetAllDevicePropData"},
+};
+
+const char*
+ptp_get_opcode_name(PTPParams* params, uint16_t opcode)
 {
-        int i;
-
-        if (!(opcode & 0x8000)) {
-                for (i=0;i<sizeof(ptp_opcode_trans)/sizeof(ptp_opcode_trans[0]);i++)
-                        if (opcode == ptp_opcode_trans[i].opcode)
-                                return snprintf(txt, spaceleft, "%s", _(ptp_opcode_trans[i].name));
-        } else {
-                switch (params->deviceinfo.VendorExtensionID) {
-                case PTP_VENDOR_MICROSOFT:
-                case PTP_VENDOR_MTP:
-                        for (i=0;i<sizeof(ptp_opcode_mtp_trans)/sizeof(ptp_opcode_mtp_trans[0]);i++)
-                                if (opcode == ptp_opcode_mtp_trans[i].opcode)
-                                        return snprintf(txt, spaceleft, "%s", _(ptp_opcode_mtp_trans[i].name));
-                        break;
-                default:break;
-                }
+#define RETURN_NAME_FROM_TABLE(TABLE, OPCODE) \
+{ \
+        unsigned int i; \
+        for (i=0; i<sizeof(TABLE)/sizeof(TABLE[0]); i++) \
+                if (OPCODE == TABLE[i].opcode) \
+                        return _(TABLE[i].name); \
+        return _("Unknown PTP_OC"); \
+}
+
+        if (!(opcode & 0x8000))
+                RETURN_NAME_FROM_TABLE(ptp_opcode_trans, opcode);
+
+        switch (params->deviceinfo.VendorExtensionID) {
+        case PTP_VENDOR_MICROSOFT:
+        case PTP_VENDOR_MTP:    RETURN_NAME_FROM_TABLE(ptp_opcode_mtp_trans, opcode);
+        case PTP_VENDOR_NIKON:  RETURN_NAME_FROM_TABLE(ptp_opcode_nikon_trans, opcode);
+        case PTP_VENDOR_CANON:  RETURN_NAME_FROM_TABLE(ptp_opcode_canon_trans, opcode);
+        case PTP_VENDOR_SONY:   RETURN_NAME_FROM_TABLE(ptp_opcode_sony_trans, opcode);
+        default:
+                break;
         }
-        return snprintf (txt, spaceleft,_("Unknown (%04x)"), opcode);
+#undef RETURN_NAME_FROM_TABLE
+
+        return _("Unknown VendorExtensionID");
 }
 
 
 struct {
         uint16_t id;
         const char *name;
 } ptp_opc_trans[] = {
         {PTP_OPC_StorageID,"StorageID"},
         {PTP_OPC_ObjectFormat,"ObjectFormat"},
         {PTP_OPC_ProtectionStatus,"ProtectionStatus"},
@@ skipping 158 matching lines @@
         {PTP_OPC_VideoBitRate,"VideoBitRate"},
         {PTP_OPC_FramesPerThousandSeconds,"FramesPerThousandSeconds"},
         {PTP_OPC_KeyFrameDistance,"KeyFrameDistance"},
         {PTP_OPC_BufferSize,"BufferSize"},
         {PTP_OPC_EncodingQuality,"EncodingQuality"},
         {PTP_OPC_EncodingProfile,"EncodingProfile"},
         {PTP_OPC_BuyFlag,"BuyFlag"},
 };
 
 int
-ptp_render_mtp_propname(uint16_t propid, int spaceleft, char *txt) {
-        int i;
+ptp_render_mtp_propname(uint16_t propid, int spaceleft, char *txt)
+{
+        unsigned int i;
         for (i=0;i<sizeof(ptp_opc_trans)/sizeof(ptp_opc_trans[0]);i++)
                 if (propid == ptp_opc_trans[i].id)
                         return snprintf(txt, spaceleft, "%s", ptp_opc_trans[i].name);
         return snprintf (txt, spaceleft,"unknown(%04x)", propid);
 }
 
 /*
  * Allocate and default-initialize a few object properties.
  */
 MTPProperties *
-ptp_get_new_object_prop_entry(MTPProperties **props, int *nrofprops) {
+ptp_get_new_object_prop_entry(MTPProperties **props, int *nrofprops)
+{
         MTPProperties *newprops;
         MTPProperties *prop;
 
-        if (*props == NULL) {
-                newprops = malloc(sizeof(MTPProperties)*(*nrofprops+1));
-        } else {
-                newprops = realloc(*props,sizeof(MTPProperties)*(*nrofprops+1));
-        }
+        newprops = realloc(*props,sizeof(MTPProperties)*(*nrofprops+1));
         if (newprops == NULL)
                 return NULL;
         prop = &newprops[*nrofprops];
         prop->property = PTP_OPC_StorageID; /* Should be "unknown" */
         prop->datatype = PTP_DTC_UNDEF;
         prop->ObjectHandle = 0x00000000U;
         prop->propval.str = NULL;
         
         (*props) = newprops;
         (*nrofprops)++;
@@ skipping 27 matching lines @@
   free(props);
 }
 
 /*
  * Find a certain object property in the cache, i.e. a certain metadata
  * item for a certain object handle.
  */
 MTPProperties *
 ptp_find_object_prop_in_cache(PTPParams *params, uint32_t const handle, uint32_t const attribute_id)
 {
-        int     i;
+        unsigned int    i;
         MTPProperties   *prop;
         PTPObject       *ob;
         uint16_t        ret;
 
         ret = ptp_object_find (params, handle, &ob);
         if (ret != PTP_RC_OK)
                 return NULL;
         prop = ob->mtpprops;
         for (i=0;i<ob->nrofmtpprops;i++) {
                 if (attribute_id == prop->property)
                         return prop;
                 prop++;
         }
         return NULL;
 }
 
-void
+uint16_t
 ptp_remove_object_from_cache(PTPParams *params, uint32_t handle)
 {
-        int i;
+        unsigned int i;
         PTPObject       *ob;
-        uint16_t        ret;
 
-        ret = ptp_object_find (params, handle, &ob);
-        if (ret != PTP_RC_OK)
-                return;
+        CHECK_PTP_RC(ptp_object_find (params, handle, &ob));
         i = ob-params->objects;
         /* remove object from object info cache */
         ptp_free_object (ob);
 
         if (i < params->nrofobjects-1)
                 memmove (ob,ob+1,(params->nrofobjects-1-i)*sizeof(PTPObject));
         params->nrofobjects--;
         /* We use less memory than before so this shouldn't fail */
         params->objects = realloc(params->objects, sizeof(PTPObject)*params->nrofobjects);
+        return PTP_RC_OK;
 }
 
-static int _cmp_ob (const void *a, const void *b) {
+static int _cmp_ob (const void *a, const void *b)
+{
         PTPObject *oa = (PTPObject*)a;
         PTPObject *ob = (PTPObject*)b;
 
         return oa->oid - ob->oid;
 }
         
 void
-ptp_objects_sort (PTPParams *params) {
+ptp_objects_sort (PTPParams *params)
+{
         qsort (params->objects, params->nrofobjects, sizeof(PTPObject), _cmp_ob);
 }
 
 /* Binary search in objects. Needs "objects" to be a sorted by objectid list!  */
 uint16_t
-ptp_object_find (PTPParams *params, uint32_t handle, PTPObject **retob) {
+ptp_object_find (PTPParams *params, uint32_t handle, PTPObject **retob)
+{
         PTPObject       tmpob;
 
         tmpob.oid = handle;
         *retob = bsearch (&tmpob, params->objects, params->nrofobjects, sizeof(tmpob), _cmp_ob);
         if (!*retob)
                 return PTP_RC_GeneralError;
         return PTP_RC_OK;
 }
 
 /* Binary search in objects + insert of not found. Needs "objects" to be a sorted by objectid list!  */
 uint16_t
-ptp_object_find_or_insert (PTPParams *params, uint32_t handle, PTPObject **retob) {
-        int             begin, end, cursor;
-        int             insertat;
+ptp_object_find_or_insert (PTPParams *params, uint32_t handle, PTPObject **retob)
+{
+        unsigned int    begin, end, cursor;
+        unsigned int    insertat;
         PTPObject       *newobs;
 
         if (!handle) return PTP_RC_GeneralError;
         *retob = NULL;
         if (!params->nrofobjects) {
                 params->objects = calloc(1,sizeof(PTPObject));
                 params->nrofobjects = 1;
                 params->objects[0].oid = handle;
                 *retob = &params->objects[0];
                 return PTP_RC_OK;
@@ skipping 28 matching lines @@
         } else {
                 if ((end == params->nrofobjects-1) && (handle > params->objects[end].oid))
                         insertat=end+1;
                 else
                         insertat=begin+1;
         }
         /*ptp_debug (params, "inserting oid %x at [%x,%x], begin=%d, end=%d, insertat=%d\n", handle, params->objects[begin].oid, params->objects[end].oid, begin, end, insertat);*/
         newobs = realloc (params->objects, sizeof(PTPObject)*(params->nrofobjects+1));
         if (!newobs) return PTP_RC_GeneralError;
         params->objects = newobs;
-        if (insertat<=params->nrofobjects)
+        if (insertat<params->nrofobjects)
                 memmove (&params->objects[insertat+1],&params->objects[insertat],(params->nrofobjects-insertat)*sizeof(PTPObject));
         memset(&params->objects[insertat],0,sizeof(PTPObject));
         params->objects[insertat].oid = handle;
         *retob = &params->objects[insertat];
         params->nrofobjects++;
         return PTP_RC_OK;
 }
 
 uint16_t
-ptp_object_want (PTPParams *params, uint32_t handle, int want, PTPObject **retob) {
+ptp_object_want (PTPParams *params, uint32_t handle, unsigned int want, PTPObject **retob)
+{
         uint16_t        ret;
         PTPObject       *ob;
         /*Camera                *camera = ((PTPData *)params->data)->camera;*/
 
         /* If GetObjectInfo is broken, force GetPropList */
         if (params->device_flags & DEVICE_FLAG_PROPLIST_OVERRIDES_OI)
                 want |= PTPOBJECT_MTPPROPLIST_LOADED;
 
         *retob = NULL;
         if (!handle) {
                 ptp_debug (params, "ptp_object_want: querying handle 0?\n");
                 return PTP_RC_GeneralError;
         }
-        ret = ptp_object_find_or_insert (params, handle, &ob);
-        if (ret != PTP_RC_OK)
-                return PTP_RC_GeneralError;
+        CHECK_PTP_RC(ptp_object_find_or_insert (params, handle, &ob));
         *retob = ob;
         /* Do we have all of it already? */
         if ((ob->flags & want) == want)
                 return PTP_RC_OK;
 
 #define X (PTPOBJECT_OBJECTINFO_LOADED|PTPOBJECT_STORAGEID_LOADED|PTPOBJECT_PARENTOBJECT_LOADED)
         if ((want & X) && ((ob->flags & X) != X)) {
                 uint32_t        saveparent = 0;
                 
                 /* One EOS issue, where getobjecthandles(root) returns obs without root flag. */
                 if (ob->flags & PTPOBJECT_PARENTOBJECT_LOADED)
                         saveparent = ob->oi.ParentObject;
 
                 ret = ptp_getobjectinfo (params, handle, &ob->oi);
                 if (ret != PTP_RC_OK) {
                         /* kill it from the internal list ... */
                         ptp_remove_object_from_cache(params, handle);
                         return ret;
                 }
                 if (!ob->oi.Filename) ob->oi.Filename=strdup("<none>");
                 if (ob->flags & PTPOBJECT_PARENTOBJECT_LOADED)
                         ob->oi.ParentObject = saveparent;
 
                 /* Second EOS issue, 0x20000000 has 0x20000000 as parent */
                 if (ob->oi.ParentObject == handle)
                         ob->oi.ParentObject = 0;
+
+                /* Read out the canon special flags */
+                if ((params->deviceinfo.VendorExtensionID == PTP_VENDOR_CANON) &&
+                    ptp_operation_issupported(params,PTP_OC_CANON_GetObjectInfoEx)) {
+                        PTPCANONFolderEntry *ents = NULL;
+                        uint32_t            numents = 0;
+
+                        ret = ptp_canon_getobjectinfo(params,
+                                ob->oi.StorageID,0,
+                                ob->oi.ParentObject,handle,
+                                &ents,&numents
+                        );
+                        if ((ret == PTP_RC_OK) && (numents >= 1))
+                                ob->canon_flags = ents[0].Flags;
+                        free (ents);
+                }
+
                 ob->flags |= X;
-
-                /* EOS bug, DCIM links back to itself. */
         }
 #undef X
         if (    (want & PTPOBJECT_MTPPROPLIST_LOADED) &&
                 (!(ob->flags & PTPOBJECT_MTPPROPLIST_LOADED))
         ) {
                 int             nrofprops = 0;
                 MTPProperties   *props = NULL;
 
                 if (params->device_flags & DEVICE_FLAG_BROKEN_MTPGETOBJPROPLIST) {
                         want &= ~PTPOBJECT_MTPPROPLIST_LOADED;
                         goto fallback;
                 }
                 /* Microsoft/MTP has fast directory retrieval. */
                 if (!ptp_operation_issupported(params,PTP_OC_MTP_GetObjPropList)) {
                         want &= ~PTPOBJECT_MTPPROPLIST_LOADED;
                         goto fallback;
                 }
 
                 ptp_debug (params, "ptp2/mtpfast: reading mtp proplist of %08x", handle);
                 /* We just want this one object, not all at once. */
                 ret = ptp_mtp_getobjectproplist_single (params, handle, &props, &nrofprops);
                 if (ret != PTP_RC_OK)
                         goto fallback;
                 ob->mtpprops = props;
                 ob->nrofmtpprops = nrofprops;
 
                 /* Override the ObjectInfo data with data from properties */
                 if (params->device_flags & DEVICE_FLAG_PROPLIST_OVERRIDES_OI) {
-                        int i;
+                        unsigned int i;
                         MTPProperties *prop = ob->mtpprops;
 
                         for (i=0;i<ob->nrofmtpprops;i++,prop++) {
                                 /* in case we got all subtree objects */
                                 if (prop->ObjectHandle != handle) continue;
 
                                 switch (prop->property) {
                                 case PTP_OPC_StorageID:
                                         ob->oi.StorageID = prop->propval.u32;
                                         break;
@@ skipping 147 matching lines @@
         return PTP_RC_GeneralError;
 }
 
 
 uint16_t
 ptp_add_object_to_cache(PTPParams *params, uint32_t handle)
 {
         PTPObject *ob;
         return ptp_object_want (params, handle, PTPOBJECT_OBJECTINFO_LOADED|PTPOBJECT_MTPPROPLIST_LOADED, &ob);
 }