Extra log output

src/frame/headers.rs

@@ -128,9 +128,17 @@ impl Headers {
     {
         let flags = HeadersFlag(head.flag());
 
+        trace!("loading headers; flags={:?}", flags);
+
         // Read the padding length
         if flags.is_padded() {
             let pad = src.get_u8() as usize;
+            let len = src.get_ref().len();
+
+            if pad >= len {
+                trace!("too much padding");
+                return Err(Error::TooMuchPadding);
+            }
 
             // Truncate the last `pad` bytes.
             let len = src.get_ref().len() - pad;
@@ -178,7 +186,7 @@ impl Headers {
         // priority.
         //
         // TODO: Provide a way to abort decoding if an error is hit.
-        try!(decoder.decode(src, |header| {
+        let res = decoder.decode(src, |header| {
             use hpack::Header::*;
 
             match header {
@@ -191,9 +199,15 @@ impl Headers {
                 Path(v) => set_pseudo!(path, v),
                 Status(v) => set_pseudo!(status, v),
             }
-        }));
+        });
+
+        if let Err(e) = res {
+            trace!("hpack decoding error; err={:?}", e);
+            return Err(e.into());
+        }
 
         if err {
+            trace!("repeated pseudo");
             return Err(hpack::DecoderError::RepeatedPseudo.into());
         }
 

src/hpack/decoder.rs

@@ -171,16 +171,20 @@ impl Decoder {
             self.last_max_update = size;
         }
 
+        trace!("decode");
+
         while src.has_remaining() {
             // At this point we are always at the beginning of the next block
             // within the HPACK data. The type of the block can always be
             // determined from the first byte.
             match try!(Representation::load(peek_u8(src))) {
                 Indexed => {
+                    trace!("    Indexed; rem={:?}", src.remaining());
                     can_resize = false;
                     f(try!(self.decode_indexed(src)));
                 }
                 LiteralWithIndexing => {
+                    trace!("    LiteralWithIndexing; rem={:?}", src.remaining());
                     can_resize = false;
                     let entry = try!(self.decode_literal(src, true));
 
@@ -190,11 +194,13 @@ impl Decoder {
                     f(entry);
                 }
                 LiteralWithoutIndexing => {
+                    trace!("    LiteralWithoutIndexing; rem={:?}", src.remaining());
                     can_resize = false;
                     let entry = try!(self.decode_literal(src, false));
                     f(entry);
                 }
                 LiteralNeverIndexed => {
+                    trace!("    LiteralNeverIndexed; rem={:?}", src.remaining());
                     can_resize = false;
                     let entry = try!(self.decode_literal(src, false));
 
@@ -203,6 +209,7 @@ impl Decoder {
                     f(entry);
                 }
                 SizeUpdate => {
+                    trace!("    SizeUpdate; rem={:?}", src.remaining());
                     if !can_resize {
                         return Err(DecoderError::InvalidMaxDynamicSize);
                     }
@@ -277,6 +284,7 @@ impl Decoder {
         let len = try!(decode_int(buf, 7));
 
         if len > buf.remaining() {
+            trace!("decode_string underflow; len={}; remaining={}", len, buf.remaining());
             return Err(DecoderError::StringUnderflow);
         }
 

src/proto/framed_read.rs

@@ -50,6 +50,8 @@ impl<T> FramedRead<T> {
 
         let kind = head.kind();
 
+        trace!("    -> kind={:?}", kind);
+
         let frame = match kind {
             Kind::Settings => {
                 frame::Settings::load(head, &bytes[frame::HEADER_LEN..])?.into()