Fetch libexif 0.6.21 to include the security fixes.

libexif/sources/libexif/olympus/mnote-olympus-entry.c

 /* mnote-olympus-entry.c
  *
  * Copyright (c) 2002-2009 Lutz Mueller <lutz@users.sourceforge.net> et. al.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 58 matching lines @@
 {                                                                       \
         if ((number < t1) || (number > t2)) {                           \
                 snprintf (v, maxlen,                                    \
                         _("Invalid number of components (%i, "          \
                         "expected %i or %i)."), (int) number,           \
                         (int) t1, (int) t2);                            \
                 break;                                                  \
         }                                                               \
 }
 
+#define R2L(n) ((n).denominator ? (long)(n).numerator/(n).denominator : 0L)
+#define R2D(n) ((n).denominator ? (double)(n).numerator/(n).denominator : 0.0)
+
 static const struct {
         ExifTag tag;
         ExifFormat fmt;
         struct {
                 int index;
                 const char *string;
         } elem[24];
 } items[] = {
 #ifndef NO_VERBOSE_TAG_DATA
   { MNOTE_NIKON_TAG_LENSTYPE, EXIF_FORMAT_BYTE,
@@ skipping 191 matching lines @@
 
         if (!entry)
                 return (NULL);
 
         memset (v, 0, maxlen);
         maxlen--;
 
         if ((!entry->data) && (entry->components > 0)) 
                 return (v);
 
+        if ((!entry->data) && (entry->size > 0))
+                return NULL;  /* internal inconsistency error */
+
         switch (entry->tag) {
         
         /* Nikon */
         case MNOTE_NIKON_TAG_FIRMWARE:
                 CF (entry->format,  EXIF_FORMAT_UNDEFINED, v, maxlen);
                 CC (entry->components, 4, v, maxlen);
                 vl = exif_get_long (entry->data, entry->order);
                 if ((vl & 0xF0F0F0F0) == 0x30303030) {
                         memcpy (v, entry->data, MIN (maxlen, 4));
                 } else {
@@ skipping 62 matching lines @@
         case MNOTE_OLYMPUS_TAG_LENSTEMPERATURE:
                 CF (entry->format, EXIF_FORMAT_SSHORT, v, maxlen);
                 CC (entry->components, 1, v, maxlen);
                 vs = exif_get_short (entry->data, entry->order);
                 snprintf (v, maxlen, "%hd", vs);
                 break;
         case MNOTE_NIKON_TAG_WHITEBALANCERB:
                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
                 CC (entry->components, 4, v, maxlen);
                 vr = exif_get_rational (entry->data, entry->order);
-                r = (double)vr.numerator / vr.denominator;
+                r = R2D(vr);
                 vr = exif_get_rational (entry->data+8, entry->order);
-                b = (double)vr.numerator / vr.denominator;
+                b = R2D(vr);
                 snprintf (v, maxlen, _("Red Correction %f, blue Correction %f"), r,b);
                 break;
         case MNOTE_NIKON_TAG_MANUALFOCUSDISTANCE:
                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
                 CC (entry->components, 1, v, maxlen);
                 vr = exif_get_rational (entry->data, entry->order);
-                if (vr.numerator) {
-                        r = (double)vr.numerator / vr.denominator;
+                if (!vr.numerator || !vr.denominator) {
+                        strncpy (v, _("No manual focus selection"), maxlen);
+                } else {
+                        r = R2D(vr);
                         snprintf (v, maxlen, _("%2.2f meters"), r);
-                } else {
-                        strncpy (v, _("No manual focus selection"), maxlen);
                 }
                 break;
         case MNOTE_NIKON_TAG_SENSORPIXELSIZE:
                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
                 CC (entry->components, 2, v, maxlen);
                 vr = exif_get_rational (entry->data, entry->order);
                 vr2 = exif_get_rational (entry->data+8, entry->order);
-                r = (double)vr.numerator / vr.denominator;
-                b = (double)vr2.numerator / vr2.denominator;
+                r = R2D(vr);
+                b = R2D(vr2);
                 snprintf (v, maxlen, "%2.2f x %2.2f um", r, b);
                 break;
         case MNOTE_NIKON_TAG_BRACKETING:
                 CF2 (entry->format, EXIF_FORMAT_BYTE, EXIF_FORMAT_SHORT, v, maxlen);
                 CC (entry->components, 1, v, maxlen);
                 if (EXIF_FORMAT_SHORT == entry->format) {
                         vs = exif_get_short (entry->data, entry->order);
                 } else {
                         vs = entry->data[0];
                 }
@@ skipping 35 matching lines @@
                 if (items[i].elem[j].index != vs) {
                         snprintf (v, maxlen, _("Unknown value %hi"), vs);
                         break;
                 }
                 strncpy (v, _(items[i].elem[j].string), maxlen);
                 break;
         case MNOTE_OLYMPUS_TAG_DIGIZOOM:
                 if (entry->format == EXIF_FORMAT_RATIONAL) {
                         CC (entry->components, 1, v, maxlen);
                         vr = exif_get_rational (entry->data, entry->order);
-                        if (!vr.numerator) {
+                        if (!vr.numerator || !vr.denominator) {
                                 strncpy (v, _("None"), maxlen);
                         } else {
-                                r = (double)vr.numerator / vr.denominator;
+                                r = R2D(vr);
                                 snprintf (v, maxlen, "%2.2f", r);
                         }
                         break;
                 }
                 /* fall through to handle SHORT version of this tag */
         case MNOTE_NIKON_TAG_LENSTYPE:
         case MNOTE_NIKON_TAG_FLASHUSED:
         case MNOTE_NIKON1_TAG_QUALITY:
         case MNOTE_NIKON1_TAG_COLORMODE:
         case MNOTE_NIKON1_TAG_IMAGEADJUSTMENT:
@@ skipping 94 matching lines @@
                         break;
                 }
                 break;
         case MNOTE_NIKON_TAG_LENS:
                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
                 CC (entry->components, 4, v, maxlen);
                 {
                         double c,d;
                         unsigned long a,b;
                         vr = exif_get_rational (entry->data, entry->order);
-                        a = vr.numerator / vr.denominator;
+                        a = R2L(vr);
                         vr = exif_get_rational (entry->data+8, entry->order);
-                        b = vr.numerator / vr.denominator;
+                        b = R2L(vr);
                         vr = exif_get_rational (entry->data+16, entry->order);
-                        c = (double)vr.numerator / vr.denominator;
+                        c = R2D(vr);
                         vr = exif_get_rational (entry->data+24, entry->order);
-                        d = (double)vr.numerator / vr.denominator;
+                        d = R2D(vr);
                         snprintf (v, maxlen, "%ld-%ldmm 1:%3.1f - %3.1f",a,b,c,d);
                 }
                 break;
 
         /* Olympus */
         case MNOTE_OLYMPUS_TAG_MODE:
                 CF (entry->format, EXIF_FORMAT_LONG, v, maxlen);
                 CC (entry->components, 3, v, maxlen);
                 vl = exif_get_long (entry->data, entry->order);
                 switch (vl) {
@@ skipping 87 matching lines @@
                 for (i=0; i < (int)entry->components; ++i) {
                         vl = exif_get_long (entry->data+4*i, entry->order);
                         sprintf (buf, "%lu ", (unsigned long)vl);
                         strncat (v, buf, maxlen - strlen (v));
                 }
                 break;
         case MNOTE_OLYMPUS_TAG_FOCUSDIST:
                 CF (entry->format, EXIF_FORMAT_RATIONAL, v, maxlen);
                 CC (entry->components, 1, v, maxlen);
                 vr = exif_get_rational (entry->data, entry->order);
-                if (vr.numerator == 0) {
+                if (!vr.numerator || !vr.denominator) {
                         strncpy (v, _("Unknown"), maxlen);
                 }
                 else {
                         unsigned long tmp = vr.numerator / vr.denominator;
                         snprintf (v, maxlen, "%li mm", tmp);
                 }
                 break;
         case MNOTE_OLYMPUS_TAG_WBALANCE:
                 CF (entry->format, EXIF_FORMAT_SHORT, v, maxlen);
                 CC (entry->components, 2, v, maxlen);
@@ skipping 90 matching lines @@
                         CC (entry->components, 1, v, maxlen);
                         vl = exif_get_long (entry->data, entry->order);
                         snprintf (v, maxlen, "%li", (long int) vl);
                         break;
                 case EXIF_FORMAT_RATIONAL:
                         CC (entry->components, 1, v, maxlen);
                         vr = exif_get_rational (entry->data, entry->order);
                         if (!vr.denominator) {
                                 strncpy (v, _("Infinite"), maxlen);
                         } else {
-                                r = (double)vr.numerator / vr.denominator;
+                                r = R2D(vr);
                                 snprintf (v, maxlen, "%2.3f", r);
                         }
                         break;
                 case EXIF_FORMAT_SRATIONAL:
                         CC (entry->components, 1, v, maxlen);
                         vsr = exif_get_srational (entry->data, entry->order);
                         if (!vsr.denominator) {
                                 strncpy (v, _("Infinite"), maxlen);
                         } else {
-                                r = (double)vsr.numerator / vsr.denominator;
+                                r = R2D(vsr);
                                 snprintf (v, maxlen, "%2.3f", r);
                         }
                         break;
                 case EXIF_FORMAT_UNDEFINED:
                 default:
                         snprintf (v, maxlen, _("%i bytes unknown data: "),
                                   entry->size);
                         for (i = 0; i < (int)entry->size; i++) {
                                 sprintf (buf, "%02x", entry->data[i]);
                                 strncat (v, buf, maxlen - strlen (v));
                         }
                         break;
                 }
                 break;
         }
 
         return (v);
 }