Add a better error message (#66)

Author: xd009642

src/hash_table.rs

@@ -5,6 +5,7 @@ use nom::{
     number::complete::*,
 };
 use std::borrow::Cow;
+use std::mem::size_of;
 use tracing::debug;
 
 #[derive(Copy, Clone, Debug)]
@@ -49,13 +50,15 @@ fn read_value(
         return Err(nom::Err::Failure(VerboseError { errors }));
     }
     if input.len() < data_len {
+        tracing::trace!("{} < {}", input.len(), data_len);
         return Err(nom::Err::Failure(VerboseError::from_error_kind(
             &input[input.len()..],
             ErrorKind::Eof,
         )));
     }
     let mut result = vec![];
     let end_len = input.len() - data_len;
+    tracing::trace!("input: {} end: {}", input.len(), end_len);
 
     let expected_end = &input[data_len..];
     let mut last_hash = 0;
@@ -69,12 +72,22 @@ fn read_value(
         }
         // This is only available for versions > v1. But as rust won't be going backwards to legacy
         // versions it's a safe assumption.
+        tracing::trace!("1. le_u64: {}", bytes.len());
         let (bytes, counts_len) = le_u64(bytes)?;
+        tracing::trace!("Counts len: {}", counts_len);
         if bytes.len() <= end_len {
             break;
         }
         input = bytes;
+        if size_of::<u64>().saturating_mul(counts_len as usize) > input.len() {
+            let errors = vec![(
+                input,
+                VerboseErrorKind::Context("hash_table value count length exceeds length of input"),
+            )];
+            return Err(nom::Err::Failure(VerboseError { errors }));
+        }
         for _ in 0..counts_len {
+            // tracing::trace!("2. le_u64: {}", input.len());
             let (bytes, count) = le_u64(input)?;
             input = bytes;
             counts.push(count);
@@ -86,6 +99,7 @@ fn read_value(
 
         // If the version is > v2 then there can also be value profiling data so lets try and parse
         // that now
+        tracing::trace!("3. le_u32: {}", input.len());
         let (bytes, total_size) = le_u32(input)?;
         if bytes.len() <= end_len {
             break;
@@ -151,7 +165,11 @@ impl HashTable {
         mut num_entries: u64,
     ) -> ParseResult<'a, u64> {
         let (bytes, num_items_in_bucket) = le_u16(input)?;
-        debug!("Number of items in bucket: {}", num_items_in_bucket);
+        debug!(
+            "Number of items in bucket: {}, input remaining: {}",
+            num_items_in_bucket,
+            input.len()
+        );
         let mut remaining = bytes;
         for _i in 0..num_items_in_bucket {
             let (bytes, _hash) = le_u64(remaining)?;

src/instrumentation_profile/mod.rs

@@ -2,7 +2,7 @@ use crate::instrumentation_profile::indexed_profile::*;
 use crate::instrumentation_profile::raw_profile::*;
 use crate::instrumentation_profile::text_profile::*;
 use crate::instrumentation_profile::types::*;
-use nom::{error::VerboseError, IResult};
+use nom::{error::VerboseError, Err, IResult};
 use std::fs::File;
 use std::io;
 use std::io::prelude::*;
@@ -43,9 +43,21 @@ pub fn parse_bytes(data: &[u8]) -> io::Result<InstrumentationProfile> {
             "Unsupported instrumentation profile format",
         ));
     };
-    nom_res.map(|(_bytes, res)| res).map_err(|_e| {
-        trace!("{}", _e);
-        io::Error::new(io::ErrorKind::Other, "Parsing failed")
+    nom_res.map(|(_bytes, res)| res).map_err(|e| {
+        // trace!("{}", e);
+        let verbose_error_message = |err: VerboseError<&[u8]>| {
+            err.errors
+                .iter()
+                .map(|(_, x)| format!("{:?}", x))
+                .collect::<Vec<String>>()
+                .join(" ")
+        };
+        let error_message = match e {
+            Err::Error(e) => format!("parser error: {}", verbose_error_message(e)),
+            Err::Failure(e) => format!("parser failure: {}", verbose_error_message(e)),
+            Err::Incomplete(_) => unreachable!("llvm_profparsers works on complete data"),
+        };
+        io::Error::new(io::ErrorKind::Other, error_message)
     })
 }