socket related from network_framework_integration branch

README.md

@@ -148,6 +148,7 @@ Simply call the `aws_client_bootstrap_new_socket_channel` `aws_server_bootstrap_
 ### Event Loop
 Core to Async-IO is the event-loop. We provide an implementation for most platforms out of the box:
 
+<!-- DEBUG WIP we need to insert Dispatch Queue here for iOS and specify kQueue is for macOS -->
 Platform | Implementation
 --- | ---
 Linux | Edge-Triggered Epoll

include/aws/io/private/dispatch_queue.h

@@ -0,0 +1,52 @@
+#ifndef AWS_IO_PRIVATE_DISPATCH_QUEUE_H
+#define AWS_IO_PRIVATE_DISPATCH_QUEUE_H
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <Security/Security.h>
+#include <aws/io/tls_channel_handler.h>
+#include <dispatch/dispatch.h>
+
+struct secure_transport_ctx {
+    struct aws_tls_ctx ctx;
+    CFAllocatorRef wrapped_allocator;
+    CFArrayRef certs;
+    SecIdentityRef secitem_identity;
+    CFArrayRef ca_cert;
+    enum aws_tls_versions minimum_version;
+    struct aws_string *alpn_list;
+    bool verify_peer;
+};
+
+struct dispatch_scheduling_state {
+    // Let's us skip processing an iteration task if one is already in the middle
+    // of executing
+    bool is_executing_iteration;
+
+    // List<scheduled_service_entry> in sorted order by timestamp
+    //
+    // When we go to schedule a new iteration, we check here first to see
+    // if our scheduling attempt is redundant
+    struct aws_linked_list scheduled_services;
+};
+
+struct dispatch_loop {
+    struct aws_allocator *allocator;
+    struct aws_ref_count ref_count;
+    dispatch_queue_t dispatch_queue;
+    struct aws_task_scheduler scheduler;
+    struct aws_linked_list local_cross_thread_tasks;
+
+    struct {
+        struct dispatch_scheduling_state scheduling_state;
+        struct aws_linked_list cross_thread_tasks;
+        struct aws_mutex lock;
+        bool suspended;
+    } synced_data;
+
+    bool wakeup_schedule_needed;
+};
+
+#endif /* #ifndef AWS_IO_PRIVATE_DISPATCH_QUEUE_H */

include/aws/io/private/socket.h

@@ -0,0 +1,20 @@
+#ifndef AWS_IO_PRIVATE_SOCKET_H
+#define AWS_IO_PRIVATE_SOCKET_H
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/io/socket.h>
+
+int aws_socket_init_poll_based(
+    struct aws_socket *socket,
+    struct aws_allocator *alloc,
+    const struct aws_socket_options *options);
+
+int aws_socket_init_completion_port_based(
+    struct aws_socket *socket,
+    struct aws_allocator *alloc,
+    const struct aws_socket_options *options);
+
+#endif /* #ifndef AWS_IO_PRIVATE_SOCKET_H */

include/aws/io/socket.h

@@ -6,6 +6,7 @@
  */
 
 #include <aws/io/channel.h>
+#include <aws/io/event_loop.h>
 #include <aws/io/io.h>
 
 AWS_PUSH_SANE_WARNING_LEVEL
@@ -44,6 +45,7 @@ struct aws_socket_options {
     /* If set, sets the number of keep alive probes allowed to fail before the connection is considered
      * lost. If zero OS defaults are used. On Windows, this option is meaningless until Windows 10 1703.*/
     uint16_t keep_alive_max_failed_probes;
+    enum aws_event_loop_style event_loop_style;
     bool keepalive;
 
     /**
@@ -114,7 +116,44 @@ struct aws_socket_endpoint {
     uint32_t port;
 };
 
+struct aws_socket;
+
+struct aws_socket_vtable {
+    void (*socket_cleanup_fn)(struct aws_socket *socket);
+    int (*socket_connect_fn)(
+        struct aws_socket *socket,
+        const struct aws_socket_endpoint *remote_endpoint,
+        struct aws_event_loop *event_loop,
+        aws_socket_on_connection_result_fn *on_connection_result,
+        void *user_data);
+    int (*socket_bind_fn)(struct aws_socket *socket, const struct aws_socket_endpoint *local_endpoint);
+    int (*socket_listen_fn)(struct aws_socket *socket, int backlog_size);
+    int (*socket_start_accept_fn)(
+        struct aws_socket *socket,
+        struct aws_event_loop *accept_loop,
+        aws_socket_on_accept_result_fn *on_accept_result,
+        void *user_data);
+    int (*socket_stop_accept_fn)(struct aws_socket *socket);
+    int (*socket_close_fn)(struct aws_socket *socket);
+    int (*socket_shutdown_dir_fn)(struct aws_socket *socket, enum aws_channel_direction dir);
+    int (*socket_set_options_fn)(struct aws_socket *socket, const struct aws_socket_options *options);
+    int (*socket_assign_to_event_loop_fn)(struct aws_socket *socket, struct aws_event_loop *event_loop);
+    int (*socket_subscribe_to_readable_events_fn)(
+        struct aws_socket *socket,
+        aws_socket_on_readable_fn *on_readable,
+        void *user_data);
+    int (*socket_read_fn)(struct aws_socket *socket, struct aws_byte_buf *buffer, size_t *amount_read);
+    int (*socket_write_fn)(
+        struct aws_socket *socket,
+        const struct aws_byte_cursor *cursor,
+        aws_socket_on_write_completed_fn *written_fn,
+        void *user_data);
+    int (*socket_get_error_fn)(struct aws_socket *socket);
+    bool (*socket_is_open_fn)(struct aws_socket *socket);
+};
+
 struct aws_socket {
+    struct aws_socket_vtable *vtable;
     struct aws_allocator *allocator;
     struct aws_socket_endpoint local_endpoint;
     struct aws_socket_endpoint remote_endpoint;
@@ -123,6 +162,7 @@ struct aws_socket {
     struct aws_event_loop *event_loop;
     struct aws_channel_handler *handler;
     int state;
+    enum aws_event_loop_style event_loop_style;
     aws_socket_on_readable_fn *readable_fn;
     void *readable_user_data;
     aws_socket_on_connection_result_fn *connection_result_fn;
@@ -147,6 +187,14 @@ aws_ms_fn_ptr aws_winsock_get_acceptex_fn(void);
 
 AWS_EXTERN_C_BEGIN
 
+AWS_IO_API struct aws_socket_options aws_socket_options_default_tcp_ipv6(enum aws_event_loop_style el_style);
+AWS_IO_API struct aws_socket_options aws_socket_options_default_tcp_ipv4(enum aws_event_loop_style el_style);
+
+AWS_IO_API struct aws_socket_options aws_socket_options_default_udp_ipv6(enum aws_event_loop_style el_style);
+AWS_IO_API struct aws_socket_options aws_socket_options_default_udp_ipv4(enum aws_event_loop_style el_style);
+
+AWS_IO_API struct aws_socket_options aws_socket_options_default_local(enum aws_event_loop_style el_style);
+
 /**
  * Initializes a socket object with socket options. options will be copied.
  */
@@ -260,7 +308,7 @@ AWS_IO_API int aws_socket_assign_to_event_loop(struct aws_socket *socket, struct
 AWS_IO_API struct aws_event_loop *aws_socket_get_event_loop(struct aws_socket *socket);
 
 /**
- * Subscribes on_readable to notifications when the socket goes readable (edge-triggered). Errors will also be recieved
+ * Subscribes on_readable to notifications when the socket goes readable (edge-triggered). Errors will also be received
  * in the callback.
  *
  * Note! This function is technically not thread safe, but we do not enforce which thread you call from.

source/channel_bootstrap.c

@@ -523,6 +523,10 @@ static bool s_aws_socket_domain_uses_dns(enum aws_socket_domain domain) {
     return domain == AWS_SOCKET_IPV4 || domain == AWS_SOCKET_IPV6;
 }
 
+/* Called when a socket connection attempt task completes. First socket to successfully open
+ * assigns itself to connection_args->channel_data.socket and flips connection_args->connection_chosen
+ * to true. Subsequent successful sockets will be released and cleaned up
+ */
 static void s_on_client_connection_established(struct aws_socket *socket, int error_code, void *user_data) {
     struct client_connection_args *connection_args = user_data;
 
@@ -565,7 +569,6 @@ static void s_on_client_connection_established(struct aws_socket *socket, int er
             (void *)connection_args->bootstrap,
             (void *)socket);
         aws_socket_close(socket);
-
         aws_socket_clean_up(socket);
         aws_mem_release(connection_args->bootstrap->allocator, socket);
 
@@ -813,8 +816,9 @@ int aws_client_bootstrap_new_socket_channel(struct aws_socket_channel_bootstrap_
     AWS_FATAL_ASSERT(options->shutdown_callback);
     AWS_FATAL_ASSERT(bootstrap);
 
-    const struct aws_socket_options *socket_options = options->socket_options;
+    struct aws_socket_options *socket_options = (struct aws_socket_options *)options->socket_options;
     AWS_FATAL_ASSERT(socket_options != NULL);
+    socket_options->event_loop_style = aws_event_loop_group_get_style(bootstrap->event_loop_group);
 
     const struct aws_tls_connection_options *tls_options = options->tls_options;
 
@@ -832,10 +836,6 @@ int aws_client_bootstrap_new_socket_channel(struct aws_socket_channel_bootstrap_
     struct client_connection_args *client_connection_args =
         aws_mem_calloc(bootstrap->allocator, 1, sizeof(struct client_connection_args));
 
-    if (!client_connection_args) {
-        return AWS_OP_ERR;
-    }
-
     const char *host_name = options->host_name;
     uint32_t port = options->port;
 
@@ -1361,9 +1361,7 @@ void s_on_server_connection_result(
             (void *)socket);
         struct server_channel_data *channel_data =
             aws_mem_calloc(connection_args->bootstrap->allocator, 1, sizeof(struct server_channel_data));
-        if (!channel_data) {
-            goto error_cleanup;
-        }
+
         channel_data->incoming_called = false;
         channel_data->socket = new_socket;
         channel_data->server_connection_args = connection_args;
@@ -1376,11 +1374,10 @@ void s_on_server_connection_result(
             .setup_user_data = channel_data,
             .shutdown_user_data = channel_data,
             .on_shutdown_completed = s_on_server_channel_on_shutdown,
+            .event_loop = event_loop,
+            .enable_read_back_pressure = channel_data->server_connection_args->enable_read_back_pressure,
         };
 
-        channel_args.event_loop = event_loop;
-        channel_args.enable_read_back_pressure = channel_data->server_connection_args->enable_read_back_pressure;
-
         if (aws_socket_assign_to_event_loop(new_socket, event_loop)) {
             aws_mem_release(connection_args->bootstrap->allocator, (void *)channel_data);
             goto error_cleanup;
@@ -1497,6 +1494,8 @@ struct aws_socket *aws_server_bootstrap_new_socket_listener(
     struct aws_event_loop *connection_loop =
         aws_event_loop_group_get_next_loop(bootstrap_options->bootstrap->event_loop_group);
 
+    ((struct aws_socket_options *)bootstrap_options->socket_options)->event_loop_style =
+        aws_event_loop_group_get_style(bootstrap_options->bootstrap->event_loop_group);
     if (aws_socket_init(
             &server_connection_args->listener,
             bootstrap_options->bootstrap->allocator,

source/darwin/dispatch_queue_event_loop.c

@@ -14,6 +14,7 @@
 #include <unistd.h>
 
 #include <Block.h>
+#include <aws/io/private/dispatch_queue.h>
 #include <dispatch/dispatch.h>
 #include <dispatch/queue.h>
 
@@ -46,42 +47,13 @@ static struct aws_event_loop_vtable s_vtable = {
     .is_on_callers_thread = s_is_on_callers_thread,
 };
 
-struct dispatch_scheduling_state {
-    // Let's us skip processing an iteration task if one is already in the middle
-    // of executing
-    bool is_executing_iteration;
-
-    // List<scheduled_service_entry> in sorted order by timestamp
-    //
-    // When we go to schedule a new iteration, we check here first to see
-    // if our scheduling attempt is redundant
-    struct aws_linked_list scheduled_services;
-};
-
 struct scheduled_service_entry {
     struct aws_allocator *allocator;
     uint64_t timestamp;
     struct aws_linked_list_node node;
     struct aws_event_loop *loop; // might eventually need to be ref-counted for cleanup?
 };
 
-struct dispatch_loop {
-    struct aws_allocator *allocator;
-    struct aws_ref_count ref_count;
-    dispatch_queue_t dispatch_queue;
-    struct aws_task_scheduler scheduler;
-    struct aws_linked_list local_cross_thread_tasks;
-
-    struct {
-        struct dispatch_scheduling_state scheduling_state;
-        struct aws_linked_list cross_thread_tasks;
-        struct aws_mutex lock;
-        bool suspended;
-    } synced_data;
-
-    bool wakeup_schedule_needed;
-};
-
 struct scheduled_service_entry *scheduled_service_entry_new(struct aws_event_loop *loop, uint64_t timestamp) {
     struct scheduled_service_entry *entry = aws_mem_calloc(loop->alloc, 1, sizeof(struct scheduled_service_entry));