Safely skip unexpected bytes in the headers

Author: art049

src/header.rs

@@ -1,10 +1,12 @@
-use std::io::Read;
+use std::io::{Read, Seek, SeekFrom};
 
 use byteorder::{ByteOrder, ReadBytesExt};
 
 use super::features::FeatureSet;
 use super::section::PerfFileSection;
 
+const MAGIC_SIZE: usize = 8;
+
 /// `perf_header`
 ///
 /// The magic number identifies the perf file and the version. Current perf versions
@@ -14,7 +16,7 @@ use super::section::PerfFileSection;
 /// endian.
 #[derive(Debug, Clone, Copy)]
 pub struct PerfHeader {
-    pub magic: [u8; 8],
+    pub magic: [u8; MAGIC_SIZE],
     /// size of the header
     #[allow(dead_code)]
     pub header_size: u64,
@@ -28,8 +30,8 @@ pub struct PerfHeader {
 }
 
 impl PerfHeader {
-    pub fn parse<R: Read>(mut reader: R) -> Result<Self, std::io::Error> {
-        let mut magic = [0; 8];
+    pub fn parse<R: Read + Seek>(mut reader: R) -> Result<Self, std::io::Error> {
+        let mut magic = [0; MAGIC_SIZE];
         reader.read_exact(&mut magic)?;
 
         if magic[0] == b'P' {
@@ -39,9 +41,9 @@ impl PerfHeader {
         }
     }
 
-    fn parse_impl<R: Read, T: ByteOrder>(
+    fn parse_impl<R: Read + Seek, T: ByteOrder>(
         mut reader: R,
-        magic: [u8; 8],
+        magic: [u8; MAGIC_SIZE],
     ) -> Result<Self, std::io::Error> {
         let header_size = reader.read_u64::<T>()?;
         let attr_size = reader.read_u64::<T>()?;
@@ -54,6 +56,14 @@ impl PerfHeader {
             reader.read_u64::<T>()?,
             reader.read_u64::<T>()?,
         ]);
+
+        // Skip any additional header bytes from newer formats. Size excludes magic.
+        let known_size = (std::mem::size_of::<Self>() - MAGIC_SIZE) as u64;
+        if header_size > known_size {
+            let extra_bytes = header_size - known_size;
+            reader.seek(SeekFrom::Current(extra_bytes as i64))?;
+        }
+
         Ok(Self {
             magic,
             header_size,
@@ -74,22 +84,31 @@ impl PerfHeader {
 /// file sections.
 #[derive(Debug, Clone, Copy)]
 pub struct PerfPipeHeader {
-    pub magic: [u8; 8],
+    pub magic: [u8; MAGIC_SIZE],
     /// size of the header (should be 16)
     #[allow(dead_code)]
     pub size: u64,
 }
 
 impl PerfPipeHeader {
     pub fn parse<R: Read>(mut reader: R) -> Result<Self, std::io::Error> {
-        let mut magic = [0; 8];
+        let mut magic = [0; MAGIC_SIZE];
         reader.read_exact(&mut magic)?;
 
         let size = if magic[0] == b'P' {
             reader.read_u64::<byteorder::LittleEndian>()?
         } else {
             reader.read_u64::<byteorder::BigEndian>()?
         };
+
+        // Skip any additional header bytes from newer formats. size excludes magic.
+        // Use io::copy to sink instead of seek since pipe mode doesn't support seeking.
+        let known_size = (std::mem::size_of::<Self>() - MAGIC_SIZE) as u64;
+        if size > known_size {
+            let extra_bytes = size - known_size;
+            std::io::copy(&mut reader.by_ref().take(extra_bytes), &mut std::io::sink())?;
+        }
+
         Ok(Self { magic, size })
     }
 }