Source file
src/archive/tar/reader_test.go
1
2
3
4
5 package tar
6
7 import (
8 "bytes"
9 "compress/bzip2"
10 "errors"
11 "fmt"
12 "hash/crc32"
13 "internal/obscuretestdata"
14 "io"
15 "maps"
16 "math"
17 "os"
18 "path"
19 "reflect"
20 "slices"
21 "strconv"
22 "strings"
23 "testing"
24 "time"
25 )
26
27 func TestReader(t *testing.T) {
28 vectors := []struct {
29 file string
30 obscured bool
31 headers []*Header
32 chksums []string
33 err error
34 }{{
35 file: "testdata/gnu.tar",
36 headers: []*Header{{
37 Name: "small.txt",
38 Mode: 0640,
39 Uid: 73025,
40 Gid: 5000,
41 Size: 5,
42 ModTime: time.Unix(1244428340, 0),
43 Typeflag: '0',
44 Uname: "dsymonds",
45 Gname: "eng",
46 Format: FormatGNU,
47 }, {
48 Name: "small2.txt",
49 Mode: 0640,
50 Uid: 73025,
51 Gid: 5000,
52 Size: 11,
53 ModTime: time.Unix(1244436044, 0),
54 Typeflag: '0',
55 Uname: "dsymonds",
56 Gname: "eng",
57 Format: FormatGNU,
58 }},
59 chksums: []string{
60 "6cbd88fc",
61 "ddac04b3",
62 },
63 }, {
64 file: "testdata/sparse-formats.tar",
65 headers: []*Header{{
66 Name: "sparse-gnu",
67 Mode: 420,
68 Uid: 1000,
69 Gid: 1000,
70 Size: 200,
71 ModTime: time.Unix(1392395740, 0),
72 Typeflag: 0x53,
73 Linkname: "",
74 Uname: "david",
75 Gname: "david",
76 Devmajor: 0,
77 Devminor: 0,
78 Format: FormatGNU,
79 }, {
80 Name: "sparse-posix-0.0",
81 Mode: 420,
82 Uid: 1000,
83 Gid: 1000,
84 Size: 200,
85 ModTime: time.Unix(1392342187, 0),
86 Typeflag: 0x30,
87 Linkname: "",
88 Uname: "david",
89 Gname: "david",
90 Devmajor: 0,
91 Devminor: 0,
92 PAXRecords: map[string]string{
93 "GNU.sparse.size": "200",
94 "GNU.sparse.numblocks": "95",
95 "GNU.sparse.map": "1,1,3,1,5,1,7,1,9,1,11,1,13,1,15,1,17,1,19,1,21,1,23,1,25,1,27,1,29,1,31,1,33,1,35,1,37,1,39,1,41,1,43,1,45,1,47,1,49,1,51,1,53,1,55,1,57,1,59,1,61,1,63,1,65,1,67,1,69,1,71,1,73,1,75,1,77,1,79,1,81,1,83,1,85,1,87,1,89,1,91,1,93,1,95,1,97,1,99,1,101,1,103,1,105,1,107,1,109,1,111,1,113,1,115,1,117,1,119,1,121,1,123,1,125,1,127,1,129,1,131,1,133,1,135,1,137,1,139,1,141,1,143,1,145,1,147,1,149,1,151,1,153,1,155,1,157,1,159,1,161,1,163,1,165,1,167,1,169,1,171,1,173,1,175,1,177,1,179,1,181,1,183,1,185,1,187,1,189,1",
96 },
97 Format: FormatPAX,
98 }, {
99 Name: "sparse-posix-0.1",
100 Mode: 420,
101 Uid: 1000,
102 Gid: 1000,
103 Size: 200,
104 ModTime: time.Unix(1392340456, 0),
105 Typeflag: 0x30,
106 Linkname: "",
107 Uname: "david",
108 Gname: "david",
109 Devmajor: 0,
110 Devminor: 0,
111 PAXRecords: map[string]string{
112 "GNU.sparse.size": "200",
113 "GNU.sparse.numblocks": "95",
114 "GNU.sparse.map": "1,1,3,1,5,1,7,1,9,1,11,1,13,1,15,1,17,1,19,1,21,1,23,1,25,1,27,1,29,1,31,1,33,1,35,1,37,1,39,1,41,1,43,1,45,1,47,1,49,1,51,1,53,1,55,1,57,1,59,1,61,1,63,1,65,1,67,1,69,1,71,1,73,1,75,1,77,1,79,1,81,1,83,1,85,1,87,1,89,1,91,1,93,1,95,1,97,1,99,1,101,1,103,1,105,1,107,1,109,1,111,1,113,1,115,1,117,1,119,1,121,1,123,1,125,1,127,1,129,1,131,1,133,1,135,1,137,1,139,1,141,1,143,1,145,1,147,1,149,1,151,1,153,1,155,1,157,1,159,1,161,1,163,1,165,1,167,1,169,1,171,1,173,1,175,1,177,1,179,1,181,1,183,1,185,1,187,1,189,1",
115 "GNU.sparse.name": "sparse-posix-0.1",
116 },
117 Format: FormatPAX,
118 }, {
119 Name: "sparse-posix-1.0",
120 Mode: 420,
121 Uid: 1000,
122 Gid: 1000,
123 Size: 200,
124 ModTime: time.Unix(1392337404, 0),
125 Typeflag: 0x30,
126 Linkname: "",
127 Uname: "david",
128 Gname: "david",
129 Devmajor: 0,
130 Devminor: 0,
131 PAXRecords: map[string]string{
132 "GNU.sparse.major": "1",
133 "GNU.sparse.minor": "0",
134 "GNU.sparse.realsize": "200",
135 "GNU.sparse.name": "sparse-posix-1.0",
136 },
137 Format: FormatPAX,
138 }, {
139 Name: "end",
140 Mode: 420,
141 Uid: 1000,
142 Gid: 1000,
143 Size: 4,
144 ModTime: time.Unix(1392398319, 0),
145 Typeflag: 0x30,
146 Linkname: "",
147 Uname: "david",
148 Gname: "david",
149 Devmajor: 0,
150 Devminor: 0,
151 Format: FormatGNU,
152 }},
153 chksums: []string{
154 "5375e1d2",
155 "5375e1d2",
156 "5375e1d2",
157 "5375e1d2",
158 "8eb179ba",
159 },
160 }, {
161 file: "testdata/star.tar",
162 headers: []*Header{{
163 Name: "small.txt",
164 Mode: 0640,
165 Uid: 73025,
166 Gid: 5000,
167 Size: 5,
168 ModTime: time.Unix(1244592783, 0),
169 Typeflag: '0',
170 Uname: "dsymonds",
171 Gname: "eng",
172 AccessTime: time.Unix(1244592783, 0),
173 ChangeTime: time.Unix(1244592783, 0),
174 }, {
175 Name: "small2.txt",
176 Mode: 0640,
177 Uid: 73025,
178 Gid: 5000,
179 Size: 11,
180 ModTime: time.Unix(1244592783, 0),
181 Typeflag: '0',
182 Uname: "dsymonds",
183 Gname: "eng",
184 AccessTime: time.Unix(1244592783, 0),
185 ChangeTime: time.Unix(1244592783, 0),
186 }},
187 }, {
188 file: "testdata/v7.tar",
189 headers: []*Header{{
190 Name: "small.txt",
191 Mode: 0444,
192 Uid: 73025,
193 Gid: 5000,
194 Size: 5,
195 ModTime: time.Unix(1244593104, 0),
196 Typeflag: '0',
197 }, {
198 Name: "small2.txt",
199 Mode: 0444,
200 Uid: 73025,
201 Gid: 5000,
202 Size: 11,
203 ModTime: time.Unix(1244593104, 0),
204 Typeflag: '0',
205 }},
206 }, {
207 file: "testdata/pax.tar",
208 headers: []*Header{{
209 Name: "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
210 Mode: 0664,
211 Uid: 1000,
212 Gid: 1000,
213 Uname: "shane",
214 Gname: "shane",
215 Size: 7,
216 ModTime: time.Unix(1350244992, 23960108),
217 ChangeTime: time.Unix(1350244992, 23960108),
218 AccessTime: time.Unix(1350244992, 23960108),
219 Typeflag: TypeReg,
220 PAXRecords: map[string]string{
221 "path": "a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
222 "mtime": "1350244992.023960108",
223 "atime": "1350244992.023960108",
224 "ctime": "1350244992.023960108",
225 },
226 Format: FormatPAX,
227 }, {
228 Name: "a/b",
229 Mode: 0777,
230 Uid: 1000,
231 Gid: 1000,
232 Uname: "shane",
233 Gname: "shane",
234 Size: 0,
235 ModTime: time.Unix(1350266320, 910238425),
236 ChangeTime: time.Unix(1350266320, 910238425),
237 AccessTime: time.Unix(1350266320, 910238425),
238 Typeflag: TypeSymlink,
239 Linkname: "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
240 PAXRecords: map[string]string{
241 "linkpath": "123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100",
242 "mtime": "1350266320.910238425",
243 "atime": "1350266320.910238425",
244 "ctime": "1350266320.910238425",
245 },
246 Format: FormatPAX,
247 }},
248 }, {
249 file: "testdata/pax-bad-hdr-file.tar",
250 err: ErrHeader,
251 }, {
252 file: "testdata/pax-bad-hdr-large.tar.bz2",
253 err: ErrFieldTooLong,
254 }, {
255 file: "testdata/pax-bad-mtime-file.tar",
256 err: ErrHeader,
257 }, {
258 file: "testdata/pax-pos-size-file.tar",
259 headers: []*Header{{
260 Name: "foo",
261 Mode: 0640,
262 Uid: 319973,
263 Gid: 5000,
264 Size: 999,
265 ModTime: time.Unix(1442282516, 0),
266 Typeflag: '0',
267 Uname: "joetsai",
268 Gname: "eng",
269 PAXRecords: map[string]string{
270 "size": "000000000000000000000999",
271 },
272 Format: FormatPAX,
273 }},
274 chksums: []string{
275 "5fd7e86a",
276 },
277 }, {
278 file: "testdata/pax-records.tar",
279 headers: []*Header{{
280 Typeflag: TypeReg,
281 Name: "file",
282 Uname: strings.Repeat("long", 10),
283 ModTime: time.Unix(0, 0),
284 PAXRecords: map[string]string{
285 "GOLANG.pkg": "tar",
286 "comment": "Hello, 世界",
287 "uname": strings.Repeat("long", 10),
288 },
289 Format: FormatPAX,
290 }},
291 }, {
292 file: "testdata/pax-global-records.tar",
293 headers: []*Header{{
294 Typeflag: TypeXGlobalHeader,
295 Name: "global1",
296 PAXRecords: map[string]string{"path": "global1", "mtime": "1500000000.0"},
297 Format: FormatPAX,
298 }, {
299 Typeflag: TypeReg,
300 Name: "file1",
301 ModTime: time.Unix(0, 0),
302 Format: FormatUSTAR,
303 }, {
304 Typeflag: TypeReg,
305 Name: "file2",
306 PAXRecords: map[string]string{"path": "file2"},
307 ModTime: time.Unix(0, 0),
308 Format: FormatPAX,
309 }, {
310 Typeflag: TypeXGlobalHeader,
311 Name: "GlobalHead.0.0",
312 PAXRecords: map[string]string{"path": ""},
313 Format: FormatPAX,
314 }, {
315 Typeflag: TypeReg,
316 Name: "file3",
317 ModTime: time.Unix(0, 0),
318 Format: FormatUSTAR,
319 }, {
320 Typeflag: TypeReg,
321 Name: "file4",
322 ModTime: time.Unix(1400000000, 0),
323 PAXRecords: map[string]string{"mtime": "1400000000"},
324 Format: FormatPAX,
325 }},
326 }, {
327 file: "testdata/nil-uid.tar",
328 headers: []*Header{{
329 Name: "P1050238.JPG.log",
330 Mode: 0664,
331 Uid: 0,
332 Gid: 0,
333 Size: 14,
334 ModTime: time.Unix(1365454838, 0),
335 Typeflag: TypeReg,
336 Linkname: "",
337 Uname: "eyefi",
338 Gname: "eyefi",
339 Devmajor: 0,
340 Devminor: 0,
341 Format: FormatGNU,
342 }},
343 }, {
344 file: "testdata/xattrs.tar",
345 headers: []*Header{{
346 Name: "small.txt",
347 Mode: 0644,
348 Uid: 1000,
349 Gid: 10,
350 Size: 5,
351 ModTime: time.Unix(1386065770, 448252320),
352 Typeflag: '0',
353 Uname: "alex",
354 Gname: "wheel",
355 AccessTime: time.Unix(1389782991, 419875220),
356 ChangeTime: time.Unix(1389782956, 794414986),
357 Xattrs: map[string]string{
358 "user.key": "value",
359 "user.key2": "value2",
360
361 "security.selinux": "unconfined_u:object_r:default_t:s0\x00",
362 },
363 PAXRecords: map[string]string{
364 "mtime": "1386065770.44825232",
365 "atime": "1389782991.41987522",
366 "ctime": "1389782956.794414986",
367 "SCHILY.xattr.user.key": "value",
368 "SCHILY.xattr.user.key2": "value2",
369 "SCHILY.xattr.security.selinux": "unconfined_u:object_r:default_t:s0\x00",
370 },
371 Format: FormatPAX,
372 }, {
373 Name: "small2.txt",
374 Mode: 0644,
375 Uid: 1000,
376 Gid: 10,
377 Size: 11,
378 ModTime: time.Unix(1386065770, 449252304),
379 Typeflag: '0',
380 Uname: "alex",
381 Gname: "wheel",
382 AccessTime: time.Unix(1389782991, 419875220),
383 ChangeTime: time.Unix(1386065770, 449252304),
384 Xattrs: map[string]string{
385 "security.selinux": "unconfined_u:object_r:default_t:s0\x00",
386 },
387 PAXRecords: map[string]string{
388 "mtime": "1386065770.449252304",
389 "atime": "1389782991.41987522",
390 "ctime": "1386065770.449252304",
391 "SCHILY.xattr.security.selinux": "unconfined_u:object_r:default_t:s0\x00",
392 },
393 Format: FormatPAX,
394 }},
395 }, {
396
397 file: "testdata/gnu-multi-hdrs.tar",
398 headers: []*Header{{
399 Name: "GNU2/GNU2/long-path-name",
400 Linkname: "GNU4/GNU4/long-linkpath-name",
401 ModTime: time.Unix(0, 0),
402 Typeflag: '2',
403 Format: FormatGNU,
404 }},
405 }, {
406
407
408
409 file: "testdata/gnu-incremental.tar",
410 headers: []*Header{{
411 Name: "test2/",
412 Mode: 16877,
413 Uid: 1000,
414 Gid: 1000,
415 Size: 14,
416 ModTime: time.Unix(1441973427, 0),
417 Typeflag: 'D',
418 Uname: "rawr",
419 Gname: "dsnet",
420 AccessTime: time.Unix(1441974501, 0),
421 ChangeTime: time.Unix(1441973436, 0),
422 Format: FormatGNU,
423 }, {
424 Name: "test2/foo",
425 Mode: 33188,
426 Uid: 1000,
427 Gid: 1000,
428 Size: 64,
429 ModTime: time.Unix(1441973363, 0),
430 Typeflag: '0',
431 Uname: "rawr",
432 Gname: "dsnet",
433 AccessTime: time.Unix(1441974501, 0),
434 ChangeTime: time.Unix(1441973436, 0),
435 Format: FormatGNU,
436 }, {
437 Name: "test2/sparse",
438 Mode: 33188,
439 Uid: 1000,
440 Gid: 1000,
441 Size: 536870912,
442 ModTime: time.Unix(1441973427, 0),
443 Typeflag: 'S',
444 Uname: "rawr",
445 Gname: "dsnet",
446 AccessTime: time.Unix(1441991948, 0),
447 ChangeTime: time.Unix(1441973436, 0),
448 Format: FormatGNU,
449 }},
450 }, {
451
452 file: "testdata/pax-multi-hdrs.tar",
453 headers: []*Header{{
454 Name: "bar",
455 Linkname: "PAX4/PAX4/long-linkpath-name",
456 ModTime: time.Unix(0, 0),
457 Typeflag: '2',
458 PAXRecords: map[string]string{
459 "linkpath": "PAX4/PAX4/long-linkpath-name",
460 },
461 Format: FormatPAX,
462 }},
463 }, {
464
465
466
467 file: "testdata/gnu-long-nul.tar",
468 headers: []*Header{{
469 Name: "0123456789",
470 Mode: 0644,
471 Uid: 1000,
472 Gid: 1000,
473 ModTime: time.Unix(1486082191, 0),
474 Typeflag: '0',
475 Uname: "rawr",
476 Gname: "dsnet",
477 Format: FormatGNU,
478 }},
479 }, {
480
481
482
483
484
485 file: "testdata/gnu-utf8.tar",
486 headers: []*Header{{
487 Name: "☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹☺☻☹",
488 Mode: 0644,
489 Uid: 1000, Gid: 1000,
490 ModTime: time.Unix(0, 0),
491 Typeflag: '0',
492 Uname: "☺",
493 Gname: "⚹",
494 Format: FormatGNU,
495 }},
496 }, {
497
498
499
500
501
502 file: "testdata/gnu-not-utf8.tar",
503 headers: []*Header{{
504 Name: "hi\x80\x81\x82\x83bye",
505 Mode: 0644,
506 Uid: 1000,
507 Gid: 1000,
508 ModTime: time.Unix(0, 0),
509 Typeflag: '0',
510 Uname: "rawr",
511 Gname: "dsnet",
512 Format: FormatGNU,
513 }},
514 }, {
515
516
517 file: "testdata/pax-nul-xattrs.tar",
518 err: ErrHeader,
519 }, {
520
521
522
523
524
525 file: "testdata/pax-nul-path.tar",
526 err: ErrHeader,
527 }, {
528 file: "testdata/neg-size.tar.base64",
529 obscured: true,
530 err: ErrHeader,
531 }, {
532 file: "testdata/issue10968.tar",
533 err: ErrHeader,
534 }, {
535 file: "testdata/issue11169.tar",
536 err: ErrHeader,
537 }, {
538 file: "testdata/issue12435.tar",
539 err: ErrHeader,
540 }, {
541
542
543 file: "testdata/invalid-go17.tar",
544 headers: []*Header{{
545 Name: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/foo",
546 Uid: 010000000,
547 ModTime: time.Unix(0, 0),
548 Typeflag: '0',
549 }},
550 }, {
551
552 file: "testdata/ustar-file-devs.tar",
553 headers: []*Header{{
554 Name: "file",
555 Mode: 0644,
556 Typeflag: '0',
557 ModTime: time.Unix(0, 0),
558 Devmajor: 1,
559 Devminor: 1,
560 Format: FormatUSTAR,
561 }},
562 }, {
563
564 file: "testdata/gnu-nil-sparse-data.tar",
565 headers: []*Header{{
566 Name: "sparse.db",
567 Typeflag: TypeGNUSparse,
568 Size: 1000,
569 ModTime: time.Unix(0, 0),
570 Format: FormatGNU,
571 }},
572 }, {
573
574 file: "testdata/gnu-nil-sparse-hole.tar",
575 headers: []*Header{{
576 Name: "sparse.db",
577 Typeflag: TypeGNUSparse,
578 Size: 1000,
579 ModTime: time.Unix(0, 0),
580 Format: FormatGNU,
581 }},
582 }, {
583
584 file: "testdata/pax-nil-sparse-data.tar",
585 headers: []*Header{{
586 Name: "sparse.db",
587 Typeflag: TypeReg,
588 Size: 1000,
589 ModTime: time.Unix(0, 0),
590 PAXRecords: map[string]string{
591 "size": "1512",
592 "GNU.sparse.major": "1",
593 "GNU.sparse.minor": "0",
594 "GNU.sparse.realsize": "1000",
595 "GNU.sparse.name": "sparse.db",
596 },
597 Format: FormatPAX,
598 }},
599 }, {
600
601 file: "testdata/pax-nil-sparse-hole.tar",
602 headers: []*Header{{
603 Name: "sparse.db",
604 Typeflag: TypeReg,
605 Size: 1000,
606 ModTime: time.Unix(0, 0),
607 PAXRecords: map[string]string{
608 "size": "512",
609 "GNU.sparse.major": "1",
610 "GNU.sparse.minor": "0",
611 "GNU.sparse.realsize": "1000",
612 "GNU.sparse.name": "sparse.db",
613 },
614 Format: FormatPAX,
615 }},
616 }, {
617 file: "testdata/trailing-slash.tar",
618 headers: []*Header{{
619 Typeflag: TypeDir,
620 Name: strings.Repeat("123456789/", 30),
621 ModTime: time.Unix(0, 0),
622 PAXRecords: map[string]string{
623 "path": strings.Repeat("123456789/", 30),
624 },
625 Format: FormatPAX,
626 }},
627 }, {
628
629
630 file: "testdata/gnu-sparse-many-zeros.tar.bz2",
631 err: errSparseTooLong,
632 }}
633
634 for _, v := range vectors {
635 t.Run(strings.TrimSuffix(path.Base(v.file), ".base64"), func(t *testing.T) {
636 path := v.file
637 if v.obscured {
638 tf, err := obscuretestdata.DecodeToTempFile(path)
639 if err != nil {
640 t.Fatalf("obscuredtestdata.DecodeToTempFile(%s): %v", path, err)
641 }
642 path = tf
643 }
644
645 f, err := os.Open(path)
646 if err != nil {
647 t.Fatalf("unexpected error: %v", err)
648 }
649 defer f.Close()
650
651 var fr io.Reader = f
652 if strings.HasSuffix(v.file, ".bz2") || strings.HasSuffix(v.file, ".bz2.base64") {
653 fr = bzip2.NewReader(fr)
654 }
655
656
657 var (
658 tr = NewReader(fr)
659 hdrs []*Header
660 chksums []string
661 rdbuf = make([]byte, 8)
662 )
663 for {
664 var hdr *Header
665 hdr, err = tr.Next()
666 if err != nil {
667 if err == io.EOF {
668 err = nil
669 }
670 break
671 }
672 hdrs = append(hdrs, hdr)
673
674 if v.chksums == nil {
675 continue
676 }
677 h := crc32.NewIEEE()
678 _, err = io.CopyBuffer(h, tr, rdbuf)
679 if err != nil {
680 break
681 }
682 chksums = append(chksums, fmt.Sprintf("%x", h.Sum(nil)))
683 }
684
685 for i, hdr := range hdrs {
686 if i >= len(v.headers) {
687 t.Fatalf("entry %d: unexpected header:\ngot %+v", i, *hdr)
688 }
689 if !reflect.DeepEqual(*hdr, *v.headers[i]) {
690 t.Fatalf("entry %d: incorrect header:\ngot %+v\nwant %+v", i, *hdr, *v.headers[i])
691 }
692 }
693 if len(hdrs) != len(v.headers) {
694 t.Fatalf("got %d headers, want %d headers", len(hdrs), len(v.headers))
695 }
696
697 for i, sum := range chksums {
698 if i >= len(v.chksums) {
699 t.Fatalf("entry %d: unexpected sum: got %s", i, sum)
700 }
701 if sum != v.chksums[i] {
702 t.Fatalf("entry %d: incorrect checksum: got %s, want %s", i, sum, v.chksums[i])
703 }
704 }
705
706 if err != v.err {
707 t.Fatalf("unexpected error: got %v, want %v", err, v.err)
708 }
709 f.Close()
710 })
711 }
712 }
713
714 func TestPartialRead(t *testing.T) {
715 type testCase struct {
716 cnt int
717 output string
718 }
719 vectors := []struct {
720 file string
721 cases []testCase
722 }{{
723 file: "testdata/gnu.tar",
724 cases: []testCase{
725 {4, "Kilt"},
726 {6, "Google"},
727 },
728 }, {
729 file: "testdata/sparse-formats.tar",
730 cases: []testCase{
731 {2, "\x00G"},
732 {4, "\x00G\x00o"},
733 {6, "\x00G\x00o\x00G"},
734 {8, "\x00G\x00o\x00G\x00o"},
735 {4, "end\n"},
736 },
737 }}
738
739 for _, v := range vectors {
740 t.Run(path.Base(v.file), func(t *testing.T) {
741 f, err := os.Open(v.file)
742 if err != nil {
743 t.Fatalf("Open() error: %v", err)
744 }
745 defer f.Close()
746
747 tr := NewReader(f)
748 for i, tc := range v.cases {
749 hdr, err := tr.Next()
750 if err != nil || hdr == nil {
751 t.Fatalf("entry %d, Next(): got %v, want %v", i, err, nil)
752 }
753 buf := make([]byte, tc.cnt)
754 if _, err := io.ReadFull(tr, buf); err != nil {
755 t.Fatalf("entry %d, ReadFull(): got %v, want %v", i, err, nil)
756 }
757 if string(buf) != tc.output {
758 t.Fatalf("entry %d, ReadFull(): got %q, want %q", i, string(buf), tc.output)
759 }
760 }
761
762 if _, err := tr.Next(); err != io.EOF {
763 t.Fatalf("Next(): got %v, want EOF", err)
764 }
765 })
766 }
767 }
768
769 func TestUninitializedRead(t *testing.T) {
770 f, err := os.Open("testdata/gnu.tar")
771 if err != nil {
772 t.Fatalf("Unexpected error: %v", err)
773 }
774 defer f.Close()
775
776 tr := NewReader(f)
777 _, err = tr.Read([]byte{})
778 if err == nil || err != io.EOF {
779 t.Errorf("Unexpected error: %v, wanted %v", err, io.EOF)
780 }
781
782 }
783
784 type reader struct{ io.Reader }
785 type readSeeker struct{ io.ReadSeeker }
786 type readBadSeeker struct{ io.ReadSeeker }
787
788 func (rbs *readBadSeeker) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("illegal seek") }
789
790
791
792
793 func TestReadTruncation(t *testing.T) {
794 var ss []string
795 for _, p := range []string{
796 "testdata/gnu.tar",
797 "testdata/ustar-file-reg.tar",
798 "testdata/pax-path-hdr.tar",
799 "testdata/sparse-formats.tar",
800 } {
801 buf, err := os.ReadFile(p)
802 if err != nil {
803 t.Fatalf("unexpected error: %v", err)
804 }
805 ss = append(ss, string(buf))
806 }
807
808 data1, data2, pax, sparse := ss[0], ss[1], ss[2], ss[3]
809 data2 += strings.Repeat("\x00", 10*512)
810 trash := strings.Repeat("garbage ", 64)
811
812 vectors := []struct {
813 input string
814 cnt int
815 err error
816 }{
817 {"", 0, io.EOF},
818 {data1[:511], 0, io.ErrUnexpectedEOF},
819 {data1[:512], 1, io.ErrUnexpectedEOF},
820 {data1[:1024], 1, io.EOF},
821 {data1[:1536], 2, io.ErrUnexpectedEOF},
822 {data1[:2048], 2, io.EOF},
823 {data1, 2, io.EOF},
824 {data1[:2048] + data2[:1536], 3, io.EOF},
825 {data2[:511], 0, io.ErrUnexpectedEOF},
826 {data2[:512], 1, io.ErrUnexpectedEOF},
827 {data2[:1195], 1, io.ErrUnexpectedEOF},
828 {data2[:1196], 1, io.EOF},
829 {data2[:1200], 1, io.EOF},
830 {data2[:1535], 1, io.EOF},
831 {data2[:1536], 1, io.EOF},
832 {data2[:1536] + trash[:1], 1, io.ErrUnexpectedEOF},
833 {data2[:1536] + trash[:511], 1, io.ErrUnexpectedEOF},
834 {data2[:1536] + trash, 1, ErrHeader},
835 {data2[:2048], 1, io.EOF},
836 {data2[:2048] + trash[:1], 1, io.ErrUnexpectedEOF},
837 {data2[:2048] + trash[:511], 1, io.ErrUnexpectedEOF},
838 {data2[:2048] + trash, 1, ErrHeader},
839 {data2[:2560], 1, io.EOF},
840 {data2[:2560] + trash[:1], 1, io.EOF},
841 {data2[:2560] + trash[:511], 1, io.EOF},
842 {data2[:2560] + trash, 1, io.EOF},
843 {data2[:3072], 1, io.EOF},
844 {pax, 0, io.EOF},
845 {pax + trash[:1], 0, io.ErrUnexpectedEOF},
846 {pax + trash[:511], 0, io.ErrUnexpectedEOF},
847 {sparse[:511], 0, io.ErrUnexpectedEOF},
848 {sparse[:512], 0, io.ErrUnexpectedEOF},
849 {sparse[:3584], 1, io.EOF},
850 {sparse[:9200], 1, io.EOF},
851 {sparse[:9216], 1, io.EOF},
852 {sparse[:9728], 2, io.ErrUnexpectedEOF},
853 {sparse[:10240], 2, io.EOF},
854 {sparse[:11264], 2, io.ErrUnexpectedEOF},
855 {sparse, 5, io.EOF},
856 {sparse + trash, 5, io.EOF},
857 }
858
859 for i, v := range vectors {
860 for j := 0; j < 6; j++ {
861 var tr *Reader
862 var s1, s2 string
863
864 switch j {
865 case 0:
866 tr = NewReader(&reader{strings.NewReader(v.input)})
867 s1, s2 = "io.Reader", "auto"
868 case 1:
869 tr = NewReader(&reader{strings.NewReader(v.input)})
870 s1, s2 = "io.Reader", "manual"
871 case 2:
872 tr = NewReader(&readSeeker{strings.NewReader(v.input)})
873 s1, s2 = "io.ReadSeeker", "auto"
874 case 3:
875 tr = NewReader(&readSeeker{strings.NewReader(v.input)})
876 s1, s2 = "io.ReadSeeker", "manual"
877 case 4:
878 tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
879 s1, s2 = "ReadBadSeeker", "auto"
880 case 5:
881 tr = NewReader(&readBadSeeker{strings.NewReader(v.input)})
882 s1, s2 = "ReadBadSeeker", "manual"
883 }
884
885 var cnt int
886 var err error
887 for {
888 if _, err = tr.Next(); err != nil {
889 break
890 }
891 cnt++
892 if s2 == "manual" {
893 if _, err = tr.writeTo(io.Discard); err != nil {
894 break
895 }
896 }
897 }
898 if err != v.err {
899 t.Errorf("test %d, NewReader(%s) with %s discard: got %v, want %v",
900 i, s1, s2, err, v.err)
901 }
902 if cnt != v.cnt {
903 t.Errorf("test %d, NewReader(%s) with %s discard: got %d headers, want %d headers",
904 i, s1, s2, cnt, v.cnt)
905 }
906 }
907 }
908 }
909
910
911
912 func TestReadHeaderOnly(t *testing.T) {
913 f, err := os.Open("testdata/hdr-only.tar")
914 if err != nil {
915 t.Fatalf("unexpected error: %v", err)
916 }
917 defer f.Close()
918
919 var hdrs []*Header
920 tr := NewReader(f)
921 for {
922 hdr, err := tr.Next()
923 if err == io.EOF {
924 break
925 }
926 if err != nil {
927 t.Errorf("Next(): got %v, want %v", err, nil)
928 continue
929 }
930 hdrs = append(hdrs, hdr)
931
932
933 cnt, _ := io.ReadFull(tr, []byte{0})
934 if cnt > 0 && hdr.Typeflag != TypeReg {
935 t.Errorf("ReadFull(...): got %d bytes, want 0 bytes", cnt)
936 }
937 }
938
939
940
941 if len(hdrs) != 16 {
942 t.Fatalf("len(hdrs): got %d, want %d", len(hdrs), 16)
943 }
944 for i := 0; i < 8; i++ {
945 hdr1, hdr2 := hdrs[i+0], hdrs[i+8]
946 hdr1.Size, hdr2.Size = 0, 0
947 if !reflect.DeepEqual(*hdr1, *hdr2) {
948 t.Errorf("incorrect header:\ngot %+v\nwant %+v", *hdr1, *hdr2)
949 }
950 }
951 }
952
953 func TestMergePAX(t *testing.T) {
954 vectors := []struct {
955 in map[string]string
956 want *Header
957 ok bool
958 }{{
959 in: map[string]string{
960 "path": "a/b/c",
961 "uid": "1000",
962 "mtime": "1350244992.023960108",
963 },
964 want: &Header{
965 Name: "a/b/c",
966 Uid: 1000,
967 ModTime: time.Unix(1350244992, 23960108),
968 PAXRecords: map[string]string{
969 "path": "a/b/c",
970 "uid": "1000",
971 "mtime": "1350244992.023960108",
972 },
973 },
974 ok: true,
975 }, {
976 in: map[string]string{
977 "gid": "gtgergergersagersgers",
978 },
979 ok: false,
980 }, {
981 in: map[string]string{
982 "missing": "missing",
983 "SCHILY.xattr.key": "value",
984 },
985 want: &Header{
986 Xattrs: map[string]string{"key": "value"},
987 PAXRecords: map[string]string{
988 "missing": "missing",
989 "SCHILY.xattr.key": "value",
990 },
991 },
992 ok: true,
993 }}
994
995 for i, v := range vectors {
996 got := new(Header)
997 err := mergePAX(got, v.in)
998 if v.ok && !reflect.DeepEqual(*got, *v.want) {
999 t.Errorf("test %d, mergePAX(...):\ngot %+v\nwant %+v", i, *got, *v.want)
1000 }
1001 if ok := err == nil; ok != v.ok {
1002 t.Errorf("test %d, mergePAX(...): got %v, want %v", i, ok, v.ok)
1003 }
1004 }
1005 }
1006
1007 func TestParsePAX(t *testing.T) {
1008 vectors := []struct {
1009 in string
1010 want map[string]string
1011 ok bool
1012 }{
1013 {"", nil, true},
1014 {"6 k=1\n", map[string]string{"k": "1"}, true},
1015 {"10 a=name\n", map[string]string{"a": "name"}, true},
1016 {"9 a=name\n", map[string]string{"a": "name"}, true},
1017 {"30 mtime=1350244992.023960108\n", map[string]string{"mtime": "1350244992.023960108"}, true},
1018 {"3 somelongkey=\n", nil, false},
1019 {"50 tooshort=\n", nil, false},
1020 {"13 key1=haha\n13 key2=nana\n13 key3=kaka\n",
1021 map[string]string{"key1": "haha", "key2": "nana", "key3": "kaka"}, true},
1022 {"13 key1=val1\n13 key2=val2\n8 key1=\n",
1023 map[string]string{"key1": "", "key2": "val2"}, true},
1024 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=2\n" +
1025 "23 GNU.sparse.offset=1\n25 GNU.sparse.numbytes=2\n" +
1026 "23 GNU.sparse.offset=3\n25 GNU.sparse.numbytes=4\n",
1027 map[string]string{paxGNUSparseSize: "10", paxGNUSparseNumBlocks: "2", paxGNUSparseMap: "1,2,3,4"}, true},
1028 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
1029 "25 GNU.sparse.numbytes=2\n23 GNU.sparse.offset=1\n",
1030 nil, false},
1031 {"22 GNU.sparse.size=10\n26 GNU.sparse.numblocks=1\n" +
1032 "25 GNU.sparse.offset=1,2\n25 GNU.sparse.numbytes=2\n",
1033 nil, false},
1034 }
1035
1036 for i, v := range vectors {
1037 r := strings.NewReader(v.in)
1038 got, err := parsePAX(r)
1039 if !maps.Equal(got, v.want) && !(len(got) == 0 && len(v.want) == 0) {
1040 t.Errorf("test %d, parsePAX():\ngot %v\nwant %v", i, got, v.want)
1041 }
1042 if ok := err == nil; ok != v.ok {
1043 t.Errorf("test %d, parsePAX(): got %v, want %v", i, ok, v.ok)
1044 }
1045 }
1046 }
1047
1048 func TestReadOldGNUSparseMap(t *testing.T) {
1049 populateSparseMap := func(sa sparseArray, sps []string) []string {
1050 for i := 0; len(sps) > 0 && i < sa.maxEntries(); i++ {
1051 copy(sa.entry(i), sps[0])
1052 sps = sps[1:]
1053 }
1054 if len(sps) > 0 {
1055 copy(sa.isExtended(), "\x80")
1056 }
1057 return sps
1058 }
1059
1060 makeInput := func(format Format, size string, sps ...string) (out []byte) {
1061
1062 var blk block
1063 gnu := blk.toGNU()
1064 sparse := gnu.sparse()
1065 copy(gnu.realSize(), size)
1066 sps = populateSparseMap(sparse, sps)
1067 if format != FormatUnknown {
1068 blk.setFormat(format)
1069 }
1070 out = append(out, blk[:]...)
1071
1072
1073 for len(sps) > 0 {
1074 var blk block
1075 sps = populateSparseMap(blk.toSparse(), sps)
1076 out = append(out, blk[:]...)
1077 }
1078 return out
1079 }
1080
1081 makeSparseStrings := func(sp []sparseEntry) (out []string) {
1082 var f formatter
1083 for _, s := range sp {
1084 var b [24]byte
1085 f.formatNumeric(b[:12], s.Offset)
1086 f.formatNumeric(b[12:], s.Length)
1087 out = append(out, string(b[:]))
1088 }
1089 return out
1090 }
1091
1092 vectors := []struct {
1093 input []byte
1094 wantMap sparseDatas
1095 wantSize int64
1096 wantErr error
1097 }{{
1098 input: makeInput(FormatUnknown, ""),
1099 wantErr: ErrHeader,
1100 }, {
1101 input: makeInput(FormatGNU, "1234", "fewa"),
1102 wantSize: 01234,
1103 wantErr: ErrHeader,
1104 }, {
1105 input: makeInput(FormatGNU, "0031"),
1106 wantSize: 031,
1107 }, {
1108 input: makeInput(FormatGNU, "80"),
1109 wantErr: ErrHeader,
1110 }, {
1111 input: makeInput(FormatGNU, "1234",
1112 makeSparseStrings(sparseDatas{{0, 0}, {1, 1}})...),
1113 wantMap: sparseDatas{{0, 0}, {1, 1}},
1114 wantSize: 01234,
1115 }, {
1116 input: makeInput(FormatGNU, "1234",
1117 append(makeSparseStrings(sparseDatas{{0, 0}, {1, 1}}), []string{"", "blah"}...)...),
1118 wantMap: sparseDatas{{0, 0}, {1, 1}},
1119 wantSize: 01234,
1120 }, {
1121 input: makeInput(FormatGNU, "3333",
1122 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}})...),
1123 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}},
1124 wantSize: 03333,
1125 }, {
1126 input: makeInput(FormatGNU, "",
1127 append(append(
1128 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}}),
1129 []string{"", ""}...),
1130 makeSparseStrings(sparseDatas{{4, 1}, {6, 1}})...)...),
1131 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}},
1132 }, {
1133 input: makeInput(FormatGNU, "",
1134 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...)[:blockSize],
1135 wantErr: io.ErrUnexpectedEOF,
1136 }, {
1137 input: makeInput(FormatGNU, "",
1138 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...)[:3*blockSize/2],
1139 wantErr: io.ErrUnexpectedEOF,
1140 }, {
1141 input: makeInput(FormatGNU, "",
1142 makeSparseStrings(sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}})...),
1143 wantMap: sparseDatas{{0, 1}, {2, 1}, {4, 1}, {6, 1}, {8, 1}, {10, 1}},
1144 }, {
1145 input: makeInput(FormatGNU, "",
1146 makeSparseStrings(sparseDatas{{10 << 30, 512}, {20 << 30, 512}})...),
1147 wantMap: sparseDatas{{10 << 30, 512}, {20 << 30, 512}},
1148 }}
1149
1150 for i, v := range vectors {
1151 var blk block
1152 var hdr Header
1153 v.input = v.input[copy(blk[:], v.input):]
1154 tr := Reader{r: bytes.NewReader(v.input)}
1155 got, err := tr.readOldGNUSparseMap(&hdr, &blk)
1156 if !slices.Equal(got, v.wantMap) {
1157 t.Errorf("test %d, readOldGNUSparseMap(): got %v, want %v", i, got, v.wantMap)
1158 }
1159 if err != v.wantErr {
1160 t.Errorf("test %d, readOldGNUSparseMap() = %v, want %v", i, err, v.wantErr)
1161 }
1162 if hdr.Size != v.wantSize {
1163 t.Errorf("test %d, Header.Size = %d, want %d", i, hdr.Size, v.wantSize)
1164 }
1165 }
1166 }
1167
1168 func TestReadGNUSparsePAXHeaders(t *testing.T) {
1169 padInput := func(s string) string {
1170 return s + string(zeroBlock[:blockPadding(int64(len(s)))])
1171 }
1172
1173 vectors := []struct {
1174 inputData string
1175 inputHdrs map[string]string
1176 wantMap sparseDatas
1177 wantSize int64
1178 wantName string
1179 wantErr error
1180 }{{
1181 inputHdrs: nil,
1182 wantErr: nil,
1183 }, {
1184 inputHdrs: map[string]string{
1185 paxGNUSparseNumBlocks: strconv.FormatInt(math.MaxInt64, 10),
1186 paxGNUSparseMap: "0,1,2,3",
1187 },
1188 wantErr: ErrHeader,
1189 }, {
1190 inputHdrs: map[string]string{
1191 paxGNUSparseNumBlocks: "4\x00",
1192 paxGNUSparseMap: "0,1,2,3",
1193 },
1194 wantErr: ErrHeader,
1195 }, {
1196 inputHdrs: map[string]string{
1197 paxGNUSparseNumBlocks: "4",
1198 paxGNUSparseMap: "0,1,2,3",
1199 },
1200 wantErr: ErrHeader,
1201 }, {
1202 inputHdrs: map[string]string{
1203 paxGNUSparseNumBlocks: "2",
1204 paxGNUSparseMap: "0,1,2,3",
1205 },
1206 wantMap: sparseDatas{{0, 1}, {2, 3}},
1207 }, {
1208 inputHdrs: map[string]string{
1209 paxGNUSparseNumBlocks: "2",
1210 paxGNUSparseMap: "0, 1,2,3",
1211 },
1212 wantErr: ErrHeader,
1213 }, {
1214 inputHdrs: map[string]string{
1215 paxGNUSparseNumBlocks: "2",
1216 paxGNUSparseMap: "0,1,02,3",
1217 paxGNUSparseRealSize: "4321",
1218 },
1219 wantMap: sparseDatas{{0, 1}, {2, 3}},
1220 wantSize: 4321,
1221 }, {
1222 inputHdrs: map[string]string{
1223 paxGNUSparseNumBlocks: "2",
1224 paxGNUSparseMap: "0,one1,2,3",
1225 },
1226 wantErr: ErrHeader,
1227 }, {
1228 inputHdrs: map[string]string{
1229 paxGNUSparseMajor: "0",
1230 paxGNUSparseMinor: "0",
1231 paxGNUSparseNumBlocks: "2",
1232 paxGNUSparseMap: "0,1,2,3",
1233 paxGNUSparseSize: "1234",
1234 paxGNUSparseRealSize: "4321",
1235 paxGNUSparseName: "realname",
1236 },
1237 wantMap: sparseDatas{{0, 1}, {2, 3}},
1238 wantSize: 1234,
1239 wantName: "realname",
1240 }, {
1241 inputHdrs: map[string]string{
1242 paxGNUSparseMajor: "0",
1243 paxGNUSparseMinor: "0",
1244 paxGNUSparseNumBlocks: "1",
1245 paxGNUSparseMap: "10737418240,512",
1246 paxGNUSparseSize: "10737418240",
1247 paxGNUSparseName: "realname",
1248 },
1249 wantMap: sparseDatas{{10737418240, 512}},
1250 wantSize: 10737418240,
1251 wantName: "realname",
1252 }, {
1253 inputHdrs: map[string]string{
1254 paxGNUSparseMajor: "0",
1255 paxGNUSparseMinor: "0",
1256 paxGNUSparseNumBlocks: "0",
1257 paxGNUSparseMap: "",
1258 },
1259 wantMap: sparseDatas{},
1260 }, {
1261 inputHdrs: map[string]string{
1262 paxGNUSparseMajor: "0",
1263 paxGNUSparseMinor: "1",
1264 paxGNUSparseNumBlocks: "4",
1265 paxGNUSparseMap: "0,5,10,5,20,5,30,5",
1266 },
1267 wantMap: sparseDatas{{0, 5}, {10, 5}, {20, 5}, {30, 5}},
1268 }, {
1269 inputHdrs: map[string]string{
1270 paxGNUSparseMajor: "1",
1271 paxGNUSparseMinor: "0",
1272 paxGNUSparseNumBlocks: "4",
1273 paxGNUSparseMap: "0,5,10,5,20,5,30,5",
1274 },
1275 wantErr: io.ErrUnexpectedEOF,
1276 }, {
1277 inputData: padInput("0\n"),
1278 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1279 wantMap: sparseDatas{},
1280 }, {
1281 inputData: padInput("0\n")[:blockSize-1] + "#",
1282 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1283 wantMap: sparseDatas{},
1284 }, {
1285 inputData: padInput("0"),
1286 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1287 wantErr: io.ErrUnexpectedEOF,
1288 }, {
1289 inputData: padInput("ab\n"),
1290 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1291 wantErr: ErrHeader,
1292 }, {
1293 inputData: padInput("1\n2\n3\n"),
1294 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1295 wantMap: sparseDatas{{2, 3}},
1296 }, {
1297 inputData: padInput("1\n2\n"),
1298 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1299 wantErr: io.ErrUnexpectedEOF,
1300 }, {
1301 inputData: padInput("1\n2\n\n"),
1302 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1303 wantErr: ErrHeader,
1304 }, {
1305 inputData: string(zeroBlock[:]) + padInput("0\n"),
1306 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1307 wantErr: ErrHeader,
1308 }, {
1309 inputData: strings.Repeat("0", blockSize) + padInput("1\n5\n1\n"),
1310 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1311 wantMap: sparseDatas{{5, 1}},
1312 }, {
1313 inputData: padInput(fmt.Sprintf("%d\n", int64(math.MaxInt64))),
1314 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1315 wantErr: ErrHeader,
1316 }, {
1317 inputData: padInput(strings.Repeat("0", 300) + "1\n" + strings.Repeat("0", 1000) + "5\n" + strings.Repeat("0", 800) + "2\n"),
1318 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1319 wantMap: sparseDatas{{5, 2}},
1320 }, {
1321 inputData: padInput("2\n10737418240\n512\n21474836480\n512\n"),
1322 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1323 wantMap: sparseDatas{{10737418240, 512}, {21474836480, 512}},
1324 }, {
1325 inputData: padInput("100\n" + func() string {
1326 var ss []string
1327 for i := 0; i < 100; i++ {
1328 ss = append(ss, fmt.Sprintf("%d\n%d\n", int64(i)<<30, 512))
1329 }
1330 return strings.Join(ss, "")
1331 }()),
1332 inputHdrs: map[string]string{paxGNUSparseMajor: "1", paxGNUSparseMinor: "0"},
1333 wantMap: func() (spd sparseDatas) {
1334 for i := 0; i < 100; i++ {
1335 spd = append(spd, sparseEntry{int64(i) << 30, 512})
1336 }
1337 return spd
1338 }(),
1339 }}
1340
1341 for i, v := range vectors {
1342 var hdr Header
1343 hdr.PAXRecords = v.inputHdrs
1344 r := strings.NewReader(v.inputData + "#")
1345 tr := Reader{curr: ®FileReader{r, int64(r.Len())}}
1346 got, err := tr.readGNUSparsePAXHeaders(&hdr)
1347 if !slices.Equal(got, v.wantMap) {
1348 t.Errorf("test %d, readGNUSparsePAXHeaders(): got %v, want %v", i, got, v.wantMap)
1349 }
1350 if err != v.wantErr {
1351 t.Errorf("test %d, readGNUSparsePAXHeaders() = %v, want %v", i, err, v.wantErr)
1352 }
1353 if hdr.Size != v.wantSize {
1354 t.Errorf("test %d, Header.Size = %d, want %d", i, hdr.Size, v.wantSize)
1355 }
1356 if hdr.Name != v.wantName {
1357 t.Errorf("test %d, Header.Name = %s, want %s", i, hdr.Name, v.wantName)
1358 }
1359 if v.wantErr == nil && r.Len() == 0 {
1360 t.Errorf("test %d, canary byte unexpectedly consumed", i)
1361 }
1362 }
1363 }
1364
1365
1366
1367 type testNonEmptyReader struct{ io.Reader }
1368
1369 func (r testNonEmptyReader) Read(b []byte) (int, error) {
1370 if len(b) == 0 {
1371 return 0, errors.New("unexpected empty Read call")
1372 }
1373 return r.Reader.Read(b)
1374 }
1375
1376 func TestFileReader(t *testing.T) {
1377 type (
1378 testRead struct {
1379 cnt int
1380 wantStr string
1381 wantErr error
1382 }
1383 testWriteTo struct {
1384 ops fileOps
1385 wantCnt int64
1386 wantErr error
1387 }
1388 testRemaining struct {
1389 wantLCnt int64
1390 wantPCnt int64
1391 }
1392 testFnc any
1393 )
1394
1395 type (
1396 makeReg struct {
1397 str string
1398 size int64
1399 }
1400 makeSparse struct {
1401 makeReg makeReg
1402 spd sparseDatas
1403 size int64
1404 }
1405 fileMaker any
1406 )
1407
1408 vectors := []struct {
1409 maker fileMaker
1410 tests []testFnc
1411 }{{
1412 maker: makeReg{"", 0},
1413 tests: []testFnc{
1414 testRemaining{0, 0},
1415 testRead{0, "", io.EOF},
1416 testRead{1, "", io.EOF},
1417 testWriteTo{nil, 0, nil},
1418 testRemaining{0, 0},
1419 },
1420 }, {
1421 maker: makeReg{"", 1},
1422 tests: []testFnc{
1423 testRemaining{1, 1},
1424 testRead{5, "", io.ErrUnexpectedEOF},
1425 testWriteTo{nil, 0, io.ErrUnexpectedEOF},
1426 testRemaining{1, 1},
1427 },
1428 }, {
1429 maker: makeReg{"hello", 5},
1430 tests: []testFnc{
1431 testRemaining{5, 5},
1432 testRead{5, "hello", io.EOF},
1433 testRemaining{0, 0},
1434 },
1435 }, {
1436 maker: makeReg{"hello, world", 50},
1437 tests: []testFnc{
1438 testRemaining{50, 50},
1439 testRead{7, "hello, ", nil},
1440 testRemaining{43, 43},
1441 testRead{5, "world", nil},
1442 testRemaining{38, 38},
1443 testWriteTo{nil, 0, io.ErrUnexpectedEOF},
1444 testRead{1, "", io.ErrUnexpectedEOF},
1445 testRemaining{38, 38},
1446 },
1447 }, {
1448 maker: makeReg{"hello, world", 5},
1449 tests: []testFnc{
1450 testRemaining{5, 5},
1451 testRead{0, "", nil},
1452 testRead{4, "hell", nil},
1453 testRemaining{1, 1},
1454 testWriteTo{fileOps{"o"}, 1, nil},
1455 testRemaining{0, 0},
1456 testWriteTo{nil, 0, nil},
1457 testRead{0, "", io.EOF},
1458 },
1459 }, {
1460 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
1461 tests: []testFnc{
1462 testRemaining{8, 5},
1463 testRead{3, "ab\x00", nil},
1464 testRead{10, "\x00\x00cde", io.EOF},
1465 testRemaining{0, 0},
1466 },
1467 }, {
1468 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
1469 tests: []testFnc{
1470 testRemaining{8, 5},
1471 testWriteTo{fileOps{"ab", int64(3), "cde"}, 8, nil},
1472 testRemaining{0, 0},
1473 },
1474 }, {
1475 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 10},
1476 tests: []testFnc{
1477 testRemaining{10, 5},
1478 testRead{100, "ab\x00\x00\x00cde\x00\x00", io.EOF},
1479 testRemaining{0, 0},
1480 },
1481 }, {
1482 maker: makeSparse{makeReg{"abc", 5}, sparseDatas{{0, 2}, {5, 3}}, 10},
1483 tests: []testFnc{
1484 testRemaining{10, 5},
1485 testRead{100, "ab\x00\x00\x00c", io.ErrUnexpectedEOF},
1486 testRemaining{4, 2},
1487 },
1488 }, {
1489 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 8},
1490 tests: []testFnc{
1491 testRemaining{8, 5},
1492 testRead{8, "\x00abc\x00\x00de", io.EOF},
1493 testRemaining{0, 0},
1494 },
1495 }, {
1496 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 0}, {6, 0}, {6, 2}}, 8},
1497 tests: []testFnc{
1498 testRemaining{8, 5},
1499 testRead{8, "\x00abc\x00\x00de", io.EOF},
1500 testRemaining{0, 0},
1501 },
1502 }, {
1503 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 0}, {6, 0}, {6, 2}}, 8},
1504 tests: []testFnc{
1505 testRemaining{8, 5},
1506 testWriteTo{fileOps{int64(1), "abc", int64(2), "de"}, 8, nil},
1507 testRemaining{0, 0},
1508 },
1509 }, {
1510 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 10},
1511 tests: []testFnc{
1512 testRead{100, "\x00abc\x00\x00de\x00\x00", io.EOF},
1513 },
1514 }, {
1515 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}}, 10},
1516 tests: []testFnc{
1517 testWriteTo{fileOps{int64(1), "abc", int64(2), "de", int64(1), "\x00"}, 10, nil},
1518 },
1519 }, {
1520 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 2}, {8, 0}, {8, 0}, {8, 0}, {8, 0}}, 10},
1521 tests: []testFnc{
1522 testRead{100, "\x00abc\x00\x00de\x00\x00", io.EOF},
1523 },
1524 }, {
1525 maker: makeSparse{makeReg{"", 0}, sparseDatas{}, 2},
1526 tests: []testFnc{
1527 testRead{100, "\x00\x00", io.EOF},
1528 },
1529 }, {
1530 maker: makeSparse{makeReg{"", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1531 tests: []testFnc{
1532 testRead{100, "\x00", io.ErrUnexpectedEOF},
1533 },
1534 }, {
1535 maker: makeSparse{makeReg{"ab", 2}, sparseDatas{{1, 3}, {6, 5}}, 15},
1536 tests: []testFnc{
1537 testRead{100, "\x00ab", errMissData},
1538 },
1539 }, {
1540 maker: makeSparse{makeReg{"ab", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1541 tests: []testFnc{
1542 testRead{100, "\x00ab", io.ErrUnexpectedEOF},
1543 },
1544 }, {
1545 maker: makeSparse{makeReg{"abc", 3}, sparseDatas{{1, 3}, {6, 5}}, 15},
1546 tests: []testFnc{
1547 testRead{100, "\x00abc\x00\x00", errMissData},
1548 },
1549 }, {
1550 maker: makeSparse{makeReg{"abc", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1551 tests: []testFnc{
1552 testRead{100, "\x00abc\x00\x00", io.ErrUnexpectedEOF},
1553 },
1554 }, {
1555 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 5}}, 15},
1556 tests: []testFnc{
1557 testRead{100, "\x00abc\x00\x00de", errMissData},
1558 },
1559 }, {
1560 maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{1, 3}, {6, 5}}, 15},
1561 tests: []testFnc{
1562 testWriteTo{fileOps{int64(1), "abc", int64(2), "de"}, 8, errMissData},
1563 },
1564 }, {
1565 maker: makeSparse{makeReg{"abcde", 8}, sparseDatas{{1, 3}, {6, 5}}, 15},
1566 tests: []testFnc{
1567 testRead{100, "\x00abc\x00\x00de", io.ErrUnexpectedEOF},
1568 },
1569 }, {
1570 maker: makeSparse{makeReg{"abcdefghEXTRA", 13}, sparseDatas{{1, 3}, {6, 5}}, 15},
1571 tests: []testFnc{
1572 testRemaining{15, 13},
1573 testRead{100, "\x00abc\x00\x00defgh\x00\x00\x00\x00", errUnrefData},
1574 testWriteTo{nil, 0, errUnrefData},
1575 testRemaining{0, 5},
1576 },
1577 }, {
1578 maker: makeSparse{makeReg{"abcdefghEXTRA", 13}, sparseDatas{{1, 3}, {6, 5}}, 15},
1579 tests: []testFnc{
1580 testRemaining{15, 13},
1581 testWriteTo{fileOps{int64(1), "abc", int64(2), "defgh", int64(4)}, 15, errUnrefData},
1582 testRead{100, "", errUnrefData},
1583 testRemaining{0, 5},
1584 },
1585 }}
1586
1587 for i, v := range vectors {
1588 var fr fileReader
1589 switch maker := v.maker.(type) {
1590 case makeReg:
1591 r := testNonEmptyReader{strings.NewReader(maker.str)}
1592 fr = ®FileReader{r, maker.size}
1593 case makeSparse:
1594 if !validateSparseEntries(maker.spd, maker.size) {
1595 t.Fatalf("invalid sparse map: %v", maker.spd)
1596 }
1597 sph := invertSparseEntries(maker.spd, maker.size)
1598 r := testNonEmptyReader{strings.NewReader(maker.makeReg.str)}
1599 fr = ®FileReader{r, maker.makeReg.size}
1600 fr = &sparseFileReader{fr, sph, 0}
1601 default:
1602 t.Fatalf("test %d, unknown make operation: %T", i, maker)
1603 }
1604
1605 for j, tf := range v.tests {
1606 switch tf := tf.(type) {
1607 case testRead:
1608 b := make([]byte, tf.cnt)
1609 n, err := fr.Read(b)
1610 if got := string(b[:n]); got != tf.wantStr || err != tf.wantErr {
1611 t.Errorf("test %d.%d, Read(%d):\ngot (%q, %v)\nwant (%q, %v)", i, j, tf.cnt, got, err, tf.wantStr, tf.wantErr)
1612 }
1613 case testWriteTo:
1614 f := &testFile{ops: tf.ops}
1615 got, err := fr.WriteTo(f)
1616 if _, ok := err.(testError); ok {
1617 t.Errorf("test %d.%d, WriteTo(): %v", i, j, err)
1618 } else if got != tf.wantCnt || err != tf.wantErr {
1619 t.Errorf("test %d.%d, WriteTo() = (%d, %v), want (%d, %v)", i, j, got, err, tf.wantCnt, tf.wantErr)
1620 }
1621 if len(f.ops) > 0 {
1622 t.Errorf("test %d.%d, expected %d more operations", i, j, len(f.ops))
1623 }
1624 case testRemaining:
1625 if got := fr.logicalRemaining(); got != tf.wantLCnt {
1626 t.Errorf("test %d.%d, logicalRemaining() = %d, want %d", i, j, got, tf.wantLCnt)
1627 }
1628 if got := fr.physicalRemaining(); got != tf.wantPCnt {
1629 t.Errorf("test %d.%d, physicalRemaining() = %d, want %d", i, j, got, tf.wantPCnt)
1630 }
1631 default:
1632 t.Fatalf("test %d.%d, unknown test operation: %T", i, j, tf)
1633 }
1634 }
1635 }
1636 }
1637
1638 func TestInsecurePaths(t *testing.T) {
1639 t.Setenv("GODEBUG", "tarinsecurepath=0")
1640 for _, path := range []string{
1641 "../foo",
1642 "/foo",
1643 "a/b/../../../c",
1644 } {
1645 var buf bytes.Buffer
1646 tw := NewWriter(&buf)
1647 tw.WriteHeader(&Header{
1648 Name: path,
1649 })
1650 const securePath = "secure"
1651 tw.WriteHeader(&Header{
1652 Name: securePath,
1653 })
1654 tw.Close()
1655
1656 tr := NewReader(&buf)
1657 h, err := tr.Next()
1658 if err != ErrInsecurePath {
1659 t.Errorf("tr.Next for file %q: got err %v, want ErrInsecurePath", path, err)
1660 continue
1661 }
1662 if h.Name != path {
1663 t.Errorf("tr.Next for file %q: got name %q, want %q", path, h.Name, path)
1664 }
1665
1666 h, err = tr.Next()
1667 if err != nil {
1668 t.Errorf("tr.Next for file %q: got err %v, want nil", securePath, err)
1669 }
1670 if h.Name != securePath {
1671 t.Errorf("tr.Next for file %q: got name %q, want %q", securePath, h.Name, securePath)
1672 }
1673 }
1674 }
1675
1676 func TestDisableInsecurePathCheck(t *testing.T) {
1677 t.Setenv("GODEBUG", "tarinsecurepath=1")
1678 var buf bytes.Buffer
1679 tw := NewWriter(&buf)
1680 const name = "/foo"
1681 tw.WriteHeader(&Header{
1682 Name: name,
1683 })
1684 tw.Close()
1685 tr := NewReader(&buf)
1686 h, err := tr.Next()
1687 if err != nil {
1688 t.Fatalf("tr.Next with tarinsecurepath=1: got err %v, want nil", err)
1689 }
1690 if h.Name != name {
1691 t.Fatalf("tr.Next with tarinsecurepath=1: got name %q, want %q", h.Name, name)
1692 }
1693 }
1694
View as plain text