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