jetstream: use async dns resolution

build.zig.zon

···
 
     .dependencies = .{
         .ourio = .{
-            .url = "/home/tim/repos/github.com/rockorager/ourio",
-            .hash = "ourio-0.0.0-_s-z0SsPAgB0SDzLiMiEKWY9MrHCrdVEPL01OQF4uVcm",
+            .url = "git+https://github.com/rockorager/ourio#54a2eae0fe28d5258b0982ea66b77e3d340e376c",
+            .hash = "ourio-0.0.0-_s-z0cQPAgAbjkkQLaiiDRRRYUZlSyYLQhXwZ_J32dj2",
         },
     },
 

src/jetstream.zig

···
 const ourio = @import("ourio");
 
 const Allocator = std.mem.Allocator;
+const dns = stda.net.dns;
 const posix = std.posix;
 
 /// A stream of events from the jetstream
···
     challenge: []const u8,
 
     state: union(enum) {
+        dns,
         connect: *stda.net.ConnectTask,
         handshake: *stda.tls.Client.HandshakeTask,
         conn: *stda.tls.Client,
···
     const guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
     const Msg = enum {
+        dns,
         connect,
         handshake,
         upgrade,
···
         io: *ourio.Ring,
         bundle: std.crypto.Certificate.Bundle,
         opts: Options,
+        resolver: *dns.Resolver,
         ctx: ourio.Context,
     ) !void {
         var seed: u64 = undefined;
···
         var prng = std.Random.DefaultPrng.init(seed);
         const idx = prng.random().int(u2);
         const host = hosts[idx];
-        const task = try stda.net.tcpConnectToHost(io, host, 443, .{
+        const question: dns.Question = .{
+            .host = host,
+            .type = .A,
+        };
+
+        try resolver.resolveQuery(io, question, .{
             .ptr = self,
-            .msg = @intFromEnum(Msg.connect),
+            .msg = @intFromEnum(Msg.dns),
             .cb = Stream.onCompletion,
         });
 
···
             .gpa = gpa,
             .fd = -1,
             .bundle = bundle,
-            .state = .{ .connect = task },
+            .state = .dns,
             .challenge = "",
             .host = idx,
             .path = path,
···
         self.gpa.free(self.path);
         self.gpa.free(self.challenge);
         switch (self.state) {
+            .dns => {},
             .connect => {},
             .handshake => {},
             .conn => |conn| {
···
         const result = task.result.?;
 
         switch (task.msgToEnum(Msg)) {
+            .dns => {
+                const bytes = try result.userbytes;
+                const resp: dns.Response = .{ .bytes = bytes };
+                var iter = try resp.answerIterator();
+                while (iter.next()) |answer| {
+                    switch (answer) {
+                        .A => |ip4| {
+                            const addr = std.net.Ip4Address.init(ip4, 443);
+                            const conn_task = try stda.net.tcpConnectToAddr(io, .{ .in = addr }, .{
+                                .ptr = self,
+                                .msg = @intFromEnum(Msg.connect),
+                                .cb = Stream.onCompletion,
+                            });
+                            self.state = .{ .connect = conn_task };
+                        },
+
+                        .CNAME => {},
+
+                        else => return error.Unexpected,
+                    }
+                }
+            },
+
             .connect => {
                 self.fd = result.userfd catch |err| return self.reportError(io, err);
                 const hs_task = try stda.tls.Client.init(
···
     var io: ourio.Ring = try .init(gpa, 16);
     defer io.deinit();
 
+    var resolver: stda.net.dns.Resolver = undefined;
+    try resolver.init(gpa, &io, .{});
+    try io.run(.until_done);
+
     var stream: Stream = undefined;
-    try stream.init(gpa, &io, bundle, .{}, .{ .cb = testHandler });
+    try stream.init(gpa, &io, bundle, .{}, &resolver, .{ .cb = testHandler });
     defer stream.deinit();
 
     try io.run(.until_done);