From 4c3a9d79f1af75347eca4614638a19e701bdfc4b Mon Sep 17 00:00:00 2001
From: Dustin Oprea <myselfasunder@gmail.com>
Date: Thu, 7 Jun 2018 23:18:36 -0400
Subject: [PATCH] ifd_enumerate: Properly handle unknown-type tags during the
 initial parse.

---
 ifd_enumerate.go | 70 +++++++++++++++++++++++++-----------------------
 1 file changed, 37 insertions(+), 33 deletions(-)

diff --git a/ifd_enumerate.go b/ifd_enumerate.go
index 09b42d6..6335ceb 100644
--- a/ifd_enumerate.go
+++ b/ifd_enumerate.go
@@ -194,44 +194,48 @@ func (ie *IfdEnumerate) resolveTagValue(ite *IfdTagEntry) (valueBytes []byte, is
         }
 
         value, err := UndefinedValue(ite.Ii, ite.TagId, valueContext, ie.byteOrder)
-        log.PanicIf(err)
+        if err != nil {
+            if log.Is(err, ErrUnhandledUnknownTypedTag) == true {
+                valueBytes = []byte(UnparseableUnknownTagValuePlaceholder)
+                return valueBytes, true, nil
+            } else {
+                log.Panic(err)
+            }
+        } else {
+            switch value.(type) {
+            case []byte:
+                return value.([]byte), false, nil
+            case string:
+                return []byte(value.(string)), false, nil
+            case UnknownTagValue:
+                valueBytes, err := value.(UnknownTagValue).ValueBytes()
+                log.PanicIf(err)
 
-        switch value.(type) {
-        case []byte:
-            return value.([]byte), false, nil
-        case string:
-            return []byte(value.(string)), false, nil
-        case UnknownTagValue:
-            valueBytes, err := value.(UnknownTagValue).ValueBytes()
-
-// TODO(dustin): Is this always bytes? What about the tag-specific structures that are built? Handle unhandled unknown. Set isUnhandledUnknown.
-
-            log.PanicIf(err)
-
-            return valueBytes, false, nil
-        default:
+                return valueBytes, false, nil
+            default:
 // TODO(dustin): !! Finish translating the rest of the types (make reusable and replace into other similar implementations?)
-            log.Panicf("can not produce bytes for unknown-type tag (0x%04x): [%s]", ite.TagId, reflect.TypeOf(value))
+                log.Panicf("can not produce bytes for unknown-type tag (0x%04x): [%s]", ite.TagId, reflect.TypeOf(value))
+            }
         }
-    }
-
-    originalType := NewTagType(ite.TagType, ie.byteOrder)
-    byteCount := uint32(originalType.Size()) * ite.UnitCount
-
-    tt := NewTagType(TypeByte, ie.byteOrder)
-
-    if tt.ValueIsEmbedded(byteCount) == true {
-        iteLogger.Debugf(nil, "Reading BYTE value (ITE; embedded).")
-
-        // In this case, the bytes normally used for the offset are actually
-        // data.
-        valueBytes, err = tt.ParseBytes(ite.RawValueOffset, byteCount)
-        log.PanicIf(err)
     } else {
-        iteLogger.Debugf(nil, "Reading BYTE value (ITE; at offset).")
+        originalType := NewTagType(ite.TagType, ie.byteOrder)
+        byteCount := uint32(originalType.Size()) * ite.UnitCount
 
-        valueBytes, err = tt.ParseBytes(addressableData[ite.ValueOffset:], byteCount)
-        log.PanicIf(err)
+        tt := NewTagType(TypeByte, ie.byteOrder)
+
+        if tt.ValueIsEmbedded(byteCount) == true {
+            iteLogger.Debugf(nil, "Reading BYTE value (ITE; embedded).")
+
+            // In this case, the bytes normally used for the offset are actually
+            // data.
+            valueBytes, err = tt.ParseBytes(ite.RawValueOffset, byteCount)
+            log.PanicIf(err)
+        } else {
+            iteLogger.Debugf(nil, "Reading BYTE value (ITE; at offset).")
+
+            valueBytes, err = tt.ParseBytes(addressableData[ite.ValueOffset:], byteCount)
+            log.PanicIf(err)
+        }
     }
 
     return valueBytes, false, nil