std.tar: enable setting executable bit

In pipeToFileSystem when option mode_mode option is set on posix file systems.

Author: ianic

lib/std/tar.zig

@@ -25,8 +25,20 @@ pub const output = @import("tar/output.zig");
 pub const PipeOptions = struct {
     /// Number of directory levels to skip when extracting files.
     strip_components: u32 = 0,
+    /// How to handle the "mode" property of files from within the tar file.
+    mode_mode: ModeMode = .executable_bit_only,
     /// Prevents creation of empty directories.
     exclude_empty_directories: bool = false,
+
+    pub const ModeMode = enum {
+        /// The mode from the tar file is completely ignored. Files are created
+        /// with the default mode when creating files.
+        ignore,
+        /// The mode from the tar file is inspected for the owner executable bit
+        /// only. This bit is copied to the group and other executable bits.
+        /// Other bits of the mode are left as the default when creating files.
+        executable_bit_only,
+    };
 };
 
 const Header = struct {
@@ -526,7 +538,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: PipeOptions)
                 const file_name = stripComponents(file.name, options.strip_components);
                 if (file_name.len == 0) return error.BadFileName;
 
-                var fs_file = try createDirAndFile(dir, file_name);
+                var fs_file = try createDirAndFile(dir, file_name, fileMode(file.mode, options));
                 defer fs_file.close();
                 try file.writeAll(fs_file);
             },
@@ -543,12 +555,31 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: PipeOptions)
     }
 }
 
-fn createDirAndFile(dir: std.fs.Dir, file_name: []const u8) !std.fs.File {
-    const fs_file = dir.createFile(file_name, .{ .exclusive = true }) catch |err| {
+const default_mode = std.fs.File.default_mode;
+
+fn fileMode(mode: u32, options: PipeOptions) std.fs.File.Mode {
+    const S = std.posix.S;
+    if (!std.fs.has_executable_bit or
+        options.mode_mode == .ignore or
+        mode & S.IXUSR == 0)
+        return default_mode;
+    return default_mode | S.IXUSR | S.IXGRP | S.IXOTH;
+}
+
+test fileMode {
+    if (!std.fs.has_executable_bit) return error.SkipZigTest;
+    try testing.expectEqual(default_mode, fileMode(0o744, PipeOptions{ .mode_mode = .ignore }));
+    try testing.expectEqual(0o777, fileMode(0o744, PipeOptions{}));
+    try testing.expectEqual(0o666, fileMode(0o644, PipeOptions{}));
+    try testing.expectEqual(0o666, fileMode(0o655, PipeOptions{}));
+}
+
+fn createDirAndFile(dir: std.fs.Dir, file_name: []const u8, mode: std.fs.File.Mode) !std.fs.File {
+    const fs_file = dir.createFile(file_name, .{ .exclusive = true, .mode = mode }) catch |err| {
         if (err == error.FileNotFound) {
             if (std.fs.path.dirname(file_name)) |dir_name| {
                 try dir.makePath(dir_name);
-                return try dir.createFile(file_name, .{ .exclusive = true });
+                return try dir.createFile(file_name, .{ .exclusive = true, .mode = mode });
             }
         }
         return err;
@@ -784,9 +815,9 @@ test "create file and symlink" {
     var root = testing.tmpDir(.{});
     defer root.cleanup();
 
-    var file = try createDirAndFile(root.dir, "file1");
+    var file = try createDirAndFile(root.dir, "file1", default_mode);
     file.close();
-    file = try createDirAndFile(root.dir, "a/b/c/file2");
+    file = try createDirAndFile(root.dir, "a/b/c/file2", default_mode);
     file.close();
 
     createDirAndSymlink(root.dir, "a/b/c/file2", "symlink1") catch |err| {
@@ -798,7 +829,7 @@ test "create file and symlink" {
 
     // Danglink symlnik, file created later
     try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
-    file = try createDirAndFile(root.dir, "g/h/i/file4");
+    file = try createDirAndFile(root.dir, "g/h/i/file4", default_mode);
     file.close();
 }
 
@@ -893,6 +924,7 @@ test pipeToFileSystem {
     pipeToFileSystem(dir, reader, .{
         .strip_components = 1,
         .exclude_empty_directories = true,
+        .mode_mode = .ignore,
     }) catch |err| {
         // Skip on platform which don't support symlinks
         if (err == error.UnableToCreateSymLink) return error.SkipZigTest;
@@ -911,6 +943,45 @@ test pipeToFileSystem {
     );
 }
 
+test "executable bit" {
+    if (!std.fs.has_executable_bit) return error.SkipZigTest;
+    const S = std.posix.S;
+
+    const data = @embedFile("tar/testdata/example.tar");
+
+    for ([_]PipeOptions.ModeMode{ .ignore, .executable_bit_only }) |opt| {
+        var fbs = std.io.fixedBufferStream(data);
+        const reader = fbs.reader();
+
+        var tmp = testing.tmpDir(.{ .no_follow = true });
+        defer tmp.cleanup();
+
+        pipeToFileSystem(tmp.dir, reader, .{
+            .strip_components = 1,
+            .exclude_empty_directories = true,
+            .mode_mode = opt,
+        }) catch |err| {
+            // Skip on platform which don't support symlinks
+            if (err == error.UnableToCreateSymLink) return error.SkipZigTest;
+            return err;
+        };
+
+        const fs = try tmp.dir.statFile("a/file");
+        try testing.expect(fs.kind == .file);
+        if (opt == .executable_bit_only) {
+            // Executable bit is set for user, group and others
+            try testing.expect(fs.mode & S.IXUSR > 0);
+            try testing.expect(fs.mode & S.IXGRP > 0);
+            try testing.expect(fs.mode & S.IXOTH > 0);
+        }
+        if (opt == .ignore) {
+            try testing.expect(fs.mode & S.IXUSR == 0);
+            try testing.expect(fs.mode & S.IXGRP == 0);
+            try testing.expect(fs.mode & S.IXOTH == 0);
+        }
+    }
+}
+
 fn normalizePath(bytes: []u8) []u8 {
     const canonical_sep = std.fs.path.sep_posix;
     if (std.fs.path.sep == canonical_sep) return bytes;