Esempio n. 1
0
        /// <summary>
        /// Attempt to extract a stream from an archive
        /// </summary>
        /// <param name="entryName">Name of the entry to be extracted</param>
        /// <param name="realEntry">Output representing the entry name that was found</param>
        /// <returns>MemoryStream representing the entry, null on error</returns>
        public override (MemoryStream, string) CopyToStream(string entryName)
        {
            MemoryStream ms        = new MemoryStream();
            string       realEntry = null;

            try
            {
                SharpCompress.Archives.SevenZip.SevenZipArchive sza = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(_filename, new ReaderOptions {
                    LeaveStreamOpen = false,
                });
                foreach (SevenZipArchiveEntry entry in sza.Entries)
                {
                    if (entry != null && !entry.IsDirectory && entry.Key.Contains(entryName))
                    {
                        // Write the file out
                        realEntry = entry.Key;
                        entry.WriteTo(ms);
                        break;
                    }
                }
                sza.Dispose();
            }
            catch (Exception ex)
            {
                Globals.Logger.Error(ex.ToString());
                ms        = null;
                realEntry = null;
            }

            return(ms, realEntry);
        }
Esempio n. 2
0
        /// <summary>
        /// Generate a list of DatItem objects from the header values in an archive
        /// </summary>
        /// <param name="omitFromScan">Hash representing the hashes that should be skipped</param>
        /// <param name="date">True if entry dates should be included, false otherwise (default)</param>
        /// <returns>List of DatItem objects representing the found data</returns>
        /// <remarks>TODO: All instances of Hash.DeepHashes should be made into 0x0 eventually</remarks>
        public override List <BaseFile> GetChildren(Hash omitFromScan = Hash.DeepHashes, bool date = false)
        {
            List <BaseFile> found    = new List <BaseFile>();
            string          gamename = Path.GetFileNameWithoutExtension(_filename);

            try
            {
                SharpCompress.Archives.SevenZip.SevenZipArchive sza = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(Utilities.TryOpenRead(_filename));
                foreach (SevenZipArchiveEntry entry in sza.Entries.Where(e => e != null && !e.IsDirectory))
                {
                    // If secure hashes are disabled, do a quickscan
                    if (omitFromScan == Hash.SecureHashes)
                    {
                        found.Add(new BaseFile
                        {
                            Filename = entry.Key,
                            Size     = entry.Size,
                            CRC      = BitConverter.GetBytes(entry.Crc),
                            Date     = (date && entry.LastModifiedTime != null ? entry.LastModifiedTime?.ToString("yyyy/MM/dd hh:mm:ss") : null),

                            Parent = gamename,
                        });
                    }
                    // Otherwise, use the stream directly
                    else
                    {
                        Stream   entryStream      = entry.OpenEntryStream();
                        BaseFile sevenZipEntryRom = Utilities.GetStreamInfo(entryStream, entry.Size, omitFromScan: omitFromScan);
                        sevenZipEntryRom.Filename = entry.Key;
                        sevenZipEntryRom.Parent   = gamename;
                        sevenZipEntryRom.Date     = (date && entry.LastModifiedTime != null ? entry.LastModifiedTime?.ToString("yyyy/MM/dd hh:mm:ss") : null);
                        found.Add(sevenZipEntryRom);
                        entryStream.Dispose();
                    }
                }

                // Dispose of the archive
                sza.Dispose();
            }
            catch (Exception ex)
            {
                Globals.Logger.Error(ex.ToString());
                return(null);
            }

            return(found);
        }
Esempio n. 3
0
        /// <summary>
        /// Attempt to extract a file as an archive
        /// </summary>
        /// <param name="outDir">Output directory for archive extraction</param>
        /// <returns>True if the extraction was a success, false otherwise</returns>
        public override bool CopyAll(string outDir)
        {
            bool encounteredErrors = true;

            try
            {
                // Create the temp directory
                Directory.CreateDirectory(outDir);

                // Extract all files to the temp directory
                SharpCompress.Archives.SevenZip.SevenZipArchive sza = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(Utilities.TryOpenRead(_filename));
                foreach (SevenZipArchiveEntry entry in sza.Entries)
                {
                    entry.WriteToDirectory(outDir, new ExtractionOptions {
                        PreserveFileTime = true, ExtractFullPath = true, Overwrite = true
                    });
                }
                encounteredErrors = false;
                sza.Dispose();
            }
            catch (EndOfStreamException)
            {
                // Catch this but don't count it as an error because SharpCompress is unsafe
            }
            catch (InvalidOperationException)
            {
                encounteredErrors = true;
            }
            catch (Exception ex)
            {
                Globals.Logger.Error(ex.ToString());
                encounteredErrors = true;
            }

            return(encounteredErrors);
        }
Esempio n. 4
0
        /// <summary>
        /// Generate a list of empty folders in an archive
        /// </summary>
        /// <param name="input">Input file to get data from</param>
        /// <returns>List of empty folders in the archive</returns>
        public override List <string> GetEmptyFolders()
        {
            List <string> empties = new List <string>();

            try
            {
                SharpCompress.Archives.SevenZip.SevenZipArchive sza = SharpCompress.Archives.SevenZip.SevenZipArchive.Open(_filename, new ReaderOptions {
                    LeaveStreamOpen = false
                });
                List <SevenZipArchiveEntry> sevenZipEntries = sza.Entries.OrderBy(e => e.Key, new NaturalSort.NaturalReversedComparer()).ToList();
                string lastSevenZipEntry = null;
                foreach (SevenZipArchiveEntry entry in sevenZipEntries)
                {
                    if (entry != null)
                    {
                        // If the current is a superset of last, we skip it
                        if (lastSevenZipEntry != null && lastSevenZipEntry.StartsWith(entry.Key))
                        {
                            // No-op
                        }
                        // If the entry is a directory, we add it
                        else if (entry.IsDirectory)
                        {
                            empties.Add(entry.Key);
                            lastSevenZipEntry = entry.Key;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Globals.Logger.Error(ex.ToString());
            }

            return(empties);
        }
 internal SevenZipReader(SevenZipArchive archive)
     : base(new ReaderOptions(), ArchiveType.SevenZip)
 {
     this.archive = archive;
 }
Esempio n. 6
0
 internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
     : base(readerOptions, ArchiveType.SevenZip)
 {
     this.archive = archive;
 }
 internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
     : base(part)
 {
     Archive = archive;
 }