exif/
tiff.rs

1//
2// Copyright (c) 2016 KAMADA Ken'ichi.
3// All rights reserved.
4//
5// Redistribution and use in source and binary forms, with or without
6// modification, are permitted provided that the following conditions
7// are met:
8// 1. Redistributions of source code must retain the above copyright
9//    notice, this list of conditions and the following disclaimer.
10// 2. Redistributions in binary form must reproduce the above copyright
11//    notice, this list of conditions and the following disclaimer in the
12//    documentation and/or other materials provided with the distribution.
13//
14// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24// SUCH DAMAGE.
25//
26
27use std::fmt;
28use mutate_once::MutOnce;
29
30use crate::endian::{Endian, BigEndian, LittleEndian};
31use crate::error::Error;
32use crate::tag::{Context, Tag, UnitPiece};
33use crate::util::{atou16, ctou32};
34use crate::value;
35use crate::value::Value;
36use crate::value::get_type_info;
37
38// TIFF header magic numbers [EXIF23 4.5.2].
39const TIFF_BE: u16 = 0x4d4d;
40const TIFF_LE: u16 = 0x4949;
41const TIFF_FORTY_TWO: u16 = 0x002a;
42pub const TIFF_BE_SIG: [u8; 4] = [0x4d, 0x4d, 0x00, 0x2a];
43pub const TIFF_LE_SIG: [u8; 4] = [0x49, 0x49, 0x2a, 0x00];
44
45// Partially parsed TIFF field (IFD entry).
46// Value::Unknown is abused to represent a partially parsed value.
47// Such a value must never be exposed to the users of this library.
48#[derive(Debug)]
49pub struct IfdEntry {
50    // When partially parsed, the value is stored as Value::Unknown.
51    // Do not leak this field to the outside.
52    field: MutOnce<Field>,
53}
54
55impl IfdEntry {
56    pub fn ifd_num_tag(&self) -> (In, Tag) {
57        if self.field.is_fixed() {
58            let field = self.field.get_ref();
59            (field.ifd_num, field.tag)
60        } else {
61            let field = self.field.get_mut();
62            (field.ifd_num, field.tag)
63        }
64    }
65
66    pub fn ref_field<'a>(&'a self, data: &[u8], le: bool) -> &'a Field {
67        self.parse(data, le);
68        self.field.get_ref()
69    }
70
71    fn into_field(self, data: &[u8], le: bool) -> Field {
72        self.parse(data, le);
73        self.field.into_inner()
74    }
75
76    fn parse(&self, data: &[u8], le: bool) {
77        if !self.field.is_fixed() {
78            let mut field = self.field.get_mut();
79            if le {
80                Self::parse_value::<LittleEndian>(&mut field.value, data);
81            } else {
82                Self::parse_value::<BigEndian>(&mut field.value, data);
83            }
84        }
85    }
86
87    // Converts a partially parsed value into a real one.
88    fn parse_value<E>(value: &mut Value, data: &[u8]) where E: Endian {
89        match *value {
90            Value::Unknown(typ, cnt, ofs) => {
91                let (unitlen, parser) = get_type_info::<E>(typ);
92                if unitlen != 0 {
93                    *value = parser(data, ofs as usize, cnt as usize);
94                }
95            },
96            _ => panic!("value is already parsed"),
97        }
98    }
99}
100
101/// A TIFF/Exif field.
102#[derive(Debug, Clone)]
103pub struct Field {
104    /// The tag of this field.
105    pub tag: Tag,
106    /// The index of the IFD to which this field belongs.
107    pub ifd_num: In,
108    /// The value of this field.
109    pub value: Value,
110}
111
112/// An IFD number.
113///
114/// The IFDs are indexed from 0.  The 0th IFD is for the primary image
115/// and the 1st one is for the thumbnail.  Two associated constants,
116/// `In::PRIMARY` and `In::THUMBNAIL`, are defined for them respectively.
117///
118/// # Examples
119/// ```
120/// use exif::In;
121/// assert_eq!(In::PRIMARY.index(), 0);
122/// assert_eq!(In::THUMBNAIL.index(), 1);
123/// ```
124#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
125pub struct In(pub u16);
126
127impl In {
128    pub const PRIMARY: In = In(0);
129    pub const THUMBNAIL: In = In(1);
130
131    /// Returns the IFD number.
132    #[inline]
133    pub fn index(self) -> u16 {
134        self.0
135    }
136}
137
138impl fmt::Display for In {
139    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
140        match self.0 {
141            0 => f.pad("primary"),
142            1 => f.pad("thumbnail"),
143            n => f.pad(&format!("IFD{}", n)),
144        }
145    }
146}
147
148/// Parse the Exif attributes in the TIFF format.
149///
150/// Returns a Vec of Exif fields and a bool.
151/// The boolean value is true if the data is little endian.
152/// If an error occurred, `exif::Error` is returned.
153pub fn parse_exif(data: &[u8]) -> Result<(Vec<Field>, bool), Error> {
154    let mut parser = Parser::new();
155    parser.parse(data)?;
156    let (entries, le) = (parser.entries, parser.little_endian);
157    Ok((entries.into_iter().map(|e| e.into_field(data, le)).collect(), le))
158}
159
160#[derive(Debug)]
161pub struct Parser {
162    pub entries: Vec<IfdEntry>,
163    pub little_endian: bool,
164    // `Some<Vec>` to enable the option and `None` to disable it.
165    pub continue_on_error: Option<Vec<Error>>,
166}
167
168impl Parser {
169    pub fn new() -> Self {
170        Self {
171            entries: Vec::new(),
172            little_endian: false,
173            continue_on_error: None,
174        }
175    }
176
177    pub fn parse(&mut self, data: &[u8]) -> Result<(), Error> {
178        // Check the byte order and call the real parser.
179        if data.len() < 8 {
180            return Err(Error::InvalidFormat("Truncated TIFF header"));
181        }
182        match BigEndian::loadu16(data, 0) {
183            TIFF_BE => {
184                self.little_endian = false;
185                self.parse_header::<BigEndian>(data)
186            },
187            TIFF_LE => {
188                self.little_endian = true;
189                self.parse_header::<LittleEndian>(data)
190            },
191            _ => Err(Error::InvalidFormat("Invalid TIFF byte order")),
192        }
193    }
194
195    fn parse_header<E>(&mut self, data: &[u8])
196                       -> Result<(), Error> where E: Endian {
197        // Parse the rest of the header (42 and the IFD offset).
198        if E::loadu16(data, 2) != TIFF_FORTY_TWO {
199            return Err(Error::InvalidFormat("Invalid forty two"));
200        }
201        let ifd_offset = E::loadu32(data, 4) as usize;
202        self.parse_body::<E>(data, ifd_offset)
203            .or_else(|e| self.check_error(e))
204    }
205
206    fn parse_body<E>(&mut self, data: &[u8], mut ifd_offset: usize)
207                     -> Result<(), Error> where E: Endian {
208        let mut ifd_num_ck = Some(0);
209        while ifd_offset != 0 {
210            let ifd_num = ifd_num_ck
211                .ok_or(Error::InvalidFormat("Too many IFDs"))?;
212            // Limit the number of IFDs to defend against resource exhaustion
213            // attacks.
214            if ifd_num >= 8 {
215                return Err(Error::InvalidFormat("Limit the IFD count to 8"));
216            }
217            ifd_offset = self.parse_ifd::<E>(
218                data, ifd_offset, Context::Tiff, ifd_num)?;
219            ifd_num_ck = ifd_num.checked_add(1);
220        }
221        Ok(())
222    }
223
224    // Parse IFD [EXIF23 4.6.2].
225    fn parse_ifd<E>(&mut self, data: &[u8],
226                    mut offset: usize, ctx: Context, ifd_num: u16)
227                    -> Result<usize, Error> where E: Endian {
228        // Count (the number of the entries).
229        if data.len() < offset || data.len() - offset < 2 {
230            return Err(Error::InvalidFormat("Truncated IFD count"));
231        }
232        let count = E::loadu16(data, offset) as usize;
233        offset += 2;
234
235        // Array of entries.
236        for _ in 0..count {
237            if data.len() - offset < 12 {
238                return Err(Error::InvalidFormat("Truncated IFD"));
239            }
240            let entry = Self::parse_ifd_entry::<E>(data, offset);
241            offset += 12;
242            let (tag, val) = match entry {
243                Ok(x) => x,
244                Err(e) => {
245                    self.check_error(e)?;
246                    continue;
247                },
248            };
249
250            // No infinite recursion will occur because the context is not
251            // recursively defined.
252            let tag = Tag(ctx, tag);
253            let child_ctx = match tag {
254                Tag::ExifIFDPointer => Context::Exif,
255                Tag::GPSInfoIFDPointer => Context::Gps,
256                Tag::InteropIFDPointer => Context::Interop,
257                _ => {
258                    self.entries.push(IfdEntry { field: Field {
259                        tag: tag, ifd_num: In(ifd_num), value: val }.into()});
260                    continue;
261                },
262            };
263            self.parse_child_ifd::<E>(data, val, child_ctx, ifd_num)
264                .or_else(|e| self.check_error(e))?;
265        }
266
267        // Offset to the next IFD.
268        if data.len() - offset < 4 {
269            return Err(Error::InvalidFormat("Truncated next IFD offset"));
270        }
271        let next_ifd_offset = E::loadu32(data, offset);
272        Ok(next_ifd_offset as usize)
273    }
274
275    fn parse_ifd_entry<E>(data: &[u8], offset: usize)
276                          -> Result<(u16, Value), Error> where E: Endian {
277        // The size of entry has been checked in parse_ifd().
278        let tag = E::loadu16(data, offset);
279        let typ = E::loadu16(data, offset + 2);
280        let cnt = E::loadu32(data, offset + 4);
281        let valofs_at = offset + 8;
282        let (unitlen, _parser) = get_type_info::<E>(typ);
283        let vallen = unitlen.checked_mul(cnt as usize).ok_or(
284            Error::InvalidFormat("Invalid entry count"))?;
285        let val = if vallen <= 4 {
286            Value::Unknown(typ, cnt, valofs_at as u32)
287        } else {
288            let ofs = E::loadu32(data, valofs_at) as usize;
289            if data.len() < ofs || data.len() - ofs < vallen {
290                return Err(Error::InvalidFormat("Truncated field value"));
291            }
292            Value::Unknown(typ, cnt, ofs as u32)
293        };
294        Ok((tag, val))
295    }
296
297    fn parse_child_ifd<E>(&mut self, data: &[u8],
298                          mut pointer: Value, ctx: Context, ifd_num: u16)
299                          -> Result<(), Error> where E: Endian {
300        // The pointer is not yet parsed, so do it here.
301        IfdEntry::parse_value::<E>(&mut pointer, data);
302
303        // A pointer field has type == LONG and count == 1, so the
304        // value (IFD offset) must be embedded in the "value offset"
305        // element of the field.
306        let ofs = pointer.get_uint(0).ok_or(
307            Error::InvalidFormat("Invalid pointer"))? as usize;
308        match self.parse_ifd::<E>(data, ofs, ctx, ifd_num)? {
309            0 => Ok(()),
310            _ => Err(Error::InvalidFormat("Unexpected next IFD")),
311        }
312    }
313
314    fn check_error(&mut self, err: Error) -> Result<(), Error> {
315        match self.continue_on_error {
316            Some(ref mut v) => Ok(v.push(err)),
317            None => Err(err),
318        }
319    }
320}
321
322pub fn is_tiff(buf: &[u8]) -> bool {
323    buf.starts_with(&TIFF_BE_SIG) || buf.starts_with(&TIFF_LE_SIG)
324}
325
326/// A struct used to parse a DateTime field.
327///
328/// # Examples
329/// ```
330/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
331/// use exif::DateTime;
332/// let dt = DateTime::from_ascii(b"2016:05:04 03:02:01")?;
333/// assert_eq!(dt.year, 2016);
334/// assert_eq!(dt.to_string(), "2016-05-04 03:02:01");
335/// # Ok(()) }
336/// ```
337#[derive(Debug)]
338pub struct DateTime {
339    pub year: u16,
340    pub month: u8,
341    pub day: u8,
342    pub hour: u8,
343    pub minute: u8,
344    pub second: u8,
345    /// The subsecond data in nanoseconds.  If the Exif attribute has
346    /// more sigfinicant digits, they are rounded down.
347    pub nanosecond: Option<u32>,
348    /// The offset of the time zone in minutes.
349    pub offset: Option<i16>,
350}
351
352impl DateTime {
353    /// Parse an ASCII data of a DateTime field.  The range of a number
354    /// is not validated, so, for example, 13 may be returned as the month.
355    ///
356    /// If the value is blank, `Error::BlankValue` is returned.
357    pub fn from_ascii(data: &[u8]) -> Result<DateTime, Error> {
358        if data == b"    :  :     :  :  " || data == b"                   " {
359            return Err(Error::BlankValue("DateTime is blank"));
360        } else if data.len() < 19 {
361            return Err(Error::InvalidFormat("DateTime too short"));
362        } else if !(data[4] == b':' && data[7] == b':' && data[10] == b' ' &&
363                    data[13] == b':' && data[16] == b':') {
364            return Err(Error::InvalidFormat("Invalid DateTime delimiter"));
365        }
366        Ok(DateTime {
367            year: atou16(&data[0..4])?,
368            month: atou16(&data[5..7])? as u8,
369            day: atou16(&data[8..10])? as u8,
370            hour: atou16(&data[11..13])? as u8,
371            minute: atou16(&data[14..16])? as u8,
372            second: atou16(&data[17..19])? as u8,
373            nanosecond: None,
374            offset: None,
375        })
376    }
377
378    /// Parses an SubsecTime-like field.
379    pub fn parse_subsec(&mut self, data: &[u8]) -> Result<(), Error> {
380        let mut subsec = 0;
381        let mut ndigits = 0;
382        for &c in data {
383            if c == b' ' {
384                break;
385            }
386            subsec = subsec * 10 + ctou32(c)?;
387            ndigits += 1;
388            if ndigits >= 9 {
389                break;
390            }
391        }
392        if ndigits == 0 {
393            self.nanosecond = None;
394        } else {
395            for _ in ndigits..9 {
396                subsec *= 10;
397            }
398            self.nanosecond = Some(subsec);
399        }
400        Ok(())
401    }
402
403    /// Parses an OffsetTime-like field.
404    pub fn parse_offset(&mut self, data: &[u8]) -> Result<(), Error> {
405        if data == b"   :  " || data == b"      " {
406            return Err(Error::BlankValue("OffsetTime is blank"));
407        } else if data.len() < 6 {
408            return Err(Error::InvalidFormat("OffsetTime too short"));
409        } else if data[3] != b':' {
410            return Err(Error::InvalidFormat("Invalid OffsetTime delimiter"));
411        }
412        let hour = atou16(&data[1..3])?;
413        let min = atou16(&data[4..6])?;
414        let offset = (hour * 60 + min) as i16;
415        self.offset = Some(match data[0] {
416            b'+' => offset,
417            b'-' => -offset,
418            _ => return Err(Error::InvalidFormat("Invalid OffsetTime sign")),
419        });
420        Ok(())
421    }
422}
423
424impl fmt::Display for DateTime {
425    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
426        write!(f, "{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
427               self.year, self.month, self.day,
428               self.hour, self.minute, self.second)
429    }
430}
431
432impl Field {
433    /// Returns an object that implements `std::fmt::Display` for
434    /// printing the value of this field in a tag-specific format.
435    ///
436    /// To print the value with the unit, call `with_unit` method on the
437    /// returned object.  It takes a parameter, which is either `()`,
438    /// `&Field`, or `&Exif`, that provides the unit information.
439    /// If the unit does not depend on another field, `()` can be used.
440    /// Otherwise, `&Field` or `&Exif` should be used.
441    ///
442    /// # Examples
443    ///
444    /// ```
445    /// use exif::{Field, In, Tag, Value};
446    ///
447    /// let xres = Field {
448    ///     tag: Tag::XResolution,
449    ///     ifd_num: In::PRIMARY,
450    ///     value: Value::Rational(vec![(72, 1).into()]),
451    /// };
452    /// let resunit = Field {
453    ///     tag: Tag::ResolutionUnit,
454    ///     ifd_num: In::PRIMARY,
455    ///     value: Value::Short(vec![3]),
456    /// };
457    /// assert_eq!(xres.display_value().to_string(), "72");
458    /// assert_eq!(resunit.display_value().to_string(), "cm");
459    /// // The unit of XResolution is indicated by ResolutionUnit.
460    /// assert_eq!(xres.display_value().with_unit(&resunit).to_string(),
461    ///            "72 pixels per cm");
462    /// // If ResolutionUnit is not given, the default value is used.
463    /// assert_eq!(xres.display_value().with_unit(()).to_string(),
464    ///            "72 pixels per inch");
465    /// assert_eq!(xres.display_value().with_unit(&xres).to_string(),
466    ///            "72 pixels per inch");
467    ///
468    /// let flen = Field {
469    ///     tag: Tag::FocalLengthIn35mmFilm,
470    ///     ifd_num: In::PRIMARY,
471    ///     value: Value::Short(vec![24]),
472    /// };
473    /// // The unit of the focal length is always mm, so the argument
474    /// // has nothing to do with the result.
475    /// assert_eq!(flen.display_value().with_unit(()).to_string(),
476    ///            "24 mm");
477    /// assert_eq!(flen.display_value().with_unit(&resunit).to_string(),
478    ///            "24 mm");
479    /// ```
480    #[inline]
481    pub fn display_value(&self) -> DisplayValue {
482        DisplayValue {
483            tag: self.tag,
484            ifd_num: self.ifd_num,
485            value_display: self.value.display_as(self.tag),
486        }
487    }
488}
489
490/// Helper struct for printing a value in a tag-specific format.
491pub struct DisplayValue<'a> {
492    tag: Tag,
493    ifd_num: In,
494    value_display: value::Display<'a>,
495}
496
497impl<'a> DisplayValue<'a> {
498    #[inline]
499    pub fn with_unit<T>(&self, unit_provider: T)
500                        -> DisplayValueUnit<'a, T> where T: ProvideUnit<'a> {
501        DisplayValueUnit {
502            ifd_num: self.ifd_num,
503            value_display: self.value_display,
504            unit: self.tag.unit(),
505            unit_provider: unit_provider,
506        }
507    }
508}
509
510impl<'a> fmt::Display for DisplayValue<'a> {
511    #[inline]
512    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
513        self.value_display.fmt(f)
514    }
515}
516
517/// Helper struct for printing a value with its unit.
518pub struct DisplayValueUnit<'a, T> where T: ProvideUnit<'a> {
519    ifd_num: In,
520    value_display: value::Display<'a>,
521    unit: Option<&'static [UnitPiece]>,
522    unit_provider: T,
523}
524
525impl<'a, T> fmt::Display for DisplayValueUnit<'a, T> where T: ProvideUnit<'a> {
526    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
527        if let Some(unit) = self.unit {
528            assert!(!unit.is_empty());
529            for piece in unit {
530                match *piece {
531                    UnitPiece::Value => self.value_display.fmt(f),
532                    UnitPiece::Str(s) => f.write_str(s),
533                    UnitPiece::Tag(tag) =>
534                        if let Some(x) = self.unit_provider.get_field(
535                                tag, self.ifd_num) {
536                            x.value.display_as(tag).fmt(f)
537                        } else if let Some(x) = tag.default_value() {
538                            x.display_as(tag).fmt(f)
539                        } else {
540                            write!(f, "[{} missing]", tag)
541                        },
542                }?
543            }
544            Ok(())
545        } else {
546            self.value_display.fmt(f)
547        }
548    }
549}
550
551pub trait ProvideUnit<'a>: Copy {
552    fn get_field(self, tag: Tag, ifd_num: In) -> Option<&'a Field>;
553}
554
555impl<'a> ProvideUnit<'a> for () {
556    fn get_field(self, _tag: Tag, _ifd_num: In) -> Option<&'a Field> {
557        None
558    }
559}
560
561impl<'a> ProvideUnit<'a> for &'a Field {
562    fn get_field(self, tag: Tag, ifd_num: In) -> Option<&'a Field> {
563        Some(self).filter(|x| x.tag == tag && x.ifd_num == ifd_num)
564    }
565}
566
567#[cfg(test)]
568mod tests {
569    use super::*;
570
571    #[test]
572    fn in_convert() {
573        assert_eq!(In::PRIMARY.index(), 0);
574        assert_eq!(In::THUMBNAIL.index(), 1);
575        assert_eq!(In(2).index(), 2);
576        assert_eq!(In(65535).index(), 65535);
577        assert_eq!(In::PRIMARY, In(0));
578    }
579
580    #[test]
581    fn in_display() {
582        assert_eq!(format!("{:10}", In::PRIMARY), "primary   ");
583        assert_eq!(format!("{:>10}", In::THUMBNAIL), " thumbnail");
584        assert_eq!(format!("{:10}", In(2)), "IFD2      ");
585        assert_eq!(format!("{:^10}", In(65535)), " IFD65535 ");
586    }
587
588    #[test]
589    fn truncated() {
590        let mut data =
591            b"MM\0\x2a\0\0\0\x08\
592              \0\x01\x01\0\0\x03\0\0\0\x01\0\x14\0\0\0\0\0\0".to_vec();
593        parse_exif(&data).unwrap();
594        while let Some(_) = data.pop() {
595            parse_exif(&data).unwrap_err();
596        }
597    }
598
599    // Before the error is returned, the IFD is parsed multiple times
600    // as the 0th, 1st, ..., and n-th IFDs.
601    #[test]
602    fn inf_loop_by_next() {
603        let data = b"MM\0\x2a\0\0\0\x08\
604                     \0\x01\x01\0\0\x03\0\0\0\x01\0\x14\0\0\0\0\0\x08";
605        assert_err_pat!(parse_exif(data),
606                        Error::InvalidFormat("Limit the IFD count to 8"));
607    }
608
609    #[test]
610    fn inf_loop_by_exif_next() {
611        let data = b"MM\x00\x2a\x00\x00\x00\x08\
612                     \x00\x01\x87\x69\x00\x04\x00\x00\x00\x01\x00\x00\x00\x1a\
613                     \x00\x00\x00\x00\
614                     \x00\x01\x90\x00\x00\x07\x00\x00\x00\x040231\
615                     \x00\x00\x00\x08";
616        assert_err_pat!(parse_exif(data),
617                        Error::InvalidFormat("Unexpected next IFD"));
618    }
619
620    #[test]
621    fn unknown_field() {
622        let data = b"MM\0\x2a\0\0\0\x08\
623                     \0\x01\x01\0\xff\xff\0\0\0\x01\0\x14\0\0\0\0\0\0";
624        let (v, _le) = parse_exif(data).unwrap();
625        assert_eq!(v.len(), 1);
626        assert_pat!(v[0].value, Value::Unknown(0xffff, 1, 0x12));
627    }
628
629    #[test]
630    fn parse_ifd_entry() {
631        // BYTE (type == 1)
632        let data = b"\x02\x03\x00\x01\0\0\0\x04ABCD";
633        assert_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 0).unwrap(),
634                    (0x0203, Value::Unknown(1, 4, 8)));
635        let data = b"\x02\x03\x00\x01\0\0\0\x05\0\0\0\x0cABCDE";
636        assert_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 0).unwrap(),
637                    (0x0203, Value::Unknown(1, 5, 12)));
638        let data = b"\x02\x03\x00\x01\0\0\0\x05\0\0\0\x0cABCD";
639        assert_err_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 0),
640                        Error::InvalidFormat("Truncated field value"));
641
642        // SHORT (type == 3)
643        let data = b"X\x04\x05\x00\x03\0\0\0\x02ABCD";
644        assert_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 1).unwrap(),
645                    (0x0405, Value::Unknown(3, 2, 9)));
646        let data = b"X\x04\x05\x00\x03\0\0\0\x03\0\0\0\x0eXABCDEF";
647        assert_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 1).unwrap(),
648                    (0x0405, Value::Unknown(3, 3, 14)));
649        let data = b"X\x04\x05\x00\x03\0\0\0\x03\0\0\0\x0eXABCDE";
650        assert_err_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 1),
651                        Error::InvalidFormat("Truncated field value"));
652
653        // Really unknown
654        let data = b"X\x01\x02\x03\x04\x05\x06\x07\x08ABCD";
655        assert_pat!(Parser::parse_ifd_entry::<BigEndian>(data, 1).unwrap(),
656                    (0x0102, Value::Unknown(0x0304, 0x05060708, 9)));
657    }
658
659    #[test]
660    fn date_time() {
661        let mut dt = DateTime::from_ascii(b"2016:05:04 03:02:01").unwrap();
662        assert_eq!(dt.year, 2016);
663        assert_eq!(dt.to_string(), "2016-05-04 03:02:01");
664
665        dt.parse_subsec(b"987").unwrap();
666        assert_eq!(dt.nanosecond.unwrap(), 987000000);
667        dt.parse_subsec(b"000987").unwrap();
668        assert_eq!(dt.nanosecond.unwrap(), 987000);
669        dt.parse_subsec(b"987654321").unwrap();
670        assert_eq!(dt.nanosecond.unwrap(), 987654321);
671        dt.parse_subsec(b"9876543219").unwrap();
672        assert_eq!(dt.nanosecond.unwrap(), 987654321);
673        dt.parse_subsec(b"130   ").unwrap();
674        assert_eq!(dt.nanosecond.unwrap(), 130000000);
675        dt.parse_subsec(b"0").unwrap();
676        assert_eq!(dt.nanosecond.unwrap(), 0);
677        dt.parse_subsec(b"").unwrap();
678        assert!(dt.nanosecond.is_none());
679        dt.parse_subsec(b" ").unwrap();
680        assert!(dt.nanosecond.is_none());
681
682        dt.parse_offset(b"+00:00").unwrap();
683        assert_eq!(dt.offset.unwrap(), 0);
684        dt.parse_offset(b"+01:23").unwrap();
685        assert_eq!(dt.offset.unwrap(), 83);
686        dt.parse_offset(b"+99:99").unwrap();
687        assert_eq!(dt.offset.unwrap(), 6039);
688        dt.parse_offset(b"-01:23").unwrap();
689        assert_eq!(dt.offset.unwrap(), -83);
690        dt.parse_offset(b"-99:99").unwrap();
691        assert_eq!(dt.offset.unwrap(), -6039);
692        assert_err_pat!(dt.parse_offset(b"   :  "), Error::BlankValue(_));
693        assert_err_pat!(dt.parse_offset(b"      "), Error::BlankValue(_));
694    }
695
696    #[test]
697    fn display_value_with_unit() {
698        let cm = Field {
699            tag: Tag::ResolutionUnit,
700            ifd_num: In::PRIMARY,
701            value: Value::Short(vec![3]),
702        };
703        let cm_tn = Field {
704            tag: Tag::ResolutionUnit,
705            ifd_num: In::THUMBNAIL,
706            value: Value::Short(vec![3]),
707        };
708        // No unit.
709        let exifver = Field {
710            tag: Tag::ExifVersion,
711            ifd_num: In::PRIMARY,
712            value: Value::Undefined(b"0231".to_vec(), 0),
713        };
714        assert_eq!(exifver.display_value().to_string(),
715                   "2.31");
716        assert_eq!(exifver.display_value().with_unit(()).to_string(),
717                   "2.31");
718        assert_eq!(exifver.display_value().with_unit(&cm).to_string(),
719                   "2.31");
720        // Fixed string.
721        let width = Field {
722            tag: Tag::ImageWidth,
723            ifd_num: In::PRIMARY,
724            value: Value::Short(vec![257]),
725        };
726        assert_eq!(width.display_value().to_string(),
727                   "257");
728        assert_eq!(width.display_value().with_unit(()).to_string(),
729                   "257 pixels");
730        assert_eq!(width.display_value().with_unit(&cm).to_string(),
731                   "257 pixels");
732        // Unit tag (with a non-default value).
733        // Unit tag is missing but the default is specified.
734        let xres = Field {
735            tag: Tag::XResolution,
736            ifd_num: In::PRIMARY,
737            value: Value::Rational(vec![(300, 1).into()]),
738        };
739        assert_eq!(xres.display_value().to_string(),
740                   "300");
741        assert_eq!(xres.display_value().with_unit(()).to_string(),
742                   "300 pixels per inch");
743        assert_eq!(xres.display_value().with_unit(&cm).to_string(),
744                   "300 pixels per cm");
745        assert_eq!(xres.display_value().with_unit(&cm_tn).to_string(),
746                   "300 pixels per inch");
747        // Unit tag is missing and the default is not specified.
748        let gpslat = Field {
749            tag: Tag::GPSLatitude,
750            ifd_num: In::PRIMARY,
751            value: Value::Rational(vec![
752                (10, 1).into(), (0, 1).into(), (1, 10).into()]),
753        };
754        assert_eq!(gpslat.display_value().to_string(),
755                   "10 deg 0 min 0.1 sec");
756        assert_eq!(gpslat.display_value().with_unit(()).to_string(),
757                   "10 deg 0 min 0.1 sec [GPSLatitudeRef missing]");
758        assert_eq!(gpslat.display_value().with_unit(&cm).to_string(),
759                   "10 deg 0 min 0.1 sec [GPSLatitudeRef missing]");
760    }
761
762    #[test]
763    fn no_borrow_no_move() {
764        let resunit = Field {
765            tag: Tag::ResolutionUnit,
766            ifd_num: In::PRIMARY,
767            value: Value::Short(vec![3]),
768        };
769        // This fails to compile with "temporary value dropped while
770        // borrowed" error if with_unit() borrows self.
771        let d = resunit.display_value().with_unit(());
772        assert_eq!(d.to_string(), "cm");
773        // This fails to compile if with_unit() moves self.
774        let d1 = resunit.display_value();
775        let d2 = d1.with_unit(());
776        assert_eq!(d1.to_string(), "cm");
777        assert_eq!(d2.to_string(), "cm");
778    }
779
780    #[test]
781    fn continue_on_error() {
782        macro_rules! define_test {
783            {
784                data: $data:expr,
785                fields: [$($fields:pat),*],
786                errors: [$first_error:pat $(, $rest_errors:pat)*]
787            } => {
788                let data = $data;
789                let mut parser = Parser::new();
790                assert_err_pat!(parser.parse(data), $first_error);
791                let mut parser = Parser::new();
792                parser.continue_on_error = Some(Vec::new());
793                parser.parse(data).unwrap();
794                assert_eq!(parser.little_endian, false);
795                let mut entries = parser.entries.iter();
796                $(
797                    assert_pat!(entries.next().unwrap()
798                                       .ref_field(data, parser.little_endian),
799                                $fields);
800                )*
801                assert_pat!(entries.next(), None);
802                let mut errors =
803                    parser.continue_on_error.as_ref().unwrap().iter();
804                assert_pat!(errors.next().unwrap(), $first_error);
805                $(
806                    assert_pat!(errors.next().unwrap(), $rest_errors);
807                )*
808                assert_pat!(errors.next(), None);
809            }
810        }
811        // 0th IFD is missing.
812        define_test! {
813            data: b"MM\0\x2a\0\0\0\x08",
814            fields: [],
815            errors: [Error::InvalidFormat("Truncated IFD count")]
816        }
817        // 2nd entry is truncated.
818        define_test! {
819            data: b"MM\0\x2a\0\0\0\x08\
820                    \0\x02\x01\x00\0\x03\0\0\0\x01\0\x14\0\0\
821                          \x01\x01\0\x03\0\0\0\x01\0\x15\0",
822            fields: [Field { tag: Tag::ImageWidth, ifd_num: In(0),
823                             value: Value::Short(_) }],
824            errors: [Error::InvalidFormat("Truncated IFD")]
825        }
826        // 1st entry broken.
827        define_test! {
828            data: b"MM\0\x2a\0\0\0\x08\
829                    \0\x02\x01\x00\0\x03\0\0\0\x03\0\0\0\x21\
830                          \x01\x01\0\x03\0\0\0\x01\0\x15\0\0\
831                          \0\0\0\0",
832            fields: [Field { tag: Tag::ImageLength, ifd_num: In(0),
833                             value: Value::Short(_) }],
834            errors: [Error::InvalidFormat("Truncated field value")]
835        }
836        // Exif IFD has non-zero next IFD offset.
837        // Top-level next IFD is also broken.
838        define_test! {
839            data: b"MM\0\x2a\0\0\0\x08\
840                    \0\x02\x87\x69\0\x04\0\0\0\x01\0\0\0\x26\
841                          \xfd\xe8\0\x09\0\0\0\x01\xfe\xdc\xba\x98\
842                          \xff\xff\xff\xff\
843                    \0\x01\x90\x00\0\x07\0\0\0\x04\x00\x02\x03\x02\
844                          \0\0\0\x01",
845            fields: [Field { tag: Tag::ExifVersion, ifd_num: In(0),
846                             value: Value::Undefined(_, _) },
847                     Field { tag: Tag(Context::Tiff, 65000), ifd_num: In(0),
848                             value: Value::SLong(_) }],
849            errors: [Error::InvalidFormat("Unexpected next IFD"),
850                     Error::InvalidFormat("Truncated IFD count")]
851        }
852        // Exif IFD pointer has a bad type.
853        define_test! {
854            data: b"MM\0\x2a\0\0\0\x08\
855                    \0\x02\x87\x69\0\x09\0\0\0\x01\0\0\0\x26\
856                          \xfd\xe8\0\x06\0\0\0\x03\xfe\xdc\xba\x98\
857                          \0\0\0\0\
858                    \0\x01\x90\x00\0\x07\0\0\0\x04\x00\x02\x03\x02\
859                          \0\0\0\x01",
860            fields: [Field { tag: Tag(Context::Tiff, 65000), ifd_num: In(0),
861                             value: Value::SByte(_) }],
862            errors: [Error::InvalidFormat("Invalid pointer")]
863        }
864        // Exif IFD pointer is empty.
865        define_test! {
866            data: b"MM\0\x2a\0\0\0\x08\
867                    \0\x02\x87\x69\0\x04\0\0\0\x00\0\0\0\x26\
868                          \xfd\xe8\0\x08\0\0\0\x02\xfe\xdc\xba\x98\
869                          \0\0\0\0\
870                    \0\x01\x90\x00\0\x07\0\0\0\x04\x00\x02\x03\x02\
871                          \0\0\0\x01",
872            fields: [Field { tag: Tag(Context::Tiff, 65000), ifd_num: In(0),
873                             value: Value::SShort(_) }],
874            errors: [Error::InvalidFormat("Invalid pointer")]
875        }
876    }
877}
exif/tiff.rs

exif/
tiff.rs
