/// <summary> /// Unwraps the provided file with either a callback or the target directory /// </summary> /// <param name="wrapperFile">the file that contains the wrapped content</param> /// <param name="targetFile">the target file into which the content is unwrapped</param> /// <param name="unwrappedFiles">a fileMap that contains the unwrapped item</param> /// <param name="performUnzip">indicates whether to actually perform the unpacking process</param> /// <param name="requestStream">a callback that is used to create a new stream if required</param> /// <returns>a value indicating whether the unwrapping was successful</returns> private bool UnwrapFile(Stream wrapperFile, string targetFile, FileMap unwrappedFiles, bool performUnzip, Func <string, Stream> requestStream = null) { FileMapEntry ent; unwrappedFiles.Add(ent = new FileMapEntry(Path.GetFileName(targetFile))); if (performUnzip) { using (GZipInputStream gzis = new GZipInputStream(wrapperFile)) { using ( /*Stream fso = (requestStream == null) * ? new FileStream(targetFile, FileMode.Create, FileAccess.ReadWrite) * : (requestStream(targetFile) ?? * new FileStream(targetFile, FileMode.Create, FileAccess.ReadWrite)))*/ var fso = ent.Open()) { gzis.CopyTo(fso); } } } return(true); }
/// <summary> /// Unwraps a zip into a given directory /// </summary> /// <param name="zipFile">the zip-file to unwrap into the targetdirectory</param> /// <param name="targetDirectory">the targetdirectory in which to extract all files</param> /// <param name="performUnzip">indicates whether to perform the actual unpacking process</param> /// <param name="getStreamCallback">callback that is used to provide a stream for unwrapped content</param> /// <param name="copyAction">An action defining what happens while copying the content of the Stream to the target file</param> /// <param name="ignoreNullStreams">indicates whether to prevent files, for which the getStreamCallback method returns null, from being unwrapped</param> /// <param name="password">the password that is used to access the zip file</param> /// <returns>an array containing all extracted filenames</returns> private FileMap UnwrapZip(Stream zipFile, string targetDirectory, bool performUnzip, Func <FileMapEntry, Stream> getStreamCallback = null, Action <Stream, Stream> copyAction = null, bool ignoreNullStreams = false, string password = null) { FileMap map = new FileMap(targetDirectory, flattenStructure); if (copyAction == null) { copyAction = (input, output) => { try { input.CopyTo(output); } finally { output.Dispose(); } }; } using (ZipFile fl = new ZipFile(zipFile)) { if (password != null) { fl.Password = password; } foreach (ZipEntry ent in fl) { if (!ent.IsDirectory) { FileMapEntry entry = new FileMapEntry(ent.Name); map.Add(entry); if (performUnzip) { using (Stream s = fl.GetInputStream(ent)) { Stream fs = (getStreamCallback == null) ? entry.Open() : getStreamCallback(entry); if (fs == null && !ignoreNullStreams) { fs = entry.Open(); } if (fs != null) { copyAction(s, fs); } } } } } } return(map); }
/// <summary> /// Untars a file by either using the target directory or streams provided by the getStreamCallback function /// </summary> /// <param name="targetDirectory">the target directory into which to export the unwrapped files</param> /// <param name="tarStream">the tarstream that is used to export the files</param> /// <param name="unpack">indicates whether to actually perform the unpacking process</param> /// <param name="getStreamCallback">a callback that provides streams for each unwrapped file</param> /// <param name="copyAction">the action to execute for copying the content of the stream to the target</param> /// <param name="ignoreNullStreams">indicates whether to prevent using the default-directory when getStreamCallback does return null</param> /// <returns>a filemap that contains all unwrapped files and their result/source paths</returns> private FileMap UnTarFiles(string targetDirectory, TarStreamHelper tarStream, bool unpack, [InstantHandle] Func <FileMapEntry, Stream> getStreamCallback = null, [InstantHandle] Action <Stream, Stream> copyAction = null, bool ignoreNullStreams = false) { FileMap map = new FileMap(targetDirectory, flattenStructure); TarEntry entry; if (copyAction == null) { copyAction = (input, output) => { try { input.CopyTo(output); } finally { output.Dispose(); } }; } while ((entry = tarStream.InputStream.GetNextEntry()) != null) { if (!entry.IsDirectory) { FileMapEntry ent = new FileMapEntry(entry.Name); map.Add(ent); if (unpack) { Stream fout = (getStreamCallback == null) ? ent.Open() : getStreamCallback(ent); if (fout == null && !ignoreNullStreams) { fout = ent.Open(); } if (fout != null) { copyAction(tarStream.InputStream, fout); } } } } return(map); }
/// <summary> /// Writes an entry from an original file into the given zip file /// </summary> /// <param name="originalFile">the original file that is located in the filesystem</param> /// <param name="entry">an instance representing the zip-entry that is to be written</param> /// <param name="outputStream">the output stream in which to put the provided item</param> /// <param name="keySize">the keySize of the Zip Entry that is written</param> /// <returns>a value indicating whether the creation of the entry was successful(always true...)</returns> private bool WriteEntry(FileMapEntry originalFile, ZipEntry entry, ZipOutputStream outputStream, int keySize) { try { if (keySize > 0) { entry.AESKeySize = keySize; } outputStream.PutNextEntry(entry); using (Stream inputStream = originalFile.Open()) { inputStream.CopyTo(outputStream); } } finally { outputStream.CloseEntry(); } return(true); }