Generalize event_loop.Client to support H3 and raw QUIC protocols

Previously Client only supported .webtransport. Now all three application
protocols work through the same handler-callback pattern:

- .h3: onHeaders, onData, onFinished, onSettings, onGoaway callbacks;
  ClientSession gains sendRequest/sendResponse/recvBody methods
- .quic: onStreamData, onStreamFinished callbacks; ClientSession gains
  openStream/writeStream/closeQuicStream/readStream methods
- .webtransport: unchanged

Server also gains pollQuicEvents and raw QUIC Session methods
(writeStream, closeQuicStream, readStream, openStream).

ALPN is now protocol-aware (configurable via ClientConfig.alpn).

New apps: h3_client, quic_client, quic_server.
All 6 interop directions verified (Zig↔Zig, Zig↔Go for both H3 and QUIC).

Author: endel

apps/h3_client.zig

@@ -0,0 +1,90 @@
+const std = @import("std");
+const quic = @import("quic");
+const event_loop = quic.event_loop;
+const qpack = quic.qpack;
+
+const H3Client = struct {
+    pub const protocol: event_loop.Protocol = .h3;
+
+    alloc: std.mem.Allocator,
+    got_response: bool = false,
+    request_sent: bool = false,
+    path: []const u8 = "/",
+
+    pub fn onConnected(self: *H3Client, session: *event_loop.ClientSession) void {
+        std.debug.print("H3 connection established\n", .{});
+
+        const req_headers = [_]qpack.Header{
+            .{ .name = ":method", .value = "GET" },
+            .{ .name = ":scheme", .value = "https" },
+            .{ .name = ":authority", .value = "localhost" },
+            .{ .name = ":path", .value = self.path },
+            .{ .name = "user-agent", .value = "quic-zig/1.0" },
+        };
+        const stream_id = session.sendRequest(&req_headers, null) catch |err| {
+            std.debug.print("sendRequest error: {any}\n", .{err});
+            return;
+        };
+        self.request_sent = true;
+        std.debug.print("H3: sent GET {s} on stream {d}\n", .{ self.path, stream_id });
+    }
+
+    pub fn onHeaders(_: *H3Client, _: *event_loop.ClientSession, stream_id: u64, headers: []const qpack.Header) void {
+        std.debug.print("H3: response headers on stream {d}:\n", .{stream_id});
+        for (headers) |h| {
+            std.debug.print("  {s}: {s}\n", .{ h.name, h.value });
+        }
+    }
+
+    pub fn onData(self: *H3Client, session: *event_loop.ClientSession, stream_id: u64, len: usize) void {
+        _ = stream_id;
+        _ = len;
+        var body_buf: [8192]u8 = undefined;
+        while (true) {
+            const n = session.recvBody(&body_buf);
+            if (n == 0) break;
+            std.debug.print("Response: {s}", .{body_buf[0..n]});
+        }
+        self.got_response = true;
+    }
+
+    pub fn onFinished(self: *H3Client, session: *event_loop.ClientSession, stream_id: u64) void {
+        std.debug.print("H3: stream {d} finished\n", .{stream_id});
+        if (self.got_response) {
+            session.closeConnection();
+        }
+    }
+};
+
+pub fn main() !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    var port: u16 = 4434;
+    var path: []const u8 = "/";
+    var insecure = false;
+    var args = std.process.args();
+    _ = args.next();
+    while (args.next()) |arg| {
+        if (std.mem.eql(u8, arg, "--port")) {
+            if (args.next()) |v| port = std.fmt.parseInt(u16, v, 10) catch 4434;
+        } else if (std.mem.eql(u8, arg, "--path")) {
+            if (args.next()) |v| path = v;
+        } else if (std.mem.eql(u8, arg, "--insecure")) {
+            insecure = true;
+        }
+    }
+
+    std.debug.print("H3 client connecting to 127.0.0.1:{d}\n", .{port});
+
+    var handler = H3Client{ .alloc = alloc, .path = path };
+    var client = try event_loop.Client(H3Client).init(alloc, &handler, .{
+        .port = port,
+        .ca_cert_path = if (insecure) null else "interop/certs/ca.crt",
+        .skip_cert_verify = insecure,
+    });
+    defer client.deinit();
+
+    try client.run();
+}

apps/quic_client.zig

@@ -0,0 +1,70 @@
+const std = @import("std");
+const quic = @import("quic");
+const event_loop = quic.event_loop;
+
+const QuicEchoClient = struct {
+    pub const protocol: event_loop.Protocol = .quic;
+
+    got_response: bool = false,
+    stream_id: ?u64 = null,
+    message: []const u8 = "Hello from Zig QUIC client!",
+
+    pub fn onConnected(self: *QuicEchoClient, session: *event_loop.ClientSession) void {
+        std.debug.print("QUIC connection established\n", .{});
+
+        const sid = session.openStream() catch |err| {
+            std.debug.print("openStream error: {any}\n", .{err});
+            return;
+        };
+        self.stream_id = sid;
+
+        session.writeStream(sid, self.message) catch |err| {
+            std.debug.print("writeStream error: {any}\n", .{err});
+            return;
+        };
+        session.closeQuicStream(sid);
+        std.debug.print("Sent on stream {d}: {s}\n", .{ sid, self.message });
+    }
+
+    pub fn onStreamData(self: *QuicEchoClient, _: *event_loop.ClientSession, stream_id: u64, data: []const u8) void {
+        std.debug.print("Response on stream {d}: {s}\n", .{ stream_id, data });
+        self.got_response = true;
+    }
+
+    pub fn onStreamFinished(self: *QuicEchoClient, session: *event_loop.ClientSession, stream_id: u64) void {
+        std.debug.print("Stream {d} finished\n", .{stream_id});
+        if (self.got_response) {
+            session.closeConnection();
+        }
+    }
+};
+
+pub fn main() !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    var port: u16 = 4434;
+    var insecure = false;
+    var args = std.process.args();
+    _ = args.next();
+    while (args.next()) |arg| {
+        if (std.mem.eql(u8, arg, "--port")) {
+            if (args.next()) |v| port = std.fmt.parseInt(u16, v, 10) catch 4434;
+        } else if (std.mem.eql(u8, arg, "--insecure")) {
+            insecure = true;
+        }
+    }
+
+    std.debug.print("QUIC echo client connecting to 127.0.0.1:{d}\n", .{port});
+
+    var handler = QuicEchoClient{};
+    var client = try event_loop.Client(QuicEchoClient).init(alloc, &handler, .{
+        .port = port,
+        .ca_cert_path = if (insecure) null else "interop/certs/ca.crt",
+        .skip_cert_verify = insecure,
+    });
+    defer client.deinit();
+
+    try client.run();
+}

apps/quic_server.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+const quic = @import("quic");
+const event_loop = quic.event_loop;
+
+const QuicEchoHandler = struct {
+    pub const protocol: event_loop.Protocol = .quic;
+
+    pub fn onStreamData(_: *QuicEchoHandler, session: *event_loop.Session, stream_id: u64, data: []const u8) void {
+        std.log.info("stream {d} received: {s}", .{ stream_id, data });
+        // Echo back
+        session.writeStream(stream_id, data) catch |err| {
+            std.log.err("writeStream error: {any}", .{err});
+            return;
+        };
+        session.closeQuicStream(stream_id);
+        std.log.info("stream {d} echoed {d} bytes", .{ stream_id, data.len });
+    }
+
+    pub fn onStreamFinished(_: *QuicEchoHandler, _: *event_loop.Session, stream_id: u64) void {
+        std.log.info("stream {d} finished", .{stream_id});
+    }
+};
+
+pub fn main() !void {
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const alloc = arena.allocator();
+
+    var port: u16 = 4434;
+    var args = std.process.args();
+    _ = args.next();
+    while (args.next()) |arg| {
+        if (std.mem.eql(u8, arg, "--port")) {
+            if (args.next()) |v| port = std.fmt.parseInt(u16, v, 10) catch 4434;
+        }
+    }
+
+    var handler = QuicEchoHandler{};
+    var server = try event_loop.Server(QuicEchoHandler).init(alloc, &handler, .{
+        .port = port,
+        .cert_path = "interop/certs/server.crt",
+        .key_path = "interop/certs/server.key",
+    });
+    defer server.deinit();
+
+    std.log.info("QUIC echo server listening on 127.0.0.1:{d}", .{port});
+    try server.run();
+}

build.zig

@@ -73,6 +73,29 @@ pub fn build(b: *std.Build) void {
     if (b.args) |args| run_client.addArgs(args);
     b.step("run-client", "Run QUIC client").dependOn(&run_client.step);
 
+    // H3 client (event_loop)
+    const exe_h3_client = App.add(b, "h3-client", "apps/h3_client.zig", target, optimize, need_libc, lib_mod);
+    b.installArtifact(exe_h3_client);
+    const run_h3_client = b.addRunArtifact(exe_h3_client);
+    run_h3_client.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_h3_client.addArgs(args);
+    b.step("run-h3-client", "Run H3 client").dependOn(&run_h3_client.step);
+
+    // Raw QUIC server (event_loop)
+    const exe_quic_server = App.add(b, "quic-server", "apps/quic_server.zig", target, optimize, need_libc, lib_mod);
+    b.installArtifact(exe_quic_server);
+    const run_quic_server = b.addRunArtifact(exe_quic_server);
+    run_quic_server.step.dependOn(b.getInstallStep());
+    b.step("run-quic-server", "Run raw QUIC echo server").dependOn(&run_quic_server.step);
+
+    // Raw QUIC client (event_loop)
+    const exe_quic_client = App.add(b, "quic-client", "apps/quic_client.zig", target, optimize, need_libc, lib_mod);
+    b.installArtifact(exe_quic_client);
+    const run_quic_client = b.addRunArtifact(exe_quic_client);
+    run_quic_client.step.dependOn(b.getInstallStep());
+    if (b.args) |args| run_quic_client.addArgs(args);
+    b.step("run-quic-client", "Run raw QUIC echo client").dependOn(&run_quic_client.step);
+
     // WebTransport server
     const exe_wt_server = App.add(b, "wt-server", "apps/wt_server.zig", target, optimize, need_libc, lib_mod);
     b.installArtifact(exe_wt_server);