Process response

src/proto/connection.rs

@@ -79,15 +79,36 @@ impl<T, P> Stream for Connection<T, P>
         // buffer is clear, `poll_complete` is called here.
         let _ = try!(self.poll_complete());
 
-        match try_ready!(self.inner.poll()) {
+        let frame = match try_ready!(self.inner.poll()) {
             Some(Headers(v)) => {
-                debug!("poll; frame={:?}", v);
-                unimplemented!();
+                // TODO: Update stream state
+                let stream_id = v.stream_id();
+                let end_of_stream = v.is_end_stream();
+
+                Frame::Headers {
+                    id: stream_id,
+                    headers: P::convert_poll_message(v),
+                    end_of_stream: end_of_stream,
+                }
+            }
+            Some(Data(v)) => {
+                // TODO: Validate frame
+
+                let stream_id = v.stream_id();
+                let end_of_stream = v.is_end_stream();
+
+                Frame::Body {
+                    id: stream_id,
+                    chunk: v.into_payload(),
+                    end_of_stream: end_of_stream,
+                }
             }
             Some(frame) => panic!("unexpected frame; frame={:?}", frame),
             None => return Ok(Async::Ready(None)),
             _ => unimplemented!(),
-        }
+        };
+
+        Ok(Async::Ready(Some(frame)))
     }
 }
 

src/proto/framed_read.rs

@@ -49,7 +49,11 @@ impl<T> FramedRead<T> {
         }
 
         let frame = match head.kind() {
-            Kind::Data => unimplemented!(),
+            Kind::Data => {
+                let _ = bytes.split_to(frame::HEADER_LEN);
+                let frame = try!(frame::Data::load(head, bytes));
+                frame.into()
+            }
             Kind::Headers => {
                 let mut buf = Cursor::new(bytes);
                 buf.set_position(frame::HEADER_LEN as u64);
@@ -66,12 +70,21 @@ impl<T> FramedRead<T> {
                 frame.into()
             }
             Kind::Priority => unimplemented!(),
-            Kind::Reset => unimplemented!(),
+            Kind::Reset => {
+                let frame = try!(frame::Reset::load(head, &bytes[frame::HEADER_LEN..]));
+                debug!("decoded; frame={:?}", frame);
+                // TODO: implement
+                return Ok(None);
+            }
             Kind::Settings => {
                 let frame = try!(frame::Settings::load(head, &bytes[frame::HEADER_LEN..]));
                 frame.into()
             }
-            Kind::PushPromise => unimplemented!(),
+            Kind::PushPromise => {
+                debug!("received PUSH_PROMISE");
+                // TODO: implement
+                return Ok(None);
+            }
             Kind::Ping => unimplemented!(),
             Kind::GoAway => {
                 let frame = try!(frame::GoAway::load(&bytes[frame::HEADER_LEN..]));