std.Io.Threaded: add ioBasic which disables networking

Author: andrewrk

lib/std/Io/Threaded.zig

@@ -320,7 +320,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co
             const path = try std.fmt.bufPrint(&buf, "/proc/self/task/{d}/comm", .{self.getHandle()});
 
             var threaded: std.Io.Threaded = .init_single_threaded;
-            const io = threaded.io();
+            const io = threaded.ioBasic();
 
             const file = try std.fs.cwd().openFile(path, .{});
             defer file.close();

lib/std/Thread.zig

@@ -649,7 +649,7 @@ pub noinline fn captureCurrentStackTrace(options: StackUnwindOptions, addr_buf:
 /// See `captureCurrentStackTrace` to capture the trace addresses into a buffer instead of printing.
 pub noinline fn writeCurrentStackTrace(options: StackUnwindOptions, writer: *Writer, tty_config: tty.Config) Writer.Error!void {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
 
     if (!std.options.allow_stack_tracing) {
         tty_config.setColor(writer, .dim) catch {};
@@ -780,7 +780,7 @@ pub fn writeStackTrace(st: *const StackTrace, writer: *Writer, tty_config: tty.C
     // We use an independent Io implementation here in case there was a problem
     // with the application's Io implementation itself.
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
 
     // Fetch `st.index` straight away. Aside from avoiding redundant loads, this prevents issues if
     // `st` is `@errorReturnTrace()` and errors are encountered while writing the stack trace.
@@ -1585,7 +1585,7 @@ test "manage resources correctly" {
     };
     const gpa = std.testing.allocator;
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     var discarding: Io.Writer.Discarding = .init(&.{});
     var di: SelfInfo = .init;
     defer di.deinit(gpa);

lib/std/debug.zig

@@ -340,7 +340,7 @@ pub const OpenSelfExeError = Io.File.OpenSelfExeError;
 pub fn openSelfExe(flags: File.OpenFlags) OpenSelfExeError!File {
     if (native_os == .linux or native_os == .serenity or native_os == .windows) {
         var threaded: Io.Threaded = .init_single_threaded;
-        const io = threaded.io();
+        const io = threaded.ioBasic();
         return .adaptFromNewApi(try Io.File.openSelfExe(io, flags));
     }
     // Use of max_path_bytes here is valid as the resulting path is immediately

lib/std/fs.zig

@@ -850,14 +850,14 @@ pub fn close(self: *Dir) void {
 /// Deprecated in favor of `Io.Dir.openFile`.
 pub fn openFile(self: Dir, sub_path: []const u8, flags: File.OpenFlags) File.OpenError!File {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return .adaptFromNewApi(try Io.Dir.openFile(self.adaptToNewApi(), io, sub_path, flags));
 }
 
 /// Deprecated in favor of `Io.Dir.createFile`.
 pub fn createFile(self: Dir, sub_path: []const u8, flags: File.CreateFlags) File.OpenError!File {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     const new_file = try Io.Dir.createFile(self.adaptToNewApi(), io, sub_path, flags);
     return .adaptFromNewApi(new_file);
 }
@@ -868,7 +868,7 @@ pub const MakeError = Io.Dir.MakeError;
 /// Deprecated in favor of `Io.Dir.makeDir`.
 pub fn makeDir(self: Dir, sub_path: []const u8) MakeError!void {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.Dir.makeDir(.{ .handle = self.fd }, io, sub_path);
 }
 
@@ -895,14 +895,14 @@ pub const MakePathError = Io.Dir.MakePathError;
 /// Deprecated in favor of `Io.Dir.makePathStatus`.
 pub fn makePathStatus(self: Dir, sub_path: []const u8) MakePathError!MakePathStatus {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.Dir.makePathStatus(.{ .handle = self.fd }, io, sub_path);
 }
 
 /// Deprecated in favor of `Io.Dir.makeOpenPath`.
 pub fn makeOpenPath(dir: Dir, sub_path: []const u8, options: OpenOptions) Io.Dir.MakeOpenPathError!Dir {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return .adaptFromNewApi(try Io.Dir.makeOpenPath(dir.adaptToNewApi(), io, sub_path, options));
 }
 
@@ -1071,7 +1071,7 @@ pub const OpenOptions = Io.Dir.OpenOptions;
 /// Deprecated in favor of `Io.Dir.openDir`.
 pub fn openDir(self: Dir, sub_path: []const u8, args: OpenOptions) OpenError!Dir {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return .adaptFromNewApi(try Io.Dir.openDir(.{ .handle = self.fd }, io, sub_path, args));
 }
 
@@ -1385,7 +1385,7 @@ pub fn readLinkW(self: Dir, sub_path_w: []const u16, buffer: []u8) ![]u8 {
 /// Deprecated in favor of `Io.Dir.readFile`.
 pub fn readFile(self: Dir, file_path: []const u8, buffer: []u8) ![]u8 {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.Dir.readFile(.{ .handle = self.fd }, io, file_path, buffer);
 }
 
@@ -1438,7 +1438,7 @@ pub fn readFileAllocOptions(
     comptime sentinel: ?u8,
 ) ReadFileAllocError!(if (sentinel) |s| [:s]align(alignment.toByteUnits()) u8 else []align(alignment.toByteUnits()) u8) {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
 
     var file = try dir.openFile(sub_path, .{});
     defer file.close();
@@ -1893,7 +1893,7 @@ pub const AccessError = Io.Dir.AccessError;
 /// Deprecated in favor of `Io.Dir.access`.
 pub fn access(self: Dir, sub_path: []const u8, options: Io.Dir.AccessOptions) AccessError!void {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.Dir.access(self.adaptToNewApi(), io, sub_path, options);
 }
 
@@ -1929,7 +1929,7 @@ pub fn copyFile(
     options: CopyFileOptions,
 ) CopyFileError!void {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
 
     const file = try source_dir.openFile(source_path, .{});
     var file_reader: File.Reader = .init(.{ .handle = file.handle }, io, &.{});
@@ -1997,7 +1997,7 @@ pub const StatFileError = File.OpenError || File.StatError || posix.FStatAtError
 /// Deprecated in favor of `Io.Dir.statPath`.
 pub fn statFile(self: Dir, sub_path: []const u8) StatFileError!Stat {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.Dir.statPath(.{ .handle = self.fd }, io, sub_path, .{});
 }
 

lib/std/fs/Dir.zig

@@ -313,7 +313,7 @@ pub const StatError = posix.FStatError;
 /// Returns `Stat` containing basic information about the `File`.
 pub fn stat(self: File) StatError!Stat {
     var threaded: Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
     return Io.File.stat(.{ .handle = self.handle }, io);
 }
 

lib/std/fs/File.zig

@@ -1089,7 +1089,7 @@ fn windowsCreateProcessPathExt(
     // opening function knowing which implementation we are in. Here, we imitate
     // that scenario.
     var threaded: std.Io.Threaded = .init_single_threaded;
-    const io = threaded.io();
+    const io = threaded.ioBasic();
 
     var dir = dir: {
         // needs to be null-terminated

lib/std/process/Child.zig

@@ -1,17 +1,23 @@
 const std = @import("std");
+const Io = std.Io;
 
 // 42 is expected by parent; other values result in test failure
 var exit_code: u8 = 42;
 
 pub fn main() !void {
     var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     const arena = arena_state.allocator();
-    try run(arena);
+
+    var threaded: std.Io.Threaded = .init(arena);
+    defer threaded.deinit();
+    const io = threaded.io();
+
+    try run(arena, io);
     arena_state.deinit();
     std.process.exit(exit_code);
 }
 
-fn run(allocator: std.mem.Allocator) !void {
+fn run(allocator: std.mem.Allocator, io: Io) !void {
     var args = try std.process.argsWithAllocator(allocator);
     defer args.deinit();
     _ = args.next() orelse unreachable; // skip binary name
@@ -33,7 +39,8 @@ fn run(allocator: std.mem.Allocator) !void {
     const hello_stdin = "hello from stdin";
     var buf: [hello_stdin.len]u8 = undefined;
     const stdin: std.fs.File = .stdin();
-    const n = try stdin.readAll(&buf);
+    var reader = stdin.reader(io, &.{});
+    const n = try reader.interface.readSliceShort(&buf);
     if (!std.mem.eql(u8, buf[0..n], hello_stdin)) {
         testError("stdin: '{s}'; want '{s}'", .{ buf[0..n], hello_stdin });
     }

test/standalone/child_process/child.zig

@@ -9,14 +9,18 @@ pub fn main() !void {
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
+    var threaded: std.Io.Threaded = .init(arena);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     const args = try std.process.argsAlloc(arena);
 
     const exe = args[0];
     var catted_anything = false;
     var stdout_buffer: [4096]u8 = undefined;
     var stdout_writer = fs.File.stdout().writerStreaming(&stdout_buffer);
     const stdout = &stdout_writer.interface;
-    var stdin_reader = fs.File.stdin().readerStreaming(&.{});
+    var stdin_reader = fs.File.stdin().readerStreaming(io, &.{});
 
     const cwd = fs.cwd();
 
@@ -32,7 +36,7 @@ pub fn main() !void {
             defer file.close();
 
             catted_anything = true;
-            var file_reader = file.reader(&.{});
+            var file_reader = file.reader(io, &.{});
             _ = try stdout.sendFileAll(&file_reader, .unlimited);
             try stdout.flush();
         }

test/standalone/simple/cat/main.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const Io = std.Io;
 const fs = std.fs;
 const mem = std.mem;
 const process = std.process;
@@ -85,7 +86,7 @@ pub fn main() anyerror!void {
         } else try argv.append(arg);
     }
 
-    var threaded: std.Io.Threaded = .init(gpa);
+    var threaded: Io.Threaded = .init(gpa);
     defer threaded.deinit();
     const io = threaded.io();
 
@@ -118,12 +119,13 @@ pub fn main() anyerror!void {
             .arch = arch,
             .os_ver = os_ver,
         };
-        try fetchTarget(allocator, argv.items, sysroot_path, target, version, tmp);
+        try fetchTarget(allocator, io, argv.items, sysroot_path, target, version, tmp);
     }
 }
 
 fn fetchTarget(
     arena: Allocator,
+    io: Io,
     args: []const []const u8,
     sysroot: []const u8,
     target: Target,
@@ -194,7 +196,7 @@ fn fetchTarget(
     var dirs = std.StringHashMap(fs.Dir).init(arena);
     try dirs.putNoClobber(".", dest_dir);
 
-    var headers_list_file_reader = headers_list_file.reader(&.{});
+    var headers_list_file_reader = headers_list_file.reader(io, &.{});
     const headers_list_str = try headers_list_file_reader.interface.allocRemaining(arena, .unlimited);
     const prefix = "/usr/include";
 
@@ -267,8 +269,8 @@ const Version = struct {
 
     pub fn format(
         v: Version,
-        writer: *std.Io.Writer,
-    ) std.Io.Writer.Error!void {
+        writer: *Io.Writer,
+    ) Io.Writer.Error!void {
         try writer.print("{d}.{d}.{d}", .{ v.major, v.minor, v.patch });
     }
 };