authorgravatar for igor.anic@gmail.comIgor Anić <igor.anic@gmail.com> 2024-03-02 10:59:25+01:00
committergravatar for igor.anic@gmail.comIgor Anić <igor.anic@gmail.com> 2024-03-11 12:22:12+01:00
log5ccbb196ad08fd5e58fc8874917a20f9a220d729
tree6fc7e2dcbbd745696058892b30ff384dab2767b4
parent10add7c677d368501691178ea0c073a9766cd498

std.tar: don't return in iterator init

Don't assert min buffer size on iterator init. That was changing public interface. This way we don't break that interface.

2 files changed, 320 insertions(+), 314 deletions(-)

lib/std/tar.zig+8-26
...@@ -115,9 +115,10 @@ pub const Header = struct {...@@ -115,9 +115,10 @@ pub const Header = struct {
115115
116 /// Includes prefix concatenated, if any.116 /// Includes prefix concatenated, if any.
117 /// TODO: check against "../" and other nefarious things117 /// TODO: check against "../" and other nefarious things
118 pub fn fullName(header: Header, buffer: *[MAX_NAME_SIZE]u8) ![]const u8 {118 pub fn fullName(header: Header, buffer: []u8) ![]const u8 {
119 const n = name(header);119 const n = name(header);
120 const p = prefix(header);120 const p = prefix(header);
121 if (buffer.len < n.len + p.len + 1) return error.TarInsufficientBuffer;
121 if (!is_ustar(header) or p.len == 0) {122 if (!is_ustar(header) or p.len == 0) {
122 @memcpy(buffer[0..n.len], n);123 @memcpy(buffer[0..n.len], n);
123 return buffer[0..n.len];124 return buffer[0..n.len];
...@@ -130,11 +131,12 @@ pub const Header = struct {...@@ -130,11 +131,12 @@ pub const Header = struct {
130131
131 /// When kind is symbolic_link linked-to name (target_path) is specified in132 /// When kind is symbolic_link linked-to name (target_path) is specified in
132 /// the linkname field.133 /// the linkname field.
133 pub fn linkName(header: Header, buffer: *[LINK_NAME_SIZE]u8) []const u8 {134 pub fn linkName(header: Header, buffer: []u8) ![]const u8 {
134 const link_name = header.str(157, 100);135 const link_name = header.str(157, 100);
135 if (link_name.len == 0) {136 if (link_name.len == 0) {
136 return buffer[0..0];137 return buffer[0..0];
137 }138 }
139 if (buffer.len < link_name.len) return error.TarInsufficientBuffer;
138 const buf = buffer[0..link_name.len];140 const buf = buffer[0..link_name.len];
139 @memcpy(buf, link_name);141 @memcpy(buf, link_name);
140 return buf;142 return buf;
...@@ -248,13 +250,7 @@ pub const IteratorOptions = struct {...@@ -248,13 +250,7 @@ pub const IteratorOptions = struct {
248250
249/// Iterates over files in tar archive.251/// Iterates over files in tar archive.
250/// `next` returns each file in `reader` tar archive.252/// `next` returns each file in `reader` tar archive.
251/// Provided buffers should be at least 256 bytes for file_name and 100 bytes253pub fn iterator(reader: anytype, options: IteratorOptions) Iterator(@TypeOf(reader)) {
252/// for link_name.
253pub fn iterator(reader: anytype, options: IteratorOptions) !Iterator(@TypeOf(reader)) {
254 if (options.file_name_buffer.len < Header.MAX_NAME_SIZE or
255 options.link_name_buffer.len < Header.LINK_NAME_SIZE)
256 return error.TarInsufficientBuffer;
257
258 return .{254 return .{
259 .reader = reader,255 .reader = reader,
260 .diagnostics = options.diagnostics,256 .diagnostics = options.diagnostics,
...@@ -372,10 +368,10 @@ fn Iterator(comptime ReaderType: type) type {...@@ -372,10 +368,10 @@ fn Iterator(comptime ReaderType: type) type {
372 self.file.size = size;368 self.file.size = size;
373 }369 }
374 if (self.file.link_name.len == 0) {370 if (self.file.link_name.len == 0) {
375 self.file.link_name = header.linkName(self.link_name_buffer[0..Header.LINK_NAME_SIZE]);371 self.file.link_name = try header.linkName(self.link_name_buffer);
376 }372 }
377 if (self.file.name.len == 0) {373 if (self.file.name.len == 0) {
378 self.file.name = try header.fullName(self.file_name_buffer[0..Header.MAX_NAME_SIZE]);374 self.file.name = try header.fullName(self.file_name_buffer);
379 }375 }
380376
381 self.padding = blockPadding(self.file.size);377 self.padding = blockPadding(self.file.size);
...@@ -565,7 +561,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi...@@ -565,7 +561,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
565561
566 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;562 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
567 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;563 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
568 var iter = try iterator(reader, .{564 var iter = iterator(reader, .{
569 .file_name_buffer = &file_name_buffer,565 .file_name_buffer = &file_name_buffer,
570 .link_name_buffer = &link_name_buffer,566 .link_name_buffer = &link_name_buffer,
571 .diagnostics = options.diagnostics,567 .diagnostics = options.diagnostics,
...@@ -871,17 +867,3 @@ test "create file and symlink" {...@@ -871,17 +867,3 @@ test "create file and symlink" {
871 _ = try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");867 _ = try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
872 _ = try createDirAndFile(root.dir, "g/h/i/file4");868 _ = try createDirAndFile(root.dir, "g/h/i/file4");
873}869}
874
875test "insufficient buffer for iterator" {
876 var file_name_buffer: [10]u8 = undefined;
877 var link_name_buffer: [10]u8 = undefined;
878
879 var fsb = std.io.fixedBufferStream("");
880 try std.testing.expectError(
881 error.TarInsufficientBuffer,
882 iterator(fsb.reader(), .{
883 .file_name_buffer = &file_name_buffer,
884 .link_name_buffer = &link_name_buffer,
885 }),
886 );
887}
lib/std/tar/test.zig+312-288
...@@ -2,333 +2,352 @@ const std = @import("std");...@@ -2,333 +2,352 @@ const std = @import("std");
2const tar = @import("../tar.zig");2const tar = @import("../tar.zig");
3const testing = std.testing;3const testing = std.testing;
44
5test "run 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.Header.Kind = .normal,
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 = .symbolic_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 = .normal,
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 = .normal,
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 = .normal,
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 = .normal,
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 = .symbolic_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 = .symbolic_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.TarInsufficientBuffer,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
329 for (cases) |case| {348 for (cases) |case| {
330 var fsb = std.io.fixedBufferStream(case.data);349 var fsb = std.io.fixedBufferStream(case.data);
331 var iter = try tar.iterator(fsb.reader(), .{350 var iter = tar.iterator(fsb.reader(), .{
332 .file_name_buffer = &file_name_buffer,351 .file_name_buffer = &file_name_buffer,
333 .link_name_buffer = &link_name_buffer,352 .link_name_buffer = &link_name_buffer,
334 });353 });
...@@ -359,6 +378,10 @@ test "run test cases" {...@@ -359,6 +378,10 @@ test "run test cases" {
359 }378 }
360 try testing.expectEqual(case.files.len, i);379 try testing.expectEqual(case.files.len, i);
361 }380 }
381}
382
383test "pax/gnu long names with small buffer" {
384 // should fail with insufficient buffer error
362385
363 var min_file_name_buffer: [tar.Header.MAX_NAME_SIZE]u8 = undefined;386 var min_file_name_buffer: [tar.Header.MAX_NAME_SIZE]u8 = undefined;
364 var min_link_name_buffer: [tar.Header.LINK_NAME_SIZE]u8 = undefined;387 var min_link_name_buffer: [tar.Header.LINK_NAME_SIZE]u8 = undefined;
...@@ -366,7 +389,7 @@ test "run test cases" {...@@ -366,7 +389,7 @@ test "run test cases" {
366389
367 for (long_name_cases) |case| {390 for (long_name_cases) |case| {
368 var fsb = std.io.fixedBufferStream(case.data);391 var fsb = std.io.fixedBufferStream(case.data);
369 var iter = try tar.iterator(fsb.reader(), .{392 var iter = tar.iterator(fsb.reader(), .{
370 .file_name_buffer = &min_file_name_buffer,393 .file_name_buffer = &min_file_name_buffer,
371 .link_name_buffer = &min_link_name_buffer,394 .link_name_buffer = &min_link_name_buffer,
372 });395 });
...@@ -382,24 +405,25 @@ test "run test cases" {...@@ -382,24 +405,25 @@ test "run test cases" {
382 }405 }
383}406}
384407
385// used in test to calculate file chksum408test "insufficient buffer in Header name filed" {
386const Md5Writer = struct {409 var min_file_name_buffer: [9]u8 = undefined;
387 h: std.crypto.hash.Md5 = std.crypto.hash.Md5.init(.{}),410 var min_link_name_buffer: [tar.Header.LINK_NAME_SIZE]u8 = undefined;
388411
389 pub fn writeAll(self: *Md5Writer, buf: []const u8) !void {412 var fsb = std.io.fixedBufferStream(cases[0].data);
390 self.h.update(buf);413 var iter = tar.iterator(fsb.reader(), .{
391 }414 .file_name_buffer = &min_file_name_buffer,
415 .link_name_buffer = &min_link_name_buffer,
416 });
392417
393 pub fn writeByte(self: *Md5Writer, byte: u8) !void {418 var iter_err: ?anyerror = null;
394 self.h.update(&[_]u8{byte});419 while (iter.next() catch |err| brk: {
395 }420 iter_err = err;
421 break :brk null;
422 }) |_| {}
396423
397 pub fn chksum(self: *Md5Writer) [32]u8 {424 try testing.expect(iter_err != null);
398 var s = [_]u8{0} ** 16;425 try testing.expectEqual(error.TarInsufficientBuffer, iter_err.?);
399 self.h.final(&s);426}
400 return std.fmt.bytesToHex(s, .lower);
401 }
402};
403427
404test "should not overwrite existing file" {428test "should not overwrite existing file" {
405 // Starting from this folder structure:429 // Starting from this folder structure: