Intermediate commit

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
-using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Tar;
@@ -74,9 +73,9 @@ namespace SharpCompress.Archives.Tar
         {
             try
             {
-                TarHeader tar = new TarHeader();
-                tar.Read(new BinaryReader(stream));
-                return tar.Name.Length > 0 && Enum.IsDefined(typeof(EntryType), tar.EntryType);
+                var input = new TarInputStream(stream);
+                var header = input.GetNextEntry();
+                return header.Name.Length > 0;
             }
             catch
             {
@@ -131,7 +130,7 @@ namespace SharpCompress.Archives.Tar
             {
                 if (header != null)
                 {
-                    if (header.EntryType == EntryType.LongName)
+                    if (header.TypeFlag == TarHeader.LF_GNU_LONGNAME)
                     {
                         previousHeader = header;
                     }

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Converters;

src/SharpCompress/Common/Tar/Headers/EntryType.cs

@@ -1,19 +0,0 @@
-namespace SharpCompress.Common.Tar.Headers
-{
-    internal enum EntryType : byte
-    {
-        File = 0,
-        OldFile = (byte)'0',
-        HardLink = (byte)'1',
-        SymLink = (byte)'2',
-        CharDevice = (byte)'3',
-        BlockDevice = (byte)'4',
-        Directory = (byte)'5',
-        Fifo = (byte)'6',
-        LongLink = (byte)'K',
-        LongName = (byte)'L',
-        SparseFile = (byte)'S',
-        VolumeHeader = (byte)'V',
-        GlobalExtendedHeader = (byte)'g'
-    }
-}

src/SharpCompress/Common/Tar/Headers/TarHeader.cs

@@ -1,269 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using SharpCompress.Converters;
-
-namespace SharpCompress.Common.Tar.Headers
-{
-    internal class TarHeader
-    {
-        internal static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        internal string Name { get; set; }
-
-        //internal int Mode { get; set; }
-        //internal int UserId { get; set; }
-        //internal string UserName { get; set; }
-        //internal int GroupId { get; set; }
-        //internal string GroupName { get; set; }
-        internal long Size { get; set; }
-        internal DateTime LastModifiedTime { get; set; }
-        internal EntryType EntryType { get; set; }
-        internal Stream PackedStream { get; set; }
-
-        internal const int BlockSize = 512;
-
-        internal void Write(Stream output)
-        {
-            byte[] buffer = new byte[BlockSize];
-
-            WriteOctalBytes(511, buffer, 100, 8); // file mode
-            WriteOctalBytes(0, buffer, 108, 8); // owner ID
-            WriteOctalBytes(0, buffer, 116, 8); // group ID
-
-            //Encoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
-            if (Name.Length > 100)
-            {
-                // Set mock filename and filetype to indicate the next block is the actual name of the file
-                WriteStringBytes("././@LongLink", buffer, 0, 100);
-                buffer[156] = (byte)EntryType.LongName;
-                WriteOctalBytes(Name.Length + 1, buffer, 124, 12);
-            }
-            else
-            {
-                WriteStringBytes(Name, buffer, 0, 100);
-                WriteOctalBytes(Size, buffer, 124, 12);
-                var time = (long)(LastModifiedTime.ToUniversalTime() - Epoch).TotalSeconds;
-                WriteOctalBytes(time, buffer, 136, 12);
-                buffer[156] = (byte)EntryType;
-
-                if (Size >= 0x1FFFFFFFF)
-                {
-                    byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
-                    var bytes12 = new byte[12];
-                    bytes.CopyTo(bytes12, 12 - bytes.Length);
-                    bytes12[0] |= 0x80;
-                    bytes12.CopyTo(buffer, 124);
-                }
-            }
-
-            int crc = RecalculateChecksum(buffer);
-            WriteOctalBytes(crc, buffer, 148, 8);
-
-            output.Write(buffer, 0, buffer.Length);
-
-            if (Name.Length > 100)
-            {
-                WriteLongFilenameHeader(output);
-                Name = Name.Substring(0, 100);
-                Write(output);
-            }
-        }
-
-        private void WriteLongFilenameHeader(Stream output)
-        {
-            byte[] nameBytes = ArchiveEncoding.Default.GetBytes(Name);
-            output.Write(nameBytes, 0, nameBytes.Length);
-
-            // pad to multiple of BlockSize bytes, and make sure a terminating null is added
-            int numPaddingBytes = BlockSize - (nameBytes.Length % BlockSize);
-            if (numPaddingBytes == 0)
-            {
-                numPaddingBytes = BlockSize;
-            }
-            output.Write(new byte[numPaddingBytes], 0, numPaddingBytes);
-        }
-
-        internal bool Read(BinaryReader reader)
-        {
-            var buffer = ReadBlock(reader);
-            if (buffer.Length == 0)
-            {
-                return false;
-            }
-
-            if (ReadEntryType(buffer) == EntryType.LongName)
-            {
-                Name = ReadLongName(reader, buffer);
-                buffer = ReadBlock(reader);
-            }
-            else
-            {
-                Name = ArchiveEncoding.Default.GetString(buffer, 0, 100).TrimNulls();
-            }
-
-            EntryType = ReadEntryType(buffer);
-            Size = ReadSize(buffer);
-
-            //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
-            //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
-            //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
-            long unixTimeStamp = ReadASCIIInt64Base8(buffer, 136, 11);
-            LastModifiedTime = Epoch.AddSeconds(unixTimeStamp).ToLocalTime();
-
-            Magic = ArchiveEncoding.Default.GetString(buffer, 257, 6).TrimNulls();
-
-            if (!string.IsNullOrEmpty(Magic)
-                && "ustar".Equals(Magic))
-            {
-                string namePrefix = ArchiveEncoding.Default.GetString(buffer, 345, 157);
-                namePrefix = namePrefix.TrimNulls();
-                if (!string.IsNullOrEmpty(namePrefix))
-                {
-                    Name = namePrefix + "/" + Name;
-                }
-            }
-            if (EntryType != EntryType.LongName
-                && Name.Length == 0)
-            {
-                return false;
-            }
-            return true;
-        }
-
-        private string ReadLongName(BinaryReader reader, byte[] buffer)
-        {
-            var size = ReadSize(buffer);
-            var nameLength = (int)size;
-            var nameBytes = reader.ReadBytes(nameLength);
-            var remainingBytesToRead = BlockSize - (nameLength % BlockSize);
-
-            // Read the rest of the block and discard the data
-            if (remainingBytesToRead < BlockSize)
-            {
-                reader.ReadBytes(remainingBytesToRead);
-            }
-            return ArchiveEncoding.Default.GetString(nameBytes, 0, nameBytes.Length).TrimNulls();
-        }
-
-        private static EntryType ReadEntryType(byte[] buffer)
-        {
-            return (EntryType)buffer[156];
-        }
-
-        private long ReadSize(byte[] buffer)
-        {
-            if ((buffer[124] & 0x80) == 0x80) // if size in binary
-            {
-                return DataConverter.BigEndian.GetInt64(buffer, 0x80);
-            }
-            return ReadASCIIInt64Base8(buffer, 124, 11);
-        }
-
-        private static byte[] ReadBlock(BinaryReader reader)
-        {
-            byte[] buffer = reader.ReadBytes(BlockSize);
-
-            if (buffer.Length != 0 && buffer.Length < BlockSize)
-            {
-                throw new InvalidOperationException("Buffer is invalid size");
-            }
-            return buffer;
-        }
-
-        private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
-        {
-            int i;
-
-            for (i = 0; i < length - 1 && i < name.Length; ++i)
-            {
-                buffer[offset + i] = (byte)name[i];
-            }
-
-            for (; i < length; ++i)
-            {
-                buffer[offset + i] = 0;
-            }
-        }
-
-        private static void WriteOctalBytes(long value, byte[] buffer, int offset, int length)
-        {
-            string val = Convert.ToString(value, 8);
-            int shift = length - val.Length - 1;
-            for (int i = 0; i < shift; i++)
-            {
-                buffer[offset + i] = (byte)' ';
-            }
-            for (int i = 0; i < val.Length; i++)
-            {
-                buffer[offset + i + shift] = (byte)val[i];
-            }
-        }
-
-        private static int ReadASCIIInt32Base8(byte[] buffer, int offset, int count)
-        {
-            string s = Encoding.UTF8.GetString(buffer, offset, count).TrimNulls();
-            if (string.IsNullOrEmpty(s))
-            {
-                return 0;
-            }
-            return Convert.ToInt32(s, 8);
-        }
-
-        private static long ReadASCIIInt64Base8(byte[] buffer, int offset, int count)
-        {
-            string s = Encoding.UTF8.GetString(buffer, offset, count).TrimNulls();
-            if (string.IsNullOrEmpty(s))
-            {
-                return 0;
-            }
-            return Convert.ToInt64(s, 8);
-        }
-
-        private static long ReadASCIIInt64(byte[] buffer, int offset, int count)
-        {
-            string s = Encoding.UTF8.GetString(buffer, offset, count).TrimNulls();
-            if (string.IsNullOrEmpty(s))
-            {
-                return 0;
-            }
-            return Convert.ToInt64(s);
-        }
-
-        internal static int RecalculateChecksum(byte[] buf)
-        {
-            // Set default value for checksum. That is 8 spaces.
-            Encoding.UTF8.GetBytes("        ").CopyTo(buf, 148);
-
-            // Calculate checksum
-            int headerChecksum = 0;
-            foreach (byte b in buf)
-            {
-                headerChecksum += b;
-            }
-            return headerChecksum;
-        }
-
-        internal static int RecalculateAltChecksum(byte[] buf)
-        {
-            Encoding.UTF8.GetBytes("        ").CopyTo(buf, 148);
-            int headerChecksum = 0;
-            foreach (byte b in buf)
-            {
-                if ((b & 0x80) == 0x80)
-                {
-                    headerChecksum -= b ^ 0x80;
-                }
-                else
-                {
-                    headerChecksum += b;
-                }
-            }
-            return headerChecksum;
-        }
-
-        public long? DataStartPosition { get; set; }
-
-        public string Magic { get; set; }
-    }
-}

src/SharpCompress/Common/Tar/TarBuffer.cs

@@ -0,0 +1,541 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common.Tar
+{
+	/// <summary>
+	/// The TarBuffer class implements the tar archive concept
+	/// of a buffered input stream. This concept goes back to the
+	/// days of blocked tape drives and special io devices. In the
+	/// C# universe, the only real function that this class
+	/// performs is to ensure that files have the correct "record"
+	/// size, or other tars will complain.
+	/// <p>
+	/// You should never have a need to access this class directly.
+	/// TarBuffers are created by Tar IO Streams.
+	/// </p>
+	/// </summary>
+	public class TarBuffer
+	{
+
+		/* A quote from GNU tar man file on blocking and records
+		   A `tar' archive file contains a series of blocks.  Each block
+		contains `BLOCKSIZE' bytes.  Although this format may be thought of as
+		being on magnetic tape, other media are often used.
+
+		   Each file archived is represented by a header block which describes
+		the file, followed by zero or more blocks which give the contents of
+		the file.  At the end of the archive file there may be a block filled
+		with binary zeros as an end-of-file marker.  A reasonable system should
+		write a block of zeros at the end, but must not assume that such a
+		block exists when reading an archive.
+
+		   The blocks may be "blocked" for physical I/O operations.  Each
+		record of N blocks is written with a single 'write ()'
+		operation.  On magnetic tapes, the result of such a write is a single
+		record.  When writing an archive, the last record of blocks should be
+		written at the full size, with blocks after the zero block containing
+		all zeros.  When reading an archive, a reasonable system should
+		properly handle an archive whose last record is shorter than the rest,
+		or which contains garbage records after a zero block.
+		*/
+
+		#region Constants
+		/// <summary>
+		/// The size of a block in a tar archive in bytes.
+		/// </summary>
+		/// <remarks>This is 512 bytes.</remarks>
+		public const int BlockSize = 512;
+
+		/// <summary>
+		/// The number of blocks in a default record.
+		/// </summary>
+		/// <remarks>
+		/// The default value is 20 blocks per record.
+		/// </remarks>
+		public const int DefaultBlockFactor = 20;
+
+		/// <summary>
+		/// The size in bytes of a default record.
+		/// </summary>
+		/// <remarks>
+		/// The default size is 10KB.
+		/// </remarks>
+		public const int DefaultRecordSize = BlockSize * DefaultBlockFactor;
+		#endregion
+
+		/// <summary>
+		/// Get the record size for this buffer
+		/// </summary>
+		/// <value>The record size in bytes.
+		/// This is equal to the <see cref="BlockFactor"/> multiplied by the <see cref="BlockSize"/></value>
+		public int RecordSize => recordSize;
+
+	    /// <summary>
+		/// Get the TAR Buffer's record size.
+		/// </summary>
+		/// <returns>The record size in bytes.
+		/// This is equal to the <see cref="BlockFactor"/> multiplied by the <see cref="BlockSize"/></returns>
+		[Obsolete("Use RecordSize property instead")]
+		public int GetRecordSize()
+		{
+			return recordSize;
+		}
+
+		/// <summary>
+		/// Get the Blocking factor for the buffer
+		/// </summary>
+		/// <value>This is the number of blocks in each record.</value>
+		public int BlockFactor => blockFactor;
+
+	    /// <summary>
+		/// Get the TAR Buffer's block factor
+		/// </summary>
+		/// <returns>The block factor; the number of blocks per record.</returns>
+		[Obsolete("Use BlockFactor property instead")]
+		public int GetBlockFactor()
+		{
+			return blockFactor;
+		}
+
+		/// <summary>
+		/// Construct a default TarBuffer
+		/// </summary>
+		protected TarBuffer()
+		{
+		}
+
+		/// <summary>
+		/// Create TarBuffer for reading with default BlockFactor
+		/// </summary>
+		/// <param name="inputStream">Stream to buffer</param>
+		/// <returns>A new <see cref="TarBuffer"/> suitable for input.</returns>
+		public static TarBuffer CreateInputTarBuffer(Stream inputStream)
+		{
+			if (inputStream == null) {
+				throw new ArgumentNullException(nameof(inputStream));
+			}
+
+			return CreateInputTarBuffer(inputStream, DefaultBlockFactor);
+		}
+
+		/// <summary>
+		/// Construct TarBuffer for reading inputStream setting BlockFactor
+		/// </summary>
+		/// <param name="inputStream">Stream to buffer</param>
+		/// <param name="blockFactor">Blocking factor to apply</param>
+		/// <returns>A new <see cref="TarBuffer"/> suitable for input.</returns>
+		public static TarBuffer CreateInputTarBuffer(Stream inputStream, int blockFactor)
+		{
+			if (inputStream == null) {
+				throw new ArgumentNullException(nameof(inputStream));
+			}
+
+			if (blockFactor <= 0) {
+				throw new ArgumentOutOfRangeException(nameof(blockFactor), "Factor cannot be negative");
+			}
+
+		    var tarBuffer = new TarBuffer
+		                    {
+		                        inputStream = inputStream,
+		                        outputStream = null
+		                    };
+		    tarBuffer.Initialize(blockFactor);
+
+			return tarBuffer;
+		}
+
+		/// <summary>
+		/// Construct TarBuffer for writing with default BlockFactor
+		/// </summary>
+		/// <param name="outputStream">output stream for buffer</param>
+		/// <returns>A new <see cref="TarBuffer"/> suitable for output.</returns>
+		public static TarBuffer CreateOutputTarBuffer(Stream outputStream)
+		{
+			if (outputStream == null) {
+				throw new ArgumentNullException(nameof(outputStream));
+			}
+
+			return CreateOutputTarBuffer(outputStream, DefaultBlockFactor);
+		}
+
+		/// <summary>
+		/// Construct TarBuffer for writing Tar output to streams.
+		/// </summary>
+		/// <param name="outputStream">Output stream to write to.</param>
+		/// <param name="blockFactor">Blocking factor to apply</param>
+		/// <returns>A new <see cref="TarBuffer"/> suitable for output.</returns>
+		public static TarBuffer CreateOutputTarBuffer(Stream outputStream, int blockFactor)
+		{
+			if (outputStream == null) {
+				throw new ArgumentNullException(nameof(outputStream));
+			}
+
+			if (blockFactor <= 0) {
+				throw new ArgumentOutOfRangeException(nameof(blockFactor), "Factor cannot be negative");
+			}
+
+			var tarBuffer = new TarBuffer();
+			tarBuffer.inputStream = null;
+			tarBuffer.outputStream = outputStream;
+			tarBuffer.Initialize(blockFactor);
+
+			return tarBuffer;
+		}
+
+		/// <summary>
+		/// Initialization common to all constructors.
+		/// </summary>
+		void Initialize(int archiveBlockFactor)
+		{
+			blockFactor = archiveBlockFactor;
+			recordSize = archiveBlockFactor * BlockSize;
+			recordBuffer = new byte[RecordSize];
+
+			if (inputStream != null) {
+				currentRecordIndex = -1;
+				currentBlockIndex = BlockFactor;
+			} else {
+				currentRecordIndex = 0;
+				currentBlockIndex = 0;
+			}
+		}
+
+		/// <summary>
+		/// Determine if an archive block indicates End of Archive. End of
+		/// archive is indicated by a block that consists entirely of null bytes.
+		/// All remaining blocks for the record should also be null's
+		/// However some older tars only do a couple of null blocks (Old GNU tar for one)
+		/// and also partial records
+		/// </summary>
+		/// <param name = "block">The data block to check.</param>
+		/// <returns>Returns true if the block is an EOF block; false otherwise.</returns>
+		[Obsolete("Use IsEndOfArchiveBlock instead")]
+		public bool IsEOFBlock(byte[] block)
+		{
+			if (block == null) {
+				throw new ArgumentNullException(nameof(block));
+			}
+
+			if (block.Length != BlockSize) {
+				throw new ArgumentException("block length is invalid");
+			}
+
+			for (int i = 0; i < BlockSize; ++i) {
+				if (block[i] != 0) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+
+		/// <summary>
+		/// Determine if an archive block indicates the End of an Archive has been reached.
+		/// End of archive is indicated by a block that consists entirely of null bytes.
+		/// All remaining blocks for the record should also be null's
+		/// However some older tars only do a couple of null blocks (Old GNU tar for one)
+		/// and also partial records
+		/// </summary>
+		/// <param name = "block">The data block to check.</param>
+		/// <returns>Returns true if the block is an EOF block; false otherwise.</returns>
+		public static bool IsEndOfArchiveBlock(byte[] block)
+		{
+			if (block == null) {
+				throw new ArgumentNullException(nameof(block));
+			}
+
+			if (block.Length != BlockSize) {
+				throw new ArgumentException("block length is invalid");
+			}
+
+			for (int i = 0; i < BlockSize; ++i) {
+				if (block[i] != 0) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/// <summary>
+		/// Skip over a block on the input stream.
+		/// </summary>
+		public void SkipBlock()
+		{
+			if (inputStream == null) {
+				throw new TarException("no input stream defined");
+			}
+
+			if (currentBlockIndex >= BlockFactor) {
+				if (!ReadRecord()) {
+					throw new TarException("Failed to read a record");
+				}
+			}
+
+			currentBlockIndex++;
+		}
+
+		/// <summary>
+		/// Read a block from the input stream.
+		/// </summary>
+		/// <returns>
+		/// The block of data read.
+		/// </returns>
+		public byte[] ReadBlock()
+		{
+			if (inputStream == null) {
+				throw new TarException("TarBuffer.ReadBlock - no input stream defined");
+			}
+
+			if (currentBlockIndex >= BlockFactor) {
+				if (!ReadRecord()) {
+					throw new TarException("Failed to read a record");
+				}
+			}
+
+			byte[] result = new byte[BlockSize];
+
+			Array.Copy(recordBuffer, (currentBlockIndex * BlockSize), result, 0, BlockSize);
+			currentBlockIndex++;
+			return result;
+		}
+
+		/// <summary>
+		/// Read a record from data stream.
+		/// </summary>
+		/// <returns>
+		/// false if End-Of-File, else true.
+		/// </returns>
+		bool ReadRecord()
+		{
+			if (inputStream == null) {
+				throw new TarException("no input stream stream defined");
+			}
+
+			currentBlockIndex = 0;
+
+			int offset = 0;
+			int bytesNeeded = RecordSize;
+
+			while (bytesNeeded > 0) {
+				long numBytes = inputStream.Read(recordBuffer, offset, bytesNeeded);
+
+				//
+				// NOTE
+				// We have found EOF, and the record is not full!
+				//
+				// This is a broken archive. It does not follow the standard
+				// blocking algorithm. However, because we are generous, and
+				// it requires little effort, we will simply ignore the error
+				// and continue as if the entire record were read. This does
+				// not appear to break anything upstream. We used to return
+				// false in this case.
+				//
+				// Thanks to 'Yohann.Roussel@alcatel.fr' for this fix.
+				//
+				if (numBytes <= 0) {
+					break;
+				}
+
+				offset += (int)numBytes;
+				bytesNeeded -= (int)numBytes;
+			}
+
+			currentRecordIndex++;
+			return true;
+		}
+
+		/// <summary>
+		/// Get the current block number, within the current record, zero based.
+		/// </summary>
+		/// <remarks>Block numbers are zero based values</remarks>
+		/// <seealso cref="RecordSize"/>
+		public int CurrentBlock => currentBlockIndex;
+
+	    /// <summary>
+		/// Get/set flag indicating ownership of the underlying stream.
+		/// When the flag is true <see cref="Close"></see> will close the underlying stream also.
+		/// </summary>
+		public bool IsStreamOwner {
+			get => isStreamOwner_;
+	        set => isStreamOwner_ = value;
+	    }
+
+		/// <summary>
+		/// Get the current block number, within the current record, zero based.
+		/// </summary>
+		/// <returns>
+		/// The current zero based block number.
+		/// </returns>
+		/// <remarks>
+		/// The absolute block number = (<see cref="GetCurrentRecordNum">record number</see> * <see cref="BlockFactor">block factor</see>) + <see cref="GetCurrentBlockNum">block number</see>.
+		/// </remarks>
+		[Obsolete("Use CurrentBlock property instead")]
+		public int GetCurrentBlockNum()
+		{
+			return currentBlockIndex;
+		}
+
+		/// <summary>
+		/// Get the current record number.
+		/// </summary>
+		/// <returns>
+		/// The current zero based record number.
+		/// </returns>
+		public int CurrentRecord => currentRecordIndex;
+
+	    /// <summary>
+		/// Get the current record number.
+		/// </summary>
+		/// <returns>
+		/// The current zero based record number.
+		/// </returns>
+		[Obsolete("Use CurrentRecord property instead")]
+		public int GetCurrentRecordNum()
+		{
+			return currentRecordIndex;
+		}
+
+		/// <summary>
+		/// Write a block of data to the archive.
+		/// </summary>
+		/// <param name="block">
+		/// The data to write to the archive.
+		/// </param>
+		public void WriteBlock(byte[] block)
+		{
+			if (block == null) {
+				throw new ArgumentNullException(nameof(block));
+			}
+
+			if (outputStream == null) {
+				throw new TarException("TarBuffer.WriteBlock - no output stream defined");
+			}
+
+			if (block.Length != BlockSize) {
+				string errorText = string.Format("TarBuffer.WriteBlock - block to write has length '{0}' which is not the block size of '{1}'",
+					block.Length, BlockSize);
+				throw new TarException(errorText);
+			}
+
+			if (currentBlockIndex >= BlockFactor) {
+				WriteRecord();
+			}
+
+			Array.Copy(block, 0, recordBuffer, (currentBlockIndex * BlockSize), BlockSize);
+			currentBlockIndex++;
+		}
+
+		/// <summary>
+		/// Write an archive record to the archive, where the record may be
+		/// inside of a larger array buffer. The buffer must be "offset plus
+		/// record size" long.
+		/// </summary>
+		/// <param name="buffer">
+		/// The buffer containing the record data to write.
+		/// </param>
+		/// <param name="offset">
+		/// The offset of the record data within buffer.
+		/// </param>
+		public void WriteBlock(byte[] buffer, int offset)
+		{
+			if (buffer == null) {
+				throw new ArgumentNullException(nameof(buffer));
+			}
+
+			if (outputStream == null) {
+				throw new TarException("TarBuffer.WriteBlock - no output stream stream defined");
+			}
+
+			if ((offset < 0) || (offset >= buffer.Length)) {
+				throw new ArgumentOutOfRangeException(nameof(offset));
+			}
+
+			if ((offset + BlockSize) > buffer.Length) {
+				string errorText = string.Format("TarBuffer.WriteBlock - record has length '{0}' with offset '{1}' which is less than the record size of '{2}'",
+					buffer.Length, offset, recordSize);
+				throw new TarException(errorText);
+			}
+
+			if (currentBlockIndex >= BlockFactor) {
+				WriteRecord();
+			}
+
+			Array.Copy(buffer, offset, recordBuffer, (currentBlockIndex * BlockSize), BlockSize);
+
+			currentBlockIndex++;
+		}
+
+		/// <summary>
+		/// Write a TarBuffer record to the archive.
+		/// </summary>
+		void WriteRecord()
+		{
+			if (outputStream == null) {
+				throw new TarException("TarBuffer.WriteRecord no output stream defined");
+			}
+
+			outputStream.Write(recordBuffer, 0, RecordSize);
+			outputStream.Flush();
+
+			currentBlockIndex = 0;
+			currentRecordIndex++;
+		}
+
+		/// <summary>
+		/// WriteFinalRecord writes the current record buffer to output any unwritten data is present.
+		/// </summary>
+		/// <remarks>Any trailing bytes are set to zero which is by definition correct behaviour
+		/// for the end of a tar stream.</remarks>
+		void WriteFinalRecord()
+		{
+			if (outputStream == null) {
+				throw new TarException("TarBuffer.WriteFinalRecord no output stream defined");
+			}
+
+			if (currentBlockIndex > 0) {
+				int dataBytes = currentBlockIndex * BlockSize;
+				Array.Clear(recordBuffer, dataBytes, RecordSize - dataBytes);
+				WriteRecord();
+			}
+
+			outputStream.Flush();
+		}
+
+		/// <summary>
+		/// Close the TarBuffer. If this is an output buffer, also flush the
+		/// current block before closing.
+		/// </summary>
+		public void Close()
+		{
+			if (outputStream != null) {
+				WriteFinalRecord();
+
+				if (isStreamOwner_) {
+					outputStream.Dispose();
+				}
+				outputStream = null;
+			} else if (inputStream != null) {
+				if (isStreamOwner_) {
+					inputStream.Dispose();
+				}
+				inputStream = null;
+			}
+		}
+
+		#region Instance Fields
+		Stream inputStream;
+		Stream outputStream;
+
+		byte[] recordBuffer;
+		int currentBlockIndex;
+		int currentRecordIndex;
+
+		int recordSize = DefaultRecordSize;
+		int blockFactor = DefaultBlockFactor;
+		bool isStreamOwner_ = true;
+		#endregion
+	}
+}

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar
@@ -16,6 +15,8 @@ namespace SharpCompress.Common.Tar
             CompressionType = type;
         }
 
+        internal TarHeader Header => filePart.Header;
+
         public override CompressionType CompressionType { get; }
 
         public override long Crc => 0;
@@ -26,7 +27,7 @@ namespace SharpCompress.Common.Tar
 
         public override long Size => filePart.Header.Size;
 
-        public override DateTime? LastModifiedTime => filePart.Header.LastModifiedTime;
+        public override DateTime? LastModifiedTime => filePart.Header.ModTime;
 
         public override DateTime? CreatedTime => null;
 
@@ -36,7 +37,7 @@ namespace SharpCompress.Common.Tar
 
         public override bool IsEncrypted => false;
 
-        public override bool IsDirectory => filePart.Header.EntryType == EntryType.Directory;
+        public override bool IsDirectory => filePart.Header.TypeFlag == TarHeader.LF_DIR;
 
         public override bool IsSplit => false;
 
@@ -45,17 +46,18 @@ namespace SharpCompress.Common.Tar
         internal static IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
                                                          CompressionType compressionType)
         {
-            foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream))
+            using (var tarStream = new TarInputStream(stream))
             {
-                if (h != null)
+                TarHeader header = null;
+                while ((header = tarStream.GetNextEntry()) != null)
                 {
                     if (mode == StreamingMode.Seekable)
                     {
-                        yield return new TarEntry(new TarFilePart(h, stream), compressionType);
+                        yield return new TarEntry(new TarFilePart(header, stream), compressionType);
                     }
                     else
                     {
-                        yield return new TarEntry(new TarFilePart(h, null), compressionType);
+                        yield return new TarEntry(new TarFilePart(header, null), compressionType);
                     }
                 }
             }

src/SharpCompress/Common/Tar/TarException.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace SharpCompress.Common.Tar
+{
+	/// <summary>
+	/// TarException represents exceptions specific to Tar classes and code.
+	/// </summary>
+	public class TarException : ArchiveException
+	{
+		/// <summary>
+		/// Initialise a new instance of <see cref="TarException" /> with its message string.
+		/// </summary>
+		/// <param name="message">A <see cref="string"/> that describes the error.</param>
+		public TarException(string message)
+			: base(message)
+		{
+		}
+	}
+}

src/SharpCompress/Common/Tar/TarFilePart.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -1,62 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common.Tar.Headers;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Tar
-{
-    internal static class TarHeaderFactory
-    {
-        internal static IEnumerable<TarHeader> ReadHeader(StreamingMode mode, Stream stream)
-        {
-            while (true)
-            {
-                TarHeader header = null;
-                try
-                {
-                    BinaryReader reader = new BinaryReader(stream);
-                    header = new TarHeader();
-                    if (!header.Read(reader))
-                    {
-                        yield break;
-                    }
-                    switch (mode)
-                    {
-                        case StreamingMode.Seekable:
-                        {
-                            header.DataStartPosition = reader.BaseStream.Position;
-
-                            //skip to nearest 512
-                            reader.BaseStream.Position += PadTo512(header.Size);
-                        }
-                            break;
-                        case StreamingMode.Streaming:
-                        {
-                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
-                        }
-                            break;
-                        default:
-                        {
-                            throw new InvalidFormatException("Invalid StreamingMode");
-                        }
-                    }
-                }
-                catch
-                {
-                    header = null;
-                }
-                yield return header;
-            }
-        }
-
-        private static long PadTo512(long size)
-        {
-            int zeros = (int)(size % 512);
-            if (zeros == 0)
-            {
-                return size;
-            }
-            return 512 - zeros + size;
-        }
-    }
-}

src/SharpCompress/Common/Tar/TarInputStream.cs

@@ -0,0 +1,547 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace SharpCompress.Common.Tar
+{
+    /// <summary>
+    /// The TarInputStream reads a UNIX tar archive as an InputStream.
+    /// methods are provided to position at each successive entry in
+    /// the archive, and the read each entry as a normal input stream
+    /// using read().
+    /// </summary>
+    public class TarInputStream : Stream
+    {
+        #region Constructors
+
+        /// <summary>
+        /// Construct a TarInputStream with default block factor
+        /// </summary>
+        /// <param name="inputStream">stream to source data from</param>
+        public TarInputStream(Stream inputStream)
+            : this(inputStream, TarBuffer.DefaultBlockFactor)
+        {
+        }
+
+        /// <summary>
+        /// Construct a TarInputStream with user specified block factor
+        /// </summary>
+        /// <param name="inputStream">stream to source data from</param>
+        /// <param name="blockFactor">block factor to apply to archive</param>
+        public TarInputStream(Stream inputStream, int blockFactor)
+        {
+            this.inputStream = inputStream;
+            tarBuffer = TarBuffer.CreateInputTarBuffer(inputStream, blockFactor);
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Get/set flag indicating ownership of the underlying stream.
+        /// When the flag is true <see cref="Close"></see> will close the underlying stream also.
+        /// </summary>
+        public bool IsStreamOwner { get => tarBuffer.IsStreamOwner; set => tarBuffer.IsStreamOwner = value; }
+
+        #region Stream Overrides
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports reading
+        /// </summary>
+        public override bool CanRead => inputStream.CanRead;
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports seeking
+        /// This property always returns false.
+        /// </summary>
+        public override bool CanSeek => false;
+
+        /// <summary>
+        /// Gets a value indicating if the stream supports writing.
+        /// This property always returns false.
+        /// </summary>
+        public override bool CanWrite => false;
+
+        /// <summary>
+        /// The length in bytes of the stream
+        /// </summary>
+        public override long Length => inputStream.Length;
+
+        /// <summary>
+        /// Gets or sets the position within the stream. 
+        /// Setting the Position is not supported and throws a NotSupportedExceptionNotSupportedException
+        /// </summary>
+        /// <exception cref="NotSupportedException">Any attempt to set position</exception>
+        public override long Position { get => inputStream.Position; set => throw new NotSupportedException("TarInputStream Seek not supported"); }
+
+        /// <summary>
+        /// Flushes the baseInputStream
+        /// </summary>
+        public override void Flush()
+        {
+            inputStream.Flush();
+        }
+
+        /// <summary>
+        /// Set the streams position.  This operation is not supported and will throw a NotSupportedException
+        /// </summary>
+        /// <param name="offset">The offset relative to the origin to seek to.</param>
+        /// <param name="origin">The <see cref="SeekOrigin"/> to start seeking from.</param>
+        /// <returns>The new position in the stream.</returns>
+        /// <exception cref="NotSupportedException">Any access</exception>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException("TarInputStream Seek not supported");
+        }
+
+        /// <summary>
+        /// Sets the length of the stream
+        /// This operation is not supported and will throw a NotSupportedException
+        /// </summary>
+        /// <param name="value">The new stream length.</param>
+        /// <exception cref="NotSupportedException">Any access</exception>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException("TarInputStream SetLength not supported");
+        }
+
+        /// <summary>
+        /// Writes a block of bytes to this stream using data from a buffer.
+        /// This operation is not supported and will throw a NotSupportedException
+        /// </summary>
+        /// <param name="buffer">The buffer containing bytes to write.</param>
+        /// <param name="offset">The offset in the buffer of the frist byte to write.</param>
+        /// <param name="count">The number of bytes to write.</param>
+        /// <exception cref="NotSupportedException">Any access</exception>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException("TarInputStream Write not supported");
+        }
+
+        /// <summary>
+        /// Writes a byte to the current position in the file stream.
+        /// This operation is not supported and will throw a NotSupportedException
+        /// </summary>
+        /// <param name="value">The byte value to write.</param>
+        /// <exception cref="NotSupportedException">Any access</exception>
+        public override void WriteByte(byte value)
+        {
+            throw new NotSupportedException("TarInputStream WriteByte not supported");
+        }
+
+        /// <summary>
+        /// Reads a byte from the current tar archive entry.
+        /// </summary>
+        /// <returns>A byte cast to an int; -1 if the at the end of the stream.</returns>
+        public override int ReadByte()
+        {
+            byte[] oneByteBuffer = new byte[1];
+            int num = Read(oneByteBuffer, 0, 1);
+            if (num <= 0)
+            {
+                // return -1 to indicate that no byte was read.
+                return -1;
+            }
+            return oneByteBuffer[0];
+        }
+
+        /// <summary>
+        /// Reads bytes from the current tar archive entry.
+        /// 
+        /// This method is aware of the boundaries of the current
+        /// entry in the archive and will deal with them appropriately
+        /// </summary>
+        /// <param name="buffer">
+        /// The buffer into which to place bytes read.
+        /// </param>
+        /// <param name="offset">
+        /// The offset at which to place bytes read.
+        /// </param>
+        /// <param name="count">
+        /// The number of bytes to read.
+        /// </param>
+        /// <returns>
+        /// The number of bytes read, or 0 at end of stream/EOF.
+        /// </returns>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException(nameof(buffer));
+            }
+
+            int totalRead = 0;
+
+            if (entryOffset >= entrySize)
+            {
+                return 0;
+            }
+
+            long numToRead = count;
+
+            if ((numToRead + entryOffset) > entrySize)
+            {
+                numToRead = entrySize - entryOffset;
+            }
+
+            if (readBuffer != null)
+            {
+                int sz = (numToRead > readBuffer.Length) ? readBuffer.Length : (int)numToRead;
+
+                Array.Copy(readBuffer, 0, buffer, offset, sz);
+
+                if (sz >= readBuffer.Length)
+                {
+                    readBuffer = null;
+                }
+                else
+                {
+                    int newLen = readBuffer.Length - sz;
+                    byte[] newBuf = new byte[newLen];
+                    Array.Copy(readBuffer, sz, newBuf, 0, newLen);
+                    readBuffer = newBuf;
+                }
+
+                totalRead += sz;
+                numToRead -= sz;
+                offset += sz;
+            }
+
+            while (numToRead > 0)
+            {
+                byte[] rec = tarBuffer.ReadBlock();
+                if (rec == null)
+                {
+                    // Unexpected EOF!
+                    throw new TarException("unexpected EOF with " + numToRead + " bytes unread");
+                }
+
+                var sz = (int)numToRead;
+                int recLen = rec.Length;
+
+                if (recLen > sz)
+                {
+                    Array.Copy(rec, 0, buffer, offset, sz);
+                    readBuffer = new byte[recLen - sz];
+                    Array.Copy(rec, sz, readBuffer, 0, recLen - sz);
+                }
+                else
+                {
+                    sz = recLen;
+                    Array.Copy(rec, 0, buffer, offset, recLen);
+                }
+
+                totalRead += sz;
+                numToRead -= sz;
+                offset += sz;
+            }
+
+            entryOffset += totalRead;
+
+            return totalRead;
+        }
+
+        /// <summary>
+        /// Closes this stream. Calls the TarBuffer's close() method.
+        /// The underlying stream is closed by the TarBuffer.
+        /// </summary>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                tarBuffer.Close();
+            }
+        }
+
+        #endregion
+        
+
+        /// <summary>
+        /// Get the record size being used by this stream's TarBuffer.
+        /// </summary>
+        public int RecordSize => tarBuffer.RecordSize;
+
+        /// <summary>
+        /// Get the record size being used by this stream's TarBuffer.
+        /// </summary>
+        /// <returns>
+        /// TarBuffer record size.
+        /// </returns>
+        [Obsolete("Use RecordSize property instead")]
+        public int GetRecordSize()
+        {
+            return tarBuffer.RecordSize;
+        }
+
+        /// <summary>
+        /// Get the available data that can be read from the current
+        /// entry in the archive. This does not indicate how much data
+        /// is left in the entire archive, only in the current entry.
+        /// This value is determined from the entry's size header field
+        /// and the amount of data already read from the current entry.
+        /// </summary>
+        /// <returns>
+        /// The number of available bytes for the current entry.
+        /// </returns>
+        public long Available => entrySize - entryOffset;
+
+        /// <summary>
+        /// Skip bytes in the input buffer. This skips bytes in the
+        /// current entry's data, not the entire archive, and will
+        /// stop at the end of the current entry's data if the number
+        /// to skip extends beyond that point.
+        /// </summary>
+        /// <param name="skipCount">
+        /// The number of bytes to skip.
+        /// </param>
+        public void Skip(long skipCount)
+        {
+            // TODO: REVIEW efficiency of TarInputStream.Skip
+            // This is horribly inefficient, but it ensures that we
+            // properly skip over bytes via the TarBuffer...
+            //
+            byte[] skipBuf = new byte[8 * 1024];
+
+            for (long num = skipCount; num > 0;)
+            {
+                int toRead = num > skipBuf.Length ? skipBuf.Length : (int)num;
+                int numRead = Read(skipBuf, 0, toRead);
+
+                if (numRead == -1)
+                {
+                    break;
+                }
+
+                num -= numRead;
+            }
+        }
+
+        /// <summary>
+        /// Return a value of true if marking is supported; false otherwise.
+        /// </summary>
+        /// <remarks>Currently marking is not supported, the return value is always false.</remarks>
+        public bool IsMarkSupported => false;
+
+        /// <summary>
+        /// Since we do not support marking just yet, we do nothing.
+        /// </summary>
+        /// <param name ="markLimit">
+        /// The limit to mark.
+        /// </param>
+        public void Mark(int markLimit)
+        {
+        }
+
+        /// <summary>
+        /// Since we do not support marking just yet, we do nothing.
+        /// </summary>
+        public void Reset()
+        {
+        }
+
+        /// <summary>
+        /// Get the next entry in this tar archive. This will skip
+        /// over any remaining data in the current entry, if there
+        /// is one, and place the input stream at the header of the
+        /// next entry, and read the header and instantiate a new
+        /// TarEntry from the header bytes and return that entry.
+        /// If there are no more entries in the archive, null will
+        /// be returned to indicate that the end of the archive has
+        /// been reached.
+        /// </summary>
+        /// <returns>
+        /// The next TarEntry in the archive, or null.
+        /// </returns>
+        public TarHeader GetNextEntry()
+        {
+            if (hasHitEOF)
+            {
+                return null;
+            }
+
+            if (currentEntry != null)
+            {
+                SkipToNextEntry();
+            }
+
+            byte[] headerBuf = tarBuffer.ReadBlock();
+
+            if (headerBuf == null)
+            {
+                hasHitEOF = true;
+            }
+            else
+                hasHitEOF |= TarBuffer.IsEndOfArchiveBlock(headerBuf);
+
+            if (hasHitEOF)
+            {
+                currentEntry = null;
+            }
+            else
+            {
+                try
+                {
+                    var header = new TarHeader();
+                    header.ParseBuffer(headerBuf);
+                    if (!header.IsChecksumValid)
+                    {
+                        throw new TarException("Header checksum is invalid");
+                    }
+                    this.entryOffset = 0;
+                    this.entrySize = header.Size;
+
+                    StringBuilder longName = null;
+
+                    if (header.TypeFlag == TarHeader.LF_GNU_LONGNAME)
+                    {
+                        byte[] nameBuffer = new byte[TarBuffer.BlockSize];
+                        long numToRead = this.entrySize;
+
+                        longName = new StringBuilder();
+
+                        while (numToRead > 0)
+                        {
+                            int numRead = this.Read(nameBuffer, 0, (numToRead > nameBuffer.Length ? nameBuffer.Length : (int)numToRead));
+
+                            if (numRead == -1)
+                            {
+                                throw new TarException("Failed to read long name entry");
+                            }
+
+                            longName.Append(TarHeader.ParseName(nameBuffer, 0, numRead).ToString());
+                            numToRead -= numRead;
+                        }
+
+                        SkipToNextEntry();
+                        headerBuf = this.tarBuffer.ReadBlock();
+                    }
+                    else if (header.TypeFlag == TarHeader.LF_GHDR)
+                    {
+                        // POSIX global extended header 
+                        // Ignore things we dont understand completely for now
+                        SkipToNextEntry();
+                        headerBuf = this.tarBuffer.ReadBlock();
+                    }
+                    else if (header.TypeFlag == TarHeader.LF_XHDR)
+                    {
+                        // POSIX extended header
+                        // Ignore things we dont understand completely for now
+                        SkipToNextEntry();
+                        headerBuf = this.tarBuffer.ReadBlock();
+                    }
+                    else if (header.TypeFlag == TarHeader.LF_GNU_VOLHDR)
+                    {
+                        // TODO: could show volume name when verbose
+                        SkipToNextEntry();
+                        headerBuf = this.tarBuffer.ReadBlock();
+                    }
+                    else if (header.TypeFlag != TarHeader.LF_NORMAL &&
+                             header.TypeFlag != TarHeader.LF_OLDNORM &&
+                             header.TypeFlag != TarHeader.LF_LINK &&
+                             header.TypeFlag != TarHeader.LF_SYMLINK &&
+                             header.TypeFlag != TarHeader.LF_DIR)
+                    {
+                        // Ignore things we dont understand completely for now
+                        SkipToNextEntry();
+                        headerBuf = tarBuffer.ReadBlock();
+                    }
+                    currentEntry = new TarHeader();
+
+                    if (longName != null)
+                    {
+                        currentEntry.Name = longName.ToString();
+                    }
+
+                    // Magic was checked here for 'ustar' but there are multiple valid possibilities
+                    // so this is not done anymore.
+
+                    entryOffset = 0;
+
+                    // TODO: Review How do we resolve this discrepancy?!
+                    entrySize = this.currentEntry.Size;
+                }
+                catch (TarException ex)
+                {
+                    entrySize = 0;
+                    entryOffset = 0;
+                    currentEntry = null;
+                    string errorText = $"Bad header in record {tarBuffer.CurrentRecord} block {tarBuffer.CurrentBlock} {ex.Message}";
+                    throw new TarException(errorText);
+                }
+            }
+            return currentEntry;
+        }
+
+        /// <summary>
+        /// Copies the contents of the current tar archive entry directly into
+        /// an output stream.
+        /// </summary>
+        /// <param name="outputStream">
+        /// The OutputStream into which to write the entry's data.
+        /// </param>
+        public void CopyEntryContents(Stream outputStream)
+        {
+            byte[] tempBuffer = new byte[32 * 1024];
+
+            while (true)
+            {
+                int numRead = Read(tempBuffer, 0, tempBuffer.Length);
+                if (numRead <= 0)
+                {
+                    break;
+                }
+                outputStream.Write(tempBuffer, 0, numRead);
+            }
+        }
+
+        private void SkipToNextEntry()
+        {
+            long numToSkip = entrySize - entryOffset;
+
+            if (numToSkip > 0)
+            {
+                Skip(numToSkip);
+            }
+
+            readBuffer = null;
+        }
+
+        #region Instance Fields
+
+        /// <summary>
+        /// Flag set when last block has been read
+        /// </summary>
+        protected bool hasHitEOF;
+
+        /// <summary>
+        /// Size of this entry as recorded in header
+        /// </summary>
+        protected long entrySize;
+
+        /// <summary>
+        /// Number of bytes read for this entry so far
+        /// </summary>
+        protected long entryOffset;
+
+        /// <summary>
+        /// Buffer used with calls to <code>Read()</code>
+        /// </summary>		
+        protected byte[] readBuffer;
+
+        /// <summary>
+        /// Working buffer
+        /// </summary>
+        protected TarBuffer tarBuffer;
+
+        /// <summary>
+        /// Current entry being read
+        /// </summary>
+        private TarHeader currentEntry;
+        
+        /// <summary>
+        /// Stream used as the source of input data.
+        /// </summary>
+        private readonly Stream inputStream;
+
+        #endregion
+    }
+}

src/SharpCompress/Common/Tar/TarOutputStream.cs

@@ -0,0 +1,417 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common.Tar
+{
+	/// <summary>
+	/// The TarOutputStream writes a UNIX tar archive as an OutputStream.
+	/// Methods are provided to put entries, and then write their contents
+	/// by writing to this stream using write().
+	/// </summary>
+	/// public
+	public class TarOutputStream : Stream
+	{
+		#region Constructors
+		/// <summary>
+		/// Construct TarOutputStream using default block factor
+		/// </summary>
+		/// <param name="outputStream">stream to write to</param>
+		public TarOutputStream(Stream outputStream)
+			: this(outputStream, TarBuffer.DefaultBlockFactor)
+		{
+		}
+
+		/// <summary>
+		/// Construct TarOutputStream with user specified block factor
+		/// </summary>
+		/// <param name="outputStream">stream to write to</param>
+		/// <param name="blockFactor">blocking factor</param>
+		public TarOutputStream(Stream outputStream, int blockFactor)
+		{
+			if (outputStream == null) {
+				throw new ArgumentNullException(nameof(outputStream));
+			}
+
+			this.outputStream = outputStream;
+			buffer = TarBuffer.CreateOutputTarBuffer(outputStream, blockFactor);
+
+			assemblyBuffer = new byte[TarBuffer.BlockSize];
+			blockBuffer = new byte[TarBuffer.BlockSize];
+		}
+		#endregion
+
+		/// <summary>
+		/// Get/set flag indicating ownership of the underlying stream.
+		/// When the flag is true <see cref="Close"></see> will close the underlying stream also.
+		/// </summary>
+		public bool IsStreamOwner {
+			get => buffer.IsStreamOwner;
+		    set => buffer.IsStreamOwner = value;
+		}
+
+		/// <summary>
+		/// true if the stream supports reading; otherwise, false.
+		/// </summary>
+		public override bool CanRead => outputStream.CanRead;
+
+	    /// <summary>
+		/// true if the stream supports seeking; otherwise, false.
+		/// </summary>
+		public override bool CanSeek => outputStream.CanSeek;
+
+	    /// <summary>
+		/// true if stream supports writing; otherwise, false.
+		/// </summary>
+		public override bool CanWrite => outputStream.CanWrite;
+
+	    /// <summary>
+		/// length of stream in bytes
+		/// </summary>
+		public override long Length => outputStream.Length;
+
+	    /// <summary>
+		/// gets or sets the position within the current stream.
+		/// </summary>
+		public override long Position {
+			get => outputStream.Position;
+	        set => outputStream.Position = value;
+	    }
+
+		/// <summary>
+		/// set the position within the current stream
+		/// </summary>
+		/// <param name="offset">The offset relative to the <paramref name="origin"/> to seek to</param>
+		/// <param name="origin">The <see cref="SeekOrigin"/> to seek from.</param>
+		/// <returns>The new position in the stream.</returns>
+		public override long Seek(long offset, SeekOrigin origin)
+		{
+			return outputStream.Seek(offset, origin);
+		}
+
+		/// <summary>
+		/// Set the length of the current stream
+		/// </summary>
+		/// <param name="value">The new stream length.</param>
+		public override void SetLength(long value)
+		{
+			outputStream.SetLength(value);
+		}
+
+		/// <summary>
+		/// Read a byte from the stream and advance the position within the stream 
+		/// by one byte or returns -1 if at the end of the stream.
+		/// </summary>
+		/// <returns>The byte value or -1 if at end of stream</returns>
+		public override int ReadByte()
+		{
+			return outputStream.ReadByte();
+		}
+
+		/// <summary>
+		/// read bytes from the current stream and advance the position within the 
+		/// stream by the number of bytes read.
+		/// </summary>
+		/// <param name="buffer">The buffer to store read bytes in.</param>
+		/// <param name="offset">The index into the buffer to being storing bytes at.</param>
+		/// <param name="count">The desired number of bytes to read.</param>
+		/// <returns>The total number of bytes read, or zero if at the end of the stream.
+		/// The number of bytes may be less than the <paramref name="count">count</paramref>
+		/// requested if data is not avialable.</returns>
+		public override int Read(byte[] buffer, int offset, int count)
+		{
+			return outputStream.Read(buffer, offset, count);
+		}
+
+		/// <summary>
+		/// All buffered data is written to destination
+		/// </summary>		
+		public override void Flush()
+		{
+			outputStream.Flush();
+		}
+
+		/// <summary>
+		/// Ends the TAR archive without closing the underlying OutputStream.
+		/// The result is that the EOF block of nulls is written.
+		/// </summary>
+		public void Finish()
+		{
+			if (IsEntryOpen) {
+				CloseEntry();
+			}
+			WriteEofBlock();
+		}
+
+		/// <summary>
+		/// Ends the TAR archive and closes the underlying OutputStream.
+		/// </summary>
+		/// <remarks>This means that Finish() is called followed by calling the
+		/// TarBuffer's Close().</remarks>
+		protected override void Dispose(bool disposing)
+		{
+			if (!isClosed) {
+				isClosed = true;
+				Finish();
+				buffer.Close();
+			}
+		}
+
+		/// <summary>
+		/// Get the record size being used by this stream's TarBuffer.
+		/// </summary>
+		public int RecordSize => buffer.RecordSize;
+
+	    /// <summary>
+		/// Get the record size being used by this stream's TarBuffer.
+		/// </summary>
+		/// <returns>
+		/// The TarBuffer record size.
+		/// </returns>
+		[Obsolete("Use RecordSize property instead")]
+		public int GetRecordSize()
+		{
+			return buffer.RecordSize;
+		}
+
+		/// <summary>
+		/// Get a value indicating wether an entry is open, requiring more data to be written.
+		/// </summary>
+		bool IsEntryOpen => (currBytes < currSize);
+
+	    /// <summary>
+		/// Put an entry on the output stream. This writes the entry's
+		/// header and positions the output stream for writing
+		/// the contents of the entry. Once this method is called, the
+		/// stream is ready for calls to write() to write the entry's
+		/// contents. Once the contents are written, closeEntry()
+		/// <B>MUST</B> be called to ensure that all buffered data
+		/// is completely written to the output stream.
+		/// </summary>
+		/// <param name="entry">
+		/// The TarEntry to be written to the archive.
+		/// </param>
+		public void PutNextEntry(TarEntry entry)
+		{
+			if (entry == null) {
+				throw new ArgumentNullException(nameof(entry));
+			}
+
+			if (entry.TarHeader.Name.Length > TarHeader.NAMELEN) {
+				var longHeader = new TarHeader();
+				longHeader.TypeFlag = TarHeader.LF_GNU_LONGNAME;
+				longHeader.Name = longHeader.Name + "././@LongLink";
+				longHeader.Mode = 420;//644 by default
+				longHeader.UserId = entry.UserId;
+				longHeader.GroupId = entry.GroupId;
+				longHeader.GroupName = entry.GroupName;
+				longHeader.UserName = entry.UserName;
+				longHeader.LinkName = "";
+				longHeader.Size = entry.TarHeader.Name.Length + 1;  // Plus one to avoid dropping last char
+
+				longHeader.WriteHeader(blockBuffer);
+				buffer.WriteBlock(blockBuffer);  // Add special long filename header block
+
+				int nameCharIndex = 0;
+
+				while (nameCharIndex < entry.TarHeader.Name.Length + 1 /* we've allocated one for the null char, now we must make sure it gets written out */) {
+					Array.Clear(blockBuffer, 0, blockBuffer.Length);
+					TarHeader.GetAsciiBytes(entry.TarHeader.Name, nameCharIndex, this.blockBuffer, 0, TarBuffer.BlockSize); // This func handles OK the extra char out of string length
+					nameCharIndex += TarBuffer.BlockSize;
+					buffer.WriteBlock(blockBuffer);
+				}
+			}
+
+			entry.WriteEntryHeader(blockBuffer);
+			buffer.WriteBlock(blockBuffer);
+
+			currBytes = 0;
+
+			currSize = entry.IsDirectory ? 0 : entry.Size;
+		}
+
+		/// <summary>
+		/// Close an entry. This method MUST be called for all file
+		/// entries that contain data. The reason is that we must
+		/// buffer data written to the stream in order to satisfy
+		/// the buffer's block based writes. Thus, there may be
+		/// data fragments still being assembled that must be written
+		/// to the output stream before this entry is closed and the
+		/// next entry written.
+		/// </summary>
+		public void CloseEntry()
+		{
+			if (assemblyBufferLength > 0) {
+				Array.Clear(assemblyBuffer, assemblyBufferLength, assemblyBuffer.Length - assemblyBufferLength);
+
+				buffer.WriteBlock(assemblyBuffer);
+
+				currBytes += assemblyBufferLength;
+				assemblyBufferLength = 0;
+			}
+
+			if (currBytes < currSize) {
+				string errorText = string.Format(
+					"Entry closed at '{0}' before the '{1}' bytes specified in the header were written",
+					currBytes, currSize);
+				throw new TarException(errorText);
+			}
+		}
+
+		/// <summary>
+		/// Writes a byte to the current tar archive entry.
+		/// This method simply calls Write(byte[], int, int).
+		/// </summary>
+		/// <param name="value">
+		/// The byte to be written.
+		/// </param>
+		public override void WriteByte(byte value)
+		{
+			Write(new byte[] { value }, 0, 1);
+		}
+
+		/// <summary>
+		/// Writes bytes to the current tar archive entry. This method
+		/// is aware of the current entry and will throw an exception if
+		/// you attempt to write bytes past the length specified for the
+		/// current entry. The method is also (painfully) aware of the
+		/// record buffering required by TarBuffer, and manages buffers
+		/// that are not a multiple of recordsize in length, including
+		/// assembling records from small buffers.
+		/// </summary>
+		/// <param name = "buffer">
+		/// The buffer to write to the archive.
+		/// </param>
+		/// <param name = "offset">
+		/// The offset in the buffer from which to get bytes.
+		/// </param>
+		/// <param name = "count">
+		/// The number of bytes to write.
+		/// </param>
+		public override void Write(byte[] buffer, int offset, int count)
+		{
+			if (buffer == null) {
+				throw new ArgumentNullException(nameof(buffer));
+			}
+
+			if (offset < 0) {
+				throw new ArgumentOutOfRangeException(nameof(offset), "Cannot be negative");
+			}
+
+			if (buffer.Length - offset < count) {
+				throw new ArgumentException("offset and count combination is invalid");
+			}
+
+			if (count < 0) {
+				throw new ArgumentOutOfRangeException(nameof(count), "Cannot be negative");
+			}
+
+			if ((currBytes + count) > currSize) {
+				string errorText = string.Format("request to write '{0}' bytes exceeds size in header of '{1}' bytes",
+					count, this.currSize);
+				throw new ArgumentOutOfRangeException(nameof(count), errorText);
+			}
+
+			//
+			// We have to deal with assembly!!!
+			// The programmer can be writing little 32 byte chunks for all
+			// we know, and we must assemble complete blocks for writing.
+			// TODO  REVIEW Maybe this should be in TarBuffer? Could that help to
+			//        eliminate some of the buffer copying.
+			//
+			if (assemblyBufferLength > 0) {
+				if ((assemblyBufferLength + count) >= blockBuffer.Length) {
+					int aLen = blockBuffer.Length - assemblyBufferLength;
+
+					Array.Copy(assemblyBuffer, 0, blockBuffer, 0, assemblyBufferLength);
+					Array.Copy(buffer, offset, blockBuffer, assemblyBufferLength, aLen);
+
+					this.buffer.WriteBlock(blockBuffer);
+
+					currBytes += blockBuffer.Length;
+
+					offset += aLen;
+					count -= aLen;
+
+					assemblyBufferLength = 0;
+				} else {
+					Array.Copy(buffer, offset, assemblyBuffer, assemblyBufferLength, count);
+					offset += count;
+					assemblyBufferLength += count;
+					count -= count;
+				}
+			}
+
+			//
+			// When we get here we have EITHER:
+			//   o An empty "assembly" buffer.
+			//   o No bytes to write (count == 0)
+			//
+			while (count > 0) {
+				if (count < blockBuffer.Length) {
+					Array.Copy(buffer, offset, assemblyBuffer, assemblyBufferLength, count);
+					assemblyBufferLength += count;
+					break;
+				}
+
+				this.buffer.WriteBlock(buffer, offset);
+
+				int bufferLength = blockBuffer.Length;
+				currBytes += bufferLength;
+				count -= bufferLength;
+				offset += bufferLength;
+			}
+		}
+
+		/// <summary>
+		/// Write an EOF (end of archive) block to the tar archive.
+		/// An EOF block consists of all zeros.
+		/// </summary>
+		void WriteEofBlock()
+		{
+			Array.Clear(blockBuffer, 0, blockBuffer.Length);
+			buffer.WriteBlock(blockBuffer);
+		}
+
+		#region Instance Fields
+		/// <summary>
+		/// bytes written for this entry so far
+		/// </summary>
+		long currBytes;
+
+		/// <summary>
+		/// current 'Assembly' buffer length
+		/// </summary>		
+		int assemblyBufferLength;
+
+		/// <summary>
+		/// Flag indicating wether this instance has been closed or not.
+		/// </summary>
+		bool isClosed;
+
+		/// <summary>
+		/// Size for the current entry
+		/// </summary>
+		protected long currSize;
+
+		/// <summary>
+		/// single block working buffer 
+		/// </summary>
+		protected byte[] blockBuffer;
+
+		/// <summary>
+		/// 'Assembly' buffer used to assemble data before writing
+		/// </summary>
+		protected byte[] assemblyBuffer;
+
+		/// <summary>
+		/// TarBuffer used to provide correct blocking factor
+		/// </summary>
+		protected TarBuffer buffer;
+
+		/// <summary>
+		/// the destination stream for the archive contents
+		/// </summary>
+		protected Stream outputStream;
+		#endregion
+	}
+}

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -1,90 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Common.Tar
-{
-    internal class TarReadOnlySubStream : Stream
-    {
-        private bool isDisposed;
-        private long amountRead;
-
-        public TarReadOnlySubStream(Stream stream, long bytesToRead)
-        {
-            Stream = stream;
-            BytesLeftToRead = bytesToRead;
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            if (isDisposed)
-            {
-                return;
-            }
-            isDisposed = true;
-            if (disposing)
-            {
-                long skipBytes = amountRead % 512;
-                if (skipBytes == 0)
-                {
-                    return;
-                }
-                skipBytes = 512 - skipBytes;
-                if (skipBytes == 0)
-                {
-                    return;
-                }
-                var buffer = new byte[skipBytes];
-                Stream.ReadFully(buffer);
-            }
-        }
-
-        private long BytesLeftToRead { get; set; }
-
-        public Stream Stream { get; }
-
-        public override bool CanRead => true;
-
-        public override bool CanSeek => false;
-
-        public override bool CanWrite => false;
-
-        public override void Flush()
-        {
-            throw new NotSupportedException();
-        }
-
-        public override long Length => throw new NotSupportedException();
-
-        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (BytesLeftToRead < count)
-            {
-                count = (int)BytesLeftToRead;
-            }
-            int read = Stream.Read(buffer, offset, count);
-            if (read > 0)
-            {
-                BytesLeftToRead -= read;
-                amountRead += read;
-            }
-            return read;
-        }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException();
-        }
-    }
-}

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -28,7 +28,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
-using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.Deflate

src/SharpCompress/Writers/Tar/TarWriter.cs

@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using SharpCompress.Common;
-using SharpCompress.Common.Tar.Headers;
+using SharpCompress.Common.Tar;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
@@ -67,10 +67,10 @@ namespace SharpCompress.Writers.Tar
             long realSize = size ?? source.Length;
 
             TarHeader header = new TarHeader();
-            header.LastModifiedTime = modificationTime ?? TarHeader.Epoch;
+            header.ModTime = modificationTime ?? TarHeader.Epoch;
             header.Name = NormalizeFilename(filename);
             header.Size = realSize;
-            header.Write(OutputStream);
+            header.WriteHeader(OutputStream);
             size = source.TransferTo(OutputStream);
             PadTo512(size.Value, false);
         }