authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-03-11 17:03:44-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2024-03-11 17:03:44-07:00
logf60c24c73cc5c5894fbfb7060a70bc683c4a4ba5
tree981b2b5fa0a8ab5ed5db4be972467367de2ec1f9
parent26e895e3dc4ff1b7ac235414a356840bccb4fb1e
parentc974e198164e13fea491e3897a04ec82d132fbf6
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #19155 from ianic/tar_max_file_size

std.tar: error on insufficient buffers provided to iterator

6 files changed, 633 insertions(+), 449 deletions(-)

lib/docs/wasm/main.zig+1-2
...@@ -767,7 +767,7 @@ fn unpack_inner(tar_bytes: []u8) !void {...@@ -767,7 +767,7 @@ fn unpack_inner(tar_bytes: []u8) !void {
767 });767 });
768 while (try it.next()) |tar_file| {768 while (try it.next()) |tar_file| {
769 switch (tar_file.kind) {769 switch (tar_file.kind) {
770 .normal => {770 .file => {
771 if (tar_file.size == 0 and tar_file.name.len == 0) break;771 if (tar_file.size == 0 and tar_file.name.len == 0) break;
772 if (std.mem.endsWith(u8, tar_file.name, ".zig")) {772 if (std.mem.endsWith(u8, tar_file.name, ".zig")) {
773 log.debug("found file: '{s}'", .{tar_file.name});773 log.debug("found file: '{s}'", .{tar_file.name});
...@@ -790,7 +790,6 @@ fn unpack_inner(tar_bytes: []u8) !void {...@@ -790,7 +790,6 @@ fn unpack_inner(tar_bytes: []u8) !void {
790 tar_file.name,790 tar_file.name,
791 });791 });
792 }792 }
793 try tar_file.skip();
794 },793 },
795 else => continue,794 else => continue,
796 }795 }
lib/std/tar.zig+293-123
...@@ -15,22 +15,65 @@...@@ -15,22 +15,65 @@
15//! GNU tar reference: https://www.gnu.org/software/tar/manual/html_node/Standard.html15//! GNU tar reference: https://www.gnu.org/software/tar/manual/html_node/Standard.html
16//! pax reference: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_1316//! pax reference: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13
1717
18const std = @import("std.zig");18const std = @import("std");
19const assert = std.debug.assert;19const assert = std.debug.assert;
20const testing = std.testing;
2021
21pub const output = @import("tar/output.zig");22pub const output = @import("tar/output.zig");
2223
23pub const Options = struct {24/// Provide this to receive detailed error messages.
25/// When this is provided, some errors which would otherwise be returned
26/// immediately will instead be added to this structure. The API user must check
27/// the errors in diagnostics to know whether the operation succeeded or failed.
28pub const Diagnostics = struct {
29 allocator: std.mem.Allocator,
30 errors: std.ArrayListUnmanaged(Error) = .{},
31
32 pub const Error = union(enum) {
33 unable_to_create_sym_link: struct {
34 code: anyerror,
35 file_name: []const u8,
36 link_name: []const u8,
37 },
38 unable_to_create_file: struct {
39 code: anyerror,
40 file_name: []const u8,
41 },
42 unsupported_file_type: struct {
43 file_name: []const u8,
44 file_type: Header.Kind,
45 },
46 };
47
48 pub fn deinit(d: *Diagnostics) void {
49 for (d.errors.items) |item| {
50 switch (item) {
51 .unable_to_create_sym_link => |info| {
52 d.allocator.free(info.file_name);
53 d.allocator.free(info.link_name);
54 },
55 .unable_to_create_file => |info| {
56 d.allocator.free(info.file_name);
57 },
58 .unsupported_file_type => |info| {
59 d.allocator.free(info.file_name);
60 },
61 }
62 }
63 d.errors.deinit(d.allocator);
64 d.* = undefined;
65 }
66};
67
68/// pipeToFileSystem options
69pub const PipeOptions = struct {
24 /// Number of directory levels to skip when extracting files.70 /// Number of directory levels to skip when extracting files.
25 strip_components: u32 = 0,71 strip_components: u32 = 0,
26 /// How to handle the "mode" property of files from within the tar file.72 /// How to handle the "mode" property of files from within the tar file.
27 mode_mode: ModeMode = .executable_bit_only,73 mode_mode: ModeMode = .executable_bit_only,
28 /// Prevents creation of empty directories.74 /// Prevents creation of empty directories.
29 exclude_empty_directories: bool = false,75 exclude_empty_directories: bool = false,
30 /// Provide this to receive detailed error messages.76 /// Collects error messages during unpacking
31 /// When this is provided, some errors which would otherwise be returned immediately
32 /// will instead be added to this structure. The API user must check the errors
33 /// in diagnostics to know whether the operation succeeded or failed.
34 diagnostics: ?*Diagnostics = null,77 diagnostics: ?*Diagnostics = null,
3578
36 pub const ModeMode = enum {79 pub const ModeMode = enum {
...@@ -42,56 +85,16 @@ pub const Options = struct {...@@ -42,56 +85,16 @@ pub const Options = struct {
42 /// Other bits of the mode are left as the default when creating files.85 /// Other bits of the mode are left as the default when creating files.
43 executable_bit_only,86 executable_bit_only,
44 };87 };
45
46 pub const Diagnostics = struct {
47 allocator: std.mem.Allocator,
48 errors: std.ArrayListUnmanaged(Error) = .{},
49
50 pub const Error = union(enum) {
51 unable_to_create_sym_link: struct {
52 code: anyerror,
53 file_name: []const u8,
54 link_name: []const u8,
55 },
56 unable_to_create_file: struct {
57 code: anyerror,
58 file_name: []const u8,
59 },
60 unsupported_file_type: struct {
61 file_name: []const u8,
62 file_type: Header.Kind,
63 },
64 };
65
66 pub fn deinit(d: *Diagnostics) void {
67 for (d.errors.items) |item| {
68 switch (item) {
69 .unable_to_create_sym_link => |info| {
70 d.allocator.free(info.file_name);
71 d.allocator.free(info.link_name);
72 },
73 .unable_to_create_file => |info| {
74 d.allocator.free(info.file_name);
75 },
76 .unsupported_file_type => |info| {
77 d.allocator.free(info.file_name);
78 },
79 }
80 }
81 d.errors.deinit(d.allocator);
82 d.* = undefined;
83 }
84 };
85};88};
8689
87pub const Header = struct {90const Header = struct {
88 const SIZE = 512;91 const SIZE = 512;
89 const MAX_NAME_SIZE = 100 + 1 + 155; // name(100) + separator(1) + prefix(155)92 const MAX_NAME_SIZE = 100 + 1 + 155; // name(100) + separator(1) + prefix(155)
90 const LINK_NAME_SIZE = 100;93 const LINK_NAME_SIZE = 100;
9194
92 bytes: *const [SIZE]u8,95 bytes: *const [SIZE]u8,
9396
94 pub const Kind = enum(u8) {97 const Kind = enum(u8) {
95 normal_alias = 0,98 normal_alias = 0,
96 normal = '0',99 normal = '0',
97 hard_link = '1',100 hard_link = '1',
...@@ -114,9 +117,10 @@ pub const Header = struct {...@@ -114,9 +117,10 @@ pub const Header = struct {
114117
115 /// Includes prefix concatenated, if any.118 /// Includes prefix concatenated, if any.
116 /// TODO: check against "../" and other nefarious things119 /// TODO: check against "../" and other nefarious things
117 pub fn fullName(header: Header, buffer: *[MAX_NAME_SIZE]u8) ![]const u8 {120 pub fn fullName(header: Header, buffer: []u8) ![]const u8 {
118 const n = name(header);121 const n = name(header);
119 const p = prefix(header);122 const p = prefix(header);
123 if (buffer.len < n.len + p.len + 1) return error.TarInsufficientBuffer;
120 if (!is_ustar(header) or p.len == 0) {124 if (!is_ustar(header) or p.len == 0) {
121 @memcpy(buffer[0..n.len], n);125 @memcpy(buffer[0..n.len], n);
122 return buffer[0..n.len];126 return buffer[0..n.len];
...@@ -127,11 +131,14 @@ pub const Header = struct {...@@ -127,11 +131,14 @@ pub const Header = struct {
127 return buffer[0 .. p.len + 1 + n.len];131 return buffer[0 .. p.len + 1 + n.len];
128 }132 }
129133
130 pub fn linkName(header: Header, buffer: *[LINK_NAME_SIZE]u8) []const u8 {134 /// When kind is symbolic_link linked-to name (target_path) is specified in
135 /// the linkname field.
136 pub fn linkName(header: Header, buffer: []u8) ![]const u8 {
131 const link_name = header.str(157, 100);137 const link_name = header.str(157, 100);
132 if (link_name.len == 0) {138 if (link_name.len == 0) {
133 return buffer[0..0];139 return buffer[0..0];
134 }140 }
141 if (buffer.len < link_name.len) return error.TarInsufficientBuffer;
135 const buf = buffer[0..link_name.len];142 const buf = buffer[0..link_name.len];
136 @memcpy(buf, link_name);143 @memcpy(buf, link_name);
137 return buf;144 return buf;
...@@ -233,71 +240,85 @@ fn nullStr(str: []const u8) []const u8 {...@@ -233,71 +240,85 @@ fn nullStr(str: []const u8) []const u8 {
233 return str;240 return str;
234}241}
235242
243/// Options for iterator.
244/// Buffers should be provided by the caller.
236pub const IteratorOptions = struct {245pub const IteratorOptions = struct {
237 /// Use a buffer with length `std.fs.MAX_PATH_BYTES` to match file system capabilities.246 /// Use a buffer with length `std.fs.MAX_PATH_BYTES` to match file system capabilities.
238 file_name_buffer: []u8,247 file_name_buffer: []u8,
239 /// Use a buffer with length `std.fs.MAX_PATH_BYTES` to match file system capabilities.248 /// Use a buffer with length `std.fs.MAX_PATH_BYTES` to match file system capabilities.
240 link_name_buffer: []u8,249 link_name_buffer: []u8,
250 /// Collects error messages during unpacking
241 diagnostics: ?*Diagnostics = null,251 diagnostics: ?*Diagnostics = null,
242
243 pub const Diagnostics = Options.Diagnostics;
244};252};
245253
246/// Iterates over files in tar archive.254/// Iterates over files in tar archive.
247/// `next` returns each file in `reader` tar archive.255/// `next` returns each file in tar archive.
248pub fn iterator(reader: anytype, options: IteratorOptions) Iterator(@TypeOf(reader)) {256pub fn iterator(reader: anytype, options: IteratorOptions) Iterator(@TypeOf(reader)) {
249 return .{257 return .{
250 .reader = reader,258 .reader = reader,
251 .diagnostics = options.diagnostics,259 .diagnostics = options.diagnostics,
252 .header_buffer = undefined,
253 .file_name_buffer = options.file_name_buffer,260 .file_name_buffer = options.file_name_buffer,
254 .link_name_buffer = options.link_name_buffer,261 .link_name_buffer = options.link_name_buffer,
255 .padding = 0,
256 .file = undefined,
257 };262 };
258}263}
259264
260fn Iterator(comptime ReaderType: type) type {265/// Type of the file returned by iterator `next` method.
266pub const FileKind = enum {
267 directory,
268 sym_link,
269 file,
270};
271
272/// Iteartor over entries in the tar file represented by reader.
273pub fn Iterator(comptime ReaderType: type) type {
261 return struct {274 return struct {
262 reader: ReaderType,275 reader: ReaderType,
263 diagnostics: ?*Options.Diagnostics,276 diagnostics: ?*Diagnostics = null,
264277
265 // buffers for heeader and file attributes278 // buffers for heeader and file attributes
266 header_buffer: [Header.SIZE]u8,279 header_buffer: [Header.SIZE]u8 = undefined,
267 file_name_buffer: []u8,280 file_name_buffer: []u8,
268 link_name_buffer: []u8,281 link_name_buffer: []u8,
269282
270 // bytes of padding to the end of the block283 // bytes of padding to the end of the block
271 padding: usize,284 padding: usize = 0,
272 // current tar file285 // not consumed bytes of file from last next iteration
273 file: File,286 unread_file_bytes: u64 = 0,
274287
275 pub const File = struct {288 pub const File = struct {
276 name: []const u8, // name of file, symlink or directory289 name: []const u8, // name of file, symlink or directory
277 link_name: []const u8, // target name of symlink290 link_name: []const u8, // target name of symlink
278 size: u64, // size of the file in bytes291 size: u64 = 0, // size of the file in bytes
279 mode: u32,292 mode: u32 = 0,
280 kind: Header.Kind,293 kind: FileKind = .file,
294
295 unread_bytes: *u64,
296 parent_reader: ReaderType,
297
298 pub const Reader = std.io.Reader(File, ReaderType.Error, File.read);
281299
282 reader: ReaderType,300 pub fn reader(self: File) Reader {
301 return .{ .context = self };
302 }
303
304 pub fn read(self: File, dest: []u8) ReaderType.Error!usize {
305 const buf = dest[0..@min(dest.len, self.unread_bytes.*)];
306 const n = try self.parent_reader.read(buf);
307 self.unread_bytes.* -= n;
308 return n;
309 }
283310
284 // Writes file content to writer.311 // Writes file content to writer.
285 pub fn write(self: File, writer: anytype) !void {312 pub fn writeAll(self: File, writer: anytype) !void {
286 var buffer: [4096]u8 = undefined;313 var buffer: [4096]u8 = undefined;
287314
288 var n: u64 = 0;315 while (self.unread_bytes.* > 0) {
289 while (n < self.size) {316 const buf = buffer[0..@min(buffer.len, self.unread_bytes.*)];
290 const buf = buffer[0..@min(buffer.len, self.size - n)];317 try self.parent_reader.readNoEof(buf);
291 try self.reader.readNoEof(buf);
292 try writer.writeAll(buf);318 try writer.writeAll(buf);
293 n += buf.len;319 self.unread_bytes.* -= buf.len;
294 }320 }
295 }321 }
296
297 // Skips file content. Advances reader.
298 pub fn skip(self: File) !void {
299 try self.reader.skipBytes(self.size, .{});
300 }
301 };322 };
302323
303 const Self = @This();324 const Self = @This();
...@@ -315,20 +336,18 @@ fn Iterator(comptime ReaderType: type) type {...@@ -315,20 +336,18 @@ fn Iterator(comptime ReaderType: type) type {
315 }336 }
316337
317 fn readString(self: *Self, size: usize, buffer: []u8) ![]const u8 {338 fn readString(self: *Self, size: usize, buffer: []u8) ![]const u8 {
318 if (size > buffer.len) return error.TarCorruptInput;339 if (size > buffer.len) return error.TarInsufficientBuffer;
319 const buf = buffer[0..size];340 const buf = buffer[0..size];
320 try self.reader.readNoEof(buf);341 try self.reader.readNoEof(buf);
321 return nullStr(buf);342 return nullStr(buf);
322 }343 }
323344
324 fn initFile(self: *Self) void {345 fn newFile(self: *Self) File {
325 self.file = .{346 return .{
326 .name = self.file_name_buffer[0..0],347 .name = self.file_name_buffer[0..0],
327 .link_name = self.link_name_buffer[0..0],348 .link_name = self.link_name_buffer[0..0],
328 .size = 0,349 .parent_reader = self.reader,
329 .kind = .normal,350 .unread_bytes = &self.unread_file_bytes,
330 .mode = 0,
331 .reader = self.reader,
332 };351 };
333 }352 }
334353
...@@ -345,7 +364,12 @@ fn Iterator(comptime ReaderType: type) type {...@@ -345,7 +364,12 @@ fn Iterator(comptime ReaderType: type) type {
345 /// loop iterates through one or more entries until it collects a all364 /// loop iterates through one or more entries until it collects a all
346 /// file attributes.365 /// file attributes.
347 pub fn next(self: *Self) !?File {366 pub fn next(self: *Self) !?File {
348 self.initFile();367 if (self.unread_file_bytes > 0) {
368 // If file content was not consumed by caller
369 try self.reader.skipBytes(self.unread_file_bytes, .{});
370 self.unread_file_bytes = 0;
371 }
372 var file: File = self.newFile();
349373
350 while (try self.readHeader()) |header| {374 while (try self.readHeader()) |header| {
351 const kind = header.kind();375 const kind = header.kind();
...@@ -355,46 +379,52 @@ fn Iterator(comptime ReaderType: type) type {...@@ -355,46 +379,52 @@ fn Iterator(comptime ReaderType: type) type {
355 switch (kind) {379 switch (kind) {
356 // File types to retrun upstream380 // File types to retrun upstream
357 .directory, .normal, .symbolic_link => {381 .directory, .normal, .symbolic_link => {
358 self.file.kind = kind;382 file.kind = switch (kind) {
359 self.file.mode = try header.mode();383 .directory => .directory,
384 .normal => .file,
385 .symbolic_link => .sym_link,
386 else => unreachable,
387 };
388 file.mode = try header.mode();
360389
361 // set file attributes if not already set by prefix/extended headers390 // set file attributes if not already set by prefix/extended headers
362 if (self.file.size == 0) {391 if (file.size == 0) {
363 self.file.size = size;392 file.size = size;
364 }393 }
365 if (self.file.link_name.len == 0) {394 if (file.link_name.len == 0) {
366 self.file.link_name = header.linkName(self.link_name_buffer[0..Header.LINK_NAME_SIZE]);395 file.link_name = try header.linkName(self.link_name_buffer);
367 }396 }
368 if (self.file.name.len == 0) {397 if (file.name.len == 0) {
369 self.file.name = try header.fullName(self.file_name_buffer[0..Header.MAX_NAME_SIZE]);398 file.name = try header.fullName(self.file_name_buffer);
370 }399 }
371400
372 self.padding = blockPadding(self.file.size);401 self.padding = blockPadding(file.size);
373 return self.file;402 self.unread_file_bytes = file.size;
403 return file;
374 },404 },
375 // Prefix header types405 // Prefix header types
376 .gnu_long_name => {406 .gnu_long_name => {
377 self.file.name = try self.readString(@intCast(size), self.file_name_buffer);407 file.name = try self.readString(@intCast(size), self.file_name_buffer);
378 },408 },
379 .gnu_long_link => {409 .gnu_long_link => {
380 self.file.link_name = try self.readString(@intCast(size), self.link_name_buffer);410 file.link_name = try self.readString(@intCast(size), self.link_name_buffer);
381 },411 },
382 .extended_header => {412 .extended_header => {
383 // Use just attributes from last extended header.413 // Use just attributes from last extended header.
384 self.initFile();414 file = self.newFile();
385415
386 var rdr = paxIterator(self.reader, @intCast(size));416 var rdr = paxIterator(self.reader, @intCast(size));
387 while (try rdr.next()) |attr| {417 while (try rdr.next()) |attr| {
388 switch (attr.kind) {418 switch (attr.kind) {
389 .path => {419 .path => {
390 self.file.name = try attr.value(self.file_name_buffer);420 file.name = try attr.value(self.file_name_buffer);
391 },421 },
392 .linkpath => {422 .linkpath => {
393 self.file.link_name = try attr.value(self.link_name_buffer);423 file.link_name = try attr.value(self.link_name_buffer);
394 },424 },
395 .size => {425 .size => {
396 var buf: [pax_max_size_attr_len]u8 = undefined;426 var buf: [pax_max_size_attr_len]u8 = undefined;
397 self.file.size = try std.fmt.parseInt(u64, try attr.value(&buf), 10);427 file.size = try std.fmt.parseInt(u64, try attr.value(&buf), 10);
398 },428 },
399 }429 }
400 }430 }
...@@ -467,7 +497,8 @@ fn PaxIterator(comptime ReaderType: type) type {...@@ -467,7 +497,8 @@ fn PaxIterator(comptime ReaderType: type) type {
467 // Copies pax attribute value into destination buffer.497 // Copies pax attribute value into destination buffer.
468 // Must be called with destination buffer of size at least Attribute.len.498 // Must be called with destination buffer of size at least Attribute.len.
469 pub fn value(self: Attribute, dst: []u8) ![]const u8 {499 pub fn value(self: Attribute, dst: []u8) ![]const u8 {
470 assert(self.len <= dst.len);500 if (self.len > dst.len) return error.TarInsufficientBuffer;
501 // assert(self.len <= dst.len);
471 const buf = dst[0..self.len];502 const buf = dst[0..self.len];
472 const n = try self.reader.readAll(buf);503 const n = try self.reader.readAll(buf);
473 if (n < self.len) return error.UnexpectedEndOfStream;504 if (n < self.len) return error.UnexpectedEndOfStream;
...@@ -540,7 +571,8 @@ fn PaxIterator(comptime ReaderType: type) type {...@@ -540,7 +571,8 @@ fn PaxIterator(comptime ReaderType: type) type {
540 };571 };
541}572}
542573
543pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !void {574/// Saves tar file content to the file systems.
575pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: PipeOptions) !void {
544 switch (options.mode_mode) {576 switch (options.mode_mode) {
545 .ignore => {},577 .ignore => {},
546 .executable_bit_only => {578 .executable_bit_only => {
...@@ -568,24 +600,23 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi...@@ -568,24 +600,23 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
568 try dir.makePath(file_name);600 try dir.makePath(file_name);
569 }601 }
570 },602 },
571 .normal => {603 .file => {
572 if (file.size == 0 and file.name.len == 0) return;604 if (file.size == 0 and file.name.len == 0) return;
573 const file_name = stripComponents(file.name, options.strip_components);605 const file_name = stripComponents(file.name, options.strip_components);
574 if (file_name.len == 0) return error.BadFileName;606 if (file_name.len == 0) return error.BadFileName;
575607
576 if (createDirAndFile(dir, file_name)) |fs_file| {608 if (createDirAndFile(dir, file_name)) |fs_file| {
577 defer fs_file.close();609 defer fs_file.close();
578 try file.write(fs_file);610 try file.writeAll(fs_file);
579 } else |err| {611 } else |err| {
580 const d = options.diagnostics orelse return err;612 const d = options.diagnostics orelse return err;
581 try d.errors.append(d.allocator, .{ .unable_to_create_file = .{613 try d.errors.append(d.allocator, .{ .unable_to_create_file = .{
582 .code = err,614 .code = err,
583 .file_name = try d.allocator.dupe(u8, file_name),615 .file_name = try d.allocator.dupe(u8, file_name),
584 } });616 } });
585 try file.skip();
586 }617 }
587 },618 },
588 .symbolic_link => {619 .sym_link => {
589 // The file system path of the symbolic link.620 // The file system path of the symbolic link.
590 const file_name = stripComponents(file.name, options.strip_components);621 const file_name = stripComponents(file.name, options.strip_components);
591 if (file_name.len == 0) return error.BadFileName;622 if (file_name.len == 0) return error.BadFileName;
...@@ -601,7 +632,6 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi...@@ -601,7 +632,6 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
601 } });632 } });
602 };633 };
603 },634 },
604 else => unreachable,
605 }635 }
606 }636 }
607}637}
...@@ -619,6 +649,7 @@ fn createDirAndFile(dir: std.fs.Dir, file_name: []const u8) !std.fs.File {...@@ -619,6 +649,7 @@ fn createDirAndFile(dir: std.fs.Dir, file_name: []const u8) !std.fs.File {
619 return fs_file;649 return fs_file;
620}650}
621651
652// Creates a symbolic link at path `file_name` which points to `link_name`.
622fn createDirAndSymlink(dir: std.fs.Dir, link_name: []const u8, file_name: []const u8) !void {653fn createDirAndSymlink(dir: std.fs.Dir, link_name: []const u8, file_name: []const u8) !void {
623 dir.symLink(link_name, file_name, .{}) catch |err| {654 dir.symLink(link_name, file_name, .{}) catch |err| {
624 if (err == error.FileNotFound) {655 if (err == error.FileNotFound) {
...@@ -645,8 +676,8 @@ fn stripComponents(path: []const u8, count: u32) []const u8 {...@@ -645,8 +676,8 @@ fn stripComponents(path: []const u8, count: u32) []const u8 {
645 return path[i..];676 return path[i..];
646}677}
647678
648test "tar stripComponents" {679test "stripComponents" {
649 const expectEqualStrings = std.testing.expectEqualStrings;680 const expectEqualStrings = testing.expectEqualStrings;
650 try expectEqualStrings("a/b/c", stripComponents("a/b/c", 0));681 try expectEqualStrings("a/b/c", stripComponents("a/b/c", 0));
651 try expectEqualStrings("b/c", stripComponents("a/b/c", 1));682 try expectEqualStrings("b/c", stripComponents("a/b/c", 1));
652 try expectEqualStrings("c", stripComponents("a/b/c", 2));683 try expectEqualStrings("c", stripComponents("a/b/c", 2));
...@@ -654,7 +685,7 @@ test "tar stripComponents" {...@@ -654,7 +685,7 @@ test "tar stripComponents" {
654 try expectEqualStrings("", stripComponents("a/b/c", 4));685 try expectEqualStrings("", stripComponents("a/b/c", 4));
655}686}
656687
657test "tar PaxIterator" {688test "PaxIterator" {
658 const Attr = struct {689 const Attr = struct {
659 kind: PaxAttributeKind,690 kind: PaxAttributeKind,
660 value: []const u8 = undefined,691 value: []const u8 = undefined,
...@@ -757,24 +788,24 @@ test "tar PaxIterator" {...@@ -757,24 +788,24 @@ test "tar PaxIterator" {
757 var i: usize = 0;788 var i: usize = 0;
758 while (iter.next() catch |err| {789 while (iter.next() catch |err| {
759 if (case.err) |e| {790 if (case.err) |e| {
760 try std.testing.expectEqual(e, err);791 try testing.expectEqual(e, err);
761 continue;792 continue;
762 }793 }
763 return err;794 return err;
764 }) |attr| : (i += 1) {795 }) |attr| : (i += 1) {
765 const exp = case.attrs[i];796 const exp = case.attrs[i];
766 try std.testing.expectEqual(exp.kind, attr.kind);797 try testing.expectEqual(exp.kind, attr.kind);
767 const value = attr.value(&buffer) catch |err| {798 const value = attr.value(&buffer) catch |err| {
768 if (exp.err) |e| {799 if (exp.err) |e| {
769 try std.testing.expectEqual(e, err);800 try testing.expectEqual(e, err);
770 break :outer;801 break :outer;
771 }802 }
772 return err;803 return err;
773 };804 };
774 try std.testing.expectEqualStrings(exp.value, value);805 try testing.expectEqualStrings(exp.value, value);
775 }806 }
776 try std.testing.expectEqual(case.attrs.len, i);807 try testing.expectEqual(case.attrs.len, i);
777 try std.testing.expect(case.err == null);808 try testing.expect(case.err == null);
778 }809 }
779}810}
780811
...@@ -782,7 +813,7 @@ test {...@@ -782,7 +813,7 @@ test {
782 _ = @import("tar/test.zig");813 _ = @import("tar/test.zig");
783}814}
784815
785test "tar header parse size" {816test "header parse size" {
786 const cases = [_]struct {817 const cases = [_]struct {
787 in: []const u8,818 in: []const u8,
788 want: u64 = 0,819 want: u64 = 0,
...@@ -810,14 +841,14 @@ test "tar header parse size" {...@@ -810,14 +841,14 @@ test "tar header parse size" {
810 @memcpy(bytes[124 .. 124 + case.in.len], case.in);841 @memcpy(bytes[124 .. 124 + case.in.len], case.in);
811 var header = Header{ .bytes = &bytes };842 var header = Header{ .bytes = &bytes };
812 if (case.err) |err| {843 if (case.err) |err| {
813 try std.testing.expectError(err, header.size());844 try testing.expectError(err, header.size());
814 } else {845 } else {
815 try std.testing.expectEqual(case.want, try header.size());846 try testing.expectEqual(case.want, try header.size());
816 }847 }
817 }848 }
818}849}
819850
820test "tar header parse mode" {851test "header parse mode" {
821 const cases = [_]struct {852 const cases = [_]struct {
822 in: []const u8,853 in: []const u8,
823 want: u64 = 0,854 want: u64 = 0,
...@@ -835,9 +866,148 @@ test "tar header parse mode" {...@@ -835,9 +866,148 @@ test "tar header parse mode" {
835 @memcpy(bytes[100 .. 100 + case.in.len], case.in);866 @memcpy(bytes[100 .. 100 + case.in.len], case.in);
836 var header = Header{ .bytes = &bytes };867 var header = Header{ .bytes = &bytes };
837 if (case.err) |err| {868 if (case.err) |err| {
838 try std.testing.expectError(err, header.mode());869 try testing.expectError(err, header.mode());
839 } else {870 } else {
840 try std.testing.expectEqual(case.want, try header.mode());871 try testing.expectEqual(case.want, try header.mode());
872 }
873 }
874}
875
876test "create file and symlink" {
877 var root = testing.tmpDir(.{});
878 defer root.cleanup();
879
880 var file = try createDirAndFile(root.dir, "file1");
881 file.close();
882 file = try createDirAndFile(root.dir, "a/b/c/file2");
883 file.close();
884
885 createDirAndSymlink(root.dir, "a/b/c/file2", "symlink1") catch |err| {
886 // On Windows when developer mode is not enabled
887 if (err == error.AccessDenied) return error.SkipZigTest;
888 return err;
889 };
890 try createDirAndSymlink(root.dir, "../../../file1", "d/e/f/symlink2");
891
892 // Danglink symlnik, file created later
893 try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
894 file = try createDirAndFile(root.dir, "g/h/i/file4");
895 file.close();
896}
897
898test iterator {
899 // Example tar file is created from this tree structure:
900 // $ tree example
901 // example
902 // ├── a
903 // │   └── file
904 // ├── b
905 // │   └── symlink -> ../a/file
906 // └── empty
907 // $ cat example/a/file
908 // content
909 // $ tar -cf example.tar example
910 // $ tar -tvf example.tar
911 // example/
912 // example/b/
913 // example/b/symlink -> ../a/file
914 // example/a/
915 // example/a/file
916 // example/empty/
917
918 const data = @embedFile("tar/testdata/example.tar");
919 var fbs = std.io.fixedBufferStream(data);
920
921 // User provided buffers to the iterator
922 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
923 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
924 // Create iterator
925 var iter = iterator(fbs.reader(), .{
926 .file_name_buffer = &file_name_buffer,
927 .link_name_buffer = &link_name_buffer,
928 });
929 // Iterate over files in example.tar
930 var file_no: usize = 0;
931 while (try iter.next()) |file| : (file_no += 1) {
932 switch (file.kind) {
933 .directory => {
934 switch (file_no) {
935 0 => try testing.expectEqualStrings("example/", file.name),
936 1 => try testing.expectEqualStrings("example/b/", file.name),
937 3 => try testing.expectEqualStrings("example/a/", file.name),
938 5 => try testing.expectEqualStrings("example/empty/", file.name),
939 else => unreachable,
940 }
941 },
942 .file => {
943 try testing.expectEqualStrings("example/a/file", file.name);
944 // Read file content
945 var buf: [16]u8 = undefined;
946 const n = try file.reader().readAll(&buf);
947 try testing.expectEqualStrings("content\n", buf[0..n]);
948 },
949 .sym_link => {
950 try testing.expectEqualStrings("example/b/symlink", file.name);
951 try testing.expectEqualStrings("../a/file", file.link_name);
952 },
841 }953 }
842 }954 }
843}955}
956
957test pipeToFileSystem {
958 // Example tar file is created from this tree structure:
959 // $ tree example
960 // example
961 // ├── a
962 // │   └── file
963 // ├── b
964 // │   └── symlink -> ../a/file
965 // └── empty
966 // $ cat example/a/file
967 // content
968 // $ tar -cf example.tar example
969 // $ tar -tvf example.tar
970 // example/
971 // example/b/
972 // example/b/symlink -> ../a/file
973 // example/a/
974 // example/a/file
975 // example/empty/
976
977 const data = @embedFile("tar/testdata/example.tar");
978 var fbs = std.io.fixedBufferStream(data);
979 const reader = fbs.reader();
980
981 var tmp = testing.tmpDir(.{ .no_follow = true });
982 defer tmp.cleanup();
983 const dir = tmp.dir;
984
985 // Save tar from `reader` to the file system `dir`
986 pipeToFileSystem(dir, reader, .{
987 .mode_mode = .ignore,
988 .strip_components = 1,
989 .exclude_empty_directories = true,
990 }) catch |err| {
991 // Skip on platform which don't support symlinks
992 if (err == error.UnableToCreateSymLink) return error.SkipZigTest;
993 return err;
994 };
995
996 try testing.expectError(error.FileNotFound, dir.statFile("empty"));
997 try testing.expect((try dir.statFile("a/file")).kind == .file);
998 try testing.expect((try dir.statFile("b/symlink")).kind == .file); // statFile follows symlink
999
1000 var buf: [32]u8 = undefined;
1001 try testing.expectEqualSlices(
1002 u8,
1003 "../a/file",
1004 normalizePath(try dir.readLink("b/symlink", &buf)),
1005 );
1006}
1007
1008fn normalizePath(bytes: []u8) []u8 {
1009 const canonical_sep = std.fs.path.sep_posix;
1010 if (std.fs.path.sep == canonical_sep) return bytes;
1011 std.mem.replaceScalar(u8, bytes, std.fs.path.sep, canonical_sep);
1012 return bytes;
1013}
lib/std/tar/test.zig+338-323
...@@ -1,328 +1,347 @@...@@ -1,328 +1,347 @@
1const std = @import("../std.zig");1const std = @import("std");
2const tar = std.tar;2const tar = @import("../tar.zig");
3const testing = std.testing;3const testing = std.testing;
44
5test "tar run Go test cases" {5const Case = struct {
6 const Case = struct {6 const File = struct {
7 const File = struct {7 name: []const u8,
8 name: []const u8,8 size: u64 = 0,
9 size: u64 = 0,9 mode: u32 = 0,
10 mode: u32 = 0,10 link_name: []const u8 = &[0]u8{},
11 link_name: []const u8 = &[0]u8{},11 kind: tar.FileKind = .file,
12 kind: tar.Header.Kind = .normal,12 truncated: bool = false, // when there is no file body, just header, usefull for huge files
13 truncated: bool = false, // when there is no file body, just header, usefull for huge files
14 };
15
16 data: []const u8, // testdata file content
17 files: []const File = &[_]@This().File{}, // expected files to found in archive
18 chksums: []const []const u8 = &[_][]const u8{}, // chksums of each file content
19 err: ?anyerror = null, // parsing should fail with this error
20 };13 };
2114
22 const cases = [_]Case{15 data: []const u8, // testdata file content
23 .{16 files: []const File = &[_]@This().File{}, // expected files to found in archive
24 .data = @embedFile("testdata/gnu.tar"),17 chksums: []const []const u8 = &[_][]const u8{}, // chksums of each file content
25 .files = &[_]Case.File{18 err: ?anyerror = null, // parsing should fail with this error
26 .{19};
27 .name = "small.txt",20
28 .size = 5,21const cases = [_]Case{
29 .mode = 0o640,22 .{
30 },23 .data = @embedFile("testdata/gnu.tar"),
31 .{24 .files = &[_]Case.File{
32 .name = "small2.txt",25 .{
33 .size = 11,26 .name = "small.txt",
34 .mode = 0o640,27 .size = 5,
35 },28 .mode = 0o640,
36 },29 },
37 .chksums = &[_][]const u8{30 .{
38 "e38b27eaccb4391bdec553a7f3ae6b2f",31 .name = "small2.txt",
39 "c65bd2e50a56a2138bf1716f2fd56fe9",32 .size = 11,
33 .mode = 0o640,
40 },34 },
41 },35 },
42 .{36 .chksums = &[_][]const u8{
43 .data = @embedFile("testdata/sparse-formats.tar"),37 "e38b27eaccb4391bdec553a7f3ae6b2f",
44 .err = error.TarUnsupportedHeader,38 "c65bd2e50a56a2138bf1716f2fd56fe9",
45 },39 },
46 .{40 },
47 .data = @embedFile("testdata/star.tar"),41 .{
48 .files = &[_]Case.File{42 .data = @embedFile("testdata/sparse-formats.tar"),
49 .{43 .err = error.TarUnsupportedHeader,
50 .name = "small.txt",44 },
51 .size = 5,45 .{
52 .mode = 0o640,46 .data = @embedFile("testdata/star.tar"),
53 },47 .files = &[_]Case.File{
54 .{48 .{
55 .name = "small2.txt",49 .name = "small.txt",
56 .size = 11,50 .size = 5,
57 .mode = 0o640,51 .mode = 0o640,
58 },
59 },52 },
60 .chksums = &[_][]const u8{53 .{
61 "e38b27eaccb4391bdec553a7f3ae6b2f",54 .name = "small2.txt",
62 "c65bd2e50a56a2138bf1716f2fd56fe9",55 .size = 11,
56 .mode = 0o640,
63 },57 },
64 },58 },
65 .{59 .chksums = &[_][]const u8{
66 .data = @embedFile("testdata/v7.tar"),60 "e38b27eaccb4391bdec553a7f3ae6b2f",
67 .files = &[_]Case.File{61 "c65bd2e50a56a2138bf1716f2fd56fe9",
68 .{
69 .name = "small.txt",
70 .size = 5,
71 .mode = 0o444,
72 },
73 .{
74 .name = "small2.txt",
75 .size = 11,
76 .mode = 0o444,
77 },
78 },
79 .chksums = &[_][]const u8{
80 "e38b27eaccb4391bdec553a7f3ae6b2f",
81 "c65bd2e50a56a2138bf1716f2fd56fe9",
82 },
83 },62 },
84 .{63 },
85 .data = @embedFile("testdata/pax.tar"),64 .{
86 .files = &[_]Case.File{65 .data = @embedFile("testdata/v7.tar"),
87 .{66 .files = &[_]Case.File{
88 .name = "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",67 .{
89 .size = 7,68 .name = "small.txt",
90 .mode = 0o664,69 .size = 5,
91 },70 .mode = 0o444,
92 .{
93 .name = "a/b",
94 .size = 0,
95 .kind = .symbolic_link,
96 .mode = 0o777,
97 .link_name = "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
98 },
99 },71 },
100 .chksums = &[_][]const u8{72 .{
101 "3c382e8f5b6631aa2db52643912ffd4a",73 .name = "small2.txt",
74 .size = 11,
75 .mode = 0o444,
102 },76 },
103 },77 },
104 .{78 .chksums = &[_][]const u8{
105 // pax attribute don't end with \n79 "e38b27eaccb4391bdec553a7f3ae6b2f",
106 .data = @embedFile("testdata/pax-bad-hdr-file.tar"),80 "c65bd2e50a56a2138bf1716f2fd56fe9",
107 .err = error.PaxInvalidAttributeEnd,
108 },81 },
109 .{82 },
110 // size is in pax attribute83 .{
111 .data = @embedFile("testdata/pax-pos-size-file.tar"),84 .data = @embedFile("testdata/pax.tar"),
112 .files = &[_]Case.File{85 .files = &[_]Case.File{
113 .{86 .{
114 .name = "foo",87 .name = "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
115 .size = 999,88 .size = 7,
116 .kind = .normal,89 .mode = 0o664,
117 .mode = 0o640,
118 },
119 },90 },
120 .chksums = &[_][]const u8{91 .{
121 "0afb597b283fe61b5d4879669a350556",92 .name = "a/b",
93 .size = 0,
94 .kind = .sym_link,
95 .mode = 0o777,
96 .link_name = "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
122 },97 },
123 },98 },
124 .{99 .chksums = &[_][]const u8{
125 // has pax records which we are not interested in100 "3c382e8f5b6631aa2db52643912ffd4a",
126 .data = @embedFile("testdata/pax-records.tar"),101 },
127 .files = &[_]Case.File{102 },
128 .{103 .{
129 .name = "file",104 // pax attribute don't end with \n
130 },105 .data = @embedFile("testdata/pax-bad-hdr-file.tar"),
106 .err = error.PaxInvalidAttributeEnd,
107 },
108 .{
109 // size is in pax attribute
110 .data = @embedFile("testdata/pax-pos-size-file.tar"),
111 .files = &[_]Case.File{
112 .{
113 .name = "foo",
114 .size = 999,
115 .kind = .file,
116 .mode = 0o640,
131 },117 },
132 },118 },
133 .{119 .chksums = &[_][]const u8{
134 // has global records which we are ignoring120 "0afb597b283fe61b5d4879669a350556",
135 .data = @embedFile("testdata/pax-global-records.tar"),121 },
136 .files = &[_]Case.File{122 },
137 .{123 .{
138 .name = "file1",124 // has pax records which we are not interested in
139 },125 .data = @embedFile("testdata/pax-records.tar"),
140 .{126 .files = &[_]Case.File{
141 .name = "file2",127 .{
142 },128 .name = "file",
143 .{
144 .name = "file3",
145 },
146 .{
147 .name = "file4",
148 },
149 },129 },
150 },130 },
151 .{131 },
152 .data = @embedFile("testdata/nil-uid.tar"),132 .{
153 .files = &[_]Case.File{133 // has global records which we are ignoring
154 .{134 .data = @embedFile("testdata/pax-global-records.tar"),
155 .name = "P1050238.JPG.log",135 .files = &[_]Case.File{
156 .size = 14,136 .{
157 .kind = .normal,137 .name = "file1",
158 .mode = 0o664,
159 },
160 },138 },
161 .chksums = &[_][]const u8{139 .{
162 "08d504674115e77a67244beac19668f5",140 .name = "file2",
163 },141 },
164 },142 .{
165 .{143 .name = "file3",
166 // has xattrs and pax records which we are ignoring
167 .data = @embedFile("testdata/xattrs.tar"),
168 .files = &[_]Case.File{
169 .{
170 .name = "small.txt",
171 .size = 5,
172 .kind = .normal,
173 .mode = 0o644,
174 },
175 .{
176 .name = "small2.txt",
177 .size = 11,
178 .kind = .normal,
179 .mode = 0o644,
180 },
181 },144 },
182 .chksums = &[_][]const u8{145 .{
183 "e38b27eaccb4391bdec553a7f3ae6b2f",146 .name = "file4",
184 "c65bd2e50a56a2138bf1716f2fd56fe9",
185 },147 },
186 },148 },
187 .{149 },
188 .data = @embedFile("testdata/gnu-multi-hdrs.tar"),150 .{
189 .files = &[_]Case.File{151 .data = @embedFile("testdata/nil-uid.tar"),
190 .{152 .files = &[_]Case.File{
191 .name = "GNU2/GNU2/long-path-name",153 .{
192 .link_name = "GNU4/GNU4/long-linkpath-name",154 .name = "P1050238.JPG.log",
193 .kind = .symbolic_link,155 .size = 14,
194 },156 .kind = .file,
157 .mode = 0o664,
195 },158 },
196 },159 },
197 .{160 .chksums = &[_][]const u8{
198 // has gnu type D (directory) and S (sparse) blocks161 "08d504674115e77a67244beac19668f5",
199 .data = @embedFile("testdata/gnu-incremental.tar"),
200 .err = error.TarUnsupportedHeader,
201 },162 },
202 .{163 },
203 // should use values only from last pax header164 .{
204 .data = @embedFile("testdata/pax-multi-hdrs.tar"),165 // has xattrs and pax records which we are ignoring
205 .files = &[_]Case.File{166 .data = @embedFile("testdata/xattrs.tar"),
206 .{167 .files = &[_]Case.File{
207 .name = "bar",168 .{
208 .link_name = "PAX4/PAX4/long-linkpath-name",169 .name = "small.txt",
209 .kind = .symbolic_link,170 .size = 5,
210 },171 .kind = .file,
172 .mode = 0o644,
211 },173 },
212 },174 .{
213 .{175 .name = "small2.txt",
214 .data = @embedFile("testdata/gnu-long-nul.tar"),176 .size = 11,
215 .files = &[_]Case.File{177 .kind = .file,
216 .{178 .mode = 0o644,
217 .name = "0123456789",
218 .mode = 0o644,
219 },
220 },179 },
221 },180 },
222 .{181 .chksums = &[_][]const u8{
223 .data = @embedFile("testdata/gnu-utf8.tar"),182 "e38b27eaccb4391bdec553a7f3ae6b2f",
224 .files = &[_]Case.File{183 "c65bd2e50a56a2138bf1716f2fd56fe9",
225 .{
226 .name = "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
227 .mode = 0o644,
228 },
229 },
230 },184 },
231 .{185 },
232 .data = @embedFile("testdata/gnu-not-utf8.tar"),186 .{
233 .files = &[_]Case.File{187 .data = @embedFile("testdata/gnu-multi-hdrs.tar"),
234 .{188 .files = &[_]Case.File{
235 .name = "hi\x80\x81\x82\x83bye",189 .{
236 .mode = 0o644,190 .name = "GNU2/GNU2/long-path-name",
237 },191 .link_name = "GNU4/GNU4/long-linkpath-name",
192 .kind = .sym_link,
238 },193 },
239 },194 },
240 .{195 },
241 // null in pax key196 .{
242 .data = @embedFile("testdata/pax-nul-xattrs.tar"),197 // has gnu type D (directory) and S (sparse) blocks
243 .err = error.PaxNullInKeyword,198 .data = @embedFile("testdata/gnu-incremental.tar"),
244 },199 .err = error.TarUnsupportedHeader,
245 .{200 },
246 .data = @embedFile("testdata/pax-nul-path.tar"),201 .{
247 .err = error.PaxNullInValue,202 // should use values only from last pax header
248 },203 .data = @embedFile("testdata/pax-multi-hdrs.tar"),
249 .{204 .files = &[_]Case.File{
250 .data = @embedFile("testdata/neg-size.tar"),205 .{
251 .err = error.TarHeader,206 .name = "bar",
252 },207 .link_name = "PAX4/PAX4/long-linkpath-name",
253 .{208 .kind = .sym_link,
254 .data = @embedFile("testdata/issue10968.tar"),209 },
255 .err = error.TarHeader,
256 },
257 .{
258 .data = @embedFile("testdata/issue11169.tar"),
259 .err = error.TarHeader,
260 },210 },
261 .{211 },
262 .data = @embedFile("testdata/issue12435.tar"),212 .{
263 .err = error.TarHeaderChksum,213 .data = @embedFile("testdata/gnu-long-nul.tar"),
214 .files = &[_]Case.File{
215 .{
216 .name = "0123456789",
217 .mode = 0o644,
218 },
264 },219 },
265 .{220 },
266 // has magic with space at end instead of null221 .{
267 .data = @embedFile("testdata/invalid-go17.tar"),222 .data = @embedFile("testdata/gnu-utf8.tar"),
268 .files = &[_]Case.File{223 .files = &[_]Case.File{
269 .{224 .{
270 .name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/foo",225 .name = "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
271 },226 .mode = 0o644,
272 },227 },
273 },228 },
274 .{229 },
275 .data = @embedFile("testdata/ustar-file-devs.tar"),230 .{
276 .files = &[_]Case.File{231 .data = @embedFile("testdata/gnu-not-utf8.tar"),
277 .{232 .files = &[_]Case.File{
278 .name = "file",233 .{
279 .mode = 0o644,234 .name = "hi\x80\x81\x82\x83bye",
280 },235 .mode = 0o644,
281 },236 },
282 },237 },
283 .{238 },
284 .data = @embedFile("testdata/trailing-slash.tar"),239 .{
285 .files = &[_]Case.File{240 // null in pax key
286 .{241 .data = @embedFile("testdata/pax-nul-xattrs.tar"),
287 .name = "123456789/" ** 30,242 .err = error.PaxNullInKeyword,
288 .kind = .directory,243 },
289 },244 .{
245 .data = @embedFile("testdata/pax-nul-path.tar"),
246 .err = error.PaxNullInValue,
247 },
248 .{
249 .data = @embedFile("testdata/neg-size.tar"),
250 .err = error.TarHeader,
251 },
252 .{
253 .data = @embedFile("testdata/issue10968.tar"),
254 .err = error.TarHeader,
255 },
256 .{
257 .data = @embedFile("testdata/issue11169.tar"),
258 .err = error.TarHeader,
259 },
260 .{
261 .data = @embedFile("testdata/issue12435.tar"),
262 .err = error.TarHeaderChksum,
263 },
264 .{
265 // has magic with space at end instead of null
266 .data = @embedFile("testdata/invalid-go17.tar"),
267 .files = &[_]Case.File{
268 .{
269 .name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/foo",
290 },270 },
291 },271 },
292 .{272 },
293 // Has size in gnu extended format. To represent size bigger than 8 GB.273 .{
294 .data = @embedFile("testdata/writer-big.tar"),274 .data = @embedFile("testdata/ustar-file-devs.tar"),
295 .files = &[_]Case.File{275 .files = &[_]Case.File{
296 .{276 .{
297 .name = "tmp/16gig.txt",277 .name = "file",
298 .size = 16 * 1024 * 1024 * 1024,278 .mode = 0o644,
299 .truncated = true,
300 .mode = 0o640,
301 },
302 },279 },
303 },280 },
304 .{281 },
305 // Size in gnu extended format, and name in pax attribute.282 .{
306 .data = @embedFile("testdata/writer-big-long.tar"),283 .data = @embedFile("testdata/trailing-slash.tar"),
307 .files = &[_]Case.File{284 .files = &[_]Case.File{
308 .{285 .{
309 .name = "longname/" ** 15 ++ "16gig.txt",286 .name = "123456789/" ** 30,
310 .size = 16 * 1024 * 1024 * 1024,287 .kind = .directory,
311 .mode = 0o644,
312 .truncated = true,
313 },
314 },288 },
315 },289 },
316 .{290 },
317 .data = @embedFile("testdata/fuzz1.tar"),291 .{
318 .err = error.TarCorruptInput,292 // Has size in gnu extended format. To represent size bigger than 8 GB.
293 .data = @embedFile("testdata/writer-big.tar"),
294 .files = &[_]Case.File{
295 .{
296 .name = "tmp/16gig.txt",
297 .size = 16 * 1024 * 1024 * 1024,
298 .truncated = true,
299 .mode = 0o640,
300 },
319 },301 },
320 .{302 },
321 .data = @embedFile("testdata/fuzz2.tar"),303 .{
322 .err = error.PaxSizeAttrOverflow,304 // Size in gnu extended format, and name in pax attribute.
305 .data = @embedFile("testdata/writer-big-long.tar"),
306 .files = &[_]Case.File{
307 .{
308 .name = "longname/" ** 15 ++ "16gig.txt",
309 .size = 16 * 1024 * 1024 * 1024,
310 .mode = 0o644,
311 .truncated = true,
312 },
323 },313 },
324 };314 },
315 .{
316 .data = @embedFile("testdata/fuzz1.tar"),
317 .err = error.TarInsufficientBuffer,
318 },
319 .{
320 .data = @embedFile("testdata/fuzz2.tar"),
321 .err = error.PaxSizeAttrOverflow,
322 },
323};
324
325// used in test to calculate file chksum
326const Md5Writer = struct {
327 h: std.crypto.hash.Md5 = std.crypto.hash.Md5.init(.{}),
328
329 pub fn writeAll(self: *Md5Writer, buf: []const u8) !void {
330 self.h.update(buf);
331 }
332
333 pub fn writeByte(self: *Md5Writer, byte: u8) !void {
334 self.h.update(&[_]u8{byte});
335 }
325336
337 pub fn chksum(self: *Md5Writer) [32]u8 {
338 var s = [_]u8{0} ** 16;
339 self.h.final(&s);
340 return std.fmt.bytesToHex(s, .lower);
341 }
342};
343
344test "run test cases" {
326 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;345 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
327 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;346 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
328347
...@@ -350,37 +369,65 @@ test "tar run Go test cases" {...@@ -350,37 +369,65 @@ test "tar run Go test cases" {
350369
351 if (case.chksums.len > i) {370 if (case.chksums.len > i) {
352 var md5writer = Md5Writer{};371 var md5writer = Md5Writer{};
353 try actual.write(&md5writer);372 try actual.writeAll(&md5writer);
354 const chksum = md5writer.chksum();373 const chksum = md5writer.chksum();
355 try testing.expectEqualStrings(case.chksums[i], &chksum);374 try testing.expectEqualStrings(case.chksums[i], &chksum);
356 } else {375 } else {
357 if (!expected.truncated) try actual.skip(); // skip file content376 if (expected.truncated) {
377 iter.unread_file_bytes = 0;
378 }
358 }379 }
359 }380 }
360 try testing.expectEqual(case.files.len, i);381 try testing.expectEqual(case.files.len, i);
361 }382 }
362}383}
363384
364// used in test to calculate file chksum385test "pax/gnu long names with small buffer" {
365const Md5Writer = struct {386 // should fail with insufficient buffer error
366 h: std.crypto.hash.Md5 = std.crypto.hash.Md5.init(.{}),
367387
368 pub fn writeAll(self: *Md5Writer, buf: []const u8) !void {388 var min_file_name_buffer: [256]u8 = undefined;
369 self.h.update(buf);389 var min_link_name_buffer: [100]u8 = undefined;
370 }390 const long_name_cases = [_]Case{ cases[11], cases[25], cases[28] };
371391
372 pub fn writeByte(self: *Md5Writer, byte: u8) !void {392 for (long_name_cases) |case| {
373 self.h.update(&[_]u8{byte});393 var fsb = std.io.fixedBufferStream(case.data);
374 }394 var iter = tar.iterator(fsb.reader(), .{
395 .file_name_buffer = &min_file_name_buffer,
396 .link_name_buffer = &min_link_name_buffer,
397 });
375398
376 pub fn chksum(self: *Md5Writer) [32]u8 {399 var iter_err: ?anyerror = null;
377 var s = [_]u8{0} ** 16;400 while (iter.next() catch |err| brk: {
378 self.h.final(&s);401 iter_err = err;
379 return std.fmt.bytesToHex(s, .lower);402 break :brk null;
403 }) |_| {}
404
405 try testing.expect(iter_err != null);
406 try testing.expectEqual(error.TarInsufficientBuffer, iter_err.?);
380 }407 }
381};408}
409
410test "insufficient buffer in Header name filed" {
411 var min_file_name_buffer: [9]u8 = undefined;
412 var min_link_name_buffer: [100]u8 = undefined;
413
414 var fsb = std.io.fixedBufferStream(cases[0].data);
415 var iter = tar.iterator(fsb.reader(), .{
416 .file_name_buffer = &min_file_name_buffer,
417 .link_name_buffer = &min_link_name_buffer,
418 });
419
420 var iter_err: ?anyerror = null;
421 while (iter.next() catch |err| brk: {
422 iter_err = err;
423 break :brk null;
424 }) |_| {}
425
426 try testing.expect(iter_err != null);
427 try testing.expectEqual(error.TarInsufficientBuffer, iter_err.?);
428}
382429
383test "tar should not overwrite existing file" {430test "should not overwrite existing file" {
384 // Starting from this folder structure:431 // Starting from this folder structure:
385 // $ tree root432 // $ tree root
386 // root433 // root
...@@ -436,7 +483,7 @@ test "tar should not overwrite existing file" {...@@ -436,7 +483,7 @@ test "tar should not overwrite existing file" {
436 try tar.pipeToFileSystem(root2.dir, fsb.reader(), .{ .mode_mode = .ignore, .strip_components = 0 });483 try tar.pipeToFileSystem(root2.dir, fsb.reader(), .{ .mode_mode = .ignore, .strip_components = 0 });
437}484}
438485
439test "tar case sensitivity" {486test "case sensitivity" {
440 // Mimicking issue #18089, this tar contains, same file name in two case487 // Mimicking issue #18089, this tar contains, same file name in two case
441 // sensitive name version. Should fail on case insensitive file systems.488 // sensitive name version. Should fail on case insensitive file systems.
442 //489 //
...@@ -462,35 +509,3 @@ test "tar case sensitivity" {...@@ -462,35 +509,3 @@ test "tar case sensitivity" {
462 try testing.expect((try root.dir.statFile("alacritty/darkermatrix.yml")).kind == .file);509 try testing.expect((try root.dir.statFile("alacritty/darkermatrix.yml")).kind == .file);
463 try testing.expect((try root.dir.statFile("alacritty/Darkermatrix.yml")).kind == .file);510 try testing.expect((try root.dir.statFile("alacritty/Darkermatrix.yml")).kind == .file);
464}511}
465
466test "tar pipeToFileSystem" {
467 // $ tar tvf
468 // pipe_to_file_system_test/
469 // pipe_to_file_system_test/b/
470 // pipe_to_file_system_test/b/symlink -> ../a/file
471 // pipe_to_file_system_test/a/
472 // pipe_to_file_system_test/a/file
473 // pipe_to_file_system_test/empty/
474 const data = @embedFile("testdata/pipe_to_file_system_test.tar");
475 var fsb = std.io.fixedBufferStream(data);
476
477 var root = std.testing.tmpDir(.{ .no_follow = true });
478 defer root.cleanup();
479
480 tar.pipeToFileSystem(root.dir, fsb.reader(), .{
481 .mode_mode = .ignore,
482 .strip_components = 1,
483 .exclude_empty_directories = true,
484 }) catch |err| {
485 // Skip on platform which don't support symlinks
486 if (err == error.UnableToCreateSymLink) return error.SkipZigTest;
487 return err;
488 };
489
490 try testing.expectError(error.FileNotFound, root.dir.statFile("empty"));
491 try testing.expect((try root.dir.statFile("a/file")).kind == .file);
492 // TODO is there better way to test symlink
493 try testing.expect((try root.dir.statFile("b/symlink")).kind == .file); // statFile follows symlink
494 var buf: [32]u8 = undefined;
495 _ = try root.dir.readLink("b/symlink", &buf);
496}
lib/std/tar/testdata/example.tar created
Binary files /dev/null and b/lib/std/tar/testdata/example.tar differ
lib/std/tar/testdata/pipe_to_file_system_test.tar deleted
Binary files a/lib/std/tar/testdata/pipe_to_file_system_test.tar and /dev/null differ
src/Package/Fetch.zig+1-1
...@@ -1147,7 +1147,7 @@ fn unpackTarball(f: *Fetch, out_dir: fs.Dir, reader: anytype) RunError!void {...@@ -1147,7 +1147,7 @@ fn unpackTarball(f: *Fetch, out_dir: fs.Dir, reader: anytype) RunError!void {
1147 const eb = &f.error_bundle;1147 const eb = &f.error_bundle;
1148 const gpa = f.arena.child_allocator;1148 const gpa = f.arena.child_allocator;
11491149
1150 var diagnostics: std.tar.Options.Diagnostics = .{ .allocator = gpa };1150 var diagnostics: std.tar.Diagnostics = .{ .allocator = gpa };
1151 defer diagnostics.deinit();1151 defer diagnostics.deinit();
11521152
1153 std.tar.pipeToFileSystem(out_dir, reader, .{1153 std.tar.pipeToFileSystem(out_dir, reader, .{