using System; using System.IO; using System.Text; namespace ICSharpCode.SharpZipLib.Tar { /// /// Used to advise clients of 'events' while processing archives /// public delegate void ProgressMessageHandler(TarArchive archive, TarEntry entry, string message); /// /// The TarArchive class implements the concept of a /// 'Tape Archive'. A tar archive is a series of entries, each of /// which represents a file system object. Each entry in /// the archive consists of a header block followed by 0 or more data blocks. /// Directory entries consist only of the header block, and are followed by entries /// for the directory's contents. File entries consist of a /// header followed by the number of blocks needed to /// contain the file's contents. All entries are written on /// block boundaries. Blocks are 512 bytes long. /// /// TarArchives are instantiated in either read or write mode, /// based upon whether they are instantiated with an InputStream /// or an OutputStream. Once instantiated TarArchives read/write /// mode can not be changed. /// /// There is currently no support for random access to tar archives. /// However, it seems that subclassing TarArchive, and using the /// TarBuffer.CurrentRecord and TarBuffer.CurrentBlock /// properties, this would be rather trivial. /// public class TarArchive : IDisposable { /// /// Client hook allowing detailed information to be reported during processing /// public event ProgressMessageHandler ProgressMessageEvent; /// /// Raises the ProgressMessage event /// /// The TarEntry for this event /// message for this event. Null is no message protected virtual void OnProgressMessageEvent(TarEntry entry, string message) { ProgressMessageHandler handler = ProgressMessageEvent; if (handler != null) { handler(this, entry, message); } } #region Constructors /// /// Constructor for a default . /// protected TarArchive() { } /// /// Initalise a TarArchive for input. /// /// The to use for input. protected TarArchive(TarInputStream stream) { if (stream == null) { throw new ArgumentNullException("nameof(stream)"); } tarIn = stream; } /// /// Initialise a TarArchive for output. /// /// The to use for output. protected TarArchive(TarOutputStream stream) { if (stream == null) { throw new ArgumentNullException("nameof(stream)"); } tarOut = stream; } #endregion #region Static factory methods /// /// The InputStream based constructors create a TarArchive for the /// purposes of extracting or listing a tar archive. Thus, use /// these constructors when you wish to extract files from or list /// the contents of an existing tar archive. /// /// The stream to retrieve archive data from. /// Returns a new suitable for reading from. public static TarArchive CreateInputTarArchive(Stream inputStream) { if (inputStream == null) { throw new ArgumentNullException("nameof(inputStream)"); } var tarStream = inputStream as TarInputStream; TarArchive result; if (tarStream != null) { result = new TarArchive(tarStream); } else { result = CreateInputTarArchive(inputStream, TarBuffer.DefaultBlockFactor); } return result; } /// /// Create TarArchive for reading setting block factor /// /// A stream containing the tar archive contents /// The blocking factor to apply /// Returns a suitable for reading. public static TarArchive CreateInputTarArchive(Stream inputStream, int blockFactor) { if (inputStream == null) { throw new ArgumentNullException("nameof(inputStream)"); } if (inputStream is TarInputStream) { throw new ArgumentException("TarInputStream not valid"); } return new TarArchive(new TarInputStream(inputStream, blockFactor)); } /// /// Create a TarArchive for writing to, using the default blocking factor /// /// The to write to /// Returns a suitable for writing. public static TarArchive CreateOutputTarArchive(Stream outputStream) { if (outputStream == null) { throw new ArgumentNullException("nameof(outputStream)"); } var tarStream = outputStream as TarOutputStream; TarArchive result; if (tarStream != null) { result = new TarArchive(tarStream); } else { result = CreateOutputTarArchive(outputStream, TarBuffer.DefaultBlockFactor); } return result; } /// /// Create a tar archive for writing. /// /// The stream to write to /// The blocking factor to use for buffering. /// Returns a suitable for writing. public static TarArchive CreateOutputTarArchive(Stream outputStream, int blockFactor) { if (outputStream == null) { throw new ArgumentNullException("nameof(outputStream)"); } if (outputStream is TarOutputStream) { throw new ArgumentException("TarOutputStream is not valid"); } return new TarArchive(new TarOutputStream(outputStream, blockFactor)); } #endregion /// /// Set the flag that determines whether existing files are /// kept, or overwritten during extraction. /// /// /// If true, do not overwrite existing files. /// public void SetKeepOldFiles(bool keepExistingFiles) { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } keepOldFiles = keepExistingFiles; } /// /// Get/set the ascii file translation flag. If ascii file translation /// is true, then the file is checked to see if it a binary file or not. /// If the flag is true and the test indicates it is ascii text /// file, it will be translated. The translation converts the local /// operating system's concept of line ends into the UNIX line end, /// '\n', which is the defacto standard for a TAR archive. This makes /// text files compatible with UNIX. /// public bool AsciiTranslate { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return asciiTranslate; } set { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } asciiTranslate = value; } } /// /// Set the ascii file translation flag. /// /// /// If true, translate ascii text files. /// [Obsolete("Use the AsciiTranslate property")] public void SetAsciiTranslation(bool translateAsciiFiles) { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } asciiTranslate = translateAsciiFiles; } /// /// PathPrefix is added to entry names as they are written if the value is not null. /// A slash character is appended after PathPrefix /// public string PathPrefix { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return pathPrefix; } set { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } pathPrefix = value; } } /// /// RootPath is removed from entry names if it is found at the /// beginning of the name. /// public string RootPath { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return rootPath; } set { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } // Convert to forward slashes for matching. Trim trailing / for correct final path rootPath = value.Replace('\\', '/').TrimEnd('/'); } } /// /// Set user and group information that will be used to fill in the /// tar archive's entry headers. This information is based on that available /// for the linux operating system, which is not always available on other /// operating systems. TarArchive allows the programmer to specify values /// to be used in their place. /// is set to true by this call. /// /// /// The user id to use in the headers. /// /// /// The user name to use in the headers. /// /// /// The group id to use in the headers. /// /// /// The group name to use in the headers. /// public void SetUserInfo(int userId, string userName, int groupId, string groupName) { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } this.userId = userId; this.userName = userName; this.groupId = groupId; this.groupName = groupName; applyUserInfoOverrides = true; } /// /// Get or set a value indicating if overrides defined by SetUserInfo should be applied. /// /// If overrides are not applied then the values as set in each header will be used. public bool ApplyUserInfoOverrides { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return applyUserInfoOverrides; } set { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } applyUserInfoOverrides = value; } } /// /// Get the archive user id. /// See ApplyUserInfoOverrides for detail /// on how to allow setting values on a per entry basis. /// /// /// The current user id. /// public int UserId { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return userId; } } /// /// Get the archive user name. /// See ApplyUserInfoOverrides for detail /// on how to allow setting values on a per entry basis. /// /// /// The current user name. /// public string UserName { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return userName; } } /// /// Get the archive group id. /// See ApplyUserInfoOverrides for detail /// on how to allow setting values on a per entry basis. /// /// /// The current group id. /// public int GroupId { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return groupId; } } /// /// Get the archive group name. /// See ApplyUserInfoOverrides for detail /// on how to allow setting values on a per entry basis. /// /// /// The current group name. /// public string GroupName { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } return groupName; } } /// /// Get the archive's record size. Tar archives are composed of /// a series of RECORDS each containing a number of BLOCKS. /// This allowed tar archives to match the IO characteristics of /// the physical device being used. Archives are expected /// to be properly "blocked". /// /// /// The record size this archive is using. /// public int RecordSize { get { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } if (tarIn != null) { return tarIn.RecordSize; } else if (tarOut != null) { return tarOut.RecordSize; } return TarBuffer.DefaultRecordSize; } } /// /// Sets the IsStreamOwner property on the underlying stream. /// Set this to false to prevent the Close of the TarArchive from closing the stream. /// public bool IsStreamOwner { set { if (tarIn != null) { tarIn.IsStreamOwner = value; } else { tarOut.IsStreamOwner = value; } } } /// /// Close the archive. /// [Obsolete("Use Close instead")] public void CloseArchive() { Close(); } /// /// Perform the "list" command for the archive contents. /// /// NOTE That this method uses the progress event to actually list /// the contents. If the progress display event is not set, nothing will be listed! /// public void ListContents() { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } while (true) { TarEntry entry = tarIn.GetNextEntry(); if (entry == null) { break; } OnProgressMessageEvent(entry, null); } } /// /// Perform the "extract" command and extract the contents of the archive. /// /// /// The destination directory into which to extract. /// public void ExtractContents(string destinationDirectory) { if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } while (true) { TarEntry entry = tarIn.GetNextEntry(); if (entry == null) { break; } if (entry.TarHeader.TypeFlag == TarHeader.LF_LINK || entry.TarHeader.TypeFlag == TarHeader.LF_SYMLINK) continue; ExtractEntry(destinationDirectory, entry); } } /// /// Extract an entry from the archive. This method assumes that the /// tarIn stream has been properly set with a call to GetNextEntry(). /// /// /// The destination directory into which to extract. /// /// /// The TarEntry returned by tarIn.GetNextEntry(). /// void ExtractEntry(string destDir, TarEntry entry) { OnProgressMessageEvent(entry, null); string name = entry.Name; if (Path.IsPathRooted(name)) { // NOTE: // for UNC names... \\machine\share\zoom\beet.txt gives \zoom\beet.txt name = name.Substring(Path.GetPathRoot(name).Length); } name = name.Replace('/', Path.DirectorySeparatorChar); string destFile = Path.Combine(destDir, name); if (entry.IsDirectory) { EnsureDirectoryExists(destFile); } else { string parentDirectory = Path.GetDirectoryName(destFile); EnsureDirectoryExists(parentDirectory); bool process = true; var fileInfo = new FileInfo(destFile); if (fileInfo.Exists) { if (keepOldFiles) { OnProgressMessageEvent(entry, "Destination file already exists"); process = false; } else if ((fileInfo.Attributes & FileAttributes.ReadOnly) != 0) { OnProgressMessageEvent(entry, "Destination file already exists, and is read-only"); process = false; } } if (process) { bool asciiTrans = false; Stream outputStream = File.Create(destFile); if (this.asciiTranslate) { asciiTrans = !IsBinary(destFile); } StreamWriter outw = null; if (asciiTrans) { outw = new StreamWriter(outputStream); } byte[] rdbuf = new byte[32 * 1024]; while (true) { int numRead = tarIn.Read(rdbuf, 0, rdbuf.Length); if (numRead <= 0) { break; } if (asciiTrans) { for (int off = 0, b = 0; b < numRead; ++b) { if (rdbuf[b] == 10) { string s = Encoding.ASCII.GetString(rdbuf, off, (b - off)); outw.WriteLine(s); off = b + 1; } } } else { outputStream.Write(rdbuf, 0, numRead); } } if (asciiTrans) { outw.Dispose(); } else { outputStream.Dispose(); } } } } /// /// Write an entry to the archive. This method will call the putNextEntry /// and then write the contents of the entry, and finally call closeEntry() /// for entries that are files. For directories, it will call putNextEntry(), /// and then, if the recurse flag is true, process each entry that is a /// child of the directory. /// /// /// The TarEntry representing the entry to write to the archive. /// /// /// If true, process the children of directory entries. /// public void WriteEntry(TarEntry sourceEntry, bool recurse) { if (sourceEntry == null) { throw new ArgumentNullException("nameof(sourceEntry)"); } if (isDisposed) { throw new ObjectDisposedException("TarArchive"); } try { if (recurse) { TarHeader.SetValueDefaults(sourceEntry.UserId, sourceEntry.UserName, sourceEntry.GroupId, sourceEntry.GroupName); } WriteEntryCore(sourceEntry, recurse); } finally { if (recurse) { TarHeader.RestoreSetValues(); } } } /// /// Write an entry to the archive. This method will call the putNextEntry /// and then write the contents of the entry, and finally call closeEntry() /// for entries that are files. For directories, it will call putNextEntry(), /// and then, if the recurse flag is true, process each entry that is a /// child of the directory. /// /// /// The TarEntry representing the entry to write to the archive. /// /// /// If true, process the children of directory entries. /// void WriteEntryCore(TarEntry sourceEntry, bool recurse) { string tempFileName = null; string entryFilename = sourceEntry.File; var entry = (TarEntry)sourceEntry.Clone(); if (applyUserInfoOverrides) { entry.GroupId = groupId; entry.GroupName = groupName; entry.UserId = userId; entry.UserName = userName; } OnProgressMessageEvent(entry, null); if (asciiTranslate && !entry.IsDirectory) { if (!IsBinary(entryFilename)) { tempFileName = Path.GetTempFileName(); using (StreamReader inStream = File.OpenText(entryFilename)) { using (Stream outStream = File.Create(tempFileName)) { while (true) { string line = inStream.ReadLine(); if (line == null) { break; } byte[] data = Encoding.ASCII.GetBytes(line); outStream.Write(data, 0, data.Length); outStream.WriteByte((byte)'\n'); } outStream.Flush(); } } entry.Size = new FileInfo(tempFileName).Length; entryFilename = tempFileName; } } string newName = null; if (rootPath != null) { if (entry.Name.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase)) { newName = entry.Name.Substring(rootPath.Length + 1); } } if (pathPrefix != null) { newName = (newName == null) ? pathPrefix + "/" + entry.Name : pathPrefix + "/" + newName; } if (newName != null) { entry.Name = newName; } tarOut.PutNextEntry(entry); if (entry.IsDirectory) { if (recurse) { TarEntry[] list = entry.GetDirectoryEntries(); for (int i = 0; i < list.Length; ++i) { WriteEntryCore(list[i], recurse); } } } else { using (Stream inputStream = File.OpenRead(entryFilename)) { byte[] localBuffer = new byte[32 * 1024]; while (true) { int numRead = inputStream.Read(localBuffer, 0, localBuffer.Length); if (numRead <= 0) { break; } tarOut.Write(localBuffer, 0, numRead); } } if (!string.IsNullOrEmpty(tempFileName)) { File.Delete(tempFileName); } tarOut.CloseEntry(); } } /// /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } /// /// Releases the unmanaged resources used by the FileStream and optionally releases the managed resources. /// /// true to release both managed and unmanaged resources; /// false to release only unmanaged resources. protected virtual void Dispose(bool disposing) { if (!isDisposed) { isDisposed = true; if (disposing) { if (tarOut != null) { tarOut.Flush(); tarOut.Dispose(); } if (tarIn != null) { tarIn.Dispose(); } } } } /// /// Closes the archive and releases any associated resources. /// public virtual void Close() { Dispose(true); } /// /// Ensures that resources are freed and other cleanup operations are performed /// when the garbage collector reclaims the . /// ~TarArchive() { Dispose(false); } static void EnsureDirectoryExists(string directoryName) { if (!Directory.Exists(directoryName)) { try { Directory.CreateDirectory(directoryName); } catch (Exception e) { throw new TarException("Exception creating directory '" + directoryName + "', " + e.Message, e); } } } // TODO: TarArchive - Is there a better way to test for a text file? // It no longer reads entire files into memory but is still a weak test! // This assumes that byte values 0-7, 14-31 or 255 are binary // and that all non text files contain one of these values static bool IsBinary(string filename) { using (FileStream fs = File.OpenRead(filename)) { int sampleSize = Math.Min(4096, (int)fs.Length); byte[] content = new byte[sampleSize]; int bytesRead = fs.Read(content, 0, sampleSize); for (int i = 0; i < bytesRead; ++i) { byte b = content[i]; if ((b < 8) || ((b > 13) && (b < 32)) || (b == 255)) { return true; } } } return false; } #region Instance Fields bool keepOldFiles; bool asciiTranslate; int userId; string userName = string.Empty; int groupId; string groupName = string.Empty; string rootPath; string pathPrefix; bool applyUserInfoOverrides; TarInputStream tarIn; TarOutputStream tarOut; bool isDisposed; #endregion } }