Improve IPv6 options parsing

  - Do not require the packet structure of the header have the same
    lifetime as the underlying bytes or the parsed representation.
  - Add the bytes of the contained options to the parsed representation
    structure.
  - Add the IPv6OptionsIterator structure to make iterating over the
    contained options easier.

Closes: #212
Approved by: whitequark

src/wire/ipv6hopbyhop.rs

@@ -1,6 +1,7 @@
 use core::fmt;
 use {Error, Result};
 
+use super::ipv6option::Ipv6OptionsIterator;
 pub use super::IpProtocol as Protocol;
 
 /// A read/write wrapper around an IPv6 Hop-by-Hop Options Header.
@@ -156,19 +157,22 @@ impl<'a, T: AsRef<[u8]> + ?Sized> fmt::Display for Header<&'a T> {
 
 /// A high-level representation of an IPv6 Hop-by-Hop Options header.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct Repr {
+pub struct Repr<'a> {
     /// The type of header immediately following the Hop-by-Hop Options header.
     pub next_header: Protocol,
     /// Length of the Hop-by-Hop Options header in 8-octet units, not including the first 8 octets.
     pub length:      u8,
+    /// The options contained in the Hop-by-Hop Options header.
+    pub options:     &'a [u8]
 }
 
-impl Repr {
+impl<'a> Repr<'a> {
     /// Parse an IPv6 Hop-by-Hop Options Header and return a high-level representation.
-    pub fn parse<T>(header: &Header<&T>) -> Result<Repr> where T: AsRef<[u8]> + ?Sized {
+    pub fn parse<T>(header: &Header<&'a T>) -> Result<Repr<'a>> where T: AsRef<[u8]> + ?Sized {
         Ok(Repr {
             next_header: header.next_header(),
-            length: header.header_len()
+            length: header.header_len(),
+            options: header.options()
         })
     }
 
@@ -182,10 +186,16 @@ impl Repr {
     pub fn emit<T: AsRef<[u8]> + AsMut<[u8]> + ?Sized>(&self, header: &mut Header<&mut T>) {
         header.set_next_header(self.next_header);
         header.set_header_len(self.length);
+        header.options_mut().copy_from_slice(self.options);
+    }
+
+    /// Return an `Iterator` for the contained options.
+    pub fn options(&self) -> Ipv6OptionsIterator {
+        Ipv6OptionsIterator::new(self.options, self.buffer_len() - 2)
     }
 }
 
-impl<'a> fmt::Display for Repr {
+impl<'a> fmt::Display for Repr<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "IPv6 Hop-by-Hop Options next_hdr={} length={} ", self.next_header, self.length)
     }
@@ -273,26 +283,26 @@ mod test {
     fn test_repr_parse_valid() {
         let header = Header::new(&REPR_PACKET_PAD4);
         let repr = Repr::parse(&header).unwrap();
-        assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 0 });
+        assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] });
 
         let header = Header::new(&REPR_PACKET_PAD12);
         let repr = Repr::parse(&header).unwrap();
-        assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 1 });
+        assert_eq!(repr, Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] });
     }
 
     #[test]
     fn test_repr_emit() {
-        let repr = Repr{ next_header: Protocol::Tcp, length: 0 };
-        let mut bytes = [0u8; 2];
+        let repr = Repr{ next_header: Protocol::Tcp, length: 0, options: &REPR_PACKET_PAD4[2..] };
+        let mut bytes = [0u8; 8];
         let mut header = Header::new(&mut bytes);
         repr.emit(&mut header);
-        assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[0..2]);
+        assert_eq!(header.into_inner(), &REPR_PACKET_PAD4[..]);
 
-        let repr = Repr{ next_header: Protocol::Tcp, length: 1 };
-        let mut bytes = [0u8; 2];
+        let repr = Repr{ next_header: Protocol::Tcp, length: 1, options: &REPR_PACKET_PAD12[2..] };
+        let mut bytes = [0u8; 16];
         let mut header = Header::new(&mut bytes);
         repr.emit(&mut header);
-        assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[0..2]);
+        assert_eq!(header.into_inner(), &REPR_PACKET_PAD12[..]);
     }
 
     #[test]

src/wire/ipv6option.rs

@@ -229,7 +229,7 @@ pub enum Repr<'a> {
 
 impl<'a> Repr<'a> {
     /// Parse an IPv6 Extension Header Option and return a high-level representation.
-    pub fn parse<T>(opt: &'a Ipv6Option<&'a T>) -> Result<Repr<'a>> where T: AsRef<[u8]> + ?Sized {
+    pub fn parse<T>(opt: &Ipv6Option<&'a T>) -> Result<Repr<'a>> where T: AsRef<[u8]> + ?Sized {
         match opt.option_type() {
             Type::Pad1 =>
                 Ok(Repr::Pad1),
@@ -282,6 +282,57 @@ impl<'a> Repr<'a> {
     }
 }
 
+/// A iterator for IPv6 options.
+#[derive(Debug)]
+pub struct Ipv6OptionsIterator<'a> {
+    pos: usize,
+    length: usize,
+    data: &'a [u8],
+    hit_error: bool
+}
+
+impl<'a> Ipv6OptionsIterator<'a> {
+    pub fn new(data: &'a [u8], length: usize) -> Ipv6OptionsIterator<'a> {
+        Ipv6OptionsIterator {
+            pos: 0,
+            hit_error: false,
+            length, data
+        }
+    }
+}
+
+impl<'a> Iterator for Ipv6OptionsIterator<'a> {
+    type Item = Result<Repr<'a>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.length && !self.hit_error {
+            // If we still have data to parse and we have not previously
+            // hit an error, attempt to parse the next option.
+            match Ipv6Option::new_checked(&self.data[self.pos..]) {
+                Ok(hdr) => {
+                    match Repr::parse(&hdr) {
+                        Ok(repr) => {
+                            self.pos += repr.buffer_len();
+                            Some(Ok(repr))
+                        }
+                        err => {
+                            self.hit_error = true;
+                            Some(err)
+                        }
+                    }
+                }
+                Err(e) => {
+                    self.hit_error = true;
+                    Some(Err(e))
+                }
+            }
+        } else {
+            // If we failed to parse an option we do
+            None
+        }
+    }
+}
+
 impl<'a> fmt::Display for Repr<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "IPv6 Option ")?;
@@ -423,4 +474,29 @@ mod test {
         failure_type = Type::Unknown(0b11000100).into();
         assert_eq!(failure_type, FailureType::DiscardSendUnicast);
     }
+
+    #[test]
+    fn test_options_iter() {
+        let options = [0x00, 0x01, 0x01, 0x00,
+                       0x01, 0x02, 0x00, 0x00,
+                       0x01, 0x00, 0x00, 0x11,
+                       0x00, 0x01, 0x08, 0x00];
+
+        let mut iterator = Ipv6OptionsIterator::new(&options, 0);
+        assert_eq!(iterator.next(), None);
+
+        iterator = Ipv6OptionsIterator::new(&options, 16);
+        for (i, opt) in iterator.enumerate() {
+            match (i, opt) {
+                (0, Ok(Repr::Pad1)) => continue,
+                (1, Ok(Repr::PadN(1))) => continue,
+                (2, Ok(Repr::PadN(2))) => continue,
+                (3, Ok(Repr::PadN(0))) => continue,
+                (4, Ok(Repr::Pad1)) => continue,
+                (5, Ok(Repr::Unknown { type_: 0x11, length: 0, .. })) => continue,
+                (6, Err(Error::Truncated)) => continue,
+                (i, res) => panic!("Unexpected option `{:?}` at index {}", res, i),
+            }
+        }
+    }
 }