1 /* exif-data.c
2 *
3 * Copyright (c) 2001 Lutz Mueller <lutz@users.sourceforge.net>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301 USA.
19 */
20
21 #include <config.h>
22
23 #include <libexif/exif-mnote-data.h>
24 #include <libexif/exif-data.h>
25 #include <libexif/exif-ifd.h>
26 #include <libexif/exif-mnote-data-priv.h>
27 #include <libexif/exif-utils.h>
28 #include <libexif/exif-loader.h>
29 #include <libexif/exif-log.h>
30 #include <libexif/i18n.h>
31 #include <libexif/exif-system.h>
32
33 #include <libexif/apple/exif-mnote-data-apple.h>
34 #include <libexif/canon/exif-mnote-data-canon.h>
35 #include <libexif/fuji/exif-mnote-data-fuji.h>
36 #include <libexif/olympus/exif-mnote-data-olympus.h>
37 #include <libexif/pentax/exif-mnote-data-pentax.h>
38 #include <libexif/huawei/exif-mnote-data-huawei.h>
39
40 #include <math.h>
41 #include <stdlib.h>
42 #include <stdio.h>
43 #include <string.h>
44
45 #undef JPEG_MARKER_SOI
46 #define JPEG_MARKER_SOI 0xd8
47 #undef JPEG_MARKER_APP0
48 #define JPEG_MARKER_APP0 0xe0
49 #undef JPEG_MARKER_APP1
50 #define JPEG_MARKER_APP1 0xe1
51 #undef JPEG_HEADER_LEN
52 #define JPEG_HEADER_LEN 6
53
54 #define CHECKOVERFLOW(offset,datasize,structsize) (( offset >= datasize) || (structsize > datasize) || (offset > datasize - structsize ))
55
56 static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
57
58 struct _ExifDataPrivate
59 {
60 ExifByteOrder order;
61
62 ExifMnoteData *md;
63
64 ExifLog *log;
65 ExifMem *mem;
66
67 unsigned int ref_count;
68
69 /* Temporarily used while loading data */
70 unsigned int offset_mnote;
71
72 ExifDataOption options;
73 ExifDataType data_type;
74 };
75
76 static void *
exif_data_alloc(ExifData * data,unsigned int i)77 exif_data_alloc (ExifData *data, unsigned int i)
78 {
79 void *d;
80
81 if (!data || !i)
82 return NULL;
83
84 d = exif_mem_alloc (data->priv->mem, i);
85 if (d)
86 return d;
87
88 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
89 return NULL;
90 }
91
92 ExifMnoteData *
exif_data_get_mnote_data(ExifData * d)93 exif_data_get_mnote_data (ExifData *d)
94 {
95 return (d && d->priv) ? d->priv->md : NULL;
96 }
97
98 ExifMem *
exif_data_get_priv_mem(ExifData * d)99 exif_data_get_priv_mem (ExifData *d)
100 {
101 return (d && d->priv) ? d->priv->mem : NULL;
102 }
103
104 void
exif_data_set_priv_md(ExifData * d,ExifMnoteData * md)105 exif_data_set_priv_md (ExifData *d, ExifMnoteData *md)
106 {
107 if (d && d->priv) {
108 d->priv->md = md;
109 }
110 }
111
112 ExifData *
exif_data_new(void)113 exif_data_new (void)
114 {
115 ExifMem *mem = exif_mem_new_default ();
116 ExifData *d = exif_data_new_mem (mem);
117
118 exif_mem_unref (mem);
119
120 return d;
121 }
122
123 ExifData *
exif_data_new_mem(ExifMem * mem)124 exif_data_new_mem (ExifMem *mem)
125 {
126 ExifData *data;
127 unsigned int i;
128
129 if (!mem)
130 return NULL;
131
132 data = exif_mem_alloc (mem, sizeof (ExifData));
133 if (!data)
134 return (NULL);
135 data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
136 if (!data->priv) {
137 exif_mem_free (mem, data);
138 return (NULL);
139 }
140 data->priv->ref_count = 1;
141
142 data->priv->mem = mem;
143 exif_mem_ref (mem);
144
145 for (i = 0; i < EXIF_IFD_COUNT; i++) {
146 data->ifd[i] = exif_content_new_mem (data->priv->mem);
147 if (!data->ifd[i]) {
148 exif_data_free (data);
149 return (NULL);
150 }
151 data->ifd[i]->parent = data;
152 }
153
154 /* Default options */
155 #ifndef NO_VERBOSE_TAG_STRINGS
156 /*
157 * When the tag list is compiled away, setting this option prevents
158 * any tags from being loaded
159 */
160 exif_data_set_option (data, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS);
161 #endif
162 exif_data_set_option (data, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
163
164 /* Default data type: none */
165 exif_data_set_data_type (data, EXIF_DATA_TYPE_COUNT);
166
167 return (data);
168 }
169
170 ExifData *
exif_data_new_from_data(const unsigned char * data,unsigned int size)171 exif_data_new_from_data (const unsigned char *data, unsigned int size)
172 {
173 ExifData *edata;
174
175 edata = exif_data_new ();
176 exif_data_load_data (edata, data, size);
177 return (edata);
178 }
179
180 static int
exif_data_load_data_entry(ExifData * data,ExifEntry * entry,const unsigned char * d,unsigned int size,unsigned int offset)181 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
182 const unsigned char *d,
183 unsigned int size, unsigned int offset)
184 {
185 unsigned int s, doff;
186
187 entry->tag = exif_get_short (d + offset + 0, data->priv->order);
188 entry->format = exif_get_short (d + offset + 2, data->priv->order);
189 entry->components = exif_get_long (d + offset + 4, data->priv->order);
190
191 /* FIXME: should use exif_tag_get_name_in_ifd here but entry->parent
192 * has not been set yet
193 */
194 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
195 "Loading entry 0x%x ('%s')...", entry->tag,
196 exif_tag_get_name (entry->tag));
197
198 /* {0,1,2,4,8} x { 0x00000000 .. 0xffffffff }
199 * -> { 0x000000000 .. 0x7fffffff8 } */
200 s = exif_format_get_size(entry->format) * entry->components;
201 if ((s < entry->components) || (s == 0)){
202 return 0;
203 }
204
205 /*
206 * Size? If bigger than 4 bytes, the actual data is not
207 * in the entry but somewhere else (offset).
208 */
209 if (s > 4)
210 doff = exif_get_long (d + offset + 8, data->priv->order);
211 else
212 doff = offset + 8;
213
214 /* Sanity checks */
215 if (doff >= size) {
216 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
217 "Tag starts past end of buffer (%u > %u)", doff, size);
218 return 0;
219 }
220
221 if (s > size - doff) {
222 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
223 "Tag data goes past end of buffer (%u > %u)", doff+s, size);
224 return 0;
225 }
226
227 entry->data = exif_data_alloc (data, s);
228 if (entry->data) {
229 entry->size = s;
230 memcpy (entry->data, d + doff, s);
231 entry->offset = doff;
232 } else {
233 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
234 return 0;
235 }
236
237 /* If this is the MakerNote, remember the offset */
238 if (entry->tag == EXIF_TAG_MAKER_NOTE) {
239 if (!entry->data) {
240 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
241 "MakerNote found with empty data");
242 } else if (entry->size > 6) {
243 exif_log (data->priv->log,
244 EXIF_LOG_CODE_DEBUG, "ExifData",
245 "MakerNote found (%02x %02x %02x %02x "
246 "%02x %02x %02x...).",
247 entry->data[0], entry->data[1], entry->data[2],
248 entry->data[3], entry->data[4], entry->data[5],
249 entry->data[6]);
250 }
251
252 if (!data->priv->offset_mnote) {
253 data->priv->offset_mnote = doff;
254 }
255 if (entry->data && (entry->size >= 8) &&
256 !memcmp(entry->data, HUAWEI_HEADER, 8)) {
257 data->priv->offset_mnote = doff;
258 }
259 }
260 return 1;
261 }
262
263 static void
exif_data_save_data_entry(ExifData * data,ExifEntry * e,unsigned char ** d,unsigned int * ds,unsigned int offset)264 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
265 unsigned char **d, unsigned int *ds,
266 unsigned int offset)
267 {
268 unsigned int doff, s;
269 unsigned int ts;
270
271 if (!data || !data->priv)
272 return;
273
274 /*
275 * Each entry is 12 bytes long. The memory for the entry has
276 * already been allocated.
277 */
278 exif_set_short (*d + 6 + offset + 0,
279 data->priv->order, (ExifShort) e->tag);
280 exif_set_short (*d + 6 + offset + 2,
281 data->priv->order, (ExifShort) e->format);
282
283 if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
284 /* If this is the maker note tag, update it. */
285 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
286 if (is_huawei_md(data->priv->md) &&
287 e->data && (e->size >= 8) &&
288 !memcmp(e->data, HUAWEI_HEADER, 8)) {
289 /* TODO: this is using the wrong ExifMem to free e->data */
290 exif_mem_free (data->priv->mem, e->data);
291 e->data = NULL;
292 e->size = 0;
293 exif_mnote_data_set_offset (data->priv->md, *ds - 6);
294 exif_mnote_data_save (data->priv->md, &e->data, &e->size);
295 e->components = e->size;
296 if (exif_format_get_size (e->format) != 1) {
297 /* e->format is taken from input code,
298 * but we need to make sure it is a 1 byte
299 * entity due to the multiplication below. */
300 e->format = EXIF_FORMAT_UNDEFINED;
301 }
302 }
303 }
304 }
305
306 exif_set_long (*d + 6 + offset + 4,
307 data->priv->order, e->components);
308
309 /*
310 * Size? If bigger than 4 bytes, the actual data is not in
311 * the entry but somewhere else.
312 */
313 s = exif_format_get_size (e->format) * e->components;
314 if (s > 4) {
315 unsigned char *t;
316 doff = *ds - 6;
317 ts = *ds + s;
318
319 /*
320 * According to the TIFF specification,
321 * the offset must be an even number. If we need to introduce
322 * a padding byte, we set it to 0.
323 */
324 if (s & 1)
325 ts++;
326 t = exif_mem_realloc (data->priv->mem, *d, ts);
327 if (!t) {
328 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
329 return;
330 }
331 *d = t;
332 *ds = ts;
333 exif_set_long (*d + 6 + offset + 8, data->priv->order, doff);
334 if (s & 1)
335 *(*d + *ds - 1) = '\0';
336
337 } else
338 doff = offset + 8;
339
340 /* Write the data. Fill unneeded bytes with 0. Do not crash with
341 * e->data is NULL */
342 if (e->data) {
343 unsigned int len = s;
344 if (e->size < s) len = e->size;
345 memcpy (*d + 6 + doff, e->data, len);
346 } else {
347 memset (*d + 6 + doff, 0, s);
348 }
349 if (s < 4)
350 memset (*d + 6 + doff + s, 0, (4 - s));
351 }
352
353 static void
exif_data_save_data_entry_general(ExifData * data,ExifEntry * e,unsigned char ** d,unsigned int * ds,unsigned int offset)354 exif_data_save_data_entry_general (ExifData *data, ExifEntry *e,
355 unsigned char **d, unsigned int *ds,
356 unsigned int offset)
357 {
358 unsigned int doff, s;
359 unsigned int ts;
360
361 if (!data || !data->priv)
362 return;
363
364 /*
365 * Each entry is 12 bytes long. The memory for the entry has
366 * already been allocated.
367 */
368 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0,
369 data->priv->order, (ExifShort)e->tag);
370 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2,
371 data->priv->order, (ExifShort)e->format);
372
373 if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
374 /* If this is the maker note tag, update it. */
375 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
376 if (is_huawei_md(data->priv->md) &&
377 e->data && (e->size >= 8) &&
378 !memcmp(e->data, HUAWEI_HEADER, 8)) {
379 /* TODO: this is using the wrong ExifMem to free e->data */
380 exif_mem_free(data->priv->mem, e->data);
381 e->data = NULL;
382 e->size = 0;
383 exif_mnote_data_set_offset(data->priv->md, *ds - 6 + JPEG_HEADER_LEN);
384 exif_mnote_data_save(data->priv->md, &e->data, &e->size);
385 e->components = e->size;
386 if (exif_format_get_size(e->format) != 1) {
387 /* e->format is taken from input code,
388 * but we need to make sure it is a 1 byte
389 * entity due to the multiplication below. */
390 e->format = EXIF_FORMAT_UNDEFINED;
391 }
392 }
393 }
394 }
395
396 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4,
397 data->priv->order, e->components);
398
399 /*
400 * Size? If bigger than 4 bytes, the actual data is not in
401 * the entry but somewhere else.
402 */
403 s = exif_format_get_size(e->format) * e->components;
404 if (s > 4) {
405 unsigned char* t;
406 doff = *ds - 6 + JPEG_HEADER_LEN;
407 ts = *ds + s;
408
409 /*
410 * According to the TIFF specification,
411 * the offset must be an even number. If we need to introduce
412 * a padding byte, we set it to 0.
413 */
414 if (s & 1)
415 ts++;
416 t = exif_mem_realloc(data->priv->mem, *d, ts);
417 if (!t) {
418 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", ts);
419 return;
420 }
421 *d = t;
422 *ds = ts;
423 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order, doff);
424 if (s & 1)
425 *(*d + *ds - 1) = '\0';
426
427 } else
428 doff = offset + 8;
429
430 /* Write the data. Fill unneeded bytes with 0. Do not crash with
431 * e->data is NULL */
432 if (e->data) {
433 unsigned int len = s;
434 if (e->size < s) len = e->size;
435 if (CHECKOVERFLOW(6 - JPEG_HEADER_LEN + doff, *ds, len)) return;
436 memcpy(*d + 6 - JPEG_HEADER_LEN + doff, e->data, len);
437 } else {
438 memset(*d + 6 - JPEG_HEADER_LEN + doff, 0, s);
439 }
440 if (s < 4)
441 memset(*d + 6 - JPEG_HEADER_LEN + doff + s, 0, (4 - s));
442 }
443
444 static void
exif_data_load_data_thumbnail(ExifData * data,const unsigned char * d,unsigned int ds,ExifLong o,ExifLong s)445 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
446 unsigned int ds, ExifLong o, ExifLong s)
447 {
448 /* Sanity checks */
449 if (o >= ds) {
450 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail offset (%u).", o);
451 return;
452 }
453 if (CHECKOVERFLOW(o,ds,s)) {
454 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail size (%u), max would be %u.", s, ds-o);
455 return;
456 }
457 if (data->data)
458 exif_mem_free (data->priv->mem, data->data);
459 if (!(data->data = exif_data_alloc (data, s))) {
460 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
461 data->size = 0;
462 return;
463 }
464 data->size = s;
465 memcpy (data->data, d + o, s);
466 }
467
468 #undef CHECK_REC
469 #define CHECK_REC(i) \
470 if ((i) == ifd) { \
471 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
472 "ExifData", "Recursive entry in IFD " \
473 "'%s' detected. Skipping...", \
474 exif_ifd_get_name (i)); \
475 break; \
476 } \
477 if (data->ifd[(i)]->count) { \
478 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
479 "ExifData", "Attempt to load IFD " \
480 "'%s' multiple times detected. " \
481 "Skipping...", \
482 exif_ifd_get_name (i)); \
483 break; \
484 }
485
486 /*! Calculate the recursion cost added by one level of IFD loading.
487 *
488 * The work performed is related to the cost in the exponential relation
489 * work=1.1**cost
490 */
491 static unsigned int
level_cost(unsigned int n)492 level_cost(unsigned int n)
493 {
494 static const double log_1_1 = 0.09531017980432493;
495
496 /* Adding 0.1 protects against the case where n==1 */
497 return ceil(log(n + 0.1)/log_1_1);
498 }
499
500 static void
load_thumbnail_entry(ExifData * data,ExifTag tag,ExifIfd ifd,const unsigned char * d,unsigned int ds,unsigned int offset,unsigned i)501 load_thumbnail_entry (ExifData *data, ExifTag tag, ExifIfd ifd,
502 const unsigned char *d,
503 unsigned int ds, unsigned int offset, unsigned i)
504 {
505 /*
506 * If we don't know the tag, don't fail. It could be that new
507 * versions of the standard have defined additional tags. Note that
508 * 0 is a valid tag in the GPS IFD.
509 */
510 if (!exif_tag_get_name_in_ifd (tag, ifd)) {
511
512 /*
513 * Special case: Tag and format 0. That's against specification
514 * (at least up to 2.2). But Photoshop writes it anyways.
515 */
516 if (!d || CHECKOVERFLOW(offset + 12 * i, ds, 4) ||
517 !memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
518 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
519 "Skipping empty entry at position %u in '%s'.", i,
520 exif_ifd_get_name (ifd));
521 return;
522 }
523 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
524 "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
525 "to <libexif-devel@lists.sourceforge.net>.", tag, i,
526 exif_ifd_get_name (ifd));
527 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
528 return;
529 }
530 ExifEntry *entry = exif_entry_new_mem (data->priv->mem);
531 if (!entry) {
532 exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
533 "Could not allocate memory");
534 return;
535 }
536 if (exif_data_load_data_entry (data, entry, d, ds,
537 offset + 12 * i))
538 exif_content_add_entry (data->ifd[ifd], entry);
539 exif_entry_unref (entry);
540 }
541
542 /*! Load data for an IFD.
543 *
544 * \param[in,out] data #ExifData
545 * \param[in] ifd IFD to load
546 * \param[in] d pointer to buffer containing raw IFD data
547 * \param[in] ds size of raw data in buffer at \c d
548 * \param[in] offset offset into buffer at \c d at which IFD starts
549 * \param[in] recursion_cost factor indicating how expensive this recursive
550 * call could be
551 */
552 static void
exif_data_load_data_content(ExifData * data,ExifIfd ifd,const unsigned char * d,unsigned int ds,unsigned int offset,unsigned int recursion_cost)553 exif_data_load_data_content (ExifData *data, ExifIfd ifd,
554 const unsigned char *d,
555 unsigned int ds, unsigned int offset, unsigned int recursion_cost)
556 {
557 ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
558 ExifShort n;
559 ExifEntry *entry;
560 unsigned int i;
561 ExifTag tag;
562
563 if (!data || !data->priv)
564 return;
565
566 /* check for valid ExifIfd enum range */
567 if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
568 return;
569
570 if (recursion_cost > 170) {
571 /*
572 * recursion_cost is a logarithmic-scale indicator of how expensive this
573 * recursive call might end up being. It is an indicator of the depth of
574 * recursion as well as the potential for worst-case future recursive
575 * calls. Since it's difficult to tell ahead of time how often recursion
576 * will occur, this assumes the worst by assuming every tag could end up
577 * causing recursion.
578 * The value of 170 was chosen to limit typical EXIF structures to a
579 * recursive depth of about 6, but pathological ones (those with very
580 * many tags) to only 2.
581 */
582 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
583 "Deep/expensive recursion detected!");
584 return;
585 }
586
587 /* Read the number of entries */
588 if (CHECKOVERFLOW(offset, ds, 2)) {
589 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
590 "Tag data past end of buffer (%u+2 > %u)", offset, ds);
591 return;
592 }
593 n = exif_get_short (d + offset, data->priv->order);
594 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
595 "Loading %hu entries...", n);
596 offset += 2;
597
598 /* Check if we have enough data. */
599 if (CHECKOVERFLOW(offset, ds, 12*n)) {
600 n = (ds - offset) / 12;
601 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
602 "Short data; only loading %hu entries...", n);
603 }
604
605 for (i = 0; i < n; i++) {
606
607 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
608 switch (tag) {
609 case EXIF_TAG_EXIF_IFD_POINTER:
610 case EXIF_TAG_GPS_INFO_IFD_POINTER:
611 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
612 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
613 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
614 o = exif_get_long (d + offset + 12 * i + 8,
615 data->priv->order);
616 if (o >= ds) {
617 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
618 "Tag data past end of buffer (%u > %u)", offset+2, ds);
619 return;
620 }
621 /* FIXME: IFD_POINTER tags aren't marked as being in a
622 * specific IFD, so exif_tag_get_name_in_ifd won't work
623 */
624 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
625 "Sub-IFD entry 0x%x ('%s') at %u.", tag,
626 exif_tag_get_name(tag), o);
627 switch (tag) {
628 case EXIF_TAG_EXIF_IFD_POINTER:
629 CHECK_REC (EXIF_IFD_EXIF);
630 exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
631 recursion_cost + level_cost(n));
632 break;
633 case EXIF_TAG_GPS_INFO_IFD_POINTER:
634 CHECK_REC (EXIF_IFD_GPS);
635 exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
636 recursion_cost + level_cost(n));
637 break;
638 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
639 CHECK_REC (EXIF_IFD_INTEROPERABILITY);
640 exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
641 recursion_cost + level_cost(n));
642 break;
643 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
644 thumbnail_offset = o;
645 if (thumbnail_offset && thumbnail_length)
646 exif_data_load_data_thumbnail (data, d,
647 ds, thumbnail_offset,
648 thumbnail_length);
649 load_thumbnail_entry(data, tag, ifd, d, ds, offset, i);
650 break;
651 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
652 thumbnail_length = o;
653 if (thumbnail_offset && thumbnail_length)
654 exif_data_load_data_thumbnail (data, d,
655 ds, thumbnail_offset,
656 thumbnail_length);
657 load_thumbnail_entry(data, tag, ifd, d, ds, offset, i);
658 break;
659 default:
660 return;
661 }
662 break;
663 default:
664 /*
665 * If we don't know the tag, don't fail. It could be that new
666 * versions of the standard have defined additional tags. Note that
667 * 0 is a valid tag in the GPS IFD.
668 */
669 if (!exif_tag_get_name_in_ifd (tag, ifd)) {
670
671 /*
672 * Special case: Tag and format 0. That's against specification
673 * (at least up to 2.2). But Photoshop writes it anyways.
674 */
675 if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
676 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
677 "Skipping empty entry at position %u in '%s'.", i,
678 exif_ifd_get_name (ifd));
679 break;
680 }
681 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
682 "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
683 "to <libexif-devel@lists.sourceforge.net>.", tag, i,
684 exif_ifd_get_name (ifd));
685 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
686 break;
687 }
688 entry = exif_entry_new_mem (data->priv->mem);
689 if (!entry) {
690 exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
691 "Could not allocate memory");
692 return;
693 }
694 if (exif_data_load_data_entry (data, entry, d, ds,
695 offset + 12 * i))
696 exif_content_add_entry (data->ifd[ifd], entry);
697 exif_entry_unref (entry);
698 break;
699 }
700 }
701 }
702
703 static int
cmp_func(const unsigned char * p1,const unsigned char * p2,ExifByteOrder o)704 cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o)
705 {
706 ExifShort tag1 = exif_get_short (p1, o);
707 ExifShort tag2 = exif_get_short (p2, o);
708
709 return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0;
710 }
711
712 static int
cmp_func_intel(const void * elem1,const void * elem2)713 cmp_func_intel (const void *elem1, const void *elem2)
714 {
715 return cmp_func ((const unsigned char *) elem1,
716 (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
717 }
718
719 static int
cmp_func_motorola(const void * elem1,const void * elem2)720 cmp_func_motorola (const void *elem1, const void *elem2)
721 {
722 return cmp_func ((const unsigned char *) elem1,
723 (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
724 }
725
726 static void
exif_data_save_data_content(ExifData * data,ExifContent * ifd,unsigned char ** d,unsigned int * ds,unsigned int offset)727 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
728 unsigned char **d, unsigned int *ds,
729 unsigned int offset)
730 {
731 unsigned int j, n_ptr = 0, n_thumb = 0;
732 ExifIfd i;
733 unsigned char *t;
734 unsigned int ts;
735 unsigned int icount = 0;
736
737 if (!data || !data->priv || !ifd || !d || !ds)
738 return;
739
740 for (i = 0; i < EXIF_IFD_COUNT; i++)
741 if (ifd == data->ifd[i])
742 break;
743 if (i == EXIF_IFD_COUNT)
744 return; /* error */
745
746 /*
747 * Check if we need some extra entries for pointers or the thumbnail.
748 */
749 switch (i) {
750 case EXIF_IFD_0:
751
752 /*
753 * The pointer to IFD_EXIF is in IFD_0. The pointer to
754 * IFD_INTEROPERABILITY is in IFD_EXIF.
755 */
756 if (data->ifd[EXIF_IFD_EXIF]->count ||
757 data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
758 n_ptr++;
759
760 /* The pointer to IFD_GPS is in IFD_0. */
761 if (data->ifd[EXIF_IFD_GPS]->count)
762 n_ptr++;
763
764 break;
765 case EXIF_IFD_1:
766 if (data->size)
767 n_thumb = 2;
768 for (j = 0; j < ifd->count; j++) {
769 if (ifd->entries[j]->tag == EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH ||
770 ifd->entries[j]->tag == EXIF_TAG_JPEG_INTERCHANGE_FORMAT) {
771 icount++;
772 }
773 }
774 ifd->count = ifd->count - icount;
775 break;
776 case EXIF_IFD_EXIF:
777 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
778 n_ptr++;
779 default:
780 break;
781 }
782
783 /*
784 * Allocate enough memory for all entries
785 * and the number of entries.
786 */
787 ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
788 t = exif_mem_realloc (data->priv->mem, *d, ts);
789 if (!t) {
790 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
791 return;
792 }
793 *d = t;
794 *ds = ts;
795
796 /* Save the number of entries */
797 exif_set_short (*d + 6 + offset, data->priv->order,
798 (ExifShort) (ifd->count + n_ptr + n_thumb));
799 offset += 2;
800
801 /*
802 * Save each entry. Make sure that no memcpys from NULL pointers are
803 * performed
804 */
805 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
806 "Saving %i entries (IFD '%s', offset: %i)...",
807 ifd->count, exif_ifd_get_name (i), offset);
808 for (j = 0; j < ifd->count; j++) {
809 if (i == EXIF_IFD_1 &&
810 (ifd->entries[j]->tag == EXIF_TAG_JPEG_INTERCHANGE_FORMAT ||
811 ifd->entries[j]->tag == EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH))
812 continue;
813 if (ifd->entries[j]) {
814 exif_data_save_data_entry (data, ifd->entries[j], d, ds,
815 offset + 12 * j);
816 }
817 }
818
819 offset += 12 * ifd->count;
820
821 /* Now save special entries. */
822 switch (i) {
823 case EXIF_IFD_0:
824
825 /*
826 * The pointer to IFD_EXIF is in IFD_0.
827 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
828 * therefore, if IFD_INTEROPERABILITY is not empty, we need
829 * IFD_EXIF even if latter is empty.
830 */
831 if (data->ifd[EXIF_IFD_EXIF]->count ||
832 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
833 exif_set_short (*d + 6 + offset + 0, data->priv->order,
834 EXIF_TAG_EXIF_IFD_POINTER);
835 exif_set_short (*d + 6 + offset + 2, data->priv->order,
836 EXIF_FORMAT_LONG);
837 exif_set_long (*d + 6 + offset + 4, data->priv->order,
838 1);
839 exif_set_long (*d + 6 + offset + 8, data->priv->order,
840 *ds - 6);
841 exif_data_save_data_content (data,
842 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
843 offset += 12;
844 }
845
846 /* The pointer to IFD_GPS is in IFD_0, too. */
847 if (data->ifd[EXIF_IFD_GPS]->count) {
848 exif_set_short (*d + 6 + offset + 0, data->priv->order,
849 EXIF_TAG_GPS_INFO_IFD_POINTER);
850 exif_set_short (*d + 6 + offset + 2, data->priv->order,
851 EXIF_FORMAT_LONG);
852 exif_set_long (*d + 6 + offset + 4, data->priv->order,
853 1);
854 exif_set_long (*d + 6 + offset + 8, data->priv->order,
855 *ds - 6);
856 exif_data_save_data_content (data,
857 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
858 offset += 12;
859 }
860
861 break;
862 case EXIF_IFD_EXIF:
863
864 /*
865 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
866 * See note above.
867 */
868 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
869 exif_set_short (*d + 6 + offset + 0, data->priv->order,
870 EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
871 exif_set_short (*d + 6 + offset + 2, data->priv->order,
872 EXIF_FORMAT_LONG);
873 exif_set_long (*d + 6 + offset + 4, data->priv->order,
874 1);
875 exif_set_long (*d + 6 + offset + 8, data->priv->order,
876 *ds - 6);
877 exif_data_save_data_content (data,
878 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
879 *ds - 6);
880 offset += 12;
881 }
882
883 break;
884 case EXIF_IFD_1:
885
886 /*
887 * Information about the thumbnail (if any) is saved in
888 * IFD_1.
889 */
890 if (data->size) {
891
892 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
893 exif_set_short (*d + 6 + offset + 0, data->priv->order,
894 EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
895 exif_set_short (*d + 6 + offset + 2, data->priv->order,
896 EXIF_FORMAT_LONG);
897 exif_set_long (*d + 6 + offset + 4, data->priv->order,
898 1);
899 exif_set_long (*d + 6 + offset + 8, data->priv->order,
900 *ds - 6);
901 ts = *ds + data->size;
902 t = exif_mem_realloc (data->priv->mem, *d, ts);
903 if (!t) {
904 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
905 ts);
906 return;
907 }
908 *d = t;
909 *ds = ts;
910 memcpy (*d + *ds - data->size, data->data, data->size);
911 offset += 12;
912
913 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
914 exif_set_short (*d + 6 + offset + 0, data->priv->order,
915 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
916 exif_set_short (*d + 6 + offset + 2, data->priv->order,
917 EXIF_FORMAT_LONG);
918 exif_set_long (*d + 6 + offset + 4, data->priv->order,
919 1);
920 exif_set_long (*d + 6 + offset + 8, data->priv->order,
921 data->size);
922 offset += 12;
923 }
924
925 break;
926 default:
927 break;
928 }
929
930 /* Sort the directory according to TIFF specification */
931 qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12,
932 (ifd->count + n_ptr + n_thumb), 12,
933 (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
934
935 /* Correctly terminate the directory */
936 if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
937 data->size)) {
938
939 /*
940 * We are saving IFD 0. Tell where IFD 1 starts and save
941 * IFD 1.
942 */
943 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
944 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
945 *ds - 6);
946 } else
947 exif_set_long (*d + 6 + offset, data->priv->order, 0);
948 }
949
950 static void
exif_data_save_data_content_general(ExifData * data,ExifContent * ifd,unsigned char ** d,unsigned int * ds,unsigned int offset)951 exif_data_save_data_content_general (ExifData* data, ExifContent* ifd,
952 unsigned char** d, unsigned int* ds,
953 unsigned int offset)
954 {
955 unsigned int j, n_ptr = 0, n_thumb = 0;
956 ExifIfd i;
957 unsigned char* t;
958 unsigned int ts;
959
960 if (!data || !data->priv || !ifd || !d || !ds)
961 return;
962
963 for (i = 0; i < EXIF_IFD_COUNT; i++)
964 if (ifd == data->ifd[i])
965 break;
966 if (i == EXIF_IFD_COUNT)
967 return; /* error */
968
969 /*
970 * Check if we need some extra entries for pointers or the thumbnail.
971 */
972 switch (i) {
973 case EXIF_IFD_0:
974
975 /*
976 * The pointer to IFD_EXIF is in IFD_0. The pointer to
977 * IFD_INTEROPERABILITY is in IFD_EXIF.
978 */
979 if (data->ifd[EXIF_IFD_EXIF]->count ||
980 data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
981 n_ptr++;
982
983 /* The pointer to IFD_GPS is in IFD_0. */
984 if (data->ifd[EXIF_IFD_GPS]->count)
985 n_ptr++;
986
987 break;
988 case EXIF_IFD_1:
989 if (data->size)
990 n_thumb = 2;
991 break;
992 case EXIF_IFD_EXIF:
993 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
994 n_ptr++;
995 default:
996 break;
997 }
998
999 /*
1000 * Allocate enough memory for all entries
1001 * and the number of entries.
1002 */
1003 ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
1004 t = exif_mem_realloc(data->priv->mem, *d, ts);
1005 if (!t) {
1006 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", ts);
1007 return;
1008 }
1009 *d = t;
1010 *ds = ts;
1011
1012 /* Save the number of entries */
1013 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset, data->priv->order,
1014 (ExifShort)(ifd->count + n_ptr + n_thumb));
1015 offset += 2;
1016
1017 /*
1018 * Save each entry. Make sure that no memcpys from NULL pointers are
1019 * performed
1020 */
1021 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1022 "Saving %i entries (IFD '%s', offset: %i)...",
1023 ifd->count, exif_ifd_get_name(i), offset);
1024 printf("current ifd->count %u\n", ifd->count);
1025 for (j = 0; j < ifd->count; j++) {
1026 if (ifd->entries[j]) {
1027 exif_data_save_data_entry_general(data, ifd->entries[j], d, ds,
1028 offset + 12 * j);
1029 }
1030 }
1031
1032 offset += 12 * ifd->count;
1033
1034 /* Now save special entries. */
1035 switch (i) {
1036 case EXIF_IFD_0:
1037
1038 /*
1039 * The pointer to IFD_EXIF is in IFD_0.
1040 * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
1041 * therefore, if IFD_INTEROPERABILITY is not empty, we need
1042 * IFD_EXIF even if latter is empty.
1043 */
1044 if (data->ifd[EXIF_IFD_EXIF]->count ||
1045 data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
1046 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0, data->priv->order,
1047 EXIF_TAG_EXIF_IFD_POINTER);
1048 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2, data->priv->order,
1049 EXIF_FORMAT_LONG);
1050 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4, data->priv->order,
1051 1);
1052 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order,
1053 *ds - 6 + JPEG_HEADER_LEN);
1054 exif_data_save_data_content_general(data,
1055 data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6 + JPEG_HEADER_LEN);
1056 offset += 12;
1057 }
1058
1059 /* The pointer to IFD_GPS is in IFD_0, too. */
1060 if (data->ifd[EXIF_IFD_GPS]->count) {
1061 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0, data->priv->order,
1062 EXIF_TAG_GPS_INFO_IFD_POINTER);
1063 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2, data->priv->order,
1064 EXIF_FORMAT_LONG);
1065 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4, data->priv->order,
1066 1);
1067 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order,
1068 *ds - 6 + JPEG_HEADER_LEN);
1069 exif_data_save_data_content_general(data,
1070 data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6 + JPEG_HEADER_LEN);
1071 offset += 12;
1072 }
1073
1074 break;
1075 case EXIF_IFD_EXIF:
1076
1077 /*
1078 * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
1079 * See note above.
1080 */
1081 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
1082 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0, data->priv->order,
1083 EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
1084 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2, data->priv->order,
1085 EXIF_FORMAT_LONG);
1086 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4, data->priv->order,
1087 1);
1088 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order,
1089 *ds - 6 + JPEG_HEADER_LEN);
1090 exif_data_save_data_content_general(data,
1091 data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
1092 *ds - 6 + JPEG_HEADER_LEN);
1093 offset += 12;
1094 }
1095
1096 break;
1097 case EXIF_IFD_1:
1098
1099 /*
1100 * Information about the thumbnail (if any) is saved in
1101 * IFD_1.
1102 */
1103 if (data->size) {
1104
1105 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
1106 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0, data->priv->order,
1107 EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
1108 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2, data->priv->order,
1109 EXIF_FORMAT_LONG);
1110 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4, data->priv->order,
1111 1);
1112 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order,
1113 *ds - 6 + JPEG_HEADER_LEN);
1114 ts = *ds + data->size;
1115 t = exif_mem_realloc(data->priv->mem, *d, ts);
1116 if (!t) {
1117 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData",
1118 ts);
1119 return;
1120 }
1121 *d = t;
1122 *ds = ts;
1123 memcpy(*d + *ds - data->size, data->data, data->size);
1124 offset += 12;
1125
1126 /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
1127 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 0, data->priv->order,
1128 EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
1129 exif_set_short(*d + 6 - JPEG_HEADER_LEN + offset + 2, data->priv->order,
1130 EXIF_FORMAT_LONG);
1131 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 4, data->priv->order,
1132 1);
1133 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset + 8, data->priv->order,
1134 data->size);
1135 offset += 12;
1136 }
1137
1138 break;
1139 default:
1140 break;
1141 }
1142
1143 /* Sort the directory according to TIFF specification */
1144 qsort(*d + 6 - JPEG_HEADER_LEN + offset - (ifd->count + n_ptr + n_thumb) * 12,
1145 (ifd->count + n_ptr + n_thumb), 12,
1146 (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
1147
1148 /* Correctly terminate the directory */
1149 if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
1150 data->size)) {
1151
1152 /*
1153 * We are saving IFD 0. Tell where IFD 1 starts and save
1154 * IFD 1.
1155 */
1156 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset, data->priv->order, *ds - 6 + JPEG_HEADER_LEN);
1157 exif_data_save_data_content_general(data, data->ifd[EXIF_IFD_1], d, ds,
1158 *ds - 6 + JPEG_HEADER_LEN);
1159 }
1160 else
1161 exif_set_long(*d + 6 - JPEG_HEADER_LEN + offset, data->priv->order, 0);
1162 }
1163
1164 typedef enum {
1165 EXIF_DATA_TYPE_MAKER_NOTE_NONE = 0,
1166 EXIF_DATA_TYPE_MAKER_NOTE_CANON = 1,
1167 EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS = 2,
1168 EXIF_DATA_TYPE_MAKER_NOTE_PENTAX = 3,
1169 EXIF_DATA_TYPE_MAKER_NOTE_NIKON = 4,
1170 EXIF_DATA_TYPE_MAKER_NOTE_CASIO = 5,
1171 EXIF_DATA_TYPE_MAKER_NOTE_FUJI = 6
1172 } ExifDataTypeMakerNote;
1173
1174 /*! If MakerNote is recognized, load it.
1175 *
1176 * \param[in,out] data #ExifData
1177 * \param[in] d pointer to raw EXIF data
1178 * \param[in] ds length of data at d
1179 */
1180 static void
interpret_maker_note(ExifData * data,const unsigned char * d,unsigned int ds)1181 interpret_maker_note(ExifData *data, const unsigned char *d, unsigned int ds)
1182 {
1183 int mnoteid;
1184 ExifEntry* e = exif_content_get_huawei_makenote_entry(data->ifd[EXIF_IFD_EXIF]);
1185
1186 if (!e)
1187 return;
1188
1189 if ((mnoteid = exif_mnote_data_olympus_identify (data, e)) != 0) {
1190 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1191 "ExifData", "Olympus MakerNote variant type %d", mnoteid);
1192 data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
1193
1194 } else if ((mnoteid = exif_mnote_data_canon_identify (data, e)) != 0) {
1195 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1196 "ExifData", "Canon MakerNote variant type %d", mnoteid);
1197 data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
1198
1199 } else if ((mnoteid = exif_mnote_data_fuji_identify (data, e)) != 0) {
1200 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1201 "ExifData", "Fuji MakerNote variant type %d", mnoteid);
1202 data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
1203
1204 /* NOTE: Must do Pentax detection last because some of the
1205 * heuristics are pretty general. */
1206 } else if ((mnoteid = exif_mnote_data_pentax_identify (data, e)) != 0) {
1207 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1208 "ExifData", "Pentax MakerNote variant type %d", mnoteid);
1209 data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
1210 } else if ((mnoteid = exif_mnote_data_apple_identify (data, e)) != 0) {
1211 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1212 "ExifData", "Apple MakerNote variant type %d", mnoteid);
1213 data->priv->md = exif_mnote_data_apple_new (data->priv->mem);
1214 } else if ((mnoteid = exif_mnote_data_huawei_identify (data, e)) != 0) {
1215 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
1216 "ExifData", "Huawei MakerNote variant type %d", mnoteid);
1217 data->priv->md = exif_mnote_data_huawei_new (data->priv->mem);
1218 }
1219
1220 /*
1221 * If we are able to interpret the maker note, do so.
1222 */
1223 if (data->priv->md) {
1224 exif_mnote_data_log (data->priv->md, data->priv->log);
1225 exif_mnote_data_set_byte_order (data->priv->md,
1226 data->priv->order);
1227 exif_mnote_data_set_offset (data->priv->md,
1228 data->priv->offset_mnote);
1229 exif_mnote_data_load (data->priv->md, d, ds);
1230 }
1231 }
1232
1233 #define LOG_TOO_SMALL \
1234 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \
1235 _("Size of data too small to allow for EXIF data."));
1236
1237 void
exif_data_load_data(ExifData * data,const unsigned char * d_orig,unsigned int ds)1238 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
1239 unsigned int ds)
1240 {
1241 unsigned int l;
1242 ExifLong offset;
1243 ExifShort n;
1244 const unsigned char *d = d_orig;
1245 unsigned int len, fullds;
1246
1247 if (!data || !data->priv || !d || !ds)
1248 return;
1249
1250 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1251 "Parsing %i byte(s) EXIF data...\n", ds);
1252
1253 /*
1254 * It can be that the data starts with the EXIF header. If it does
1255 * not, search the EXIF marker.
1256 */
1257 if (ds < 6) {
1258 LOG_TOO_SMALL;
1259 return;
1260 }
1261 if (!memcmp (d, ExifHeader, 6)) {
1262 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1263 "Found EXIF header at start.");
1264 } else {
1265 while (ds >= 3) {
1266 while (ds && (d[0] == 0xff)) {
1267 d++;
1268 ds--;
1269 }
1270
1271 /* JPEG_MARKER_SOI */
1272 if (ds && d[0] == JPEG_MARKER_SOI) {
1273 d++;
1274 ds--;
1275 continue;
1276 }
1277
1278 /* JPEG_MARKER_APP1 */
1279 if (ds && d[0] == JPEG_MARKER_APP1) {
1280 /*
1281 * Verify the exif header
1282 * (offset 3, length 6).
1283 * FF E1 NN NN EXIFHEADER
1284 * ^^ d points here currently
1285 */
1286 if ((ds >= 9) && !memcmp (d+3, ExifHeader, 6))
1287 break;
1288 /* fallthrough */
1289 }
1290 /* Skip irrelevant APP markers. The branch for APP1 must come before this,
1291 otherwise this code block will cause APP1 to be skipped. This code path
1292 is only relevant for files that are nonconformant to the EXIF
1293 specification. For conformant files, the APP1 code path above will be
1294 taken. */
1295 if (ds >= 3 && d[0] >= 0xe0 && d[0] <= 0xef) { /* JPEG_MARKER_APPn */
1296 d++;
1297 ds--;
1298 l = (((unsigned int)d[0]) << 8) | d[1];
1299 if (l > ds)
1300 return;
1301 d += l;
1302 ds -= l;
1303 continue;
1304 }
1305
1306 /* Unknown marker or data. Give up. */
1307 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1308 "ExifData", _("EXIF marker not found."));
1309 return;
1310 }
1311 if (ds < 3) {
1312 LOG_TOO_SMALL;
1313 return;
1314 }
1315 d++;
1316 ds--;
1317 len = (((unsigned int)d[0]) << 8) | d[1];
1318 if (len > ds) {
1319 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1320 "ExifData", _("Read length %d is longer than data length %d."), len, ds);
1321 return;
1322 }
1323 if (len < 2) {
1324 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1325 "ExifData", _("APP Tag too short."));
1326 return;
1327 }
1328 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1329 "We have to deal with %i byte(s) of EXIF data.",
1330 len);
1331 d += 2;
1332 ds = len - 2; /* we do not want the full rest size, but only the size of the tag */
1333 }
1334
1335 /*
1336 * Verify the exif header
1337 * (offset 2, length 6).
1338 */
1339 if (ds < 6) {
1340 LOG_TOO_SMALL;
1341 return;
1342 }
1343 if (memcmp (d, ExifHeader, 6)) {
1344 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1345 "ExifData", _("EXIF header not found."));
1346 return;
1347 }
1348
1349 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1350 "Found EXIF header.");
1351
1352 /* Sanity check the data length */
1353 if (ds < 14)
1354 return;
1355
1356 /* The JPEG APP1 section can be no longer than 64 KiB (including a
1357 16-bit length), so cap the data length to protect against overflow
1358 in future offset calculations */
1359 fullds = ds;
1360 if (ds > 0xfffe)
1361 ds = 0xfffe;
1362
1363 /* Byte order (offset 6, length 2) */
1364 if (!memcmp (d + 6, "II", 2))
1365 data->priv->order = EXIF_BYTE_ORDER_INTEL;
1366 else if (!memcmp (d + 6, "MM", 2))
1367 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
1368 else {
1369 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1370 "ExifData", _("Unknown encoding."));
1371 return;
1372 }
1373
1374 /* Fixed value */
1375 if (exif_get_short (d + 8, data->priv->order) != 0x002a)
1376 return;
1377
1378 /* IFD 0 offset */
1379 offset = exif_get_long (d + 10, data->priv->order);
1380 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1381 "IFD 0 at %i.", (int) offset);
1382
1383 /* ds is restricted to 16 bit above, so offset is restricted too, and offset+8 should not overflow. */
1384 if (offset > ds || offset + 6 + 2 > ds)
1385 return;
1386
1387 /* Parse the actual exif data (usually offset 14 from start) */
1388 exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
1389
1390 /* IFD 1 offset */
1391 n = exif_get_short (d + 6 + offset, data->priv->order);
1392 /* offset < 2<<16, n is 16 bit at most, so this op will not overflow */
1393 if (offset + 6 + 2 + 12 * n + 4 > ds)
1394 return;
1395
1396 offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
1397 if (offset) {
1398 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1399 "IFD 1 at %i.", (int) offset);
1400
1401 /* Sanity check. ds is ensured to be above 6 above, offset is 16bit */
1402 if (offset > ds - 6) {
1403 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1404 "ExifData", "Bogus offset of IFD1.");
1405 } else {
1406 exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
1407 }
1408 }
1409
1410 /*
1411 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
1412 * cameras use pointers in the maker note tag that point to the
1413 * space between IFDs. Here is the only place where we have access
1414 * to that data.
1415 */
1416 interpret_maker_note(data, d, fullds);
1417
1418 /* Fixup tags if requested */
1419 if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
1420 exif_data_fix (data);
1421 }
1422
1423 void
exif_data_load_data_general(ExifData * data,const unsigned char * d_orig,unsigned int ds)1424 exif_data_load_data_general (ExifData* data, const unsigned char* d_orig,
1425 unsigned int ds)
1426 {
1427 ExifLong offset;
1428 ExifShort n;
1429 const unsigned char* d = d_orig;
1430 unsigned int fullds;
1431
1432 if (!data || !data->priv || !d || !ds)
1433 return;
1434
1435 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1436 "Parsing %i byte(s) EXIF data...\n", ds);
1437
1438 /* Sanity check the data length */
1439 if (ds < 14)
1440 return;
1441
1442 /* The JPEG APP1 section can be no longer than 64 KiB (including a
1443 16-bit length), so cap the data length to protect against overflow
1444 in future offset calculations */
1445 fullds = ds;
1446 if (ds > 0xfffe)
1447 ds = 0xfffe;
1448
1449 /* Byte order (offset 6, length 2) */
1450 if (!memcmp(d + 6 - 6, "II", 2))
1451 data->priv->order = EXIF_BYTE_ORDER_INTEL;
1452 else if (!memcmp(d + 6 - 6, "MM", 2))
1453 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
1454 else {
1455 exif_log(data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1456 "ExifData", _("Unknown encoding."));
1457 return;
1458 }
1459
1460 /* Fixed value */
1461 if (exif_get_short(d + 8 - 6, data->priv->order) != 0x002a)
1462 return;
1463
1464 /* IFD 0 offset */
1465 offset = exif_get_long(d + 10 - 6, data->priv->order);
1466 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1467 "IFD 0 at %i.", (int)offset);
1468
1469 /* ds is restricted to 16 bit above, so offset is restricted too, and offset+8 should not overflow. */
1470 // compare offset and buffer size
1471 if (offset > ds || offset + 6 - 6 + 2 > ds)
1472 return;
1473
1474 /* Parse the actual exif data (usually offset 14 from start) */
1475 exif_data_load_data_content(data, EXIF_IFD_0, d + 6 - 6, ds - 6 + 6, offset, 0);
1476
1477 /* IFD 1 offset */
1478 n = exif_get_short(d + 6 - 6 + offset, data->priv->order);
1479 /* offset < 2<<16, n is 16 bit at most, so this op will not overflow */
1480 if (offset + 6 - 6 + 2 + 12 * n + 4 > ds)
1481 return;
1482
1483 offset = exif_get_long(d + 6 - 6 + offset + 2 + 12 * n, data->priv->order);
1484 if (offset) {
1485 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1486 "IFD 1 at %i.", (int)offset);
1487
1488 /* Sanity check. ds is ensured to be above 6 above, offset is 16bit */
1489 if (offset > ds - 6 + 6) {
1490 exif_log(data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
1491 "ExifData", "Bogus offset of IFD1.");
1492 } else {
1493 exif_data_load_data_content(data, EXIF_IFD_1, d + 6 - 6, ds - 6 + 6, offset, 0);
1494 }
1495 }
1496
1497 /*
1498 * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
1499 * cameras use pointers in the maker note tag that point to the
1500 * space between IFDs. Here is the only place where we have access
1501 * to that data.
1502 */
1503 interpret_maker_note(data, d, fullds);
1504
1505 /* Fixup tags if requested */
1506 if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
1507 exif_data_fix(data);
1508 }
1509
1510 void
exif_data_save_data(ExifData * data,unsigned char ** d,unsigned int * ds)1511 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
1512 {
1513 if (ds)
1514 *ds = 0; /* This means something went wrong */
1515
1516 if (!data || !d || !ds)
1517 return;
1518
1519 /* Header */
1520 *ds = 14;
1521 *d = exif_data_alloc (data, *ds);
1522 if (!*d) {
1523 *ds = 0;
1524 return;
1525 }
1526 memcpy (*d, ExifHeader, 6);
1527
1528 /* Order (offset 6) */
1529 if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
1530 memcpy (*d + 6, "II", 2);
1531 } else {
1532 memcpy (*d + 6, "MM", 2);
1533 }
1534
1535 /* Fixed value (2 bytes, offset 8) */
1536 exif_set_short (*d + 8, data->priv->order, 0x002a);
1537
1538 /*
1539 * IFD 0 offset (4 bytes, offset 10).
1540 * We will start 8 bytes after the
1541 * EXIF header (2 bytes for order, another 2 for the test, and
1542 * 4 bytes for the IFD 0 offset make 8 bytes together).
1543 */
1544 exif_set_long (*d + 10, data->priv->order, 8);
1545
1546 /* Now save IFD 0. IFD 1 will be saved automatically. */
1547 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1548 "Saving IFDs...");
1549 exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
1550 *ds - 6);
1551 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1552 "Saved %i byte(s) EXIF data.", *ds);
1553 }
1554
1555 void
exif_data_save_data_general(ExifData * data,unsigned char ** d,unsigned int * ds)1556 exif_data_save_data_general(ExifData* data, unsigned char** d, unsigned int* ds)
1557 {
1558 if (ds)
1559 *ds = 0; /* This means something went wrong */
1560
1561 if (!data || !d || !ds)
1562 return;
1563
1564 /* Header 4D 4D 00 2A 00 00 00 08*/
1565 *ds = 8;
1566 *d = exif_data_alloc(data, *ds);
1567 if (!*d) {
1568 *ds = 0;
1569 return;
1570 }
1571
1572 /* Order (offset 6) */
1573 if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
1574 memcpy(*d + 6 - 6, "II", 2);
1575 }
1576 else {
1577 memcpy(*d + 6 - 6, "MM", 2);
1578 }
1579
1580 /* Fixed value (2 bytes, offset 8) */
1581 exif_set_short(*d + 8 - 6, data->priv->order, 0x002a);
1582
1583 /*
1584 * IFD 0 offset (4 bytes, offset 10).
1585 * We will start 8 bytes after the
1586 * EXIF header (2 bytes for order, another 2 for the test, and
1587 * 4 bytes for the IFD 0 offset make 8 bytes together).
1588 */
1589 exif_set_long(*d + 10 - 6, data->priv->order, 8);
1590 /* Now save IFD 0. IFD 1 will be saved automatically. */
1591 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1592 "Saving IFDs...");
1593 exif_data_save_data_content_general(data, data->ifd[EXIF_IFD_0], d, ds,
1594 *ds);
1595 exif_log(data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1596 "Saved %i byte(s) EXIF data.", *ds);
1597 }
1598
1599 ExifData *
exif_data_new_from_file(const char * path)1600 exif_data_new_from_file (const char *path)
1601 {
1602 ExifData *edata;
1603 ExifLoader *loader;
1604
1605 loader = exif_loader_new ();
1606 exif_loader_write_file (loader, path);
1607 edata = exif_loader_get_data (loader);
1608 exif_loader_unref (loader);
1609
1610 return (edata);
1611 }
1612
1613 void
exif_data_ref(ExifData * data)1614 exif_data_ref (ExifData *data)
1615 {
1616 if (!data)
1617 return;
1618
1619 data->priv->ref_count++;
1620 }
1621
1622 void
exif_data_unref(ExifData * data)1623 exif_data_unref (ExifData *data)
1624 {
1625 if (!data || !data->priv)
1626 return;
1627
1628 data->priv->ref_count--;
1629 if (!data->priv->ref_count)
1630 exif_data_free (data);
1631 }
1632
1633 void
exif_data_free(ExifData * data)1634 exif_data_free (ExifData *data)
1635 {
1636 unsigned int i;
1637 ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
1638
1639 if (!data)
1640 return;
1641
1642 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1643 if (data->ifd[i]) {
1644 exif_content_unref (data->ifd[i]);
1645 data->ifd[i] = NULL;
1646 }
1647 }
1648
1649 if (data->data) {
1650 exif_mem_free (mem, data->data);
1651 data->data = NULL;
1652 }
1653
1654 if (data->priv) {
1655 if (data->priv->log) {
1656 exif_log_unref (data->priv->log);
1657 data->priv->log = NULL;
1658 }
1659 if (data->priv->md) {
1660 exif_mnote_data_unref (data->priv->md);
1661 data->priv->md = NULL;
1662 }
1663 exif_mem_free (mem, data->priv);
1664 exif_mem_free (mem, data);
1665 }
1666
1667 exif_mem_unref (mem);
1668 }
1669
1670 void
exif_data_dump(ExifData * data)1671 exif_data_dump (ExifData *data)
1672 {
1673 unsigned int i;
1674
1675 if (!data)
1676 return;
1677
1678 for (i = 0; i < EXIF_IFD_COUNT; i++) {
1679 if (data->ifd[i] && data->ifd[i]->count) {
1680 printf ("Dumping IFD '%s'...\n",
1681 exif_ifd_get_name (i));
1682 exif_content_dump (data->ifd[i], 0);
1683 }
1684 }
1685
1686 if (data->data) {
1687 printf ("%i byte(s) thumbnail data available: ", data->size);
1688 if (data->size >= 4) {
1689 printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
1690 data->data[0], data->data[1],
1691 data->data[data->size - 2],
1692 data->data[data->size - 1]);
1693 }
1694 }
1695 }
1696
1697 ExifByteOrder
exif_data_get_byte_order(ExifData * data)1698 exif_data_get_byte_order (ExifData *data)
1699 {
1700 if (!data)
1701 return (0);
1702
1703 return (data->priv->order);
1704 }
1705
1706 void
exif_data_foreach_content(ExifData * data,ExifDataForeachContentFunc func,void * user_data)1707 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
1708 void *user_data)
1709 {
1710 unsigned int i;
1711
1712 if (!data || !func)
1713 return;
1714
1715 for (i = 0; i < EXIF_IFD_COUNT; i++)
1716 func (data->ifd[i], user_data);
1717 }
1718
1719 typedef struct _ByteOrderChangeData ByteOrderChangeData;
1720 struct _ByteOrderChangeData {
1721 ExifByteOrder old, new;
1722 };
1723
1724 static void
entry_set_byte_order(ExifEntry * e,void * data)1725 entry_set_byte_order (ExifEntry *e, void *data)
1726 {
1727 ByteOrderChangeData *d = data;
1728
1729 if (!e)
1730 return;
1731
1732 exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new);
1733 }
1734
1735 static void
content_set_byte_order(ExifContent * content,void * data)1736 content_set_byte_order (ExifContent *content, void *data)
1737 {
1738 exif_content_foreach_entry (content, entry_set_byte_order, data);
1739 }
1740
1741 void
exif_data_set_byte_order(ExifData * data,ExifByteOrder order)1742 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
1743 {
1744 ByteOrderChangeData d;
1745
1746 if (!data || (order == data->priv->order))
1747 return;
1748
1749 d.old = data->priv->order;
1750 d.new = order;
1751 exif_data_foreach_content (data, content_set_byte_order, &d);
1752 data->priv->order = order;
1753 if (data->priv->md)
1754 exif_mnote_data_set_byte_order (data->priv->md, order);
1755 }
1756
1757 void
exif_data_log(ExifData * data,ExifLog * log)1758 exif_data_log (ExifData *data, ExifLog *log)
1759 {
1760 unsigned int i;
1761
1762 if (!data || !data->priv)
1763 return;
1764 exif_log_unref (data->priv->log);
1765 data->priv->log = log;
1766 exif_log_ref (log);
1767
1768 for (i = 0; i < EXIF_IFD_COUNT; i++)
1769 exif_content_log (data->ifd[i], log);
1770 }
1771
1772 /* Used internally within libexif */
1773 ExifLog *exif_data_get_log (ExifData *);
1774 ExifLog *
exif_data_get_log(ExifData * data)1775 exif_data_get_log (ExifData *data)
1776 {
1777 if (!data || !data->priv)
1778 return NULL;
1779 return data->priv->log;
1780 }
1781
1782 static const struct {
1783 ExifDataOption option;
1784 const char *name;
1785 const char *description;
1786 } exif_data_option[] = {
1787 {EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"),
1788 N_("Ignore unknown tags when loading EXIF data.")},
1789 {EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"),
1790 N_("Add, correct and remove entries to get EXIF data that follows "
1791 "the specification.")},
1792 {EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"),
1793 N_("When loading and resaving Exif data, save the maker note unmodified."
1794 " Be aware that the maker note can get corrupted.")},
1795 {0, NULL, NULL}
1796 };
1797
1798 const char *
exif_data_option_get_name(ExifDataOption o)1799 exif_data_option_get_name (ExifDataOption o)
1800 {
1801 unsigned int i;
1802
1803 for (i = 0; exif_data_option[i].name; i++)
1804 if (exif_data_option[i].option == o)
1805 break;
1806 return _(exif_data_option[i].name);
1807 }
1808
1809 const char *
exif_data_option_get_description(ExifDataOption o)1810 exif_data_option_get_description (ExifDataOption o)
1811 {
1812 unsigned int i;
1813
1814 for (i = 0; exif_data_option[i].description; i++)
1815 if (exif_data_option[i].option == o)
1816 break;
1817 return _(exif_data_option[i].description);
1818 }
1819
1820 void
exif_data_set_option(ExifData * d,ExifDataOption o)1821 exif_data_set_option (ExifData *d, ExifDataOption o)
1822 {
1823 if (!d)
1824 return;
1825
1826 d->priv->options |= o;
1827 }
1828
1829 void
exif_data_unset_option(ExifData * d,ExifDataOption o)1830 exif_data_unset_option (ExifData *d, ExifDataOption o)
1831 {
1832 if (!d)
1833 return;
1834
1835 d->priv->options &= ~o;
1836 }
1837
1838 static void
fix_func(ExifContent * c,void * UNUSED (data))1839 fix_func (ExifContent *c, void *UNUSED(data))
1840 {
1841 switch (exif_content_get_ifd (c)) {
1842 case EXIF_IFD_1:
1843 if (c->parent->data)
1844 exif_content_fix (c);
1845 else if (c->count) {
1846 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1847 "No thumbnail but entries on thumbnail. These entries have been "
1848 "removed.");
1849 while (c->count) {
1850 unsigned int cnt = c->count;
1851 exif_content_remove_entry (c, c->entries[c->count - 1]);
1852 if (cnt == c->count) {
1853 /* safety net */
1854 exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1855 "failed to remove last entry from entries.");
1856 c->count--;
1857 }
1858 }
1859 }
1860 break;
1861 default:
1862 exif_content_fix (c);
1863 }
1864 }
1865
1866 void
exif_data_fix(ExifData * d)1867 exif_data_fix (ExifData *d)
1868 {
1869 exif_data_foreach_content (d, fix_func, NULL);
1870 }
1871
1872 void
exif_data_set_data_type(ExifData * d,ExifDataType dt)1873 exif_data_set_data_type (ExifData *d, ExifDataType dt)
1874 {
1875 if (!d || !d->priv)
1876 return;
1877
1878 d->priv->data_type = dt;
1879 }
1880
1881 ExifDataType
exif_data_get_data_type(ExifData * d)1882 exif_data_get_data_type (ExifData *d)
1883 {
1884 return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_UNKNOWN;
1885 }
1886