Add Graceful Shutdown support

If graceful shutdown is initiated, a GOAWAY of the max stream ID - 1 is
sent, followed by a PING frame, to measure RTT. When the PING is ACKed,
the connection sends a new GOAWAY with the proper last processed stream
ID. From there, once all active streams have completely, the connection
will finally close.

src/proto/streams/recv.rs

@@ -26,6 +26,15 @@ pub(super) struct Recv {
     /// The stream ID of the last processed stream
     last_processed_id: StreamId,
 
+    /// Any streams with a higher ID are ignored.
+    ///
+    /// This starts as MAX, but is lowered when a GOAWAY is received.
+    ///
+    /// > After sending a GOAWAY frame, the sender can discard frames for
+    /// > streams initiated by the receiver with identifiers higher than
+    /// > the identified last stream.
+    max_stream_id: StreamId,
+
     /// Streams that have pending window updates
     pending_window_updates: store::Queue<stream::NextWindowUpdate>,
 
@@ -85,7 +94,8 @@ impl Recv {
             in_flight_data: 0 as WindowSize,
             next_stream_id: Ok(next_stream_id.into()),
             pending_window_updates: store::Queue::new(),
-            last_processed_id: StreamId::zero(),
+            last_processed_id: StreamId::ZERO,
+            max_stream_id: StreamId::MAX,
             pending_accept: store::Queue::new(),
             pending_reset_expired: store::Queue::new(),
             reset_duration: config.local_reset_duration,
@@ -606,12 +616,25 @@ impl Recv {
         stream.notify_recv();
     }
 
+    pub fn go_away(&mut self, last_processed_id: StreamId) {
+        assert!(self.max_stream_id >= last_processed_id);
+
+        self.max_stream_id = last_processed_id;
+    }
+
     pub fn recv_eof(&mut self, stream: &mut Stream) {
         stream.state.recv_eof();
         stream.notify_send();
         stream.notify_recv();
     }
 
+    /// Get the max ID of streams we can receive.
+    ///
+    /// This gets lowered if we send a GOAWAY frame.
+    pub fn max_stream_id(&self) -> StreamId {
+        self.max_stream_id
+    }
+
     fn next_stream_id(&self) -> Result<StreamId, RecvError> {
         if let Ok(id) = self.next_stream_id {
             Ok(id)

src/proto/streams/streams.rs

@@ -127,6 +127,11 @@ where
         let mut me = self.inner.lock().unwrap();
         let me = &mut *me;
 
+        if id > me.actions.recv.max_stream_id() {
+            trace!("id ({:?}) > max_stream_id ({:?}), ignoring HEADERS", id, me.actions.recv.max_stream_id());
+            return Ok(());
+        }
+
         let key = match me.store.find_entry(id) {
             Entry::Occupied(e) => e.key(),
             Entry::Vacant(e) => match me.actions.recv.open(id, &mut me.counts)? {
@@ -209,6 +214,11 @@ where
         let stream = match me.store.find_mut(&id) {
             Some(stream) => stream,
             None => {
+                if id > me.actions.recv.max_stream_id() {
+                    trace!("id ({:?}) > max_stream_id ({:?}), ignoring DATA", id, me.actions.recv.max_stream_id());
+                    return Ok(());
+                }
+
                 trace!("recv_data; stream not found: {:?}", id);
                 return Err(RecvError::Connection(Reason::PROTOCOL_ERROR));
             },
@@ -243,6 +253,11 @@ where
             return Err(RecvError::Connection(Reason::PROTOCOL_ERROR));
         }
 
+        if id > me.actions.recv.max_stream_id() {
+            trace!("id ({:?}) > max_stream_id ({:?}), ignoring RST_STREAM", id, me.actions.recv.max_stream_id());
+            return Ok(());
+        }
+
         let stream = match me.store.find_mut(&id) {
             Some(stream) => stream,
             None => {
@@ -295,7 +310,7 @@ where
         last_processed_id
     }
 
-    pub fn recv_goaway(&mut self, frame: &frame::GoAway) {
+    pub fn recv_go_away(&mut self, frame: &frame::GoAway) {
         let mut me = self.inner.lock().unwrap();
         let me = &mut *me;
 
@@ -307,6 +322,8 @@ where
         let last_stream_id = frame.last_stream_id();
         let err = frame.reason().into();
 
+        actions.recv.go_away(last_stream_id);
+
         me.store
             .for_each(|stream| if stream.id > last_stream_id {
                 counts.transition(stream, |_, stream| {
@@ -631,6 +648,13 @@ where
             actions.recv.enqueue_reset_expiration(stream, counts)
         })
     }
+
+    pub fn send_go_away(&mut self, last_processed_id: StreamId) {
+        let mut me = self.inner.lock().unwrap();
+        let me = &mut *me;
+        let actions = &mut me.actions;
+        actions.recv.go_away(last_processed_id);
+    }
 }
 
 impl<B> Streams<B, client::Peer>