libexif/exif-data.c

   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/canon/exif-mnote-data-canon.h>
  34 #include <libexif/fuji/exif-mnote-data-fuji.h>
  35 #include <libexif/olympus/exif-mnote-data-olympus.h>
  36 #include <libexif/pentax/exif-mnote-data-pentax.h>
  37
  38 #include <math.h>
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42
  43 #undef JPEG_MARKER_SOI
  44 #define JPEG_MARKER_SOI  0xd8
  45 #undef JPEG_MARKER_APP0
  46 #define JPEG_MARKER_APP0 0xe0
  47 #undef JPEG_MARKER_APP1
  48 #define JPEG_MARKER_APP1 0xe1
  49
  50 static const unsigned char ExifHeader[] = {0x45, 0x78, 0x69, 0x66, 0x00, 0x00};
  51
  52 struct _ExifDataPrivate
  53 {
  54         ExifByteOrder order;
  55
  56         ExifMnoteData *md;
  57
  58         ExifLog *log;
  59         ExifMem *mem;
  60
  61         unsigned int ref_count;
  62
  63         /* Temporarily used while loading data */
  64         unsigned int offset_mnote;
  65
  66         ExifDataOption options;
  67         ExifDataType data_type;
  68 };
  69
  70 static void *
  71 exif_data_alloc (ExifData *data, unsigned int i)
  72 {
  73         void *d;
  74
  75         if (!data || !i)
  76                 return NULL;
  77
  78         d = exif_mem_alloc (data->priv->mem, i);
  79         if (d)
  80                 return d;
  81
  82         EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", i);
  83         return NULL;
  84 }
  85
  86 ExifMnoteData *
  87 exif_data_get_mnote_data (ExifData *d)
  88 {
  89         return (d && d->priv) ? d->priv->md : NULL;
  90 }
  91
  92 ExifData *
  93 exif_data_new (void)
  94 {
  95         ExifMem *mem = exif_mem_new_default ();
  96         ExifData *d = exif_data_new_mem (mem);
  97
  98         exif_mem_unref (mem);
  99
 100         return d;
 101 }
 102
 103 ExifData *
 104 exif_data_new_mem (ExifMem *mem)
 105 {
 106         ExifData *data;
 107         unsigned int i;
 108
 109         if (!mem)
 110                 return NULL;
 111
 112         data = exif_mem_alloc (mem, sizeof (ExifData));
 113         if (!data)
 114                 return (NULL);
 115         data->priv = exif_mem_alloc (mem, sizeof (ExifDataPrivate));
 116         if (!data->priv) {
 117                 exif_mem_free (mem, data);
 118                 return (NULL);
 119         }
 120         data->priv->ref_count = 1;
 121
 122         data->priv->mem = mem;
 123         exif_mem_ref (mem);
 124
 125         for (i = 0; i < EXIF_IFD_COUNT; i++) {
 126                 data->ifd[i] = exif_content_new_mem (data->priv->mem);
 127                 if (!data->ifd[i]) {
 128                         exif_data_free (data);
 129                         return (NULL);
 130                 }
 131                 data->ifd[i]->parent = data;
 132         }
 133
 134         /* Default options */
 135 #ifndef NO_VERBOSE_TAG_STRINGS
 136         /*
 137          * When the tag list is compiled away, setting this option prevents
 138          * any tags from being loaded
 139          */
 140         exif_data_set_option (data, EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS);
 141 #endif
 142         exif_data_set_option (data, EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
 143
 144         /* Default data type: none */
 145         exif_data_set_data_type (data, EXIF_DATA_TYPE_COUNT);
 146
 147         return (data);
 148 }
 149
 150 ExifData *
 151 exif_data_new_from_data (const unsigned char *data, unsigned int size)
 152 {
 153         ExifData *edata;
 154
 155         edata = exif_data_new ();
 156         exif_data_load_data (edata, data, size);
 157         return (edata);
 158 }
 159
 160 static int
 161 exif_data_load_data_entry (ExifData *data, ExifEntry *entry,
 162                            const unsigned char *d,
 163                            unsigned int size, unsigned int offset)
 164 {
 165         unsigned int s, doff;
 166
 167         entry->tag        = exif_get_short (d + offset + 0, data->priv->order);
 168         entry->format     = exif_get_short (d + offset + 2, data->priv->order);
 169         entry->components = exif_get_long  (d + offset + 4, data->priv->order);
 170
 171         /* FIXME: should use exif_tag_get_name_in_ifd here but entry->parent
 172          * has not been set yet
 173          */
 174         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 175                   "Loading entry 0x%x ('%s')...", entry->tag,
 176                   exif_tag_get_name (entry->tag));
 177
 178         /* {0,1,2,4,8} x { 0x00000000 .. 0xffffffff }
 179          *   -> { 0x000000000 .. 0x7fffffff8 } */
 180         s = exif_format_get_size(entry->format) * entry->components;
 181         if ((s < entry->components) || (s == 0)){
 182                 return 0;
 183         }
 184
 185         /*
 186          * Size? If bigger than 4 bytes, the actual data is not
 187          * in the entry but somewhere else (offset).
 188          */
 189         if (s > 4)
 190                 doff = exif_get_long (d + offset + 8, data->priv->order);
 191         else
 192                 doff = offset + 8;
 193
 194         /* Sanity checks */
 195         if (doff >= size) {
 196                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 197                                   "Tag starts past end of buffer (%u > %u)", doff, size);
 198                 return 0;
 199         }
 200
 201         if (s > size - doff) {
 202                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 203                                   "Tag data goes past end of buffer (%u > %u)", doff+s, size);
 204                 return 0;
 205         }
 206
 207         entry->data = exif_data_alloc (data, s);
 208         if (entry->data) {
 209                 entry->size = s;
 210                 memcpy (entry->data, d + doff, s);
 211         } else {
 212                 EXIF_LOG_NO_MEMORY(data->priv->log, "ExifData", s);
 213                 return 0;
 214         }
 215
 216         /* If this is the MakerNote, remember the offset */
 217         if (entry->tag == EXIF_TAG_MAKER_NOTE) {
 218                 if (!entry->data) {
 219                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 220                                           "MakerNote found with empty data");
 221                 } else if (entry->size > 6) {
 222                         exif_log (data->priv->log,
 223                                                EXIF_LOG_CODE_DEBUG, "ExifData",
 224                                                "MakerNote found (%02x %02x %02x %02x "
 225                                                "%02x %02x %02x...).",
 226                                                entry->data[0], entry->data[1], entry->data[2],
 227                                                entry->data[3], entry->data[4], entry->data[5],
 228                                                entry->data[6]);
 229                 }
 230                 data->priv->offset_mnote = doff;
 231         }
 232         return 1;
 233 }
 234
 235 static void
 236 exif_data_save_data_entry (ExifData *data, ExifEntry *e,
 237                            unsigned char **d, unsigned int *ds,
 238                            unsigned int offset)
 239 {
 240         unsigned int doff, s;
 241         unsigned int ts;
 242
 243         if (!data || !data->priv)
 244                 return;
 245
 246         /*
 247          * Each entry is 12 bytes long. The memory for the entry has
 248          * already been allocated.
 249          */
 250         exif_set_short (*d + 6 + offset + 0,
 251                         data->priv->order, (ExifShort) e->tag);
 252         exif_set_short (*d + 6 + offset + 2,
 253                         data->priv->order, (ExifShort) e->format);
 254
 255         if (!(data->priv->options & EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE)) {
 256                 /* If this is the maker note tag, update it. */
 257                 if ((e->tag == EXIF_TAG_MAKER_NOTE) && data->priv->md) {
 258                         /* TODO: this is using the wrong ExifMem to free e->data */
 259                         exif_mem_free (data->priv->mem, e->data);
 260                         e->data = NULL;
 261                         e->size = 0;
 262                         exif_mnote_data_set_offset (data->priv->md, *ds - 6);
 263                         exif_mnote_data_save (data->priv->md, &e->data, &e->size);
 264                         e->components = e->size;
 265                         if (exif_format_get_size (e->format) != 1) {
 266                                 /* e->format is taken from input code,
 267                                  * but we need to make sure it is a 1 byte
 268                                  * entity due to the multiplication below. */
 269                                 e->format = EXIF_FORMAT_UNDEFINED;
 270                         }
 271                 }
 272         }
 273
 274         exif_set_long  (*d + 6 + offset + 4,
 275                         data->priv->order, e->components);
 276
 277         /*
 278          * Size? If bigger than 4 bytes, the actual data is not in
 279          * the entry but somewhere else.
 280          */
 281         s = exif_format_get_size (e->format) * e->components;
 282         if (s > 4) {
 283                 unsigned char *t;
 284                 doff = *ds - 6;
 285                 ts = *ds + s;
 286
 287                 /*
 288                  * According to the TIFF specification,
 289                  * the offset must be an even number. If we need to introduce
 290                  * a padding byte, we set it to 0.
 291                  */
 292                 if (s & 1)
 293                         ts++;
 294                 t = exif_mem_realloc (data->priv->mem, *d, ts);
 295                 if (!t) {
 296                         EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
 297                         return;
 298                 }
 299                 *d = t;
 300                 *ds = ts;
 301                 exif_set_long (*d + 6 + offset + 8, data->priv->order, doff);
 302                 if (s & 1)
 303                         *(*d + *ds - 1) = '\0';
 304
 305         } else
 306                 doff = offset + 8;
 307
 308         /* Write the data. Fill unneeded bytes with 0. Do not crash with
 309          * e->data is NULL */
 310         if (e->data) {
 311                 unsigned int len = s;
 312                 if (e->size < s) len = e->size;
 313                 memcpy (*d + 6 + doff, e->data, len);
 314         } else {
 315                 memset (*d + 6 + doff, 0, s);
 316         }
 317         if (s < 4)
 318                 memset (*d + 6 + doff + s, 0, (4 - s));
 319 }
 320
 321 static void
 322 exif_data_load_data_thumbnail (ExifData *data, const unsigned char *d,
 323                                unsigned int ds, ExifLong o, ExifLong s)
 324 {
 325         /* Sanity checks */
 326         if (o >= ds) {
 327                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail offset (%u).", o);
 328                 return;
 329         }
 330         if (s > ds - o) {
 331                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData", "Bogus thumbnail size (%u), max would be %u.", s, ds-o);
 332                 return;
 333         }
 334         if (data->data)
 335                 exif_mem_free (data->priv->mem, data->data);
 336         if (!(data->data = exif_data_alloc (data, s))) {
 337                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", s);
 338                 data->size = 0;
 339                 return;
 340         }
 341         data->size = s;
 342         memcpy (data->data, d + o, s);
 343 }
 344
 345 #undef CHECK_REC
 346 #define CHECK_REC(i)                                    \
 347 if ((i) == ifd) {                               \
 348         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
 349                 "ExifData", "Recursive entry in IFD "   \
 350                 "'%s' detected. Skipping...",           \
 351                 exif_ifd_get_name (i));                 \
 352         break;                                          \
 353 }                                                       \
 354 if (data->ifd[(i)]->count) {                            \
 355         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, \
 356                 "ExifData", "Attempt to load IFD "      \
 357                 "'%s' multiple times detected. "        \
 358                 "Skipping...",                          \
 359                 exif_ifd_get_name (i));                 \
 360         break;                                          \
 361 }
 362
 363 /*! Calculate the recursion cost added by one level of IFD loading.
 364  *
 365  * The work performed is related to the cost in the exponential relation
 366  *   work=1.1**cost
 367  */
 368 static unsigned int
 369 level_cost(unsigned int n)
 370 {
 371     static const double log_1_1 = 0.09531017980432493;
 372
 373         /* Adding 0.1 protects against the case where n==1 */
 374         return ceil(log(n + 0.1)/log_1_1);
 375 }
 376
 377 /*! Load data for an IFD.
 378  *
 379  * \param[in,out] data #ExifData
 380  * \param[in] ifd IFD to load
 381  * \param[in] d pointer to buffer containing raw IFD data
 382  * \param[in] ds size of raw data in buffer at \c d
 383  * \param[in] offset offset into buffer at \c d at which IFD starts
 384  * \param[in] recursion_cost factor indicating how expensive this recursive
 385  * call could be
 386  */
 387 static void
 388 exif_data_load_data_content (ExifData *data, ExifIfd ifd,
 389                              const unsigned char *d,
 390                              unsigned int ds, unsigned int offset, unsigned int recursion_cost)
 391 {
 392         ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
 393         ExifShort n;
 394         ExifEntry *entry;
 395         unsigned int i;
 396         ExifTag tag;
 397
 398         if (!data || !data->priv)
 399                 return;
 400
 401         /* check for valid ExifIfd enum range */
 402         if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
 403           return;
 404
 405         if (recursion_cost > 170) {
 406                 /*
 407                  * recursion_cost is a logarithmic-scale indicator of how expensive this
 408                  * recursive call might end up being. It is an indicator of the depth of
 409                  * recursion as well as the potential for worst-case future recursive
 410                  * calls. Since it's difficult to tell ahead of time how often recursion
 411                  * will occur, this assumes the worst by assuming every tag could end up
 412                  * causing recursion.
 413                  * The value of 170 was chosen to limit typical EXIF structures to a
 414                  * recursive depth of about 6, but pathological ones (those with very
 415                  * many tags) to only 2.
 416                  */
 417                 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
 418                           "Deep/expensive recursion detected!");
 419                 return;
 420         }
 421
 422         /* Read the number of entries */
 423         if ((offset + 2 < offset) || (offset + 2 < 2) || (offset + 2 > ds)) {
 424                 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
 425                           "Tag data past end of buffer (%u > %u)", offset+2, ds);
 426                 return;
 427         }
 428         n = exif_get_short (d + offset, data->priv->order);
 429         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 430                   "Loading %hu entries...", n);
 431         offset += 2;
 432
 433         /* Check if we have enough data. */
 434         if (offset + 12 * n > ds) {
 435                 n = (ds - offset) / 12;
 436                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 437                                   "Short data; only loading %hu entries...", n);
 438         }
 439
 440         for (i = 0; i < n; i++) {
 441
 442                 tag = exif_get_short (d + offset + 12 * i, data->priv->order);
 443                 switch (tag) {
 444                 case EXIF_TAG_EXIF_IFD_POINTER:
 445                 case EXIF_TAG_GPS_INFO_IFD_POINTER:
 446                 case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 447                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 448                 case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 449                         o = exif_get_long (d + offset + 12 * i + 8,
 450                                            data->priv->order);
 451                         if (o >= ds) {
 452                                 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
 453                                           "Tag data past end of buffer (%u > %u)", offset+2, ds);
 454                                 return;
 455                         }
 456                         /* FIXME: IFD_POINTER tags aren't marked as being in a
 457                          * specific IFD, so exif_tag_get_name_in_ifd won't work
 458                          */
 459                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 460                                   "Sub-IFD entry 0x%x ('%s') at %u.", tag,
 461                                   exif_tag_get_name(tag), o);
 462                         switch (tag) {
 463                         case EXIF_TAG_EXIF_IFD_POINTER:
 464                                 CHECK_REC (EXIF_IFD_EXIF);
 465                                 exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
 466                                         recursion_cost + level_cost(n));
 467                                 break;
 468                         case EXIF_TAG_GPS_INFO_IFD_POINTER:
 469                                 CHECK_REC (EXIF_IFD_GPS);
 470                                 exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
 471                                         recursion_cost + level_cost(n));
 472                                 break;
 473                         case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
 474                                 CHECK_REC (EXIF_IFD_INTEROPERABILITY);
 475                                 exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
 476                                         recursion_cost + level_cost(n));
 477                                 break;
 478                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
 479                                 thumbnail_offset = o;
 480                                 if (thumbnail_offset && thumbnail_length)
 481                                         exif_data_load_data_thumbnail (data, d,
 482                                                                        ds, thumbnail_offset,
 483                                                                        thumbnail_length);
 484                                 break;
 485                         case EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH:
 486                                 thumbnail_length = o;
 487                                 if (thumbnail_offset && thumbnail_length)
 488                                         exif_data_load_data_thumbnail (data, d,
 489                                                                        ds, thumbnail_offset,
 490                                                                        thumbnail_length);
 491                                 break;
 492                         default:
 493                                 return;
 494                         }
 495                         break;
 496                 default:
 497
 498                         /*
 499                          * If we don't know the tag, don't fail. It could be that new
 500                          * versions of the standard have defined additional tags. Note that
 501                          * 0 is a valid tag in the GPS IFD.
 502                          */
 503                         if (!exif_tag_get_name_in_ifd (tag, ifd)) {
 504
 505                                 /*
 506                                  * Special case: Tag and format 0. That's against specification
 507                                  * (at least up to 2.2). But Photoshop writes it anyways.
 508                                  */
 509                                 if (!memcmp (d + offset + 12 * i, "\0\0\0\0", 4)) {
 510                                         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 511                                                   "Skipping empty entry at position %u in '%s'.", i,
 512                                                   exif_ifd_get_name (ifd));
 513                                         break;
 514                                 }
 515                                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 516                                           "Unknown tag 0x%04x (entry %u in '%s'). Please report this tag "
 517                                           "to <libexif-devel@lists.sourceforge.net>.", tag, i,
 518                                           exif_ifd_get_name (ifd));
 519                                 if (data->priv->options & EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS)
 520                                         break;
 521                         }
 522                         entry = exif_entry_new_mem (data->priv->mem);
 523                         if (!entry) {
 524                                   exif_log (data->priv->log, EXIF_LOG_CODE_NO_MEMORY, "ExifData",
 525                                           "Could not allocate memory");
 526                                   return;
 527                         }
 528                         if (exif_data_load_data_entry (data, entry, d, ds,
 529                                                    offset + 12 * i))
 530                                 exif_content_add_entry (data->ifd[ifd], entry);
 531                         exif_entry_unref (entry);
 532                         break;
 533                 }
 534         }
 535 }
 536
 537 static int
 538 cmp_func (const unsigned char *p1, const unsigned char *p2, ExifByteOrder o)
 539 {
 540         ExifShort tag1 = exif_get_short (p1, o);
 541         ExifShort tag2 = exif_get_short (p2, o);
 542
 543         return (tag1 < tag2) ? -1 : (tag1 > tag2) ? 1 : 0;
 544 }
 545
 546 static int
 547 cmp_func_intel (const void *elem1, const void *elem2)
 548 {
 549         return cmp_func ((const unsigned char *) elem1,
 550                          (const unsigned char *) elem2, EXIF_BYTE_ORDER_INTEL);
 551 }
 552
 553 static int
 554 cmp_func_motorola (const void *elem1, const void *elem2)
 555 {
 556         return cmp_func ((const unsigned char *) elem1,
 557                          (const unsigned char *) elem2, EXIF_BYTE_ORDER_MOTOROLA);
 558 }
 559
 560 static void
 561 exif_data_save_data_content (ExifData *data, ExifContent *ifd,
 562                              unsigned char **d, unsigned int *ds,
 563                              unsigned int offset)
 564 {
 565         unsigned int j, n_ptr = 0, n_thumb = 0;
 566         ExifIfd i;
 567         unsigned char *t;
 568         unsigned int ts;
 569
 570         if (!data || !data->priv || !ifd || !d || !ds)
 571                 return;
 572
 573         for (i = 0; i < EXIF_IFD_COUNT; i++)
 574                 if (ifd == data->ifd[i])
 575                         break;
 576         if (i == EXIF_IFD_COUNT)
 577                 return; /* error */
 578
 579         /*
 580          * Check if we need some extra entries for pointers or the thumbnail.
 581          */
 582         switch (i) {
 583         case EXIF_IFD_0:
 584
 585                 /*
 586                  * The pointer to IFD_EXIF is in IFD_0. The pointer to
 587                  * IFD_INTEROPERABILITY is in IFD_EXIF.
 588                  */
 589                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 590                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 591                         n_ptr++;
 592
 593                 /* The pointer to IFD_GPS is in IFD_0. */
 594                 if (data->ifd[EXIF_IFD_GPS]->count)
 595                         n_ptr++;
 596
 597                 break;
 598         case EXIF_IFD_1:
 599                 if (data->size)
 600                         n_thumb = 2;
 601                 break;
 602         case EXIF_IFD_EXIF:
 603                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count)
 604                         n_ptr++;
 605         default:
 606                 break;
 607         }
 608
 609         /*
 610          * Allocate enough memory for all entries
 611          * and the number of entries.
 612          */
 613         ts = *ds + (2 + (ifd->count + n_ptr + n_thumb) * 12 + 4);
 614         t = exif_mem_realloc (data->priv->mem, *d, ts);
 615         if (!t) {
 616                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData", ts);
 617                 return;
 618         }
 619         *d = t;
 620         *ds = ts;
 621
 622         /* Save the number of entries */
 623         exif_set_short (*d + 6 + offset, data->priv->order,
 624                         (ExifShort) (ifd->count + n_ptr + n_thumb));
 625         offset += 2;
 626
 627         /*
 628          * Save each entry. Make sure that no memcpys from NULL pointers are
 629          * performed
 630          */
 631         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 632                   "Saving %i entries (IFD '%s', offset: %i)...",
 633                   ifd->count, exif_ifd_get_name (i), offset);
 634         for (j = 0; j < ifd->count; j++) {
 635                 if (ifd->entries[j]) {
 636                         exif_data_save_data_entry (data, ifd->entries[j], d, ds,
 637                                 offset + 12 * j);
 638                 }
 639         }
 640
 641         offset += 12 * ifd->count;
 642
 643         /* Now save special entries. */
 644         switch (i) {
 645         case EXIF_IFD_0:
 646
 647                 /*
 648                  * The pointer to IFD_EXIF is in IFD_0.
 649                  * However, the pointer to IFD_INTEROPERABILITY is in IFD_EXIF,
 650                  * therefore, if IFD_INTEROPERABILITY is not empty, we need
 651                  * IFD_EXIF even if latter is empty.
 652                  */
 653                 if (data->ifd[EXIF_IFD_EXIF]->count ||
 654                     data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 655                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 656                                         EXIF_TAG_EXIF_IFD_POINTER);
 657                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 658                                         EXIF_FORMAT_LONG);
 659                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 660                                         1);
 661                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 662                                         *ds - 6);
 663                         exif_data_save_data_content (data,
 664                                                      data->ifd[EXIF_IFD_EXIF], d, ds, *ds - 6);
 665                         offset += 12;
 666                 }
 667
 668                 /* The pointer to IFD_GPS is in IFD_0, too. */
 669                 if (data->ifd[EXIF_IFD_GPS]->count) {
 670                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 671                                         EXIF_TAG_GPS_INFO_IFD_POINTER);
 672                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 673                                         EXIF_FORMAT_LONG);
 674                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 675                                         1);
 676                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 677                                         *ds - 6);
 678                         exif_data_save_data_content (data,
 679                                                      data->ifd[EXIF_IFD_GPS], d, ds, *ds - 6);
 680                         offset += 12;
 681                 }
 682
 683                 break;
 684         case EXIF_IFD_EXIF:
 685
 686                 /*
 687                  * The pointer to IFD_INTEROPERABILITY is in IFD_EXIF.
 688                  * See note above.
 689                  */
 690                 if (data->ifd[EXIF_IFD_INTEROPERABILITY]->count) {
 691                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 692                                         EXIF_TAG_INTEROPERABILITY_IFD_POINTER);
 693                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 694                                         EXIF_FORMAT_LONG);
 695                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 696                                         1);
 697                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 698                                         *ds - 6);
 699                         exif_data_save_data_content (data,
 700                                                      data->ifd[EXIF_IFD_INTEROPERABILITY], d, ds,
 701                                                      *ds - 6);
 702                         offset += 12;
 703                 }
 704
 705                 break;
 706         case EXIF_IFD_1:
 707
 708                 /*
 709                  * Information about the thumbnail (if any) is saved in
 710                  * IFD_1.
 711                  */
 712                 if (data->size) {
 713
 714                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT */
 715                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 716                                         EXIF_TAG_JPEG_INTERCHANGE_FORMAT);
 717                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 718                                         EXIF_FORMAT_LONG);
 719                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 720                                         1);
 721                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 722                                         *ds - 6);
 723                         ts = *ds + data->size;
 724                         t = exif_mem_realloc (data->priv->mem, *d, ts);
 725                         if (!t) {
 726                                 EXIF_LOG_NO_MEMORY (data->priv->log, "ExifData",
 727                                                     ts);
 728                                 return;
 729                         }
 730                         *d = t;
 731                         *ds = ts;
 732                         memcpy (*d + *ds - data->size, data->data, data->size);
 733                         offset += 12;
 734
 735                         /* EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH */
 736                         exif_set_short (*d + 6 + offset + 0, data->priv->order,
 737                                         EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH);
 738                         exif_set_short (*d + 6 + offset + 2, data->priv->order,
 739                                         EXIF_FORMAT_LONG);
 740                         exif_set_long  (*d + 6 + offset + 4, data->priv->order,
 741                                         1);
 742                         exif_set_long  (*d + 6 + offset + 8, data->priv->order,
 743                                         data->size);
 744                         offset += 12;
 745                 }
 746
 747                 break;
 748         default:
 749                 break;
 750         }
 751
 752         /* Sort the directory according to TIFF specification */
 753         qsort (*d + 6 + offset - (ifd->count + n_ptr + n_thumb) * 12,
 754                (ifd->count + n_ptr + n_thumb), 12,
 755                (data->priv->order == EXIF_BYTE_ORDER_INTEL) ? cmp_func_intel : cmp_func_motorola);
 756
 757         /* Correctly terminate the directory */
 758         if (i == EXIF_IFD_0 && (data->ifd[EXIF_IFD_1]->count ||
 759                                 data->size)) {
 760
 761                 /*
 762                  * We are saving IFD 0. Tell where IFD 1 starts and save
 763                  * IFD 1.
 764                  */
 765                 exif_set_long (*d + 6 + offset, data->priv->order, *ds - 6);
 766                 exif_data_save_data_content (data, data->ifd[EXIF_IFD_1], d, ds,
 767                                              *ds - 6);
 768         } else
 769                 exif_set_long (*d + 6 + offset, data->priv->order, 0);
 770 }
 771
 772 typedef enum {
 773         EXIF_DATA_TYPE_MAKER_NOTE_NONE          = 0,
 774         EXIF_DATA_TYPE_MAKER_NOTE_CANON         = 1,
 775         EXIF_DATA_TYPE_MAKER_NOTE_OLYMPUS       = 2,
 776         EXIF_DATA_TYPE_MAKER_NOTE_PENTAX        = 3,
 777         EXIF_DATA_TYPE_MAKER_NOTE_NIKON         = 4,
 778         EXIF_DATA_TYPE_MAKER_NOTE_CASIO         = 5,
 779         EXIF_DATA_TYPE_MAKER_NOTE_FUJI          = 6
 780 } ExifDataTypeMakerNote;
 781
 782 /*! If MakerNote is recognized, load it.
 783  *
 784  * \param[in,out] data #ExifData
 785  * \param[in] d pointer to raw EXIF data
 786  * \param[in] ds length of data at d
 787  */
 788 static void
 789 interpret_maker_note(ExifData *data, const unsigned char *d, unsigned int ds)
 790 {
 791         int mnoteid;
 792         ExifEntry* e = exif_data_get_entry (data, EXIF_TAG_MAKER_NOTE);
 793         if (!e)
 794                 return;
 795
 796         if ((mnoteid = exif_mnote_data_olympus_identify (data, e)) != 0) {
 797                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 798                         "ExifData", "Olympus MakerNote variant type %d", mnoteid);
 799                 data->priv->md = exif_mnote_data_olympus_new (data->priv->mem);
 800
 801         } else if ((mnoteid = exif_mnote_data_canon_identify (data, e)) != 0) {
 802                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 803                         "ExifData", "Canon MakerNote variant type %d", mnoteid);
 804                 data->priv->md = exif_mnote_data_canon_new (data->priv->mem, data->priv->options);
 805
 806         } else if ((mnoteid = exif_mnote_data_fuji_identify (data, e)) != 0) {
 807                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 808                         "ExifData", "Fuji MakerNote variant type %d", mnoteid);
 809                 data->priv->md = exif_mnote_data_fuji_new (data->priv->mem);
 810
 811         /* NOTE: Must do Pentax detection last because some of the
 812          * heuristics are pretty general. */
 813         } else if ((mnoteid = exif_mnote_data_pentax_identify (data, e)) != 0) {
 814                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG,
 815                         "ExifData", "Pentax MakerNote variant type %d", mnoteid);
 816                 data->priv->md = exif_mnote_data_pentax_new (data->priv->mem);
 817         }
 818
 819         /*
 820          * If we are able to interpret the maker note, do so.
 821          */
 822         if (data->priv->md) {
 823                 exif_mnote_data_log (data->priv->md, data->priv->log);
 824                 exif_mnote_data_set_byte_order (data->priv->md,
 825                                                 data->priv->order);
 826                 exif_mnote_data_set_offset (data->priv->md,
 827                                             data->priv->offset_mnote);
 828                 exif_mnote_data_load (data->priv->md, d, ds);
 829         }
 830 }
 831
 832 #define LOG_TOO_SMALL \
 833 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData", \
 834                 _("Size of data too small to allow for EXIF data."));
 835
 836 void
 837 exif_data_load_data (ExifData *data, const unsigned char *d_orig,
 838                      unsigned int ds)
 839 {
 840         unsigned int l;
 841         ExifLong offset;
 842         ExifShort n;
 843         const unsigned char *d = d_orig;
 844         unsigned int len, fullds;
 845
 846         if (!data || !data->priv || !d || !ds)
 847                 return;
 848
 849         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 850                   "Parsing %i byte(s) EXIF data...\n", ds);
 851
 852         /*
 853          * It can be that the data starts with the EXIF header. If it does
 854          * not, search the EXIF marker.
 855          */
 856         if (ds < 6) {
 857                 LOG_TOO_SMALL;
 858                 return;
 859         }
 860         if (!memcmp (d, ExifHeader, 6)) {
 861                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 862                           "Found EXIF header at start.");
 863         } else {
 864                 while (ds >= 3) {
 865                         while (ds && (d[0] == 0xff)) {
 866                                 d++;
 867                                 ds--;
 868                         }
 869
 870                         /* JPEG_MARKER_SOI */
 871                         if (ds && d[0] == JPEG_MARKER_SOI) {
 872                                 d++;
 873                                 ds--;
 874                                 continue;
 875                         }
 876
 877                         /* JPEG_MARKER_APP1 */
 878                         if (ds && d[0] == JPEG_MARKER_APP1)
 879                                 break;
 880
 881                         /* Skip irrelevant APP markers. The branch for APP1 must come before this,
 882                            otherwise this code block will cause APP1 to be skipped. This code path
 883                            is only relevant for files that are nonconformant to the EXIF
 884                            specification. For conformant files, the APP1 code path above will be
 885                            taken. */
 886                         if (ds >= 3 && d[0] >= 0xe0 && d[0] <= 0xef) {  /* JPEG_MARKER_APPn */
 887                                 d++;
 888                                 ds--;
 889                                 l = (d[0] << 8) | d[1];
 890                                 if (l > ds)
 891                                         return;
 892                                 d += l;
 893                                 ds -= l;
 894                                 continue;
 895                         }
 896
 897                         /* Unknown marker or data. Give up. */
 898                         exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
 899                                   "ExifData", _("EXIF marker not found."));
 900                         return;
 901                 }
 902                 if (ds < 3) {
 903                         LOG_TOO_SMALL;
 904                         return;
 905                 }
 906                 d++;
 907                 ds--;
 908                 len = (d[0] << 8) | d[1];
 909                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 910                           "We have to deal with %i byte(s) of EXIF data.",
 911                           len);
 912                 d += 2;
 913                 ds -= 2;
 914         }
 915
 916         /*
 917          * Verify the exif header
 918          * (offset 2, length 6).
 919          */
 920         if (ds < 6) {
 921                 LOG_TOO_SMALL;
 922                 return;
 923         }
 924         if (memcmp (d, ExifHeader, 6)) {
 925                 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
 926                           "ExifData", _("EXIF header not found."));
 927                 return;
 928         }
 929
 930         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 931                   "Found EXIF header.");
 932
 933         /* Sanity check the data length */
 934         if (ds < 14)
 935                 return;
 936
 937         /* The JPEG APP1 section can be no longer than 64 KiB (including a
 938            16-bit length), so cap the data length to protect against overflow
 939            in future offset calculations */
 940         fullds = ds;
 941         if (ds > 0xfffe)
 942                 ds = 0xfffe;
 943
 944         /* Byte order (offset 6, length 2) */
 945         if (!memcmp (d + 6, "II", 2))
 946                 data->priv->order = EXIF_BYTE_ORDER_INTEL;
 947         else if (!memcmp (d + 6, "MM", 2))
 948                 data->priv->order = EXIF_BYTE_ORDER_MOTOROLA;
 949         else {
 950                 exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
 951                           "ExifData", _("Unknown encoding."));
 952                 return;
 953         }
 954
 955         /* Fixed value */
 956         if (exif_get_short (d + 8, data->priv->order) != 0x002a)
 957                 return;
 958
 959         /* IFD 0 offset */
 960         offset = exif_get_long (d + 10, data->priv->order);
 961         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 962                   "IFD 0 at %i.", (int) offset);
 963
 964         /* ds is restricted to 16 bit above, so offset is restricted too, and offset+8 should not overflow. */
 965         if (offset > ds || offset + 6 + 2 > ds)
 966                 return;
 967
 968         /* Parse the actual exif data (usually offset 14 from start) */
 969         exif_data_load_data_content (data, EXIF_IFD_0, d + 6, ds - 6, offset, 0);
 970
 971         /* IFD 1 offset */
 972         n = exif_get_short (d + 6 + offset, data->priv->order);
 973         /* offset < 2<<16, n is 16 bit at most, so this op will not overflow */
 974         if (offset + 6 + 2 + 12 * n + 4 > ds)
 975                 return;
 976
 977         offset = exif_get_long (d + 6 + offset + 2 + 12 * n, data->priv->order);
 978         if (offset) {
 979                 exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
 980                           "IFD 1 at %i.", (int) offset);
 981
 982                 /* Sanity check. ds is ensured to be above 6 above, offset is 16bit */
 983                 if (offset > ds - 6) {
 984                         exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA,
 985                                   "ExifData", "Bogus offset of IFD1.");
 986                 } else {
 987                    exif_data_load_data_content (data, EXIF_IFD_1, d + 6, ds - 6, offset, 0);
 988                 }
 989         }
 990
 991         /*
 992          * If we got an EXIF_TAG_MAKER_NOTE, try to interpret it. Some
 993          * cameras use pointers in the maker note tag that point to the
 994          * space between IFDs. Here is the only place where we have access
 995          * to that data.
 996          */
 997         interpret_maker_note(data, d, fullds);
 998
 999         /* Fixup tags if requested */
1000         if (data->priv->options & EXIF_DATA_OPTION_FOLLOW_SPECIFICATION)
1001                 exif_data_fix (data);
1002 }
1003
1004 void
1005 exif_data_save_data (ExifData *data, unsigned char **d, unsigned int *ds)
1006 {
1007         if (ds)
1008                 *ds = 0;        /* This means something went wrong */
1009
1010         if (!data || !d || !ds)
1011                 return;
1012
1013         /* Header */
1014         *ds = 14;
1015         *d = exif_data_alloc (data, *ds);
1016         if (!*d)  {
1017                 *ds = 0;
1018                 return;
1019         }
1020         memcpy (*d, ExifHeader, 6);
1021
1022         /* Order (offset 6) */
1023         if (data->priv->order == EXIF_BYTE_ORDER_INTEL) {
1024                 memcpy (*d + 6, "II", 2);
1025         } else {
1026                 memcpy (*d + 6, "MM", 2);
1027         }
1028
1029         /* Fixed value (2 bytes, offset 8) */
1030         exif_set_short (*d + 8, data->priv->order, 0x002a);
1031
1032         /*
1033          * IFD 0 offset (4 bytes, offset 10).
1034          * We will start 8 bytes after the
1035          * EXIF header (2 bytes for order, another 2 for the test, and
1036          * 4 bytes for the IFD 0 offset make 8 bytes together).
1037          */
1038         exif_set_long (*d + 10, data->priv->order, 8);
1039
1040         /* Now save IFD 0. IFD 1 will be saved automatically. */
1041         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1042                   "Saving IFDs...");
1043         exif_data_save_data_content (data, data->ifd[EXIF_IFD_0], d, ds,
1044                                      *ds - 6);
1045         exif_log (data->priv->log, EXIF_LOG_CODE_DEBUG, "ExifData",
1046                   "Saved %i byte(s) EXIF data.", *ds);
1047 }
1048
1049 ExifData *
1050 exif_data_new_from_file (const char *path)
1051 {
1052         ExifData *edata;
1053         ExifLoader *loader;
1054
1055         loader = exif_loader_new ();
1056         exif_loader_write_file (loader, path);
1057         edata = exif_loader_get_data (loader);
1058         exif_loader_unref (loader);
1059
1060         return (edata);
1061 }
1062
1063 void
1064 exif_data_ref (ExifData *data)
1065 {
1066         if (!data)
1067                 return;
1068
1069         data->priv->ref_count++;
1070 }
1071
1072 void
1073 exif_data_unref (ExifData *data)
1074 {
1075         if (!data)
1076                 return;
1077
1078         data->priv->ref_count--;
1079         if (!data->priv->ref_count)
1080                 exif_data_free (data);
1081 }
1082
1083 void
1084 exif_data_free (ExifData *data)
1085 {
1086         unsigned int i;
1087         ExifMem *mem = (data && data->priv) ? data->priv->mem : NULL;
1088
1089         if (!data)
1090                 return;
1091
1092         for (i = 0; i < EXIF_IFD_COUNT; i++) {
1093                 if (data->ifd[i]) {
1094                         exif_content_unref (data->ifd[i]);
1095                         data->ifd[i] = NULL;
1096                 }
1097         }
1098
1099         if (data->data) {
1100                 exif_mem_free (mem, data->data);
1101                 data->data = NULL;
1102         }
1103
1104         if (data->priv) {
1105                 if (data->priv->log) {
1106                         exif_log_unref (data->priv->log);
1107                         data->priv->log = NULL;
1108                 }
1109                 if (data->priv->md) {
1110                         exif_mnote_data_unref (data->priv->md);
1111                         data->priv->md = NULL;
1112                 }
1113                 exif_mem_free (mem, data->priv);
1114                 exif_mem_free (mem, data);
1115         }
1116
1117         exif_mem_unref (mem);
1118 }
1119
1120 void
1121 exif_data_dump (ExifData *data)
1122 {
1123         unsigned int i;
1124
1125         if (!data)
1126                 return;
1127
1128         for (i = 0; i < EXIF_IFD_COUNT; i++) {
1129                 if (data->ifd[i] && data->ifd[i]->count) {
1130                         printf ("Dumping IFD '%s'...\n",
1131                                 exif_ifd_get_name (i));
1132                         exif_content_dump (data->ifd[i], 0);
1133                 }
1134         }
1135
1136         if (data->data) {
1137                 printf ("%i byte(s) thumbnail data available: ", data->size);
1138                 if (data->size >= 4) {
1139                         printf ("0x%02x 0x%02x ... 0x%02x 0x%02x\n",
1140                                 data->data[0], data->data[1],
1141                                 data->data[data->size - 2],
1142                                 data->data[data->size - 1]);
1143                 }
1144         }
1145 }
1146
1147 ExifByteOrder
1148 exif_data_get_byte_order (ExifData *data)
1149 {
1150         if (!data)
1151                 return (0);
1152
1153         return (data->priv->order);
1154 }
1155
1156 void
1157 exif_data_foreach_content (ExifData *data, ExifDataForeachContentFunc func,
1158                            void *user_data)
1159 {
1160         unsigned int i;
1161
1162         if (!data || !func)
1163                 return;
1164
1165         for (i = 0; i < EXIF_IFD_COUNT; i++)
1166                 func (data->ifd[i], user_data);
1167 }
1168
1169 typedef struct _ByteOrderChangeData ByteOrderChangeData;
1170 struct _ByteOrderChangeData {
1171         ExifByteOrder old, new;
1172 };
1173
1174 static void
1175 entry_set_byte_order (ExifEntry *e, void *data)
1176 {
1177         ByteOrderChangeData *d = data;
1178
1179         if (!e)
1180                 return;
1181
1182         exif_array_set_byte_order (e->format, e->data, e->components, d->old, d->new);
1183 }
1184
1185 static void
1186 content_set_byte_order (ExifContent *content, void *data)
1187 {
1188         exif_content_foreach_entry (content, entry_set_byte_order, data);
1189 }
1190
1191 void
1192 exif_data_set_byte_order (ExifData *data, ExifByteOrder order)
1193 {
1194         ByteOrderChangeData d;
1195
1196         if (!data || (order == data->priv->order))
1197                 return;
1198
1199         d.old = data->priv->order;
1200         d.new = order;
1201         exif_data_foreach_content (data, content_set_byte_order, &d);
1202         data->priv->order = order;
1203         if (data->priv->md)
1204                 exif_mnote_data_set_byte_order (data->priv->md, order);
1205 }
1206
1207 void
1208 exif_data_log (ExifData *data, ExifLog *log)
1209 {
1210         unsigned int i;
1211
1212         if (!data || !data->priv)
1213                 return;
1214         exif_log_unref (data->priv->log);
1215         data->priv->log = log;
1216         exif_log_ref (log);
1217
1218         for (i = 0; i < EXIF_IFD_COUNT; i++)
1219                 exif_content_log (data->ifd[i], log);
1220 }
1221
1222 /* Used internally within libexif */
1223 ExifLog *exif_data_get_log (ExifData *);
1224 ExifLog *
1225 exif_data_get_log (ExifData *data)
1226 {
1227         if (!data || !data->priv)
1228                 return NULL;
1229         return data->priv->log;
1230 }
1231
1232 static const struct {
1233         ExifDataOption option;
1234         const char *name;
1235         const char *description;
1236 } exif_data_option[] = {
1237         {EXIF_DATA_OPTION_IGNORE_UNKNOWN_TAGS, N_("Ignore unknown tags"),
1238          N_("Ignore unknown tags when loading EXIF data.")},
1239         {EXIF_DATA_OPTION_FOLLOW_SPECIFICATION, N_("Follow specification"),
1240          N_("Add, correct and remove entries to get EXIF data that follows "
1241             "the specification.")},
1242         {EXIF_DATA_OPTION_DONT_CHANGE_MAKER_NOTE, N_("Do not change maker note"),
1243          N_("When loading and resaving Exif data, save the maker note unmodified."
1244             " Be aware that the maker note can get corrupted.")},
1245         {0, NULL, NULL}
1246 };
1247
1248 const char *
1249 exif_data_option_get_name (ExifDataOption o)
1250 {
1251         unsigned int i;
1252
1253         for (i = 0; exif_data_option[i].name; i++)
1254                 if (exif_data_option[i].option == o)
1255                         break;
1256         return _(exif_data_option[i].name);
1257 }
1258
1259 const char *
1260 exif_data_option_get_description (ExifDataOption o)
1261 {
1262         unsigned int i;
1263
1264         for (i = 0; exif_data_option[i].description; i++)
1265                 if (exif_data_option[i].option == o)
1266                         break;
1267         return _(exif_data_option[i].description);
1268 }
1269
1270 void
1271 exif_data_set_option (ExifData *d, ExifDataOption o)
1272 {
1273         if (!d)
1274                 return;
1275
1276         d->priv->options |= o;
1277 }
1278
1279 void
1280 exif_data_unset_option (ExifData *d, ExifDataOption o)
1281 {
1282         if (!d)
1283                 return;
1284
1285         d->priv->options &= ~o;
1286 }
1287
1288 static void
1289 fix_func (ExifContent *c, void *UNUSED(data))
1290 {
1291         switch (exif_content_get_ifd (c)) {
1292         case EXIF_IFD_1:
1293                 if (c->parent->data)
1294                         exif_content_fix (c);
1295                 else if (c->count) {
1296                         exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1297                                   "No thumbnail but entries on thumbnail. These entries have been "
1298                                   "removed.");
1299                         while (c->count) {
1300                                 unsigned int cnt = c->count;
1301                                 exif_content_remove_entry (c, c->entries[c->count - 1]);
1302                                 if (cnt == c->count) {
1303                                         /* safety net */
1304                                         exif_log (c->parent->priv->log, EXIF_LOG_CODE_DEBUG, "exif-data",
1305                                         "failed to remove last entry from entries.");
1306                                         c->count--;
1307                                 }
1308                         }
1309                 }
1310                 break;
1311         default:
1312                 exif_content_fix (c);
1313         }
1314 }
1315
1316 void
1317 exif_data_fix (ExifData *d)
1318 {
1319         exif_data_foreach_content (d, fix_func, NULL);
1320 }
1321
1322 void
1323 exif_data_set_data_type (ExifData *d, ExifDataType dt)
1324 {
1325         if (!d || !d->priv)
1326                 return;
1327
1328         d->priv->data_type = dt;
1329 }
1330
1331 ExifDataType
1332 exif_data_get_data_type (ExifData *d)
1333 {
1334         return (d && d->priv) ? d->priv->data_type : EXIF_DATA_TYPE_UNKNOWN;
1335 }