/// <summary> /// Creates a file on the file system with the entry?s contents and the specified name. The last write time of the file is set to the /// entry?s last write time. This method does not allow overwriting of an existing file with the same name. Attempting to extract explicit /// directories (entries with names that end in directory separator characters) will not result in the creation of a directory. /// </summary> /// /// <exception cref="UnauthorizedAccessException">The caller does not have the required permission.</exception> /// <exception cref="ArgumentException">destinationFileName is a zero-length string, contains only white space, or contains one or more /// invalid characters as defined by InvalidPathChars. -or- destinationFileName specifies a directory.</exception> /// <exception cref="ArgumentNullException">destinationFileName is null.</exception> /// <exception cref="PathTooLongException">The specified path, file name, or both exceed the system-defined maximum length. /// For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.</exception> /// <exception cref="DirectoryNotFoundException">The path specified in destinationFileName is invalid (for example, it is on /// an unmapped drive).</exception> /// <exception cref="IOException">destinationFileName already exists. /// -or- An I/O error has occurred. -or- The entry is currently open for writing. /// -or- The entry has been deleted from the archive.</exception> /// <exception cref="NotSupportedException">destinationFileName is in an invalid format /// -or- The ZipArchive that this entry belongs to was opened in a write-only mode.</exception> /// <exception cref="InvalidDataException">The entry is missing from the archive or is corrupt and cannot be read /// -or- The entry has been compressed using a compression method that is not supported.</exception> /// <exception cref="ObjectDisposedException">The ZipArchive that this entry belongs to has been disposed.</exception> /// /// <param name="destinationFile">The name of the file that will hold the contents of the entry. /// The path is permitted to specify relative or absolute path information. /// Relative path information is interpreted as relative to the current working directory.</param> public static void ExtractToFile(this ZipArchiveEntry source, FileEntry destinationFile) { ExtractToFile(source, destinationFile, false); }
public static async Task <EpubPackage> ReadPackageAsync(ZipArchive epubArchive, string rootFilePath) { ZipArchiveEntry rootFileEntry = epubArchive.GetEntry(rootFilePath); if (rootFileEntry == null) { throw new Exception("EPUB parsing error: root file not found in archive."); } XDocument containerDocument; using (Stream containerStream = rootFileEntry.Open()) { containerDocument = await XmlUtils.LoadDocumentAsync(containerStream).ConfigureAwait(false); } XNamespace opfNamespace = "http://www.idpf.org/2007/opf"; XElement packageNode = containerDocument.Element(opfNamespace + "package"); EpubPackage result = new EpubPackage(); string epubVersionValue = packageNode.Attribute("version").Value; if (epubVersionValue == "2.0") { result.EpubVersion = EpubVersion.EPUB_2; } else if (epubVersionValue == "3.0") { result.EpubVersion = EpubVersion.EPUB_3; } else { throw new Exception(String.Format("Unsupported EPUB version: {0}.", epubVersionValue)); } XElement metadataNode = packageNode.Element(opfNamespace + "metadata"); if (metadataNode == null) { throw new Exception("EPUB parsing error: metadata not found in the package."); } EpubMetadata metadata = ReadMetadata(metadataNode, result.EpubVersion); result.Metadata = metadata; XElement manifestNode = packageNode.Element(opfNamespace + "manifest"); if (manifestNode == null) { throw new Exception("EPUB parsing error: manifest not found in the package."); } EpubManifest manifest = ReadManifest(manifestNode); result.Manifest = manifest; XElement spineNode = packageNode.Element(opfNamespace + "spine"); if (spineNode == null) { throw new Exception("EPUB parsing error: spine not found in the package."); } EpubSpine spine = ReadSpine(spineNode); result.Spine = spine; XElement guideNode = packageNode.Element(opfNamespace + "guide"); if (guideNode != null) { EpubGuide guide = ReadGuide(guideNode); result.Guide = guide; } return(result); }
/// <summary> /// Updates the Manifest.xml file of the datapackage to be uploaded with the original file name of the related data message before the upload /// </summary> /// <param name="archive">The data package which is being prepared for upload</param> /// <param name="dataMessage">The data message object containing the inforation related to the file which is getting uploaded</param> /// <param name="fileNameInPackageOrig">Original file name in the package</param> /// <returns>Final file name in the package</returns> private string UpdateManifestFile(ZipArchive archive, DataMessage dataMessage, string fileNameInPackageOrig) { if (archive is null || dataMessage is null) { return(fileNameInPackageOrig); } // This modification will cause that the original file name is used in the package that is going to be uploaded to D365 // Get the manifest.xml entery ZipArchiveEntry manifestEntry = archive.GetEntry("Manifest.xml"); // Save the Manifest.xml as temporary file string tempManifestFileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); string tempManifestFileNameNew = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); manifestEntry.ExtractToFile(tempManifestFileName, true); // Modify the file name to the original filename XmlDocument tempXmlDocManifest = new XmlDocument(); using (var tempManifestFile = new StreamReader(tempManifestFileName)) { tempXmlDocManifest.Load(new XmlTextReader(tempManifestFile) { Namespaces = false }); tempXmlDocManifest.SelectSingleNode("//InputFilePath[1]").InnerText = Path.GetFileName(dataMessage.FullPath); // Save the document to a file and auto-indent the output. using XmlTextWriter writer = new XmlTextWriter(tempManifestFileNameNew, null) { Namespaces = false, Formatting = System.Xml.Formatting.Indented }; tempXmlDocManifest.Save(writer); } // Delete the Manifest.xml from the archive file manifestEntry.Delete(); // Add a new Manifest.xml based on the adjusted file archive.CreateEntryFromFile(tempManifestFileNameNew, "Manifest.xml"); // Delete the tempoirary file File.Delete(tempManifestFileName); File.Delete(tempManifestFileNameNew); // Adapt the fileNameInPackage string fileNameInPackage = Path.GetFileName(dataMessage.FullPath); // Check if package template contains input file and remove it first. It should not be there in the first place. ZipArchiveEntry entry = archive.GetEntry(fileNameInPackage); if (entry != null) { entry.Delete(); Log.WarnFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Package_template_contains_input_file_1_Please_remove_it_from_the_template, fileNameInPackage)); } return(fileNameInPackage); }
public void Read(ZipArchive archive, string MapName, bool ApplyUpdates) { string basename = MapName.Remove(MapName.Length - 4); Stream S57map = null; ZipArchiveEntry baseentry = null; SortedList <uint, ZipArchiveEntry> updatefiles = new SortedList <uint, ZipArchiveEntry>(); Stream S57update; foreach (ZipArchiveEntry entry in archive.Entries) { if (entry.Name.Contains(basename)) { if (entry.Name.Equals(MapName)) { baseentry = entry; } else { int val; string end = entry.Name.Substring(entry.Name.Length - 3); if (char.IsDigit(end[0]) && char.IsDigit(end[1]) && char.IsDigit(end[2])) { int.TryParse(end, out val); updatefiles.Add(Convert.ToUInt32(end.ToString()), entry); } } } } S57map = baseentry.Open(); int count = (int)baseentry.Length; if (fileByteArray == null) { fileByteArray = new byte[count]; } else { Array.Clear(fileByteArray, 0, fileByteArray.Length); Array.Resize(ref fileByteArray, count); } MemoryStream memoryStream = new MemoryStream(fileByteArray); S57map.CopyTo(memoryStream); memoryStream.Dispose(); using (var reader = new Iso8211Reader(fileByteArray)) { baseFile = new BaseFile(reader); foreach (var bla in reader.tagcollector) { Console.WriteLine(bla); } } S57map.Dispose(); if (ApplyUpdates) { foreach (var entry in updatefiles) { S57update = entry.Value.Open(); count = (int)entry.Value.Length; Array.Clear(fileByteArray, 0, fileByteArray.Length); Array.Resize(ref fileByteArray, count); memoryStream = new MemoryStream(fileByteArray); S57update.CopyTo(memoryStream); memoryStream.Dispose(); using (var updatereader = new Iso8211Reader(fileByteArray)) { UpdateFile updateFile = new UpdateFile(updatereader); baseFile.ApplyUpdateFile(updateFile); } S57update.Dispose(); } } cellInfo = new Cell(baseFile); baseFile.BindVectorPointersOfVectors(); baseFile.BindVectorPointersOfFeatures(); baseFile.BuildVectorGeometry(); baseFile.BindFeatureObjectPointers(); }
public ParallelReadableZipArchiveEntry(ZipArchiveEntry zipArchiveEntry, ParallelReadableZipArchive parallelReadableZipArchive) { this.zipArchive = parallelReadableZipArchive; this.FullName = zipArchiveEntry.FullName; this.LastWriteTime = zipArchiveEntry.LastWriteTime; }
public void DeserializeFiddlerTrace(String filePath, String customAgent) { // Open the SAZ var archive = System.IO.Compression.ZipFile.Open(filePath, ZipArchiveMode.Read); // Group the archive entries by frame number var result = from e in archive.Entries where e.Name.Contains("_c.txt") || e.Name.Contains("_s.txt") || e.Name.Contains("_m.xml") group e by Utils.GetFrameNumber(e.Name) into g select new { Frame = g.Key, Data = g }; List <ServiceCallItem> frameData = new List <ServiceCallItem>(); // Process data per frame foreach (var group in result) { // Grab the individual files ZipArchiveEntry cFileArchive = group.Data.ElementAt(0); ZipArchiveEntry mFileArchive = group.Data.ElementAt(1); ZipArchiveEntry sFileArchive = group.Data.ElementAt(2); ServiceCallItem frame = null; frame = ServiceCallItem.FromFiddlerFrame((UInt32)group.Frame, cFileArchive, mFileArchive, sFileArchive); // If this is not an Xbox Service Endpoint that we are checking, then move along. if (frame == null || (!Utils.IsAnalyzedService(frame, customAgent) && m_allEndpoints == false)) { continue; } frameData.Add(frame); } var consoleGroups = from f in frameData group f by f.m_consoleIP; foreach (var consoleFrames in consoleGroups.Where(g => g.Key != String.Empty)) { var consoleData = new PerConsoleData(); var xboxServiceFrames = consoleFrames.GroupBy(f => f.m_host) .Select(group => new { Host = group.Key, History = group.AsEnumerable() }); consoleData.m_servicesHistory = xboxServiceFrames.ToDictionary(g => g.Host, g => new LinkedList <ServiceCallItem>(g.History.OrderBy(call => call.m_reqTimeUTC))); // Xbox telemetry endpoint if (consoleData.m_servicesHistory.ContainsKey("data-vef.xboxlive.com")) { ConvertCS1ToEvent(consoleData.m_servicesHistory); } // Windows Telemetry endpoint if (consoleData.m_servicesHistory.Any(k => k.Key.Contains(".data.microsoft.com"))) { ConvertCS2ToEvent(consoleData.m_servicesHistory); } foreach (var endpoint in consoleData.m_servicesHistory) { consoleData.m_servicesStats.Add(endpoint.Key, new ServiceCallStats(endpoint.Value)); } m_perConsoleData.Add(consoleFrames.Key, consoleData); } }
public static void ExtractToFile(this ZipArchiveEntry source, string destinationFileName, bool overwrite);
static void Main(string[] args) { string recafJarPath = Path.Combine(Directory.GetCurrentDirectory(), "recaf-edit.jar"); string destJarPath = Path.Combine(Directory.GetCurrentDirectory(), "spacehaven.jar"); string destZipPath = Path.Combine(Directory.GetCurrentDirectory(), "patch.zip"); Console.WriteLine("Config : JarPacker.config"); Console.WriteLine("Recaf JAR : recaf-edit.jar"); Console.WriteLine("Destination JAR : spacehaven.jar"); Console.WriteLine("---------------------------------------------------------"); string[] classPaths = File.ReadAllLines(Path.Combine(Directory.GetCurrentDirectory(), "JarPacker.config")); using (ZipArchive recafJar = ZipFile.Open(recafJarPath, ZipArchiveMode.Read)) { List <ZipArchiveEntry> classEntries = new List <ZipArchiveEntry>(); foreach (string classPath in classPaths) { ZipArchiveEntry classEntry = recafJar.GetEntry(classPath.Trim()); if (classEntry == null) { Console.WriteLine($"Can't find {classPath} in {recafJarPath}"); Console.ReadLine(); return; } classEntries.Add(classEntry); } Console.WriteLine("What do you want to do ?"); Console.WriteLine("[1] Update spacehaven.jar"); Console.WriteLine("[2] Create patch zip"); switch (Console.ReadKey(true).KeyChar) { case '1': using (ZipArchive destJar = ZipFile.Open(destJarPath, ZipArchiveMode.Update)) { foreach (ZipArchiveEntry classEntry in classEntries) { destJar.GetEntry(classEntry.FullName).Delete(); ZipArchiveEntry updatedEntry = destJar.CreateEntry(classEntry.FullName); classEntry.Open().CopyTo(updatedEntry.Open()); Console.WriteLine($"Updated {classEntry.FullName}"); } } Console.WriteLine($"Updated all classes in {destJarPath}"); break; case '2': using (FileStream fileStream = new FileStream(destZipPath, FileMode.Create)) { using (ZipArchive destZip = new ZipArchive(fileStream, ZipArchiveMode.Update)) { foreach (ZipArchiveEntry classEntry in classEntries) { ZipArchiveEntry newEntry = destZip.CreateEntry(classEntry.FullName); classEntry.Open().CopyTo(newEntry.Open()); Console.WriteLine($"Created {classEntry.FullName}"); } } } Console.WriteLine($"Zip patch written : {destZipPath}"); break; } } Console.ReadLine(); }
/// <summary> /// Determines NuGet packages from 'packages.config'. /// </summary> /// <param name="project">Project to inspect.</param> /// <param name="packagesFolders">Possible 'packages' folders inside solution or project directories.</param> private void GetNuGetPackagesFromPackagesConfig(ProjectInfo project, HashSet <string> packagesFolders) { sLog.Write(LogLevel.Debug, "Get nuspec files for '{0}'", project.ProjectName); var packagePaths = new Dictionary <string, string>(); // extract 'packages.config' and determine id and version foreach (XElement element in XElement.Load(project.NuGetInformationPath).Descendants()) { switch (element.Name.LocalName) { case "package": string id = element.Attribute("id").Value; if (string.IsNullOrEmpty(id)) { continue; } string version = element.Attribute("version").Value; if (string.IsNullOrEmpty(version)) { continue; } packagePaths.Add(id, $"{id}.{version}"); break; } } var nugetPackages = new Dictionary <string, string>(); // find path to NuGet packages inside one of the packages folder foreach (string id in packagePaths.Keys) { foreach (string packagesFolder in packagesFolders) { string nugetPackagePath = Path.Combine(packagesFolder, packagePaths[id], $"{packagePaths[id]}.nupkg"); if (!File.Exists(nugetPackagePath)) { continue; } sLog.Write(LogLevel.Debug, "{0}: Found NuGet package '{1}'.", project.ProjectName, nugetPackagePath); nugetPackages.Add(id, nugetPackagePath); break; } } // extract 'nuspec' file from package and store information foreach (string nugetId in nugetPackages.Keys) { if (mNuGetPackages.ContainsKey(nugetId)) { // NuGet package dependency was already found within another project continue; } // extract nuspec file from package using (var fs = new FileStream(nugetPackages[nugetId], FileMode.Open)) { var archive = new ZipArchive(fs, ZipArchiveMode.Read); ZipArchiveEntry nuSpec = archive.Entries.First(x => x.Name.EndsWith(".nuspec")); if (nuSpec == null) { sLog.Write(LogLevel.Error, "The NuGet package '{0}' does not contains an '.nuspec' file.", nugetId); continue; } string nuspecPath = Path.Combine(Path.GetDirectoryName(nugetPackages[nugetId]), $"{nugetId}.nuspec"); using (var nuspecStream = new FileStream(nuspecPath, FileMode.Create, FileAccess.Write)) { nuSpec.Open().CopyTo(nuspecStream); } sLog.Write(LogLevel.Debug, "Add NuGet package '{0}' to processing...", nugetId); mNuGetPackages.Add(nugetId, nuspecPath); } } }
/// <summary> /// Inspect each given nuget package for either license or licenseUrl tags. Download license if necessary. /// </summary> public void GetNuGetLicenseInfo() { if (mFinishProcessing) { // already finished processing return; } if (mNuGetPackages == null || mNuGetPackages.Count == 0) { // no NuGet packages found to process. sLog.Write(LogLevel.Notice, "There are no NuGet packages found."); return; } foreach (string nuSpecFilePath in mNuGetPackages.Values) { sLog.Write(LogLevel.Debug, "Begin retrieving NuGet specification information from '{0}'...", nuSpecFilePath); // extract important information from NuGet specification file var doc = new XmlDocument(); doc.Load(nuSpecFilePath); XmlNode root = doc.DocumentElement; if (root == null) { continue; } var namespaceManager = new XmlNamespaceManager(doc.NameTable); namespaceManager.AddNamespace("nu", root.NamespaceURI); string identifier = root.SelectSingleNode("/nu:package/nu:metadata/nu:id", namespaceManager)?.InnerText ?? string.Empty; string version = root.SelectSingleNode("/nu:package/nu:metadata/nu:version", namespaceManager)?.InnerText ?? string.Empty; string authors = root.SelectSingleNode("/nu:package/nu:metadata/nu:authors", namespaceManager)?.InnerText ?? string.Empty; string licenseUrl = root.SelectSingleNode("/nu:package/nu:metadata/nu:licenseUrl", namespaceManager)?.InnerText ?? string.Empty; if (licenseUrl == cDeprecatedLicenseUrl) { licenseUrl = string.Empty; } string projectUrl = root.SelectSingleNode("/nu:package/nu:metadata/nu:projectUrl", namespaceManager)?.InnerText ?? string.Empty; string copyright = root.SelectSingleNode("/nu:package/nu:metadata/nu:copyright", namespaceManager)?.InnerText ?? string.Empty; XmlNode licenseNode = root.SelectSingleNode("/nu:package/nu:metadata/nu:license", namespaceManager); var license = string.Empty; if (licenseNode != null) { switch (licenseNode.Attributes["type"].Value) { // TODO: Is there a better handling e.g. loading templates? case "expression": // SPDX expression as defined in https://spdx.org/spdx-specification-21-web-version#h.jxpfx0ykyb60 license = licenseNode.InnerText ?? string.Empty; break; case "file": // license is contained as file within the nuget package string directoryPath = Path.GetDirectoryName(nuSpecFilePath); string licensePath = Path.Combine(directoryPath, licenseNode.InnerText); if (!File.Exists(licensePath)) { // License file does not exist, try to open NuGet package on same folder hierarchy // this could happen if a packages.config was processed and only the nuspec was unzipped. string nugetPackage = Path.Combine(directoryPath, $"{identifier}.{version}.nupkg"); if (!File.Exists(nugetPackage)) { sLog.Write( LogLevel.Error, "The path '{0}' to the license defined by the NuGet specification does not exists.", licensePath); break; } // try to extract license file from package using (var fs = new FileStream(nugetPackage, FileMode.Open)) { var archive = new ZipArchive(fs, ZipArchiveMode.Read); ZipArchiveEntry licenseEntry = archive.Entries.First(x => x.Name.Contains(licenseNode.InnerText)); if (licenseEntry == null) { sLog.Write(LogLevel.Error, "The NuGet package '{0}' does not contains '{1}'", licenseNode.InnerText); break; } using (var licenseStream = new FileStream(licensePath, FileMode.Create, FileAccess.Write)) { licenseEntry.Open().CopyTo(licenseStream); } } } license = File.ReadAllText(licensePath) ?? string.Empty; break; } } // TODO: extend to download other url then from github.com if (string.IsNullOrEmpty(license) && !string.IsNullOrEmpty(licenseUrl) && (licenseUrl.Contains("github.com") || licenseUrl.Contains("/raw.githubusercontent.com/"))) { // download license when only url to license is given string url = licenseUrl.Contains("github.com") ? licenseUrl.Replace("/blob/", "/raw/") : licenseUrl; try { using (var client = new WebClient()) { license = client.DownloadString(url); sLog.Write(LogLevel.Debug, "Successful downloaded license '{0}' for {1}", url, identifier); } } catch (WebException ex) { sLog.Write(LogLevel.Error, "Error during downloading '{0}': {1}", url, ex.Message); } } if (string.IsNullOrEmpty(license) && string.IsNullOrEmpty(licenseUrl)) { sLog.Write(LogLevel.Error, "The NuGet specification file '{0}' does not contain valid license information", nuSpecFilePath); continue; } var package = new PackageLicenseInfo(identifier, version, authors, copyright, licenseUrl, projectUrl, license); mLicenses.Add(package); sLog.Write(LogLevel.Debug, "Successful extract license information for '{0} v{1}'.", identifier, version); } sLog.Write(LogLevel.Notice, "Successful extract license information from found NuGet packages."); sLog.Write(LogLevel.Notice, "--------------------------------------------------------------------------------"); }
private void ParseAuditFvdlWithXmlReader(ZipArchiveEntry zipArchiveEntry, string systemName) { try { XmlReaderSettings xmlReaderSettings = GenerateXmlReaderSettings(); using (XmlReader xmlReader = XmlReader.Create(zipArchiveEntry.Open(), xmlReaderSettings)) { while (xmlReader.Read()) { if (xmlReader.IsStartElement()) { switch (xmlReader.Name) { case "CreatedTS": { lastObserved = DateTime.Parse(xmlReader.GetAttribute("date")).ToLongDateString(); break; } case "BuildID": { CreateAddAssetCommand(xmlReader, systemName); break; } case "Vulnerability": { ParseFvdlVulnerablityNode(xmlReader); break; } case "Description": { ParseFvdlDescriptionNode(xmlReader); break; } case "EngineVersion": { CreateUpdateSourceCommand(xmlReader); break; } default: { break; } } } } } foreach (FprVulnerability fprVulnerability in fprVulnerabilityList) { using (SQLiteCommand sqliteCommand = FindingsDatabaseActions.sqliteConnection.CreateCommand()) { AddVulnerabilityAndUniqueFinding(fprVulnerability); } } } catch (Exception exception) { log.Error("Unable to read \"audit.fvdl\"."); throw exception; } }
public ZipArchiveEntryWrap(ZipArchiveEntry instance) { this.Instance = instance; }
static void Main() { using ZipArchive zipFile = ZipFile.Open("zipFile.zip", ZipArchiveMode.Create); ZipArchiveEntry zipArchiveEntry = zipFile.CreateEntryFromFile("copyMe.png", "copyMeEntry.png"); }
private void ButtomCompute_Click(object sender, RoutedEventArgs e) { ButtomCompute.IsEnabled = false; ButtonSelectDestinationDirectory.IsEnabled = false; ButtonSelectSourceDirectory.IsEnabled = false; if (TextBoxSourceDirectory.Text == NODIRSTR || TextBoxDestinationDirectory.Text == NODIRSTR) { System.Windows.MessageBox.Show("Please select both a source and destination directory."); return; } DirectoryInfo SourceDirectory = new DirectoryInfo(TextBoxSourceDirectory.Text); if (!SourceDirectory.Exists) { System.Windows.MessageBox.Show(string.Format("Source directory \"{0}\" does not exist. Please use the \"Select...\" button to navigate to a real directory.", SourceDirectory.FullName)); return; } DirectoryInfo DestinationDirectory = new DirectoryInfo(TextBoxDestinationDirectory.Text); if (!DestinationDirectory.Exists) { System.Windows.MessageBox.Show(string.Format("Destination directory \"{0}\" does not exist. Please use the \"Select...\" button to navigate to a real directory.", SourceDirectory.FullName)); return; } ButtomCompute.Visibility = Visibility.Hidden; ButtonSelectDestinationDirectory.Visibility = Visibility.Hidden; ButtonSelectSourceDirectory.Visibility = Visibility.Hidden; TextBoxDestinationDirectory.Visibility = Visibility.Hidden; TextBoxSourceDirectory.Visibility = Visibility.Hidden; ProgressBarZIPRip.Visibility = Visibility.Visible; LabelProgress.Visibility = Visibility.Visible; FileInfo[] ZIPFiles = SourceDirectory.GetFiles("*_fastqc.zip"); string[] FQZDataSplit = null; string rootname; List <string> Summary = new List <string>(); int nFiles = ZIPFiles.Length; for (int i = 0; i < nFiles; i++) { LabelProgress.Content = string.Format("Processing file {0} of {1} ({2:0.0}%)...", i, nFiles, ((double)i / nFiles) * 100); FileInfo FastQCZipFile = ZIPFiles[i]; Summary.Add("Module Name\tStatus\n"); //Extract the stats from their containing file using (ZipArchive FQZip = ZipFile.OpenRead(FastQCZipFile.FullName)) { rootname = FastQCZipFile.Name.Substring(0, FastQCZipFile.Name.Length - 4); ZipArchiveEntry FQZData = FQZip.Entries.Where(n => n.Name == "fastqc_data.txt").First(); //Filenames are without directory FQZDataSplit = new StreamReader(FQZData.Open()).ReadToEnd().Split(new string[] { ">>" }, StringSplitOptions.RemoveEmptyEntries); } //Probably a bad idea but hey it's only ~270KB so lets do this in-memory //File contains _all_ records, encapsulated by >>MODULE NAME\t<pass|fail>\n[...]>>END MODULE, thus, split by '>>' FQZDataSplit = FQZDataSplit.Where(n => (n != "END_MODULE\n")).Skip(1).ToArray(); //now each line represents one dataset, to be written to one file //(first entry is the fast qc version info, and thus skipped) foreach (string FQZDataFile in FQZDataSplit) { string[] FQZSplit = FQZDataFile.Split('\n'); string moduleName = FQZSplit[0]; //first line contains the module name and pass/fail Summary.Add(moduleName); moduleName = rootname + "_" + moduleName.Split('\t')[0] + ".txt"; //Create output file named based on the input file and current module FQZSplit[1] = FQZSplit[1].Replace("#", string.Empty); //correct headers try { FileInfo OutputFile = new FileInfo(System.IO.Path.Combine(DestinationDirectory.FullName, moduleName)); using (StreamWriter OutputFileWriter = new StreamWriter(OutputFile.Create())) { OutputFileWriter.Write(string.Join("\n", FQZSplit.Skip(1))); } //dump stats to file } catch (UnauthorizedAccessException) { System.Windows.MessageBox.Show("The program is unable to gain access to the target directory. Please select a new output directory or re-run the application with elevated privileges."); return; } catch (PathTooLongException) { System.Windows.MessageBox.Show("The program cannot create the output file, as its full path would be longer than the system maximum. Please select a different output folder with a shorter path."); return; } } //repeat data dump for summary try { FileInfo OutputFile = new FileInfo(System.IO.Path.Combine(DestinationDirectory.FullName, (rootname + "_Summary.txt"))); using (StreamWriter OutputFileWriter = new StreamWriter(OutputFile.Create())) { foreach (string s in Summary) { OutputFileWriter.Write(s + "\n"); } } } catch (UnauthorizedAccessException) { System.Windows.MessageBox.Show("The program is unable to gain access to the target directory. Please select a new output directory or re-run the application with elevated privileges."); } catch (PathTooLongException) { System.Windows.MessageBox.Show("The program cannot create the output file, as its full path would be longer than the system maximum. Please select a different output folder with a shorter path."); } //Update GUI - supposed to be a BackgroundWorkerThread... } ButtomCompute.Visibility = Visibility.Visible; ButtonSelectDestinationDirectory.Visibility = Visibility.Visible; ButtonSelectSourceDirectory.Visibility = Visibility.Visible; TextBoxDestinationDirectory.Visibility = Visibility.Visible; TextBoxSourceDirectory.Visibility = Visibility.Visible; ProgressBarZIPRip.Visibility = Visibility.Hidden; LabelProgress.Visibility = Visibility.Hidden; ButtomCompute.IsEnabled = true; ButtonSelectDestinationDirectory.IsEnabled = true; ButtonSelectSourceDirectory.IsEnabled = true; System.Windows.MessageBox.Show("Operation complete. Extracted " + nFiles + " FastQC files into individual .txt files.\nHave a nice day!"); //Done! }
public ZippedFileInfo(ZipArchiveEntry entry) { _entry = entry; }
private string ComputeEntryHash(ZipArchiveEntry entry, S3WriterResourceProperties properties) => $"{GetMD5AsHexString(entry)}-{DetermineEncodingType(entry.FullName, properties)}";
public static bool UnzipMod(this InstallerWindow ins, Stream zs) { string platform = ""; if (ETGFinder.Platform.HasFlag(ETGPlatform.Windows)) { platform = "win32"; } else if (ETGFinder.Platform.HasFlag(ETGPlatform.MacOS)) { platform = "osx"; } else if (ETGFinder.Platform.HasFlag(ETGPlatform.Linux)) { platform = ETGFinder.Platform.HasFlag(ETGPlatform.X64) ? "lib64" : "lib"; } string fallback = "ETGMOD"; string prefix = fallback; if (ETGFinder.Version.Contains("b")) { prefix += "-BETA"; } fallback += "/"; prefix += "/"; string pathGame = ins.MainModDir; ins.Log("Checking for ").Log(prefix).LogLine("..."); using (ZipArchive zip = new ZipArchive(zs, ZipArchiveMode.Read)) { int prefixCount = 0; int fallbackCount = 0; int noneCount = 0; ins.InitProgress("Scanning ZIP", zip.Entries.Count); for (int i = 0; i < zip.Entries.Count; i++) { ins.SetProgress(i); ZipArchiveEntry entry = zip.Entries[i]; ins.Log("Entry: ").Log(entry.FullName).Log(": ").Log(entry.Length.ToString()).LogLine(" bytes"); if (entry.FullName == "InstallerVersion.txt") { ins.LogLine("Found version file."); using (Stream s = entry.Open()) { using (StreamReader sr = new StreamReader(s)) { Version minv = new Version(sr.ReadLine().Trim()); if (InstallerWindow.Version < minv) { ins.LogLine("There's a new ETGMod Installer version!"); ins.LogLine("Visit https://modthegungeon.github.io/#download to download it."); ins.Log("(Minimum installer version for this ETGMod version: ").LogLine(minv.ToString()).Log(")"); ins.Invoke(() => ins.Progress.BrushProgress = new System.Drawing.SolidBrush(System.Drawing.Color.FromArgb(255, 63, 63, 91)) ); ins.InitProgress("Installer update required!", 1).SetProgress(1); return(false); } } } continue; } string entryName = entry.FullName; if (entry.FullName.StartsWith(prefix)) { prefixCount++; } else if (entry.FullName.StartsWith(fallback)) { fallbackCount++; } else { noneCount++; } } if (0 < prefixCount) { ins.Log(prefix).LogLine(" found."); ins.InitProgress("Extracting ZIP", prefixCount); } else if (0 < fallbackCount) { ins.Log("Didn't find ").Log(prefix).Log(", falling back to ").Log(fallback).LogLine("."); prefix = fallback; ins.InitProgress("Extracting ZIP", fallbackCount); } else { ins.LogLine("Is this even a ETGMod ZIP? uh..."); prefix = ""; ins.InitProgress("Extracting ZIP", noneCount); } int extracted = 0; for (int i = 0; i < zip.Entries.Count; i++) { ZipArchiveEntry entry = zip.Entries[i]; if (!entry.FullName.StartsWith(prefix) || entry.FullName == prefix) { continue; } ins.SetProgress(++extracted); string entryName = entry.FullName.Substring(prefix.Length); if (entryName.StartsWith("LIBS/")) { entryName = entryName.Substring(5); if (!entryName.StartsWith(platform + "/")) { continue; } entryName = entryName.Substring(platform.Length + 1); } entryName = entryName.Replace('/', Path.DirectorySeparatorChar); string path = Path.Combine(pathGame, entryName); ins.Log("Extracting: ").Log(entry.FullName).Log(" -> ").LogLine(path); if (entry.Length == 0 && entry.CompressedLength == 0) { Directory.CreateDirectory(path); } else { entry.ExtractToFile(path, true); } } ins.EndProgress("Extracted ZIP."); } return(true); }
public static async Task ReadInterleaved() { using (ZipArchive archive = new ZipArchive(await StreamHelpers.CreateTempCopyStream(ZipTest.zfile("normal.zip")))) { ZipArchiveEntry e1 = archive.GetEntry("first.txt"); ZipArchiveEntry e2 = archive.GetEntry("notempty/second.txt"); //read all of e1 and e2's contents Byte[] e1readnormal = new Byte[e1.Length]; Byte[] e2readnormal = new Byte[e2.Length]; Byte[] e1interleaved = new Byte[e1.Length]; Byte[] e2interleaved = new Byte[e2.Length]; using (Stream e1s = e1.Open()) { ZipTest.ReadBytes(e1s, e1readnormal, e1.Length); } using (Stream e2s = e2.Open()) { ZipTest.ReadBytes(e2s, e2readnormal, e2.Length); } //now read interleaved, assume we are working with < 4gb files const Int32 bytesAtATime = 15; using (Stream e1s = e1.Open(), e2s = e2.Open()) { Int32 e1pos = 0; Int32 e2pos = 0; while (e1pos < e1.Length || e2pos < e2.Length) { if (e1pos < e1.Length) { Int32 e1bytesRead = e1s.Read(e1interleaved, e1pos, bytesAtATime + e1pos > e1.Length ? (Int32)e1.Length - e1pos : bytesAtATime); e1pos += e1bytesRead; } if (e2pos < e2.Length) { Int32 e2bytesRead = e2s.Read(e2interleaved, e2pos, bytesAtATime + e2pos > e2.Length ? (Int32)e2.Length - e2pos : bytesAtATime); e2pos += e2bytesRead; } } } //now compare to original read ZipTest.ArraysEqual <Byte>(e1readnormal, e1interleaved, e1readnormal.Length); ZipTest.ArraysEqual <Byte>(e2readnormal, e2interleaved, e2readnormal.Length); //now read one entry interleaved Byte[] e1selfInterleaved1 = new Byte[e1.Length]; Byte[] e1selfInterleaved2 = new Byte[e2.Length]; using (Stream s1 = e1.Open(), s2 = e1.Open()) { Int32 s1pos = 0; Int32 s2pos = 0; while (s1pos < e1.Length || s2pos < e1.Length) { if (s1pos < e1.Length) { Int32 s1bytesRead = s1.Read(e1interleaved, s1pos, bytesAtATime + s1pos > e1.Length ? (Int32)e1.Length - s1pos : bytesAtATime); s1pos += s1bytesRead; } if (s2pos < e1.Length) { Int32 s2bytesRead = s2.Read(e2interleaved, s2pos, bytesAtATime + s2pos > e1.Length ? (Int32)e1.Length - s2pos : bytesAtATime); s2pos += s2bytesRead; } } } //now compare to original read ZipTest.ArraysEqual <Byte>(e1readnormal, e1selfInterleaved1, e1readnormal.Length); ZipTest.ArraysEqual <Byte>(e1readnormal, e1selfInterleaved2, e1readnormal.Length); } }
private void reloadUI(string root) { currentRoot = root; mods.Clear(); modZips.Clear(); lstRaces.Items.Clear(); lstMods.Items.Clear(); llToxicRagers.Text = tagLines[new Random().Next(tagLines.Count)]; txtPath.Text = root; btnInstall.Text = "select a mod and a map to replace, then click here!"; btnInstall.Enabled = false; string twtFile = Path.Combine(txtPath.Text, "data.twt"); if (File.Exists(twtFile)) { TWT twt = TWT.Load(twtFile); foreach (TWTEntry entry in twt.Contents) { twt.Extract(entry, Path.Combine(txtPath.Text, "data")); } File.Move(twtFile, Path.Combine(txtPath.Text, "data.twat")); } string racesTXT = Path.Combine(txtPath.Text, "data", "races.txt"); if (File.Exists(racesTXT)) { races = RacesTXT.Load(Path.Combine(txtPath.Text, "data", "races.txt")); foreach (RaceDetails race in races.Races) { if (!race.BoundaryRace) { lstRaces.Items.Add(race.Name); } } } string mapModDir = Path.Combine(txtPath.Text, ".mods", "maps"); if (Directory.Exists(mapModDir)) { foreach (string file in Directory.GetFiles(mapModDir, "*.zip")) { using (FileStream fs = new FileStream(file, FileMode.Open)) using (ZipArchive archive = new ZipArchive(fs, ZipArchiveMode.Read)) { if (archive.Entries.Any(f => f.Name.EndsWith(".c2t", StringComparison.InvariantCultureIgnoreCase)) && archive.Entries.Any(f => f.Name == "" && f.FullName.ToLower() == @"data/races/")) { ZipArchiveEntry entry = archive.Entries.First(f => f.Name.EndsWith(".c2t", StringComparison.InvariantCultureIgnoreCase)); using (MemoryStream ms = new MemoryStream()) using (BinaryReader br = new BinaryReader(ms)) { entry.Open().CopyTo(ms); ms.Seek(0, SeekOrigin.Begin); RaceDetails details = RaceDetails.Load(new DocumentParser(br)); int index = lstMods.Items.Add(details.Name); modZips.Add(index, file); mods.Add(details); } } } } } foreach (string file in Directory.GetFiles(txtPath.Text, "*.c2t")) { RaceDetails details = RaceDetails.Load(new DocumentParser(file)); if (!mods.Any(m => m.Name == details.Name)) { lstMods.Items.Add(details.Name); mods.Add(details); } } }
public static void IsZipSameAsDir(Stream archiveFile, String directory, ZipArchiveMode mode, Boolean dontRequireExplicit, Boolean dontCheckTimes) { int count = 0; using (ZipArchive archive = new ZipArchive(archiveFile, mode)) { var allFilesInDir = FileData.InPath(directory); foreach (var file in allFilesInDir) { count++; String entryName = file.FullName; if (file.IsFolder) { entryName += Path.DirectorySeparatorChar; } ZipArchiveEntry entry = archive.GetEntry(entryName); if (entry == null) { entryName = FlipSlashes(entryName); entry = archive.GetEntry(entryName); } if (file.IsFile) { try { Assert.NotNull(entry); } catch (Exception) { Console.WriteLine("File Entry {0} in directory but not archive: {1}", entryName, file.FullName); throw; } Int64 givenLength = entry.Length; var buffer = new byte[entry.Length]; using (Stream entrystream = entry.Open()) { entrystream.Read(buffer, 0, buffer.Length); String crc = CRC.CalculateCRC(buffer); Assert.Equal(file.Length, givenLength); Assert.Equal(file.CRC, crc); } if (!dontCheckTimes) { Double offBy = (file.LastModifiedDate - entry.LastWriteTime.DateTime).TotalSeconds; Assert.True( (offBy >= -2 && offBy <= 2) || // Temporary adjustment for active issue 1326 ((offBy >= 3598 && offBy <= 3602)), String.Format("{0}, {1}, {2}", file.LastModifiedDate.ToString(), entry.LastWriteTime.DateTime.ToString(), file.FullName)); } Assert.Equal(file.Name, entry.Name); Assert.Equal(entryName, entry.FullName); Assert.Equal(entryName, entry.ToString()); Assert.Equal(archive, entry.Archive); } else if (file.IsFolder) { if (entry == null) //entry not found { string entryNameOtherSlash = FlipSlashes(entryName); Boolean isEmtpy = !allFilesInDir.Any( f => f.IsFile && (f.FullName.StartsWith(entryName, StringComparison.OrdinalIgnoreCase) || f.FullName.StartsWith(entryNameOtherSlash, StringComparison.OrdinalIgnoreCase))); if ((!dontRequireExplicit || isEmtpy) && !entryName.Contains("emptydir")) { Assert.True(false, String.Format("Folder Entry {0} in directory but not archive: {1}", entryName, directory)); } if ((dontRequireExplicit && !isEmtpy) || entryName.Contains("emptydir")) { count--; //discount this entry } } else { using (Stream es = entry.Open()) { try { Assert.True(es.Length == 0, "Length should be 0"); } catch (NotSupportedException) { try { Assert.Equal(-1, es.ReadByte()); } catch (Exception) { Console.WriteLine("Didn't return EOF"); throw; } } } } } } Assert.Equal(count, archive.Entries.Count); } }
private async Task <Etag> ExportFiles(ZipArchive archive, Etag lastEtag, Etag maxEtag) { var totalCount = 0; var lastReport = SystemTime.UtcNow; var reportInterval = TimeSpan.FromSeconds(2); Operations.ShowProgress("Exporting Files"); var metadataList = new List <FileContainer>(); Exception exceptionHappened = null; try { while (true) { bool hasDocs = false; using (var files = await Operations.GetFiles(lastEtag, Options.BatchSize)) { while (await files.MoveNextAsync()) { hasDocs = true; var file = files.Current; if (file.IsTombstone) { lastEtag = file.Etag; continue; } var tempLastEtag = file.Etag; if (maxEtag != null && tempLastEtag.CompareTo(maxEtag) > 0) { break; } // Write the metadata (which includes the stream size and file container name) var fileContainer = new FileContainer { Key = Path.Combine(file.Directory.TrimStart('/'), file.Name), Metadata = file.Metadata, }; ZipArchiveEntry fileToStore = archive.CreateEntry(fileContainer.Key); using (var fileStream = await Operations.DownloadFile(file)) using (var zipStream = fileToStore.Open()) { await fileStream.CopyToAsync(zipStream).ConfigureAwait(false); } metadataList.Add(fileContainer); lastEtag = tempLastEtag; totalCount++; if (totalCount % 1000 == 0 || SystemTime.UtcNow - lastReport > reportInterval) { //TODO: Show also the MB/sec and total GB exported. Operations.ShowProgress("Exported {0} files. ", totalCount); lastReport = SystemTime.UtcNow; } } } if (!hasDocs) { break; } } } catch (Exception e) { Operations.ShowProgress("Got Exception during smuggler export. Exception: {0}. ", e.Message); Operations.ShowProgress("Done with reading files, total: {0}, lastEtag: {1}", totalCount, lastEtag); exceptionHappened = new SmugglerExportException(e.Message, e) { LastEtag = lastEtag, }; } var metadataEntry = archive.CreateEntry(MetadataEntry); using (var metadataStream = metadataEntry.Open()) using (var writer = new StreamWriter(metadataStream)) { foreach (var item in metadataList) { writer.WriteLine(RavenJObject.FromObject(item)); } } if (exceptionHappened != null) { throw exceptionHappened; } Operations.ShowProgress("Done with reading documents, total: {0}, lastEtag: {1}", totalCount, lastEtag); return(lastEtag); }
/// <summary> /// Processes input queue /// </summary> /// <returns> /// Task object for continuation /// </returns> private async Task ProcessInputQueue() { using (_httpClientHelper = new HttpClientHelper(_settings)) { var fileCount = 0; string fileNameInPackageTemplate = ""; FileStream zipToOpen = null; ZipArchive archive = null; if (_settings.InputFilesArePackages == false) { fileNameInPackageTemplate = GetFileNameInPackageTemplate(); if (string.IsNullOrEmpty(fileNameInPackageTemplate)) { throw new JobExecutionException(string.Format(Resources.Job_0_Please_check_your_package_template_Input_file_name_in_Manifest_cannot_be_identified, _context.JobDetail.Key)); } } while (InputQueue.TryDequeue(out DataMessage dataMessage)) { try { if (fileCount > 0 && _settings.DelayBetweenFiles > 0) //Only delay after first file and never after last. { System.Threading.Thread.Sleep(TimeSpan.FromSeconds(_settings.DelayBetweenFiles)); } fileCount++; var sourceStream = _retryPolicyForIo.Execute(() => FileOperationsHelper.Read(dataMessage.FullPath)); if (sourceStream == null) { continue; //Nothing to do here } string tempFileName = ""; //If we need to "wrap" file in package envelope if (_settings.InputFilesArePackages == false) { using (zipToOpen = new FileStream(_settings.PackageTemplate, FileMode.Open)) { tempFileName = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()); _retryPolicyForIo.Execute(() => FileOperationsHelper.Create(zipToOpen, tempFileName)); var tempZipStream = _retryPolicyForIo.Execute(() => FileOperationsHelper.Read(tempFileName)); using (archive = new ZipArchive(tempZipStream, ZipArchiveMode.Update)) { //Check if package template contains input file and remove it first. It should not be there in the first place. ZipArchiveEntry entry = archive.GetEntry(fileNameInPackageTemplate); if (entry != null) { entry.Delete(); Log.WarnFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Package_template_contains_input_file_1_Please_remove_it_from_the_template, _context.JobDetail.Key, fileNameInPackageTemplate)); } // Update Manifest file with the original file name for end-to-end traceability. Use the new file name in the rest of the method. fileNameInPackageTemplate = UpdateManifestFile(archive, dataMessage, fileNameInPackageTemplate); var importedFile = archive.CreateEntry(fileNameInPackageTemplate, CompressionLevel.Fastest); using var entryStream = importedFile.Open(); sourceStream.CopyTo(entryStream); sourceStream.Close(); sourceStream.Dispose(); } sourceStream = _retryPolicyForIo.Execute(() => FileOperationsHelper.Read(tempFileName)); } } if (Log.IsDebugEnabled) { Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Uploading_file_1_File_size_2_bytes, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}"), sourceStream.Length)); } // Get blob url and id. Returns in json format var response = await _httpClientHelper.GetAzureWriteUrl(); if (!response.IsSuccessStatusCode) { throw new JobExecutionException($"Job: {_settings.JobKey}. Request GetAzureWriteUrl failed."); } var blobInfo = (JObject)JsonConvert.DeserializeObject(HttpClientHelper.ReadResponseString(response)); var blobUrl = blobInfo["BlobUrl"].ToString(); var blobUri = new Uri(blobUrl); //Upload package to blob storage var uploadResponse = await _httpClientHelper.UploadContentsToBlob(blobUri, sourceStream); if (sourceStream != null) { sourceStream.Close(); sourceStream.Dispose(); if (!_settings.InputFilesArePackages)//if we wraped file in package envelop we need to delete temp file { _retryPolicyForIo.Execute(() => FileOperationsHelper.Delete(tempFileName)); } } if (uploadResponse.IsSuccessStatusCode) { //Now send import request var targetLegalEntity = _settings.Company; if (_settings.MultiCompanyImport && _settings.GetLegalEntityFromSubfolder) { targetLegalEntity = new FileInfo(dataMessage.FullPath).Directory.Name; } if (_settings.MultiCompanyImport && _settings.GetLegalEntityFromFilename) { String[] separator = { _settings.FilenameSeparator }; var tokenList = dataMessage.Name.Split(separator, 10, StringSplitOptions.RemoveEmptyEntries); targetLegalEntity = tokenList[_settings.LegalEntityTokenPosition - 1]; } if (targetLegalEntity.Length > 4) { Log.ErrorFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Target_legal_entity_is_not_valid_1, _context.JobDetail.Key, targetLegalEntity)); } if (string.IsNullOrEmpty(targetLegalEntity)) { throw new Exception(string.Format(Resources.Job_0_Unable_to_get_target_legal_entity_name, _context.JobDetail.Key)); } var executionIdGenerated = CreateExecutionId(_settings.DataProject); var importResponse = await _httpClientHelper.ImportFromPackage(blobUri.AbsoluteUri, _settings.DataProject, executionIdGenerated, _settings.ExecuteImport, _settings.OverwriteDataProject, targetLegalEntity); if (importResponse.IsSuccessStatusCode) { var result = importResponse.Content.ReadAsStringAsync().Result; var jsonResponse = (JObject)JsonConvert.DeserializeObject(result); string executionId = jsonResponse["value"].ToString(); var targetDataMessage = new DataMessage(dataMessage) { MessageId = executionId, FullPath = dataMessage.FullPath.Replace(_settings.InputDir, _settings.UploadSuccessDir), MessageStatus = MessageStatus.Enqueued }; // Move to inprocess/success location _retryPolicyForIo.Execute(() => FileOperationsHelper.Move(dataMessage.FullPath, targetDataMessage.FullPath)); if (_settings.ExecutionJobPresent) { _retryPolicyForIo.Execute(() => FileOperationsHelper.WriteStatusFile(targetDataMessage, _settings.StatusFileExtension)); } if (Log.IsDebugEnabled) { Log.DebugFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_File_1_uploaded_successfully, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}"))); } } else { // import request failed. Move message to error location. Log.ErrorFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Upload_failed_for_file_1_Failure_response_Status_2_Reason_3, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}"), importResponse.StatusCode, importResponse.ReasonPhrase, $"{Environment.NewLine}packageUrl: {blobUri.AbsoluteUri}{Environment.NewLine}definitionGroupId: {_settings.DataProject}{Environment.NewLine}executionId: {executionIdGenerated}{Environment.NewLine}execute: {_settings.ExecuteImport}{Environment.NewLine}overwrite: {_settings.OverwriteDataProject}{Environment.NewLine}legalEntityId: {targetLegalEntity}")); var targetDataMessage = new DataMessage(dataMessage) { FullPath = dataMessage.FullPath.Replace(_settings.InputDir, _settings.UploadErrorsDir), MessageStatus = MessageStatus.Failed }; // Move data to error location _retryPolicyForIo.Execute(() => FileOperationsHelper.Move(dataMessage.FullPath, targetDataMessage.FullPath)); // Save the log with import failure details _retryPolicyForIo.Execute(() => FileOperationsHelper.WriteStatusLogFile(targetDataMessage, importResponse, _settings.StatusFileExtension)); } } else { // upload failed. Move message to error location. Log.ErrorFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Upload_failed_for_file_1_Failure_response_Status_2_Reason_3, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}"), uploadResponse.StatusCode, uploadResponse.ReasonPhrase)); var targetDataMessage = new DataMessage(dataMessage) { FullPath = dataMessage.FullPath.Replace(_settings.InputDir, _settings.UploadErrorsDir), MessageStatus = MessageStatus.Failed }; // Move data to error location _retryPolicyForIo.Execute(() => FileOperationsHelper.Move(dataMessage.FullPath, targetDataMessage.FullPath)); // Save the log with import failure details _retryPolicyForIo.Execute(() => FileOperationsHelper.WriteStatusLogFile(targetDataMessage, uploadResponse, _settings.StatusFileExtension)); } } catch (Exception ex) { Log.ErrorFormat(CultureInfo.InvariantCulture, string.Format(Resources.Job_0_Failure_processing_file_1_Exception_2, _context.JobDetail.Key, dataMessage.FullPath.Replace(@"{", @"{{").Replace(@"}", @"}}"), ex.Message), ex); throw; } finally { if (zipToOpen != null) { zipToOpen.Close(); zipToOpen.Dispose(); } archive?.Dispose(); } } } }
private static XDocument XDocumentFromZipArchiveEntry(ZipArchiveEntry entry) { using (var reportStream = entry.Open()) return(XDocument.Load(reportStream)); }
public string DestinationFile(ZipArchiveEntry entry) { string dest_file = Path.ChangeExtension(entry.Name, ".txt"); return(dest_file); }
private void Button_Click_2(object sender, RoutedEventArgs e) { //Считывает полный путь к файлу Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog(); dialog.Filter = "Text documents (*.txt)|*.txt|All files (*.*)|*.*"; dialog.FilterIndex = 2; Nullable <bool> result = dialog.ShowDialog(); if (result == true) { // Open document filename = dialog.FileName; //TextBlock textBlock = new TextBlock(); filePath = System.IO.Path.GetDirectoryName(filename); textBlock.Text = filename; } string infoFile = ""; for (int i = filePath.Length + 1; i < filename.Length; i++) { infoFile += filename[i]; } //string sz = System.IO.File.ReadAllText(filePath + "\\" + "size.txt"); /*var indxx = sz.IndexOf('@'); * var indxx2 = sz.IndexOf('?'); * string btSz = ""; * string nbOfByte = ""; * string extension = ""; * for (int i = 0; i < indxx; i++) * { * btSz += sz[i]; * } * * for (int i = indxx + 1; i < indxx2; i++) * { * nbOfByte += sz[i]; * } * * * for (int i = indxx2 + 1; i < sz.Length; i++) * { * extension += sz[i]; * }*/ string btSz = File.ReadLines(filePath + "\\" + infoFile).Skip(0).First(); string nbOfByte = File.ReadLines(filePath + "\\" + infoFile).Skip(1).First(); string extension = File.ReadLines(filePath + "\\" + infoFile).Skip(2).First(); string flname = File.ReadLines(filePath + "\\" + infoFile).Skip(3).First(); string[] allFoundFiles = Directory.GetFiles(filePath, "*@*.zip", SearchOption.AllDirectories); long count = 0; int size = Convert.ToInt32(btSz); int bytesCount = Convert.ToInt32(nbOfByte); byte[] byteArray = new byte[size]; int[,] array = new int[allFoundFiles.Length, 2]; string tm = ""; for (int i = 0; i < allFoundFiles.Length; i++) { var a = allFoundFiles[i]; var fInd = a.IndexOf('@'); tm = ""; for (int j = fInd + 1; j < a.Length - extension.Length; j++) { tm += a[j]; } array[i, 0] = Convert.ToInt32(tm); array[i, 1] = i; } for (int i = 0; i < allFoundFiles.Length; i++) { for (int j = 0; j < allFoundFiles.Length - 1; j++) { if (array[j, 0] > array[j + 1, 0]) { int z = array[j, 0]; int y = array[j, 1]; array[j, 0] = array[j + 1, 0]; array[j, 1] = array[j + 1, 1]; array[j + 1, 0] = z; array[j + 1, 1] = y; } } } int[] indexOfFiles = new int[allFoundFiles.Length]; for (int i = 0; i < allFoundFiles.Length; i++) { indexOfFiles[i] = array[i, 1]; } // int iteratCount = 0; for (int i = 0; i < allFoundFiles.Length; i++) { using (FileStream zipToOpen = new FileStream(allFoundFiles[indexOfFiles[i]], FileMode.Open)) { using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update)) { ZipArchiveEntry readmeEntry = archive.GetEntry(i + extension); using (StreamWriter writer = new StreamWriter(readmeEntry.Open())) { var _byte_counter = bytesCount; while (_byte_counter > 0 && count < size) { _byte_counter--; byteArray[count] = (byte)writer.BaseStream.ReadByte(); count++; } } } } } using (FileStream zipToOpen = new FileStream(filePath + "\\" + flname + ".zip", FileMode.OpenOrCreate)) { using (ZipArchive zip = new ZipArchive(zipToOpen, ZipArchiveMode.Update)) { ZipArchiveEntry readmeEntry = zip.CreateEntry(flname + extension); using (StreamWriter writer = new StreamWriter(readmeEntry.Open())) { foreach (var item in byteArray) { writer.BaseStream.WriteByte(item); progressBar.Value++; } } } } }
public ZipArchiveProblems Validate(ZipArchiveEntry entry, IDbaseRecordEnumerator <RoadSegmentWidthChangeDbaseRecord> records) { if (entry == null) { throw new ArgumentNullException(nameof(entry)); } if (records == null) { throw new ArgumentNullException(nameof(records)); } var problems = ZipArchiveProblems.None; try { var identifiers = new Dictionary <AttributeId, RecordNumber>(); var moved = records.MoveNext(); if (moved) { while (moved) { var recordContext = entry.AtDbaseRecord(records.CurrentRecordNumber); var record = records.Current; if (record != null) { if (!record.RECORDTYPE.HasValue) { problems += recordContext.RequiredFieldIsNull(record.RECORDTYPE.Field); } else { if (!RecordType.ByIdentifier.ContainsKey(record.RECORDTYPE.Value)) { problems += recordContext.RecordTypeMismatch(record.RECORDTYPE.Value); } } if (record.WB_OIDN.HasValue) { if (record.WB_OIDN.Value == 0) { problems += recordContext.IdentifierZero(); } else { var identifier = new AttributeId(record.WB_OIDN.Value); if (identifiers.TryGetValue(identifier, out var takenByRecordNumber)) { problems += recordContext.IdentifierNotUnique( identifier, takenByRecordNumber ); } else { identifiers.Add(identifier, records.CurrentRecordNumber); } } } else { problems += recordContext.RequiredFieldIsNull(record.WB_OIDN.Field); } if (!record.BREEDTE.HasValue) { problems += recordContext.RequiredFieldIsNull(record.BREEDTE.Field); } else if (!RoadSegmentWidth.Accepts(record.BREEDTE.Value)) { problems += recordContext.WidthOutOfRange(record.BREEDTE.Value); } if (!record.VANPOSITIE.HasValue) { problems += recordContext.RequiredFieldIsNull(record.VANPOSITIE.Field); } else if (!RoadSegmentPosition.Accepts(record.VANPOSITIE.Value)) { problems += recordContext.FromPositionOutOfRange(record.VANPOSITIE.Value); } if (!record.TOTPOSITIE.HasValue) { problems += recordContext.RequiredFieldIsNull(record.TOTPOSITIE.Field); } else if (!RoadSegmentPosition.Accepts(record.TOTPOSITIE.Value)) { problems += recordContext.ToPositionOutOfRange(record.TOTPOSITIE.Value); } if (!record.WS_OIDN.HasValue) { problems += recordContext.RequiredFieldIsNull(record.WS_OIDN.Field); } else if (!RoadSegmentId.Accepts(record.WS_OIDN.Value)) { problems += recordContext.RoadSegmentIdOutOfRange(record.WS_OIDN.Value); } } moved = records.MoveNext(); } } else { problems += entry.HasNoDbaseRecords(false); } } catch (Exception exception) { problems += entry.AtDbaseRecord(records.CurrentRecordNumber).HasDbaseRecordFormatError(exception); } return(problems); }
private void Button_Click_1(object sender, RoutedEventArgs e) { if (fileIsChecked) { progressBar.Value = 0; int SIZE = Convert.ToInt32(textBlock2.Text); filename = textBlock.Text; // Определяет единицу информации // По-умолчанию - 1Мб if (textBlock2.Text == null) { SIZE = 1024; } if (cbx.SelectedItem.ToString() == "байт") { SIZE *= 1; } else if (cbx.SelectedItem.ToString() == "кБ") { SIZE *= 1024; } else if (cbx.SelectedItem.ToString() == "мБ") { SIZE *= 1048576; } MAX = SIZE; byte[] bt = File.ReadAllBytes(filename); // Нахождения индекса элемента с которого начинается расширение int indxx = 0; for (int i = 0; i < filename.Length; i++) { if (filename[i] == '.') { indxx = i; } } string extension = ""; for (int i = indxx; i < filename.Length; i++) { extension += filename[i]; } //string extension = filename.Substring(filename.Length - 5); // Определяет количество архивов int count = (bt.Length + SIZE - 1) / SIZE; int cnt = 0; // Имя файла string flname = ""; for (int i = filePath.Length + 1; i < filename.Length - extension.Length; i++) { flname += filename[i]; } // Создание архивов for (int i = 0; i < count; i++) { using (FileStream zipToOpen = new FileStream(filePath + "\\" + flname + "@" + i + ".zip", FileMode.OpenOrCreate)) { using (ZipArchive zip = new ZipArchive(zipToOpen, ZipArchiveMode.Update)) { ZipArchiveEntry readmeEntry = zip.CreateEntry(i + extension); using (StreamWriter writer = new StreamWriter(readmeEntry.Open())) { long _byte_counter = SIZE; while (_byte_counter > 0 && cnt < bt.Length) { _byte_counter--; writer.BaseStream.WriteByte(bt[cnt]); progressBar.Value++; cnt++; } } } } } System.IO.File.WriteAllText(filePath + "\\" + flname + "_Info.txt", bt.Length.ToString() + "\r\n" + SIZE + "\r\n" + extension + "\r\n" + flname); } }
public void InvalidFiles() { Assert.Throws <InvalidDataException>(() => ZipFile.OpenRead(bad("EOCDmissing.zip"))); using (TempFile testArchive = CreateTempCopyFile(bad("EOCDmissing.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } Assert.Throws <InvalidDataException>(() => ZipFile.OpenRead(bad("CDoffsetOutOfBounds.zip"))); using (TempFile testArchive = CreateTempCopyFile(bad("CDoffsetOutOfBounds.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } using (ZipArchive archive = ZipFile.OpenRead(bad("CDoffsetInBoundsWrong.zip"))) { Assert.Throws <InvalidDataException>(() => { var x = archive.Entries; }); } using (TempFile testArchive = CreateTempCopyFile(bad("CDoffsetInBoundsWrong.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } using (ZipArchive archive = ZipFile.OpenRead(bad("numberOfEntriesDifferent.zip"))) { Assert.Throws <InvalidDataException>(() => { var x = archive.Entries; }); } using (TempFile testArchive = CreateTempCopyFile(bad("numberOfEntriesDifferent.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } //read mode on empty file using (var memoryStream = new MemoryStream()) { Assert.Throws <InvalidDataException>(() => new ZipArchive(memoryStream)); } //offset out of bounds using (ZipArchive archive = ZipFile.OpenRead(bad("localFileOffsetOutOfBounds.zip"))) { ZipArchiveEntry e = archive.Entries[0]; Assert.Throws <InvalidDataException>(() => e.Open()); } using (TempFile testArchive = CreateTempCopyFile(bad("localFileOffsetOutOfBounds.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } //compressed data offset + compressed size out of bounds using (ZipArchive archive = ZipFile.OpenRead(bad("compressedSizeOutOfBounds.zip"))) { ZipArchiveEntry e = archive.Entries[0]; Assert.Throws <InvalidDataException>(() => e.Open()); } using (TempFile testArchive = CreateTempCopyFile(bad("compressedSizeOutOfBounds.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } //signature wrong using (ZipArchive archive = ZipFile.OpenRead(bad("localFileHeaderSignatureWrong.zip"))) { ZipArchiveEntry e = archive.Entries[0]; Assert.Throws <InvalidDataException>(() => e.Open()); } using (TempFile testArchive = CreateTempCopyFile(bad("localFileHeaderSignatureWrong.zip"), GetTestFilePath())) { Assert.Throws <InvalidDataException>(() => ZipFile.Open(testArchive.Path, ZipArchiveMode.Update)); } }
private void encryptButton_Click(object sender, EventArgs e) { if (MessageBox.Show("Remember:\n" + "With Folder(s), Encryption Feature MUST compress it before encrypting.\n\n" + "Do you want to continue?", "Encrypt", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) { return; } Account receiver = (Account)this.accountListBox.SelectedItem; List <string> successList = new List <string>(); List <string> failureList = new List <string>(); int mode = 0; mode += (this.compressCheckBox.Checked) ? 1 : 0; mode += (this.compressOneFileCheckBox.Checked) ? 1 : 0; EventHandler encryptEvent = null; switch (mode) { case 0: encryptEvent = new EventHandler(delegate(object o, EventArgs a) { TreeNode node = (TreeNode)o; string path = node.FullPath; try { if (File.Exists(path + ".enc")) { throw new Exception("Cannot encrypt because ENC file already exists."); } byte[] zipData = null; if (node.BackColor == Color.Yellow) { using (MemoryStream memStream = new MemoryStream()) { using (ZipArchive archive = new ZipArchive(memStream, ZipArchiveMode.Create)) compressDirectory(path, Path.GetDirectoryName(path).Length + 1, archive); zipData = memStream.ToArray(); } } else { zipData = File.ReadAllBytes(path); } byte[] data = new byte[zipData.Length + 33]; data[0] = (byte)((node.BackColor == Color.Yellow) ? 1 : 0); Buffer.BlockCopy(SHA256.Create().ComputeHash(zipData), 0, data, 1, 32); Buffer.BlockCopy(zipData, 0, data, 33, zipData.Length); File.WriteAllBytes(path + ".enc", DataEncryption.encrypt(receiver.getPublicKey(), data)); successList.Add(path); node.Parent.Nodes.Add(node.Text + ".enc"); } catch (Exception ex) { Console.WriteLine(ex.ToString()); failureList.Add(path); } }); doCheckedNodes(this.filesDirectoriesTreeView.Nodes, encryptEvent); break; case 1: encryptEvent = new EventHandler(delegate(object o, EventArgs a) { TreeNode node = (TreeNode)o; string path = node.FullPath; try { if (File.Exists(path + ".enc")) { throw new Exception("Cannot encrypt because ENC file already exists."); } byte[] zipData = null; if (node.BackColor == Color.Yellow) { using (MemoryStream memStream = new MemoryStream()) { using (ZipArchive archive = new ZipArchive(memStream, ZipArchiveMode.Create)) compressDirectory(path, Path.GetDirectoryName(path).Length + 1, archive); zipData = memStream.ToArray(); } } else { using (MemoryStream memStream = new MemoryStream()) { using (ZipArchive archive = new ZipArchive(memStream, ZipArchiveMode.Create)) { ZipArchiveEntry entry = archive.CreateEntry(Path.GetFileName(path)); using (BinaryWriter writer = new BinaryWriter(entry.Open())) writer.Write(File.ReadAllBytes(path)); } zipData = memStream.ToArray(); } } byte[] data = new byte[zipData.Length + 33]; data[0] = 1; Buffer.BlockCopy(SHA256.Create().ComputeHash(zipData), 0, data, 1, 32); Buffer.BlockCopy(zipData, 0, data, 33, zipData.Length); File.WriteAllBytes(path + ".enc", DataEncryption.encrypt(receiver.getPublicKey(), data)); successList.Add(path); node.Parent.Nodes.Add(node.Text + ".enc"); } catch (Exception ex) { Console.WriteLine(ex.ToString()); failureList.Add(path); } }); doCheckedNodes(this.filesDirectoriesTreeView.Nodes, encryptEvent); break; case 2: try { DirectoryInfo root = new DirectoryInfo(this.pathTextBox.Text); if (File.Exists(root.FullName + "\\" + root.Name + ".enc")) { throw new Exception("Cannot encrypt because ENC file already exists."); } byte[] zipData = null; using (MemoryStream memStream = new MemoryStream()) { using (ZipArchive archive = new ZipArchive(memStream, ZipArchiveMode.Create)) { encryptEvent = new EventHandler(delegate(object o, EventArgs a) { TreeNode node = (TreeNode)o; string path = node.FullPath; if (node.BackColor == Color.Yellow) { compressDirectory(path, Path.GetDirectoryName(path).Length + 1, archive); } else { ZipArchiveEntry entry = archive.CreateEntry(Path.GetFileName(path)); using (BinaryWriter writer = new BinaryWriter(entry.Open())) writer.Write(File.ReadAllBytes(path)); } }); doCheckedNodes(this.filesDirectoriesTreeView.Nodes, encryptEvent); } zipData = memStream.ToArray(); } byte[] data = new byte[zipData.Length + 33]; data[0] = 1; Buffer.BlockCopy(SHA256.Create().ComputeHash(zipData), 0, data, 1, 32); Buffer.BlockCopy(zipData, 0, data, 33, zipData.Length); File.WriteAllBytes(root.FullName + "\\" + root.Name + ".enc", DataEncryption.encrypt(receiver.getPublicKey(), data)); this.filesDirectoriesTreeView.Nodes[0].Nodes.Add(root.Name + ".enc"); MessageBox.Show("Encrypt Success", "Encrypt", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch (Exception ex) { MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } return; default: MessageBox.Show("Encrypt Failure", "Encrypt Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } string success = "Success: " + successList.Count.ToString() + " file(s) or folder(s)\n"; foreach (string s in successList) { success += s + "\n"; } string failure = "Failure: " + failureList.Count.ToString() + " file(s) or folder(s)\n"; foreach (string s in failureList) { failure += s + "\n"; } MessageBox.Show("Result:\n\n" + success + "\n" + failure, "Encrypt", MessageBoxButtons.OK, MessageBoxIcon.Information); }
/*************************************************** 4.3.16 End of central directory record: end of central dir signature 4 bytes (0x06054b50) number of this disk 2 bytes number of the disk with the start of the central directory 2 bytes total number of entries in the central directory on this disk 2 bytes total number of entries in the central directory 2 bytes size of the central directory 4 bytes offset of start of central directory with respect to the starting disk number 4 bytes .ZIP file comment length 2 bytes .ZIP file comment (variable size) */ /*************************************************** File header: central file header signature 4 bytes (0x02014b50) version made by 2 bytes version needed to extract 2 bytes general purpose bit flag 2 bytes compression method 2 bytes last mod file time 2 bytes last mod file date 2 bytes crc-32 4 bytes compressed size 4 bytes uncompressed size 4 bytes file name length 2 bytes extra field length 2 bytes file comment length 2 bytes disk number start 2 bytes internal file attributes 2 bytes external file attributes 4 bytes relative offset of local header 4 bytes file name (variable size) extra field (variable size) file comment (variable size) */ private List<ZipArchiveEntry> InflateDirectory() { _fileEntries = new List<ZipArchiveEntry>(); BinaryReader reader = new BinaryReader(ZipStream); reader.BaseStream.Seek(-4, SeekOrigin.End); // skip back while (reader.ReadInt32() != END_CENTRAL_DIR_SIG) { reader.BaseStream.Seek(-5, SeekOrigin.Current); } // skip over number of this disk, number of the disk with dir start, total number of entries on this disk reader.BaseStream.Seek(6, SeekOrigin.Current); short entryCount = reader.ReadInt16(); int directorySize = reader.ReadInt32(); int directoryStart = reader.ReadInt32(); reader.BaseStream.Seek(directoryStart, SeekOrigin.Begin); bool doRebuild = false; for (int i = 0; i < entryCount; i++) { if (reader.ReadInt32() == CENTRAL_FILE_HDR_SIG) { ZipArchiveEntry zipEntry = new ZipArchiveEntry(); reader.BaseStream.Seek(4, SeekOrigin.Current); short flags = reader.ReadInt16(); // read general purpose bit flag if ((flags & 8) > 0) //Silverlight doesn't like this format. We'll "fix it" further below { doRebuild = true; } // skip: compression method, last mod file time, last mod file date reader.BaseStream.Seek(6, SeekOrigin.Current); zipEntry.CRC32 = reader.ReadInt32(); zipEntry.CompressedLength = reader.ReadInt32(); zipEntry.Length = reader.ReadInt32(); short fileNameLength = reader.ReadInt16(); short extraFieldLength = reader.ReadInt16(); short fileCommentLength = reader.ReadInt16(); // skip disk number start, internal file attr, ext file attr reader.BaseStream.Seek(8, SeekOrigin.Current); zipEntry.FileStart = reader.ReadInt32(); zipEntry.Filename = new string(reader.ReadChars(fileNameLength)); _fileEntries.Add(zipEntry); reader.BaseStream.Seek(extraFieldLength + fileCommentLength, SeekOrigin.Current); } } if (doRebuild) { // if file size is reported after the compressed data the filestream is unsupported by silverlight MemoryStream newZipStream = new MemoryStream(); BinaryWriter writer = new BinaryWriter(newZipStream); RebuildEntries(ref reader, ref writer); // rewind reader.BaseStream.Seek(directoryStart, SeekOrigin.Begin); //Rebuild directory RebuildDirectory(ref reader, ref writer); writer.Write(reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position))); ZipStream = newZipStream; //Swap to use our newly cleaned stream } return _fileEntries; }
public CookBookFile(string file) { this.Extension = GetFileExtension(); this.FullName = Path.GetFileName(file); this.Source = null; }