Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 1 | /* ptp-pack.c |
| 2 | * |
| 3 | * Copyright (C) 2001-2004 Mariusz Woloszyn <emsi@ipartners.pl> |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 4 | * Copyright (C) 2003-2016 Marcus Meissner <marcus@jet.franken.de> |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 5 | * Copyright (C) 2006-2008 Linus Walleij <triad@df.lth.se> |
| 6 | * Copyright (C) 2007 Tero Saarni <tero.saarni@gmail.com> |
| 7 | * Copyright (C) 2009 Axel Waggershauser <awagger@web.de> |
| 8 | * |
| 9 | * This library is free software; you can redistribute it and/or |
| 10 | * modify it under the terms of the GNU Lesser General Public |
| 11 | * License as published by the Free Software Foundation; either |
| 12 | * version 2 of the License, or (at your option) any later version. |
| 13 | * |
| 14 | * This library is distributed in the hope that it will be useful, |
| 15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 17 | * Lesser General Public License for more details. |
| 18 | * |
| 19 | * You should have received a copy of the GNU Lesser General Public |
| 20 | * License along with this library; if not, write to the |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 21 | * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| 22 | * Boston, MA 02110-1301 USA |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 23 | */ |
| 24 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 25 | /* currently this file is included into ptp.c */ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 26 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 27 | #ifdef HAVE_LIMITS_H |
| 28 | #include <limits.h> |
| 29 | #endif |
| 30 | #ifndef UINT_MAX |
| 31 | # define UINT_MAX 0xFFFFFFFF |
| 32 | #endif |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 33 | #if defined(HAVE_ICONV) && defined(HAVE_LANGINFO_H) |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 34 | #include <iconv.h> |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 35 | #endif |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 36 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 37 | static inline uint16_t |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 38 | htod16p (PTPParams *params, uint16_t var) |
| 39 | { |
| 40 | return ((params->byteorder==PTP_DL_LE)?htole16(var):htobe16(var)); |
| 41 | } |
| 42 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 43 | static inline uint32_t |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 44 | htod32p (PTPParams *params, uint32_t var) |
| 45 | { |
| 46 | return ((params->byteorder==PTP_DL_LE)?htole32(var):htobe32(var)); |
| 47 | } |
| 48 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 49 | static inline void |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 50 | htod16ap (PTPParams *params, unsigned char *a, uint16_t val) |
| 51 | { |
| 52 | if (params->byteorder==PTP_DL_LE) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 53 | htole16a(a,val); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 54 | else |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 55 | htobe16a(a,val); |
| 56 | } |
| 57 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 58 | static inline void |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 59 | htod32ap (PTPParams *params, unsigned char *a, uint32_t val) |
| 60 | { |
| 61 | if (params->byteorder==PTP_DL_LE) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 62 | htole32a(a,val); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 63 | else |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 64 | htobe32a(a,val); |
| 65 | } |
| 66 | |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 67 | static inline void |
| 68 | htod64ap (PTPParams *params, unsigned char *a, uint64_t val) |
| 69 | { |
| 70 | if (params->byteorder==PTP_DL_LE) |
| 71 | htole64a(a,val); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 72 | else |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 73 | htobe64a(a,val); |
| 74 | } |
| 75 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 76 | static inline uint16_t |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 77 | dtoh16p (PTPParams *params, uint16_t var) |
| 78 | { |
| 79 | return ((params->byteorder==PTP_DL_LE)?le16toh(var):be16toh(var)); |
| 80 | } |
| 81 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 82 | static inline uint32_t |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 83 | dtoh32p (PTPParams *params, uint32_t var) |
| 84 | { |
| 85 | return ((params->byteorder==PTP_DL_LE)?le32toh(var):be32toh(var)); |
| 86 | } |
| 87 | |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 88 | static inline uint64_t |
| 89 | dtoh64p (PTPParams *params, uint64_t var) |
| 90 | { |
| 91 | return ((params->byteorder==PTP_DL_LE)?le64toh(var):be64toh(var)); |
| 92 | } |
| 93 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 94 | static inline uint16_t |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 95 | dtoh16ap (PTPParams *params, const unsigned char *a) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 96 | { |
| 97 | return ((params->byteorder==PTP_DL_LE)?le16atoh(a):be16atoh(a)); |
| 98 | } |
| 99 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 100 | static inline uint32_t |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 101 | dtoh32ap (PTPParams *params, const unsigned char *a) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 102 | { |
| 103 | return ((params->byteorder==PTP_DL_LE)?le32atoh(a):be32atoh(a)); |
| 104 | } |
| 105 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 106 | static inline uint64_t |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 107 | dtoh64ap (PTPParams *params, const unsigned char *a) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 108 | { |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 109 | return ((params->byteorder==PTP_DL_LE)?le64atoh(a):be64atoh(a)); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 110 | } |
| 111 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 112 | #define htod8a(a,x) *(uint8_t*)(a) = x |
| 113 | #define htod16a(a,x) htod16ap(params,a,x) |
| 114 | #define htod32a(a,x) htod32ap(params,a,x) |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 115 | #define htod64a(a,x) htod64ap(params,a,x) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 116 | #define htod16(x) htod16p(params,x) |
| 117 | #define htod32(x) htod32p(params,x) |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 118 | #define htod64(x) htod64p(params,x) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 119 | |
| 120 | #define dtoh8a(x) (*(uint8_t*)(x)) |
| 121 | #define dtoh16a(a) dtoh16ap(params,a) |
| 122 | #define dtoh32a(a) dtoh32ap(params,a) |
| 123 | #define dtoh64a(a) dtoh64ap(params,a) |
| 124 | #define dtoh16(x) dtoh16p(params,x) |
| 125 | #define dtoh32(x) dtoh32p(params,x) |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 126 | #define dtoh64(x) dtoh64p(params,x) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 127 | |
| 128 | |
| 129 | static inline char* |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 130 | ptp_unpack_string(PTPParams *params, unsigned char* data, uint16_t offset, uint32_t total, uint8_t *len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 131 | { |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 132 | uint8_t length; |
| 133 | uint16_t string[PTP_MAXSTRLEN+1]; |
| 134 | /* allow for UTF-8: max of 3 bytes per UCS-2 char, plus final null */ |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 135 | char loclstr[PTP_MAXSTRLEN*3+1]; |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 136 | size_t nconv, srclen, destlen; |
| 137 | char *src, *dest; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 138 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 139 | if (offset + 1 >= total) |
| 140 | return NULL; |
| 141 | |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 142 | length = dtoh8a(&data[offset]); /* PTP_MAXSTRLEN == 255, 8 bit len */ |
| 143 | *len = length; |
| 144 | if (length == 0) /* nothing to do? */ |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 145 | return NULL; |
| 146 | |
| 147 | if (offset + 1 + length*sizeof(string[0]) > total) |
| 148 | return NULL; |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 149 | |
| 150 | /* copy to string[] to ensure correct alignment for iconv(3) */ |
| 151 | memcpy(string, &data[offset+1], length * sizeof(string[0])); |
| 152 | string[length] = 0x0000U; /* be paranoid! add a terminator. */ |
| 153 | loclstr[0] = '\0'; |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 154 | |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 155 | /* convert from camera UCS-2 to our locale */ |
| 156 | src = (char *)string; |
| 157 | srclen = length * sizeof(string[0]); |
| 158 | dest = loclstr; |
| 159 | destlen = sizeof(loclstr)-1; |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 160 | nconv = (size_t)-1; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 161 | #if defined(HAVE_ICONV) && defined(HAVE_LANGINFO_H) |
Linus Walleij | d6f25ba | 2011-11-14 23:00:52 +0100 | [diff] [blame] | 162 | if (params->cd_ucs2_to_locale != (iconv_t)-1) |
| 163 | nconv = iconv(params->cd_ucs2_to_locale, &src, &srclen, &dest, &destlen); |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 164 | #endif |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 165 | if (nconv == (size_t) -1) { /* do it the hard way */ |
| 166 | int i; |
| 167 | /* try the old way, in case iconv is broken */ |
| 168 | for (i=0;i<length;i++) { |
| 169 | if (dtoh16a(&data[offset+1+2*i])>127) |
| 170 | loclstr[i] = '?'; |
| 171 | else |
| 172 | loclstr[i] = dtoh16a(&data[offset+1+2*i]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 173 | } |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 174 | dest = loclstr+length; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 175 | } |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 176 | *dest = '\0'; |
| 177 | loclstr[sizeof(loclstr)-1] = '\0'; /* be safe? */ |
| 178 | return(strdup(loclstr)); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 179 | } |
| 180 | |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 181 | static inline int |
| 182 | ucs2strlen(uint16_t const * const unicstr) |
| 183 | { |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 184 | int length = 0; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 185 | |
| 186 | /* Unicode strings are terminated with 2 * 0x00 */ |
| 187 | for(length = 0; unicstr[length] != 0x0000U; length ++); |
| 188 | return length; |
| 189 | } |
| 190 | |
| 191 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 192 | static inline void |
| 193 | ptp_pack_string(PTPParams *params, char *string, unsigned char* data, uint16_t offset, uint8_t *len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 194 | { |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 195 | int packedlen = 0; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 196 | uint16_t ucs2str[PTP_MAXSTRLEN+1]; |
| 197 | char *ucs2strp = (char *) ucs2str; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 198 | size_t convlen = strlen(string); |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 199 | |
| 200 | /* Cannot exceed 255 (PTP_MAXSTRLEN) since it is a single byte, duh ... */ |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 201 | memset(ucs2strp, 0, sizeof(ucs2str)); /* XXX: necessary? */ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 202 | #if defined(HAVE_ICONV) && defined(HAVE_LANGINFO_H) |
Linus Walleij | d000c37 | 2011-12-20 08:32:23 +0100 | [diff] [blame] | 203 | if (params->cd_locale_to_ucs2 != (iconv_t)-1) { |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 204 | size_t nconv; |
| 205 | size_t convmax = PTP_MAXSTRLEN * 2; /* Includes the terminator */ |
| 206 | char *stringp = string; |
| 207 | |
| 208 | nconv = iconv(params->cd_locale_to_ucs2, &stringp, &convlen, |
| 209 | &ucs2strp, &convmax); |
| 210 | if (nconv == (size_t) -1) |
| 211 | ucs2str[0] = 0x0000U; |
Linus Walleij | d6f25ba | 2011-11-14 23:00:52 +0100 | [diff] [blame] | 212 | } else |
Linus Walleij | d000c37 | 2011-12-20 08:32:23 +0100 | [diff] [blame] | 213 | #endif |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 214 | { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 215 | unsigned int i; |
| 216 | |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 217 | for (i=0;i<convlen;i++) { |
| 218 | ucs2str[i] = string[i]; |
| 219 | } |
| 220 | ucs2str[convlen] = 0; |
| 221 | } |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 222 | /* |
| 223 | * XXX: isn't packedlen just ( (uint16_t *)ucs2strp - ucs2str )? |
| 224 | * why do we need ucs2strlen()? |
| 225 | */ |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 226 | packedlen = ucs2strlen(ucs2str); |
| 227 | if (packedlen > PTP_MAXSTRLEN-1) { |
| 228 | *len=0; |
| 229 | return; |
| 230 | } |
Linus Walleij | 958441f | 2006-08-29 15:30:11 +0000 | [diff] [blame] | 231 | |
Linus Walleij | 7f23438 | 2006-12-09 19:41:00 +0000 | [diff] [blame] | 232 | /* number of characters including terminating 0 (PTP standard confirmed) */ |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 233 | htod8a(&data[offset],packedlen+1); |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 234 | memcpy(&data[offset+1], &ucs2str[0], packedlen * sizeof(ucs2str[0])); |
| 235 | htod16a(&data[offset+packedlen*2+1], 0x0000); /* terminate 0 */ |
Linus Walleij | 958441f | 2006-08-29 15:30:11 +0000 | [diff] [blame] | 236 | |
| 237 | /* The returned length is in number of characters */ |
Linus Walleij | 048d938 | 2006-12-04 08:19:19 +0000 | [diff] [blame] | 238 | *len = (uint8_t) packedlen+1; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 239 | } |
| 240 | |
| 241 | static inline unsigned char * |
Linus Walleij | 735f416 | 2006-08-29 09:18:17 +0000 | [diff] [blame] | 242 | ptp_get_packed_stringcopy(PTPParams *params, char *string, uint32_t *packed_size) |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 243 | { |
Richard Low | 8b42ca3 | 2006-11-15 08:52:17 +0000 | [diff] [blame] | 244 | uint8_t packed[PTP_MAXSTRLEN*2+3], len; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 245 | size_t plen; |
| 246 | unsigned char *retcopy = NULL; |
Richard Low | d47b921 | 2007-08-16 21:14:23 +0000 | [diff] [blame] | 247 | |
| 248 | if (string == NULL) |
| 249 | ptp_pack_string(params, "", (unsigned char*) packed, 0, &len); |
| 250 | else |
| 251 | ptp_pack_string(params, string, (unsigned char*) packed, 0, &len); |
| 252 | |
Linus Walleij | 958441f | 2006-08-29 15:30:11 +0000 | [diff] [blame] | 253 | /* returned length is in characters, then one byte for string length */ |
| 254 | plen = len*2 + 1; |
Linus Walleij | 048d938 | 2006-12-04 08:19:19 +0000 | [diff] [blame] | 255 | |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 256 | retcopy = malloc(plen); |
Linus Walleij | 735f416 | 2006-08-29 09:18:17 +0000 | [diff] [blame] | 257 | if (!retcopy) { |
| 258 | *packed_size = 0; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 259 | return NULL; |
Linus Walleij | 735f416 | 2006-08-29 09:18:17 +0000 | [diff] [blame] | 260 | } |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 261 | memcpy(retcopy, packed, plen); |
Linus Walleij | 735f416 | 2006-08-29 09:18:17 +0000 | [diff] [blame] | 262 | *packed_size = plen; |
Linus Walleij | a823a70 | 2006-08-27 21:27:46 +0000 | [diff] [blame] | 263 | return (retcopy); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 264 | } |
| 265 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 266 | static inline uint32_t |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 267 | ptp_unpack_uint32_t_array(PTPParams *params, unsigned char* data, unsigned int offset, unsigned int datalen, uint32_t **array) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 268 | { |
| 269 | uint32_t n, i=0; |
| 270 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 271 | if (!data) |
| 272 | return 0; |
| 273 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 274 | if (offset >= datalen) |
| 275 | return 0; |
| 276 | |
| 277 | if (offset + sizeof(uint32_t) > datalen) |
| 278 | return 0; |
| 279 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 280 | *array = NULL; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 281 | n=dtoh32a(&data[offset]); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 282 | if (n >= UINT_MAX/sizeof(uint32_t)) |
| 283 | return 0; |
| 284 | if (!n) |
| 285 | return 0; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 286 | |
| 287 | if (offset + sizeof(uint32_t)*(n+1) > datalen) { |
| 288 | ptp_debug (params ,"array runs over datalen bufferend (%d vs %d)", offset + sizeof(uint32_t)*(n+1) , datalen); |
| 289 | return 0; |
| 290 | } |
| 291 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 292 | *array = malloc (n*sizeof(uint32_t)); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 293 | if (!*array) |
| 294 | return 0; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 295 | for (i=0;i<n;i++) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 296 | (*array)[i]=dtoh32a(&data[offset+(sizeof(uint32_t)*(i+1))]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 297 | return n; |
| 298 | } |
| 299 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 300 | static inline uint32_t |
Linus Walleij | f67bca9 | 2006-05-29 09:33:39 +0000 | [diff] [blame] | 301 | ptp_pack_uint32_t_array(PTPParams *params, uint32_t *array, uint32_t arraylen, unsigned char **data ) |
| 302 | { |
| 303 | uint32_t i=0; |
| 304 | |
| 305 | *data = malloc ((arraylen+1)*sizeof(uint32_t)); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 306 | if (!*data) |
| 307 | return 0; |
Linus Walleij | f67bca9 | 2006-05-29 09:33:39 +0000 | [diff] [blame] | 308 | htod32a(&(*data)[0],arraylen); |
| 309 | for (i=0;i<arraylen;i++) |
| 310 | htod32a(&(*data)[sizeof(uint32_t)*(i+1)], array[i]); |
| 311 | return (arraylen+1)*sizeof(uint32_t); |
| 312 | } |
| 313 | |
| 314 | static inline uint32_t |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 315 | ptp_unpack_uint16_t_array(PTPParams *params, unsigned char* data, unsigned int offset, unsigned int datalen, uint16_t **array) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 316 | { |
| 317 | uint32_t n, i=0; |
| 318 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 319 | if (!data) |
| 320 | return 0; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 321 | *array = NULL; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 322 | n=dtoh32a(&data[offset]); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 323 | if (n >= UINT_MAX/sizeof(uint16_t)) |
| 324 | return 0; |
| 325 | if (!n) |
| 326 | return 0; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 327 | if (offset + sizeof(uint32_t) > datalen) |
| 328 | return 0; |
| 329 | if (offset + sizeof(uint32_t)+sizeof(uint16_t)*n > datalen) { |
| 330 | ptp_debug (params ,"array runs over datalen bufferend (%d vs %d)", offset + sizeof(uint32_t)+n*sizeof(uint16_t) , datalen); |
| 331 | return 0; |
| 332 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 333 | *array = malloc (n*sizeof(uint16_t)); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 334 | if (!*array) |
| 335 | return 0; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 336 | for (i=0;i<n;i++) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 337 | (*array)[i]=dtoh16a(&data[offset+(sizeof(uint16_t)*(i+2))]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 338 | return n; |
| 339 | } |
| 340 | |
| 341 | /* DeviceInfo pack/unpack */ |
| 342 | |
| 343 | #define PTP_di_StandardVersion 0 |
| 344 | #define PTP_di_VendorExtensionID 2 |
| 345 | #define PTP_di_VendorExtensionVersion 6 |
| 346 | #define PTP_di_VendorExtensionDesc 8 |
| 347 | #define PTP_di_FunctionalMode 8 |
| 348 | #define PTP_di_OperationsSupported 10 |
| 349 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 350 | static inline int |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 351 | ptp_unpack_DI (PTPParams *params, unsigned char* data, PTPDeviceInfo *di, unsigned int datalen) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 352 | { |
| 353 | uint8_t len; |
| 354 | unsigned int totallen; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 355 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 356 | if (!data) return 0; |
| 357 | if (datalen < 12) return 0; |
| 358 | memset (di, 0, sizeof(*di)); |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 359 | di->StandardVersion = dtoh16a(&data[PTP_di_StandardVersion]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 360 | di->VendorExtensionID = |
| 361 | dtoh32a(&data[PTP_di_VendorExtensionID]); |
| 362 | di->VendorExtensionVersion = |
| 363 | dtoh16a(&data[PTP_di_VendorExtensionVersion]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 364 | di->VendorExtensionDesc = |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 365 | ptp_unpack_string(params, data, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 366 | PTP_di_VendorExtensionDesc, |
| 367 | datalen, |
| 368 | &len); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 369 | totallen=len*2+1; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 370 | if (datalen <= totallen) return 0; |
| 371 | di->FunctionalMode = |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 372 | dtoh16a(&data[PTP_di_FunctionalMode+totallen]); |
| 373 | di->OperationsSupported_len = ptp_unpack_uint16_t_array(params, data, |
| 374 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 375 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 376 | &di->OperationsSupported); |
| 377 | totallen=totallen+di->OperationsSupported_len*sizeof(uint16_t)+sizeof(uint32_t); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 378 | if (datalen <= totallen+PTP_di_OperationsSupported) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 379 | di->EventsSupported_len = ptp_unpack_uint16_t_array(params, data, |
| 380 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 381 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 382 | &di->EventsSupported); |
| 383 | totallen=totallen+di->EventsSupported_len*sizeof(uint16_t)+sizeof(uint32_t); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 384 | if (datalen <= totallen+PTP_di_OperationsSupported) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 385 | di->DevicePropertiesSupported_len = |
| 386 | ptp_unpack_uint16_t_array(params, data, |
| 387 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 388 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 389 | &di->DevicePropertiesSupported); |
| 390 | totallen=totallen+di->DevicePropertiesSupported_len*sizeof(uint16_t)+sizeof(uint32_t); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 391 | if (datalen <= totallen+PTP_di_OperationsSupported) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 392 | di->CaptureFormats_len = ptp_unpack_uint16_t_array(params, data, |
| 393 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 394 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 395 | &di->CaptureFormats); |
| 396 | totallen=totallen+di->CaptureFormats_len*sizeof(uint16_t)+sizeof(uint32_t); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 397 | if (datalen <= totallen+PTP_di_OperationsSupported) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 398 | di->ImageFormats_len = ptp_unpack_uint16_t_array(params, data, |
| 399 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 400 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 401 | &di->ImageFormats); |
| 402 | totallen=totallen+di->ImageFormats_len*sizeof(uint16_t)+sizeof(uint32_t); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 403 | if (datalen <= totallen+PTP_di_OperationsSupported) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 404 | di->Manufacturer = ptp_unpack_string(params, data, |
| 405 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 406 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 407 | &len); |
| 408 | totallen+=len*2+1; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 409 | /* be more relaxed ... as these are optional its ok if they are not here */ |
| 410 | if (datalen <= totallen+PTP_di_OperationsSupported) return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 411 | di->Model = ptp_unpack_string(params, data, |
| 412 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 413 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 414 | &len); |
| 415 | totallen+=len*2+1; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 416 | /* be more relaxed ... as these are optional its ok if they are not here */ |
| 417 | if (datalen <= totallen+PTP_di_OperationsSupported) return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 418 | di->DeviceVersion = ptp_unpack_string(params, data, |
| 419 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 420 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 421 | &len); |
| 422 | totallen+=len*2+1; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 423 | /* be more relaxed ... as these are optional its ok if they are not here */ |
| 424 | if (datalen <= totallen+PTP_di_OperationsSupported) return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 425 | di->SerialNumber = ptp_unpack_string(params, data, |
| 426 | PTP_di_OperationsSupported+totallen, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 427 | datalen, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 428 | &len); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 429 | return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 430 | } |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 431 | |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 432 | inline static void |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 433 | ptp_free_DI (PTPDeviceInfo *di) { |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 434 | free (di->SerialNumber); |
| 435 | free (di->DeviceVersion); |
| 436 | free (di->Model); |
| 437 | free (di->Manufacturer); |
| 438 | free (di->ImageFormats); |
| 439 | free (di->CaptureFormats); |
| 440 | free (di->VendorExtensionDesc); |
| 441 | free (di->OperationsSupported); |
| 442 | free (di->EventsSupported); |
| 443 | free (di->DevicePropertiesSupported); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 444 | memset(di, 0, sizeof(*di)); |
Linus Walleij | a8a19cc | 2007-02-02 22:13:17 +0000 | [diff] [blame] | 445 | } |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 446 | |
| 447 | /* EOS Device Info unpack */ |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 448 | static inline int |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 449 | ptp_unpack_EOS_DI (PTPParams *params, unsigned char* data, PTPCanonEOSDeviceInfo *di, unsigned int datalen) |
| 450 | { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 451 | unsigned int totallen = 4; |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 452 | |
| 453 | memset (di,0, sizeof(*di)); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 454 | if (datalen < 8) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 455 | |
| 456 | /* uint32_t struct len - ignore */ |
| 457 | di->EventsSupported_len = ptp_unpack_uint32_t_array(params, data, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 458 | totallen, datalen, &di->EventsSupported); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 459 | if (!di->EventsSupported) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 460 | totallen += di->EventsSupported_len*sizeof(uint32_t)+4; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 461 | if (totallen >= datalen) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 462 | |
| 463 | di->DevicePropertiesSupported_len = ptp_unpack_uint32_t_array(params, data, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 464 | totallen, datalen, &di->DevicePropertiesSupported); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 465 | if (!di->DevicePropertiesSupported) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 466 | totallen += di->DevicePropertiesSupported_len*sizeof(uint32_t)+4; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 467 | if (totallen >= datalen) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 468 | |
| 469 | di->unk_len = ptp_unpack_uint32_t_array(params, data, |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 470 | totallen, datalen, &di->unk); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 471 | if (!di->unk) return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 472 | totallen += di->unk_len*sizeof(uint32_t)+4; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 473 | return 1; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 474 | } |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 475 | |
| 476 | static inline void |
| 477 | ptp_free_EOS_DI (PTPCanonEOSDeviceInfo *di) |
| 478 | { |
| 479 | free (di->EventsSupported); |
| 480 | free (di->DevicePropertiesSupported); |
| 481 | free (di->unk); |
| 482 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 483 | |
| 484 | /* ObjectHandles array pack/unpack */ |
| 485 | |
| 486 | #define PTP_oh 0 |
| 487 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 488 | static inline void |
| 489 | ptp_unpack_OH (PTPParams *params, unsigned char* data, PTPObjectHandles *oh, unsigned int len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 490 | { |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 491 | if (len) { |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 492 | oh->n = ptp_unpack_uint32_t_array(params, data, PTP_oh, len, &oh->Handler); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 493 | } else { |
| 494 | oh->n = 0; |
| 495 | oh->Handler = NULL; |
| 496 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 497 | } |
| 498 | |
| 499 | /* StoreIDs array pack/unpack */ |
| 500 | |
| 501 | #define PTP_sids 0 |
| 502 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 503 | static inline void |
| 504 | ptp_unpack_SIDs (PTPParams *params, unsigned char* data, PTPStorageIDs *sids, unsigned int len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 505 | { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 506 | sids->n = 0; |
| 507 | sids->Storage = NULL; |
| 508 | |
| 509 | if (!data || !len) |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 510 | return; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 511 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 512 | sids->n = ptp_unpack_uint32_t_array(params, data, PTP_sids, len, &sids->Storage); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 513 | } |
| 514 | |
| 515 | /* StorageInfo pack/unpack */ |
| 516 | |
| 517 | #define PTP_si_StorageType 0 |
| 518 | #define PTP_si_FilesystemType 2 |
| 519 | #define PTP_si_AccessCapability 4 |
| 520 | #define PTP_si_MaxCapability 6 |
| 521 | #define PTP_si_FreeSpaceInBytes 14 |
| 522 | #define PTP_si_FreeSpaceInImages 22 |
| 523 | #define PTP_si_StorageDescription 26 |
| 524 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 525 | static inline int |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 526 | ptp_unpack_SI (PTPParams *params, unsigned char* data, PTPStorageInfo *si, unsigned int len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 527 | { |
| 528 | uint8_t storagedescriptionlen; |
| 529 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 530 | if (len < 26) return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 531 | si->StorageType=dtoh16a(&data[PTP_si_StorageType]); |
| 532 | si->FilesystemType=dtoh16a(&data[PTP_si_FilesystemType]); |
| 533 | si->AccessCapability=dtoh16a(&data[PTP_si_AccessCapability]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 534 | si->MaxCapability=dtoh64a(&data[PTP_si_MaxCapability]); |
| 535 | si->FreeSpaceInBytes=dtoh64a(&data[PTP_si_FreeSpaceInBytes]); |
| 536 | si->FreeSpaceInImages=dtoh32a(&data[PTP_si_FreeSpaceInImages]); |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 537 | |
| 538 | /* FIXME: check more lengths here */ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 539 | si->StorageDescription=ptp_unpack_string(params, data, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 540 | PTP_si_StorageDescription, |
| 541 | len, |
| 542 | &storagedescriptionlen); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 543 | si->VolumeLabel=ptp_unpack_string(params, data, |
| 544 | PTP_si_StorageDescription+storagedescriptionlen*2+1, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 545 | len, |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 546 | &storagedescriptionlen); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 547 | return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 548 | } |
| 549 | |
| 550 | /* ObjectInfo pack/unpack */ |
| 551 | |
| 552 | #define PTP_oi_StorageID 0 |
| 553 | #define PTP_oi_ObjectFormat 4 |
| 554 | #define PTP_oi_ProtectionStatus 6 |
| 555 | #define PTP_oi_ObjectCompressedSize 8 |
| 556 | #define PTP_oi_ThumbFormat 12 |
| 557 | #define PTP_oi_ThumbCompressedSize 14 |
| 558 | #define PTP_oi_ThumbPixWidth 18 |
| 559 | #define PTP_oi_ThumbPixHeight 22 |
| 560 | #define PTP_oi_ImagePixWidth 26 |
| 561 | #define PTP_oi_ImagePixHeight 30 |
| 562 | #define PTP_oi_ImageBitDepth 34 |
| 563 | #define PTP_oi_ParentObject 38 |
| 564 | #define PTP_oi_AssociationType 42 |
| 565 | #define PTP_oi_AssociationDesc 44 |
| 566 | #define PTP_oi_SequenceNumber 48 |
| 567 | #define PTP_oi_filenamelen 52 |
| 568 | #define PTP_oi_Filename 53 |
| 569 | |
Linus Walleij | a032327 | 2007-01-07 12:21:30 +0000 | [diff] [blame] | 570 | /* the max length assuming zero length dates. We have need 3 */ |
| 571 | /* bytes for these. */ |
Richard Low | a679b1c | 2006-12-29 20:08:14 +0000 | [diff] [blame] | 572 | #define PTP_oi_MaxLen PTP_oi_Filename+(PTP_MAXSTRLEN+1)*2+3 |
| 573 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 574 | static inline uint32_t |
| 575 | ptp_pack_OI (PTPParams *params, PTPObjectInfo *oi, unsigned char** oidataptr) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 576 | { |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 577 | unsigned char* oidata; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 578 | uint8_t filenamelen; |
| 579 | uint8_t capturedatelen=0; |
Richard Low | a679b1c | 2006-12-29 20:08:14 +0000 | [diff] [blame] | 580 | /* let's allocate some memory first; correct assuming zero length dates */ |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 581 | oidata=malloc(PTP_oi_MaxLen + params->ocs64*4); |
| 582 | *oidataptr=oidata; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 583 | /* the caller should free it after use! */ |
| 584 | #if 0 |
| 585 | char *capture_date="20020101T010101"; /* XXX Fake date */ |
| 586 | #endif |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 587 | memset (oidata, 0, PTP_oi_MaxLen + params->ocs64*4); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 588 | htod32a(&oidata[PTP_oi_StorageID],oi->StorageID); |
| 589 | htod16a(&oidata[PTP_oi_ObjectFormat],oi->ObjectFormat); |
| 590 | htod16a(&oidata[PTP_oi_ProtectionStatus],oi->ProtectionStatus); |
| 591 | htod32a(&oidata[PTP_oi_ObjectCompressedSize],oi->ObjectCompressedSize); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 592 | if (params->ocs64) |
| 593 | oidata += 4; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 594 | htod16a(&oidata[PTP_oi_ThumbFormat],oi->ThumbFormat); |
| 595 | htod32a(&oidata[PTP_oi_ThumbCompressedSize],oi->ThumbCompressedSize); |
| 596 | htod32a(&oidata[PTP_oi_ThumbPixWidth],oi->ThumbPixWidth); |
| 597 | htod32a(&oidata[PTP_oi_ThumbPixHeight],oi->ThumbPixHeight); |
| 598 | htod32a(&oidata[PTP_oi_ImagePixWidth],oi->ImagePixWidth); |
| 599 | htod32a(&oidata[PTP_oi_ImagePixHeight],oi->ImagePixHeight); |
| 600 | htod32a(&oidata[PTP_oi_ImageBitDepth],oi->ImageBitDepth); |
| 601 | htod32a(&oidata[PTP_oi_ParentObject],oi->ParentObject); |
| 602 | htod16a(&oidata[PTP_oi_AssociationType],oi->AssociationType); |
| 603 | htod32a(&oidata[PTP_oi_AssociationDesc],oi->AssociationDesc); |
| 604 | htod32a(&oidata[PTP_oi_SequenceNumber],oi->SequenceNumber); |
| 605 | |
| 606 | ptp_pack_string(params, oi->Filename, oidata, PTP_oi_filenamelen, &filenamelen); |
| 607 | /* |
| 608 | filenamelen=(uint8_t)strlen(oi->Filename); |
| 609 | htod8a(&req->data[PTP_oi_filenamelen],filenamelen+1); |
| 610 | for (i=0;i<filenamelen && i< PTP_MAXSTRLEN; i++) { |
| 611 | req->data[PTP_oi_Filename+i*2]=oi->Filename[i]; |
| 612 | } |
| 613 | */ |
| 614 | /* |
| 615 | *XXX Fake date. |
| 616 | * for example Kodak sets Capture date on the basis of EXIF data. |
| 617 | * Spec says that this field is from perspective of Initiator. |
| 618 | */ |
| 619 | #if 0 /* seems now we don't need any data packed in OI dataset... for now ;)*/ |
| 620 | capturedatelen=strlen(capture_date); |
| 621 | htod8a(&data[PTP_oi_Filename+(filenamelen+1)*2], |
| 622 | capturedatelen+1); |
| 623 | for (i=0;i<capturedatelen && i< PTP_MAXSTRLEN; i++) { |
| 624 | data[PTP_oi_Filename+(i+filenamelen+1)*2+1]=capture_date[i]; |
| 625 | } |
| 626 | htod8a(&data[PTP_oi_Filename+(filenamelen+capturedatelen+2)*2+1], |
| 627 | capturedatelen+1); |
| 628 | for (i=0;i<capturedatelen && i< PTP_MAXSTRLEN; i++) { |
| 629 | data[PTP_oi_Filename+(i+filenamelen+capturedatelen+2)*2+2]= |
| 630 | capture_date[i]; |
| 631 | } |
| 632 | #endif |
| 633 | /* XXX this function should return dataset length */ |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 634 | return (PTP_oi_Filename+filenamelen*2+(capturedatelen+1)*3)+params->ocs64*4; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 635 | } |
| 636 | |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 637 | static time_t |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 638 | ptp_unpack_PTPTIME (const char *str) { |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 639 | char ptpdate[40]; |
| 640 | char tmp[5]; |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 641 | size_t ptpdatelen; |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 642 | struct tm tm; |
| 643 | |
| 644 | if (!str) |
| 645 | return 0; |
| 646 | ptpdatelen = strlen(str); |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 647 | if (ptpdatelen >= sizeof (ptpdate)) { |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 648 | /*ptp_debug (params ,"datelen is larger then size of buffer", ptpdatelen, (int)sizeof(ptpdate));*/ |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 649 | return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 650 | } |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 651 | if (ptpdatelen<15) { |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 652 | /*ptp_debug (params ,"datelen is less than 15 (%d)", ptpdatelen);*/ |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 653 | return 0; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 654 | } |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 655 | strncpy (ptpdate, str, sizeof(ptpdate)); |
| 656 | ptpdate[sizeof(ptpdate) - 1] = '\0'; |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 657 | |
| 658 | memset(&tm,0,sizeof(tm)); |
| 659 | strncpy (tmp, ptpdate, 4); |
| 660 | tmp[4] = 0; |
| 661 | tm.tm_year=atoi (tmp) - 1900; |
| 662 | strncpy (tmp, ptpdate + 4, 2); |
| 663 | tmp[2] = 0; |
| 664 | tm.tm_mon = atoi (tmp) - 1; |
| 665 | strncpy (tmp, ptpdate + 6, 2); |
| 666 | tmp[2] = 0; |
| 667 | tm.tm_mday = atoi (tmp); |
| 668 | strncpy (tmp, ptpdate + 9, 2); |
| 669 | tmp[2] = 0; |
| 670 | tm.tm_hour = atoi (tmp); |
| 671 | strncpy (tmp, ptpdate + 11, 2); |
| 672 | tmp[2] = 0; |
| 673 | tm.tm_min = atoi (tmp); |
| 674 | strncpy (tmp, ptpdate + 13, 2); |
| 675 | tmp[2] = 0; |
| 676 | tm.tm_sec = atoi (tmp); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 677 | tm.tm_isdst = -1; |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 678 | return mktime (&tm); |
| 679 | } |
| 680 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 681 | static inline void |
| 682 | ptp_unpack_OI (PTPParams *params, unsigned char* data, PTPObjectInfo *oi, unsigned int len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 683 | { |
| 684 | uint8_t filenamelen; |
| 685 | uint8_t capturedatelen; |
| 686 | char *capture_date; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 687 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 688 | if (len < PTP_oi_SequenceNumber) |
| 689 | return; |
| 690 | |
| 691 | oi->Filename = oi->Keywords = NULL; |
| 692 | |
| 693 | /* FIXME: also handle length with all the strings at the end */ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 694 | oi->StorageID=dtoh32a(&data[PTP_oi_StorageID]); |
| 695 | oi->ObjectFormat=dtoh16a(&data[PTP_oi_ObjectFormat]); |
| 696 | oi->ProtectionStatus=dtoh16a(&data[PTP_oi_ProtectionStatus]); |
| 697 | oi->ObjectCompressedSize=dtoh32a(&data[PTP_oi_ObjectCompressedSize]); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 698 | |
| 699 | /* Stupid Samsung Galaxy developers emit a 64bit objectcompressedsize */ |
| 700 | if ((data[PTP_oi_filenamelen] == 0) && (data[PTP_oi_filenamelen+4] != 0)) { |
| 701 | params->ocs64 = 1; |
| 702 | data += 4; |
| 703 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 704 | oi->ThumbFormat=dtoh16a(&data[PTP_oi_ThumbFormat]); |
| 705 | oi->ThumbCompressedSize=dtoh32a(&data[PTP_oi_ThumbCompressedSize]); |
| 706 | oi->ThumbPixWidth=dtoh32a(&data[PTP_oi_ThumbPixWidth]); |
| 707 | oi->ThumbPixHeight=dtoh32a(&data[PTP_oi_ThumbPixHeight]); |
| 708 | oi->ImagePixWidth=dtoh32a(&data[PTP_oi_ImagePixWidth]); |
| 709 | oi->ImagePixHeight=dtoh32a(&data[PTP_oi_ImagePixHeight]); |
| 710 | oi->ImageBitDepth=dtoh32a(&data[PTP_oi_ImageBitDepth]); |
| 711 | oi->ParentObject=dtoh32a(&data[PTP_oi_ParentObject]); |
| 712 | oi->AssociationType=dtoh16a(&data[PTP_oi_AssociationType]); |
| 713 | oi->AssociationDesc=dtoh32a(&data[PTP_oi_AssociationDesc]); |
| 714 | oi->SequenceNumber=dtoh32a(&data[PTP_oi_SequenceNumber]); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 715 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 716 | oi->Filename= ptp_unpack_string(params, data, PTP_oi_filenamelen, len, &filenamelen); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 717 | |
| 718 | capture_date = ptp_unpack_string(params, data, |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 719 | PTP_oi_filenamelen+filenamelen*2+1, len, &capturedatelen); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 720 | /* subset of ISO 8601, without '.s' tenths of second and |
| 721 | * time zone |
| 722 | */ |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 723 | oi->CaptureDate = ptp_unpack_PTPTIME(capture_date); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 724 | free(capture_date); |
| 725 | |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 726 | /* now the modification date ... */ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 727 | capture_date = ptp_unpack_string(params, data, |
| 728 | PTP_oi_filenamelen+filenamelen*2 |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 729 | +capturedatelen*2+2, len, &capturedatelen); |
Linus Walleij | 6db174f | 2009-05-09 13:15:26 +0000 | [diff] [blame] | 730 | oi->ModificationDate = ptp_unpack_PTPTIME(capture_date); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 731 | free(capture_date); |
| 732 | } |
| 733 | |
| 734 | /* Custom Type Value Assignement (without Length) macro frequently used below */ |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 735 | #define CTVAL(target,func) { \ |
| 736 | if (total - *offset < sizeof(target)) \ |
| 737 | return 0; \ |
| 738 | target = func(&data[*offset]); \ |
| 739 | *offset += sizeof(target); \ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 740 | } |
| 741 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 742 | #define RARR(val,member,func) { \ |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 743 | unsigned int n,j; \ |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 744 | if (total - *offset < sizeof(uint32_t)) \ |
| 745 | return 0; \ |
| 746 | n = dtoh32a (&data[*offset]); \ |
| 747 | *offset += sizeof(uint32_t); \ |
| 748 | \ |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 749 | if (n >= UINT_MAX/sizeof(val->a.v[0])) \ |
| 750 | return 0; \ |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 751 | if (n > (total - (*offset))/sizeof(val->a.v[0]))\ |
| 752 | return 0; \ |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 753 | val->a.count = n; \ |
| 754 | val->a.v = malloc(sizeof(val->a.v[0])*n); \ |
| 755 | if (!val->a.v) return 0; \ |
| 756 | for (j=0;j<n;j++) \ |
| 757 | CTVAL(val->a.v[j].member, func); \ |
| 758 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 759 | |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 760 | static inline unsigned int |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 761 | ptp_unpack_DPV ( |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 762 | PTPParams *params, unsigned char* data, unsigned int *offset, unsigned int total, |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 763 | PTPPropertyValue* value, uint16_t datatype |
| 764 | ) { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 765 | if (*offset >= total) /* we are at the end or over the end of the buffer */ |
| 766 | return 0; |
| 767 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 768 | switch (datatype) { |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 769 | case PTP_DTC_INT8: |
| 770 | CTVAL(value->i8,dtoh8a); |
| 771 | break; |
| 772 | case PTP_DTC_UINT8: |
| 773 | CTVAL(value->u8,dtoh8a); |
| 774 | break; |
| 775 | case PTP_DTC_INT16: |
| 776 | CTVAL(value->i16,dtoh16a); |
| 777 | break; |
| 778 | case PTP_DTC_UINT16: |
| 779 | CTVAL(value->u16,dtoh16a); |
| 780 | break; |
| 781 | case PTP_DTC_INT32: |
| 782 | CTVAL(value->i32,dtoh32a); |
| 783 | break; |
| 784 | case PTP_DTC_UINT32: |
| 785 | CTVAL(value->u32,dtoh32a); |
| 786 | break; |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 787 | case PTP_DTC_INT64: |
| 788 | CTVAL(value->i64,dtoh64a); |
| 789 | break; |
| 790 | case PTP_DTC_UINT64: |
| 791 | CTVAL(value->u64,dtoh64a); |
| 792 | break; |
| 793 | |
Linus Walleij | 037a125 | 2006-12-16 20:36:52 +0000 | [diff] [blame] | 794 | case PTP_DTC_UINT128: |
| 795 | *offset += 16; |
| 796 | /*fprintf(stderr,"unhandled unpack of uint128n");*/ |
| 797 | break; |
| 798 | case PTP_DTC_INT128: |
| 799 | *offset += 16; |
| 800 | /*fprintf(stderr,"unhandled unpack of int128n");*/ |
| 801 | break; |
| 802 | |
| 803 | |
| 804 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 805 | case PTP_DTC_AINT8: |
| 806 | RARR(value,i8,dtoh8a); |
| 807 | break; |
| 808 | case PTP_DTC_AUINT8: |
| 809 | RARR(value,u8,dtoh8a); |
| 810 | break; |
| 811 | case PTP_DTC_AUINT16: |
| 812 | RARR(value,u16,dtoh16a); |
| 813 | break; |
| 814 | case PTP_DTC_AINT16: |
| 815 | RARR(value,i16,dtoh16a); |
| 816 | break; |
| 817 | case PTP_DTC_AUINT32: |
| 818 | RARR(value,u32,dtoh32a); |
| 819 | break; |
| 820 | case PTP_DTC_AINT32: |
| 821 | RARR(value,i32,dtoh32a); |
| 822 | break; |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 823 | case PTP_DTC_AUINT64: |
| 824 | RARR(value,u64,dtoh64a); |
| 825 | break; |
| 826 | case PTP_DTC_AINT64: |
| 827 | RARR(value,i64,dtoh64a); |
| 828 | break; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 829 | /* XXX: other int types are unimplemented */ |
| 830 | /* XXX: other int arrays are unimplemented also */ |
| 831 | case PTP_DTC_STR: { |
| 832 | uint8_t len; |
| 833 | /* XXX: max size */ |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 834 | |
| 835 | if (*offset >= total+1) |
| 836 | return 0; |
| 837 | |
| 838 | value->str = ptp_unpack_string(params,data,*offset,total,&len); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 839 | *offset += len*2+1; |
| 840 | if (!value->str) |
Linus Walleij | deddc34 | 2008-08-16 23:52:06 +0000 | [diff] [blame] | 841 | return 1; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 842 | break; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 843 | } |
Linus Walleij | 037a125 | 2006-12-16 20:36:52 +0000 | [diff] [blame] | 844 | default: |
| 845 | return 0; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 846 | } |
| 847 | return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 848 | } |
| 849 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 850 | /* Device Property pack/unpack */ |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 851 | #define PTP_dpd_DevicePropertyCode 0 |
| 852 | #define PTP_dpd_DataType 2 |
| 853 | #define PTP_dpd_GetSet 4 |
| 854 | #define PTP_dpd_FactoryDefaultValue 5 |
| 855 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 856 | static inline int |
| 857 | ptp_unpack_DPD (PTPParams *params, unsigned char* data, PTPDevicePropDesc *dpd, unsigned int dpdlen) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 858 | { |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 859 | unsigned int offset = 0, ret; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 860 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 861 | memset (dpd, 0, sizeof(*dpd)); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 862 | if (dpdlen <= 5) |
| 863 | return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 864 | dpd->DevicePropertyCode=dtoh16a(&data[PTP_dpd_DevicePropertyCode]); |
| 865 | dpd->DataType=dtoh16a(&data[PTP_dpd_DataType]); |
| 866 | dpd->GetSet=dtoh8a(&data[PTP_dpd_GetSet]); |
Linus Walleij | deddc34 | 2008-08-16 23:52:06 +0000 | [diff] [blame] | 867 | dpd->FormFlag=PTP_DPFF_None; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 868 | |
| 869 | offset = PTP_dpd_FactoryDefaultValue; |
| 870 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->FactoryDefaultValue, dpd->DataType); |
| 871 | if (!ret) goto outofmemory; |
Linus Walleij | deddc34 | 2008-08-16 23:52:06 +0000 | [diff] [blame] | 872 | if ((dpd->DataType == PTP_DTC_STR) && (offset == dpdlen)) |
| 873 | return 1; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 874 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->CurrentValue, dpd->DataType); |
| 875 | if (!ret) goto outofmemory; |
| 876 | |
| 877 | /* if offset==0 then Data Type format is not supported by this |
| 878 | code or the Data Type is a string (with two empty strings as |
| 879 | values). In both cases Form Flag should be set to 0x00 and FORM is |
| 880 | not present. */ |
| 881 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 882 | if (offset==PTP_dpd_FactoryDefaultValue) |
| 883 | return 1; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 884 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 885 | dpd->FormFlag=dtoh8a(&data[offset]); |
| 886 | offset+=sizeof(uint8_t); |
| 887 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 888 | switch (dpd->FormFlag) { |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 889 | case PTP_DPFF_Range: |
| 890 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->FORM.Range.MinimumValue, dpd->DataType); |
| 891 | if (!ret) goto outofmemory; |
| 892 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->FORM.Range.MaximumValue, dpd->DataType); |
| 893 | if (!ret) goto outofmemory; |
| 894 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->FORM.Range.StepSize, dpd->DataType); |
| 895 | if (!ret) goto outofmemory; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 896 | break; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 897 | case PTP_DPFF_Enumeration: { |
| 898 | int i; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 899 | #define N dpd->FORM.Enum.NumberOfValues |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 900 | N = dtoh16a(&data[offset]); |
| 901 | offset+=sizeof(uint16_t); |
| 902 | dpd->FORM.Enum.SupportedValue = malloc(N*sizeof(dpd->FORM.Enum.SupportedValue[0])); |
| 903 | if (!dpd->FORM.Enum.SupportedValue) |
| 904 | goto outofmemory; |
| 905 | |
| 906 | memset (dpd->FORM.Enum.SupportedValue,0 , N*sizeof(dpd->FORM.Enum.SupportedValue[0])); |
| 907 | for (i=0;i<N;i++) { |
| 908 | ret = ptp_unpack_DPV (params, data, &offset, dpdlen, &dpd->FORM.Enum.SupportedValue[i], dpd->DataType); |
| 909 | |
| 910 | /* Slightly different handling here. The HP PhotoSmart 120 |
| 911 | * specifies an enumeration with N in wrong endian |
| 912 | * 00 01 instead of 01 00, so we count the enum just until the |
| 913 | * the end of the packet. |
| 914 | */ |
| 915 | if (!ret) { |
| 916 | if (!i) |
| 917 | goto outofmemory; |
| 918 | dpd->FORM.Enum.NumberOfValues = i; |
| 919 | break; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 920 | } |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 921 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 922 | } |
| 923 | } |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 924 | #undef N |
| 925 | return 1; |
| 926 | outofmemory: |
| 927 | ptp_free_devicepropdesc(dpd); |
| 928 | return 0; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 929 | } |
| 930 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 931 | /* Device Property pack/unpack */ |
| 932 | #define PTP_dpd_Sony_DevicePropertyCode 0 |
| 933 | #define PTP_dpd_Sony_DataType 2 |
| 934 | #define PTP_dpd_Sony_GetSet 4 |
| 935 | #define PTP_dpd_Sony_Unknown 5 |
| 936 | #define PTP_dpd_Sony_FactoryDefaultValue 6 |
| 937 | |
| 938 | static inline int |
| 939 | ptp_unpack_Sony_DPD (PTPParams *params, unsigned char* data, PTPDevicePropDesc *dpd, unsigned int dpdlen, unsigned int *poffset) |
| 940 | { |
| 941 | unsigned int ret; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 942 | #if 0 |
| 943 | unsigned int unk1, unk2; |
| 944 | #endif |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 945 | |
| 946 | memset (dpd, 0, sizeof(*dpd)); |
| 947 | dpd->DevicePropertyCode=dtoh16a(&data[PTP_dpd_Sony_DevicePropertyCode]); |
| 948 | dpd->DataType=dtoh16a(&data[PTP_dpd_Sony_DataType]); |
| 949 | |
| 950 | #if 0 |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 951 | /* get set ? */ |
| 952 | unk1 = dtoh8a(&data[PTP_dpd_Sony_GetSet]); |
| 953 | unk2 = dtoh8a(&data[PTP_dpd_Sony_Unknown]); |
| 954 | ptp_debug (params, "prop 0x%04x, datatype 0x%04x, unk1 %d unk2 %d", dpd->DevicePropertyCode, dpd->DataType, unk1, unk2); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 955 | #endif |
| 956 | dpd->GetSet=1; |
| 957 | |
| 958 | dpd->FormFlag=PTP_DPFF_None; |
| 959 | |
| 960 | *poffset = PTP_dpd_Sony_FactoryDefaultValue; |
| 961 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->FactoryDefaultValue, dpd->DataType); |
| 962 | if (!ret) goto outofmemory; |
| 963 | if ((dpd->DataType == PTP_DTC_STR) && (*poffset == dpdlen)) |
| 964 | return 1; |
| 965 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->CurrentValue, dpd->DataType); |
| 966 | if (!ret) goto outofmemory; |
| 967 | |
| 968 | /* if offset==0 then Data Type format is not supported by this |
| 969 | code or the Data Type is a string (with two empty strings as |
| 970 | values). In both cases Form Flag should be set to 0x00 and FORM is |
| 971 | not present. */ |
| 972 | |
| 973 | if (*poffset==PTP_dpd_Sony_FactoryDefaultValue) |
| 974 | return 1; |
| 975 | |
| 976 | dpd->FormFlag=dtoh8a(&data[*poffset]); |
| 977 | *poffset+=sizeof(uint8_t); |
| 978 | |
| 979 | switch (dpd->FormFlag) { |
| 980 | case PTP_DPFF_Range: |
| 981 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->FORM.Range.MinimumValue, dpd->DataType); |
| 982 | if (!ret) goto outofmemory; |
| 983 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->FORM.Range.MaximumValue, dpd->DataType); |
| 984 | if (!ret) goto outofmemory; |
| 985 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->FORM.Range.StepSize, dpd->DataType); |
| 986 | if (!ret) goto outofmemory; |
| 987 | break; |
| 988 | case PTP_DPFF_Enumeration: { |
| 989 | int i; |
| 990 | #define N dpd->FORM.Enum.NumberOfValues |
| 991 | N = dtoh16a(&data[*poffset]); |
| 992 | *poffset+=sizeof(uint16_t); |
| 993 | dpd->FORM.Enum.SupportedValue = malloc(N*sizeof(dpd->FORM.Enum.SupportedValue[0])); |
| 994 | if (!dpd->FORM.Enum.SupportedValue) |
| 995 | goto outofmemory; |
| 996 | |
| 997 | memset (dpd->FORM.Enum.SupportedValue,0 , N*sizeof(dpd->FORM.Enum.SupportedValue[0])); |
| 998 | for (i=0;i<N;i++) { |
| 999 | ret = ptp_unpack_DPV (params, data, poffset, dpdlen, &dpd->FORM.Enum.SupportedValue[i], dpd->DataType); |
| 1000 | |
| 1001 | /* Slightly different handling here. The HP PhotoSmart 120 |
| 1002 | * specifies an enumeration with N in wrong endian |
| 1003 | * 00 01 instead of 01 00, so we count the enum just until the |
| 1004 | * the end of the packet. |
| 1005 | */ |
| 1006 | if (!ret) { |
| 1007 | if (!i) |
| 1008 | goto outofmemory; |
| 1009 | dpd->FORM.Enum.NumberOfValues = i; |
| 1010 | break; |
| 1011 | } |
| 1012 | } |
| 1013 | } |
| 1014 | } |
| 1015 | #undef N |
| 1016 | return 1; |
| 1017 | outofmemory: |
| 1018 | ptp_free_devicepropdesc(dpd); |
| 1019 | return 0; |
| 1020 | } |
| 1021 | |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1022 | static inline void |
| 1023 | duplicate_PropertyValue (const PTPPropertyValue *src, PTPPropertyValue *dst, uint16_t type) { |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1024 | if (type == PTP_DTC_STR) { |
| 1025 | if (src->str) |
| 1026 | dst->str = strdup(src->str); |
| 1027 | else |
| 1028 | dst->str = NULL; |
| 1029 | return; |
| 1030 | } |
| 1031 | |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1032 | if (type & PTP_DTC_ARRAY_MASK) { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1033 | unsigned int i; |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1034 | |
| 1035 | dst->a.count = src->a.count; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1036 | dst->a.v = malloc (sizeof(src->a.v[0])*src->a.count); |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1037 | for (i=0;i<src->a.count;i++) |
| 1038 | duplicate_PropertyValue (&src->a.v[i], &dst->a.v[i], type & ~PTP_DTC_ARRAY_MASK); |
| 1039 | return; |
| 1040 | } |
| 1041 | switch (type & ~PTP_DTC_ARRAY_MASK) { |
| 1042 | case PTP_DTC_INT8: dst->i8 = src->i8; break; |
| 1043 | case PTP_DTC_UINT8: dst->u8 = src->u8; break; |
| 1044 | case PTP_DTC_INT16: dst->i16 = src->i16; break; |
| 1045 | case PTP_DTC_UINT16: dst->u16 = src->u16; break; |
| 1046 | case PTP_DTC_INT32: dst->i32 = src->i32; break; |
| 1047 | case PTP_DTC_UINT32: dst->u32 = src->u32; break; |
| 1048 | case PTP_DTC_UINT64: dst->u64 = src->u64; break; |
| 1049 | case PTP_DTC_INT64: dst->i64 = src->i64; break; |
| 1050 | #if 0 |
| 1051 | case PTP_DTC_INT128: dst->i128 = src->i128; break; |
| 1052 | case PTP_DTC_UINT128: dst->u128 = src->u128; break; |
| 1053 | #endif |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1054 | default: break; |
| 1055 | } |
| 1056 | return; |
| 1057 | } |
| 1058 | |
| 1059 | static inline void |
| 1060 | duplicate_DevicePropDesc(const PTPDevicePropDesc *src, PTPDevicePropDesc *dst) { |
| 1061 | int i; |
| 1062 | |
| 1063 | dst->DevicePropertyCode = src->DevicePropertyCode; |
| 1064 | dst->DataType = src->DataType; |
| 1065 | dst->GetSet = src->GetSet; |
| 1066 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1067 | duplicate_PropertyValue (&src->FactoryDefaultValue, &dst->FactoryDefaultValue, src->DataType); |
| 1068 | duplicate_PropertyValue (&src->CurrentValue, &dst->CurrentValue, src->DataType); |
Linus Walleij | d9ee8cd | 2013-11-04 01:54:35 +0100 | [diff] [blame] | 1069 | |
| 1070 | dst->FormFlag = src->FormFlag; |
| 1071 | switch (src->FormFlag) { |
| 1072 | case PTP_DPFF_Range: |
| 1073 | duplicate_PropertyValue (&src->FORM.Range.MinimumValue, &dst->FORM.Range.MinimumValue, src->DataType); |
| 1074 | duplicate_PropertyValue (&src->FORM.Range.MaximumValue, &dst->FORM.Range.MaximumValue, src->DataType); |
| 1075 | duplicate_PropertyValue (&src->FORM.Range.StepSize, &dst->FORM.Range.StepSize, src->DataType); |
| 1076 | break; |
| 1077 | case PTP_DPFF_Enumeration: |
| 1078 | dst->FORM.Enum.NumberOfValues = src->FORM.Enum.NumberOfValues; |
| 1079 | dst->FORM.Enum.SupportedValue = malloc (sizeof(dst->FORM.Enum.SupportedValue[0])*src->FORM.Enum.NumberOfValues); |
| 1080 | for (i = 0; i<src->FORM.Enum.NumberOfValues ; i++) |
| 1081 | duplicate_PropertyValue (&src->FORM.Enum.SupportedValue[i], &dst->FORM.Enum.SupportedValue[i], src->DataType); |
| 1082 | break; |
| 1083 | case PTP_DPFF_None: |
| 1084 | break; |
| 1085 | } |
| 1086 | } |
| 1087 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1088 | #define PTP_opd_ObjectPropertyCode 0 |
| 1089 | #define PTP_opd_DataType 2 |
| 1090 | #define PTP_opd_GetSet 4 |
| 1091 | #define PTP_opd_FactoryDefaultValue 5 |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1092 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1093 | static inline int |
| 1094 | ptp_unpack_OPD (PTPParams *params, unsigned char* data, PTPObjectPropDesc *opd, unsigned int opdlen) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1095 | { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1096 | unsigned int offset=0, ret; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1097 | |
| 1098 | memset (opd, 0, sizeof(*opd)); |
| 1099 | opd->ObjectPropertyCode=dtoh16a(&data[PTP_opd_ObjectPropertyCode]); |
| 1100 | opd->DataType=dtoh16a(&data[PTP_opd_DataType]); |
| 1101 | opd->GetSet=dtoh8a(&data[PTP_opd_GetSet]); |
| 1102 | |
| 1103 | offset = PTP_opd_FactoryDefaultValue; |
| 1104 | ret = ptp_unpack_DPV (params, data, &offset, opdlen, &opd->FactoryDefaultValue, opd->DataType); |
| 1105 | if (!ret) goto outofmemory; |
| 1106 | |
| 1107 | opd->GroupCode=dtoh32a(&data[offset]); |
| 1108 | offset+=sizeof(uint32_t); |
| 1109 | |
| 1110 | opd->FormFlag=dtoh8a(&data[offset]); |
| 1111 | offset+=sizeof(uint8_t); |
| 1112 | |
| 1113 | switch (opd->FormFlag) { |
| 1114 | case PTP_OPFF_Range: |
| 1115 | ret = ptp_unpack_DPV (params, data, &offset, opdlen, &opd->FORM.Range.MinimumValue, opd->DataType); |
| 1116 | if (!ret) goto outofmemory; |
| 1117 | ret = ptp_unpack_DPV (params, data, &offset, opdlen, &opd->FORM.Range.MaximumValue, opd->DataType); |
| 1118 | if (!ret) goto outofmemory; |
| 1119 | ret = ptp_unpack_DPV (params, data, &offset, opdlen, &opd->FORM.Range.StepSize, opd->DataType); |
| 1120 | if (!ret) goto outofmemory; |
| 1121 | break; |
| 1122 | case PTP_OPFF_Enumeration: { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1123 | unsigned int i; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1124 | #define N opd->FORM.Enum.NumberOfValues |
| 1125 | N = dtoh16a(&data[offset]); |
| 1126 | offset+=sizeof(uint16_t); |
| 1127 | opd->FORM.Enum.SupportedValue = malloc(N*sizeof(opd->FORM.Enum.SupportedValue[0])); |
| 1128 | if (!opd->FORM.Enum.SupportedValue) |
| 1129 | goto outofmemory; |
| 1130 | |
| 1131 | memset (opd->FORM.Enum.SupportedValue,0 , N*sizeof(opd->FORM.Enum.SupportedValue[0])); |
| 1132 | for (i=0;i<N;i++) { |
| 1133 | ret = ptp_unpack_DPV (params, data, &offset, opdlen, &opd->FORM.Enum.SupportedValue[i], opd->DataType); |
| 1134 | |
| 1135 | /* Slightly different handling here. The HP PhotoSmart 120 |
| 1136 | * specifies an enumeration with N in wrong endian |
| 1137 | * 00 01 instead of 01 00, so we count the enum just until the |
| 1138 | * the end of the packet. |
| 1139 | */ |
| 1140 | if (!ret) { |
| 1141 | if (!i) |
| 1142 | goto outofmemory; |
| 1143 | opd->FORM.Enum.NumberOfValues = i; |
| 1144 | break; |
| 1145 | } |
| 1146 | } |
| 1147 | #undef N |
| 1148 | } |
| 1149 | } |
| 1150 | return 1; |
| 1151 | outofmemory: |
| 1152 | ptp_free_objectpropdesc(opd); |
| 1153 | return 0; |
| 1154 | } |
| 1155 | |
| 1156 | |
| 1157 | static inline uint32_t |
| 1158 | ptp_pack_DPV (PTPParams *params, PTPPropertyValue* value, unsigned char** dpvptr, uint16_t datatype) |
| 1159 | { |
| 1160 | unsigned char* dpv=NULL; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1161 | uint32_t size=0; |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1162 | unsigned int i; |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1163 | |
| 1164 | switch (datatype) { |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1165 | case PTP_DTC_INT8: |
| 1166 | size=sizeof(int8_t); |
| 1167 | dpv=malloc(size); |
| 1168 | htod8a(dpv,value->i8); |
| 1169 | break; |
| 1170 | case PTP_DTC_UINT8: |
| 1171 | size=sizeof(uint8_t); |
| 1172 | dpv=malloc(size); |
| 1173 | htod8a(dpv,value->u8); |
| 1174 | break; |
| 1175 | case PTP_DTC_INT16: |
| 1176 | size=sizeof(int16_t); |
| 1177 | dpv=malloc(size); |
| 1178 | htod16a(dpv,value->i16); |
| 1179 | break; |
| 1180 | case PTP_DTC_UINT16: |
| 1181 | size=sizeof(uint16_t); |
| 1182 | dpv=malloc(size); |
| 1183 | htod16a(dpv,value->u16); |
| 1184 | break; |
| 1185 | case PTP_DTC_INT32: |
| 1186 | size=sizeof(int32_t); |
| 1187 | dpv=malloc(size); |
| 1188 | htod32a(dpv,value->i32); |
| 1189 | break; |
| 1190 | case PTP_DTC_UINT32: |
| 1191 | size=sizeof(uint32_t); |
| 1192 | dpv=malloc(size); |
| 1193 | htod32a(dpv,value->u32); |
| 1194 | break; |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 1195 | case PTP_DTC_INT64: |
| 1196 | size=sizeof(int64_t); |
| 1197 | dpv=malloc(size); |
| 1198 | htod64a(dpv,value->i64); |
| 1199 | break; |
| 1200 | case PTP_DTC_UINT64: |
| 1201 | size=sizeof(uint64_t); |
| 1202 | dpv=malloc(size); |
| 1203 | htod64a(dpv,value->u64); |
| 1204 | break; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1205 | case PTP_DTC_AUINT8: |
| 1206 | size=sizeof(uint32_t)+value->a.count*sizeof(uint8_t); |
| 1207 | dpv=malloc(size); |
| 1208 | htod32a(dpv,value->a.count); |
| 1209 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1210 | htod8a(&dpv[sizeof(uint32_t)+i*sizeof(uint8_t)],value->a.v[i].u8); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1211 | break; |
| 1212 | case PTP_DTC_AINT8: |
| 1213 | size=sizeof(uint32_t)+value->a.count*sizeof(int8_t); |
| 1214 | dpv=malloc(size); |
| 1215 | htod32a(dpv,value->a.count); |
| 1216 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1217 | htod8a(&dpv[sizeof(uint32_t)+i*sizeof(int8_t)],value->a.v[i].i8); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1218 | break; |
| 1219 | case PTP_DTC_AUINT16: |
| 1220 | size=sizeof(uint32_t)+value->a.count*sizeof(uint16_t); |
| 1221 | dpv=malloc(size); |
| 1222 | htod32a(dpv,value->a.count); |
| 1223 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1224 | htod16a(&dpv[sizeof(uint32_t)+i*sizeof(uint16_t)],value->a.v[i].u16); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1225 | break; |
| 1226 | case PTP_DTC_AINT16: |
| 1227 | size=sizeof(uint32_t)+value->a.count*sizeof(int16_t); |
| 1228 | dpv=malloc(size); |
| 1229 | htod32a(dpv,value->a.count); |
| 1230 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1231 | htod16a(&dpv[sizeof(uint32_t)+i*sizeof(int16_t)],value->a.v[i].i16); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1232 | break; |
| 1233 | case PTP_DTC_AUINT32: |
| 1234 | size=sizeof(uint32_t)+value->a.count*sizeof(uint32_t); |
| 1235 | dpv=malloc(size); |
| 1236 | htod32a(dpv,value->a.count); |
| 1237 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1238 | htod32a(&dpv[sizeof(uint32_t)+i*sizeof(uint32_t)],value->a.v[i].u32); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1239 | break; |
| 1240 | case PTP_DTC_AINT32: |
| 1241 | size=sizeof(uint32_t)+value->a.count*sizeof(int32_t); |
| 1242 | dpv=malloc(size); |
| 1243 | htod32a(dpv,value->a.count); |
| 1244 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1245 | htod32a(&dpv[sizeof(uint32_t)+i*sizeof(int32_t)],value->a.v[i].i32); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1246 | break; |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 1247 | case PTP_DTC_AUINT64: |
| 1248 | size=sizeof(uint32_t)+value->a.count*sizeof(uint64_t); |
| 1249 | dpv=malloc(size); |
| 1250 | htod32a(dpv,value->a.count); |
| 1251 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1252 | htod64a(&dpv[sizeof(uint32_t)+i*sizeof(uint64_t)],value->a.v[i].u64); |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 1253 | break; |
| 1254 | case PTP_DTC_AINT64: |
| 1255 | size=sizeof(uint32_t)+value->a.count*sizeof(int64_t); |
| 1256 | dpv=malloc(size); |
| 1257 | htod32a(dpv,value->a.count); |
| 1258 | for (i=0;i<value->a.count;i++) |
Richard Low | cc26590 | 2007-07-30 20:14:12 +0000 | [diff] [blame] | 1259 | htod64a(&dpv[sizeof(uint32_t)+i*sizeof(int64_t)],value->a.v[i].i64); |
Linus Walleij | abf5475 | 2007-07-30 19:51:54 +0000 | [diff] [blame] | 1260 | break; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1261 | /* XXX: other int types are unimplemented */ |
| 1262 | case PTP_DTC_STR: { |
Linus Walleij | 735f416 | 2006-08-29 09:18:17 +0000 | [diff] [blame] | 1263 | dpv=ptp_get_packed_stringcopy(params, value->str, &size); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1264 | break; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1265 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1266 | } |
| 1267 | *dpvptr=dpv; |
| 1268 | return size; |
| 1269 | } |
| 1270 | |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1271 | #define MAX_MTP_PROPS 127 |
| 1272 | static inline uint32_t |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1273 | ptp_pack_OPL (PTPParams *params, MTPProperties *props, int nrofprops, unsigned char** opldataptr) |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1274 | { |
| 1275 | unsigned char* opldata; |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1276 | MTPProperties *propitr; |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1277 | unsigned char *packedprops[MAX_MTP_PROPS]; |
| 1278 | uint32_t packedpropslens[MAX_MTP_PROPS]; |
Linus Walleij | 39b9374 | 2006-11-27 11:25:59 +0000 | [diff] [blame] | 1279 | uint32_t packedobjecthandles[MAX_MTP_PROPS]; |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1280 | uint16_t packedpropsids[MAX_MTP_PROPS]; |
| 1281 | uint16_t packedpropstypes[MAX_MTP_PROPS]; |
| 1282 | uint32_t totalsize = 0; |
| 1283 | uint32_t bufp = 0; |
| 1284 | uint32_t noitems = 0; |
| 1285 | uint32_t i; |
| 1286 | |
| 1287 | totalsize = sizeof(uint32_t); /* 4 bytes to store the number of elements */ |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1288 | propitr = props; |
| 1289 | while (nrofprops-- && noitems < MAX_MTP_PROPS) { |
Richard Low | 6c0a6ce | 2006-11-26 10:42:08 +0000 | [diff] [blame] | 1290 | /* Object Handle */ |
Linus Walleij | 39b9374 | 2006-11-27 11:25:59 +0000 | [diff] [blame] | 1291 | packedobjecthandles[noitems]=propitr->ObjectHandle; |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1292 | totalsize += sizeof(uint32_t); /* Object ID */ |
| 1293 | /* Metadata type */ |
| 1294 | packedpropsids[noitems]=propitr->property; |
| 1295 | totalsize += sizeof(uint16_t); |
| 1296 | /* Data type */ |
| 1297 | packedpropstypes[noitems]= propitr->datatype; |
| 1298 | totalsize += sizeof(uint16_t); |
| 1299 | /* Add each property to be sent. */ |
| 1300 | packedpropslens[noitems] = ptp_pack_DPV (params, &propitr->propval, &packedprops[noitems], propitr->datatype); |
| 1301 | totalsize += packedpropslens[noitems]; |
| 1302 | noitems ++; |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1303 | propitr ++; |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1304 | } |
| 1305 | |
| 1306 | /* Allocate memory for the packed property list */ |
| 1307 | opldata = malloc(totalsize); |
| 1308 | |
| 1309 | htod32a(&opldata[bufp],noitems); |
| 1310 | bufp += 4; |
| 1311 | |
| 1312 | /* Copy into a nice packed list */ |
| 1313 | for (i = 0; i < noitems; i++) { |
| 1314 | /* Object ID */ |
Richard Low | 6c0a6ce | 2006-11-26 10:42:08 +0000 | [diff] [blame] | 1315 | htod32a(&opldata[bufp],packedobjecthandles[i]); |
Linus Walleij | 99310d4 | 2006-11-01 08:29:39 +0000 | [diff] [blame] | 1316 | bufp += sizeof(uint32_t); |
| 1317 | htod16a(&opldata[bufp],packedpropsids[i]); |
| 1318 | bufp += sizeof(uint16_t); |
| 1319 | htod16a(&opldata[bufp],packedpropstypes[i]); |
| 1320 | bufp += sizeof(uint16_t); |
| 1321 | /* The copy the actual property */ |
| 1322 | memcpy(&opldata[bufp], packedprops[i], packedpropslens[i]); |
| 1323 | bufp += packedpropslens[i]; |
| 1324 | free(packedprops[i]); |
| 1325 | } |
| 1326 | *opldataptr = opldata; |
| 1327 | return totalsize; |
| 1328 | } |
| 1329 | |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1330 | static int |
| 1331 | _compare_func(const void* x, const void *y) { |
| 1332 | const MTPProperties *px = x; |
| 1333 | const MTPProperties *py = y; |
| 1334 | |
| 1335 | return px->ObjectHandle - py->ObjectHandle; |
| 1336 | } |
| 1337 | |
Richard Low | 8d82d2f | 2006-11-16 20:37:43 +0000 | [diff] [blame] | 1338 | static inline int |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1339 | ptp_unpack_OPL (PTPParams *params, unsigned char* data, MTPProperties **pprops, unsigned int len) |
Richard Low | 8d82d2f | 2006-11-16 20:37:43 +0000 | [diff] [blame] | 1340 | { |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1341 | uint32_t prop_count = dtoh32a(data); |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1342 | MTPProperties *props = NULL; |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1343 | unsigned int offset = 0, i; |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1344 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1345 | *pprops = NULL; |
| 1346 | if (prop_count == 0) |
| 1347 | return 0; |
| 1348 | if (prop_count >= INT_MAX/sizeof(MTPProperties)) { |
| 1349 | ptp_debug (params ,"prop_count %d is too large", prop_count); |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1350 | return 0; |
| 1351 | } |
Linus Walleij | d49955b | 2008-11-09 17:20:00 +0000 | [diff] [blame] | 1352 | ptp_debug (params ,"Unpacking MTP OPL, size %d (prop_count %d)", len, prop_count); |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1353 | data += sizeof(uint32_t); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1354 | len -= sizeof(uint32_t); |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1355 | props = malloc(prop_count * sizeof(MTPProperties)); |
| 1356 | if (!props) return 0; |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1357 | for (i = 0; i < prop_count; i++) { |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1358 | if (len <= 0) { |
Linus Walleij | d49955b | 2008-11-09 17:20:00 +0000 | [diff] [blame] | 1359 | ptp_debug (params ,"short MTP Object Property List at property %d (of %d)", i, prop_count); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1360 | ptp_debug (params ,"device probably needs DEVICE_FLAG_BROKEN_MTPGETOBJPROPLIST_ALL"); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1361 | ptp_debug (params ,"or even DEVICE_FLAG_BROKEN_MTPGETOBJPROPLIST", i); |
Linus Walleij | d49955b | 2008-11-09 17:20:00 +0000 | [diff] [blame] | 1362 | qsort (props, i, sizeof(MTPProperties),_compare_func); |
| 1363 | *pprops = props; |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1364 | return i; |
| 1365 | } |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1366 | props[i].ObjectHandle = dtoh32a(data); |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1367 | data += sizeof(uint32_t); |
| 1368 | len -= sizeof(uint32_t); |
| 1369 | |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1370 | props[i].property = dtoh16a(data); |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1371 | data += sizeof(uint16_t); |
| 1372 | len -= sizeof(uint16_t); |
| 1373 | |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1374 | props[i].datatype = dtoh16a(data); |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1375 | data += sizeof(uint16_t); |
| 1376 | len -= sizeof(uint16_t); |
| 1377 | |
| 1378 | offset = 0; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1379 | if (!ptp_unpack_DPV(params, data, &offset, len, &props[i].propval, props[i].datatype)) { |
| 1380 | ptp_debug (params ,"unpacking DPV of property %d encountered insufficient buffer. attack?", i); |
| 1381 | qsort (props, i, sizeof(MTPProperties),_compare_func); |
| 1382 | *pprops = props; |
| 1383 | return i; |
| 1384 | } |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1385 | data += offset; |
| 1386 | len -= offset; |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1387 | } |
Linus Walleij | 1e9a033 | 2007-09-12 19:35:56 +0000 | [diff] [blame] | 1388 | qsort (props, prop_count, sizeof(MTPProperties),_compare_func); |
| 1389 | *pprops = props; |
Linus Walleij | 277cd53 | 2006-11-20 14:57:46 +0000 | [diff] [blame] | 1390 | return prop_count; |
Richard Low | 8d82d2f | 2006-11-16 20:37:43 +0000 | [diff] [blame] | 1391 | } |
| 1392 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1393 | /* |
| 1394 | PTP USB Event container unpack |
| 1395 | Copyright (c) 2003 Nikolai Kopanygin |
| 1396 | */ |
| 1397 | |
| 1398 | #define PTP_ec_Length 0 |
| 1399 | #define PTP_ec_Type 4 |
| 1400 | #define PTP_ec_Code 6 |
| 1401 | #define PTP_ec_TransId 8 |
| 1402 | #define PTP_ec_Param1 12 |
| 1403 | #define PTP_ec_Param2 16 |
| 1404 | #define PTP_ec_Param3 20 |
| 1405 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1406 | static inline void |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1407 | ptp_unpack_EC (PTPParams *params, unsigned char* data, PTPContainer *ec, unsigned int len) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1408 | { |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1409 | unsigned int length; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1410 | int type; |
| 1411 | |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1412 | if (data==NULL) |
| 1413 | return; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1414 | memset(ec,0,sizeof(*ec)); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1415 | |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1416 | length=dtoh32a(&data[PTP_ec_Length]); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1417 | if (length > len) { |
| 1418 | ptp_debug (params, "length %d in container, but data only %d bytes?!", length, len); |
| 1419 | return; |
| 1420 | } |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1421 | type = dtoh16a(&data[PTP_ec_Type]); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1422 | |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1423 | ec->Code=dtoh16a(&data[PTP_ec_Code]); |
| 1424 | ec->Transaction_ID=dtoh32a(&data[PTP_ec_TransId]); |
| 1425 | |
| 1426 | if (type!=PTP_USB_CONTAINER_EVENT) { |
| 1427 | ptp_debug (params, "Unknown canon event type %d (code=%x,tid=%x), please report!",type,ec->Code,ec->Transaction_ID); |
| 1428 | return; |
| 1429 | } |
| 1430 | if (length>=(PTP_ec_Param1+4)) { |
| 1431 | ec->Param1=dtoh32a(&data[PTP_ec_Param1]); |
| 1432 | ec->Nparam=1; |
| 1433 | } |
| 1434 | if (length>=(PTP_ec_Param2+4)) { |
| 1435 | ec->Param2=dtoh32a(&data[PTP_ec_Param2]); |
| 1436 | ec->Nparam=2; |
| 1437 | } |
| 1438 | if (length>=(PTP_ec_Param3+4)) { |
| 1439 | ec->Param3=dtoh32a(&data[PTP_ec_Param3]); |
| 1440 | ec->Nparam=3; |
| 1441 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1442 | } |
| 1443 | |
| 1444 | /* |
| 1445 | PTP Canon Folder Entry unpack |
| 1446 | Copyright (c) 2003 Nikolai Kopanygin |
| 1447 | */ |
| 1448 | #define PTP_cfe_ObjectHandle 0 |
| 1449 | #define PTP_cfe_ObjectFormatCode 4 |
| 1450 | #define PTP_cfe_Flags 6 |
| 1451 | #define PTP_cfe_ObjectSize 7 |
| 1452 | #define PTP_cfe_Time 11 |
| 1453 | #define PTP_cfe_Filename 15 |
| 1454 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1455 | static inline void |
| 1456 | ptp_unpack_Canon_FE (PTPParams *params, unsigned char* data, PTPCANONFolderEntry *fe) |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1457 | { |
| 1458 | int i; |
| 1459 | if (data==NULL) |
| 1460 | return; |
| 1461 | fe->ObjectHandle=dtoh32a(&data[PTP_cfe_ObjectHandle]); |
| 1462 | fe->ObjectFormatCode=dtoh16a(&data[PTP_cfe_ObjectFormatCode]); |
| 1463 | fe->Flags=dtoh8a(&data[PTP_cfe_Flags]); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1464 | fe->ObjectSize=dtoh32a((unsigned char*)&data[PTP_cfe_ObjectSize]); |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 1465 | fe->Time=(time_t)dtoh32a(&data[PTP_cfe_Time]); |
| 1466 | for (i=0; i<PTP_CANON_FilenameBufferLen; i++) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1467 | fe->Filename[i]=(char)dtoh8a(&data[PTP_cfe_Filename+i]); |
| 1468 | } |
| 1469 | |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 1470 | /* |
| 1471 | PTP Canon EOS Folder Entry unpack |
| 1472 | 0: 00 00 08 a0 objectid |
| 1473 | 4: 01 00 02 00 storageid |
| 1474 | 8: 01 30 00 00 ofc |
| 1475 | 12: 01 00 |
| 1476 | 14: 00 00 |
| 1477 | 16: 11 00 00 00 |
| 1478 | 20: 00 00 00 00 |
| 1479 | 24: 00 00 00 80 |
| 1480 | 28: 00 00 08 a0 |
| 1481 | 32: 4d 49 53 43-00 00 00 00 00 00 00 00 name |
| 1482 | 00 00 00 00 |
| 1483 | 84 bc 74 46 objectime |
| 1484 | |
| 1485 | |
| 1486 | (normal PTP GetObjectInfo) |
| 1487 | ObjectInfo for 'IMG_0199.JPG': |
| 1488 | Object ID: 0x92740c72 |
| 1489 | StorageID: 0x00020001 |
| 1490 | ObjectFormat: 0x3801 |
| 1491 | ProtectionStatus: 0x0000 |
| 1492 | ObjectCompressedSize: 2217241 |
| 1493 | ThumbFormat: 0x3808 |
| 1494 | ThumbCompressedSize: 5122 |
| 1495 | ThumbPixWidth: 160 |
| 1496 | ThumbPixHeight: 120 |
| 1497 | ImagePixWidth: 4000 |
| 1498 | ImagePixHeight: 3000 |
| 1499 | ImageBitDepth: 24 |
| 1500 | ParentObject: 0x92740000 |
| 1501 | AssociationType: 0x0000 |
| 1502 | AssociationDesc: 0x00000000 |
| 1503 | SequenceNumber: 0x00000000 |
| 1504 | ModificationDate: 0x4d985ff0 |
| 1505 | CaptureDate: 0x4d985ff0 |
| 1506 | |
| 1507 | 0010 38 00 00 00 Size of this entry |
| 1508 | 0014 72 0c 74 92 OID |
| 1509 | 0018 01 00 02 00 StorageID |
| 1510 | 001c 01 38 00 00 OFC |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1511 | 0020 00 00 00 00 ?? |
| 1512 | 0024 21 00 00 00 flags (4 bytes? 1 byte?) |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 1513 | 0028 19 d5 21 00 Size |
| 1514 | 002c 00 00 74 92 ? |
| 1515 | 0030 70 0c 74 92 OID |
| 1516 | 0034 49 4d 47 5f-30 31 39 39 2e 4a 50 47 IMG_0199.JPG |
| 1517 | 0040 00 00 00 00 |
| 1518 | 0044 10 7c 98 4d Time |
| 1519 | |
| 1520 | |
| 1521 | */ |
| 1522 | #define PTP_cefe_ObjectHandle 0 |
| 1523 | #define PTP_cefe_StorageID 4 |
| 1524 | #define PTP_cefe_ObjectFormatCode 8 |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1525 | #define PTP_cefe_Flags 16 |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 1526 | #define PTP_cefe_ObjectSize 20 |
| 1527 | #define PTP_cefe_Filename 32 |
| 1528 | #define PTP_cefe_Time 48 |
| 1529 | |
| 1530 | static inline void |
| 1531 | ptp_unpack_Canon_EOS_FE (PTPParams *params, unsigned char* data, PTPCANONFolderEntry *fe) |
| 1532 | { |
| 1533 | int i; |
| 1534 | |
| 1535 | fe->ObjectHandle=dtoh32a(&data[PTP_cefe_ObjectHandle]); |
| 1536 | fe->ObjectFormatCode=dtoh16a(&data[PTP_cefe_ObjectFormatCode]); |
| 1537 | fe->Flags=dtoh8a(&data[PTP_cefe_Flags]); |
| 1538 | fe->ObjectSize=dtoh32a((unsigned char*)&data[PTP_cefe_ObjectSize]); |
| 1539 | fe->Time=(time_t)dtoh32a(&data[PTP_cefe_Time]); |
| 1540 | for (i=0; i<PTP_CANON_FilenameBufferLen; i++) |
| 1541 | fe->Filename[i]=(char)data[PTP_cefe_Filename+i]; |
| 1542 | } |
| 1543 | |
| 1544 | |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1545 | static inline uint16_t |
| 1546 | ptp_unpack_EOS_ImageFormat (PTPParams* params, unsigned char** data ) |
| 1547 | { |
| 1548 | /* |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1549 | EOS ImageFormat entries (of at least the 5DM2 and the 400D) look like this: |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1550 | uint32: number of entries / generated files (1 or 2) |
| 1551 | uint32: size of this entry in bytes (most likely allways 0x10) |
| 1552 | uint32: image type (1 == JPG, 6 == RAW) |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1553 | uint32: image size (0 == Large, 1 == Medium, 2 == Small, 0xe == S1, 0xf == S2, 0x10 == S3) |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1554 | uint32: image compression (2 == Standard/JPG, 3 == Fine/JPG, 4 == Lossles/RAW) |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1555 | If the number of entries is 2 the last 4 uint32 repeat. |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1556 | |
| 1557 | example: |
| 1558 | 0: 0x 1 |
| 1559 | 1: 0x 10 |
| 1560 | 2: 0x 6 |
| 1561 | 3: 0x 1 |
| 1562 | 4: 0x 4 |
| 1563 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1564 | The idea is to simply 'condense' these values to just one uint16 to be able to conveniently |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1565 | use the available enumeration facilities (look-up table). The image size and compression |
| 1566 | values fully describe the image format. Hence we generate a uint16 with the four nibles set |
| 1567 | as follows: entry 1 size | entry 1 compression | entry 2 size | entry 2 compression. |
| 1568 | The above example would result in the value 0x1400. |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1569 | |
| 1570 | The EOS 5D Mark III (and possibly other high-end EOS as well) added the extra fancy S1, S2 |
| 1571 | and S3 JPEG options. S1 replaces the old Small. -1 the S1/S2/S3 to prevent the 0x10 overflow. |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1572 | */ |
| 1573 | |
| 1574 | const unsigned char* d = *data; |
| 1575 | uint32_t n = dtoh32a( d ); |
| 1576 | uint32_t l, s1, c1, s2 = 0, c2 = 0; |
| 1577 | |
| 1578 | if (n != 1 && n !=2) { |
| 1579 | ptp_debug (params, "parsing EOS ImageFormat property failed (n != 1 && n != 2: %d)", n); |
| 1580 | return 0; |
| 1581 | } |
| 1582 | |
| 1583 | l = dtoh32a( d+=4 ); |
| 1584 | if (l != 0x10) { |
| 1585 | ptp_debug (params, "parsing EOS ImageFormat property failed (l != 0x10: 0x%x)", l); |
| 1586 | return 0; |
| 1587 | } |
| 1588 | |
| 1589 | d+=4; /* skip type */ |
| 1590 | s1 = dtoh32a( d+=4 ); |
| 1591 | c1 = dtoh32a( d+=4 ); |
| 1592 | |
| 1593 | if (n == 2) { |
| 1594 | l = dtoh32a( d+=4 ); |
| 1595 | if (l != 0x10) { |
| 1596 | ptp_debug (params, "parsing EOS ImageFormat property failed (l != 0x10: 0x%x)", l); |
| 1597 | return 0; |
| 1598 | } |
| 1599 | d+=4; /* skip type */ |
| 1600 | s2 = dtoh32a( d+=4 ); |
| 1601 | c2 = dtoh32a( d+=4 ); |
| 1602 | } |
| 1603 | |
| 1604 | *data = (unsigned char*) d+4; |
| 1605 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1606 | /* deal with S1/S2/S3 JPEG sizes, see above. */ |
| 1607 | if( s1 >= 0xe ) |
| 1608 | s1--; |
| 1609 | if( s2 >= 0xe ) |
| 1610 | s2--; |
| 1611 | |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1612 | return ((s1 & 0xF) << 12) | ((c1 & 0xF) << 8) | ((s2 & 0xF) << 4) | ((c2 & 0xF) << 0); |
| 1613 | } |
| 1614 | |
| 1615 | static inline uint32_t |
| 1616 | ptp_pack_EOS_ImageFormat (PTPParams* params, unsigned char* data, uint16_t value) |
| 1617 | { |
| 1618 | uint32_t n = (value & 0xFF) ? 2 : 1; |
| 1619 | uint32_t s = 4 + 0x10 * n; |
| 1620 | |
| 1621 | if( !data ) |
| 1622 | return s; |
| 1623 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1624 | #define PACK_5DM3_SMALL_JPEG_SIZE( X ) (X) >= 0xd ? (X)+1 : (X) |
| 1625 | |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1626 | htod32a(data+=0, n); |
| 1627 | htod32a(data+=4, 0x10); |
| 1628 | htod32a(data+=4, ((value >> 8) & 0xF) == 4 ? 6 : 1); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1629 | htod32a(data+=4, PACK_5DM3_SMALL_JPEG_SIZE((value >> 12) & 0xF)); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1630 | htod32a(data+=4, (value >> 8) & 0xF); |
| 1631 | |
| 1632 | if (n==2) { |
| 1633 | htod32a(data+=4, 0x10); |
| 1634 | htod32a(data+=4, ((value >> 0) & 0xF) == 4 ? 6 : 1); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1635 | htod32a(data+=4, PACK_5DM3_SMALL_JPEG_SIZE((value >> 4) & 0xF)); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1636 | htod32a(data+=4, (value >> 0) & 0xF); |
| 1637 | } |
| 1638 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1639 | #undef PACK_5DM3_SMALL_JPEG_SIZE |
| 1640 | |
| 1641 | return s; |
| 1642 | } |
| 1643 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1644 | /* 00: 32 bit size |
| 1645 | * 04: 16 bit subsize |
| 1646 | * 08: 16 bit version (?) |
| 1647 | * 0c: 16 bit focus_points_in_struct |
| 1648 | * 10: 16 bit focus_points_in_use |
| 1649 | * 14: variable arrays: |
| 1650 | * 16 bit sizex, 16 bit sizey |
| 1651 | * 16 bit othersizex, 16 bit othersizey |
| 1652 | * 16 bit array height[focus_points_in_struct] |
| 1653 | * 16 bit array width[focus_points_in_struct] |
| 1654 | * 16 bit array offsetheight[focus_points_in_struct] middle is 0 |
| 1655 | * 16 bit array offsetwidth[focus_points_in_struct] middle is ? |
| 1656 | * bitfield of selected focus points, starting with 0 [size focus_points_in_struct in bits] |
| 1657 | * unknown stuff , likely which are active |
| 1658 | * 16 bit 0xffff |
| 1659 | * |
| 1660 | * size=NxN,size2=NxN,points={NxNxNxN,NxNxNxN,...},selected={0,1,2} |
| 1661 | */ |
| 1662 | static inline char* |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1663 | ptp_unpack_EOS_FocusInfoEx (PTPParams* params, unsigned char** data, uint32_t datasize ) |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1664 | { |
| 1665 | uint32_t size = dtoh32a( *data ); |
| 1666 | uint32_t halfsize = dtoh16a( (*data) + 4); |
| 1667 | uint32_t version = dtoh16a( (*data) + 6); |
| 1668 | uint32_t focus_points_in_struct = dtoh16a( (*data) + 8); |
| 1669 | uint32_t focus_points_in_use = dtoh16a( (*data) + 10); |
| 1670 | uint32_t sizeX = dtoh16a( (*data) + 12); |
| 1671 | uint32_t sizeY = dtoh16a( (*data) + 14); |
| 1672 | uint32_t size2X = dtoh16a( (*data) + 16); |
| 1673 | uint32_t size2Y = dtoh16a( (*data) + 18); |
| 1674 | uint32_t i; |
| 1675 | uint32_t maxlen; |
| 1676 | char *str, *p; |
| 1677 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1678 | if ((size >= datasize) || (size < 20)) |
| 1679 | return strdup("bad size 1"); |
| 1680 | /* every focuspoint gets 4 (16 bit number possible "-" sign and a x) and a ,*/ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1681 | /* inital things around lets say 100 chars at most. |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1682 | * FIXME: check selected when we decode it |
| 1683 | */ |
| 1684 | if (size < focus_points_in_struct*8) { |
| 1685 | ptp_error(params, "focus_points_in_struct %d is too large vs size %d", focus_points_in_struct, size); |
| 1686 | return strdup("bad size 2"); |
| 1687 | } |
| 1688 | if (focus_points_in_use > focus_points_in_struct) { |
| 1689 | ptp_error(params, "focus_points_in_use %d is larger than focus_points_in_struct %d", focus_points_in_use, focus_points_in_struct); |
| 1690 | return strdup("bad size 3"); |
| 1691 | } |
| 1692 | |
| 1693 | maxlen = focus_points_in_use*32 + 100 + (size - focus_points_in_struct*8)*2; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1694 | if (halfsize != size-4) { |
| 1695 | ptp_error(params, "halfsize %d is not expected %d", halfsize, size-4); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1696 | return strdup("bad size 4"); |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1697 | } |
| 1698 | if (20 + focus_points_in_struct*8 + (focus_points_in_struct+7)/8 > size) { |
| 1699 | ptp_error(params, "size %d is too large for fp in struct %d", focus_points_in_struct*8 + 20 + (focus_points_in_struct+7)/8, size); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1700 | return strdup("bad size 5"); |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1701 | } |
| 1702 | #if 0 |
| 1703 | ptp_debug(params,"d1d3 content:"); |
| 1704 | for (i=0;i<size;i+=2) |
| 1705 | ptp_debug(params,"%d: %02x %02x", i, (*data)[i], (*data)[i+1]); |
| 1706 | #endif |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1707 | ptp_debug(params,"d1d3 version %d", version); |
| 1708 | ptp_debug(params,"d1d3 size %d", size); |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1709 | ptp_debug(params,"d1d3 focus points in struct %d, in use %d", focus_points_in_struct, focus_points_in_use); |
| 1710 | |
| 1711 | str = (char*)malloc( maxlen ); |
| 1712 | if (!str) |
| 1713 | return NULL; |
| 1714 | p = str; |
| 1715 | |
| 1716 | p += sprintf(p,"eosversion=%d,size=%dx%d,size2=%dx%d,points={", version, sizeX, sizeY, size2X, size2Y); |
| 1717 | for (i=0;i<focus_points_in_use;i++) { |
| 1718 | int16_t x = dtoh16a((*data) + focus_points_in_struct*4 + 20 + 2*i); |
| 1719 | int16_t y = dtoh16a((*data) + focus_points_in_struct*6 + 20 + 2*i); |
| 1720 | int16_t w = dtoh16a((*data) + focus_points_in_struct*2 + 20 + 2*i); |
| 1721 | int16_t h = dtoh16a((*data) + focus_points_in_struct*0 + 20 + 2*i); |
| 1722 | |
| 1723 | p += sprintf(p,"{%d,%d,%d,%d}",x,y,w,h); |
| 1724 | |
| 1725 | if (i<focus_points_in_use-1) |
| 1726 | p += sprintf(p,","); |
| 1727 | } |
| 1728 | p += sprintf(p,"},select={"); |
| 1729 | for (i=0;i<focus_points_in_use;i++) { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1730 | if ((1<<(i%8)) & ((*data)[focus_points_in_struct*8+20+i/8])) |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1731 | p+=sprintf(p,"%d,", i); |
| 1732 | } |
| 1733 | |
| 1734 | p += sprintf(p,"},unknown={"); |
| 1735 | for (i=focus_points_in_struct*8+(focus_points_in_struct+7)/8+20;i<size;i++) { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1736 | if ((p-str) > maxlen - 4) |
| 1737 | break; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1738 | p+=sprintf(p,"%02x", (*data)[i]); |
| 1739 | } |
| 1740 | p += sprintf(p,"}"); |
| 1741 | return str; |
| 1742 | } |
| 1743 | |
| 1744 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1745 | static inline char* |
| 1746 | ptp_unpack_EOS_CustomFuncEx (PTPParams* params, unsigned char** data ) |
| 1747 | { |
| 1748 | uint32_t s = dtoh32a( *data ); |
| 1749 | uint32_t n = s/4, i; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1750 | char *str, *p; |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1751 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1752 | if (s > 1024) { |
| 1753 | ptp_debug (params, "customfuncex data is larger than 1k / %d... unexpected?", s); |
| 1754 | return strdup("bad length"); |
| 1755 | } |
| 1756 | str = (char*)malloc( s*2+s/4+1 ); /* n is size in uint32, maximum %x len is 8 chars and \0*/ |
| 1757 | if (!str) |
| 1758 | return strdup("malloc failed"); |
| 1759 | |
| 1760 | p = str; |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1761 | for (i=0; i < n; ++i) |
| 1762 | p += sprintf(p, "%x,", dtoh32a( *data + 4*i )); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1763 | return str; |
| 1764 | } |
| 1765 | |
| 1766 | static inline uint32_t |
| 1767 | ptp_pack_EOS_CustomFuncEx (PTPParams* params, unsigned char* data, char* str) |
| 1768 | { |
| 1769 | uint32_t s = strtoul(str, NULL, 16); |
| 1770 | uint32_t n = s/4, i, v; |
| 1771 | |
| 1772 | if (!data) |
| 1773 | return s; |
| 1774 | |
| 1775 | for (i=0; i<n; i++) |
| 1776 | { |
| 1777 | v = strtoul(str, &str, 16); |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 1778 | str++; /* skip the ',' delimiter */ |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 1779 | htod32a(data + i*4, v); |
| 1780 | } |
| 1781 | |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1782 | return s; |
| 1783 | } |
| 1784 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 1785 | /* |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1786 | PTP EOS Changes Entry unpack |
| 1787 | */ |
| 1788 | #define PTP_ece_Size 0 |
| 1789 | #define PTP_ece_Type 4 |
| 1790 | |
| 1791 | #define PTP_ece_Prop_Subtype 8 /* only for properties */ |
| 1792 | #define PTP_ece_Prop_Val_Data 0xc /* only for properties */ |
| 1793 | #define PTP_ece_Prop_Desc_Type 0xc /* only for property descs */ |
| 1794 | #define PTP_ece_Prop_Desc_Count 0x10 /* only for property descs */ |
| 1795 | #define PTP_ece_Prop_Desc_Data 0x14 /* only for property descs */ |
| 1796 | |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 1797 | /* for PTP_EC_CANON_EOS_RequestObjectTransfer */ |
| 1798 | #define PTP_ece_OI_ObjectID 8 |
| 1799 | #define PTP_ece_OI_OFC 0x0c |
| 1800 | #define PTP_ece_OI_Size 0x14 |
| 1801 | #define PTP_ece_OI_Name 0x1c |
| 1802 | |
| 1803 | /* for PTP_EC_CANON_EOS_ObjectAddedEx */ |
| 1804 | #define PTP_ece_OA_ObjectID 8 |
| 1805 | #define PTP_ece_OA_StorageID 0x0c |
| 1806 | #define PTP_ece_OA_OFC 0x10 |
| 1807 | #define PTP_ece_OA_Size 0x1c |
| 1808 | #define PTP_ece_OA_Parent 0x20 |
| 1809 | #define PTP_ece_OA_Name 0x28 |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1810 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1811 | #define PTP_ece2_OA_ObjectID 8 /* OK */ |
| 1812 | #define PTP_ece2_OA_StorageID 0x0c /* OK */ |
| 1813 | #define PTP_ece2_OA_OFC 0x10 /* OK */ |
| 1814 | #define PTP_ece2_OA_Size 0x1c /* OK, might be 64 bit now? */ |
| 1815 | #define PTP_ece2_OA_Parent 0x24 |
| 1816 | #define PTP_ece2_OA_2ndOID 0x28 |
| 1817 | #define PTP_ece2_OA_Name 0x2c /* OK */ |
| 1818 | |
| 1819 | /* for PTP_EC_CANON_EOS_ObjectAddedNew */ |
| 1820 | #define PTP_ece_OAN_OFC 0x0c |
| 1821 | #define PTP_ece_OAN_Size 0x14 |
| 1822 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 1823 | static PTPDevicePropDesc* |
| 1824 | _lookup_or_allocate_canon_prop(PTPParams *params, uint16_t proptype) |
| 1825 | { |
| 1826 | unsigned int j; |
| 1827 | |
| 1828 | for (j=0;j<params->nrofcanon_props;j++) |
| 1829 | if (params->canon_props[j].proptype == proptype) |
| 1830 | break; |
| 1831 | if (j<params->nrofcanon_props) |
| 1832 | return ¶ms->canon_props[j].dpd; |
| 1833 | |
| 1834 | if (j) |
| 1835 | params->canon_props = realloc(params->canon_props, sizeof(params->canon_props[0])*(j+1)); |
| 1836 | else |
| 1837 | params->canon_props = malloc(sizeof(params->canon_props[0])); |
| 1838 | params->canon_props[j].proptype = proptype; |
| 1839 | params->canon_props[j].size = 0; |
| 1840 | params->canon_props[j].data = NULL; |
| 1841 | memset (¶ms->canon_props[j].dpd,0,sizeof(params->canon_props[j].dpd)); |
| 1842 | params->canon_props[j].dpd.GetSet = 1; |
| 1843 | params->canon_props[j].dpd.FormFlag = PTP_DPFF_None; |
| 1844 | params->nrofcanon_props = j+1; |
| 1845 | return ¶ms->canon_props[j].dpd; |
| 1846 | } |
| 1847 | |
| 1848 | |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1849 | static inline int |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1850 | ptp_unpack_CANON_changes (PTPParams *params, unsigned char* data, int datasize, PTPCanon_changes_entry **pce) |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1851 | { |
| 1852 | int i = 0, entries = 0; |
| 1853 | unsigned char *curdata = data; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1854 | PTPCanon_changes_entry *ce; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1855 | |
| 1856 | if (data==NULL) |
| 1857 | return 0; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1858 | while (curdata - data + 8 < datasize) { |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1859 | uint32_t size = dtoh32a(&curdata[PTP_ece_Size]); |
| 1860 | uint32_t type = dtoh32a(&curdata[PTP_ece_Type]); |
| 1861 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1862 | if (size > datasize) { |
| 1863 | ptp_debug (params, "size %d is larger than datasize %d", size, datasize); |
| 1864 | break; |
| 1865 | } |
| 1866 | if (size < 8) { |
| 1867 | ptp_debug (params, "size %d is smaller than 8.", size); |
| 1868 | break; |
| 1869 | } |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1870 | if ((size == 8) && (type == 0)) |
| 1871 | break; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1872 | if ((curdata - data) + size >= datasize) { |
| 1873 | ptp_debug (params, "canon eos event decoder ran over supplied data, skipping entries"); |
| 1874 | break; |
| 1875 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1876 | if (type == PTP_EC_CANON_EOS_OLCInfoChanged) { |
| 1877 | unsigned int j; |
| 1878 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1879 | entries++; |
| 1880 | if (size >= 12+2) { |
| 1881 | for (j=0;j<31;j++) |
| 1882 | if (dtoh16a(curdata+12) & (1<<j)) |
| 1883 | entries++; |
| 1884 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1885 | } |
| 1886 | curdata += size; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1887 | entries++; |
| 1888 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1889 | ce = malloc (sizeof(PTPCanon_changes_entry)*(entries+1)); |
| 1890 | if (!ce) return 0; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1891 | |
| 1892 | curdata = data; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1893 | while (curdata - data + 8 < datasize) { |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1894 | uint32_t size = dtoh32a(&curdata[PTP_ece_Size]); |
| 1895 | uint32_t type = dtoh32a(&curdata[PTP_ece_Type]); |
| 1896 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1897 | if (size > datasize) { |
| 1898 | ptp_debug (params, "size %d is larger than datasize %d", size, datasize); |
| 1899 | break; |
| 1900 | } |
| 1901 | if (size < 8) { |
| 1902 | ptp_debug (params, "size %d is smaller than 8", size); |
| 1903 | break; |
| 1904 | } |
| 1905 | |
| 1906 | if ((size == 8) && (type == 0)) |
| 1907 | break; |
| 1908 | |
| 1909 | if ((curdata - data) + size >= datasize) { |
| 1910 | ptp_debug (params, "canon eos event decoder ran over supplied data, skipping entries"); |
| 1911 | break; |
| 1912 | } |
| 1913 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1914 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 1915 | ce[i].u.info = NULL; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1916 | switch (type) { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1917 | case PTP_EC_CANON_EOS_ObjectAddedEx: |
| 1918 | if (size < PTP_ece_OA_Name+1) { |
| 1919 | ptp_debug (params, "size %d is smaller than %d", size, PTP_ece_OA_Name+1); |
| 1920 | break; |
| 1921 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1922 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_OBJECTINFO; |
| 1923 | ce[i].u.object.oid = dtoh32a(&curdata[PTP_ece_OA_ObjectID]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1924 | ce[i].u.object.oi.StorageID = dtoh32a(&curdata[PTP_ece_OA_StorageID]); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1925 | ce[i].u.object.oi.ParentObject = dtoh32a(&curdata[PTP_ece_OA_Parent]); |
| 1926 | ce[i].u.object.oi.ObjectFormat = dtoh16a(&curdata[PTP_ece_OA_OFC]); |
| 1927 | ce[i].u.object.oi.ObjectCompressedSize= dtoh32a(&curdata[PTP_ece_OA_Size]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1928 | ce[i].u.object.oi.Filename = strdup(((char*)&curdata[PTP_ece_OA_Name])); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1929 | ptp_debug (params, "event %d: objectinfo added oid %08lx, parent %08lx, ofc %04x, size %d, filename %s", i, ce[i].u.object.oid, ce[i].u.object.oi.ParentObject, ce[i].u.object.oi.ObjectFormat, ce[i].u.object.oi.ObjectCompressedSize, ce[i].u.object.oi.Filename); |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 1930 | break; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1931 | case PTP_EC_CANON_EOS_ObjectAddedUnknown: /* FIXME: review if the data used is correct */ |
| 1932 | if (size < PTP_ece2_OA_Name+1) { |
| 1933 | ptp_debug (params, "size %d is smaller than %d", size, PTP_ece2_OA_Name+1); |
| 1934 | break; |
| 1935 | } |
| 1936 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_OBJECTINFO; |
| 1937 | ce[i].u.object.oid = dtoh32a(&curdata[PTP_ece2_OA_ObjectID]); |
| 1938 | ce[i].u.object.oi.StorageID = dtoh32a(&curdata[PTP_ece2_OA_StorageID]); |
| 1939 | ce[i].u.object.oi.ParentObject = dtoh32a(&curdata[PTP_ece2_OA_Parent]); |
| 1940 | ce[i].u.object.oi.ObjectFormat = dtoh16a(&curdata[PTP_ece2_OA_OFC]); |
| 1941 | ce[i].u.object.oi.ObjectCompressedSize= dtoh32a(&curdata[PTP_ece2_OA_Size]); /* FIXME: might be 64bit now */ |
| 1942 | ce[i].u.object.oi.Filename = strdup(((char*)&curdata[PTP_ece2_OA_Name])); |
| 1943 | ptp_debug (params, "event %d: objectinfo added oid %08lx, parent %08lx, ofc %04x, size %d, filename %s", i, ce[i].u.object.oid, ce[i].u.object.oi.ParentObject, ce[i].u.object.oi.ObjectFormat, ce[i].u.object.oi.ObjectCompressedSize, ce[i].u.object.oi.Filename); |
| 1944 | break; |
| 1945 | case PTP_EC_CANON_EOS_RequestObjectTransfer: |
| 1946 | case PTP_EC_CANON_EOS_RequestObjectTransferNew: /* FIXME: confirm */ |
| 1947 | if (size < PTP_ece_OI_Name+1) { |
| 1948 | ptp_debug (params, "size %d is smaller than %d", size, PTP_ece_OI_Name+1); |
| 1949 | break; |
| 1950 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1951 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_OBJECTTRANSFER; |
| 1952 | ce[i].u.object.oid = dtoh32a(&curdata[PTP_ece_OI_ObjectID]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1953 | ce[i].u.object.oi.StorageID = 0; /* use as marker */ |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1954 | ce[i].u.object.oi.ObjectFormat = dtoh16a(&curdata[PTP_ece_OI_OFC]); |
| 1955 | ce[i].u.object.oi.ParentObject = 0; /* check, but use as marker */ |
| 1956 | ce[i].u.object.oi.ObjectCompressedSize = dtoh32a(&curdata[PTP_ece_OI_Size]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1957 | ce[i].u.object.oi.Filename = strdup(((char*)&curdata[PTP_ece_OI_Name])); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1958 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1959 | ptp_debug (params, "event %d: request object transfer oid %08lx, ofc %04x, size %d, filename %p", i, ce[i].u.object.oid, ce[i].u.object.oi.ObjectFormat, ce[i].u.object.oi.ObjectCompressedSize, ce[i].u.object.oi.Filename); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1960 | break; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1961 | case PTP_EC_CANON_EOS_AvailListChanged: { /* property desc */ |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1962 | uint32_t proptype = dtoh32a(&curdata[PTP_ece_Prop_Subtype]); |
| 1963 | uint32_t propxtype = dtoh32a(&curdata[PTP_ece_Prop_Desc_Type]); |
| 1964 | uint32_t propxcnt = dtoh32a(&curdata[PTP_ece_Prop_Desc_Count]); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 1965 | unsigned char *xdata = &curdata[PTP_ece_Prop_Desc_Data]; |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 1966 | unsigned int j; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1967 | PTPDevicePropDesc *dpd; |
| 1968 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1969 | if (size < PTP_ece_Prop_Desc_Data) { |
| 1970 | ptp_debug (params, "size %d is smaller than %d", size, PTP_ece_Prop_Desc_Data); |
| 1971 | break; |
| 1972 | } |
| 1973 | |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1974 | ptp_debug (params, "event %d: EOS prop %04x desc record, datasize %d, propxtype %d", i, proptype, size-PTP_ece_Prop_Desc_Data, propxtype); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1975 | for (j=0;j<params->nrofcanon_props;j++) |
| 1976 | if (params->canon_props[j].proptype == proptype) |
| 1977 | break; |
| 1978 | if (j==params->nrofcanon_props) { |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1979 | ptp_debug (params, "event %d: propdesc %x, default value not found.", i, proptype); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1980 | break; |
| 1981 | } |
| 1982 | dpd = ¶ms->canon_props[j].dpd; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 1983 | /* 1 - uint16 ? |
| 1984 | * 3 - uint16 |
| 1985 | * 7 - string? |
| 1986 | */ |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1987 | if (propxtype != 3) { |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 1988 | ptp_debug (params, "event %d: propxtype is %x for %04x, unhandled, size %d", i, propxtype, proptype, size); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 1989 | for (j=0;j<size-PTP_ece_Prop_Desc_Data;j++) |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 1990 | ptp_debug (params, " %d: %02x", j, xdata[j]); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 1991 | break; |
| 1992 | } |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1993 | if (! propxcnt) |
| 1994 | break; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 1995 | if (propxcnt >= 2<<16) /* buggy or exploit */ |
| 1996 | break; |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 1997 | |
| 1998 | ptp_debug (params, "event %d: propxtype is %x, prop is 0x%04x, data type is 0x%04x, propxcnt is %d.", |
| 1999 | i, propxtype, proptype, dpd->DataType, propxcnt); |
| 2000 | dpd->FormFlag = PTP_DPFF_Enumeration; |
| 2001 | dpd->FORM.Enum.NumberOfValues = propxcnt; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2002 | free (dpd->FORM.Enum.SupportedValue); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2003 | dpd->FORM.Enum.SupportedValue = malloc (sizeof (PTPPropertyValue)*propxcnt); |
| 2004 | |
| 2005 | switch (proptype) { |
| 2006 | case PTP_DPC_CANON_EOS_ImageFormat: |
| 2007 | case PTP_DPC_CANON_EOS_ImageFormatCF: |
| 2008 | case PTP_DPC_CANON_EOS_ImageFormatSD: |
| 2009 | case PTP_DPC_CANON_EOS_ImageFormatExtHD: |
| 2010 | /* special handling of ImageFormat properties */ |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2011 | for (j=0;j<propxcnt;j++) { |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2012 | dpd->FORM.Enum.SupportedValue[j].u16 = |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2013 | ptp_unpack_EOS_ImageFormat( params, &xdata ); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2014 | ptp_debug (params, "event %d: suppval[%d] of %x is 0x%x.", i, j, proptype, dpd->FORM.Enum.SupportedValue[j].u16); |
| 2015 | } |
| 2016 | break; |
| 2017 | default: |
| 2018 | /* 'normal' enumerated types */ |
| 2019 | switch (dpd->DataType) { |
| 2020 | #define XX( TYPE, CONV )\ |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2021 | if (sizeof(dpd->FORM.Enum.SupportedValue[j].TYPE)*propxcnt + PTP_ece_Prop_Desc_Data > size) { \ |
| 2022 | ptp_debug (params, "size %d does not match needed %d", sizeof(dpd->FORM.Enum.SupportedValue[j].TYPE)*propxcnt + PTP_ece_Prop_Desc_Data, size); \ |
| 2023 | break; \ |
| 2024 | } \ |
| 2025 | for (j=0;j<propxcnt;j++) { \ |
| 2026 | dpd->FORM.Enum.SupportedValue[j].TYPE = CONV(xdata); \ |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2027 | ptp_debug (params, "event %d: suppval[%d] of %x is 0x%x.", i, j, proptype, CONV(xdata)); \ |
| 2028 | xdata += 4; /* might only be for propxtype 3 */ \ |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2029 | } \ |
| 2030 | break; |
| 2031 | |
| 2032 | case PTP_DTC_INT16: XX( i16, dtoh16a ); |
| 2033 | case PTP_DTC_UINT32: XX( u32, dtoh32a ); |
| 2034 | case PTP_DTC_UINT16: XX( u16, dtoh16a ); |
| 2035 | case PTP_DTC_UINT8: XX( u8, dtoh8a ); |
| 2036 | #undef XX |
| 2037 | default: |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2038 | free (dpd->FORM.Enum.SupportedValue); |
| 2039 | dpd->FORM.Enum.SupportedValue = NULL; |
| 2040 | dpd->FORM.Enum.NumberOfValues = 0; |
| 2041 | ptp_debug (params ,"event %d: data type 0x%04x of %x unhandled, size %d, raw values:", i, dpd->DataType, proptype, dtoh32a(xdata), size); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2042 | for (j=0;j<(size-PTP_ece_Prop_Desc_Data)/4;j++, xdata+=4) /* 4 is good for propxtype 3 */ |
| 2043 | ptp_debug (params, " %3d: 0x%8x", j, dtoh32a(xdata)); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2044 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2045 | } |
| 2046 | } |
| 2047 | break; |
| 2048 | } |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2049 | case PTP_EC_CANON_EOS_PropValueChanged: |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2050 | if (size >= 0xc) { /* property info */ |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2051 | unsigned int j; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2052 | uint32_t proptype = dtoh32a(&curdata[PTP_ece_Prop_Subtype]); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2053 | unsigned char *xdata = &curdata[PTP_ece_Prop_Val_Data]; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2054 | PTPDevicePropDesc *dpd; |
| 2055 | |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2056 | if (size < PTP_ece_Prop_Val_Data) { |
| 2057 | ptp_debug (params, "size %d is smaller than %d", size, PTP_ece_Prop_Val_Data); |
| 2058 | break; |
| 2059 | } |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2060 | ptp_debug (params, "event %d: EOS prop %04x info record, datasize is %d", i, proptype, size-PTP_ece_Prop_Val_Data); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2061 | for (j=0;j<params->nrofcanon_props;j++) |
| 2062 | if (params->canon_props[j].proptype == proptype) |
| 2063 | break; |
| 2064 | if (j<params->nrofcanon_props) { |
| 2065 | if ( (params->canon_props[j].size != size) || |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2066 | (memcmp(params->canon_props[j].data,xdata,size-PTP_ece_Prop_Val_Data))) { |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2067 | params->canon_props[j].data = realloc(params->canon_props[j].data,size-PTP_ece_Prop_Val_Data); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2068 | params->canon_props[j].size = size; |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2069 | memcpy (params->canon_props[j].data,xdata,size-PTP_ece_Prop_Val_Data); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2070 | } |
| 2071 | } else { |
| 2072 | if (j) |
| 2073 | params->canon_props = realloc(params->canon_props, sizeof(params->canon_props[0])*(j+1)); |
| 2074 | else |
| 2075 | params->canon_props = malloc(sizeof(params->canon_props[0])); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2076 | params->canon_props[j].proptype = proptype; |
| 2077 | params->canon_props[j].size = size; |
| 2078 | params->canon_props[j].data = malloc(size-PTP_ece_Prop_Val_Data); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2079 | memcpy(params->canon_props[j].data, xdata, size-PTP_ece_Prop_Val_Data); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2080 | memset (¶ms->canon_props[j].dpd,0,sizeof(params->canon_props[j].dpd)); |
| 2081 | params->canon_props[j].dpd.GetSet = 1; |
| 2082 | params->canon_props[j].dpd.FormFlag = PTP_DPFF_None; |
| 2083 | params->nrofcanon_props = j+1; |
| 2084 | } |
| 2085 | dpd = ¶ms->canon_props[j].dpd; |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2086 | |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2087 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_PROPERTY; |
| 2088 | ce[i].u.propid = proptype; |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2089 | |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2090 | /* fix GetSet value */ |
| 2091 | switch (proptype) { |
| 2092 | #define XX(x) case PTP_DPC_CANON_##x: |
| 2093 | XX(EOS_FocusMode) |
| 2094 | XX(EOS_BatteryPower) |
| 2095 | XX(EOS_BatterySelect) |
| 2096 | XX(EOS_ModelID) |
| 2097 | XX(EOS_PTPExtensionVersion) |
| 2098 | XX(EOS_DPOFVersion) |
| 2099 | XX(EOS_AvailableShots) |
| 2100 | XX(EOS_CurrentStorage) |
| 2101 | XX(EOS_CurrentFolder) |
| 2102 | XX(EOS_MyMenu) |
| 2103 | XX(EOS_MyMenuList) |
| 2104 | XX(EOS_HDDirectoryStructure) |
| 2105 | XX(EOS_BatteryInfo) |
| 2106 | XX(EOS_AdapterInfo) |
| 2107 | XX(EOS_LensStatus) |
| 2108 | XX(EOS_CardExtension) |
| 2109 | XX(EOS_TempStatus) |
| 2110 | XX(EOS_ShutterCounter) |
| 2111 | XX(EOS_SerialNumber) |
| 2112 | XX(EOS_DepthOfFieldPreview) |
| 2113 | XX(EOS_EVFRecordStatus) |
| 2114 | XX(EOS_LvAfSystem) |
| 2115 | XX(EOS_FocusInfoEx) |
| 2116 | XX(EOS_DepthOfField) |
| 2117 | XX(EOS_Brightness) |
| 2118 | XX(EOS_EFComp) |
| 2119 | XX(EOS_LensName) |
| 2120 | XX(EOS_LensID) |
| 2121 | #undef XX |
| 2122 | dpd->GetSet = PTP_DPGS_Get; |
| 2123 | break; |
| 2124 | } |
| 2125 | |
| 2126 | /* set DataType */ |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2127 | switch (proptype) { |
Linus Walleij | ac052c1 | 2007-07-18 18:37:10 +0000 | [diff] [blame] | 2128 | case PTP_DPC_CANON_EOS_CameraTime: |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2129 | case PTP_DPC_CANON_EOS_UTCTime: |
| 2130 | case PTP_DPC_CANON_EOS_Summertime: /* basical the DST flag */ |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2131 | case PTP_DPC_CANON_EOS_AvailableShots: |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2132 | case PTP_DPC_CANON_EOS_CaptureDestination: |
| 2133 | case PTP_DPC_CANON_EOS_WhiteBalanceXA: |
| 2134 | case PTP_DPC_CANON_EOS_WhiteBalanceXB: |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2135 | case PTP_DPC_CANON_EOS_CurrentStorage: |
| 2136 | case PTP_DPC_CANON_EOS_CurrentFolder: |
| 2137 | case PTP_DPC_CANON_EOS_ShutterCounter: |
| 2138 | case PTP_DPC_CANON_EOS_ModelID: |
| 2139 | case PTP_DPC_CANON_EOS_LensID: |
| 2140 | case PTP_DPC_CANON_EOS_StroboFiring: |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2141 | case PTP_DPC_CANON_EOS_AFSelectFocusArea: |
| 2142 | case PTP_DPC_CANON_EOS_ContinousAFMode: |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2143 | case PTP_DPC_CANON_EOS_MirrorUpSetting: |
Linus Walleij | ac052c1 | 2007-07-18 18:37:10 +0000 | [diff] [blame] | 2144 | dpd->DataType = PTP_DTC_UINT32; |
| 2145 | break; |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2146 | /* enumeration for AEM is never provided, but is available to set */ |
| 2147 | case PTP_DPC_CANON_EOS_AutoExposureMode: |
| 2148 | dpd->DataType = PTP_DTC_UINT16; |
| 2149 | dpd->FormFlag = PTP_DPFF_Enumeration; |
| 2150 | dpd->FORM.Enum.NumberOfValues = 0; |
| 2151 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2152 | case PTP_DPC_CANON_EOS_Aperture: |
| 2153 | case PTP_DPC_CANON_EOS_ShutterSpeed: |
| 2154 | case PTP_DPC_CANON_EOS_ISOSpeed: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2155 | case PTP_DPC_CANON_EOS_FocusMode: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2156 | case PTP_DPC_CANON_EOS_ColorSpace: |
| 2157 | case PTP_DPC_CANON_EOS_BatteryPower: |
Linus Walleij | e29ca68 | 2010-01-30 08:15:25 +0000 | [diff] [blame] | 2158 | case PTP_DPC_CANON_EOS_BatterySelect: |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2159 | case PTP_DPC_CANON_EOS_PTPExtensionVersion: |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2160 | case PTP_DPC_CANON_EOS_DriveMode: |
| 2161 | case PTP_DPC_CANON_EOS_AEB: |
Linus Walleij | e29ca68 | 2010-01-30 08:15:25 +0000 | [diff] [blame] | 2162 | case PTP_DPC_CANON_EOS_BracketMode: |
| 2163 | case PTP_DPC_CANON_EOS_QuickReviewTime: |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2164 | case PTP_DPC_CANON_EOS_EVFMode: |
| 2165 | case PTP_DPC_CANON_EOS_EVFOutputDevice: |
Linus Walleij | a381e8a | 2013-03-05 21:00:06 +0100 | [diff] [blame] | 2166 | case PTP_DPC_CANON_EOS_AutoPowerOff: |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2167 | case PTP_DPC_CANON_EOS_EVFRecordStatus: |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2168 | dpd->DataType = PTP_DTC_UINT16; |
| 2169 | break; |
| 2170 | case PTP_DPC_CANON_EOS_PictureStyle: |
| 2171 | case PTP_DPC_CANON_EOS_WhiteBalance: |
| 2172 | case PTP_DPC_CANON_EOS_MeteringMode: |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2173 | case PTP_DPC_CANON_EOS_ExpCompensation: |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2174 | dpd->DataType = PTP_DTC_UINT8; |
| 2175 | break; |
| 2176 | case PTP_DPC_CANON_EOS_Owner: |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2177 | case PTP_DPC_CANON_EOS_Artist: |
| 2178 | case PTP_DPC_CANON_EOS_Copyright: |
| 2179 | case PTP_DPC_CANON_EOS_SerialNumber: |
| 2180 | case PTP_DPC_CANON_EOS_LensName: |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2181 | dpd->DataType = PTP_DTC_STR; |
| 2182 | break; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2183 | case PTP_DPC_CANON_EOS_WhiteBalanceAdjustA: |
| 2184 | case PTP_DPC_CANON_EOS_WhiteBalanceAdjustB: |
| 2185 | dpd->DataType = PTP_DTC_INT16; |
| 2186 | break; |
| 2187 | /* unknown props, listed from dump.... all 16 bit, but vals might be smaller */ |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2188 | case PTP_DPC_CANON_EOS_DPOFVersion: |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2189 | dpd->DataType = PTP_DTC_UINT16; |
| 2190 | ptp_debug (params, "event %d: Unknown EOS property %04x, datasize is %d, using uint16", i ,proptype, size-PTP_ece_Prop_Val_Data); |
| 2191 | for (j=0;j<size-PTP_ece_Prop_Val_Data;j++) |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2192 | ptp_debug (params, " %d: %02x", j, xdata[j]); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2193 | break; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2194 | case PTP_DPC_CANON_EOS_CustomFunc1: |
| 2195 | case PTP_DPC_CANON_EOS_CustomFunc2: |
| 2196 | case PTP_DPC_CANON_EOS_CustomFunc3: |
| 2197 | case PTP_DPC_CANON_EOS_CustomFunc4: |
| 2198 | case PTP_DPC_CANON_EOS_CustomFunc5: |
| 2199 | case PTP_DPC_CANON_EOS_CustomFunc6: |
| 2200 | case PTP_DPC_CANON_EOS_CustomFunc7: |
| 2201 | case PTP_DPC_CANON_EOS_CustomFunc8: |
| 2202 | case PTP_DPC_CANON_EOS_CustomFunc9: |
| 2203 | case PTP_DPC_CANON_EOS_CustomFunc10: |
| 2204 | case PTP_DPC_CANON_EOS_CustomFunc11: |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2205 | dpd->DataType = PTP_DTC_UINT8; |
| 2206 | ptp_debug (params, "event %d: Unknown EOS property %04x, datasize is %d, using uint8", i ,proptype, size-PTP_ece_Prop_Val_Data); |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2207 | for (j=0;j<size-PTP_ece_Prop_Val_Data;j++) |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2208 | ptp_debug (params, " %d: %02x", j, xdata[j]); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2209 | /* custom func entries look like this on the 400D: '5 0 0 0 ?' = 4 bytes size + 1 byte data */ |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2210 | xdata += 4; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2211 | break; |
| 2212 | /* yet unknown 32bit props */ |
| 2213 | case PTP_DPC_CANON_EOS_ColorTemperature: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2214 | case PTP_DPC_CANON_EOS_WftStatus: |
| 2215 | case PTP_DPC_CANON_EOS_LensStatus: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2216 | case PTP_DPC_CANON_EOS_CardExtension: |
| 2217 | case PTP_DPC_CANON_EOS_TempStatus: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2218 | case PTP_DPC_CANON_EOS_PhotoStudioMode: |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2219 | case PTP_DPC_CANON_EOS_DepthOfFieldPreview: |
| 2220 | case PTP_DPC_CANON_EOS_EVFSharpness: |
| 2221 | case PTP_DPC_CANON_EOS_EVFWBMode: |
| 2222 | case PTP_DPC_CANON_EOS_EVFClickWBCoeffs: |
| 2223 | case PTP_DPC_CANON_EOS_EVFColorTemp: |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2224 | case PTP_DPC_CANON_EOS_ExposureSimMode: |
| 2225 | case PTP_DPC_CANON_EOS_LvAfSystem: |
| 2226 | case PTP_DPC_CANON_EOS_MovSize: |
| 2227 | case PTP_DPC_CANON_EOS_DepthOfField: |
| 2228 | case PTP_DPC_CANON_EOS_LvViewTypeSelect: |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2229 | case PTP_DPC_CANON_EOS_AloMode: |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2230 | case PTP_DPC_CANON_EOS_Brightness: |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2231 | dpd->DataType = PTP_DTC_UINT32; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2232 | ptp_debug (params, "event %d: Unknown EOS property %04x, datasize is %d, using uint32", i ,proptype, size-PTP_ece_Prop_Val_Data); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2233 | if ((size-PTP_ece_Prop_Val_Data) % sizeof(uint32_t) != 0) |
| 2234 | ptp_debug (params, "event %d: Warning: datasize modulo sizeof(uint32) is not 0: ", i, (size-PTP_ece_Prop_Val_Data) % sizeof(uint32_t) ); |
| 2235 | for (j=0;j<(size-PTP_ece_Prop_Val_Data)/sizeof(uint32_t);j++) |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2236 | ptp_debug (params, " %d: 0x%8x", j, dtoh32a(xdata+j*4)); |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2237 | break; |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2238 | /* ImageFormat properties have to be ignored here, see special handling below */ |
| 2239 | case PTP_DPC_CANON_EOS_ImageFormat: |
| 2240 | case PTP_DPC_CANON_EOS_ImageFormatCF: |
| 2241 | case PTP_DPC_CANON_EOS_ImageFormatSD: |
| 2242 | case PTP_DPC_CANON_EOS_ImageFormatExtHD: |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 2243 | case PTP_DPC_CANON_EOS_CustomFuncEx: |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2244 | case PTP_DPC_CANON_EOS_FocusInfoEx: |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2245 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2246 | default: |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 2247 | ptp_debug (params, "event %d: Unknown EOS property %04x, datasize is %d", i ,proptype, size-PTP_ece_Prop_Val_Data); |
| 2248 | for (j=0;j<size-PTP_ece_Prop_Val_Data;j++) |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2249 | ptp_debug (params, " %d: %02x", j, xdata[j]); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2250 | break; |
| 2251 | } |
| 2252 | switch (dpd->DataType) { |
Linus Walleij | ac052c1 | 2007-07-18 18:37:10 +0000 | [diff] [blame] | 2253 | case PTP_DTC_UINT32: |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2254 | dpd->FactoryDefaultValue.u32 = dtoh32a(xdata); |
| 2255 | dpd->CurrentValue.u32 = dtoh32a(xdata); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 2256 | ptp_debug (params ,"event %d: currentvalue of %x is %x", i, proptype, dpd->CurrentValue.u32); |
Linus Walleij | ac052c1 | 2007-07-18 18:37:10 +0000 | [diff] [blame] | 2257 | break; |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2258 | case PTP_DTC_INT16: |
| 2259 | dpd->FactoryDefaultValue.i16 = dtoh16a(xdata); |
| 2260 | dpd->CurrentValue.i16 = dtoh16a(xdata); |
| 2261 | ptp_debug (params,"event %d: currentvalue of %x is %d", i, proptype, dpd->CurrentValue.i16); |
| 2262 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2263 | case PTP_DTC_UINT16: |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2264 | dpd->FactoryDefaultValue.u16 = dtoh16a(xdata); |
| 2265 | dpd->CurrentValue.u16 = dtoh16a(xdata); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 2266 | ptp_debug (params,"event %d: currentvalue of %x is %x", i, proptype, dpd->CurrentValue.u16); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2267 | break; |
| 2268 | case PTP_DTC_UINT8: |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2269 | dpd->FactoryDefaultValue.u8 = dtoh8a(xdata); |
| 2270 | dpd->CurrentValue.u8 = dtoh8a(xdata); |
Linus Walleij | 3bc0d7f | 2008-11-01 23:06:24 +0000 | [diff] [blame] | 2271 | ptp_debug (params,"event %d: currentvalue of %x is %x", i, proptype, dpd->CurrentValue.u8); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2272 | break; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2273 | case PTP_DTC_INT8: |
| 2274 | dpd->FactoryDefaultValue.i8 = dtoh8a(xdata); |
| 2275 | dpd->CurrentValue.i8 = dtoh8a(xdata); |
| 2276 | ptp_debug (params,"event %d: currentvalue of %x is %x", i, proptype, dpd->CurrentValue.i8); |
| 2277 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2278 | case PTP_DTC_STR: { |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2279 | #if 0 /* 5D MII and 400D aktually store plain ASCII in their string properties */ |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2280 | uint8_t len = 0; |
| 2281 | dpd->FactoryDefaultValue.str = ptp_unpack_string(params, data, 0, &len); |
| 2282 | dpd->CurrentValue.str = ptp_unpack_string(params, data, 0, &len); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2283 | #else |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2284 | free (dpd->FactoryDefaultValue.str); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2285 | dpd->FactoryDefaultValue.str = strdup( (char*)xdata ); |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2286 | |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2287 | free (dpd->CurrentValue.str); |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2288 | dpd->CurrentValue.str = strdup( (char*)xdata ); |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2289 | #endif |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2290 | ptp_debug (params,"event %d: currentvalue of %x is %s", i, proptype, dpd->CurrentValue.str); |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2291 | break; |
| 2292 | } |
| 2293 | default: |
| 2294 | /* debug is printed in switch above this one */ |
| 2295 | break; |
| 2296 | } |
Linus Walleij | 1a0c301 | 2009-07-23 23:06:58 +0000 | [diff] [blame] | 2297 | |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 2298 | /* ImageFormat and customFuncEx special handling (WARNING: dont move this in front of the dpd->DataType switch!) */ |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2299 | switch (proptype) { |
| 2300 | case PTP_DPC_CANON_EOS_ImageFormat: |
| 2301 | case PTP_DPC_CANON_EOS_ImageFormatCF: |
| 2302 | case PTP_DPC_CANON_EOS_ImageFormatSD: |
| 2303 | case PTP_DPC_CANON_EOS_ImageFormatExtHD: |
| 2304 | dpd->DataType = PTP_DTC_UINT16; |
Linus Walleij | e206af6 | 2011-04-19 01:51:39 +0200 | [diff] [blame] | 2305 | dpd->FactoryDefaultValue.u16 = ptp_unpack_EOS_ImageFormat( params, &xdata ); |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2306 | dpd->CurrentValue.u16 = dpd->FactoryDefaultValue.u16; |
| 2307 | ptp_debug (params,"event %d: decoded imageformat, currentvalue of %x is %x", i, proptype, dpd->CurrentValue.u16); |
| 2308 | break; |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 2309 | case PTP_DPC_CANON_EOS_CustomFuncEx: |
| 2310 | dpd->DataType = PTP_DTC_STR; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2311 | free (dpd->FactoryDefaultValue.str); |
| 2312 | free (dpd->CurrentValue.str); |
| 2313 | dpd->FactoryDefaultValue.str = ptp_unpack_EOS_CustomFuncEx( params, &xdata ); |
Marcus Meissner | 0546a76 | 2012-04-10 18:49:10 +0200 | [diff] [blame] | 2314 | dpd->CurrentValue.str = strdup( (char*)dpd->FactoryDefaultValue.str ); |
| 2315 | ptp_debug (params,"event %d: decoded custom function, currentvalue of %x is %s", i, proptype, dpd->CurrentValue.str); |
| 2316 | break; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2317 | case PTP_DPC_CANON_EOS_FocusInfoEx: |
| 2318 | dpd->DataType = PTP_DTC_STR; |
| 2319 | free (dpd->FactoryDefaultValue.str); |
| 2320 | free (dpd->CurrentValue.str); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2321 | dpd->FactoryDefaultValue.str = ptp_unpack_EOS_FocusInfoEx( params, &xdata, size ); |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2322 | dpd->CurrentValue.str = strdup( (char*)dpd->FactoryDefaultValue.str ); |
| 2323 | ptp_debug (params,"event %d: decoded focus info, currentvalue of %x is %s", i, proptype, dpd->CurrentValue.str); |
| 2324 | break; |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2325 | } |
| 2326 | |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2327 | break; |
| 2328 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2329 | /* one more information record handed to us */ |
| 2330 | case PTP_EC_CANON_EOS_OLCInfoChanged: { |
| 2331 | uint32_t len, curoff; |
| 2332 | uint16_t mask,proptype; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2333 | PTPDevicePropDesc *dpd; |
| 2334 | |
| 2335 | /* unclear what OLC stands for */ |
| 2336 | ptp_debug (params, "event %d: EOS event OLCInfoChanged (size %d)", i, size); |
| 2337 | if (size >= 0x8) { /* event info */ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2338 | unsigned int k; |
| 2339 | for (k=8;k<size;k++) |
| 2340 | ptp_debug (params, " %d: %02x", k-8, curdata[k]); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2341 | } |
| 2342 | len = dtoh32a(curdata+8); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2343 | if ((len != size-8) && (len != size-4)) { |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2344 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2345 | ce[i].u.info = strdup("OLC size unexpected"); |
| 2346 | ptp_debug (params, "event %d: OLC unexpected size %d for blob len %d (not -4 nor -8)", i, size, len); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2347 | break; |
| 2348 | } |
| 2349 | mask = dtoh16a(curdata+8+4); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2350 | if (size < 14) { |
| 2351 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2352 | ce[i].u.info = strdup("OLC size too small"); |
| 2353 | ptp_debug (params, "event %d: OLC unexpected size %d", i, size); |
| 2354 | break; |
| 2355 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2356 | curoff = 8+4+4; |
| 2357 | if (mask & CANON_EOS_OLC_BUTTON) { |
| 2358 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2359 | ce[i].u.info = malloc(strlen("Button 1234567")); |
| 2360 | sprintf(ce[i].u.info, "Button %d", dtoh16a(curdata+curoff)); |
| 2361 | i++; |
| 2362 | curoff += 2; |
| 2363 | } |
| 2364 | |
| 2365 | if (mask & CANON_EOS_OLC_SHUTTERSPEED) { |
| 2366 | /* 6 bytes: 01 01 98 10 00 60 */ |
| 2367 | /* this seesm to be the shutter speed record */ |
| 2368 | proptype = PTP_DPC_CANON_EOS_ShutterSpeed; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2369 | dpd = _lookup_or_allocate_canon_prop(params, proptype); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2370 | dpd->CurrentValue.u16 = curdata[curoff+5]; /* just use last byte */ |
| 2371 | |
| 2372 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_PROPERTY; |
| 2373 | ce[i].u.propid = proptype; |
| 2374 | curoff += 6; |
| 2375 | i++; |
| 2376 | } |
| 2377 | if (mask & CANON_EOS_OLC_APERTURE) { |
| 2378 | /* 5 bytes: 01 01 5b 30 30 */ |
| 2379 | /* this seesm to be the aperture record */ |
| 2380 | proptype = PTP_DPC_CANON_EOS_Aperture; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2381 | dpd = _lookup_or_allocate_canon_prop(params, proptype); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2382 | dpd->CurrentValue.u16 = curdata[curoff+4]; /* just use last byte */ |
| 2383 | |
| 2384 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_PROPERTY; |
| 2385 | ce[i].u.propid = proptype; |
| 2386 | curoff += 5; |
| 2387 | i++; |
| 2388 | } |
| 2389 | if (mask & CANON_EOS_OLC_ISO) { |
| 2390 | /* 5 bytes: 01 01 00 78 */ |
| 2391 | /* this seesm to be the aperture record */ |
| 2392 | proptype = PTP_DPC_CANON_EOS_ISOSpeed; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2393 | dpd = _lookup_or_allocate_canon_prop(params, proptype); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2394 | dpd->CurrentValue.u16 = curdata[curoff+3]; /* just use last byte */ |
| 2395 | |
| 2396 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_PROPERTY; |
| 2397 | ce[i].u.propid = proptype; |
| 2398 | curoff += 4; |
| 2399 | i++; |
| 2400 | } |
| 2401 | if (mask & 0x0010) { |
| 2402 | /* mask 0x0010: 4 bytes, 04 00 00 00 observed */ |
| 2403 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2404 | ce[i].u.info = malloc(strlen("OLCInfo event 0x0010 content 01234567")+1); |
| 2405 | sprintf(ce[i].u.info,"OLCInfo event 0x0010 content %02x%02x%02x%02x", |
| 2406 | curdata[curoff], |
| 2407 | curdata[curoff+1], |
| 2408 | curdata[curoff+2], |
| 2409 | curdata[curoff+3] |
| 2410 | ); |
| 2411 | curoff += 4; |
| 2412 | i++; |
| 2413 | } |
| 2414 | if (mask & 0x0020) { |
| 2415 | /* mask 0x0020: 6 bytes, 00 00 00 00 00 00 observed */ |
| 2416 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2417 | ce[i].u.info = malloc(strlen("OLCInfo event 0x0020 content 0123456789ab")+1); |
| 2418 | sprintf(ce[i].u.info,"OLCInfo event 0x0020 content %02x%02x%02x%02x%02x%02x", |
| 2419 | curdata[curoff], |
| 2420 | curdata[curoff+1], |
| 2421 | curdata[curoff+2], |
| 2422 | curdata[curoff+3], |
| 2423 | curdata[curoff+4], |
| 2424 | curdata[curoff+5] |
| 2425 | ); |
| 2426 | curoff += 6; |
| 2427 | i++; |
| 2428 | } |
| 2429 | if (mask & 0x0040) { |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2430 | int value = (signed char)curdata[curoff+2]; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2431 | /* mask 0x0040: 7 bytes, 01 01 00 00 00 00 00 observed */ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2432 | /* exposure indicator */ |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2433 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2434 | ce[i].u.info = malloc(strlen("OLCInfo exposure indicator 012345678901234567890123456789abcd")+1); |
| 2435 | sprintf(ce[i].u.info,"OLCInfo exposure indicator %d,%d,%d.%d (%02x%02x%02x%02x)", |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2436 | curdata[curoff], |
| 2437 | curdata[curoff+1], |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2438 | value/10,abs(value)%10, |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2439 | curdata[curoff+3], |
| 2440 | curdata[curoff+4], |
| 2441 | curdata[curoff+5], |
| 2442 | curdata[curoff+6] |
| 2443 | ); |
| 2444 | curoff += 7; |
| 2445 | i++; |
| 2446 | } |
| 2447 | if (mask & 0x0080) { |
| 2448 | /* mask 0x0080: 4 bytes, 00 00 00 00 observed */ |
| 2449 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2450 | ce[i].u.info = malloc(strlen("OLCInfo event 0x0080 content 01234567")+1); |
| 2451 | sprintf(ce[i].u.info,"OLCInfo event 0x0080 content %02x%02x%02x%02x", |
| 2452 | curdata[curoff], |
| 2453 | curdata[curoff+1], |
| 2454 | curdata[curoff+2], |
| 2455 | curdata[curoff+3] |
| 2456 | ); |
| 2457 | curoff += 4; |
| 2458 | i++; |
| 2459 | } |
| 2460 | if (mask & 0x0100) { |
| 2461 | /* mask 0x0100: 6 bytes, 00 00 00 00 00 00 (before focus) and 00 00 00 00 01 00 (on focus) observed */ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2462 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_FOCUSINFO; |
| 2463 | ce[i].u.info = malloc(strlen("0123456789ab")+1); |
| 2464 | sprintf(ce[i].u.info,"%02x%02x%02x%02x%02x%02x", |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2465 | curdata[curoff], |
| 2466 | curdata[curoff+1], |
| 2467 | curdata[curoff+2], |
| 2468 | curdata[curoff+3], |
| 2469 | curdata[curoff+4], |
| 2470 | curdata[curoff+5] |
| 2471 | ); |
| 2472 | curoff += 6; |
| 2473 | i++; |
| 2474 | } |
| 2475 | if (mask & 0x0200) { |
| 2476 | /* mask 0x0200: 7 bytes, 00 00 00 00 00 00 00 observed */ |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2477 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_FOCUSMASK; |
| 2478 | ce[i].u.info = malloc(strlen("0123456789abcd0123456789abcdef")+1); |
| 2479 | sprintf(ce[i].u.info,"%02x%02x%02x%02x%02x%02x%02x", |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2480 | curdata[curoff], |
| 2481 | curdata[curoff+1], |
| 2482 | curdata[curoff+2], |
| 2483 | curdata[curoff+3], |
| 2484 | curdata[curoff+4], |
| 2485 | curdata[curoff+5], |
| 2486 | curdata[curoff+6] |
| 2487 | ); |
| 2488 | curoff += 7; |
| 2489 | i++; |
| 2490 | } |
| 2491 | if (mask & 0x0400) { |
| 2492 | /* mask 0x0400: 7 bytes, 00 00 00 00 00 00 00 observed */ |
| 2493 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2494 | ce[i].u.info = malloc(strlen("OLCInfo event 0x0400 content 0123456789abcd")+1); |
| 2495 | sprintf(ce[i].u.info,"OLCInfo event 0x0400 content %02x%02x%02x%02x%02x%02x%02x", |
| 2496 | curdata[curoff], |
| 2497 | curdata[curoff+1], |
| 2498 | curdata[curoff+2], |
| 2499 | curdata[curoff+3], |
| 2500 | curdata[curoff+4], |
| 2501 | curdata[curoff+5], |
| 2502 | curdata[curoff+6] |
| 2503 | ); |
| 2504 | curoff += 7; |
| 2505 | i++; |
| 2506 | } |
| 2507 | if (mask & 0x0800) { |
| 2508 | /* mask 0x0800: 8 bytes, 00 00 00 00 00 00 00 00 and 19 01 00 00 00 00 00 00 and others observed */ |
| 2509 | /* might be mask of focus points selected */ |
| 2510 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2511 | ce[i].u.info = malloc(strlen("OLCInfo event 0x0800 content 0123456789abcdef")+1); |
| 2512 | sprintf(ce[i].u.info,"OLCInfo event 0x0800 content %02x%02x%02x%02x%02x%02x%02x%02x", |
| 2513 | curdata[curoff], |
| 2514 | curdata[curoff+1], |
| 2515 | curdata[curoff+2], |
| 2516 | curdata[curoff+3], |
| 2517 | curdata[curoff+4], |
| 2518 | curdata[curoff+5], |
| 2519 | curdata[curoff+6], |
| 2520 | curdata[curoff+7] |
| 2521 | ); |
| 2522 | curoff += 8; |
| 2523 | i++; |
| 2524 | } |
| 2525 | if (mask & 0x1000) { |
| 2526 | /* mask 0x1000: 1 byte, 00 observed */ |
| 2527 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2528 | ce[i].u.info = malloc(strlen("OLCInfo event 0x1000 content 01")+1); |
| 2529 | sprintf(ce[i].u.info,"OLCInfo event 0x1000 content %02x", |
| 2530 | curdata[curoff] |
| 2531 | ); |
| 2532 | curoff += 1; |
| 2533 | i++; |
| 2534 | } |
| 2535 | /* handle more masks */ |
| 2536 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
| 2537 | ce[i].u.info = malloc(strlen("OLCInfo event mask 0123456789")+1); |
| 2538 | sprintf(ce[i].u.info, "OLCInfo event mask=%x", mask); |
| 2539 | break; |
| 2540 | } |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2541 | case PTP_EC_CANON_EOS_CameraStatusChanged: |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2542 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_CAMERASTATUS; |
| 2543 | ce[i].u.status = dtoh32a(curdata+8); |
| 2544 | ptp_debug (params, "event %d: EOS event CameraStatusChanged (size %d) = %d", i, size, dtoh32a(curdata+8)); |
Linus Walleij | 9e09ad0 | 2011-02-10 13:14:01 +0100 | [diff] [blame] | 2545 | params->eos_camerastatus = dtoh32a(curdata+8); |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2546 | break; |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2547 | case 0: /* end marker */ |
| 2548 | if (size == 8) /* no output */ |
| 2549 | break; |
| 2550 | ptp_debug (params, "event %d: EOS event 0, but size %d", i, size); |
| 2551 | break; |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 2552 | case PTP_EC_CANON_EOS_BulbExposureTime: |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2553 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2554 | ce[i].u.info = malloc(strlen("BulbExposureTime 123456789012345678")); |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2555 | sprintf (ce[i].u.info, "BulbExposureTime %d", dtoh32a(curdata+8)); |
Linus Walleij | 96aa0e3 | 2012-03-25 12:25:25 +0200 | [diff] [blame] | 2556 | break; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2557 | case PTP_EC_CANON_EOS_ObjectRemoved: |
| 2558 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_OBJECTREMOVED; |
| 2559 | ce[i].u.object.oid = dtoh32a(curdata+8); |
| 2560 | break; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2561 | default: |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2562 | switch (type) { |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2563 | #define XX(x) case PTP_EC_CANON_EOS_##x: \ |
| 2564 | ptp_debug (params, "event %d: unhandled EOS event "#x" (size %d)", i, size); \ |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2565 | ce[i].u.info = malloc(strlen("unhandled EOS event "#x" (size 123456789)")); \ |
| 2566 | sprintf (ce[i].u.info, "unhandled EOS event "#x" (size %d)", size); \ |
Linus Walleij | d7072c3 | 2010-12-07 20:43:00 +0000 | [diff] [blame] | 2567 | break; |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2568 | XX(RequestGetEvent) |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2569 | XX(RequestGetObjectInfoEx) |
| 2570 | XX(StorageStatusChanged) |
| 2571 | XX(StorageInfoChanged) |
| 2572 | XX(ObjectInfoChangedEx) |
| 2573 | XX(ObjectContentChanged) |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2574 | XX(WillSoonShutdown) |
| 2575 | XX(ShutdownTimerUpdated) |
| 2576 | XX(RequestCancelTransfer) |
| 2577 | XX(RequestObjectTransferDT) |
| 2578 | XX(RequestCancelTransferDT) |
| 2579 | XX(StoreAdded) |
| 2580 | XX(StoreRemoved) |
| 2581 | XX(BulbExposureTime) |
| 2582 | XX(RecordingTime) |
| 2583 | XX(RequestObjectTransferTS) |
| 2584 | XX(AfResult) |
| 2585 | #undef XX |
| 2586 | default: |
| 2587 | ptp_debug (params, "event %d: unknown EOS event %04x", i, type); |
| 2588 | break; |
| 2589 | } |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2590 | if (size >= 0x8) { /* event info */ |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2591 | unsigned int j; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2592 | /*ptp_debug (params, "data=%p, curdata=%p, datsize=%d, size=%d", data, curdata, datasize, size);*/ |
Linus Walleij | d463750 | 2009-06-14 23:03:33 +0000 | [diff] [blame] | 2593 | for (j=8;j<size;j++) |
| 2594 | ptp_debug (params, " %d: %02x", j, curdata[j]); |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2595 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2596 | ce[i].type = PTP_CANON_EOS_CHANGES_TYPE_UNKNOWN; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2597 | break; |
| 2598 | } |
| 2599 | curdata += size; |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2600 | i++; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2601 | if (i >= entries) { |
| 2602 | ptp_debug (params, "BAD: i %d, entries %d", i, entries); |
| 2603 | } |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2604 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2605 | if (!i) { |
| 2606 | free (ce); |
| 2607 | ce = NULL; |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2608 | } |
Linus Walleij | 9783ce3 | 2014-06-02 21:44:29 +0200 | [diff] [blame] | 2609 | *pce = ce; |
| 2610 | return i; |
Linus Walleij | f0bf437 | 2007-07-01 21:47:38 +0000 | [diff] [blame] | 2611 | } |
| 2612 | |
| 2613 | /* |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2614 | PTP USB Event container unpack for Nikon events. |
| 2615 | */ |
| 2616 | #define PTP_nikon_ec_Length 0 |
| 2617 | #define PTP_nikon_ec_Code 2 |
| 2618 | #define PTP_nikon_ec_Param1 4 |
| 2619 | #define PTP_nikon_ec_Size 6 |
| 2620 | static inline void |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2621 | ptp_unpack_Nikon_EC (PTPParams *params, unsigned char* data, unsigned int len, PTPContainer **ec, unsigned int *cnt) |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2622 | { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2623 | unsigned int i; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2624 | |
| 2625 | *ec = NULL; |
| 2626 | if (data == NULL) |
| 2627 | return; |
| 2628 | if (len < PTP_nikon_ec_Code) |
| 2629 | return; |
| 2630 | *cnt = dtoh16a(&data[PTP_nikon_ec_Length]); |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2631 | if (*cnt > (len-PTP_nikon_ec_Code)/PTP_nikon_ec_Size) { /* broken cnt? */ |
| 2632 | *cnt = 0; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2633 | return; |
Marcus Meissner | aa7d91a | 2017-03-16 15:59:48 +0100 | [diff] [blame] | 2634 | } |
Linus Walleij | 0d762cc | 2010-04-04 23:34:27 +0000 | [diff] [blame] | 2635 | if (!*cnt) |
| 2636 | return; |
| 2637 | |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2638 | *ec = malloc(sizeof(PTPContainer)*(*cnt)); |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2639 | |
| 2640 | for (i=0;i<*cnt;i++) { |
Linus Walleij | 7e75653 | 2009-05-06 21:25:09 +0000 | [diff] [blame] | 2641 | memset(&(*ec)[i],0,sizeof(PTPContainer)); |
| 2642 | (*ec)[i].Code = dtoh16a(&data[PTP_nikon_ec_Code+PTP_nikon_ec_Size*i]); |
| 2643 | (*ec)[i].Param1 = dtoh32a(&data[PTP_nikon_ec_Param1+PTP_nikon_ec_Size*i]); |
| 2644 | (*ec)[i].Nparam = 1; |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2645 | } |
Linus Walleij | eb8c6fe | 2006-02-03 09:46:22 +0000 | [diff] [blame] | 2646 | } |
| 2647 | |
| 2648 | |
Linus Walleij | b02a066 | 2006-04-25 08:05:09 +0000 | [diff] [blame] | 2649 | static inline uint32_t |
| 2650 | ptp_pack_EK_text(PTPParams *params, PTPEKTextParams *text, unsigned char **data) { |
| 2651 | int i, len = 0; |
| 2652 | uint8_t retlen; |
| 2653 | unsigned char *curdata; |
| 2654 | |
| 2655 | len = 2*(strlen(text->title)+1)+1+ |
| 2656 | 2*(strlen(text->line[0])+1)+1+ |
| 2657 | 2*(strlen(text->line[1])+1)+1+ |
| 2658 | 2*(strlen(text->line[2])+1)+1+ |
| 2659 | 2*(strlen(text->line[3])+1)+1+ |
| 2660 | 2*(strlen(text->line[4])+1)+1+ |
| 2661 | 4*2+2*4+2+4+2+5*4*2; |
| 2662 | *data = malloc(len); |
| 2663 | if (!*data) return 0; |
| 2664 | |
| 2665 | curdata = *data; |
| 2666 | htod16a(curdata,100);curdata+=2; |
| 2667 | htod16a(curdata,1);curdata+=2; |
| 2668 | htod16a(curdata,0);curdata+=2; |
| 2669 | htod16a(curdata,1000);curdata+=2; |
| 2670 | |
| 2671 | htod32a(curdata,0);curdata+=4; |
| 2672 | htod32a(curdata,0);curdata+=4; |
| 2673 | |
| 2674 | htod16a(curdata,6);curdata+=2; |
| 2675 | htod32a(curdata,0);curdata+=4; |
| 2676 | |
| 2677 | ptp_pack_string(params, text->title, curdata, 0, &retlen); curdata+=2*retlen+1;htod16a(curdata,0);curdata+=2; |
| 2678 | htod16a(curdata,0x10);curdata+=2; |
| 2679 | |
| 2680 | for (i=0;i<5;i++) { |
| 2681 | ptp_pack_string(params, text->line[i], curdata, 0, &retlen); curdata+=2*retlen+1;htod16a(curdata,0);curdata+=2; |
| 2682 | htod16a(curdata,0x10);curdata+=2; |
| 2683 | htod16a(curdata,0x01);curdata+=2; |
| 2684 | htod16a(curdata,0x02);curdata+=2; |
| 2685 | htod16a(curdata,0x06);curdata+=2; |
| 2686 | } |
| 2687 | return len; |
| 2688 | } |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 2689 | |
| 2690 | #define ptp_canon_dir_version 0x00 |
| 2691 | #define ptp_canon_dir_ofc 0x02 |
| 2692 | #define ptp_canon_dir_unk1 0x04 |
| 2693 | #define ptp_canon_dir_objectid 0x08 |
| 2694 | #define ptp_canon_dir_parentid 0x0c |
| 2695 | #define ptp_canon_dir_previd 0x10 /* in same dir */ |
| 2696 | #define ptp_canon_dir_nextid 0x14 /* in same dir */ |
| 2697 | #define ptp_canon_dir_nextchild 0x18 /* down one dir */ |
| 2698 | #define ptp_canon_dir_storageid 0x1c /* only in storage entry */ |
| 2699 | #define ptp_canon_dir_name 0x20 |
| 2700 | #define ptp_canon_dir_flags 0x2c |
| 2701 | #define ptp_canon_dir_size 0x30 |
| 2702 | #define ptp_canon_dir_unixtime 0x34 |
| 2703 | #define ptp_canon_dir_year 0x38 |
| 2704 | #define ptp_canon_dir_month 0x39 |
| 2705 | #define ptp_canon_dir_mday 0x3a |
| 2706 | #define ptp_canon_dir_hour 0x3b |
| 2707 | #define ptp_canon_dir_minute 0x3c |
| 2708 | #define ptp_canon_dir_second 0x3d |
| 2709 | #define ptp_canon_dir_unk2 0x3e |
| 2710 | #define ptp_canon_dir_thumbsize 0x40 |
| 2711 | #define ptp_canon_dir_width 0x44 |
| 2712 | #define ptp_canon_dir_height 0x48 |
| 2713 | |
| 2714 | static inline uint16_t |
| 2715 | ptp_unpack_canon_directory ( |
| 2716 | PTPParams *params, |
| 2717 | unsigned char *dir, |
| 2718 | uint32_t cnt, |
| 2719 | PTPObjectHandles *handles, |
| 2720 | PTPObjectInfo **oinfos, /* size(handles->n) */ |
| 2721 | uint32_t **flags /* size(handles->n) */ |
| 2722 | ) { |
| 2723 | unsigned int i, j, nrofobs = 0, curob = 0; |
| 2724 | |
| 2725 | #define ISOBJECT(ptr) (dtoh32a((ptr)+ptp_canon_dir_storageid) == 0xffffffff) |
| 2726 | for (i=0;i<cnt;i++) |
| 2727 | if (ISOBJECT(dir+i*0x4c)) nrofobs++; |
| 2728 | handles->n = nrofobs; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2729 | handles->Handler = calloc(nrofobs,sizeof(handles->Handler[0])); |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 2730 | if (!handles->Handler) return PTP_RC_GeneralError; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2731 | *oinfos = calloc(nrofobs,sizeof((*oinfos)[0])); |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 2732 | if (!*oinfos) return PTP_RC_GeneralError; |
Marcus Meissner | 3d692dc | 2016-02-21 12:34:06 +0100 | [diff] [blame] | 2733 | *flags = calloc(nrofobs,sizeof((*flags)[0])); |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 2734 | if (!*flags) return PTP_RC_GeneralError; |
| 2735 | |
| 2736 | /* Migrate data into objects ids, handles into |
| 2737 | * the object handler array. |
| 2738 | */ |
| 2739 | curob = 0; |
| 2740 | for (i=0;i<cnt;i++) { |
| 2741 | unsigned char *cur = dir+i*0x4c; |
| 2742 | PTPObjectInfo *oi = (*oinfos)+curob; |
| 2743 | |
| 2744 | if (!ISOBJECT(cur)) |
| 2745 | continue; |
| 2746 | |
| 2747 | handles->Handler[curob] = dtoh32a(cur + ptp_canon_dir_objectid); |
| 2748 | oi->StorageID = 0xffffffff; |
| 2749 | oi->ObjectFormat = dtoh16a(cur + ptp_canon_dir_ofc); |
| 2750 | oi->ParentObject = dtoh32a(cur + ptp_canon_dir_parentid); |
| 2751 | oi->Filename = strdup((char*)(cur + ptp_canon_dir_name)); |
| 2752 | oi->ObjectCompressedSize= dtoh32a(cur + ptp_canon_dir_size); |
| 2753 | oi->ThumbCompressedSize = dtoh32a(cur + ptp_canon_dir_thumbsize); |
| 2754 | oi->ImagePixWidth = dtoh32a(cur + ptp_canon_dir_width); |
| 2755 | oi->ImagePixHeight = dtoh32a(cur + ptp_canon_dir_height); |
| 2756 | oi->CaptureDate = oi->ModificationDate = dtoh32a(cur + ptp_canon_dir_unixtime); |
| 2757 | (*flags)[curob] = dtoh32a(cur + ptp_canon_dir_flags); |
| 2758 | curob++; |
| 2759 | } |
| 2760 | /* Walk over Storage ID entries and distribute the IDs to |
| 2761 | * the parent objects. */ |
| 2762 | for (i=0;i<cnt;i++) { |
| 2763 | unsigned char *cur = dir+i*0x4c; |
| 2764 | uint32_t nextchild = dtoh32a(cur + ptp_canon_dir_nextchild); |
| 2765 | |
| 2766 | if (ISOBJECT(cur)) |
| 2767 | continue; |
| 2768 | for (j=0;j<handles->n;j++) if (nextchild == handles->Handler[j]) break; |
| 2769 | if (j == handles->n) continue; |
| 2770 | (*oinfos)[j].StorageID = dtoh32a(cur + ptp_canon_dir_storageid); |
| 2771 | } |
| 2772 | /* Walk over all objects and distribute the storage ids */ |
| 2773 | while (1) { |
Linus Walleij | 2ad5b72 | 2013-11-04 02:07:44 +0100 | [diff] [blame] | 2774 | unsigned int changed = 0; |
Linus Walleij | 7347d0f | 2006-10-23 07:23:39 +0000 | [diff] [blame] | 2775 | for (i=0;i<cnt;i++) { |
| 2776 | unsigned char *cur = dir+i*0x4c; |
| 2777 | uint32_t oid = dtoh32a(cur + ptp_canon_dir_objectid); |
| 2778 | uint32_t nextoid = dtoh32a(cur + ptp_canon_dir_nextid); |
| 2779 | uint32_t nextchild = dtoh32a(cur + ptp_canon_dir_nextchild); |
| 2780 | uint32_t storageid; |
| 2781 | |
| 2782 | if (!ISOBJECT(cur)) |
| 2783 | continue; |
| 2784 | for (j=0;j<handles->n;j++) if (oid == handles->Handler[j]) break; |
| 2785 | if (j == handles->n) { |
| 2786 | /*fprintf(stderr,"did not find oid in lookup pass for current oid\n");*/ |
| 2787 | continue; |
| 2788 | } |
| 2789 | storageid = (*oinfos)[j].StorageID; |
| 2790 | if (storageid == 0xffffffff) continue; |
| 2791 | if (nextoid != 0xffffffff) { |
| 2792 | for (j=0;j<handles->n;j++) if (nextoid == handles->Handler[j]) break; |
| 2793 | if (j == handles->n) { |
| 2794 | /*fprintf(stderr,"did not find oid in lookup pass for next oid\n");*/ |
| 2795 | continue; |
| 2796 | } |
| 2797 | if ((*oinfos)[j].StorageID == 0xffffffff) { |
| 2798 | (*oinfos)[j].StorageID = storageid; |
| 2799 | changed++; |
| 2800 | } |
| 2801 | } |
| 2802 | if (nextchild != 0xffffffff) { |
| 2803 | for (j=0;j<handles->n;j++) if (nextchild == handles->Handler[j]) break; |
| 2804 | if (j == handles->n) { |
| 2805 | /*fprintf(stderr,"did not find oid in lookup pass for next child\n");*/ |
| 2806 | continue; |
| 2807 | } |
| 2808 | if ((*oinfos)[j].StorageID == 0xffffffff) { |
| 2809 | (*oinfos)[j].StorageID = storageid; |
| 2810 | changed++; |
| 2811 | } |
| 2812 | } |
| 2813 | } |
| 2814 | /* Check if we: |
| 2815 | * - changed no entry (nothing more to do) |
| 2816 | * - changed all of them at once (usually happens) |
| 2817 | * break if we do. |
| 2818 | */ |
| 2819 | if (!changed || (changed==nrofobs-1)) |
| 2820 | break; |
| 2821 | } |
| 2822 | #undef ISOBJECT |
| 2823 | return PTP_RC_OK; |
| 2824 | } |