Commit d4f3881bdbdeea7b4ec4974da77acbc3f462328c | zig

author	Brandon Black <bblack@wikimedia.org> 2026-05-05 11:07:15-05:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-08-10 20:33:08+02:00
log	d4f3881bdbdeea7b4ec4974da77acbc3f462328c
tree	a02113de0248f81e6798ee785b49d92078e50a2b
parent	a6c2839505c9214ca6cd8baaa52e67fcf99c9e2e

std.Io.Threaded.lookupDns: use sendTimeout

Mostly I did this to test sendTimeout with something other than my
own code.

Now that send is Operation-based, it can also honor the timeout
deadlines lookupDns is already enforcing on the receive side
(which may matter if the socket output buffer gets filled - sends
are not always immediately-successful!).

1 files changed, 15 insertions(+), 11 deletions(-)

lib
- std
  - Io
    Threaded.zig

lib/std/Io/Threaded.zig+15-11

 @@ -14655,6 +14655,11 @@ fn lookupDns(
     };
     send: while (now_ts.nanoseconds < final_ts.nanoseconds) : (now_ts = clock.now(t_io)) {
+        const timeout: Io.Timeout = .{ .deadline = .{
+            .raw = now_ts.addDuration(attempt_duration),
+            .clock = clock,
+        } };
         const max_messages = queries_buffer.len * HostName.ResolvConf.max_nameservers;
         {
             var message_buffer: [max_messages]net.OutgoingMessage = undefined;
 @@ -14670,14 +14675,14 @@ fn lookupDns(
                     message_i += 1;
                 }
             }
-            _ = netSendPosix(t, socket.handle, message_buffer[0..message_i], .{}, false);
+            const send_err, _ = socket.sendManyTimeout(t_io, message_buffer[0..message_i], .{}, timeout);
+            if (send_err) |err| switch (err) {
+                error.Canceled => |e| return e,
+                error.Timeout => continue :send,
+                else => {},
+            };
         }
-        const timeout: Io.Timeout = .{ .deadline = .{
-            .raw = now_ts.addDuration(attempt_duration),
-            .clock = clock,
-        } };
         while (true) {
             var message_buffer: [max_messages]net.IncomingMessage = @splat(.init);
             const buf = answer_buffer[answer_buffer_i..];
 @@ -14713,12 +14718,11 @@ fn lookupDns(
                         if (answers_remaining == 0) break :send;
                     },
                     2 => {
-                        var retry_message: net.OutgoingMessage = .{
+                        socket.sendTimeout(t_io, ns, query, timeout) catch |err| switch (err) {
-                            .address = ns,
+                            error.Canceled => |e| return e,
-                            .data_ptr = query.ptr,
+                            error.Timeout => continue :send,
-                            .data_len = query.len,
+                            else => {},
                         };
-                        _ = netSendPosix(t, socket.handle, (&retry_message)[0..1], .{}, false);
                         continue;
                     },
                     else => continue,