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 {
115115
116116 /// Includes prefix concatenated, if any.
117117 /// 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 {
119119 const n = name(header);
120120 const p = prefix(header);
121 if (buffer.len < n.len + p.len + 1) return error.TarInsufficientBuffer;
121122 if (!is_ustar(header) or p.len == 0) {
122123 @memcpy(buffer[0..n.len], n);
123124 return buffer[0..n.len];
......@@ -130,11 +131,12 @@ pub const Header = struct {
130131
131132 /// When kind is symbolic_link linked-to name (target_path) is specified in
132133 /// 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 {
134135 const link_name = header.str(157, 100);
135136 if (link_name.len == 0) {
136137 return buffer[0..0];
137138 }
139 if (buffer.len < link_name.len) return error.TarInsufficientBuffer;
138140 const buf = buffer[0..link_name.len];
139141 @memcpy(buf, link_name);
140142 return buf;
......@@ -248,13 +250,7 @@ pub const IteratorOptions = struct {
248250
249251/// Iterates over files in tar archive.
250252/// `next` returns each file in `reader` tar archive.
251/// Provided buffers should be at least 256 bytes for file_name and 100 bytes
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
253pub fn iterator(reader: anytype, options: IteratorOptions) Iterator(@TypeOf(reader)) {
258254 return .{
259255 .reader = reader,
260256 .diagnostics = options.diagnostics,
......@@ -372,10 +368,10 @@ fn Iterator(comptime ReaderType: type) type {
372368 self.file.size = size;
373369 }
374370 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);
376372 }
377373 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);
379375 }
380376
381377 self.padding = blockPadding(self.file.size);
......@@ -565,7 +561,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
565561
566562 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
567563 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
568 var iter = try iterator(reader, .{
564 var iter = iterator(reader, .{
569565 .file_name_buffer = &file_name_buffer,
570566 .link_name_buffer = &link_name_buffer,
571567 .diagnostics = options.diagnostics,
......@@ -871,17 +867,3 @@ test "create file and symlink" {
871867 _ = try createDirAndSymlink(root.dir, "../../../g/h/i/file4", "j/k/l/symlink3");
872868 _ = try createDirAndFile(root.dir, "g/h/i/file4");
873869}
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");
22const tar = @import("../tar.zig");
33const testing = std.testing;
44
5test "run test cases" {
6 const Case = struct {
7 const File = struct {
8 name: []const u8,
9 size: u64 = 0,
10 mode: u32 = 0,
11 link_name: []const u8 = &[0]u8{},
12 kind: tar.Header.Kind = .normal,
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
5const Case = struct {
6 const File = struct {
7 name: []const u8,
8 size: u64 = 0,
9 mode: u32 = 0,
10 link_name: []const u8 = &[0]u8{},
11 kind: tar.Header.Kind = .normal,
12 truncated: bool = false, // when there is no file body, just header, usefull for huge files
2013 };
2114
22 const cases = [_]Case{
23 .{
24 .data = @embedFile("testdata/gnu.tar"),
25 .files = &[_]Case.File{
26 .{
27 .name = "small.txt",
28 .size = 5,
29 .mode = 0o640,
30 },
31 .{
32 .name = "small2.txt",
33 .size = 11,
34 .mode = 0o640,
35 },
15 data: []const u8, // testdata file content
16 files: []const File = &[_]@This().File{}, // expected files to found in archive
17 chksums: []const []const u8 = &[_][]const u8{}, // chksums of each file content
18 err: ?anyerror = null, // parsing should fail with this error
19};
20
21const cases = [_]Case{
22 .{
23 .data = @embedFile("testdata/gnu.tar"),
24 .files = &[_]Case.File{
25 .{
26 .name = "small.txt",
27 .size = 5,
28 .mode = 0o640,
3629 },
37 .chksums = &[_][]const u8{
38 "e38b27eaccb4391bdec553a7f3ae6b2f",
39 "c65bd2e50a56a2138bf1716f2fd56fe9",
30 .{
31 .name = "small2.txt",
32 .size = 11,
33 .mode = 0o640,
4034 },
4135 },
42 .{
43 .data = @embedFile("testdata/sparse-formats.tar"),
44 .err = error.TarUnsupportedHeader,
36 .chksums = &[_][]const u8{
37 "e38b27eaccb4391bdec553a7f3ae6b2f",
38 "c65bd2e50a56a2138bf1716f2fd56fe9",
4539 },
46 .{
47 .data = @embedFile("testdata/star.tar"),
48 .files = &[_]Case.File{
49 .{
50 .name = "small.txt",
51 .size = 5,
52 .mode = 0o640,
53 },
54 .{
55 .name = "small2.txt",
56 .size = 11,
57 .mode = 0o640,
58 },
40 },
41 .{
42 .data = @embedFile("testdata/sparse-formats.tar"),
43 .err = error.TarUnsupportedHeader,
44 },
45 .{
46 .data = @embedFile("testdata/star.tar"),
47 .files = &[_]Case.File{
48 .{
49 .name = "small.txt",
50 .size = 5,
51 .mode = 0o640,
5952 },
60 .chksums = &[_][]const u8{
61 "e38b27eaccb4391bdec553a7f3ae6b2f",
62 "c65bd2e50a56a2138bf1716f2fd56fe9",
53 .{
54 .name = "small2.txt",
55 .size = 11,
56 .mode = 0o640,
6357 },
6458 },
65 .{
66 .data = @embedFile("testdata/v7.tar"),
67 .files = &[_]Case.File{
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 },
59 .chksums = &[_][]const u8{
60 "e38b27eaccb4391bdec553a7f3ae6b2f",
61 "c65bd2e50a56a2138bf1716f2fd56fe9",
8362 },
84 .{
85 .data = @embedFile("testdata/pax.tar"),
86 .files = &[_]Case.File{
87 .{
88 .name = "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
89 .size = 7,
90 .mode = 0o664,
91 },
92 .{
93 .name = "a/b",
94 .size = 0,
95 .kind = .symbolic_link,
96 .mode = 0o777,
97 .link_name = "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
98 },
63 },
64 .{
65 .data = @embedFile("testdata/v7.tar"),
66 .files = &[_]Case.File{
67 .{
68 .name = "small.txt",
69 .size = 5,
70 .mode = 0o444,
9971 },
100 .chksums = &[_][]const u8{
101 "3c382e8f5b6631aa2db52643912ffd4a",
72 .{
73 .name = "small2.txt",
74 .size = 11,
75 .mode = 0o444,
10276 },
10377 },
104 .{
105 // pax attribute don't end with \n
106 .data = @embedFile("testdata/pax-bad-hdr-file.tar"),
107 .err = error.PaxInvalidAttributeEnd,
78 .chksums = &[_][]const u8{
79 "e38b27eaccb4391bdec553a7f3ae6b2f",
80 "c65bd2e50a56a2138bf1716f2fd56fe9",
10881 },
109 .{
110 // size is in pax attribute
111 .data = @embedFile("testdata/pax-pos-size-file.tar"),
112 .files = &[_]Case.File{
113 .{
114 .name = "foo",
115 .size = 999,
116 .kind = .normal,
117 .mode = 0o640,
118 },
82 },
83 .{
84 .data = @embedFile("testdata/pax.tar"),
85 .files = &[_]Case.File{
86 .{
87 .name = "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
88 .size = 7,
89 .mode = 0o664,
11990 },
120 .chksums = &[_][]const u8{
121 "0afb597b283fe61b5d4879669a350556",
91 .{
92 .name = "a/b",
93 .size = 0,
94 .kind = .symbolic_link,
95 .mode = 0o777,
96 .link_name = "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
12297 },
12398 },
124 .{
125 // has pax records which we are not interested in
126 .data = @embedFile("testdata/pax-records.tar"),
127 .files = &[_]Case.File{
128 .{
129 .name = "file",
130 },
99 .chksums = &[_][]const u8{
100 "3c382e8f5b6631aa2db52643912ffd4a",
101 },
102 },
103 .{
104 // pax attribute don't end with \n
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,
131117 },
132118 },
133 .{
134 // has global records which we are ignoring
135 .data = @embedFile("testdata/pax-global-records.tar"),
136 .files = &[_]Case.File{
137 .{
138 .name = "file1",
139 },
140 .{
141 .name = "file2",
142 },
143 .{
144 .name = "file3",
145 },
146 .{
147 .name = "file4",
148 },
119 .chksums = &[_][]const u8{
120 "0afb597b283fe61b5d4879669a350556",
121 },
122 },
123 .{
124 // has pax records which we are not interested in
125 .data = @embedFile("testdata/pax-records.tar"),
126 .files = &[_]Case.File{
127 .{
128 .name = "file",
149129 },
150130 },
151 .{
152 .data = @embedFile("testdata/nil-uid.tar"),
153 .files = &[_]Case.File{
154 .{
155 .name = "P1050238.JPG.log",
156 .size = 14,
157 .kind = .normal,
158 .mode = 0o664,
159 },
131 },
132 .{
133 // has global records which we are ignoring
134 .data = @embedFile("testdata/pax-global-records.tar"),
135 .files = &[_]Case.File{
136 .{
137 .name = "file1",
160138 },
161 .chksums = &[_][]const u8{
162 "08d504674115e77a67244beac19668f5",
139 .{
140 .name = "file2",
163141 },
164 },
165 .{
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 },
142 .{
143 .name = "file3",
181144 },
182 .chksums = &[_][]const u8{
183 "e38b27eaccb4391bdec553a7f3ae6b2f",
184 "c65bd2e50a56a2138bf1716f2fd56fe9",
145 .{
146 .name = "file4",
185147 },
186148 },
187 .{
188 .data = @embedFile("testdata/gnu-multi-hdrs.tar"),
189 .files = &[_]Case.File{
190 .{
191 .name = "GNU2/GNU2/long-path-name",
192 .link_name = "GNU4/GNU4/long-linkpath-name",
193 .kind = .symbolic_link,
194 },
149 },
150 .{
151 .data = @embedFile("testdata/nil-uid.tar"),
152 .files = &[_]Case.File{
153 .{
154 .name = "P1050238.JPG.log",
155 .size = 14,
156 .kind = .normal,
157 .mode = 0o664,
195158 },
196159 },
197 .{
198 // has gnu type D (directory) and S (sparse) blocks
199 .data = @embedFile("testdata/gnu-incremental.tar"),
200 .err = error.TarUnsupportedHeader,
160 .chksums = &[_][]const u8{
161 "08d504674115e77a67244beac19668f5",
201162 },
202 .{
203 // should use values only from last pax header
204 .data = @embedFile("testdata/pax-multi-hdrs.tar"),
205 .files = &[_]Case.File{
206 .{
207 .name = "bar",
208 .link_name = "PAX4/PAX4/long-linkpath-name",
209 .kind = .symbolic_link,
210 },
163 },
164 .{
165 // has xattrs and pax records which we are ignoring
166 .data = @embedFile("testdata/xattrs.tar"),
167 .files = &[_]Case.File{
168 .{
169 .name = "small.txt",
170 .size = 5,
171 .kind = .normal,
172 .mode = 0o644,
211173 },
212 },
213 .{
214 .data = @embedFile("testdata/gnu-long-nul.tar"),
215 .files = &[_]Case.File{
216 .{
217 .name = "0123456789",
218 .mode = 0o644,
219 },
174 .{
175 .name = "small2.txt",
176 .size = 11,
177 .kind = .normal,
178 .mode = 0o644,
220179 },
221180 },
222 .{
223 .data = @embedFile("testdata/gnu-utf8.tar"),
224 .files = &[_]Case.File{
225 .{
226 .name = "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
227 .mode = 0o644,
228 },
229 },
181 .chksums = &[_][]const u8{
182 "e38b27eaccb4391bdec553a7f3ae6b2f",
183 "c65bd2e50a56a2138bf1716f2fd56fe9",
230184 },
231 .{
232 .data = @embedFile("testdata/gnu-not-utf8.tar"),
233 .files = &[_]Case.File{
234 .{
235 .name = "hi\x80\x81\x82\x83bye",
236 .mode = 0o644,
237 },
185 },
186 .{
187 .data = @embedFile("testdata/gnu-multi-hdrs.tar"),
188 .files = &[_]Case.File{
189 .{
190 .name = "GNU2/GNU2/long-path-name",
191 .link_name = "GNU4/GNU4/long-linkpath-name",
192 .kind = .symbolic_link,
238193 },
239194 },
240 .{
241 // null in pax key
242 .data = @embedFile("testdata/pax-nul-xattrs.tar"),
243 .err = error.PaxNullInKeyword,
244 },
245 .{
246 .data = @embedFile("testdata/pax-nul-path.tar"),
247 .err = error.PaxNullInValue,
248 },
249 .{
250 .data = @embedFile("testdata/neg-size.tar"),
251 .err = error.TarHeader,
252 },
253 .{
254 .data = @embedFile("testdata/issue10968.tar"),
255 .err = error.TarHeader,
256 },
257 .{
258 .data = @embedFile("testdata/issue11169.tar"),
259 .err = error.TarHeader,
195 },
196 .{
197 // has gnu type D (directory) and S (sparse) blocks
198 .data = @embedFile("testdata/gnu-incremental.tar"),
199 .err = error.TarUnsupportedHeader,
200 },
201 .{
202 // should use values only from last pax header
203 .data = @embedFile("testdata/pax-multi-hdrs.tar"),
204 .files = &[_]Case.File{
205 .{
206 .name = "bar",
207 .link_name = "PAX4/PAX4/long-linkpath-name",
208 .kind = .symbolic_link,
209 },
260210 },
261 .{
262 .data = @embedFile("testdata/issue12435.tar"),
263 .err = error.TarHeaderChksum,
211 },
212 .{
213 .data = @embedFile("testdata/gnu-long-nul.tar"),
214 .files = &[_]Case.File{
215 .{
216 .name = "0123456789",
217 .mode = 0o644,
218 },
264219 },
265 .{
266 // has magic with space at end instead of null
267 .data = @embedFile("testdata/invalid-go17.tar"),
268 .files = &[_]Case.File{
269 .{
270 .name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/foo",
271 },
220 },
221 .{
222 .data = @embedFile("testdata/gnu-utf8.tar"),
223 .files = &[_]Case.File{
224 .{
225 .name = "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
226 .mode = 0o644,
272227 },
273228 },
274 .{
275 .data = @embedFile("testdata/ustar-file-devs.tar"),
276 .files = &[_]Case.File{
277 .{
278 .name = "file",
279 .mode = 0o644,
280 },
229 },
230 .{
231 .data = @embedFile("testdata/gnu-not-utf8.tar"),
232 .files = &[_]Case.File{
233 .{
234 .name = "hi\x80\x81\x82\x83bye",
235 .mode = 0o644,
281236 },
282237 },
283 .{
284 .data = @embedFile("testdata/trailing-slash.tar"),
285 .files = &[_]Case.File{
286 .{
287 .name = "123456789/" ** 30,
288 .kind = .directory,
289 },
238 },
239 .{
240 // null in pax key
241 .data = @embedFile("testdata/pax-nul-xattrs.tar"),
242 .err = error.PaxNullInKeyword,
243 },
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",
290270 },
291271 },
292 .{
293 // Has size in gnu extended format. To represent size bigger than 8 GB.
294 .data = @embedFile("testdata/writer-big.tar"),
295 .files = &[_]Case.File{
296 .{
297 .name = "tmp/16gig.txt",
298 .size = 16 * 1024 * 1024 * 1024,
299 .truncated = true,
300 .mode = 0o640,
301 },
272 },
273 .{
274 .data = @embedFile("testdata/ustar-file-devs.tar"),
275 .files = &[_]Case.File{
276 .{
277 .name = "file",
278 .mode = 0o644,
302279 },
303280 },
304 .{
305 // Size in gnu extended format, and name in pax attribute.
306 .data = @embedFile("testdata/writer-big-long.tar"),
307 .files = &[_]Case.File{
308 .{
309 .name = "longname/" ** 15 ++ "16gig.txt",
310 .size = 16 * 1024 * 1024 * 1024,
311 .mode = 0o644,
312 .truncated = true,
313 },
281 },
282 .{
283 .data = @embedFile("testdata/trailing-slash.tar"),
284 .files = &[_]Case.File{
285 .{
286 .name = "123456789/" ** 30,
287 .kind = .directory,
314288 },
315289 },
316 .{
317 .data = @embedFile("testdata/fuzz1.tar"),
318 .err = error.TarInsufficientBuffer,
290 },
291 .{
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 },
319301 },
320 .{
321 .data = @embedFile("testdata/fuzz2.tar"),
322 .err = error.PaxSizeAttrOverflow,
302 },
303 .{
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 },
323313 },
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" {
326345 var file_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
327346 var link_name_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;
328347
329348 for (cases) |case| {
330349 var fsb = std.io.fixedBufferStream(case.data);
331 var iter = try tar.iterator(fsb.reader(), .{
350 var iter = tar.iterator(fsb.reader(), .{
332351 .file_name_buffer = &file_name_buffer,
333352 .link_name_buffer = &link_name_buffer,
334353 });
......@@ -359,6 +378,10 @@ test "run test cases" {
359378 }
360379 try testing.expectEqual(case.files.len, i);
361380 }
381}
382
383test "pax/gnu long names with small buffer" {
384 // should fail with insufficient buffer error
362385
363386 var min_file_name_buffer: [tar.Header.MAX_NAME_SIZE]u8 = undefined;
364387 var min_link_name_buffer: [tar.Header.LINK_NAME_SIZE]u8 = undefined;
......@@ -366,7 +389,7 @@ test "run test cases" {
366389
367390 for (long_name_cases) |case| {
368391 var fsb = std.io.fixedBufferStream(case.data);
369 var iter = try tar.iterator(fsb.reader(), .{
392 var iter = tar.iterator(fsb.reader(), .{
370393 .file_name_buffer = &min_file_name_buffer,
371394 .link_name_buffer = &min_link_name_buffer,
372395 });
......@@ -382,24 +405,25 @@ test "run test cases" {
382405 }
383406}
384407
385// used in test to calculate file chksum
386const Md5Writer = struct {
387 h: std.crypto.hash.Md5 = std.crypto.hash.Md5.init(.{}),
408test "insufficient buffer in Header name filed" {
409 var min_file_name_buffer: [9]u8 = undefined;
410 var min_link_name_buffer: [tar.Header.LINK_NAME_SIZE]u8 = undefined;
388411
389 pub fn writeAll(self: *Md5Writer, buf: []const u8) !void {
390 self.h.update(buf);
391 }
412 var fsb = std.io.fixedBufferStream(cases[0].data);
413 var iter = tar.iterator(fsb.reader(), .{
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 {
394 self.h.update(&[_]u8{byte});
395 }
418 var iter_err: ?anyerror = null;
419 while (iter.next() catch |err| brk: {
420 iter_err = err;
421 break :brk null;
422 }) |_| {}
396423
397 pub fn chksum(self: *Md5Writer) [32]u8 {
398 var s = [_]u8{0} ** 16;
399 self.h.final(&s);
400 return std.fmt.bytesToHex(s, .lower);
401 }
402};
424 try testing.expect(iter_err != null);
425 try testing.expectEqual(error.TarInsufficientBuffer, iter_err.?);
426}
403427
404428test "should not overwrite existing file" {
405429 // Starting from this folder structure: