Cutomized alpn (#329)

You can customize the alpn map now

Author: TingDaoK

include/aws/http/connection.h

@@ -329,6 +329,16 @@ struct aws_http_client_connection_options {
      */
     bool prior_knowledge_http2;
 
+    /**
+     * Optional.
+     * Pointer to the hash map containing the ALPN string to protocol to use.
+     * Hash from `struct aws_string *` to `enum aws_http_version`.
+     * If not set, only the predefined string `h2` and `http/1.1` will be recognized. Other negotiated ALPN string will
+     * result in a HTTP1/1 connection
+     * Note: Connection will keep a deep copy of the table and the strings.
+     */
+    struct aws_hash_table *alpn_string_map;
+
     /**
      * Options specific to HTTP/1.x connections.
      * Optional.
@@ -452,6 +462,22 @@ enum aws_http_version aws_http_connection_get_version(const struct aws_http_conn
 AWS_HTTP_API
 struct aws_channel *aws_http_connection_get_channel(struct aws_http_connection *connection);
 
+/**
+ * Initialize an map copied from the *src map, which maps `struct aws_string *` to `enum aws_http_version`.
+ */
+AWS_HTTP_API
+int aws_http_alpn_map_init_copy(
+    struct aws_allocator *allocator,
+    struct aws_hash_table *dest,
+    struct aws_hash_table *src);
+
+/**
+ * Initialize an empty hash-table that maps `struct aws_string *` to `enum aws_http_version`.
+ * This map can used in aws_http_client_connections_options.alpn_string_map.
+ */
+AWS_HTTP_API
+int aws_http_alpn_map_init(struct aws_allocator *allocator, struct aws_hash_table *map);
+
 /**
  * Checks http proxy options for correctness
  */

include/aws/http/private/connection_impl.h

@@ -134,11 +134,14 @@ struct aws_http_client_bootstrap {
     aws_http_proxy_request_transform_fn *proxy_request_transform;
 
     struct aws_http1_connection_options http1_options;
-    struct aws_http2_connection_options http2_options;
+    struct aws_http2_connection_options http2_options; /* allocated with bootstrap */
+    struct aws_hash_table *alpn_string_map;            /* allocated with bootstrap */
     struct aws_http_connection *connection;
 };
 
 AWS_EXTERN_C_BEGIN
+AWS_HTTP_API
+void aws_http_client_bootstrap_destroy(struct aws_http_client_bootstrap *bootstrap);
 
 AWS_HTTP_API
 void aws_http_connection_set_system_vtable(const struct aws_http_connection_system_vtable *system_vtable);
@@ -182,6 +185,7 @@ uint32_t aws_http_connection_get_next_stream_id(struct aws_http_connection *conn
  * @param manual_window_management is manual window management enabled
  * @param prior_knowledge_http2 prior knowledge about http2 connection to be used
  * @param initial_window_size what should the initial window size be
+ * @param alpn_string_map the customized ALPN string map from `struct aws_string *` to `enum aws_http_version`.
  * @param http1_options http1 options
  * @param http2_options http2 options
  * @return a new http connection or NULL on failure
@@ -195,6 +199,7 @@ struct aws_http_connection *aws_http_connection_new_channel_handler(
     bool manual_window_management,
     bool prior_knowledge_http2,
     size_t initial_window_size,
+    const struct aws_hash_table *alpn_string_map,
     const struct aws_http1_connection_options *http1_options,
     const struct aws_http2_connection_options *http2_options);
 

include/aws/http/request_response.h

@@ -715,6 +715,7 @@ struct aws_http_stream *aws_http_connection_make_request(
 AWS_HTTP_API
 struct aws_http_stream *aws_http_stream_new_server_request_handler(
     const struct aws_http_request_handler_options *options);
+
 /**
  * Users must release the stream when they are done with it, or its memory will never be cleaned up.
  * This will not cancel the stream, its callbacks will still fire if the stream is still in progress.

source/connection.c

@@ -31,6 +31,15 @@ static struct aws_http_connection_system_vtable s_default_system_vtable = {
 
 static const struct aws_http_connection_system_vtable *s_system_vtable_ptr = &s_default_system_vtable;
 
+void aws_http_client_bootstrap_destroy(struct aws_http_client_bootstrap *bootstrap) {
+    /* During allocating, the underlying stuctures should be allocated with the bootstrap by aws_mem_acquire_many. Thus,
+     * we only need to clean up the first pointer which is the bootstrap */
+    if (bootstrap->alpn_string_map) {
+        aws_hash_table_clean_up(bootstrap->alpn_string_map);
+    }
+    aws_mem_release(bootstrap->alloc, bootstrap);
+}
+
 void aws_http_connection_set_system_vtable(const struct aws_http_connection_system_vtable *system_vtable) {
     s_system_vtable_ptr = system_vtable;
 }
@@ -78,6 +87,7 @@ struct aws_http_connection *aws_http_connection_new_channel_handler(
     bool manual_window_management,
     bool prior_knowledge_http2,
     size_t initial_window_size,
+    const struct aws_hash_table *alpn_string_map,
     const struct aws_http1_connection_options *http1_options,
     const struct aws_http2_connection_options *http2_options) {
 
@@ -124,7 +134,32 @@ struct aws_http_connection *aws_http_connection_new_channel_handler(
         struct aws_channel_handler *tls_handler = tls_slot->handler;
         struct aws_byte_buf protocol = aws_tls_handler_protocol(tls_handler);
         if (protocol.len) {
-            if (aws_string_eq_byte_buf(s_alpn_protocol_http_1_1, &protocol)) {
+            bool customized = false;
+            if (alpn_string_map) {
+                customized = true;
+                struct aws_string *negotiated_result = aws_string_new_from_buf(alloc, &protocol);
+                struct aws_hash_element *found = NULL;
+                aws_hash_table_find(alpn_string_map, (void *)negotiated_result, &found);
+                if (found) {
+                    version = (enum aws_http_version)(size_t)found->value;
+                    AWS_LOGF_DEBUG(
+                        AWS_LS_HTTP_CONNECTION,
+                        "static: Customized ALPN protocol " PRInSTR " used. " PRInSTR " client connection established.",
+                        AWS_BYTE_BUF_PRI(protocol),
+                        AWS_BYTE_CURSOR_PRI(aws_http_version_to_str(version)));
+                } else {
+                    AWS_LOGF_ERROR(
+                        AWS_LS_HTTP_CONNECTION,
+                        "static: Customized ALPN protocol " PRInSTR
+                        " used. However the it's not found in the ALPN map provided.",
+                        AWS_BYTE_BUF_PRI(protocol));
+                    version = AWS_HTTP_VERSION_UNKNOWN;
+                }
+                aws_string_destroy(negotiated_result);
+            }
+            if (customized) {
+                /* Do nothing */
+            } else if (aws_string_eq_byte_buf(s_alpn_protocol_http_1_1, &protocol)) {
                 version = AWS_HTTP_VERSION_1_1;
             } else if (aws_string_eq_byte_buf(s_alpn_protocol_http_2, &protocol)) {
                 version = AWS_HTTP_VERSION_2;
@@ -350,6 +385,29 @@ struct aws_channel *aws_http_connection_get_channel(struct aws_http_connection *
     return connection->channel_slot->channel;
 }
 
+int aws_http_alpn_map_init(struct aws_allocator *allocator, struct aws_hash_table *map) {
+    AWS_ASSERT(allocator);
+    AWS_ASSERT(map);
+    int result = aws_hash_table_init(
+        map,
+        allocator,
+        5 /* initial size */,
+        aws_hash_string,
+        aws_hash_callback_string_eq,
+        aws_hash_callback_string_destroy,
+        NULL);
+    if (result) {
+        /* OOM will crash */
+        int error_code = aws_last_error();
+        AWS_LOGF_ERROR(
+            AWS_LS_HTTP_CONNECTION,
+            "Failed to initialize ALPN map with error code %d (%s)",
+            error_code,
+            aws_error_name(error_code));
+    }
+    return result;
+}
+
 void aws_http_connection_acquire(struct aws_http_connection *connection) {
     AWS_ASSERT(connection);
     aws_atomic_fetch_add(&connection->refcount, 1);
@@ -417,6 +475,7 @@ static void s_server_bootstrap_on_accept_channel_setup(
         server->manual_window_management,
         false, /* prior_knowledge_http2 */
         server->initial_window_size,
+        NULL, /* alpn_string_map */
         &http1_options,
         &http2_options);
     if (!connection) {
@@ -735,7 +794,7 @@ static void s_client_bootstrap_on_channel_setup(
         http_bootstrap->on_setup(NULL, error_code, http_bootstrap->user_data);
 
         /* Clean up the http_bootstrap, it has no more work to do. */
-        aws_mem_release(http_bootstrap->alloc, http_bootstrap);
+        aws_http_client_bootstrap_destroy(http_bootstrap);
         return;
     }
 
@@ -749,6 +808,7 @@ static void s_client_bootstrap_on_channel_setup(
         http_bootstrap->manual_window_management,
         http_bootstrap->prior_knowledge_http2,
         http_bootstrap->initial_window_size,
+        http_bootstrap->alpn_string_map,
         &http_bootstrap->http1_options,
         &http_bootstrap->http2_options);
     if (!http_bootstrap->connection) {
@@ -840,7 +900,7 @@ static void s_client_bootstrap_on_channel_shutdown(
     }
 
     /* Clean up bootstrapper */
-    aws_mem_release(http_bootstrap->alloc, http_bootstrap);
+    aws_http_client_bootstrap_destroy(http_bootstrap);
 }
 
 static int s_validate_http_client_connection_options(const struct aws_http_client_connection_options *options) {
@@ -885,6 +945,61 @@ static int s_validate_http_client_connection_options(const struct aws_http_clien
     return AWS_OP_SUCCESS;
 }
 
+struct s_copy_alpn_string_map_context {
+    struct aws_hash_table *map;
+    struct aws_allocator *allocator;
+};
+
+/* put every item into the source to make a deep copy of the map */
+static int s_copy_alpn_string_map(void *context, struct aws_hash_element *item) {
+    struct s_copy_alpn_string_map_context *func_context = context;
+    struct aws_hash_table *dest = func_context->map;
+    /* make a deep copy of the string and hash map will own the copy */
+    struct aws_string *key_copy = aws_string_new_from_string(func_context->allocator, item->key);
+    int was_created;
+    if (aws_hash_table_put(dest, key_copy, item->value, &was_created)) {
+        int error_code = aws_last_error();
+        AWS_LOGF_ERROR(
+            AWS_LS_HTTP_CONNECTION,
+            "Failed to copy ALPN map with error code %d (%s)",
+            error_code,
+            aws_error_name(error_code));
+        /* failed to put into the table, we need to clean up the copy ourselves */
+        aws_string_destroy(key_copy);
+        /* return error to stop iteration */
+        return AWS_COMMON_HASH_TABLE_ITER_ERROR;
+    }
+    if (!was_created) {
+        /* no new entry created, clean up the copy ourselves */
+        aws_string_destroy(key_copy);
+    }
+    return AWS_COMMON_HASH_TABLE_ITER_CONTINUE;
+}
+
+int aws_http_alpn_map_init_copy(
+    struct aws_allocator *allocator,
+    struct aws_hash_table *dest,
+    struct aws_hash_table *src) {
+    if (aws_http_alpn_map_init(allocator, dest)) {
+        return AWS_OP_ERR;
+    }
+    struct s_copy_alpn_string_map_context context;
+    context.allocator = allocator;
+    context.map = dest;
+    /* make a deep copy of the map */
+    if (aws_hash_table_foreach(src, s_copy_alpn_string_map, &context)) {
+        int error_code = aws_last_error();
+        AWS_LOGF_ERROR(
+            AWS_LS_HTTP_CONNECTION,
+            "Failed to copy ALPN map with error code %d (%s)",
+            error_code,
+            aws_error_name(error_code));
+        aws_hash_table_clean_up(dest);
+        return AWS_OP_ERR;
+    }
+    return AWS_OP_SUCCESS;
+}
+
 int aws_http_client_connect_internal(
     const struct aws_http_client_connection_options *orig_options,
     aws_http_proxy_request_transform_fn *proxy_request_transform) {
@@ -899,6 +1014,10 @@ int aws_http_client_connect_internal(
 
     /* make copy of options, and add defaults for missing optional structs */
     struct aws_http_client_connection_options options = *orig_options;
+    if (options.prior_knowledge_http2 && options.tls_options) {
+        AWS_LOGF_ERROR(AWS_LS_HTTP_CONNECTION, "static: HTTP/2 prior knowledge only works with cleartext TCP.");
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
 
     struct aws_http1_connection_options default_http1_options;
     AWS_ZERO_STRUCT(default_http1_options);
@@ -926,13 +1045,16 @@ int aws_http_client_connect_internal(
     }
 
     struct aws_http2_setting *setting_array = NULL;
+    struct aws_hash_table *alpn_string_map = NULL;
     if (!aws_mem_acquire_many(
             options.allocator,
-            2,
+            3,
             &http_bootstrap,
             sizeof(struct aws_http_client_bootstrap),
             &setting_array,
-            options.http2_options->num_initial_settings * sizeof(struct aws_http2_setting))) {
+            options.http2_options->num_initial_settings * sizeof(struct aws_http2_setting),
+            &alpn_string_map,
+            sizeof(struct aws_hash_table))) {
         goto error;
     }
 
@@ -959,6 +1081,13 @@ int aws_http_client_connect_internal(
         http_bootstrap->http2_options.initial_settings_array = setting_array;
     }
 
+    if (options.alpn_string_map) {
+        if (aws_http_alpn_map_init_copy(options.allocator, alpn_string_map, options.alpn_string_map)) {
+            goto error;
+        }
+        http_bootstrap->alpn_string_map = alpn_string_map;
+    }
+
     if (options.monitoring_options) {
         http_bootstrap->monitoring_options = *options.monitoring_options;
     }
@@ -998,7 +1127,7 @@ int aws_http_client_connect_internal(
 
 error:
     if (http_bootstrap) {
-        aws_mem_release(http_bootstrap->alloc, http_bootstrap);
+        aws_http_client_bootstrap_destroy(http_bootstrap);
     }
 
     if (host_name) {
@@ -1070,6 +1199,5 @@ uint32_t aws_http_connection_get_next_stream_id(struct aws_http_connection *conn
     } else {
         connection->next_stream_id += 2;
     }
-
     return next_id;
 }

source/proxy_connection.c

@@ -536,6 +536,7 @@ static int s_aws_http_apply_http_connection_to_proxied_channel(struct aws_http_p
         context->original_manual_window_management,
         false, /* prior_knowledge_http2 */
         context->original_initial_window_size,
+        NULL, /* alpn_string_map */
         &context->original_http1_options,
         NULL); /* TODO: support http2 options */
     if (connection == NULL) {

tests/CMakeLists.txt

@@ -444,6 +444,8 @@ add_test_case(connection_setup_shutdown)
 add_test_case(connection_setup_shutdown_tls)
 add_test_case(connection_h2_prior_knowledge)
 add_test_case(connection_h2_prior_knowledge_not_work_with_tls)
+add_test_case(connection_customized_alpn)
+add_test_case(connection_customized_alpn_error_with_unknow_return_string)
 # These server tests occasionally fail. Resurrect if/when we get back to work on HTTP server.
 #add_test_case(connection_destroy_server_with_connection_existing)
 #add_test_case(connection_destroy_server_with_multiple_connections_existing)

tests/proxy_test_helper.c

@@ -235,7 +235,8 @@ int proxy_tester_clean_up(struct proxy_tester *tester) {
             if (i + 1 < channel_count) {
                 wrapper.bootstrap->on_shutdown(tester->client_connection, 0, wrapper.bootstrap->user_data);
             }
-            aws_mem_release(tester->alloc, wrapper.bootstrap);
+
+            aws_http_client_bootstrap_destroy(wrapper.bootstrap);
         }
     }