quicsilver 0.1.0 → 0.2.0

data/ext/quicsilver/quicsilver.c

@@ -8,6 +8,9 @@ static VALUE mQuicsilver;
 
 // Event queue for callbacks
 typedef struct CallbackEvent {
+    HQUIC connection;
+    void* connection_ctx;  // ConnectionContext pointer for building connection_data
+    VALUE client_obj;      // Ruby client object (for routing callbacks)
     char* event_type;
     uint64_t stream_id;
     char* data;
@@ -34,6 +37,7 @@ typedef struct {
     int failed;
     QUIC_STATUS error_status;
     uint64_t error_code;
+    VALUE client_obj;  // Ruby client object (Qnil for server connections)
 } ConnectionContext;
 
 // Listener state tracking
@@ -47,18 +51,25 @@ typedef struct {
 
 // Stream state tracking
 typedef struct {
+    HQUIC connection;
+    void* connection_ctx;  // ConnectionContext pointer (for building connection_data)
+    VALUE client_obj;      // Ruby client object (copied from connection context)
     int started;
     int shutdown;
     QUIC_STATUS error_status;
 } StreamContext;
 
 // Enqueue a callback event (thread-safe)
+// NOTE: Called from QUIC callback threads without GVL - cannot use Ruby API here
 static void
-enqueue_callback_event(const char* event_type, uint64_t stream_id, const char* data, size_t data_len)
+enqueue_callback_event(HQUIC connection, void* connection_ctx, VALUE client_obj, const char* event_type, uint64_t stream_id, const char* data, size_t data_len)
 {
     CallbackEvent* event = (CallbackEvent*)malloc(sizeof(CallbackEvent));
     if (event == NULL) return;
 
+    event->connection = connection;
+    event->connection_ctx = connection_ctx;
+    event->client_obj = client_obj;  // Store raw VALUE - will validate before use
     event->event_type = strdup(event_type);
     event->stream_id = stream_id;
     event->data = (char*)malloc(data_len);
@@ -78,15 +89,35 @@ enqueue_callback_event(const char* event_type, uint64_t stream_id, const char* d
     pthread_mutex_unlock(&queue_mutex);
 }
 
+// Free a single event
+static void
+free_event(CallbackEvent* event)
+{
+    if (event == NULL) return;
+    free(event->event_type);
+    free(event->data);
+    free(event);
+}
+
 // Process all pending callback events (called from Ruby)
 static VALUE
 quicsilver_process_events(VALUE self)
 {
     CallbackEvent* event;
-    VALUE server_class = rb_const_get(mQuicsilver, rb_intern("Server"));
+    VALUE server_class = Qnil;
     int processed = 0;
 
-    while (1) {
+    // Get Server class for server events (client_obj == Qnil)
+    server_class = rb_const_get_at(mQuicsilver, rb_intern("Server"));
+    if (rb_class_real(CLASS_OF(server_class)) != rb_cClass) {
+        server_class = Qnil;
+    }
+
+    // Process events in a loop, but limit iterations to avoid GVL starvation
+    int max_iterations = 100;
+    int iteration = 0;
+
+    while (iteration++ < max_iterations) {
         pthread_mutex_lock(&queue_mutex);
         event = event_queue_head;
         if (event != NULL) {
@@ -99,17 +130,42 @@ quicsilver_process_events(VALUE self)
 
         if (event == NULL) break;
 
-        if (!NIL_P(server_class)) {
-            rb_funcall(server_class, rb_intern("handle_stream"), 3,
-                ULL2NUM(event->stream_id),
-                rb_str_new_cstr(event->event_type),
-                rb_str_new(event->data, event->data_len));
+        // Route based on client_obj:
+        // - If Qnil: server event, route to Server.handle_stream with connection_data
+        // - If not Qnil: client event, route to client_obj.handle_stream_event
+        int handled = 0;
+
+        if (NIL_P(event->client_obj)) {
+            // Server event - build connection_data array [connection_handle, context_ptr]
+            if (!NIL_P(server_class)) {
+                VALUE connection_data = rb_ary_new2(2);
+                rb_ary_push(connection_data, ULL2NUM((uintptr_t)event->connection));
+                rb_ary_push(connection_data, ULL2NUM((uintptr_t)event->connection_ctx));
+
+                rb_funcall(server_class, rb_intern("handle_stream"), 4,
+                    connection_data,
+                    ULL2NUM(event->stream_id),
+                    rb_str_new_cstr(event->event_type),
+                    rb_str_new(event->data, event->data_len));
+                handled = 1;
+            }
+        } else {
+            // Client event - validate object is a real Ruby object before calling
+            // This catches use-after-free when connection was closed but events still queued
+            if (RB_TYPE_P(event->client_obj, T_OBJECT)) {
+                rb_funcall(event->client_obj, rb_intern("handle_stream_event"), 3,
+                    ULL2NUM(event->stream_id),
+                    rb_str_new_cstr(event->event_type),
+                    rb_str_new(event->data, event->data_len));
+                handled = 1;
+            }
+        }
+
+        if (handled) {
             processed++;
         }
 
-        free(event->event_type);
-        free(event->data);
-        free(event);
+        free_event(event);
     }
 
     return INT2NUM(processed);
@@ -144,15 +200,19 @@ StreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event)
                     if (combined != NULL) {
                         memcpy(combined, &Stream, sizeof(HQUIC));
                         memcpy(combined + sizeof(HQUIC), buffer->Buffer, buffer->Length);
-                        enqueue_callback_event(event_type, stream_id, combined, total_len);
+                        enqueue_callback_event(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, combined, total_len);
                         free(combined);
                     }
                 } else {
-                    enqueue_callback_event(event_type, stream_id, (const char*)buffer->Buffer, buffer->Length);
+                    enqueue_callback_event(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, (const char*)buffer->Buffer, buffer->Length);
                 }
             }
             break;
         case QUIC_STREAM_EVENT_SEND_COMPLETE:
+            // Free the send buffer that was allocated in quicsilver_send_stream
+            if (Event->SEND_COMPLETE.ClientContext != NULL) {
+                free(Event->SEND_COMPLETE.ClientContext);
+            }
             break;
         case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE:
             ctx->shutdown = 1;
@@ -162,7 +222,7 @@ StreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event)
         case QUIC_STREAM_EVENT_PEER_SEND_ABORTED:
             break;
     }
-    
+
     return QUIC_STATUS_SUCCESS;
 }
 
@@ -182,8 +242,8 @@ ConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event
         case QUIC_CONNECTION_EVENT_CONNECTED:
             ctx->connected = 1;
             ctx->failed = 0;
-            // Notify Ruby about new connection
-            enqueue_callback_event("CONNECTION_ESTABLISHED", 0, (const char*)&Connection, sizeof(HQUIC));
+            // Notify Ruby about new connection - pass ctx pointer for building connection_data
+            enqueue_callback_event(Connection, ctx, ctx->client_obj, "CONNECTION_ESTABLISHED", 0, (const char*)&Connection, sizeof(HQUIC));
             break;
         case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT:
             ctx->connected = 0;
@@ -199,12 +259,17 @@ ConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event
             break;
         case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE:
             ctx->connected = 0;
+            // Notify Ruby to clean up connection resources
+            enqueue_callback_event(Connection, ctx, ctx->client_obj, "CONNECTION_CLOSED", 0, (const char*)&Connection, sizeof(HQUIC));
             break;
          case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED:
             // Client opened a stream
             Stream = Event->PEER_STREAM_STARTED.Stream;
             stream_ctx = (StreamContext*)malloc(sizeof(StreamContext));
             if (stream_ctx != NULL) {
+                stream_ctx->connection = Connection;
+                stream_ctx->connection_ctx = ctx;  // Store connection context pointer
+                stream_ctx->client_obj = ctx->client_obj;  // Copy from connection context
                 stream_ctx->started = 1;
                 stream_ctx->shutdown = 0;
                 stream_ctx->error_status = QUIC_STATUS_SUCCESS;
@@ -240,16 +305,18 @@ ListenerCallback(HQUIC Listener, void* Context, QUIC_LISTENER_EVENT* Event)
                 conn_ctx->failed = 0;
                 conn_ctx->error_status = QUIC_STATUS_SUCCESS;
                 conn_ctx->error_code = 0;
-                
+                conn_ctx->client_obj = Qnil;  // Server connections have no client object
+
                 // Set the connection callback
                 MsQuic->SetCallbackHandler(Event->NEW_CONNECTION.Connection, (void*)ConnectionCallback, conn_ctx);
-                
+
                 // Accept the new connection with the server configuration
                 QUIC_STATUS Status = MsQuic->ConnectionSetConfiguration(Event->NEW_CONNECTION.Connection, ctx->Configuration);
                 if (QUIC_FAILED(Status)) {
                     free(conn_ctx);
                     return Status;
                 }
+
             } else {
                 // Reject the connection if we can't allocate context
                 return QUIC_STATUS_OUT_OF_MEMORY;
@@ -355,7 +422,10 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     VALUE peer_bidi_stream_count_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("peer_bidi_stream_count")));
     VALUE peer_unidi_stream_count_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("peer_unidi_stream_count")));
     VALUE alpn_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("alpn")));
-    
+    VALUE stream_recv_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_recv_window")));
+    VALUE stream_recv_buffer_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_recv_buffer")));
+    VALUE conn_flow_control_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("conn_flow_control_window")));
+
     QUIC_STATUS Status;
     HQUIC Configuration = NULL;
 
@@ -366,9 +436,12 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     uint32_t peer_bidi_stream_count = NUM2INT(peer_bidi_stream_count_val);
     uint32_t peer_unidi_stream_count = NUM2INT(peer_unidi_stream_count_val);
     const char* alpn_str = StringValueCStr(alpn_val);
+    uint32_t stream_recv_window = NUM2UINT(stream_recv_window_val);
+    uint32_t stream_recv_buffer = NUM2UINT(stream_recv_buffer_val);
+    uint32_t conn_flow_control_window = NUM2UINT(conn_flow_control_window_val);
 
     QUIC_SETTINGS Settings = {0};
-    Settings.IdleTimeoutMs = idle_timeout_ms; 
+    Settings.IdleTimeoutMs = idle_timeout_ms;
     Settings.IsSet.IdleTimeoutMs = TRUE;
     Settings.ServerResumptionLevel = server_resumption_level;
     Settings.IsSet.ServerResumptionLevel = TRUE;
@@ -377,6 +450,14 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     Settings.PeerUnidiStreamCount = peer_unidi_stream_count;
     Settings.IsSet.PeerUnidiStreamCount = TRUE;
 
+    // Flow control / backpressure settings
+    Settings.StreamRecvWindowDefault = stream_recv_window;
+    Settings.IsSet.StreamRecvWindowDefault = TRUE;
+    Settings.StreamRecvBufferDefault = stream_recv_buffer;
+    Settings.IsSet.StreamRecvBufferDefault = TRUE;
+    Settings.ConnFlowControlWindow = conn_flow_control_window;
+    Settings.IsSet.ConnFlowControlWindow = TRUE;
+
     QUIC_BUFFER Alpn = { (uint32_t)strlen(alpn_str), (uint8_t*)alpn_str };
     
     // Create configuration
@@ -408,35 +489,44 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
 
 // Create a QUIC connection with context
 static VALUE
-quicsilver_create_connection(VALUE self)
+quicsilver_create_connection(VALUE self, VALUE client_obj)
 {
     if (MsQuic == NULL) {
         rb_raise(rb_eRuntimeError, "MSQUIC not initialized. Call Quicsilver.open_connection first.");
         return Qnil;
     }
-    
+
     QUIC_STATUS Status;
     HQUIC Connection = NULL;
-    
+
     // Allocate and initialize connection context
     ConnectionContext* ctx = (ConnectionContext*)malloc(sizeof(ConnectionContext));
     if (ctx == NULL) {
         rb_raise(rb_eRuntimeError, "Failed to allocate connection context");
         return Qnil;
     }
-    
+
     ctx->connected = 0;
     ctx->failed = 0;
     ctx->error_status = QUIC_STATUS_SUCCESS;
     ctx->error_code = 0;
-    
+    ctx->client_obj = client_obj;  // Store Ruby client object (Qnil for server)
+
+    // Protect from GC if it's a Ruby object
+    if (!NIL_P(client_obj)) {
+        rb_gc_register_address(&ctx->client_obj);
+    }
+
     // Create connection with enhanced callback and context
     if (QUIC_FAILED(Status = MsQuic->ConnectionOpen(Registration, ConnectionCallback, ctx, &Connection))) {
+        if (!NIL_P(client_obj)) {
+            rb_gc_unregister_address(&ctx->client_obj);
+        }
         free(ctx);
         rb_raise(rb_eRuntimeError, "ConnectionOpen failed, 0x%x!", Status);
         return Qnil;
     }
-    
+
     // Return both the connection handle and context as an array
     VALUE result = rb_ary_new2(2);
     rb_ary_push(result, ULL2NUM((uintptr_t)Connection));
@@ -522,27 +612,55 @@ quicsilver_close_connection_handle(VALUE self, VALUE connection_data)
     if (MsQuic == NULL) {
         return Qnil;
     }
-    
+
     // Extract connection handle and context from array
     VALUE connection_handle = rb_ary_entry(connection_data, 0);
     VALUE context_handle = rb_ary_entry(connection_data, 1);
-    
+
     HQUIC Connection = (HQUIC)(uintptr_t)NUM2ULL(connection_handle);
     ConnectionContext* ctx = (ConnectionContext*)(uintptr_t)NUM2ULL(context_handle);
-    
-    // Only close if connection is valid
+
     if (Connection != NULL) {
         MsQuic->ConnectionClose(Connection);
     }
-    
+
     // Free context if valid
     if (ctx != NULL) {
+        // Unregister from GC if client object was set
+        if (!NIL_P(ctx->client_obj)) {
+            rb_gc_unregister_address(&ctx->client_obj);
+        }
         free(ctx);
     }
-    
+
     return Qnil;
 }
 
+// Gracefully shutdown a QUIC connection (sends CONNECTION_CLOSE frame to peer)
+// silent = true: immediate shutdown without notifying peer
+// silent = false: graceful shutdown with CONNECTION_CLOSE frame
+static VALUE
+quicsilver_connection_shutdown(VALUE self, VALUE connection_handle, VALUE error_code, VALUE silent)
+{
+    if (MsQuic == NULL) {
+        rb_raise(rb_eRuntimeError, "MSQUIC not initialized.");
+        return Qnil;
+    }
+
+    HQUIC Connection = (HQUIC)(uintptr_t)NUM2ULL(connection_handle);
+    uint64_t ErrorCode = NUM2ULL(error_code);
+
+    if (Connection != NULL) {
+        QUIC_CONNECTION_SHUTDOWN_FLAGS flags = RTEST(silent)
+            ? QUIC_CONNECTION_SHUTDOWN_FLAG_SILENT
+            : QUIC_CONNECTION_SHUTDOWN_FLAG_NONE;
+
+        MsQuic->ConnectionShutdown(Connection, flags, ErrorCode);
+    }
+
+    return Qtrue;
+}
+
 // Close a QUIC configuration
 static VALUE
 quicsilver_close_configuration(VALUE self, VALUE config_handle)
@@ -683,15 +801,22 @@ quicsilver_close_listener(VALUE self, VALUE listener_data)
 }
 
 // Open a QUIC stream
+// Accepts connection_data array [connection_handle, context_handle]
+// Works uniformly for both client and server
 static VALUE
-quicsilver_open_stream(VALUE self, VALUE connection_handle, VALUE unidirectional)
+quicsilver_open_stream(VALUE self, VALUE connection_data, VALUE unidirectional)
 {
     if (MsQuic == NULL) {
         rb_raise(rb_eRuntimeError, "MSQUIC not initialized.");
         return Qnil;
     }
 
+    // Extract connection handle and context from array
+    VALUE connection_handle = rb_ary_entry(connection_data, 0);
+    VALUE context_handle = rb_ary_entry(connection_data, 1);
+
     HQUIC Connection = (HQUIC)(uintptr_t)NUM2ULL(connection_handle);
+    ConnectionContext* conn_ctx = (ConnectionContext*)(uintptr_t)NUM2ULL(context_handle);
     HQUIC Stream = NULL;
 
     StreamContext* ctx = (StreamContext*)malloc(sizeof(StreamContext));
@@ -699,7 +824,10 @@ quicsilver_open_stream(VALUE self, VALUE connection_handle, VALUE unidirectional
         rb_raise(rb_eRuntimeError, "Failed to allocate stream context");
         return Qnil;
     }
-    
+
+    ctx->connection = Connection;
+    ctx->connection_ctx = conn_ctx;  // Store connection context pointer
+    ctx->client_obj = conn_ctx ? conn_ctx->client_obj : Qnil;
     ctx->started = 1;
     ctx->shutdown = 0;
     ctx->error_status = QUIC_STATUS_SUCCESS;
@@ -785,11 +913,12 @@ Init_quicsilver(void)
     rb_define_singleton_method(mQuicsilver, "create_server_configuration", quicsilver_create_server_configuration, 1);
     rb_define_singleton_method(mQuicsilver, "close_configuration", quicsilver_close_configuration, 1);
     
-    // Connection management  
-    rb_define_singleton_method(mQuicsilver, "create_connection", quicsilver_create_connection, 0);
+    // Connection management
+    rb_define_singleton_method(mQuicsilver, "create_connection", quicsilver_create_connection, 1);
     rb_define_singleton_method(mQuicsilver, "start_connection", quicsilver_start_connection, 4);
     rb_define_singleton_method(mQuicsilver, "wait_for_connection", quicsilver_wait_for_connection, 2);
     rb_define_singleton_method(mQuicsilver, "connection_status", quicsilver_connection_status, 1);
+    rb_define_singleton_method(mQuicsilver, "connection_shutdown", quicsilver_connection_shutdown, 3);
     rb_define_singleton_method(mQuicsilver, "close_connection_handle", quicsilver_close_connection_handle, 1);
     
     // Listener management