Merge pull request #17363 from ziglang/tar-symlinks

introduce the `zig fetch` subcommand and symlink support in zig packages

Author: andrewrk

CMakeLists.txt

@@ -527,6 +527,7 @@ set(ZIG_STAGE2_SOURCES
     "${CMAKE_SOURCE_DIR}/src/Liveness.zig"
     "${CMAKE_SOURCE_DIR}/src/Module.zig"
     "${CMAKE_SOURCE_DIR}/src/Package.zig"
+    "${CMAKE_SOURCE_DIR}/src/Package/hash.zig"
     "${CMAKE_SOURCE_DIR}/src/RangeSet.zig"
     "${CMAKE_SOURCE_DIR}/src/Sema.zig"
     "${CMAKE_SOURCE_DIR}/src/TypedValue.zig"

lib/std/fs.zig

@@ -2003,10 +2003,12 @@ pub const Dir = struct {
         return os.windows.CreateSymbolicLink(self.fd, sym_link_path_w, target_path_w, flags.is_directory);
     }
 
+    pub const ReadLinkError = os.ReadLinkError;
+
     /// Read value of a symbolic link.
     /// The return value is a slice of `buffer`, from index `0`.
     /// Asserts that the path parameter has no null bytes.
-    pub fn readLink(self: Dir, sub_path: []const u8, buffer: []u8) ![]u8 {
+    pub fn readLink(self: Dir, sub_path: []const u8, buffer: []u8) ReadLinkError![]u8 {
         if (builtin.os.tag == .wasi and !builtin.link_libc) {
             return self.readLinkWasi(sub_path, buffer);
         }

lib/std/tar.zig

@@ -3,8 +3,13 @@ pub const Options = struct {
     strip_components: u32 = 0,
     /// How to handle the "mode" property of files from within the tar file.
     mode_mode: ModeMode = .executable_bit_only,
+    /// Provide this to receive detailed error messages.
+    /// When this is provided, some errors which would otherwise be returned immediately
+    /// will instead be added to this structure. The API user must check the errors
+    /// in diagnostics to know whether the operation succeeded or failed.
+    diagnostics: ?*Diagnostics = null,
 
-    const ModeMode = enum {
+    pub const ModeMode = enum {
         /// The mode from the tar file is completely ignored. Files are created
         /// with the default mode when creating files.
         ignore,
@@ -13,12 +18,46 @@ pub const Options = struct {
         /// Other bits of the mode are left as the default when creating files.
         executable_bit_only,
     };
+
+    pub const Diagnostics = struct {
+        allocator: std.mem.Allocator,
+        errors: std.ArrayListUnmanaged(Error) = .{},
+
+        pub const Error = union(enum) {
+            unable_to_create_sym_link: struct {
+                code: anyerror,
+                file_name: []const u8,
+                link_name: []const u8,
+            },
+            unsupported_file_type: struct {
+                file_name: []const u8,
+                file_type: Header.FileType,
+            },
+        };
+
+        pub fn deinit(d: *Diagnostics) void {
+            for (d.errors.items) |item| {
+                switch (item) {
+                    .unable_to_create_sym_link => |info| {
+                        d.allocator.free(info.file_name);
+                        d.allocator.free(info.link_name);
+                    },
+                    .unsupported_file_type => |info| {
+                        d.allocator.free(info.file_name);
+                    },
+                }
+            }
+            d.errors.deinit(d.allocator);
+            d.* = undefined;
+        }
+    };
 };
 
 pub const Header = struct {
     bytes: *const [512]u8,
 
     pub const FileType = enum(u8) {
+        normal_alias = 0,
         normal = '0',
         hard_link = '1',
         symbolic_link = '2',
@@ -65,13 +104,18 @@ pub const Header = struct {
         return str(header, 0, 0 + 100);
     }
 
+    pub fn linkName(header: Header) []const u8 {
+        return str(header, 157, 157 + 100);
+    }
+
     pub fn prefix(header: Header) []const u8 {
         return str(header, 345, 345 + 155);
     }
 
     pub fn fileType(header: Header) FileType {
-        const result = @as(FileType, @enumFromInt(header.bytes[156]));
-        return if (result == @as(FileType, @enumFromInt(0))) .normal else result;
+        const result: FileType = @enumFromInt(header.bytes[156]);
+        if (result == .normal_alias) return .normal;
+        return result;
     }
 
     fn str(header: Header, start: usize, end: usize) []const u8 {
@@ -148,7 +192,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
         const header: Header = .{ .bytes = chunk[0..512] };
         const file_size = try header.fileSize();
         const rounded_file_size = std.mem.alignForward(u64, file_size, 512);
-        const pad_len = @as(usize, @intCast(rounded_file_size - file_size));
+        const pad_len: usize = @intCast(rounded_file_size - file_size);
         const unstripped_file_name = if (file_name_override_len > 0)
             file_name_buffer[0..file_name_override_len]
         else
@@ -175,7 +219,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
                 while (true) {
                     const temp = try buffer.readChunk(reader, @intCast(rounded_file_size + 512 - file_off));
                     if (temp.len == 0) return error.UnexpectedEndOfStream;
-                    const slice = temp[0..@as(usize, @intCast(@min(file_size - file_off, temp.len)))];
+                    const slice = temp[0..@intCast(@min(file_size - file_off, temp.len))];
                     try file.writeAll(slice);
 
                     file_off += slice.len;
@@ -228,8 +272,26 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
                 buffer.skip(reader, @intCast(rounded_file_size)) catch return error.TarHeadersTooBig;
             },
             .hard_link => return error.TarUnsupportedFileType,
-            .symbolic_link => return error.TarUnsupportedFileType,
-            else => return error.TarUnsupportedFileType,
+            .symbolic_link => {
+                const file_name = try stripComponents(unstripped_file_name, options.strip_components);
+                const link_name = header.linkName();
+
+                dir.symLink(link_name, file_name, .{}) catch |err| {
+                    const d = options.diagnostics orelse return error.UnableToCreateSymLink;
+                    try d.errors.append(d.allocator, .{ .unable_to_create_sym_link = .{
+                        .code = err,
+                        .file_name = try d.allocator.dupe(u8, file_name),
+                        .link_name = try d.allocator.dupe(u8, link_name),
+                    } });
+                };
+            },
+            else => |file_type| {
+                const d = options.diagnostics orelse return error.TarUnsupportedFileType;
+                try d.errors.append(d.allocator, .{ .unsupported_file_type = .{
+                    .file_name = try d.allocator.dupe(u8, unstripped_file_name),
+                    .file_type = file_type,
+                } });
+            },
         }
     }
 }

lib/std/zig/ErrorBundle.zig

@@ -202,7 +202,7 @@ fn renderErrorMessageToWriter(
         try counting_stderr.writeAll(": ");
         // This is the length of the part before the error message:
         // e.g. "file.zig:4:5: error: "
-        const prefix_len = @as(usize, @intCast(counting_stderr.context.bytes_written));
+        const prefix_len: usize = @intCast(counting_stderr.context.bytes_written);
         try ttyconf.setColor(stderr, .reset);
         try ttyconf.setColor(stderr, .bold);
         if (err_msg.count == 1) {
@@ -356,16 +356,16 @@ pub const Wip = struct {
         }
 
         const compile_log_str_index = if (compile_log_text.len == 0) 0 else str: {
-            const str = @as(u32, @intCast(wip.string_bytes.items.len));
+            const str: u32 = @intCast(wip.string_bytes.items.len);
             try wip.string_bytes.ensureUnusedCapacity(gpa, compile_log_text.len + 1);
             wip.string_bytes.appendSliceAssumeCapacity(compile_log_text);
             wip.string_bytes.appendAssumeCapacity(0);
             break :str str;
         };
 
         wip.setExtra(0, ErrorMessageList{
-            .len = @as(u32, @intCast(wip.root_list.items.len)),
-            .start = @as(u32, @intCast(wip.extra.items.len)),
+            .len = @intCast(wip.root_list.items.len),
+            .start = @intCast(wip.extra.items.len),
             .compile_log_text = compile_log_str_index,
         });
         try wip.extra.appendSlice(gpa, @as([]const u32, @ptrCast(wip.root_list.items)));
@@ -385,7 +385,7 @@ pub const Wip = struct {
 
     pub fn addString(wip: *Wip, s: []const u8) !u32 {
         const gpa = wip.gpa;
-        const index = @as(u32, @intCast(wip.string_bytes.items.len));
+        const index: u32 = @intCast(wip.string_bytes.items.len);
         try wip.string_bytes.ensureUnusedCapacity(gpa, s.len + 1);
         wip.string_bytes.appendSliceAssumeCapacity(s);
         wip.string_bytes.appendAssumeCapacity(0);
@@ -394,7 +394,7 @@ pub const Wip = struct {
 
     pub fn printString(wip: *Wip, comptime fmt: []const u8, args: anytype) !u32 {
         const gpa = wip.gpa;
-        const index = @as(u32, @intCast(wip.string_bytes.items.len));
+        const index: u32 = @intCast(wip.string_bytes.items.len);
         try wip.string_bytes.writer(gpa).print(fmt, args);
         try wip.string_bytes.append(gpa, 0);
         return index;
@@ -406,15 +406,15 @@ pub const Wip = struct {
     }
 
     pub fn addErrorMessage(wip: *Wip, em: ErrorMessage) !MessageIndex {
-        return @as(MessageIndex, @enumFromInt(try addExtra(wip, em)));
+        return @enumFromInt(try addExtra(wip, em));
     }
 
     pub fn addErrorMessageAssumeCapacity(wip: *Wip, em: ErrorMessage) MessageIndex {
-        return @as(MessageIndex, @enumFromInt(addExtraAssumeCapacity(wip, em)));
+        return @enumFromInt(addExtraAssumeCapacity(wip, em));
     }
 
     pub fn addSourceLocation(wip: *Wip, sl: SourceLocation) !SourceLocationIndex {
-        return @as(SourceLocationIndex, @enumFromInt(try addExtra(wip, sl)));
+        return @enumFromInt(try addExtra(wip, sl));
     }
 
     pub fn addReferenceTrace(wip: *Wip, rt: ReferenceTrace) !void {
@@ -430,7 +430,7 @@ pub const Wip = struct {
         const other_list = other.getMessages();
 
         // The ensureUnusedCapacity call above guarantees this.
-        const notes_start = wip.reserveNotes(@as(u32, @intCast(other_list.len))) catch unreachable;
+        const notes_start = wip.reserveNotes(@intCast(other_list.len)) catch unreachable;
         for (notes_start.., other_list) |note, message| {
             wip.extra.items[note] = @intFromEnum(wip.addOtherMessage(other, message) catch unreachable);
         }
@@ -455,7 +455,7 @@ pub const Wip = struct {
         try wip.extra.ensureUnusedCapacity(wip.gpa, notes_len +
             notes_len * @typeInfo(ErrorBundle.ErrorMessage).Struct.fields.len);
         wip.extra.items.len += notes_len;
-        return @as(u32, @intCast(wip.extra.items.len - notes_len));
+        return @intCast(wip.extra.items.len - notes_len);
     }
 
     fn addOtherMessage(wip: *Wip, other: ErrorBundle, msg_index: MessageIndex) !MessageIndex {
@@ -510,7 +510,7 @@ pub const Wip = struct {
 
     fn addExtraAssumeCapacity(wip: *Wip, extra: anytype) u32 {
         const fields = @typeInfo(@TypeOf(extra)).Struct.fields;
-        const result = @as(u32, @intCast(wip.extra.items.len));
+        const result: u32 = @intCast(wip.extra.items.len);
         wip.extra.items.len += fields.len;
         setExtra(wip, result, extra);
         return result;