/// Returns a writable stream to an empty subfile. public Stream GetWriteStream(string subfileName) { Debug.Assert(!m_finished); if (m_zipstream != null) { #if USE_DOTNETZIP var entry = m_zipstream.PutNextEntry(subfileName); entry.LastModified = System.DateTime.Now; // entry.CompressionMethod = DotNetZip.CompressionMethod.None; no need; use the default return(new ZipOutputStreamWrapper_DotNetZip(m_zipstream)); #else var entry = new ZipLibrary.ZipEntry(subfileName); entry.DateTime = System.DateTime.Now; // There is such a thing as "Deflated, compression level 0". // Explicitly use "Stored". entry.CompressionMethod = (m_zipstream.GetLevel() == 0) ? ZipLibrary.CompressionMethod.Stored : ZipLibrary.CompressionMethod.Deflated; return(new ZipOutputStreamWrapper_SharpZipLib(m_zipstream, entry)); #endif } else { Directory.CreateDirectory(m_temporaryPath); string fullPath = Path.Combine(m_temporaryPath, subfileName); return(new FileStream(fullPath, FileMode.Create, FileAccess.Write)); } }
internal ZipPackagePart(ZipPackage package, ZipEntry entry) { Package = package; Entry = entry; SaveHandler = null; Uri = new Uri(package.GetUriKey(entry.FileName), UriKind.Relative); }
public string GetInformationFromFile(string fullPath, string defaultValue) { if (RuntimePlatform.Android == Application.platform) { string fileName = Path.GetFileName(fullPath); using (MemoryStream m = new MemoryStream()) { string obbfile = Application.dataPath; Ionic.Zip.ZipFile zipfile = new Ionic.Zip.ZipFile(obbfile); Ionic.Zip.ZipEntry ze = zipfile["assets/" + fileName]; if (ze != null) { ze.Extract(m); m.Seek(0, SeekOrigin.Begin); using (StreamReader s = new StreamReader(m)) { string fileText = s.ReadLine(); return(fileText); } } } } else { if (File.Exists(fullPath)) { String fileText = File.ReadAllText(fullPath); return(fileText); } } return(defaultValue); }
private bool AreEqual(ZipEntry approvedEntry, ZipEntry receivedEntry) { if (approvedEntry.IsDirectory && receivedEntry.IsDirectory) { return true; } using (var approvedStream = new MemoryStream()) { using (var receivedStream = new MemoryStream()) { approvedEntry.Extract(approvedStream); receivedEntry.Extract(receivedStream); var approvedBytes = approvedStream.ToArray(); var receivedBytes = receivedStream.ToArray(); var areEqual = approvedBytes == receivedBytes; for (int i = 0; i < receivedBytes.Length && i < approvedBytes.Length; i++) { if (receivedBytes[i] != approvedBytes[i]) { Logger.Event("Failed on {0}[{1}] '{2}' != '{3}'", receivedEntry.FileName, i, (char) receivedBytes[i], (char) approvedBytes[i]); return false; } } return true; } } }
protected override OperationResult Handle(ZipEntry entry, ZipFile zip) { string orig = entry.FileName; string stripped = GetStripped(entry.FileName); if (stripped == null) { if (entry.IsDirectory) { zip.RemoveEntry(entry); return OperationResult.Removed; } stripped = orig; } try { entry.FileName = stripped; return OperationResult.Changed; } catch (Exception ex) { string type = entry.IsDirectory ? "directory" : "file"; throw new Exception(string.Format("Could not rename {0} '{1}' to '{2}'", type, orig, stripped), ex); } }
public MemoryStream GetEntryMemoryStream(ZipEntry zipEntry) { var stream = new MemoryStream(); zipEntry.Extract(stream); stream.Position = 0; return stream; }
private static Bitmap LoadBitmap(ZipEntry zipEntry) { MemoryStream stream = new MemoryStream(); zipEntry.Extract(stream); stream.Position = 0; Bitmap result = new Bitmap(stream); stream.Dispose(); return result; }
/// <summary> /// Constructors /// </summary> /// <param name="ze"></param> public EmlParser(ZipEntry ze) { try { parseEML(ze); } catch (Exception ex) { throw ex; } }
private static void SetZipFile(ZipEntry zipEntry, ZipFileInfo file) { if (!string.IsNullOrEmpty(file.Password)) zipEntry.Password = file.Password; zipEntry.Comment = file.Comment; zipEntry.CompressionMethod = (Ionic.Zip.CompressionMethod)((int)file.CompressionMethod); zipEntry.CompressionLevel = (Ionic.Zlib.CompressionLevel)((int)file.CompressionLevel); }
public void Check() { // Is there a valid input stream if (_stream == null) throw new FileNotFoundException("No valid file"); // Now read gwz file and save for later use _zip = ZipFile.Read(_stream); if (_zip == null) throw new FileLoadException("No valid gwz file"); foreach(ZipEntry zipEntry in _zip.Entries) { switch(Path.GetExtension(zipEntry.FileName).ToLower()) { case ".lua": _luaFile = zipEntry; _luaFiles += 1; break; } } // Is there a Lua file? if (_luaFile == null) throw new FileNotFoundException("No valid Lua file found"); // Is there more than one Lua file if (_luaFiles > 1) throw new FileLoadException("More than one Lua file found"); // Any compilation errors of the Lua file LUA.Check(_zip[_luaFile.FileName].OpenReader(), _luaFile.FileName); // Extract cartridge data from Lua file cartridge = LUA.Extract(_zip[_luaFile.FileName].OpenReader()); // Save Lua file name for later use cartridge.LuaFileName = _luaFile.FileName; // Now check, if all media resources files exist foreach(Media media in cartridge.Medias) { foreach(MediaResource resource in media.Resources) { // Check, if filename is in list of files if (!_zip.EntryFileNames.Contains(resource.Filename)) { if (string.IsNullOrWhiteSpace(resource.Filename)) throw new FileNotFoundException("The Lua file is referencing a file without a filename"); else throw new FileNotFoundException(String.Format("The GWZ is missing a file referred to by the cartridge's code. The file name is: {0}", resource.Filename)); } } } // Now all is checked without any problems // So it seams, that this GWZ file is valid }
public static PartWrapper Create(ZipEntry part) { if (part.IsZip()) { return new ZipPartWrapper(part); } return new PartWrapper(part); }
protected override OperationResult Handle(ZipEntry entry, ZipFile zip) { if (_regex.IsMatch(entry.FileName)) { zip.RemoveEntry(entry); return OperationResult.Removed; } return OperationResult.NoChange; }
protected override OperationResult Handle(ZipEntry entry, ZipFile zip) { if (entry.IsDirectory && (entry.Attributes & FileAttributes.Directory) != FileAttributes.Directory) { entry.Attributes |= FileAttributes.Directory; } // This just helps if a file is resaved. It shouldn't be treated as modified if this cleans something up. return OperationResult.NoChange; }
public static void zipbase(string pathFile) { ZipFileToCreate = Application.StartupPath + @"\Backup\Magbase.zip"; using (Basezip.ZipFile zip = new Basezip.ZipFile()) { zip.CompressionLevel = Ionic.Zlib.CompressionLevel.BestCompression; Basezip.ZipEntry ze = zip.AddFile(pathFile); zip.Save(ZipFileToCreate); } }
public ContentSection(ZipEntry entry) { Id = Path.GetFileNameWithoutExtension(entry.FileName); ArchivePath = entry.FileName; using (Stream s = entry.OpenReader()) { using (StreamReader sr = new StreamReader(s)) { Content = sr.ReadToEnd(); } } }
public static MemoryStream ExtractFileToStream(string zipSource, string filePath) { MemoryStream stream = new MemoryStream(); using (ZipFile zip = ZipFile.Read(zipSource)) { var matchFile = new ZipEntry(); foreach (var file in zip.Where(file => file.FileName == filePath)) matchFile = file; matchFile.Extract(stream); } return stream; }
public static string ExtractFileFromStream(ZipEntry entry) { var reader = new MemoryStream(); entry.Extract(reader); reader = new MemoryStream(reader.ToArray()); var streamReader = new StreamReader(reader); var text = streamReader.ReadToEnd(); reader.Dispose(); return text; }
public static ZipCrypto ForRead(string password, ZipEntry e) { System.IO.Stream s = e._archiveStream; e._WeakEncryptionHeader = new byte[12]; byte[] eh = e._WeakEncryptionHeader; ZipCrypto z = new ZipCrypto(); if (password == null) throw new BadPasswordException("This entry requires a password."); z.InitCipher(password); ZipEntry.ReadWeakEncryptionHeader(s, eh); // Decrypt the header. This has a side effect of "further initializing the // encryption keys" in the traditional zip encryption. byte[] DecryptedHeader = z.DecryptMessage(eh, eh.Length); // CRC check // According to the pkzip spec, the final byte in the decrypted header // is the highest-order byte in the CRC. We check it here. if (DecryptedHeader[11] != (byte)((e._Crc32 >> 24) & 0xff)) { // In the case that bit 3 of the general purpose bit flag is set to // indicate the presence of an 'Extended File Header' or a 'data // descriptor' (signature 0x08074b50), the last byte of the decrypted // header is sometimes compared with the high-order byte of the // lastmodified time, rather than the high-order byte of the CRC, to // verify the password. // // This is not documented in the PKWare Appnote.txt. // This was discovered this by analysis of the Crypt.c source file in the InfoZip library // http://www.info-zip.org/pub/infozip/ if ((e._BitField & 0x0008) != 0x0008) { throw new BadPasswordException("The password did not match."); } else if (DecryptedHeader[11] != (byte)((e._TimeBlob >> 8) & 0xff)) { throw new BadPasswordException("The password did not match."); } // We have a good password. } else { // A-OK } return z; }
private BitmapSource GenerateBitmapFromZipEntry(ZipEntry entry) { MemoryStream stream = new MemoryStream(); entry.Extract(stream); stream.Seek(0, SeekOrigin.Begin); var decoder = BitmapDecoder.Create(stream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad); BitmapSource bitmapSource = decoder.Frames[0]; stream.Dispose(); return bitmapSource; }
/// <summary> /// Reads one <c>ZipEntry</c> from the given stream. If the entry is encrypted, we don't /// decrypt at this point. We also do not decompress. Mostly we read metadata. /// </summary> /// <param name="zc">the ZipContainer this entry belongs to.</param> /// <param name="first">true of this is the first entry being read from the stream.</param> /// <returns>the <c>ZipEntry</c> read from the stream.</returns> internal static ZipEntry ReadEntry(ZipContainer zc, bool first) { ZipFile zf = zc.ZipFile; Stream s = zc.ReadStream; System.Text.Encoding defaultEncoding = zc.ProvisionalAlternateEncoding; ZipEntry entry = new ZipEntry(); entry._Source = ZipEntrySource.ZipFile; entry._container = zc; entry._archiveStream = s; if (zf != null) zf.OnReadEntry(true, null); if (first) HandlePK00Prefix(s); // Read entry header, including any encryption header if (!ReadHeader(entry, defaultEncoding)) return null; // Store the position in the stream for this entry // change for workitem 8098 entry.__FileDataPosition = entry.ArchiveStream.Position; // seek past the data without reading it. We will read on Extract() s.Seek(entry._CompressedFileDataSize + entry._LengthOfTrailer, SeekOrigin.Current); // workitem 10178 Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s); // ReadHeader moves the file pointer to the end of the entry header, // as well as any encryption header. // CompressedFileDataSize includes: // the maybe compressed, maybe encrypted file data // the encryption trailer, if any // the bit 3 descriptor, if any // workitem 5306 // http://www.codeplex.com/DotNetZip/WorkItem/View.aspx?WorkItemId=5306 HandleUnexpectedDataDescriptor(entry); if (zf != null) { zf.OnReadBytes(entry); zf.OnReadEntry(false, entry); } return entry; }
public static string GetStringFile(ZipEntry zipEntry) { if (zipEntry != null) { using (var stream = zipEntry.OpenReader()) { using (StreamReader sr = new StreamReader(stream, KPGenericUtil.GetDefaultEncoding())) { string fileString = sr.ReadToEnd(); return fileString; } } } return String.Empty; }
private static void Save(ZipEntry entry, string outputFilePath) { using (var input = entry.OpenReader()) { var folderPath = Path.GetDirectoryName(outputFilePath); if (!Directory.Exists(folderPath)) { Directory.CreateDirectory(folderPath); } using (Stream output = File.OpenWrite(outputFilePath)) { CopyStream(input, output); } } }
/// <summary> /// Copy metadata that may have been changed by the app. We do this when /// resetting the zipFile instance. If the app calls Save() on a ZipFile, then /// tries to party on that file some more, we may need to Reset() it , which /// means re-reading the entries and then copying the metadata. I think. /// </summary> internal void CopyMetaData(ZipEntry source) { this.__FileDataPosition = source.__FileDataPosition; this.CompressionMethod = source.CompressionMethod; this._CompressionMethod_FromZipFile = source._CompressionMethod_FromZipFile; this._CompressedFileDataSize = source._CompressedFileDataSize; this._UncompressedSize = source._UncompressedSize; this._BitField = source._BitField; this._Source = source._Source; this._LastModified = source._LastModified; this._Mtime = source._Mtime; this._Atime = source._Atime; this._Ctime = source._Ctime; this._ntfsTimesAreSet = source._ntfsTimesAreSet; this._emitUnixTimes = source._emitUnixTimes; this._emitNtfsTimes = source._emitNtfsTimes; }
static void Main(string[] args) { string regularplist, path, ipaname; //App Name Console.WriteLine("Please read the first Readme.md/n"); Console.WriteLine("Please \"XXXX\" in the place of complete Payload/XXXX.app"); ipaname = Console.ReadLine() + ".app"; //App Path Console.WriteLine("Enter the path ipa"); path = Console.ReadLine(); ZipEntry entry = new ZipEntry(); using (ZipFile zip = ZipFile.Read(path)) { entry = zip["Payload\\" + ipaname +"\\Info.plist"]; } using (MemoryStream stream = new MemoryStream()) { entry.Extract(stream); stream.Position = 0; var downPlist = Plist.readPlist(stream, plistType.Auto); regularplist = Plist.writeXml(downPlist); } var parsedPlist = XDocument.Parse(regularplist); String[] requiredKeys = new String[] { "DTCompiler", "CFBundleIdentifier", "CFBundleShortVersionString", "MinimumOSVersion", "CFBundleSupportedPlatforms"}; var filtredXmlData = parsedPlist.Root.Element("dict").Elements("key").Where(p => requiredKeys.Contains(p.Value)).Select(p => new { key = p.Value, value = Regex.Replace(p.NextNode.ToString(), "<.*?>", string.Empty) }).ToDictionary(k => k.key, v => v.value); Console.WriteLine(filtredXmlData["DTCompiler"]); Console.WriteLine(filtredXmlData["CFBundleIdentifier"]); Console.WriteLine(filtredXmlData["CFBundleShortVersionString"]); Console.WriteLine(filtredXmlData["CFBundleSupportedPlatforms"]); Console.Read(); }
/// <summary> /// Create a <see cref="ZipEntry"/> /// </summary> /// <param name="entry"></param> internal ZipEntry(Ionic.Zip.ZipEntry entry) { zipEntry = entry; ///////////////// zipEntry.AlternateEncoding = UTF8SansBomEncoding.Default; zipEntry.AlternateEncodingUsage = ZipOption.Always; if (zipEntry.CompressionLevel != CompressionLevel.BestCompression && zipEntry.CompressionLevel != CompressionLevel.None) { if (zipEntry.CompressionRatio == 0) { zipEntry.CompressionLevel = CompressionLevel.None; } else { zipEntry.CompressionLevel = CompressionLevel.BestCompression; } } }
static bool IsTempFile(ZipEntry e) { DirectoryInfo currentDirectory = null; if (!e.IsDirectory) { if (tempExtensions.Any(ex => ex.Equals(Path.GetExtension(e.FileName), StringComparison.OrdinalIgnoreCase))) { return true; } string directoryName = Path.GetDirectoryName(e.FileName); if (!string.IsNullOrEmpty(directoryName)) { currentDirectory = new DirectoryInfo(directoryName); } else return false; } else currentDirectory = new DirectoryInfo(e.FileName); return IsFilesInCacheFolder(currentDirectory); }
public OpfMetadataFile(ZipEntry file, string password) { try { using (Stream s = (String.IsNullOrEmpty(password) ? file.OpenReader() : file.OpenReader(password))) { using (StreamReader sr = new StreamReader(s)) { try { content = XDocument.Parse(sr.ReadToEnd()); } catch (Exception ex) { throw new MetadataParseException(ex, "Nie można było otworzyć pliku z metadanymi. Może to być spowodowane uszkodzeniem jego struktury XMLowej, niewłaściwym kodowaniem, albo brakiem dostępu."); } } } } catch (Exception ex) { throw new EpubFileException(ex, "Błąd w rozpakowywaniu pliku ePub. Może to być spowodowane uszkodzeniem pliku, brakiem plików z metadanymi bądź brakiem dostępu."); } }
/// <summary> /// Metoda, ki se pokliče, ko kliknemo na gumb Razširi. Odpre saveFileDialog in prebere kam bomo datoteko /// shranili. /// OPOMBA: metoda še ne deluje 100% pravilno. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void BtnExtract_Click(object sender, EventArgs e) { filesList = new StringCollection(); FolderBrowserDialog fbd = new FolderBrowserDialog(); if (fileExplorer.SelectedItems.Count > 0 && fbd.ShowDialog() == DialogResult.OK) { // Pridobi shranjevalno pot string savePath = fbd.SelectedPath; foreach (ListViewItem item in fileExplorer.SelectedItems) { string file = item.SubItems[0].Text; // Preveri katera oblika datoteke je: ZIP, TAR, GZIP ali TAR.BZ2 if (Path.GetExtension(txtPath.Text) == ".zip") { ZipFile zip = Ionic.Zip.ZipFile.Read(txtPath.Text); ZipEntry entry = zip[file]; if (zip[file].UsesEncryption == true) { PasswordPrompt passWin = new PasswordPrompt(); passWin.ShowDialog(); zip.Password = passWin.pass; try { entry.ExtractWithPassword(savePath, passWin.pass); } catch (BadPasswordException) { if (MessageBox.Show("Napačno geslo", "Napaka", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error) == DialogResult.Retry) { passWin.ShowDialog(); } } } string enExists = savePath + @"\" + entry.FileName; if (File.Exists(enExists)) { if (MessageBox.Show("Datoteka " + file + " že obstaja. Ali jo želite zamenjati?", "Datoteka obstaja", MessageBoxButtons.YesNo, MessageBoxIcon.Information) == DialogResult.Yes) { entry.Extract(savePath, ExtractExistingFileAction.OverwriteSilently); } else { break; } } else { entry.Extract(savePath); } } else if (Path.GetExtension(txtPath.Text) == ".tar") { byte[] outBuffer = new byte[4096]; TarInputStream tar = new TarInputStream(new FileStream(txtPath.Text, FileMode.Open, FileAccess.Read)); TarEntry curEntry = tar.GetNextEntry(); while (curEntry != null) { if (curEntry.Name == file) { FileStream fs = new FileStream(savePath + @"\" + curEntry.Name, FileMode.Create, FileAccess.Write); BinaryWriter bw = new BinaryWriter(fs); tar.Read(outBuffer, 0, (int)curEntry.Size); bw.Write(outBuffer, 0, outBuffer.Length); bw.Close(); } curEntry = tar.GetNextEntry(); } tar.Close(); } else if (Path.GetExtension(txtPath.Text) == ".bz2") { Stream str = new FileStream(txtPath.Text, FileMode.Open, FileAccess.Read); BZip2InputStream bzStr = new BZip2InputStream(str); TarInputStream tar = new TarInputStream(bzStr); TarEntry curEntry = tar.GetNextEntry(); while (curEntry != null) { if (curEntry.Name == file) { byte[] outBuffer = new byte[curEntry.Size]; FileStream fs = new FileStream(savePath + @"\" + curEntry.Name, FileMode.Create, FileAccess.Write); BinaryWriter bw = new BinaryWriter(fs); tar.Read(outBuffer, 0, (int)curEntry.Size); bw.Write(outBuffer, 0, outBuffer.Length); bw.Close(); } curEntry = tar.GetNextEntry(); } tar.Close(); } else if (Path.GetExtension(txtPath.Text) == ".tgz") { Stream str = new FileStream(txtPath.Text, FileMode.Open, FileAccess.Read); GZipInputStream gzStr = new GZipInputStream(str); TarInputStream tar = new TarInputStream(gzStr); TarEntry curEntry = tar.GetNextEntry(); while (curEntry != null) { if (curEntry.Name == file) { byte[] outBuffer = new byte[curEntry.Size]; FileStream fs = new FileStream(savePath + @"\" + curEntry.Name, FileMode.Create, FileAccess.Write); BinaryWriter bw = new BinaryWriter(fs); tar.Read(outBuffer, 0, (int)curEntry.Size); bw.Write(outBuffer, 0, outBuffer.Length); bw.Close(); } curEntry = tar.GetNextEntry(); } tar.Close(); } } } else { MessageBox.Show("Nobena datoteka ni bila izbrana. Prosimo izberite datoteke.", "Napaka", MessageBoxButtons.OK, MessageBoxIcon.Information); } }
private static int GetFileFormatByZip(Ionic.Zip.ZipFile oZipFile) { if (oZipFile.ContainsEntry("[Content_Types].xml")) { Ionic.Zip.ZipEntry oEntry = oZipFile["[Content_Types].xml"]; using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize)) { oEntry.Extract(oMemoryStream); oMemoryStream.Position = 0; string sContent = System.Text.UTF8Encoding.UTF8.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length); if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml") || -1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-word.document.macroEnabled.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-word.template.macroEnabledTemplate.main+xml")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX); } else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml") || -1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-excel.sheet.macroEnabled.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-excel.template.macroEnabled.main+xml")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX); } else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml") || -1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.template.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-powerpoint.presentation.macroEnabled.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-powerpoint.slideshow.macroEnabled.main+xml") || -1 != sContent.IndexOf("application/vnd.ms-powerpoint.template.macroEnabled.main+xml")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX); } else if (-1 != sContent.IndexOf("application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX); } } } if (oZipFile.ContainsEntry("mimetype")) { Ionic.Zip.ZipEntry oEntry = oZipFile["mimetype"]; using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize)) { oEntry.Extract(oMemoryStream); oMemoryStream.Position = 0; string sContent = System.Text.ASCIIEncoding.ASCII.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length); if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.text")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT); } else if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.spreadsheet")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS); } else if (-1 != sContent.IndexOf("application/vnd.oasis.opendocument.presentation")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP); } else if (-1 != sContent.IndexOf("application/epub+zip")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB); } } } if (oZipFile.ContainsEntry("_rels/.rels")) { Ionic.Zip.ZipEntry oEntry = oZipFile["_rels/.rels"]; using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize)) { oEntry.Extract(oMemoryStream); oMemoryStream.Position = 0; string sContent = System.Text.ASCIIEncoding.ASCII.GetString(oMemoryStream.GetBuffer(), 0, (int)oMemoryStream.Length); if (-1 != sContent.IndexOf("http://schemas.microsoft.com/xps/2005/06/fixedrepresentation")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS); } } } if (oZipFile.ContainsEntry("_rels/.rels/[0].piece")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS); } if (oZipFile.ContainsEntry("Editor.bin")) { Ionic.Zip.ZipEntry oEntry = oZipFile["Editor.bin"]; int nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN; using (MemoryStream oMemoryStream = new MemoryStream((int)oEntry.UncompressedSize)) { oEntry.Extract(oMemoryStream); oMemoryStream.Position = 0; int nSignatureLength = 4; if (oMemoryStream.Length >= nSignatureLength) { byte[] aSignature = new byte[nSignatureLength]; oMemoryStream.Read(aSignature, 0, nSignatureLength); string sSignature = System.Text.ASCIIEncoding.ASCII.GetString(aSignature); switch (sSignature) { case "DOCY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY; break; case "XLSY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_XLSY; break; case "PPTY": nFormat = FileFormats.AVS_OFFICESTUDIO_FILE_TEAMLAB_PPTY; break; } } } if (FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN != nFormat) { return(nFormat); } } else if (oZipFile.ContainsEntry("Editor.xml")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_PRESENTATION); } else if (oZipFile.ContainsEntry("Editor.svg")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_DRAWING); } else if (oZipFile.ContainsEntry("Editor.html.arch")) { return(FileFormats.AVS_OFFICESTUDIO_FILE_OTHER_OLD_DOCUMENT); } return(FileFormats.AVS_OFFICESTUDIO_FILE_UNKNOWN); }
// Token: 0x060002C2 RID: 706 RVA: 0x00015EFC File Offset: 0x000140FC internal SaveProgressEventArgs(string archiveName, bool before, int entriesTotal, int entriesSaved, ZipEntry entry) : base(archiveName, before ? ZipProgressEventType.Saving_BeforeWriteEntry : ZipProgressEventType.Saving_AfterWriteEntry) { base.EntriesTotal = entriesTotal; base.CurrentEntry = entry; this._entriesSaved = entriesSaved; }
// Can be called from within ZipEntry.InternalExtract. internal bool OnSingleEntryExtract(ZipEntry entry, string path, bool before) { EventHandler<ExtractProgressEventArgs> ep = ExtractProgress; if (ep != null) { var e = (before) ? ExtractProgressEventArgs.BeforeExtractEntry(ArchiveNameForEvent, entry, path) : ExtractProgressEventArgs.AfterExtractEntry(ArchiveNameForEvent, entry, path); ep(this, e); if (e.Cancel) _extractOperationCanceled = true; } return _extractOperationCanceled; }
/// <summary> /// Reads one entry from the zip directory structure in the zip file. /// </summary> /// /// <param name="zf"> /// The zipfile for which a directory entry will be read. From this param, the /// method gets the ReadStream and the expected text encoding /// (ProvisionalAlternateEncoding) which is used if the entry is not marked /// UTF-8. /// </param> /// /// <param name="previouslySeen"> /// a list of previously seen entry names; used to prevent duplicates. /// </param> /// /// <returns>the entry read from the archive.</returns> internal static ZipEntry ReadDirEntry(ZipFile zf, Dictionary <String, Object> previouslySeen) { System.IO.Stream s = zf.ReadStream; System.Text.Encoding expectedEncoding = (zf.AlternateEncodingUsage == ZipOption.Always) ? zf.AlternateEncoding : ZipFile.DefaultEncoding; int signature = Ionic.Zip.SharedUtilities.ReadSignature(s); // return null if this is not a local file header signature if (IsNotValidZipDirEntrySig(signature)) { s.Seek(-4, System.IO.SeekOrigin.Current); // workitem 10178 Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(s); // Getting "not a ZipDirEntry signature" here is not always wrong or an // error. This can happen when walking through a zipfile. After the // last ZipDirEntry, we expect to read an // EndOfCentralDirectorySignature. When we get this is how we know // we've reached the end of the central directory. if (signature != ZipConstants.EndOfCentralDirectorySignature && signature != ZipConstants.Zip64EndOfCentralDirectoryRecordSignature && signature != ZipConstants.ZipEntrySignature // workitem 8299 ) { throw new BadReadException(String.Format(" Bad signature (0x{0:X8}) at position 0x{1:X8}", signature, s.Position)); } return(null); } int bytesRead = 42 + 4; byte[] block = new byte[42]; int n = s.Read(block, 0, block.Length); if (n != block.Length) { return(null); } int i = 0; ZipEntry zde = new ZipEntry(); zde.AlternateEncoding = expectedEncoding; zde._Source = ZipEntrySource.ZipFile; zde._container = new ZipContainer(zf); unchecked { zde._VersionMadeBy = (short)(block[i++] + block[i++] * 256); zde._VersionNeeded = (short)(block[i++] + block[i++] * 256); zde._BitField = (short)(block[i++] + block[i++] * 256); zde._CompressionMethod = (Int16)(block[i++] + block[i++] * 256); zde._TimeBlob = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; zde._LastModified = Ionic.Zip.SharedUtilities.PackedToDateTime(zde._TimeBlob); zde._timestamp |= ZipEntryTimestamp.DOS; zde._Crc32 = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; zde._CompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256); zde._UncompressedSize = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256); } // preserve zde._CompressionMethod_FromZipFile = zde._CompressionMethod; zde._filenameLength = (short)(block[i++] + block[i++] * 256); zde._extraFieldLength = (short)(block[i++] + block[i++] * 256); zde._commentLength = (short)(block[i++] + block[i++] * 256); zde._diskNumber = (UInt32)(block[i++] + block[i++] * 256); zde._InternalFileAttrs = (short)(block[i++] + block[i++] * 256); zde._ExternalFileAttrs = block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256; zde._RelativeOffsetOfLocalHeader = (uint)(block[i++] + block[i++] * 256 + block[i++] * 256 * 256 + block[i++] * 256 * 256 * 256); // workitem 7801 zde.IsText = ((zde._InternalFileAttrs & 0x01) == 0x01); block = new byte[zde._filenameLength]; n = s.Read(block, 0, block.Length); bytesRead += n; if ((zde._BitField & 0x0800) == 0x0800) { // UTF-8 is in use zde._FileNameInArchive = Ionic.Zip.SharedUtilities.Utf8StringFromBuffer(block); } else { zde._FileNameInArchive = Ionic.Zip.SharedUtilities.StringFromBuffer(block, expectedEncoding); } // workitem 10330 // insure unique entry names while (previouslySeen.ContainsKey(zde._FileNameInArchive)) { zde._FileNameInArchive = CopyHelper.AppendCopyToFileName(zde._FileNameInArchive); zde._metadataChanged = true; } if (zde.AttributesIndicateDirectory) { zde.MarkAsDirectory(); // may append a slash to filename if nec. } // workitem 6898 else if (zde._FileNameInArchive.EndsWith("/")) { zde.MarkAsDirectory(); } zde._CompressedFileDataSize = zde._CompressedSize; if ((zde._BitField & 0x01) == 0x01) { // this may change after processing the Extra field zde._Encryption_FromZipFile = zde._Encryption = EncryptionAlgorithm.PkzipWeak; zde._sourceIsEncrypted = true; } if (zde._extraFieldLength > 0) { zde._InputUsesZip64 = (zde._CompressedSize == 0xFFFFFFFF || zde._UncompressedSize == 0xFFFFFFFF || zde._RelativeOffsetOfLocalHeader == 0xFFFFFFFF); // Console.WriteLine(" Input uses Z64?: {0}", zde._InputUsesZip64); bytesRead += zde.ProcessExtraField(s, zde._extraFieldLength); zde._CompressedFileDataSize = zde._CompressedSize; } // we've processed the extra field, so we know the encryption method is set now. if (zde._Encryption == EncryptionAlgorithm.PkzipWeak) { // the "encryption header" of 12 bytes precedes the file data zde._CompressedFileDataSize -= 12; } #if AESCRYPTO else if (zde.Encryption == EncryptionAlgorithm.WinZipAes128 || zde.Encryption == EncryptionAlgorithm.WinZipAes256) { zde._CompressedFileDataSize = zde.CompressedSize - (ZipEntry.GetLengthOfCryptoHeaderBytes(zde.Encryption) + 10); zde._LengthOfTrailer = 10; } #endif // tally the trailing descriptor if ((zde._BitField & 0x0008) == 0x0008) { // sig, CRC, Comp and Uncomp sizes if (zde._InputUsesZip64) { zde._LengthOfTrailer += 24; } else { zde._LengthOfTrailer += 16; } } // workitem 12744 zde.AlternateEncoding = ((zde._BitField & 0x0800) == 0x0800) ? System.Text.Encoding.UTF8 :expectedEncoding; zde.AlternateEncodingUsage = ZipOption.Always; if (zde._commentLength > 0) { block = new byte[zde._commentLength]; n = s.Read(block, 0, block.Length); bytesRead += n; if ((zde._BitField & 0x0800) == 0x0800) { // UTF-8 is in use zde._Comment = Ionic.Zip.SharedUtilities.Utf8StringFromBuffer(block); } else { zde._Comment = Ionic.Zip.SharedUtilities.StringFromBuffer(block, expectedEncoding); } } //zde._LengthOfDirEntry = bytesRead; return(zde); }
private static ZipEntry Create(string nameInArchive, ZipEntrySource source, Object arg1, Object arg2) { if (String.IsNullOrEmpty(nameInArchive)) { throw new Ionic.Zip.ZipException("The entry name must be non-null and non-empty."); } ZipEntry entry = new ZipEntry(); // workitem 7071 // workitem 7926 - "version made by" OS should be zero for compat with WinZip entry._VersionMadeBy = (0 << 8) + 45; // indicates the attributes are FAT Attributes, and v4.5 of the spec entry._Source = source; entry._Mtime = entry._Atime = entry._Ctime = DateTime.UtcNow; if (source == ZipEntrySource.Stream) { entry._sourceStream = (arg1 as Stream); // may or may not be null } else if (source == ZipEntrySource.WriteDelegate) { entry._WriteDelegate = (arg1 as WriteDelegate); // may or may not be null } else if (source == ZipEntrySource.JitStream) { entry._OpenDelegate = (arg1 as OpenDelegate); // may or may not be null entry._CloseDelegate = (arg2 as CloseDelegate); // may or may not be null } else if (source == ZipEntrySource.ZipOutputStream) { } // workitem 9073 else if (source == ZipEntrySource.None) { // make this a valid value, for later. entry._Source = ZipEntrySource.FileSystem; } else { String filename = (arg1 as String); // must not be null if (String.IsNullOrEmpty(filename)) { throw new Ionic.Zip.ZipException("The filename must be non-null and non-empty."); } try { // The named file may or may not exist at this time. For // example, when adding a directory by name. We test existence // when necessary: when saving the ZipFile, or when getting the // attributes, and so on. // workitem 6878?? entry._Mtime = File.GetLastWriteTime(filename).ToUniversalTime(); entry._Ctime = File.GetCreationTime(filename).ToUniversalTime(); entry._Atime = File.GetLastAccessTime(filename).ToUniversalTime(); // workitem 7071 // can only get attributes on files that exist. if (File.Exists(filename) || Directory.Exists(filename)) { entry._ExternalFileAttrs = (int)File.GetAttributes(filename); } entry._ntfsTimesAreSet = true; entry._LocalFileName = Path.GetFullPath(filename); // workitem 8813 } catch (System.IO.PathTooLongException ptle) { // workitem 14035 var msg = String.Format("The path is too long, filename={0}", filename); throw new ZipException(msg, ptle); } } entry._LastModified = entry._Mtime; entry._FileNameInArchive = SharedUtilities.NormalizePathForUseInZipFile(nameInArchive); // We don't actually slurp in the file data until the caller invokes Write on this entry. return(entry); }
// build the TOC by reading each entry in the file. private static void ReadIntoInstance_Orig(ZipFile zf) { zf.OnReadStarted(); //zf._entries = new System.Collections.Generic.List<ZipEntry>(); zf._entries = new System.Collections.Generic.Dictionary <String, ZipEntry>(); ZipEntry e; if (zf.Verbose) { if (zf.Name == null) { zf.StatusMessageTextWriter.WriteLine("Reading zip from stream..."); } else { zf.StatusMessageTextWriter.WriteLine("Reading zip {0}...", zf.Name); } } // work item 6647: PK00 (packed to removable disk) bool firstEntry = true; ZipContainer zc = new ZipContainer(zf); while ((e = ZipEntry.ReadEntry(zc, firstEntry)) != null) { if (zf.Verbose) { zf.StatusMessageTextWriter.WriteLine(" {0}", e.FileName); } zf._entries.Add(e.FileName, e); firstEntry = false; } // read the zipfile's central directory structure here. // workitem 9912 // But, because it may be corrupted, ignore errors. try { ZipEntry de; // in lieu of hashset, use a dictionary var previouslySeen = new Dictionary <String, Object>(); while ((de = ZipEntry.ReadDirEntry(zf, previouslySeen)) != null) { // Housekeeping: Since ZipFile exposes ZipEntry elements in the enumerator, // we need to copy the comment that we grab from the ZipDirEntry // into the ZipEntry, so the application can access the comment. // Also since ZipEntry is used to Write zip files, we need to copy the // file attributes to the ZipEntry as appropriate. ZipEntry e1 = zf._entries[de.FileName]; if (e1 != null) { e1._Comment = de.Comment; if (de.IsDirectory) { e1.MarkAsDirectory(); } } previouslySeen.Add(de.FileName, null); // to prevent dupes } // workitem 8299 if (zf._locEndOfCDS > 0) { zf.ReadStream.Seek(zf._locEndOfCDS, SeekOrigin.Begin); } ReadCentralDirectoryFooter(zf); if (zf.Verbose && !String.IsNullOrEmpty(zf.Comment)) { zf.StatusMessageTextWriter.WriteLine("Zip file Comment: {0}", zf.Comment); } } catch (ZipException) { } catch (IOException) { } zf.OnReadCompleted(); }
/// <summary> /// Constructor for the ExtractProgressEventArgs. /// </summary> /// <param name="archiveName">the name of the zip archive.</param> /// <param name="before">whether this is before saving the entry, or after</param> /// <param name="entriesTotal">The total number of entries in the zip archive.</param> /// <param name="entriesExtracted">Number of entries that have been extracted.</param> /// <param name="entry">The entry involved in the event.</param> /// <param name="extractLocation">The location to which entries are extracted.</param> /// <param name="wantOverwrite">indicates whether the extract operation will overwrite existing files.</param> internal ExtractProgressEventArgs(string archiveName, bool before, int entriesTotal, int entriesExtracted, ZipEntry entry, string extractLocation, bool wantOverwrite) : base(archiveName, (before) ? ZipProgressEventType.Extracting_BeforeExtractEntry : ZipProgressEventType.Extracting_AfterExtractEntry) { this.EntriesTotal = entriesTotal; this.CurrentEntry = entry; this._entriesExtracted = entriesExtracted; this._overwrite = wantOverwrite; this._target = extractLocation; }
internal void OnReadBytes(ZipEntry entry) { EventHandler<ReadProgressEventArgs> rp = ReadProgress; if (rp != null) { var e = ReadProgressEventArgs.ByteUpdate(ArchiveNameForEvent, entry, ReadStream.Position, LengthOfReadStream); rp(this, e); } }
private void OnExtractEntry(int current, bool before, ZipEntry currentEntry, string path) { EventHandler<ExtractProgressEventArgs> ep = ExtractProgress; if (ep != null) { var e = new ExtractProgressEventArgs(ArchiveNameForEvent, before, _entries.Count, current, currentEntry, path); ep(this, e); if (e.Cancel) _extractOperationCanceled = true; } }
internal static ExtractProgressEventArgs AfterExtractEntry(string archiveName, ZipEntry entry, string extractLocation) { var x = new ExtractProgressEventArgs { ArchiveName = archiveName, EventType = ZipProgressEventType.Extracting_AfterExtractEntry, CurrentEntry = entry, _target = extractLocation, }; return(x); }
private void OnSaveEntry(int current, ZipEntry entry, bool before) { EventHandler<SaveProgressEventArgs> sp = SaveProgress; if (sp != null) { var e = new SaveProgressEventArgs(ArchiveNameForEvent, before, _entries.Count, current, entry); sp(this, e); if (e.Cancel) _saveOperationCanceled = true; } }
internal static ExtractProgressEventArgs AfterExtractEntry(string archiveName, ZipEntry entry, string extractLocation, bool wantOverwrite) { var x = new ExtractProgressEventArgs(); x.ArchiveName = archiveName; x.EventType = ZipProgressEventType.Extracting_AfterExtractEntry; x.CurrentEntry = entry; x._target = extractLocation; x._overwrite = wantOverwrite; return(x); }
internal void OnReadEntry(bool before, ZipEntry entry) { EventHandler<ReadProgressEventArgs> rp = ReadProgress; if (rp != null) { ReadProgressEventArgs e = (before) ? ReadProgressEventArgs.Before(ArchiveNameForEvent, _entries.Count) : ReadProgressEventArgs.After(ArchiveNameForEvent, entry, _entries.Count); rp(this, e); } }
private static void ReadCentralDirectory(ZipFile zf) { // We must have the central directory footer record, in order to properly // read zip dir entries from the central directory. This because the logic // knows when to open a spanned file when the volume number for the central // directory differs from the volume number for the zip entry. The // _diskNumberWithCd was set when originally finding the offset for the // start of the Central Directory. // workitem 9214 bool inputUsesZip64 = false; ZipEntry de; // in lieu of hashset, use a dictionary var previouslySeen = new Dictionary <String, object>(); while ((de = ZipEntry.ReadDirEntry(zf, previouslySeen)) != null) { try { de.ResetDirEntry(); zf.OnReadEntry(true, null); if (zf.Verbose) { zf.StatusMessageTextWriter.WriteLine("entry {0}", de.FileName); } zf._entries.Add(de.FileName, de); // workitem 9214 if (de._InputUsesZip64) { inputUsesZip64 = true; } previouslySeen.Add(de.FileName, null); // to prevent dupes } catch (Exception ex) { } } // workitem 9214; auto-set the zip64 flag if (inputUsesZip64) { zf.UseZip64WhenSaving = Zip64Option.Always; } // workitem 8299 if (zf._locEndOfCDS > 0) { zf.ReadStream.Seek(zf._locEndOfCDS, SeekOrigin.Begin); } ReadCentralDirectoryFooter(zf); if (zf.Verbose && !String.IsNullOrEmpty(zf.Comment)) { zf.StatusMessageTextWriter.WriteLine("Zip file Comment: {0}", zf.Comment); } // We keep the read stream open after reading. if (zf.Verbose) { zf.StatusMessageTextWriter.WriteLine("read in {0} entries.", zf._entries.Count); } zf.OnReadCompleted(); }
// Can be called from within ZipEntry._ExtractOne. internal bool OnExtractBlock(ZipEntry entry, Int64 bytesWritten, Int64 totalBytesToWrite) { EventHandler<ExtractProgressEventArgs> ep = ExtractProgress; if (ep != null) { var e = ExtractProgressEventArgs.ByteUpdate(ArchiveNameForEvent, entry, bytesWritten, totalBytesToWrite); ep(this, e); if (e.Cancel) _extractOperationCanceled = true; } return _extractOperationCanceled; }
private void _SaveSfxStub(string exeToGenerate, SelfExtractorSaveOptions options) { string nameOfIconFile = null; string stubExe = null; string unpackedResourceDir = null; string tmpDir = null; try { if (File.Exists(exeToGenerate)) { if (Verbose) { StatusMessageTextWriter.WriteLine("The existing file ({0}) will be overwritten.", exeToGenerate); } } if (!exeToGenerate.EndsWith(".exe")) { if (Verbose) { StatusMessageTextWriter.WriteLine("Warning: The generated self-extracting file will not have an .exe extension."); } } // workitem 10553 tmpDir = TempFileFolder ?? Path.GetDirectoryName(exeToGenerate); stubExe = GenerateTempPathname(tmpDir, "exe"); // get the Ionic.Zip assembly Assembly a1 = typeof(ZipFile).Assembly; using (var csharp = new Microsoft.CSharp.CSharpCodeProvider (new Dictionary <string, string>() { { "CompilerVersion", "v2.0" } })) { ExtractorSettings settings = (from x in SettingsList where x.Flavor == options.Flavor select x).FirstOrDefault(); // sanity check; should never happen if (settings == null) { throw new BadStateException(String.Format("While saving a Self-Extracting Zip, Cannot find that flavor ({0})?", options.Flavor)); } // This is the list of referenced assemblies. Ionic.Zip is // needed here. Also if it is the winforms (gui) extractor, we // need other referenced assemblies, like // System.Windows.Forms.dll, etc. var cp = new System.CodeDom.Compiler.CompilerParameters(); cp.ReferencedAssemblies.Add(a1.Location); if (settings.ReferencedAssemblies != null) { foreach (string ra in settings.ReferencedAssemblies) { cp.ReferencedAssemblies.Add(ra); } } cp.GenerateInMemory = false; cp.GenerateExecutable = true; cp.IncludeDebugInformation = false; cp.CompilerOptions = ""; Assembly a2 = Assembly.GetExecutingAssembly(); // Use this to concatenate all the source code resources into a // single module. var sb = new System.Text.StringBuilder(); // In case there are compiler errors later, we allocate a source // file name now. If errors are detected, we'll spool the source // code as well as the errors (in comments) into that filename, // and throw an exception with the filename. Makes it easier to // diagnose. This should be rare; most errors happen only // during devlpmt of DotNetZip itself, but there are rare // occasions when they occur in other cases. string sourceFile = GenerateTempPathname(tmpDir, "cs"); // // debugging: enumerate the resources in this assembly // Console.WriteLine("Resources in this assembly:"); // foreach (string rsrc in a2.GetManifestResourceNames()) // { // Console.WriteLine(rsrc); // } // Console.WriteLine(); // all the source code is embedded in the DLL as a zip file. using (ZipFile zip = ZipFile.Read(a2.GetManifestResourceStream("Ionic.Zip.Resources.ZippedResources.zip"))) { // // debugging: enumerate the files in the embedded zip // Console.WriteLine("Entries in the embbedded zip:"); // foreach (ZipEntry entry in zip) // { // Console.WriteLine(entry.FileName); // } // Console.WriteLine(); unpackedResourceDir = GenerateTempPathname(tmpDir, "tmp"); if (String.IsNullOrEmpty(options.IconFile)) { // Use the ico file that is embedded into the Ionic.Zip // DLL itself. To do this we must unpack the icon to // the filesystem, in order to specify it on the cmdline // of csc.exe. This method will remove the unpacked // file later. System.IO.Directory.CreateDirectory(unpackedResourceDir); ZipEntry e = zip["zippedFile.ico"]; // Must not extract a readonly file - it will be impossible to // delete later. if ((e.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly) { e.Attributes ^= FileAttributes.ReadOnly; } e.Extract(unpackedResourceDir); nameOfIconFile = Path.Combine(unpackedResourceDir, "zippedFile.ico"); cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", nameOfIconFile); } else { cp.CompilerOptions += String.Format("/win32icon:\"{0}\"", options.IconFile); } cp.OutputAssembly = stubExe; if (options.Flavor == SelfExtractorFlavor.WinFormsApplication) { cp.CompilerOptions += " /target:winexe"; } if (!String.IsNullOrEmpty(options.AdditionalCompilerSwitches)) { cp.CompilerOptions += " " + options.AdditionalCompilerSwitches; } if (String.IsNullOrEmpty(cp.CompilerOptions)) { cp.CompilerOptions = null; } if ((settings.CopyThroughResources != null) && (settings.CopyThroughResources.Count != 0)) { if (!Directory.Exists(unpackedResourceDir)) { System.IO.Directory.CreateDirectory(unpackedResourceDir); } foreach (string re in settings.CopyThroughResources) { string filename = Path.Combine(unpackedResourceDir, re); ExtractResourceToFile(a2, re, filename); // add the file into the target assembly as an embedded resource cp.EmbeddedResources.Add(filename); } } // add the Ionic.Utils.Zip DLL as an embedded resource cp.EmbeddedResources.Add(a1.Location); // file header sb.Append("// " + Path.GetFileName(sourceFile) + "\n") .Append("// --------------------------------------------\n//\n") .Append("// This SFX source file was generated by DotNetZip ") .Append(ZipFile.LibraryVersion.ToString()) .Append("\n// at ") .Append(System.DateTime.Now.ToString("yyyy MMMM dd HH:mm:ss")) .Append("\n//\n// --------------------------------------------\n\n\n"); // assembly attributes if (!String.IsNullOrEmpty(options.Description)) { sb.Append("[assembly: System.Reflection.AssemblyTitle(\"" + options.Description.Replace("\"", "") + "\")]\n"); } else { sb.Append("[assembly: System.Reflection.AssemblyTitle(\"DotNetZip SFX Archive\")]\n"); } if (!String.IsNullOrEmpty(options.ProductVersion)) { sb.Append("[assembly: System.Reflection.AssemblyInformationalVersion(\"" + options.ProductVersion.Replace("\"", "") + "\")]\n"); } // workitem string copyright = (String.IsNullOrEmpty(options.Copyright)) ? "Extractor: Copyright � Dino Chiesa 2008-2011" : options.Copyright.Replace("\"", ""); if (!String.IsNullOrEmpty(options.ProductName)) { sb.Append("[assembly: System.Reflection.AssemblyProduct(\"") .Append(options.ProductName.Replace("\"", "")) .Append("\")]\n"); } else { sb.Append("[assembly: System.Reflection.AssemblyProduct(\"DotNetZip\")]\n"); } sb.Append("[assembly: System.Reflection.AssemblyCopyright(\"" + copyright + "\")]\n") .Append(String.Format("[assembly: System.Reflection.AssemblyVersion(\"{0}\")]\n", ZipFile.LibraryVersion.ToString())); if (options.FileVersion != null) { sb.Append(String.Format("[assembly: System.Reflection.AssemblyFileVersion(\"{0}\")]\n", options.FileVersion.ToString())); } sb.Append("\n\n\n"); // Set the default extract location if it is available string extractLoc = options.DefaultExtractDirectory; if (extractLoc != null) { // remove double-quotes and replace slash with double-slash. // This, because the value is going to be embedded into a // cs file as a quoted string, and it needs to be escaped. extractLoc = extractLoc.Replace("\"", "").Replace("\\", "\\\\"); } string postExCmdLine = options.PostExtractCommandLine; if (postExCmdLine != null) { postExCmdLine = postExCmdLine.Replace("\\", "\\\\"); postExCmdLine = postExCmdLine.Replace("\"", "\\\""); } foreach (string rc in settings.ResourcesToCompile) { using (Stream s = zip[rc].OpenReader()) { if (s == null) { throw new ZipException(String.Format("missing resource '{0}'", rc)); } using (StreamReader sr = new StreamReader(s)) { while (sr.Peek() >= 0) { string line = sr.ReadLine(); if (extractLoc != null) { line = line.Replace("@@EXTRACTLOCATION", extractLoc); } line = line.Replace("@@REMOVE_AFTER_EXECUTE", options.RemoveUnpackedFilesAfterExecute.ToString()); line = line.Replace("@@QUIET", options.Quiet.ToString()); if (!String.IsNullOrEmpty(options.SfxExeWindowTitle)) { line = line.Replace("@@SFX_EXE_WINDOW_TITLE", options.SfxExeWindowTitle); } line = line.Replace("@@EXTRACT_EXISTING_FILE", ((int)options.ExtractExistingFile).ToString()); if (postExCmdLine != null) { line = line.Replace("@@POST_UNPACK_CMD_LINE", postExCmdLine); } sb.Append(line).Append("\n"); } } sb.Append("\n\n"); } } } string LiteralSource = sb.ToString(); #if DEBUGSFX // for debugging only string sourceModule = GenerateTempPathname(tmpDir, "cs"); using (StreamWriter sw = File.CreateText(sourceModule)) { sw.Write(LiteralSource); } Console.WriteLine("source: {0}", sourceModule); #endif var cr = csharp.CompileAssemblyFromSource(cp, LiteralSource); if (cr == null) { throw new SfxGenerationException("Cannot compile the extraction logic!"); } if (Verbose) { foreach (string output in cr.Output) { StatusMessageTextWriter.WriteLine(output); } } if (cr.Errors.Count != 0) { using (TextWriter tw = new StreamWriter(sourceFile)) { // first, the source we compiled tw.Write(LiteralSource); // now, append the compile errors tw.Write("\n\n\n// ------------------------------------------------------------------\n"); tw.Write("// Errors during compilation: \n//\n"); string p = Path.GetFileName(sourceFile); foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors) { tw.Write(String.Format("// {0}({1},{2}): {3} {4}: {5}\n//\n", p, // 0 error.Line, // 1 error.Column, // 2 error.IsWarning ? "Warning" : "error", // 3 error.ErrorNumber, // 4 error.ErrorText)); // 5 } } throw new SfxGenerationException(String.Format("Errors compiling the extraction logic! {0}", sourceFile)); } OnSaveEvent(ZipProgressEventType.Saving_AfterCompileSelfExtractor); // Now, copy the resulting EXE image to the _writestream. // Because this stub exe is being saved first, the effect will be to // concatenate the exe and the zip data together. using (System.IO.Stream input = System.IO.File.OpenRead(stubExe)) { byte[] buffer = new byte[4000]; int n = 1; while (n != 0) { n = input.Read(buffer, 0, buffer.Length); if (n != 0) { WriteStream.Write(buffer, 0, n); } } } } OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive); } finally { try { if (Directory.Exists(unpackedResourceDir)) { try { Directory.Delete(unpackedResourceDir, true); } catch (System.IO.IOException exc1) { StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1); } } if (File.Exists(stubExe)) { try { File.Delete(stubExe); } catch (System.IO.IOException exc1) { StatusMessageTextWriter.WriteLine("Warning: Exception: {0}", exc1); } } } catch (System.IO.IOException) { } } return; }
internal bool OnExtractExisting(ZipEntry entry, string path) { EventHandler<ExtractProgressEventArgs> ep = ExtractProgress; if (ep != null) { var e = ExtractProgressEventArgs.ExtractExisting(ArchiveNameForEvent, entry, path); ep(this, e); if (e.Cancel) _extractOperationCanceled = true; } return _extractOperationCanceled; }
public static ZipCrypto ForRead(string password, ZipEntry e) { System.IO.Stream s = e._archiveStream; e._WeakEncryptionHeader = new byte[12]; byte[] eh = e._WeakEncryptionHeader; ZipCrypto z = new ZipCrypto(); if (password == null) { throw new BadPasswordException("This entry requires a password."); } z.InitCipher(password); ZipEntry.ReadWeakEncryptionHeader(s, eh); // Decrypt the header. This has a side effect of "further initializing the // encryption keys" in the traditional zip encryption. byte[] DecryptedHeader = z.DecryptMessage(eh, eh.Length); // CRC check // According to the pkzip spec, the final byte in the decrypted header // is the highest-order byte in the CRC. We check it here. if (DecryptedHeader[11] != (byte)((e._Crc32 >> 24) & 0xff)) { // In the case that bit 3 of the general purpose bit flag is set to // indicate the presence of an 'Extended File Header' or a 'data // descriptor' (signature 0x08074b50), the last byte of the decrypted // header is sometimes compared with the high-order byte of the // lastmodified time, rather than the high-order byte of the CRC, to // verify the password. // // This is not documented in the PKWare Appnote.txt. It was // discovered this by analysis of the Crypt.c source file in the // InfoZip library http://www.info-zip.org/pub/infozip/ // // The reason for this is that the CRC for a file cannot be known // until the entire contents of the file have been streamed. This // means a tool would have to read the file content TWICE in its // entirety in order to perform PKZIP encryption - once to compute // the CRC, and again to actually encrypt. // // This is so important for performance that using the timeblob as // the verification should be the standard practice for DotNetZip // when using PKZIP encryption. This implies that bit 3 must be // set. The downside is that some tools still cannot cope with ZIP // files that use bit 3. Therefore, DotNetZip DOES NOT force bit 3 // when PKZIP encryption is in use, and instead, reads the stream // twice. // if ((e._BitField & 0x0008) != 0x0008) { throw new BadPasswordException("The password did not match."); } else if (DecryptedHeader[11] != (byte)((e._TimeBlob >> 8) & 0xff)) { throw new BadPasswordException("The password did not match."); } // We have a good password. } else { // A-OK } return(z); }