diff --git a/bin/recovery-netstack/src/wire/ipv4.rs b/bin/recovery-netstack/src/wire/ipv4.rs
index 6ad77c4..9ac3a15 100644
--- a/bin/recovery-netstack/src/wire/ipv4.rs
+++ b/bin/recovery-netstack/src/wire/ipv4.rs
@@ -3,10 +3,12 @@
 // found in the LICENSE file.
 
 use byteorder::{BigEndian, ByteOrder};
-use zerocopy::{AsBytes, ByteSlice, FromBytes, LayoutVerified};
+use zerocopy::{AsBytes, ByteSlice, FromBytes, Unaligned};
 
 use ip::{Ipv4Addr, Ipv4Option};
-use wire::util::{Checksum, Options, PacketFormat};
+use wire::util::packet;
+use wire::util::packet::{PacketWithOptions, PacketWithOptionsParseErr};
+use wire::util::{Checksum, OptionParseErr, Options, PacketFormat};
 
 use self::options::Ipv4OptionImpl;
 
@@ -35,6 +37,7 @@
 
 unsafe impl FromBytes for HeaderPrefix {}
 unsafe impl AsBytes for HeaderPrefix {}
+unsafe impl Unaligned for HeaderPrefix {}
 
 impl HeaderPrefix {
     fn version(&self) -> u8 {
@@ -46,144 +49,155 @@
     }
 }
 
+impl packet::Header for HeaderPrefix {
+    type Error = ();
+
+    fn total_packet_len(&self) -> Result<Option<usize>, ()> {
+        Ok(Some(BigEndian::read_u16(&self.total_len[..]) as usize))
+    }
+}
+
+impl packet::HeaderPrefix for HeaderPrefix {
+    fn total_header_len(&self) -> Result<usize, ()> {
+        Ok(self.ihl() as usize * 4)
+    }
+}
+
 /// An IPv4 packet.
 ///
 /// An `Ipv4Packet` shares its underlying memory with the byte slice it was
 /// parsed from or serialized to, meaning that no copying or extra allocation is
 /// necessary.
-pub struct Ipv4Packet<B> {
-    hdr_prefix: LayoutVerified<B, HeaderPrefix>,
-    options: Options<B, Ipv4OptionImpl>,
-    body: B,
-}
+// pub struct Ipv4Packet<B> {
+//     hdr_prefix: LayoutVerified<B, HeaderPrefix>,
+//     options: Options<B, Ipv4OptionImpl>,
+//     body: B,
+// }
+
+pub struct Ipv4Packet<B>(PacketWithOptions<B, HeaderPrefix, Options<B, Ipv4OptionImpl>>);
 
 impl<B> PacketFormat for Ipv4Packet<B> {
     const MAX_HEADER_BYTES: usize = 60;
     const MAX_FOOTER_BYTES: usize = 0;
 }
 
+pub enum Ipv4ParseErr {
+    Packet(PacketWithOptionsParseErr<(), OptionParseErr<()>>),
+    Version,
+    Checksum,
+}
+
 impl<B: ByteSlice> Ipv4Packet<B> {
     /// Parse an IPv4 packet.
     ///
     /// `parse` parses `bytes` as an IPv4 packet and validates the checksum.
     #[cfg_attr(feature = "clippy", allow(needless_pass_by_value))]
-    pub fn parse(bytes: B) -> Result<Ipv4Packet<B>, ()> {
+    pub fn parse(bytes: B) -> Result<Ipv4Packet<B>, Ipv4ParseErr> {
         // See for details: https://en.wikipedia.org/wiki/IPv4#Header
 
-        let total_len = bytes.len();
-        let (hdr_prefix, rest) =
-            LayoutVerified::<B, HeaderPrefix>::new_from_prefix(bytes).ok_or(())?;
-        let hdr_bytes = (hdr_prefix.ihl() * 4) as usize;
-        if hdr_bytes > total_len {
-            return Err(());
-        }
-        let (options, body) = rest.split_at(hdr_bytes - HEADER_PREFIX_SIZE);
-        let options = Options::parse(options).map_err(|_| ())?;
-        let packet = Ipv4Packet {
-            hdr_prefix,
-            options,
-            body,
-        };
-        if packet.hdr_prefix.version() != 4 {
-            return Err(());
+        let packet: PacketWithOptions<B, HeaderPrefix, _> =
+            PacketWithOptions::parse(bytes).map_err(Ipv4ParseErr::Packet)?;
+        let packet = Ipv4Packet(packet);
+        if packet.0.header_prefix().version() != 4 {
+            return Err(Ipv4ParseErr::Version);
         }
         if packet.compute_header_checksum() != 0 {
-            return Err(());
+            return Err(Ipv4ParseErr::Checksum);
         }
 
         Ok(packet)
     }
 
     pub fn iter_options<'a>(&'a self) -> impl 'a + Iterator<Item = Ipv4Option> {
-        self.options.iter()
+        self.0.options().iter()
     }
 }
 
 impl<B: ByteSlice> Ipv4Packet<B> {
     fn compute_header_checksum(&self) -> u16 {
         let mut c = Checksum::new();
-        c.add_bytes(self.hdr_prefix.bytes());
-        c.add_bytes(self.options.bytes());
+        c.add_bytes(self.0.header_prefix_bytes());
+        c.add_bytes(self.0.options().bytes());
         c.sum()
     }
 
     pub fn body(&self) -> &[u8] {
-        &self.body
+        self.0.body()
     }
 
     pub fn version(&self) -> u8 {
-        self.hdr_prefix.version()
+        self.0.header_prefix().version()
     }
 
     pub fn ihl(&self) -> u8 {
-        self.hdr_prefix.ihl()
+        self.0.header_prefix().ihl()
     }
 
     pub fn dscp(&self) -> u8 {
-        self.hdr_prefix.dscp_ecn >> 2
+        self.0.header_prefix().dscp_ecn >> 2
     }
 
     pub fn ecn(&self) -> u8 {
-        self.hdr_prefix.dscp_ecn & 3
+        self.0.header_prefix().dscp_ecn & 3
     }
 
     pub fn total_length(&self) -> u16 {
-        BigEndian::read_u16(&self.hdr_prefix.total_len)
+        BigEndian::read_u16(&self.0.header_prefix().total_len)
     }
 
     pub fn id(&self) -> u16 {
-        BigEndian::read_u16(&self.hdr_prefix.id)
+        BigEndian::read_u16(&self.0.header_prefix().id)
     }
 
     pub fn flags(&self) -> u8 {
-        self.hdr_prefix.flags_frag_off[0] >> 5
+        self.0.header_prefix().flags_frag_off[0] >> 5
     }
 
     pub fn fragment_offset(&self) -> u16 {
-        ((u16::from(self.hdr_prefix.flags_frag_off[0] & 0x1F)) << 8)
-            | u16::from(self.hdr_prefix.flags_frag_off[1])
+        ((u16::from(self.0.header_prefix().flags_frag_off[0] & 0x1F)) << 8)
+            | u16::from(self.0.header_prefix().flags_frag_off[1])
     }
 
     pub fn ttl(&self) -> u8 {
-        self.hdr_prefix.ttl
+        self.0.header_prefix().ttl
     }
 
     pub fn proto(&self) -> u8 {
-        self.hdr_prefix.proto
+        self.0.header_prefix().proto
     }
 
     pub fn hdr_checksum(&self) -> u16 {
-        BigEndian::read_u16(&self.hdr_prefix.hdr_checksum)
+        BigEndian::read_u16(&self.0.header_prefix().hdr_checksum)
     }
 
     pub fn src_ip(&self) -> Ipv4Addr {
-        Ipv4Addr::new(self.hdr_prefix.src_ip)
+        Ipv4Addr::new(self.0.header_prefix().src_ip)
     }
 
     pub fn dst_ip(&self) -> Ipv4Addr {
-        Ipv4Addr::new(self.hdr_prefix.dst_ip)
+        Ipv4Addr::new(self.0.header_prefix().dst_ip)
     }
 }
 
 impl<'a> Ipv4Packet<&'a mut [u8]> {
     pub fn set_id(&mut self, id: u16) {
-        BigEndian::write_u16(&mut self.hdr_prefix.id, id);
+        BigEndian::write_u16(&mut self.0.header_prefix_mut().id, id);
     }
 
     pub fn set_ttl(&mut self, ttl: u8) {
-        self.hdr_prefix.ttl = ttl;
+        self.0.header_prefix_mut().ttl = ttl;
     }
 
     pub fn set_proto(&mut self, proto: u8) {
-        self.hdr_prefix.proto = proto;
+        self.0.header_prefix_mut().proto = proto;
     }
 
     pub fn set_src_ip(&mut self, src_ip: Ipv4Addr) {
-        self.hdr_prefix.src_ip = src_ip.ipv4_bytes();
+        self.0.header_prefix_mut().src_ip = src_ip.ipv4_bytes();
     }
 
     pub fn set_dst_ip(&mut self, dst_ip: Ipv4Addr) {
-        self.hdr_prefix.dst_ip = dst_ip.ipv4_bytes();
+        self.0.header_prefix_mut().dst_ip = dst_ip.ipv4_bytes();
     }
 
     /// Compute and set the header checksum.
@@ -191,9 +205,9 @@
     /// Compute the header checksum from the current header state, and set it in
     /// the header.
     pub fn set_checksum(&mut self) {
-        self.hdr_prefix.hdr_checksum = [0, 0];
+        self.0.header_prefix_mut().hdr_checksum = [0, 0];
         let c = self.compute_header_checksum();
-        BigEndian::write_u16(&mut self.hdr_prefix.hdr_checksum, c);
+        BigEndian::write_u16(&mut self.0.header_prefix_mut().hdr_checksum, c);
     }
 }