quic 0.0.5 → 0.0.7

data/ext/quic/stream.h

@@ -1,27 +1,47 @@
 #ifndef QUIC_STREAM_H
 #define QUIC_STREAM_H 1
 
+#include "connection_common.h"
 #include "quic.h"
 
 extern VALUE rb_cQUICStream;
 
 void Init_quic_stream(VALUE rb_mQUICArg);
 
-/* Internal helpers used by connection_common.c stream callbacks and
-   write_pkt's stream-aware path. */
+/* One write's bytes, kept until the peer acknowledges them. Outside the
+   Ruby heap: ngtcp2 keeps pointers into data to retransmit from, and
+   GC.compact moves an embedded String. */
+typedef struct quic_send_chunk {
+  struct quic_send_chunk *next;
+  size_t len;
+  uint8_t data[];
+} quic_send_chunk;
 
 typedef struct {
+  /* The QUIC::Stream wrapping this struct, for the stream callbacks, which
+     get the struct from ngtcp2's stream_user_data. It needs no mark, as it
+     holds the struct; quic_stream_compact follows it when GC.compact moves
+     it. */
+  VALUE self;
   int64_t stream_id;
-  /* Cumulative bytes handed to ngtcp2 via writev_stream so far. Increases
-     monotonically; used to derive the next send position within
-     @pending_chunks. */
-  uint64_t sent_offset;
-  /* Cumulative bytes acked by the peer (per acked_stream_data_offset).
-     Increases monotonically. */
-  uint64_t acked_offset;
-  /* Cumulative bytes shifted out of @pending_chunks. Always
-     <= acked_offset (we only shift a Chunk after its end is acked). */
-  uint64_t pending_shifted;
+  /* The send buffer: what #write queued and the peer has not acknowledged,
+     as chunks in stream order. Every offset below is a position in the
+     stream. The buffer is freed only where ngtcp2 can no longer read it:
+     as the peer acknowledges it, when the stream closes, and in dfree. */
+  quic_send_chunk *send_head;
+  quic_send_chunk *send_tail;
+  /* The chunk holding the next byte to hand to ngtcp2 (sent_offset), and
+     where in it; NULL once everything queued has been handed over. That
+     chunk ends after sent_offset, which acked_offset never passes, so an
+     acknowledgement never frees it. */
+  quic_send_chunk *send_next;
+  size_t send_next_off;
+  uint64_t head_offset;   /* where send_head->data[0] sits */
+  uint64_t queued_offset; /* just past the last byte queued */
+  uint64_t sent_offset;   /* just past the last byte handed to ngtcp2 */
+  uint64_t acked_offset;  /* just past the last byte acknowledged */
+  /* What the chunks take from xmalloc, headers included; part of dsize. */
+  size_t buffered;
   bool fin_received; /* recv_stream_data delivered FIN */
   bool fin_sent;     /* #write(fin: true) queued FIN */
   bool fin_flushed;  /* write_pkt actually wrote the FIN frame */
@@ -29,10 +49,13 @@ typedef struct {
   bool closed;       /* stream_close callback fired */
   uint64_t close_app_error_code;
   bool close_has_app_error_code;
-  /* The send side is shut: the peer's STOP_SENDING arrived, or ngtcp2
-     reported the send side shut while writing. @pending_chunks has been
-     emptied, so the offsets above no longer describe it, and #write_pkt
-     skips the stream. */
+  /* The send side is shut (quic_stream_stop): the peer's STOP_SENDING
+     arrived, #reset was called, ngtcp2 reported the send side shut while
+     writing, or the stream closed. Nothing queued goes out any more,
+     #write_pkt skips the stream, and what it had not sent no longer counts
+     in quic_conn_t.stream_unsent. The send buffer stays until the stream
+     closes: ngtcp2 may still hold pointers into it at this point
+     (recv_stop_sending runs before it drops the stream's queued frames). */
   bool stopped;
   uint64_t stop_app_error_code; /* the STOP_SENDING's, 0 if none arrived */
   /* Set once a peer-initiated stream has been pushed onto the owning
@@ -46,12 +69,35 @@ typedef struct {
   bool peer_stream_held;
 } quic_stream_t;
 
-extern const rb_data_type_t quic_stream_data_type;
+/* What a connection without a stream handler does with its streams, as
+   QUIC::Streams. connection_common.c hands its ngtcp2 stream callbacks and
+   #write_pkt here, and keeps only the choice between this and the
+   handler. */
 
-/* Allocate a new QUIC::Stream Ruby object for stream_id with a
-   zero-initialized quic_stream_t, and set its ivars (@id / @client /
-   @pending_chunks / @recv_buffer). @client is owner, the Client or Server
-   the stream belongs to; the ivar keeps its name for both. */
-VALUE quic_stream_new(int64_t stream_id, VALUE owner);
+/* Make a QUIC::Stream for stream_id, a stream #open_bidi_stream or
+   #open_uni_stream has just opened on the connection self (wrapping c),
+   and register it. Returns the Stream. */
+VALUE quic_stream_open_local(VALUE self, quic_conn_t *c, int64_t stream_id);
+
+/* The ngtcp2 stream callbacks. s is the stream's stream_user_data: NULL for
+   a stream whose QUIC::Stream could not be made, which they ignore. Those
+   returning int return 0, or NGTCP2_ERR_CALLBACK_FAILURE when Ruby code
+   raised; the exception waits in c->pending_exc. */
+int quic_stream_on_open(quic_conn_t *c, int64_t stream_id);
+int quic_stream_on_recv_data(quic_conn_t *c, quic_stream_t *s, uint32_t flags,
+                             const uint8_t *data, size_t datalen);
+void quic_stream_on_acked(quic_stream_t *s, uint64_t offset, uint64_t datalen);
+int quic_stream_on_close(quic_conn_t *c, quic_stream_t *s, int64_t stream_id,
+                         uint32_t flags, uint64_t app_error_code);
+void quic_stream_on_reset(quic_stream_t *s, uint64_t app_error_code);
+void quic_stream_on_recv_stop_sending(quic_conn_t *c, quic_stream_t *s,
+                                      uint64_t app_error_code);
+
+/* #write_pkt for the connection self (wrapping c): build the next packet
+   into dest, with data from the first stream in @streams that has any.
+   Returns what ngtcp2_conn_writev_stream returned. Raises nothing. */
+ngtcp2_ssize quic_streams_write_pkt(VALUE self, quic_conn_t *c,
+                                    ngtcp2_path *path, ngtcp2_pkt_info *pi,
+                                    uint8_t *dest, size_t destlen);
 
 #endif /* QUIC_STREAM_H */

data/lib/quic/connection.rb

@@ -108,6 +108,17 @@ module QUIC
         stream
       end
 
+      # Send an application CONNECTION_CLOSE carrying error_code and reason and
+      # enter the closing period. Raises QUIC::Error::NotBound unless #bind was
+      # called, except on a connection an Endpoint made, whose CONNECTION_CLOSE
+      # goes out through Endpoint#write_pkt. A no-op once the connection is
+      # closing or draining.
+      def close(error_code: 0, reason: nil)
+        packet = _close(error_code, reason)
+        @sock.send(packet, 0) if packet
+        nil
+      end
+
       private
 
       # A C stream handler (quic/ext.h) registered on the connection owns

data/lib/quic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QUIC
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/sig/quic.rbs

@@ -321,21 +321,23 @@ module QUIC
 
     # Blocks (by internally calling #pump_once on the owning Client or
     # Server) until the peer's flow control window has room for the full
-    # payload, then queues all bytes and returns data.bytesize. Requires the
-    # owning connection to be bound to a socket via #bind; raises
-    # QUIC::Error::NotBound otherwise. Raises QUIC::Error::StreamClosed,
-    # while waiting too, once the stream has been reset or closed, or the
-    # peer has sent STOP_SENDING. STOP_SENDING also drops what was queued
-    # but not yet sent.
+    # payload, then queues all bytes and returns data.bytesize. The window is
+    # the smaller of the stream's and the connection's, and the connection's
+    # is shared with what the other streams of the connection have queued
+    # but not yet sent. Requires the owning connection to be bound to a
+    # socket via #bind; raises QUIC::Error::NotBound otherwise. Raises
+    # QUIC::Error::StreamClosed, while waiting too, once the stream has been
+    # reset or closed, or the peer has sent STOP_SENDING. STOP_SENDING also
+    # drops what was queued but not yet sent.
     def write: (String data, ?fin: bool) -> Integer
 
     # Non-blocking variant. Queues as much of `data` as the current flow
-    # control window allows and returns the byte count actually queued.
-    # Raises QUIC::Error::WaitWritable (mixed in with IO::WaitWritable) when
-    # the window is zero and the payload is non-empty, and
-    # QUIC::Error::StreamClosed as #write does. If only a partial prefix is
-    # accepted, `fin: true` is NOT propagated; the caller must re-issue with
-    # `fin: true` on the trailing chunk.
+    # control window (see #write) allows and returns the byte count actually
+    # queued. Raises QUIC::Error::WaitWritable (mixed in with
+    # IO::WaitWritable) when the window is zero and the payload is non-empty,
+    # and QUIC::Error::StreamClosed as #write does. If only a partial prefix
+    # is accepted, `fin: true` is NOT propagated; the caller must re-issue
+    # with `fin: true` on the trailing chunk.
     def write_nonblock: (String data, ?fin: bool) -> Integer
     def eof?: () -> bool
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quic
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Yusuke Nakamura
@@ -93,14 +93,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Thin Ruby binding around ngtcp2 for the QUIC transport protocol, using picotls
   for TLS 1.3 over the system OpenSSL.