@zigc/lib 0.16.0-dev.3013 → 0.16.0-dev.3041

package/std/Build/Step/Run.zig

@@ -2126,7 +2126,7 @@ fn sendMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag) !void {
         .tag = tag,
         .bytes_len = 0,
     };
-    var w = file.writer(io, &.{});
+    var w = file.writerStreaming(io, &.{});
     w.interface.writeStruct(header, .little) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
@@ -2137,7 +2137,7 @@ fn sendRunTestMessage(io: Io, file: Io.File, tag: std.zig.Client.Message.Tag, in
         .tag = tag,
         .bytes_len = 4,
     };
-    var w = file.writer(io, &.{});
+    var w = file.writerStreaming(io, &.{});
     w.interface.writeStruct(header, .little) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
@@ -2157,7 +2157,7 @@ fn sendRunFuzzTestMessage(
         .tag = .start_fuzzing,
         .bytes_len = 4 + 1 + 8,
     };
-    var w = file.writer(io, &.{});
+    var w = file.writerStreaming(io, &.{});
     w.interface.writeStruct(header, .little) catch |err| switch (err) {
         error.WriteFailed => return w.err.?,
     };
@@ -2202,7 +2202,7 @@ fn evalGeneric(run: *Run, spawn_options: process.SpawnOptions) !EvalGenericResul
             var read_buffer: [1024]u8 = undefined;
             var file_reader = file.reader(io, &read_buffer);
             var write_buffer: [1024]u8 = undefined;
-            var stdin_writer = child.stdin.?.writer(io, &write_buffer);
+            var stdin_writer = child.stdin.?.writerStreaming(io, &write_buffer);
             _ = stdin_writer.interface.sendFileAll(&file_reader, .unlimited) catch |err| switch (err) {
                 error.ReadFailed => return run.step.fail("failed to read from {f}: {t}", .{
                     path, file_reader.err.?,

package/std/Io/Dir.zig

@@ -495,6 +495,76 @@ pub fn closeMany(io: Io, dirs: []const Dir) void {
     return io.vtable.dirClose(io.userdata, dirs);
 }
 
+pub const OpenFileOptions = struct {
+    mode: Mode = .read_only,
+    /// Determines the behavior when opening a path that refers to a directory.
+    ///
+    /// If set to true, directories may be opened, but `error.IsDir` is still
+    /// possible in certain scenarios, e.g. attempting to open a directory with
+    /// write permissions.
+    ///
+    /// If set to false, `error.IsDir` will always be returned when opening a directory.
+    ///
+    /// When set to false:
+    /// * On Windows, the behavior is implemented without any extra syscalls.
+    /// * On other operating systems, the behavior is implemented with an additional
+    ///   `fstat` syscall.
+    allow_directory: bool = true,
+    /// Indicates intent for only some operations to be performed on this
+    /// opened file:
+    /// * `close`
+    /// * `stat`
+    /// On Linux and FreeBSD, this corresponds to `std.posix.O.PATH`.
+    path_only: bool = false,
+    /// Open the file with an advisory lock to coordinate with other processes
+    /// accessing it at the same time. An exclusive lock will prevent other
+    /// processes from acquiring a lock. A shared lock will prevent other
+    /// processes from acquiring a exclusive lock, but does not prevent
+    /// other process from getting their own shared locks.
+    ///
+    /// The lock is advisory, except on Linux in very specific circumstances[1].
+    /// This means that a process that does not respect the locking API can still get access
+    /// to the file, despite the lock.
+    ///
+    /// On these operating systems, the lock is acquired atomically with
+    /// opening the file:
+    /// * Darwin
+    /// * DragonFlyBSD
+    /// * FreeBSD
+    /// * Haiku
+    /// * NetBSD
+    /// * OpenBSD
+    /// On these operating systems, the lock is acquired via a separate syscall
+    /// after opening the file:
+    /// * Linux
+    /// * Windows
+    ///
+    /// [1]: https://www.kernel.org/doc/Documentation/filesystems/mandatory-locking.txt
+    lock: File.Lock = .none,
+    /// Sets whether or not to wait until the file is locked to return. If set to true,
+    /// `error.WouldBlock` will be returned. Otherwise, the file will wait until the file
+    /// is available to proceed.
+    lock_nonblocking: bool = false,
+    /// Set this to allow the opened file to automatically become the
+    /// controlling TTY for the current process.
+    allow_ctty: bool = false,
+    follow_symlinks: bool = true,
+    /// If supported by the operating system, attempted path resolution that
+    /// would escape the directory instead returns `error.AccessDenied`. If
+    /// unsupported, this option is ignored.
+    resolve_beneath: bool = false,
+
+    pub const Mode = enum { read_only, write_only, read_write };
+
+    pub fn isRead(self: OpenFileOptions) bool {
+        return self.mode != .write_only;
+    }
+
+    pub fn isWrite(self: OpenFileOptions) bool {
+        return self.mode != .read_only;
+    }
+};
+
 /// Opens a file for reading or writing, without attempting to create a new file.
 ///
 /// To create a new file, see `createFile`.
@@ -504,15 +574,60 @@ pub fn closeMany(io: Io, dirs: []const Dir) void {
 /// On Windows, `sub_path` should be encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On WASI, `sub_path` should be encoded as valid UTF-8.
 /// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
-pub fn openFile(dir: Dir, io: Io, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
-    return io.vtable.dirOpenFile(io.userdata, dir, sub_path, flags);
+pub fn openFile(dir: Dir, io: Io, sub_path: []const u8, options: OpenFileOptions) File.OpenError!File {
+    return io.vtable.dirOpenFile(io.userdata, dir, sub_path, options);
 }
 
-pub fn openFileAbsolute(io: Io, absolute_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
+pub fn openFileAbsolute(io: Io, absolute_path: []const u8, options: OpenFileOptions) File.OpenError!File {
     assert(path.isAbsolute(absolute_path));
-    return openFile(.cwd(), io, absolute_path, flags);
+    return openFile(.cwd(), io, absolute_path, options);
 }
 
+pub const CreateFileOptions = struct {
+    /// Whether the file will be created with read access.
+    read: bool = false,
+    /// If the file already exists, and is a regular file, and the access
+    /// mode allows writing, it will be truncated to length 0.
+    truncate: bool = true,
+    /// Ensures that this open call creates the file, otherwise causes
+    /// `error.PathAlreadyExists` to be returned.
+    exclusive: bool = false,
+    /// Open the file with an advisory lock to coordinate with other processes
+    /// accessing it at the same time. An exclusive lock will prevent other
+    /// processes from acquiring a lock. A shared lock will prevent other
+    /// processes from acquiring a exclusive lock, but does not prevent
+    /// other process from getting their own shared locks.
+    ///
+    /// The lock is advisory, except on Linux in very specific circumstances[1].
+    /// This means that a process that does not respect the locking API can still get access
+    /// to the file, despite the lock.
+    ///
+    /// On these operating systems, the lock is acquired atomically with
+    /// opening the file:
+    /// * Darwin
+    /// * DragonFlyBSD
+    /// * FreeBSD
+    /// * Haiku
+    /// * NetBSD
+    /// * OpenBSD
+    /// On these operating systems, the lock is acquired via a separate syscall
+    /// after opening the file:
+    /// * Linux
+    /// * Windows
+    ///
+    /// [1]: https://www.kernel.org/doc/Documentation/filesystems/mandatory-locking.txt
+    lock: File.Lock = .none,
+    /// Sets whether or not to wait until the file is locked to return. If set to true,
+    /// `error.WouldBlock` will be returned. Otherwise, the file will wait until the file
+    /// is available to proceed.
+    lock_nonblocking: bool = false,
+    permissions: Permissions = .default_file,
+    /// If supported by the operating system, attempted path resolution that
+    /// would escape the directory instead returns `error.AccessDenied`. If
+    /// unsupported, this option is ignored.
+    resolve_beneath: bool = false,
+};
+
 /// Creates, opens, or overwrites a file with write access.
 ///
 /// Allocates a resource to be dellocated with `File.close`.
@@ -520,11 +635,11 @@ pub fn openFileAbsolute(io: Io, absolute_path: []const u8, flags: File.OpenFlags
 /// On Windows, `sub_path` should be encoded as [WTF-8](https://wtf-8.codeberg.page/).
 /// On WASI, `sub_path` should be encoded as valid UTF-8.
 /// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
-pub fn createFile(dir: Dir, io: Io, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
+pub fn createFile(dir: Dir, io: Io, sub_path: []const u8, flags: CreateFileOptions) File.OpenError!File {
     return io.vtable.dirCreateFile(io.userdata, dir, sub_path, flags);
 }
 
-pub fn createFileAbsolute(io: Io, absolute_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
+pub fn createFileAbsolute(io: Io, absolute_path: []const u8, flags: CreateFileOptions) File.OpenError!File {
     return createFile(.cwd(), io, absolute_path, flags);
 }
 
@@ -534,7 +649,7 @@ pub const WriteFileOptions = struct {
     /// On other platforms, `sub_path` is an opaque sequence of bytes with no particular encoding.
     sub_path: []const u8,
     data: []const u8,
-    flags: File.CreateFlags = .{},
+    flags: CreateFileOptions = .{},
 };
 
 pub const WriteFileError = File.Writer.Error || File.OpenError;

package/std/Io/File.zig

@@ -142,11 +142,8 @@ pub fn stat(file: File, io: Io) StatError!Stat {
     return io.vtable.fileStat(io.userdata, file);
 }
 
-pub const OpenMode = enum {
-    read_only,
-    write_only,
-    read_write,
-};
+/// Deprecated, renamed to `Dir.OpenFileOptions.Mode`.
+pub const OpenMode = Dir.OpenFileOptions.Mode;
 
 pub const Lock = enum {
     none,
@@ -154,120 +151,11 @@ pub const Lock = enum {
     exclusive,
 };
 
-pub const OpenFlags = struct {
-    mode: OpenMode = .read_only,
-
-    /// Determines the behavior when opening a path that refers to a directory.
-    ///
-    /// If set to true, directories may be opened, but `error.IsDir` is still
-    /// possible in certain scenarios, e.g. attempting to open a directory with
-    /// write permissions.
-    ///
-    /// If set to false, `error.IsDir` will always be returned when opening a directory.
-    ///
-    /// When set to false:
-    /// * On Windows, the behavior is implemented without any extra syscalls.
-    /// * On other operating systems, the behavior is implemented with an additional
-    ///   `fstat` syscall.
-    allow_directory: bool = true,
-    /// Indicates intent for only some operations to be performed on this
-    /// opened file:
-    /// * `close`
-    /// * `stat`
-    /// On Linux and FreeBSD, this corresponds to `std.posix.O.PATH`.
-    path_only: bool = false,
-
-    /// Open the file with an advisory lock to coordinate with other processes
-    /// accessing it at the same time. An exclusive lock will prevent other
-    /// processes from acquiring a lock. A shared lock will prevent other
-    /// processes from acquiring a exclusive lock, but does not prevent
-    /// other process from getting their own shared locks.
-    ///
-    /// The lock is advisory, except on Linux in very specific circumstances[1].
-    /// This means that a process that does not respect the locking API can still get access
-    /// to the file, despite the lock.
-    ///
-    /// On these operating systems, the lock is acquired atomically with
-    /// opening the file:
-    /// * Darwin
-    /// * DragonFlyBSD
-    /// * FreeBSD
-    /// * Haiku
-    /// * NetBSD
-    /// * OpenBSD
-    /// On these operating systems, the lock is acquired via a separate syscall
-    /// after opening the file:
-    /// * Linux
-    /// * Windows
-    ///
-    /// [1]: https://www.kernel.org/doc/Documentation/filesystems/mandatory-locking.txt
-    lock: Lock = .none,
-
-    /// Sets whether or not to wait until the file is locked to return. If set to true,
-    /// `error.WouldBlock` will be returned. Otherwise, the file will wait until the file
-    /// is available to proceed.
-    lock_nonblocking: bool = false,
-
-    /// Set this to allow the opened file to automatically become the
-    /// controlling TTY for the current process.
-    allow_ctty: bool = false,
-
-    follow_symlinks: bool = true,
-
-    pub fn isRead(self: OpenFlags) bool {
-        return self.mode != .write_only;
-    }
+/// Deprecated, renamed to `Dir.OpenFileOptions`
+pub const OpenFlags = Dir.OpenFileOptions;
 
-    pub fn isWrite(self: OpenFlags) bool {
-        return self.mode != .read_only;
-    }
-};
-
-pub const CreateFlags = struct {
-    /// Whether the file will be created with read access.
-    read: bool = false,
-
-    /// If the file already exists, and is a regular file, and the access
-    /// mode allows writing, it will be truncated to length 0.
-    truncate: bool = true,
-
-    /// Ensures that this open call creates the file, otherwise causes
-    /// `error.PathAlreadyExists` to be returned.
-    exclusive: bool = false,
-
-    /// Open the file with an advisory lock to coordinate with other processes
-    /// accessing it at the same time. An exclusive lock will prevent other
-    /// processes from acquiring a lock. A shared lock will prevent other
-    /// processes from acquiring a exclusive lock, but does not prevent
-    /// other process from getting their own shared locks.
-    ///
-    /// The lock is advisory, except on Linux in very specific circumstances[1].
-    /// This means that a process that does not respect the locking API can still get access
-    /// to the file, despite the lock.
-    ///
-    /// On these operating systems, the lock is acquired atomically with
-    /// opening the file:
-    /// * Darwin
-    /// * DragonFlyBSD
-    /// * FreeBSD
-    /// * Haiku
-    /// * NetBSD
-    /// * OpenBSD
-    /// On these operating systems, the lock is acquired via a separate syscall
-    /// after opening the file:
-    /// * Linux
-    /// * Windows
-    ///
-    /// [1]: https://www.kernel.org/doc/Documentation/filesystems/mandatory-locking.txt
-    lock: Lock = .none,
-
-    /// Sets whether or not to wait until the file is locked to return. If set to true,
-    /// `error.WouldBlock` will be returned. Otherwise, the file will wait until the file
-    /// is available to proceed.
-    lock_nonblocking: bool = false,
-
-    permissions: Permissions = .default_file,
-};
+/// Deprecated, renamed to `Dir.CreateFileOptions`.
+pub const CreateFlags = Dir.CreateFileOptions;
 
 pub const OpenError = error{
     PipeBusy,

package/std/Io/Kqueue.zig

@@ -1029,6 +1029,7 @@ fn netBindIp(
     var storage: Io.Threaded.PosixAddress = undefined;
     var addr_len = Io.Threaded.addressToPosix(address, &storage);
     try posixBind(k, socket_fd, &storage.any, addr_len);
+    if (options.allow_broadcast) try setSocketOption(k, socket_fd, posix.SOL.SOCKET, posix.SO.BROADCAST, 1);
     try posixGetSockName(k, socket_fd, &storage.any, &addr_len);
     return .{ .handle = socket_fd, .address = Io.Threaded.addressFromPosix(&storage) };
 }

package/std/Io/Threaded.zig

@@ -4217,7 +4217,7 @@ fn dirCreateFilePosix(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    options: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
@@ -4225,34 +4225,35 @@ fn dirCreateFilePosix(
     var path_buffer: [posix.PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var os_flags: posix.O = .{
-        .ACCMODE = if (flags.read) .RDWR else .WRONLY,
+    var flags: posix.O = .{
+        .ACCMODE = if (options.read) .RDWR else .WRONLY,
         .CREAT = true,
-        .TRUNC = flags.truncate,
-        .EXCL = flags.exclusive,
+        .TRUNC = options.truncate,
+        .EXCL = options.exclusive,
     };
-    if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
-    if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
+    if (@hasField(posix.O, "LARGEFILE")) flags.LARGEFILE = true;
+    if (@hasField(posix.O, "CLOEXEC")) flags.CLOEXEC = true;
+    if (@hasField(posix.O, "RESOLVE_BENEATH")) flags.RESOLVE_BENEATH = options.resolve_beneath;
 
     // Use the O locking flags if the os supports them to acquire the lock
     // atomically. Note that the NONBLOCK flag is removed after the openat()
     // call is successful.
-    if (have_flock_open_flags) switch (flags.lock) {
+    if (have_flock_open_flags) switch (options.lock) {
         .none => {},
         .shared => {
-            os_flags.SHLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
+            flags.SHLOCK = true;
+            flags.NONBLOCK = options.lock_nonblocking;
         },
         .exclusive => {
-            os_flags.EXLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
+            flags.EXLOCK = true;
+            flags.NONBLOCK = options.lock_nonblocking;
         },
     };
 
     const fd: posix.fd_t = fd: {
         const syscall: Syscall = try .start();
         while (true) {
-            const rc = openat_sym(dir.handle, sub_path_posix, os_flags, flags.permissions.toMode());
+            const rc = openat_sym(dir.handle, sub_path_posix, flags, options.permissions.toMode());
             switch (posix.errno(rc)) {
                 .SUCCESS => {
                     syscall.finish();
@@ -4298,9 +4299,9 @@ fn dirCreateFilePosix(
     };
     errdefer closeFd(fd);
 
-    if (have_flock and !have_flock_open_flags and flags.lock != .none) {
-        const lock_nonblocking: i32 = if (flags.lock_nonblocking) posix.LOCK.NB else 0;
-        const lock_flags = switch (flags.lock) {
+    if (have_flock and !have_flock_open_flags and options.lock != .none) {
+        const lock_nonblocking: i32 = if (options.lock_nonblocking) posix.LOCK.NB else 0;
+        const lock_flags = switch (options.lock) {
             .none => unreachable,
             .shared => posix.LOCK.SH | lock_nonblocking,
             .exclusive => posix.LOCK.EX | lock_nonblocking,
@@ -4332,7 +4333,7 @@ fn dirCreateFilePosix(
         }
     }
 
-    if (have_flock_open_flags and flags.lock_nonblocking) {
+    if (have_flock_open_flags and options.lock_nonblocking) {
         var fl_flags: usize = fl: {
             const syscall: Syscall = try .start();
             while (true) {
@@ -4385,7 +4386,7 @@ fn dirCreateFileWindows(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    flags: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
@@ -4535,7 +4536,7 @@ fn dirCreateFileWasi(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.CreateFlags,
+    flags: Dir.CreateFileOptions,
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
@@ -4785,45 +4786,46 @@ fn dirOpenFilePosix(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    options: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
 
     var path_buffer: [posix.PATH_MAX]u8 = undefined;
     const sub_path_posix = try pathToPosix(sub_path, &path_buffer);
 
-    var os_flags: posix.O = switch (native_os) {
+    var flags: posix.O = switch (native_os) {
         .wasi => .{
-            .read = flags.mode != .write_only,
-            .write = flags.mode != .read_only,
-            .NOFOLLOW = !flags.follow_symlinks,
+            .read = options.mode != .write_only,
+            .write = options.mode != .read_only,
+            .NOFOLLOW = !options.follow_symlinks,
         },
         else => .{
-            .ACCMODE = switch (flags.mode) {
+            .ACCMODE = switch (options.mode) {
                 .read_only => .RDONLY,
                 .write_only => .WRONLY,
                 .read_write => .RDWR,
             },
-            .NOFOLLOW = !flags.follow_symlinks,
+            .NOFOLLOW = !options.follow_symlinks,
         },
     };
-    if (@hasField(posix.O, "CLOEXEC")) os_flags.CLOEXEC = true;
-    if (@hasField(posix.O, "LARGEFILE")) os_flags.LARGEFILE = true;
-    if (@hasField(posix.O, "NOCTTY")) os_flags.NOCTTY = !flags.allow_ctty;
-    if (@hasField(posix.O, "PATH") and flags.path_only) os_flags.PATH = true;
+    if (@hasField(posix.O, "CLOEXEC")) flags.CLOEXEC = true;
+    if (@hasField(posix.O, "LARGEFILE")) flags.LARGEFILE = true;
+    if (@hasField(posix.O, "NOCTTY")) flags.NOCTTY = !options.allow_ctty;
+    if (@hasField(posix.O, "PATH")) flags.PATH = options.path_only;
+    if (@hasField(posix.O, "RESOLVE_BENEATH")) flags.RESOLVE_BENEATH = options.resolve_beneath;
 
-    // Use the O locking flags if the os supports them to acquire the lock
+    // Use the O locking options if the os supports them to acquire the lock
     // atomically. Note that the NONBLOCK flag is removed after the openat()
     // call is successful.
-    if (have_flock_open_flags) switch (flags.lock) {
+    if (have_flock_open_flags) switch (options.lock) {
         .none => {},
         .shared => {
-            os_flags.SHLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
+            flags.SHLOCK = true;
+            flags.NONBLOCK = options.lock_nonblocking;
         },
         .exclusive => {
-            os_flags.EXLOCK = true;
-            os_flags.NONBLOCK = flags.lock_nonblocking;
+            flags.EXLOCK = true;
+            flags.NONBLOCK = options.lock_nonblocking;
         },
     };
 
@@ -4832,7 +4834,7 @@ fn dirOpenFilePosix(
     const fd: posix.fd_t = fd: {
         const syscall: Syscall = try .start();
         while (true) {
-            const rc = openat_sym(dir.handle, sub_path_posix, os_flags, mode);
+            const rc = openat_sym(dir.handle, sub_path_posix, flags, mode);
             switch (posix.errno(rc)) {
                 .SUCCESS => {
                     syscall.finish();
@@ -4878,7 +4880,7 @@ fn dirOpenFilePosix(
     };
     errdefer closeFd(fd);
 
-    if (!flags.allow_directory) {
+    if (!options.allow_directory) {
         const is_dir = is_dir: {
             const stat = fileStat(t, .{
                 .handle = fd,
@@ -4893,9 +4895,9 @@ fn dirOpenFilePosix(
         if (is_dir) return error.IsDir;
     }
 
-    if (have_flock and !have_flock_open_flags and flags.lock != .none) {
-        const lock_nonblocking: i32 = if (flags.lock_nonblocking) posix.LOCK.NB else 0;
-        const lock_flags = switch (flags.lock) {
+    if (have_flock and !have_flock_open_flags and options.lock != .none) {
+        const lock_nonblocking: i32 = if (options.lock_nonblocking) posix.LOCK.NB else 0;
+        const lock_flags = switch (options.lock) {
             .none => unreachable,
             .shared => posix.LOCK.SH | lock_nonblocking,
             .exclusive => posix.LOCK.EX | lock_nonblocking,
@@ -4926,7 +4928,7 @@ fn dirOpenFilePosix(
         }
     }
 
-    if (have_flock_open_flags and flags.lock_nonblocking) {
+    if (have_flock_open_flags and options.lock_nonblocking) {
         var fl_flags: usize = fl: {
             const syscall: Syscall = try .start();
             while (true) {
@@ -4979,7 +4981,7 @@ fn dirOpenFileWindows(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     _ = t;
@@ -4992,7 +4994,7 @@ fn dirOpenFileWindows(
 pub fn dirOpenFileWtf16(
     dir_handle: ?windows.HANDLE,
     sub_path_w: []const u16,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     const allow_directory = flags.allow_directory and !flags.isWrite();
     if (!allow_directory and std.mem.eql(u16, sub_path_w, &.{'.'})) return error.IsDir;
@@ -5129,7 +5131,7 @@ fn dirOpenFileWasi(
     userdata: ?*anyopaque,
     dir: Dir,
     sub_path: []const u8,
-    flags: File.OpenFlags,
+    flags: Dir.OpenFileOptions,
 ) File.OpenError!File {
     if (builtin.link_libc) return dirOpenFilePosix(userdata, dir, sub_path, flags);
     const t: *Threaded = @ptrCast(@alignCast(userdata));
@@ -10193,7 +10195,7 @@ fn posixSeekTo(fd: posix.fd_t, offset: u64) File.SeekError!void {
     }
 }
 
-fn processExecutableOpen(userdata: ?*anyopaque, flags: File.OpenFlags) process.OpenExecutableError!File {
+fn processExecutableOpen(userdata: ?*anyopaque, flags: Dir.OpenFileOptions) process.OpenExecutableError!File {
     const t: *Threaded = @ptrCast(@alignCast(userdata));
     switch (native_os) {
         .wasi => return error.OperationUnsupported,
@@ -12196,6 +12198,7 @@ fn netBindIpPosix(
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try posixBind(socket_fd, &storage.any, addr_len);
+    if (options.allow_broadcast) try setSocketOptionPosix(socket_fd, std.posix.SOL.SOCKET, std.posix.SO.BROADCAST, 1);
     try posixGetSockName(socket_fd, &storage.any, &addr_len);
     return .{ .handle = socket_fd, .address = addressFromPosix(&storage) };
 }
@@ -12212,6 +12215,7 @@ fn netBindIpWindows(
     const socket_handle = try openSocketAfd(family, options);
     errdefer windows.CloseHandle(socket_handle);
     const bound_address = try bindSocketIpAfd(socket_handle, address, .Active);
+    if (options.allow_broadcast) try setSocketOptionAfd(socket_handle, ws2_32.SOL.SOCKET, ws2_32.SO.BROADCAST, true);
     return .{ .handle = socket_handle, .address = bound_address };
 }
 

package/std/Io/Uring.zig

@@ -4991,6 +4991,7 @@ fn netBindIp(
     var storage: PosixAddress = undefined;
     var addr_len = addressToPosix(address, &storage);
     try ev.bind(&maybe_sync.cancel_region, socket_fd, &storage.any, addr_len);
+    if (options.allow_broadcast) try ev.setsockopt(&maybe_sync.cancel_region, socket_fd, linux.SOL.SOCKET, linux.SO.BROADCAST, 1);
     try ev.getsockname(try maybe_sync.enterSync(ev), socket_fd, &storage.any, &addr_len);
     return .{ .handle = socket_fd, .address = addressFromPosix(&storage) };
 }

package/std/Io/net.zig

@@ -282,6 +282,10 @@ pub const IpAddress = union(enum) {
         /// In this case, an IPv4 and an IPv6 application can bind to a single port
         /// at the same time.
         ip6_only: bool = false,
+        /// Allow the socket to send datagrams to broadcast addresses.
+        /// When not enabled any attempt to send datagrams to a broadcast address
+        /// will fail with `error.AccessDenied`
+        allow_broadcast: bool = false,
         mode: Socket.Mode,
         protocol: ?Protocol = null,
     };

package/std/Io.zig

@@ -160,9 +160,9 @@ pub const VTable = struct {
     dirStat: *const fn (?*anyopaque, Dir) Dir.StatError!Dir.Stat,
     dirStatFile: *const fn (?*anyopaque, Dir, []const u8, Dir.StatFileOptions) Dir.StatFileError!File.Stat,
     dirAccess: *const fn (?*anyopaque, Dir, []const u8, Dir.AccessOptions) Dir.AccessError!void,
-    dirCreateFile: *const fn (?*anyopaque, Dir, []const u8, File.CreateFlags) File.OpenError!File,
+    dirCreateFile: *const fn (?*anyopaque, Dir, []const u8, Dir.CreateFileOptions) File.OpenError!File,
     dirCreateFileAtomic: *const fn (?*anyopaque, Dir, []const u8, Dir.CreateFileAtomicOptions) Dir.CreateFileAtomicError!File.Atomic,
-    dirOpenFile: *const fn (?*anyopaque, Dir, []const u8, File.OpenFlags) File.OpenError!File,
+    dirOpenFile: *const fn (?*anyopaque, Dir, []const u8, Dir.OpenFileOptions) File.OpenError!File,
     dirClose: *const fn (?*anyopaque, []const Dir) void,
     dirRead: *const fn (?*anyopaque, *Dir.Reader, []Dir.Entry) Dir.Reader.Error!usize,
     dirRealPath: *const fn (?*anyopaque, Dir, out_buffer: []u8) Dir.RealPathError!usize,
@@ -211,7 +211,7 @@ pub const VTable = struct {
     fileMemoryMapRead: *const fn (?*anyopaque, *File.MemoryMap) File.ReadPositionalError!void,
     fileMemoryMapWrite: *const fn (?*anyopaque, *File.MemoryMap) File.WritePositionalError!void,
 
-    processExecutableOpen: *const fn (?*anyopaque, File.OpenFlags) std.process.OpenExecutableError!File,
+    processExecutableOpen: *const fn (?*anyopaque, Dir.OpenFileOptions) std.process.OpenExecutableError!File,
     processExecutablePath: *const fn (?*anyopaque, buffer: []u8) std.process.ExecutablePathError!usize,
     lockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!LockedStderr,
     tryLockStderr: *const fn (?*anyopaque, ?Terminal.Mode) Cancelable!?LockedStderr,

package/std/Target.zig

@@ -2195,7 +2195,6 @@ pub fn requiresLibC(target: *const Target) bool {
         .watchos,
         .visionos,
         .dragonfly,
-        .openbsd,
         .haiku,
         .serenity,
         => true,
@@ -2209,6 +2208,7 @@ pub fn requiresLibC(target: *const Target) bool {
         .windows,
         .freebsd,
         .netbsd,
+        .openbsd,
         .freestanding,
         .fuchsia,
         .managarm,

package/std/c.zig

@@ -8535,7 +8535,8 @@ pub const O = switch (native_os) {
         CREAT: bool = false,
         TRUNC: bool = false,
         EXCL: bool = false,
-        _12: u3 = 0,
+        RESOLVE_BENEATH: bool = false,
+        _13: u2 = 0,
         EVTONLY: bool = false,
         _16: u1 = 0,
         NOCTTY: bool = false,