stream state-machine (#216)

Start of stream state-machine
- Only header callbacks hooked up so far.
- Connection checks for active stream.
  - If stream not found, error raised or frame ignored, according to rules.
- Stream checks that frame is allowed, given current state.
- When END_STREAM is received, stream closes.
- When stream closes, connection marks it complete.
- Stream errors result stream sending RST_STREAM frame before closing.
- Connection errors shut down channel

Author: graebm

include/aws/http/private/h2_connection.h

@@ -24,6 +24,7 @@
 #include <aws/http/private/h2_frames.h>
 
 struct aws_h2_decoder;
+struct aws_h2_stream;
 
 struct aws_h2_connection {
     struct aws_http_connection base;
@@ -62,26 +63,41 @@ struct aws_h2_connection {
          * When queue is empty, then we send DATA frames from the outgoing_streams_list */
         struct aws_linked_list outgoing_frames_queue;
 
+        /* Maps stream-id to aws_h2_stream_closed_when.
+         * Contains data about streams that were recently closed by this end (sent RST_STREAM frame or END_STREAM flag),
+         * but might still receive frames that remote peer sent before learning that the stream was closed.
+         * Entries are removed after a period of time. */
+        struct aws_hash_table closed_streams_where_frames_might_trickle_in;
+
     } thread_data;
 
-    /* Any thread may touch this data, but the lock must be held */
+    /* Any thread may touch this data, but the lock must be held (unless it's an atomic) */
     struct {
+        /* For checking status from outside the event-loop thread. */
+        struct aws_atomic_var is_open;
+
+        /* If non-zero, reason to immediately reject new streams. (ex: closing) */
+        struct aws_atomic_var new_stream_error_code;
+
         struct aws_mutex lock;
 
         /* New `aws_h2_stream *` that haven't moved to `thread_data` yet */
         struct aws_linked_list pending_stream_list;
 
-        /* If non-zero, reason to immediately reject new streams. (ex: closing) */
-        int new_stream_error_code;
-
         bool is_cross_thread_work_task_scheduled;
 
-        /* For checking status from outside the event-loop thread. */
-        bool is_open;
-
     } synced_data;
 };
 
+/**
+ * The action which caused the stream to close.
+ */
+enum aws_h2_stream_closed_when {
+    AWS_H2_STREAM_CLOSED_WHEN_BOTH_SIDES_END_STREAM,
+    AWS_H2_STREAM_CLOSED_WHEN_RST_STREAM_RECEIVED,
+    AWS_H2_STREAM_CLOSED_WHEN_RST_STREAM_SENT,
+};
+
 /* Private functions called from tests... */
 
 AWS_EXTERN_C_BEGIN
@@ -110,4 +126,19 @@ AWS_EXTERN_C_END
  */
 void aws_h2_connection_enqueue_outgoing_frame(struct aws_h2_connection *connection, struct aws_h2_frame *frame);
 
+/**
+ * Invoked immediately after a stream enters the CLOSED state.
+ * The connection will remove the stream from its "active" datastructures,
+ * guaranteeing that no further decoder callbacks are invoked on the stream.
+ *
+ * This should NOT be invoked in the case of a "Connection Error",
+ * though a "Stream Error", in which a RST_STREAM is sent and the stream
+ * is closed early, would invoke this.
+ */
+int aws_h2_connection_on_stream_closed(
+    struct aws_h2_connection *connection,
+    struct aws_h2_stream *stream,
+    enum aws_h2_stream_closed_when closed_when,
+    int aws_error_code);
+
 #endif /* AWS_HTTP_H2_CONNECTION_H */

include/aws/http/private/h2_frames.h

@@ -33,6 +33,7 @@ enum aws_h2_frame_type {
     AWS_H2_FRAME_T_WINDOW_UPDATE = 0x08,
     AWS_H2_FRAME_T_CONTINUATION = 0x09,
     AWS_H2_FRAME_T_UNKNOWN,
+    AWS_H2_FRAME_TYPE_COUNT,
 };
 
 /* Represents flags that may be set on a frame (RFC-7540 6) */
@@ -45,7 +46,7 @@ enum aws_h2_frame_flag {
 };
 
 /* Error codes that may be present in RST_STREAM and GOAWAY frames (RFC-7540 7). */
-enum aws_h2_error_codes {
+enum aws_h2_error_code {
     AWS_H2_ERR_NO_ERROR = 0x00,
     AWS_H2_ERR_PROTOCOL_ERROR = 0x01, /* corresponds to AWS_ERROR_HTTP_PROTOCOL_ERROR */
     AWS_H2_ERR_INTERNAL_ERROR = 0x02,
@@ -162,6 +163,25 @@ AWS_EXTERN_C_BEGIN
 AWS_HTTP_API
 const char *aws_h2_frame_type_to_str(enum aws_h2_frame_type type);
 
+AWS_HTTP_API
+const char *aws_h2_error_code_to_str(enum aws_h2_error_code h2_error_code);
+
+/**
+ * Translate an AWS_ERROR_* into the appropriate HTTP/2 error-code to sending in a RST_STREAM or GOAWAY frame.
+ *
+ * Ex: AWS_ERROR_HTTP_PROTOCOL_ERROR -> AWS_H2_ERR_PROTOCOL_ERROR (0x1)
+ *
+ * AWS_H2_ERR_INTERNAL_ERROR is returned if nothing else matches.
+ *
+ * #TODO - is this really how we want to handle things? It seems weird to tell OUR user
+ *         about the specific rule that the peer violated. Also, if a bunch of AWS_ERROR_*
+ *         magically result in the peer being told that THEY did something wrong,
+ *         we are for sure going to accidentally re-use those AWS_ERROR_* codes for
+ *         errors-on-our-side when we should only be using them for errors-from-their-side.
+ */
+AWS_HTTP_API
+enum aws_h2_error_code aws_error_to_h2_error_code(int aws_error_code);
+
 /* Raises AWS_ERROR_INVALID_ARGUMENT if stream_id is 0 or exceeds AWS_H2_MAX_STREAM_ID */
 AWS_HTTP_API
 int aws_h2_validate_stream_id(uint32_t stream_id);

include/aws/http/private/h2_stream.h

@@ -34,12 +34,22 @@
 #define AWS_H2_STREAM_LOG(level, stream, text) AWS_H2_STREAM_LOGF(level, (stream), "%s", (text))
 
 enum aws_h2_stream_state {
+    /* Initial state, before anything sent or received. */
     AWS_H2_STREAM_STATE_IDLE,
+    /* (server-only) stream-id was reserved via PUSH_PROMISE on another stream,
+     * but HEADERS for this stream have not been sent yet */
     AWS_H2_STREAM_STATE_RESERVED_LOCAL,
+    /* (client-only) stream-id was reserved via PUSH_PROMISE on another stream,
+     * but HEADERS for this stream have not been received yet */
     AWS_H2_STREAM_STATE_RESERVED_REMOTE,
+    /* Neither side is done sending their message. */
     AWS_H2_STREAM_STATE_OPEN,
+    /* This side is done sending message (END_STREAM), but peer is not done. */
     AWS_H2_STREAM_STATE_HALF_CLOSED_LOCAL,
+    /* Peer is done sending message (END_STREAM), but this side is not done */
     AWS_H2_STREAM_STATE_HALF_CLOSED_REMOTE,
+    /* Both sides done sending message (END_STREAM),
+     * or either side has sent RST_STREAM */
     AWS_H2_STREAM_STATE_CLOSED,
 
     AWS_H2_STREAM_STATE_COUNT,
@@ -55,13 +65,8 @@ struct aws_h2_stream {
         enum aws_h2_stream_state state;
         uint64_t window_size; /* #TODO try to figure out how this actually works, and then implement it */
         struct aws_http_message *outgoing_message;
+        bool received_main_headers;
     } thread_data;
-
-    /* Any thread may touch this data, but the lock must be held */
-    struct {
-        struct aws_mutex lock;
-
-    } synced_data;
 };
 
 const char *aws_h2_stream_state_to_str(enum aws_h2_stream_state state);
@@ -75,6 +80,21 @@ enum aws_h2_stream_state aws_h2_stream_get_state(const struct aws_h2_stream *str
 /* Connection is ready to send frames from stream now */
 int aws_h2_stream_on_activated(struct aws_h2_stream *stream, bool *out_has_outgoing_data);
 
+int aws_h2_stream_on_decoder_headers_begin(struct aws_h2_stream *stream);
+
+int aws_h2_stream_on_decoder_headers_i(
+    struct aws_h2_stream *stream,
+    const struct aws_http_header *header,
+    enum aws_http_header_name name_enum,
+    enum aws_http_header_block block_type);
+
+int aws_h2_stream_on_decoder_headers_end(
+    struct aws_h2_stream *stream,
+    bool malformed,
+    enum aws_http_header_block block_type);
+
+int aws_h2_stream_on_decoder_end_stream(struct aws_h2_stream *stream);
+
 int aws_h2_stream_activate(struct aws_http_stream *stream);
 
 #endif /* AWS_HTTP_H2_STREAM_H */

include/aws/http/request_response.h

@@ -687,7 +687,7 @@ void aws_http_stream_update_window(struct aws_http_stream *stream, size_t increm
  * as http/2) for easier tracking purposes. For client streams, this will only be non-zero after a successful call
  * to aws_http_stream_activate()
  */
-uint32_t aws_http_stream_get_id(struct aws_http_stream *stream);
+uint32_t aws_http_stream_get_id(const struct aws_http_stream *stream);
 
 AWS_EXTERN_C_END