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