| import 'dart:async'; | |
| import 'dart:convert'; | |
| import 'dart:typed_data'; | |
| import 'package:async/async.dart'; | |
| import 'package:tar/src/reader.dart'; | |
| import 'package:tar/src/utils.dart'; | |
| import 'package:tar/tar.dart'; | |
| import 'package:test/test.dart'; | |
| import 'utils.dart'; | |
| // ignore_for_file: discarded_futures | |
| void main() { | |
| group('POSIX.1-2001', () { | |
| test('reads files', () => _testWith('reference/posix.tar')); | |
| test('reads large files', | |
| () => _testLargeFile('reference/headers/large_posix.tar')); | |
| }); | |
| test('(new) GNU Tar format', () => _testWith('reference/gnu.tar')); | |
| test('ustar', () => _testWith('reference/ustar.tar')); | |
| test('v7', () => _testWith('reference/v7.tar', ignoreLongFileName: true)); | |
| test('can skip tar files', () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| expect(await reader.moveNext(), isTrue); | |
| expect(await reader.moveNext(), isTrue); | |
| expect(reader.current.name, 'reference/res/subdirectory_with_a_long_name/'); | |
| }); | |
| test('getters throw before moveNext() is called', () { | |
| final reader = TarReader(const Stream<Never>.empty()); | |
| expect(() => reader.current, throwsStateError); | |
| }); | |
| test("can't use moveNext() concurrently", () { | |
| final reader = TarReader(Stream.fromFuture( | |
| Future.delayed(const Duration(seconds: 2), () => <int>[]))); | |
| expect(reader.moveNext(), completion(isFalse)); | |
| expect(() => reader.moveNext(), throwsStateError); | |
| return reader.cancel(); | |
| }); | |
| test("can't use moveNext() while a stream is active", () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| expect(await reader.moveNext(), isTrue); | |
| reader.current.contents.listen((event) {}).pause(); | |
| expect(() => reader.moveNext(), throwsStateError); | |
| await reader.cancel(); | |
| }); | |
| test("can't use moveNext() after canceling the reader", () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| await reader.cancel(); | |
| expect(() => reader.moveNext(), throwsStateError); | |
| }); | |
| test("can't read a stream multiple times", () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| await reader.moveNext(); | |
| reader.current.contents.listen(null); | |
| expect( | |
| () => reader.current.contents.listen(null), | |
| throwsA(isStateError.having( | |
| (e) => e.message, | |
| 'message', | |
| contains('A tar entry has been listened to multiple times.'), | |
| )), | |
| ); | |
| }); | |
| test("can't read a stream while a call to moveNext() is active", () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| await reader.moveNext(); | |
| unawaited(reader.moveNext()); | |
| expect( | |
| () => reader.current.contents.listen(null), | |
| throwsA(isStateError.having( | |
| (e) => e.message, | |
| 'message', | |
| contains('A tar entry has been listened to multiple times.'), | |
| )), | |
| ); | |
| }); | |
| test("can't read the stream of an old tar entry", () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| await reader.moveNext(); | |
| final oldContents = reader.current.contents; | |
| await reader.moveNext(); | |
| expect( | |
| () => oldContents.listen(null), | |
| throwsA(isStateError.having( | |
| (e) => e.message, | |
| 'message', | |
| contains('Tried listening to an outdated tar entry.'), | |
| )), | |
| ); | |
| }); | |
| test('can cancel a stream and then read further entries', () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| addTearDown(reader.cancel); | |
| await reader.moveNext(); | |
| await reader.current.contents | |
| .listen(expectAsync1((_) {}, count: 0)) | |
| .cancel(); | |
| expect(await reader.moveNext(), isTrue); | |
| }); | |
| test('cancelling the reader closes the current subscription', () async { | |
| final input = openRead('reference/posix.tar'); | |
| final reader = TarReader(input); | |
| // Skip forward to the first actual file | |
| while (await reader.moveNext()) { | |
| if (reader.current.header.hasContent) break; | |
| } | |
| // ignore: cancel_subscriptions | |
| final subscription = reader.current.contents | |
| .listen(null, onDone: expectAsync0(() {})) | |
| ..pause(); | |
| await reader.cancel(); | |
| subscription.resume(); | |
| }); | |
| group('the reader closes itself', () { | |
| test('at the end of a file', () async { | |
| // two zero blocks terminate a tar file | |
| final zeroBlock = Uint8List(512); | |
| final controller = StreamController<List<int>>(); | |
| controller.onListen = () { | |
| controller | |
| ..add(zeroBlock) | |
| ..add(zeroBlock) | |
| ..add(zeroBlock); | |
| }; | |
| final reader = TarReader(controller.stream); | |
| await expectLater(reader.moveNext(), completion(isFalse)); | |
| expect(controller.hasListener, isFalse); | |
| }); | |
| test('if the stream emits an error in headers', () async { | |
| final controller = StreamController<List<int>>(); | |
| controller.onListen = () { | |
| controller.addError('foo'); | |
| }; | |
| final reader = TarReader(controller.stream); | |
| await expectLater(reader.moveNext(), throwsA('foo')); | |
| expect(controller.hasListener, isFalse); | |
| }); | |
| test('if the stream emits an error in content', () async { | |
| // Craft a stream that starts with a valid tar file, but then emits an | |
| // error in the middle of an entry. First 512 bytes are headers. | |
| final iterator = ChunkedStreamReader(openRead('reference/v7.tar')); | |
| final controller = StreamController<List<int>>(); | |
| controller.onListen = () async { | |
| // headers + 3 bytes of content | |
| await controller.addStream(iterator.readStream(515)); | |
| controller.addError('foo'); | |
| }; | |
| final reader = TarReader(controller.stream); | |
| await expectLater(reader.moveNext(), completion(isTrue)); | |
| await expectLater( | |
| reader.current.contents, emitsThrough(emitsError('foo'))); | |
| expect(controller.hasListener, isFalse); | |
| await iterator.cancel(); | |
| }); | |
| }); | |
| group('disallowTrailingData: true', () { | |
| final emptyBlock = Uint8List(512); | |
| void closeLater(StreamController<Object?> controller) { | |
| controller.onCancel = () => fail('Should not cancel stream subscription'); | |
| Timer.run(() { | |
| // Calling close() implicitly cancels the stream subscription, we only | |
| // want to ensure that the reader is not doing that. | |
| controller.onCancel = null; | |
| expect(controller.hasListener, isTrue, | |
| reason: 'Should have a listener'); | |
| controller.close(); | |
| }); | |
| } | |
| test('throws for trailing data', () async { | |
| final input = StreamController<Uint8List>() | |
| ..add(emptyBlock) | |
| ..add(emptyBlock) | |
| // illegal content after end marker | |
| ..add(Uint8List.fromList([0, 1, 2, 3])); | |
| // The reader checks for empty data in chunks, so we timeout if the stream | |
| // goes stale. | |
| Timer.run(input.close); | |
| final reader = TarReader(input.stream, disallowTrailingData: true); | |
| await expectLater(reader.moveNext(), throwsA(isA<TarException>())); | |
| expect(input.hasListener, isFalse, | |
| reason: 'Should have cancelled subscription after error.'); | |
| }); | |
| test('does not throw or cancel if the stream ends as expected', () { | |
| final input = StreamController<Uint8List>() | |
| ..add(emptyBlock) | |
| ..add(emptyBlock); | |
| closeLater(input); | |
| final reader = TarReader(input.stream, disallowTrailingData: true); | |
| expectLater(reader.moveNext(), completion(isFalse)); | |
| }); | |
| test('does not throw or cancel when there are many empty blocks', () { | |
| final input = StreamController<Uint8List>(); | |
| for (var i = 0; i < 100; i++) { | |
| input.add(emptyBlock); | |
| } | |
| closeLater(input); | |
| final reader = TarReader(input.stream, disallowTrailingData: true); | |
| expectLater(reader.moveNext(), completion(isFalse)); | |
| }); | |
| test('does not throw or cancel if the stream ends without marker', () { | |
| final input = StreamController<Uint8List>(); | |
| closeLater(input); | |
| final reader = TarReader(input.stream, disallowTrailingData: true); | |
| expectLater(reader.moveNext(), completion(isFalse)); | |
| }); | |
| }); | |
| group('tests from dart-neats PR', () { | |
| Stream<List<int>> open(String name) { | |
| return openRead('reference/neats_test/$name'); | |
| } | |
| final tests = [ | |
| { | |
| 'file': 'gnu.tar', | |
| 'headers': <TarHeader>[ | |
| TarHeader( | |
| name: 'small.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 3, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| format: TarFormat.gnu, | |
| ), | |
| TarHeader( | |
| name: 'small2.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 8, | |
| modified: millisecondsSinceEpoch(1597755958000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| format: TarFormat.gnu, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'sparse-formats.tar', | |
| 'headers': <TarHeader>[ | |
| TarHeader( | |
| name: 'sparse-gnu', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 200, | |
| modified: millisecondsSinceEpoch(1597756151000), | |
| typeFlag: TypeFlag.gnuSparse, | |
| userName: 'jonas', | |
| groupName: 'jonas', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.gnu, | |
| ), | |
| TarHeader( | |
| name: 'sparse-posix-v-0-0', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 200, | |
| modified: millisecondsSinceEpoch(1597756151000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'jonas', | |
| groupName: 'jonas', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.pax, | |
| ), | |
| TarHeader( | |
| name: 'sparse-posix-0-1', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 200, | |
| modified: millisecondsSinceEpoch(1597756151000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'jonas', | |
| groupName: 'jonas', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.pax, | |
| ), | |
| TarHeader( | |
| name: 'sparse-posix-1-0', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 200, | |
| modified: millisecondsSinceEpoch(1597756151000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'jonas', | |
| groupName: 'jonas', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.pax, | |
| ), | |
| TarHeader( | |
| name: 'end', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 4, | |
| modified: millisecondsSinceEpoch(1597756151000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'jonas', | |
| groupName: 'jonas', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.gnu, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'star.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'small.txt', | |
| mode: 416, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 3, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| accessed: millisecondsSinceEpoch(1597755680000), | |
| changed: millisecondsSinceEpoch(1597755680000), | |
| format: TarFormat.star, | |
| ), | |
| TarHeader( | |
| name: 'small2.txt', | |
| mode: 416, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 7, | |
| modified: millisecondsSinceEpoch(1597755958000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| accessed: millisecondsSinceEpoch(1597755958000), | |
| changed: millisecondsSinceEpoch(1597755958000), | |
| format: TarFormat.star, | |
| ) | |
| ] | |
| }, | |
| { | |
| 'file': 'v7.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'small.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 3, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| format: TarFormat.v7, | |
| ), | |
| TarHeader( | |
| name: 'small2.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 8, | |
| modified: millisecondsSinceEpoch(1597755958000), | |
| typeFlag: TypeFlag.reg, | |
| format: TarFormat.v7, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'ustar.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'small.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 3, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| format: TarFormat.ustar, | |
| ), | |
| TarHeader( | |
| name: 'small2.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 8, | |
| modified: millisecondsSinceEpoch(1597755958000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| format: TarFormat.ustar, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'pax.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: | |
| 'a/123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 1000, | |
| userName: 'jonas', | |
| groupName: 'fj', | |
| size: 7, | |
| modified: microsecondsSinceEpoch(1597823492427388), | |
| changed: microsecondsSinceEpoch(1597823492427388), | |
| accessed: microsecondsSinceEpoch(1597823492427388), | |
| typeFlag: TypeFlag.reg, | |
| format: TarFormat.pax, | |
| ), | |
| TarHeader( | |
| name: 'a/b', | |
| mode: 511, | |
| userId: 1000, | |
| groupId: 1000, | |
| userName: 'garett', | |
| groupName: 'tok', | |
| size: 0, | |
| modified: microsecondsSinceEpoch(1597823492427388), | |
| changed: microsecondsSinceEpoch(1597823492427388), | |
| accessed: microsecondsSinceEpoch(1597823492427388), | |
| typeFlag: TypeFlag.symlink, | |
| linkName: | |
| '123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100', | |
| format: TarFormat.pax, | |
| ), | |
| ] | |
| }, | |
| { | |
| // PAX record with bad record length. | |
| 'file': 'pax-bad-record-length.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // PAX record with non-numeric mtime | |
| 'file': 'pax-bad-mtime.tar', | |
| 'error': true, | |
| }, | |
| { | |
| 'file': 'pax-pos-size-file.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'bar', | |
| mode: 416, | |
| userId: 143077, | |
| groupId: 1000, | |
| size: 999, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'jonasfj', | |
| groupName: 'jfj', | |
| format: TarFormat.pax, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'pax-records.tar', | |
| 'headers': [ | |
| TarHeader( | |
| typeFlag: TypeFlag.reg, | |
| size: 0, | |
| name: 'pax-records', | |
| mode: 416, | |
| userName: 'walnut', | |
| modified: millisecondsSinceEpoch(0), | |
| format: TarFormat.pax, | |
| ) | |
| ], | |
| }, | |
| { | |
| 'file': 'nil-gid-uid.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'nil-gid.txt', | |
| mode: 436, | |
| userId: 1000, | |
| groupId: 0, | |
| size: 3, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.gnu, | |
| ), | |
| TarHeader( | |
| name: 'nil-uid.txt', | |
| mode: 436, | |
| userId: 0, | |
| groupId: 1000, | |
| size: 7, | |
| modified: millisecondsSinceEpoch(1597755958000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'garett', | |
| devMajor: 0, | |
| devMinor: 0, | |
| format: TarFormat.gnu, | |
| ) | |
| ] | |
| }, | |
| { | |
| 'file': 'xattrs.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'small.txt', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 10, | |
| size: 5, | |
| modified: microsecondsSinceEpoch(1597823492427388), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'tok', | |
| accessed: microsecondsSinceEpoch(1597823492427388), | |
| changed: microsecondsSinceEpoch(1597823492427388), | |
| format: TarFormat.pax, | |
| ), | |
| TarHeader( | |
| name: 'small2.txt', | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 10, | |
| size: 11, | |
| modified: microsecondsSinceEpoch(1597823492427388), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'garett', | |
| groupName: 'tok', | |
| accessed: microsecondsSinceEpoch(1597823492427388), | |
| changed: microsecondsSinceEpoch(1597823492427388), | |
| format: TarFormat.pax, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Matches the behavior of GNU, BSD, and STAR tar utilities. | |
| 'file': 'gnu-multi-hdrs.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'long-path-name', | |
| size: 0, | |
| linkName: 'long-linkpath-name', | |
| userId: 1000, | |
| groupId: 1000, | |
| modified: millisecondsSinceEpoch(1597756829000), | |
| typeFlag: TypeFlag.symlink, | |
| format: TarFormat.gnu, | |
| mode: 0, | |
| ) | |
| ], | |
| }, | |
| { | |
| // GNU tar 'file' with atime and ctime fields set. | |
| // Old GNU incremental backup. | |
| // | |
| // Created with the GNU tar v1.27.1. | |
| // tar --incremental -S -cvf gnu-incremental.tar test2 | |
| 'file': 'gnu-incremental.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'incremental/', | |
| mode: 16877, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 14, | |
| modified: millisecondsSinceEpoch(1597755680000), | |
| typeFlag: TypeFlag.vendor, | |
| userName: 'fizz', | |
| groupName: 'foobar', | |
| accessed: millisecondsSinceEpoch(1597755680000), | |
| changed: millisecondsSinceEpoch(1597755033000), | |
| format: TarFormat.gnu, | |
| ), | |
| TarHeader( | |
| name: 'incremental/foo', | |
| mode: 33188, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 64, | |
| modified: millisecondsSinceEpoch(1597755688000), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'fizz', | |
| groupName: 'foobar', | |
| accessed: millisecondsSinceEpoch(1597759641000), | |
| changed: millisecondsSinceEpoch(1597755793000), | |
| format: TarFormat.gnu, | |
| ), | |
| TarHeader( | |
| name: 'incremental/sparse', | |
| mode: 33188, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 536870912, | |
| modified: millisecondsSinceEpoch(1597755776000), | |
| typeFlag: TypeFlag.gnuSparse, | |
| userName: 'fizz', | |
| groupName: 'foobar', | |
| accessed: millisecondsSinceEpoch(1597755703000), | |
| changed: millisecondsSinceEpoch(1597755602000), | |
| format: TarFormat.gnu, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Matches the behavior of GNU and BSD tar utilities. | |
| 'file': 'pax-multi-hdrs.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'baz', | |
| size: 0, | |
| linkName: 'bzzt/bzzt/bzzt/bzzt/bzzt/baz', | |
| modified: millisecondsSinceEpoch(0), | |
| typeFlag: TypeFlag.symlink, | |
| format: TarFormat.pax, | |
| mode: 0, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Both BSD and GNU tar truncate long names at first NUL even | |
| // if there is data following that NUL character. | |
| // This is reasonable as GNU long names are C-strings. | |
| 'file': 'gnu-long-nul.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: '9876543210', | |
| size: 0, | |
| mode: 420, | |
| userId: 1000, | |
| groupId: 1000, | |
| modified: millisecondsSinceEpoch(1597755682000), | |
| typeFlag: TypeFlag.reg, | |
| format: TarFormat.gnu, | |
| userName: 'jensen', | |
| groupName: 'jensen', | |
| ) | |
| ] | |
| }, | |
| { | |
| // This archive was generated by Writer but is readable by both | |
| // GNU and BSD tar utilities. | |
| // The archive generated by GNU is nearly byte-for-byte identical | |
| // to the Go version except the Go version sets a negative devMinor | |
| // just to force the GNU format. | |
| 'file': 'gnu-utf8.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: '🧸', | |
| size: 0, | |
| mode: 420, | |
| userId: 525, | |
| groupId: 600, | |
| modified: millisecondsSinceEpoch(0), | |
| typeFlag: TypeFlag.reg, | |
| userName: '🐻', | |
| groupName: '🥭', | |
| format: TarFormat.gnu, | |
| ) | |
| ] | |
| }, | |
| { | |
| 'file': 'gnu-non-utf8-name.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'pub\x80\x81\x82\x83dev', | |
| size: 0, | |
| mode: 422, | |
| userId: 1234, | |
| groupId: 5678, | |
| modified: millisecondsSinceEpoch(0), | |
| typeFlag: TypeFlag.reg, | |
| userName: 'walnut', | |
| groupName: 'dust', | |
| format: TarFormat.gnu, | |
| ) | |
| ] | |
| }, | |
| { | |
| // BSD tar v3.1.2 and GNU tar v1.27.1 both rejects PAX records | |
| // with NULs in the key. | |
| 'file': 'pax-nul-xattrs.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // BSD tar v3.1.2 rejects a PAX path with NUL in the value, while | |
| // GNU tar v1.27.1 simply truncates at first NUL. | |
| // We emulate the behavior of BSD since it is strange doing NUL | |
| // truncations since PAX records are length-prefix strings instead | |
| // of NUL-terminated C-strings. | |
| 'file': 'pax-nul-path.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // Malformed sparse file | |
| 'file': 'malformed-sparse-file.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // PAX records that do not have a new line at the end. | |
| 'file': 'invalid-pax-headers.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // Invalid user id | |
| 'file': 'invalid-uid.tar', | |
| 'error': true, | |
| }, | |
| { | |
| // USTAR archive with a regular entry with non-zero device numbers. | |
| 'file': 'ustar-nonzero-device-numbers.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'file', | |
| size: 0, | |
| mode: 420, | |
| typeFlag: TypeFlag.reg, | |
| modified: millisecondsSinceEpoch(0), | |
| userName: 'Jonas', | |
| groupName: 'Google', | |
| devMajor: 1, | |
| devMinor: 1, | |
| format: TarFormat.ustar, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Works on BSD tar v3.1.2 and GNU tar v.1.27.1. | |
| 'file': 'gnu-nil-sparse-data.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'nil-sparse-data', | |
| mode: 0, | |
| typeFlag: TypeFlag.gnuSparse, | |
| userId: 1000, | |
| groupId: 1000, | |
| size: 1000, | |
| modified: millisecondsSinceEpoch(1597756076000), | |
| format: TarFormat.gnu, | |
| ) | |
| ], | |
| }, | |
| { | |
| // Works on BSD tar v3.1.2 and GNU tar v.1.27.1. | |
| 'file': 'gnu-nil-sparse-hole.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'nil-sparse-hole', | |
| mode: 0, | |
| typeFlag: TypeFlag.gnuSparse, | |
| size: 1000, | |
| userId: 1000, | |
| groupId: 1000, | |
| modified: millisecondsSinceEpoch(1597756079000), | |
| format: TarFormat.gnu, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Works on BSD tar v3.1.2 and GNU tar v.1.27.1. | |
| 'file': 'pax-nil-sparse-data.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'sparse', | |
| mode: 0, | |
| typeFlag: TypeFlag.reg, | |
| size: 1000, | |
| userId: 1000, | |
| groupId: 1000, | |
| modified: millisecondsSinceEpoch(1597756076000), | |
| format: TarFormat.pax, | |
| ) | |
| ] | |
| }, | |
| { | |
| // Works on BSD tar v3.1.2 and GNU tar v.1.27.1. | |
| 'file': 'pax-nil-sparse-hole.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'sparse.txt', | |
| mode: 0, | |
| typeFlag: TypeFlag.reg, | |
| size: 1000, | |
| userId: 1000, | |
| groupId: 1000, | |
| modified: millisecondsSinceEpoch(1597756077000), | |
| format: TarFormat.pax, | |
| ) | |
| ] | |
| }, | |
| { | |
| 'file': 'trailing-slash.tar', | |
| 'headers': [ | |
| TarHeader( | |
| typeFlag: TypeFlag.dir, | |
| mode: 0, | |
| size: 0, | |
| name: '987654321/' * 30, | |
| modified: millisecondsSinceEpoch(0), | |
| format: TarFormat.pax, | |
| ) | |
| ] | |
| }, | |
| { | |
| 'file': 'pax-non-ascii-name.tar', | |
| 'headers': [ | |
| TarHeader( | |
| name: 'æøå/', | |
| mode: 493, | |
| size: 0, | |
| userName: 'sigurdm', | |
| userId: 224757, | |
| groupId: 89939, | |
| groupName: 'primarygroup', | |
| format: TarFormat.pax, | |
| typeFlag: TypeFlag.dir, | |
| modified: DateTime.utc(2020, 10, 13, 13, 04, 32, 608, 662), | |
| ), | |
| TarHeader( | |
| name: 'æøå/æøå.dart', | |
| mode: 420, | |
| size: 1024, | |
| userName: 'sigurdm', | |
| userId: 224757, | |
| groupId: 89939, | |
| groupName: 'primarygroup', | |
| format: TarFormat.pax, | |
| typeFlag: TypeFlag.reg, | |
| modified: DateTime.utc(2020, 10, 13, 13, 05, 12, 105, 884), | |
| ), | |
| ] | |
| } | |
| ]; | |
| Matcher matchesHeader(TarHeader expected) { | |
| return isA<TarHeader>() | |
| .having((e) => e.name, 'name', expected.name) | |
| .having((e) => e.modified, 'modified', expected.modified) | |
| .having((e) => e.linkName, 'linkName', expected.linkName) | |
| .having((e) => e.mode, 'mode', expected.mode) | |
| .having((e) => e.size, 'size', expected.size) | |
| .having((e) => e.userName, 'userName', expected.userName) | |
| .having((e) => e.userId, 'userId', expected.userId) | |
| .having((e) => e.groupId, 'groupId', expected.groupId) | |
| .having((e) => e.groupName, 'groupName', expected.groupName) | |
| .having((e) => e.accessed, 'accessed', expected.accessed) | |
| .having((e) => e.changed, 'changed', expected.changed) | |
| .having((e) => e.devMajor, 'devMajor', expected.devMajor) | |
| .having((e) => e.devMinor, 'devMinor', expected.devMinor) | |
| .having((e) => e.format, 'format', expected.format) | |
| .having((e) => e.typeFlag, 'typeFlag', expected.typeFlag); | |
| } | |
| for (final testInputs in tests) { | |
| test('${testInputs['file']}', () async { | |
| final tarReader = TarReader(open(testInputs['file']! as String), | |
| maxSpecialFileSize: 16000); | |
| if (testInputs['error'] == true) { | |
| expect(tarReader.moveNext(), throwsFormatException); | |
| } else { | |
| final expectedHeaders = testInputs['headers']! as List<TarHeader>; | |
| for (var i = 0; i < expectedHeaders.length; i++) { | |
| expect(await tarReader.moveNext(), isTrue); | |
| expect(tarReader.current.header, matchesHeader(expectedHeaders[i])); | |
| } | |
| expect(await tarReader.moveNext(), isFalse); | |
| } | |
| }); | |
| } | |
| test('reader produces an empty stream if the entry has no size', () async { | |
| final reader = TarReader(open('trailing-slash.tar')); | |
| while (await reader.moveNext()) { | |
| expect(await reader.current.contents.toList(), isEmpty); | |
| } | |
| }); | |
| }); | |
| test('does not read large headers', () { | |
| final reader = | |
| TarReader(openRead('reference/headers/evil_large_header.tar')); | |
| expect( | |
| reader.moveNext(), | |
| throwsA( | |
| isFormatException.having((e) => e.message, 'message', | |
| contains('hidden entry with an invalid size')), | |
| ), | |
| ); | |
| }); | |
| test('pax precedence', () async { | |
| // Edera discovered a bug in some Rust tar libraries where it was possible | |
| // to make a tar in a tar get read as nested entries: https://edera.dev/stories/tarmageddon | |
| // package:tar never had that issue, but copying a test doesn't hurt. | |
| final reader = | |
| TarReader(openRead('reference/bad/pax-header-precedence.tar')); | |
| for (final expectedName in ['normal.txt', 'blob.bin', 'marker.txt']) { | |
| expect(await reader.moveNext(), isTrue); | |
| expect(reader.current.name, expectedName); | |
| } | |
| }); | |
| group('throws on unexpected EoF', () { | |
| final expectedException = isA<TarException>() | |
| .having((e) => e.message, 'message', contains('Unexpected end')); | |
| test('at header', () { | |
| final reader = | |
| TarReader(openRead('reference/bad/truncated_in_header.tar')); | |
| expect(reader.moveNext(), throwsA(expectedException)); | |
| }); | |
| test('in content', () { | |
| final reader = TarReader(openRead('reference/bad/truncated_in_body.tar')); | |
| expect(reader.moveNext(), throwsA(expectedException)); | |
| }); | |
| }); | |
| test('throws for invalid utf8 in pax key', () async { | |
| final reader = TarReader(openRead('reference/bad/invalid_pax_header.tar')); | |
| expect(reader.moveNext(), throwsA(isA<TarException>())); | |
| }); | |
| test('throws for zero-length pax data', () async { | |
| final reader = TarReader(openRead('reference/bad/invalid_pax_len.tar')); | |
| expect(reader.moveNext(), throwsA(isA<TarException>())); | |
| }); | |
| group('PAX headers', () { | |
| test('locals overwrite globals', () { | |
| final header = PaxHeaders() | |
| ..newGlobals({'foo': 'foo', 'bar': 'bar'}) | |
| ..newLocals({'foo': 'local'}); | |
| expect(header.keys, containsAll(<String>['foo', 'bar'])); | |
| expect(header['foo'], 'local'); | |
| }); | |
| group('parse', () { | |
| final mediumName = 'CD' * 50; | |
| final longName = 'AB' * 100; | |
| final tests = [ | |
| ('6 k=v\n\n', 'k', 'v', true), | |
| ('19 path=/etc/hosts\n', 'path', '/etc/hosts', true), | |
| ('210 path=$longName\nabc', 'path', longName, true), | |
| ('110 path=$mediumName\n', 'path', mediumName, true), | |
| ('9 foo=ba\n', 'foo', 'ba', true), | |
| ('11 foo=bar\n\x00', 'foo', 'bar', true), | |
| ('18 foo=b=\nar=\n==\x00\n', 'foo', 'b=\nar=\n==\x00', true), | |
| ('27 foo=hello9 foo=ba\nworld\n', 'foo', 'hello9 foo=ba\nworld', true), | |
| ('27 ☺☻☹=日a本b語ç\n', '☺☻☹', '日a本b語ç', true), | |
| ('17 \x00hello=\x00world\n', '', '', false), | |
| ('1 k=1\n', '', '', false), | |
| ('6 k~1\n', '', '', false), | |
| ('6 k=1 ', '', '', false), | |
| ('632 k=1\n', '', '', false), | |
| ('16 longkeyname=hahaha\n', '', '', false), | |
| ('3 somelongkey=\n', '', '', false), | |
| ('50 tooshort=\n', '', '', false), | |
| ('5 k=\n', 'k', '', true), | |
| ('4 =\n', '', '', false), | |
| ('4 =', '', '', false), | |
| ]; | |
| for (var i = 0; i < tests.length; i++) { | |
| final input = tests[i]; | |
| test('parsePax #$i', () { | |
| final headers = PaxHeaders(); | |
| final (rawStr, key, value, isValid) = input; | |
| final raw = utf8.encode(rawStr); | |
| if (isValid) { | |
| headers.readPaxHeaders(raw, false, ignoreUnknown: false); | |
| expect(headers.keys, [key]); | |
| expect(headers[key], value); | |
| } else { | |
| expect(() => headers.readPaxHeaders(raw, false), | |
| throwsA(isA<TarException>())); | |
| } | |
| }); | |
| } | |
| }); | |
| }); | |
| } | |
| Future<void> _testWith(String file, {bool ignoreLongFileName = false}) async { | |
| final entries = <String, Uint8List>{}; | |
| await TarReader.forEach(openRead(file), (entry) async { | |
| entries[entry.name] = await entry.contents.readFully(); | |
| }); | |
| final testEntry = entries['reference/res/test.txt']!; | |
| expect(utf8.decode(testEntry), 'Test file content!\n'); | |
| if (!ignoreLongFileName) { | |
| final longName = entries['reference/res/' | |
| 'subdirectory_with_a_long_name/' | |
| 'file_with_a_path_length_of_more_than_100_characters_so_that_it_gets_split.txt']!; | |
| expect(utf8.decode(longName), 'ditto'); | |
| } | |
| } | |
| Future<void> _testLargeFile(String file) async { | |
| final reader = TarReader(openRead(file)); | |
| await reader.moveNext(); | |
| expect(reader.current.size, 9663676416); | |
| } | |
| extension on Stream<List<int>> { | |
| Future<Uint8List> readFully() async { | |
| final builder = BytesBuilder(); | |
| await forEach(builder.add); | |
| return builder.takeBytes(); | |
| } | |
| } |