@zigc/lib 0.16.0-dev.3059 → 0.16.0-dev.3066

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.16.0-dev.3059",
+  "version": "0.16.0-dev.3066",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Build/Step/ConfigHeader.zig

@@ -109,6 +109,10 @@ pub fn create(owner: *std.Build, options: Options) *ConfigHeader {
     return config_header;
 }
 
+pub fn addIdent(config_header: *ConfigHeader, name: []const u8, value: []const u8) void {
+    config_header.values.put(name, .{ .ident = value }) catch @panic("OOM");
+}
+
 pub fn addValue(config_header: *ConfigHeader, name: []const u8, comptime T: type, value: T) void {
     return addValueInner(config_header, name, T, value) catch @panic("OOM");
 }

package/std/Io/Threaded.zig

@@ -13482,21 +13482,80 @@ fn netLookupFallible(
     const name = host_name.bytes;
     assert(name.len <= HostName.max_len);
 
-    if (is_windows) {
-        if (options.family == null) {
-            if (IpAddress.parseIp4(name, options.port)) |addr| {
-                if (copyCanon(options.canonical_name_buffer, name)) |canon| {
-                    try resolved.putAll(t_io, &.{
-                        .{ .address = addr },
-                        .{ .canonical_name = canon },
-                    });
-                } else {
-                    try resolved.putOne(t_io, .{ .address = addr });
-                }
-                return;
-            } else |_| {}
+    // On Linux, glibc provides getaddrinfo_a which is capable of supporting our semantics.
+    // However, musl's POSIX-compliant getaddrinfo is not, so we bypass it.
+
+    if (builtin.target.isGnuLibC()) {
+        // TODO use getaddrinfo_a / gai_cancel
+    }
+
+    if (native_os == .linux or is_windows) {
+        if (IpAddress.parseIp6(name, options.port)) |addr| {
+            if (options.family == .ip4) return error.UnknownHostName;
+            if (copyCanon(options.canonical_name_buffer, name)) |canon| {
+                try resolved.putAll(t_io, &.{
+                    .{ .address = addr },
+                    .{ .canonical_name = canon },
+                });
+            } else {
+                try resolved.putOne(t_io, .{ .address = addr });
+            }
+            return;
+        } else |_| {}
+
+        if (IpAddress.parseIp4(name, options.port)) |addr| {
+            if (options.family == .ip6) return error.UnknownHostName;
+            if (copyCanon(options.canonical_name_buffer, name)) |canon| {
+                try resolved.putAll(t_io, &.{
+                    .{ .address = addr },
+                    .{ .canonical_name = canon },
+                });
+            } else {
+                try resolved.putOne(t_io, .{ .address = addr });
+            }
+            return;
+        } else |_| {}
+
+        if (t.lookupHosts(host_name, resolved, options)) return else |err| switch (err) {
+            error.UnknownHostName => {},
+            else => |e| return e,
+        }
+
+        // RFC 6761 Section 6.3.3
+        // Name resolution APIs and libraries SHOULD recognize
+        // localhost names as special and SHOULD always return the IP
+        // loopback address for address queries and negative responses
+        // for all other query types.
+
+        // Check for equal to "localhost(.)" or ends in ".localhost(.)"
+        const localhost = if (name[name.len - 1] == '.') "localhost." else "localhost";
+        if (std.mem.endsWith(u8, name, localhost) and
+            (name.len == localhost.len or name[name.len - localhost.len] == '.'))
+        {
+            var results_buffer: [3]HostName.LookupResult = undefined;
+            var results_index: usize = 0;
+            if (options.family != .ip4) {
+                results_buffer[results_index] = .{ .address = .{ .ip6 = .loopback(options.port) } };
+                results_index += 1;
+            }
+            if (options.family != .ip6) {
+                results_buffer[results_index] = .{ .address = .{ .ip4 = .loopback(options.port) } };
+                results_index += 1;
+            }
+            if (options.canonical_name_buffer) |buf| {
+                const canon_name = "localhost";
+                const canon_name_dest = buf[0..canon_name.len];
+                canon_name_dest.* = canon_name.*;
+                results_buffer[results_index] = .{ .canonical_name = .{ .bytes = canon_name_dest } };
+                results_index += 1;
+            }
+            try resolved.putAll(t_io, results_buffer[0..results_index]);
+            return;
         }
 
+        if (native_os == .linux) return t.lookupDnsSearch(host_name, resolved, options);
+
+        comptime assert(is_windows);
         var DnsQueryEx = t.dl.DnsQueryEx.load(.acquire);
         //var DnsCancelQuery = t.dl.DnsCancelQuery.load(.acquire);
         var DnsFree = t.dl.DnsFree.load(.acquire);
@@ -13540,6 +13599,7 @@ fn netLookupFallible(
                 else => |status| return windows.unexpectedStatus(status),
             }
         }
+        try Thread.checkCancel();
         const current_thread = Thread.current;
         var lookup_dns: LookupDnsWindows = .{
             .threaded = t,
@@ -13562,126 +13622,71 @@ fn netLookupFallible(
             }
         ] = 0;
         //var cancel_token: windows.DNS.QUERY.CANCEL = undefined;
+        // Workaround various bugs by attempting a synchronous non-wire query first
         switch (DnsQueryEx.?(&.{
             .Version = 1,
             .QueryName = &host_name_w,
             .QueryType = if (options.family == .ip4) .A else .AAAA,
             .QueryOptions = .{
+                .NO_WIRE_QUERY = true,
+                .NO_HOSTS_FILE = true, // handled above
                 .ADDRCONFIG = true,
                 .DUAL_ADDR = options.family == null,
-                .MULTICAST_WAIT = true,
             },
-            .pQueryCompletionCallback = if (current_thread) |_| &LookupDnsWindows.completed else null,
-        }, &lookup_dns.results,
-            //&cancel_token,
-            null)) {
+        }, &lookup_dns.results, null)) {
+            .SUCCESS => try lookup_dns.completedFallible(),
             // We must wait for the APC routine.
-            .SUCCESS, .DNS_REQUEST_PENDING => |status| if (current_thread) |_| {
-                while (!@atomicLoad(bool, &lookup_dns.done, .acquire)) {
-                    // Once we get here we must not return from the function until the
-                    // operation completes, thereby releasing references to `host_name_w`,
-                    // `lookup_dns.results`, and `cancel_token`.
-                    const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
-                        error.Canceled => |e| {
-                            //_ = DnsCancelQuery.?(&cancel_token);
-                            while (!@atomicLoad(bool, &lookup_dns.done, .acquire)) waitForApcOrAlert();
-                            return e;
-                        },
-                    };
-                    waitForApcOrAlert();
-                    alertable_syscall.finish();
-                }
-            } else switch (status) {
+            .DNS_REQUEST_PENDING => unreachable, // `pQueryCompletionCallback` was `null`
+            .DNS_ERROR_RECORD_DOES_NOT_EXIST => switch (DnsQueryEx.?(&.{
+                .Version = 1,
+                .QueryName = &host_name_w,
+                .QueryType = if (options.family == .ip4) .A else .AAAA,
+                .QueryOptions = .{
+                    .NO_HOSTS_FILE = true, // handled above
+                    .ADDRCONFIG = true,
+                    .DUAL_ADDR = options.family == null,
+                    .MULTICAST_WAIT = true,
+                },
+                .pQueryCompletionCallback = if (current_thread) |_| &LookupDnsWindows.completed else null,
+            }, &lookup_dns.results,
+                //&cancel_token,
+                null)) {
                 .SUCCESS => try lookup_dns.completedFallible(),
-                .DNS_REQUEST_PENDING => unreachable, // `pQueryCompletionCallback` was `null`
-                else => unreachable,
+                // We must wait for the APC routine.
+                .DNS_REQUEST_PENDING => {
+                    assert(current_thread != null); // `pQueryCompletionCallback` was `null`
+                    while (!@atomicLoad(bool, &lookup_dns.done, .acquire)) {
+                        // Once we get here we must not return from the function until the
+                        // operation completes, thereby releasing references to `host_name_w`,
+                        // `lookup_dns.results`, and `cancel_token`.
+                        const alertable_syscall = AlertableSyscall.start() catch |err| switch (err) {
+                            error.Canceled => |e| {
+                                //_ = DnsCancelQuery.?(&cancel_token);
+                                while (!@atomicLoad(bool, &lookup_dns.done, .acquire)) waitForApcOrAlert();
+                                return e;
+                            },
+                        };
+                        waitForApcOrAlert();
+                        alertable_syscall.finish();
+                    }
+                },
+                else => |status| lookup_dns.results.QueryStatus = status,
             },
             else => |status| lookup_dns.results.QueryStatus = status,
         }
         switch (lookup_dns.results.QueryStatus) {
             .SUCCESS => return,
             .DNS_REQUEST_PENDING => unreachable, // already handled
-            .INVALID_NAME, .DNS_INFO_NO_RECORDS => return error.UnknownHostName,
+            .INVALID_NAME,
+            .DNS_ERROR_RCODE_NAME_ERROR,
+            .DNS_INFO_NO_RECORDS,
+            .DNS_ERROR_INVALID_NAME_CHAR,
+            .DNS_ERROR_RECORD_DOES_NOT_EXIST,
+            => return error.UnknownHostName,
             else => |err| return windows.unexpectedError(err),
         }
     }
 
-    // On Linux, glibc provides getaddrinfo_a which is capable of supporting our semantics.
-    // However, musl's POSIX-compliant getaddrinfo is not, so we bypass it.
-
-    if (builtin.target.isGnuLibC()) {
-        // TODO use getaddrinfo_a / gai_cancel
-    }
-
-    if (native_os == .linux) {
-        if (options.family != .ip4) {
-            if (IpAddress.parseIp6(name, options.port)) |addr| {
-                if (copyCanon(options.canonical_name_buffer, name)) |canon| {
-                    try resolved.putAll(t_io, &.{
-                        .{ .address = addr },
-                        .{ .canonical_name = canon },
-                    });
-                } else {
-                    try resolved.putOne(t_io, .{ .address = addr });
-                }
-                return;
-            } else |_| {}
-        }
-
-        if (options.family != .ip6) {
-            if (IpAddress.parseIp4(name, options.port)) |addr| {
-                if (copyCanon(options.canonical_name_buffer, name)) |canon| {
-                    try resolved.putAll(t_io, &.{
-                        .{ .address = addr },
-                        .{ .canonical_name = canon },
-                    });
-                } else {
-                    try resolved.putOne(t_io, .{ .address = addr });
-                }
-                return;
-            } else |_| {}
-        }
-
-        t.lookupHosts(host_name, resolved, options) catch |err| switch (err) {
-            error.UnknownHostName => {},
-            else => |e| return e,
-        };
-
-        // RFC 6761 Section 6.3.3
-        // Name resolution APIs and libraries SHOULD recognize
-        // localhost names as special and SHOULD always return the IP
-        // loopback address for address queries and negative responses
-        // for all other query types.
-
-        // Check for equal to "localhost(.)" or ends in ".localhost(.)"
-        const localhost = if (name[name.len - 1] == '.') "localhost." else "localhost";
-        if (std.mem.endsWith(u8, name, localhost) and
-            (name.len == localhost.len or name[name.len - localhost.len] == '.'))
-        {
-            var results_buffer: [3]HostName.LookupResult = undefined;
-            var results_index: usize = 0;
-            if (options.family != .ip4) {
-                results_buffer[results_index] = .{ .address = .{ .ip6 = .loopback(options.port) } };
-                results_index += 1;
-            }
-            if (options.family != .ip6) {
-                results_buffer[results_index] = .{ .address = .{ .ip4 = .loopback(options.port) } };
-                results_index += 1;
-            }
-            if (options.canonical_name_buffer) |buf| {
-                const canon_name = "localhost";
-                const canon_name_dest = buf[0..canon_name.len];
-                canon_name_dest.* = canon_name.*;
-                results_buffer[results_index] = .{ .canonical_name = .{ .bytes = canon_name_dest } };
-                results_index += 1;
-            }
-            try resolved.putAll(t_io, results_buffer[0..results_index]);
-            return;
-        }
-
-        return t.lookupDnsSearch(host_name, resolved, options);
-    }
-
     if (native_os == .openbsd) {
         // TODO use getaddrinfo_async / asr_abort
     }
@@ -14510,8 +14515,32 @@ fn lookupHosts(
     resolved: *Io.Queue(HostName.LookupResult),
     options: HostName.LookupOptions,
 ) !void {
-    const t_io = io(t);
-    const file = Dir.openFileAbsolute(t_io, "/etc/hosts", .{}) catch |err| switch (err) {
+    const path_w = if (is_windows) path_w: {
+        var path_w_buf: [windows.PATH_MAX_WIDE:0]u16 = undefined;
+        const system_dir = windows.getSystemDirectoryWtf16Le();
+        const suffix = [_]u16{
+            '\\', 'd', 'r', 'i', 'v', 'e', 'r', 's', '\\', 'e', 't', 'c', '\\', 'h', 'o', 's', 't', 's',
+        };
+        @memcpy(path_w_buf[0..system_dir.len], system_dir);
+        @memcpy(path_w_buf[system_dir.len..][0..suffix.len], &suffix);
+        path_w_buf[system_dir.len + suffix.len] = 0;
+        break :path_w wToPrefixedFileW(null, &path_w_buf, .{}) catch |err| switch (err) {
+            error.FileNotFound,
+            error.AccessDenied,
+            => return error.UnknownHostName,
+
+            error.Canceled => |e| return e,
+
+            else => {
+                // Here we could add more detailed diagnostics to the results queue.
+                return error.DetectingNetworkConfigurationFailed;
+            },
+        };
+    };
+    const file = (if (is_windows)
+        dirOpenFileWtf16(null, path_w.span(), .{})
+    else
+        dirOpenFile(t, .cwd(), "/etc/hosts", .{})) catch |err| switch (err) {
         error.FileNotFound,
         error.NotDir,
         error.AccessDenied,
@@ -14524,10 +14553,10 @@ fn lookupHosts(
             return error.DetectingNetworkConfigurationFailed;
         },
     };
-    defer file.close(t_io);
+    defer fileClose(t, &.{file});
 
     var line_buf: [512]u8 = undefined;
-    var file_reader = file.reader(t_io, &line_buf);
+    var file_reader = file.reader(t.io(), &line_buf);
     return t.lookupHostsReader(host_name, resolved, options, &file_reader.interface) catch |err| switch (err) {
         error.ReadFailed => switch (file_reader.err.?) {
             error.Canceled => |e| return e,
@@ -14567,14 +14596,17 @@ fn lookupHostsReader(
             error.EndOfStream => break,
         };
         reader.toss(@min(1, reader.bufferedLen()));
-        var split_it = std.mem.splitScalar(u8, line, '#');
+        var split_it = std.mem.splitScalar(u8, if (is_windows and std.mem.endsWith(u8, line, "\r"))
+            line[0 .. line.len - 1]
+        else
+            line, '#');
         const no_comment_line = split_it.first();
 
         var line_it = std.mem.tokenizeAny(u8, no_comment_line, " \t");
         const ip_text = line_it.next() orelse continue;
         var first_name_text: ?[]const u8 = null;
         while (line_it.next()) |name_text| {
-            if (std.mem.eql(u8, name_text, host_name.bytes)) {
+            if (std.ascii.eqlIgnoreCase(name_text, host_name.bytes)) {
                 if (first_name_text == null) first_name_text = name_text;
                 break;
             }

package/std/Thread.zig

@@ -1147,6 +1147,11 @@ const LinuxThreadImpl = struct {
         /// Ported over from musl libc's pthread detached implementation:
         /// https://github.com/ifduyue/musl/search?q=__unmapself
         fn freeAndExit(self: *ThreadCompletion) noreturn {
+            // If we do not reset the child_tidptr to null here, the kernel would later write the
+            // value zero to that address, which is inside the block we're unmapping below, after
+            // our thread exits.  This can sometimes corrupt memory in other mmap blocks from
+            // unrelated concurrent threads.
+            _ = linux.set_tid_address(null);
             // If a signal were delivered between SYS_munmap and SYS_exit, any installed signal
             // handler would immediately segfault due to the stack being unmapped. To avoid this,
             // we need to mask all signals before entering the inline asm.
@@ -1484,7 +1489,7 @@ const LinuxThreadImpl = struct {
         }
 
         // Prepare the TLS segment and prepare a user_desc struct when needed on x86
-        var tls_ptr = linux.tls.prepareArea(mapped[tls_offset..]);
+        var tls_ptr = linux.tls.prepareArea(mapped[tls_offset..][0..linux.tls.area_desc.size]);
         var user_desc: if (target.cpu.arch == .x86) linux.user_desc else void = undefined;
         if (target.cpu.arch == .x86) {
             defer tls_ptr = @intFromPtr(&user_desc);

package/std/os/linux.zig

@@ -1584,6 +1584,11 @@ pub fn clone2(flags: u32, child_stack_ptr: usize) usize {
     return syscall2(.clone, flags, child_stack_ptr);
 }
 
+/// This call cannot fail, and the return value is the caller's thread id
+pub fn set_tid_address(tidptr: ?*pid_t) pid_t {
+    return @intCast(@as(u32, @truncate(syscall1(.set_tid_address, @intFromPtr(tidptr)))));
+}
+
 pub fn close(fd: fd_t) usize {
     return syscall1(.close, @as(usize, @bitCast(@as(isize, fd))));
 }