internal static int ReadEntrySignature(Stream s) { int num = 0; try { num = SharedUtilities._ReadFourBytes(s, "n/a"); if (num == 134695760) { s.Seek(12L, SeekOrigin.Current); num = SharedUtilities._ReadFourBytes(s, "n/a"); if (num != 67324752) { s.Seek(8L, SeekOrigin.Current); num = SharedUtilities._ReadFourBytes(s, "n/a"); if (num != 67324752) { s.Seek(-24L, SeekOrigin.Current); num = SharedUtilities._ReadFourBytes(s, "n/a"); } } } } catch (BadReadException) { } return(num); }
public void InitCipher(string passphrase) { byte[] array = SharedUtilities.StringToByteArray(passphrase); for (int i = 0; i < passphrase.Length; i++) { this.UpdateKeys(array[i]); } }
internal static int ReadSignature(Stream s) { int result = 0; try { result = SharedUtilities._ReadFourBytes(s, "n/a"); } catch (BadReadException) { } return(result); }
public long TruncateBackward(uint diskNumber, long offset) { if (diskNumber >= 99u) { throw new ArgumentOutOfRangeException("diskNumber"); } if (this.rwMode != ZipSegmentedStream.RwMode.Write) { this._exceptionPending = true; throw new ZipException("bad state."); } if (diskNumber == this.CurrentSegment) { return(this._innerStream.Seek(offset, SeekOrigin.Begin)); } if (this._innerStream != null) { this._innerStream.Dispose(); if (File.Exists(this._currentTempName)) { File.Delete(this._currentTempName); } } for (uint num = this.CurrentSegment - 1u; num > diskNumber; num -= 1u) { string path = this._NameForSegment(num); if (File.Exists(path)) { File.Delete(path); } } this.CurrentSegment = diskNumber; for (int i = 0; i < 3; i++) { try { this._currentTempName = SharedUtilities.InternalGetTempFileName(); File.Move(this.CurrentName, this._currentTempName); break; } catch (IOException) { if (i == 2) { throw; } } } this._innerStream = new FileStream(this._currentTempName, FileMode.Open); return(this._innerStream.Seek(offset, SeekOrigin.Begin)); }
public static string NormalizePathForUseInZipFile(string pathName) { if (string.IsNullOrEmpty(pathName)) { return(pathName); } if (pathName.Length >= 2 && pathName[1] == ':' && pathName[2] == '\\') { pathName = pathName.Substring(3); } pathName = pathName.Replace('\\', '/'); while (pathName.StartsWith("/")) { pathName = pathName.Substring(1); } return(SharedUtilities.SimplifyFwdSlashPath(pathName)); }
internal static long FindSignature(Stream stream, int SignatureToFind) { long position = stream.Position; int num = 65536; byte[] array = new byte[] { (byte)(SignatureToFind >> 24), (byte)((SignatureToFind & 16711680) >> 16), (byte)((SignatureToFind & 65280) >> 8), (byte)(SignatureToFind & 255) }; byte[] array2 = new byte[num]; bool flag = false; do { int num2 = stream.Read(array2, 0, array2.Length); if (num2 == 0) { break; } for (int i = 0; i < num2; i++) { if (array2[i] == array[3]) { long position2 = stream.Position; stream.Seek((long)(i - num2), SeekOrigin.Current); int num3 = SharedUtilities.ReadSignature(stream); flag = (num3 == SignatureToFind); if (flag) { break; } stream.Seek(position2, SeekOrigin.Begin); } } }while (!flag); if (!flag) { stream.Seek(position, SeekOrigin.Begin); return(-1L); } return(stream.Position - position - 4L); }
public static void CreateAndOpenUniqueTempFile(string dir, out Stream fs, out string filename) { for (int i = 0; i < 3; i++) { try { filename = Path.Combine(dir, SharedUtilities.InternalGetTempFileName()); fs = new FileStream(filename, FileMode.CreateNew); return; } catch (IOException) { if (i == 2) { throw; } } } throw new IOException(); }
private void _SetWriteStream(uint increment) { if (this._innerStream != null) { this._innerStream.Dispose(); if (File.Exists(this.CurrentName)) { File.Delete(this.CurrentName); } File.Move(this._currentTempName, this.CurrentName); } if (increment > 0u) { this.CurrentSegment += increment; } SharedUtilities.CreateAndOpenUniqueTempFile(this._baseDir, out this._innerStream, out this._currentTempName); if (this.CurrentSegment == 0u) { this._innerStream.Write(BitConverter.GetBytes(134695760), 0, 4); } }
public ZipEntry GetNextEntry() { if (this._findRequired) { long num = SharedUtilities.FindSignature(this._inputStream, 67324752); if (num == -1L) { return(null); } this._inputStream.Seek(-4L, SeekOrigin.Current); } else if (this._firstEntry) { this._inputStream.Seek(this._endOfEntry, SeekOrigin.Begin); } this._currentEntry = ZipEntry.ReadEntry(this._container, !this._firstEntry); this._endOfEntry = this._inputStream.Position; this._firstEntry = true; this._needSetup = true; this._findRequired = false; return(this._currentEntry); }
public bool ContainsEntry(string name) { return(this._entriesWritten.ContainsKey(SharedUtilities.NormalizePathForUseInZipFile(name))); }
public long TruncateBackward(uint diskNumber, long offset) { // Console.WriteLine("***ZSS.Trunc to disk {0}", diskNumber); // Console.WriteLine("***ZSS.Trunc: current disk {0}", CurrentSegment); if (diskNumber >= 99) { throw new ArgumentOutOfRangeException("diskNumber"); } if (rwMode != RwMode.Write) { _exceptionPending = true; throw new ZipException("bad state."); } // Seek back in the segmented stream to a (maybe) prior segment. // Check if it is the same segment. If it is, very simple. if (diskNumber == CurrentSegment) { var x = _innerStream.Seek(offset, SeekOrigin.Begin); // workitem 10178 Pathfinding.Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_innerStream); return(x); } // Seeking back to a prior segment. // The current segment and any intervening segments must be removed. // First, close the current segment, and then remove it. if (_innerStream != null) { #if NETCF _innerStream.Close(); #else _innerStream.Dispose(); #endif if (File.Exists(_currentTempName)) { File.Delete(_currentTempName); } } // Now, remove intervening segments. for (uint j = CurrentSegment - 1; j > diskNumber; j--) { string s = _NameForSegment(j); // Console.WriteLine("***ZSS.Trunc: removing file {0}", s); if (File.Exists(s)) { File.Delete(s); } } // now, open the desired segment. It must exist. CurrentSegment = diskNumber; // get a new temp file, try 3 times: for (int i = 0; i < 3; i++) { try { _currentTempName = SharedUtilities.InternalGetTempFileName(); // move the .z0x file back to a temp name File.Move(CurrentName, _currentTempName); break; // workitem 12403 } catch (IOException) { if (i == 2) { throw; } } } // open it _innerStream = new FileStream(_currentTempName, FileMode.Open); var r = _innerStream.Seek(offset, SeekOrigin.Begin); // workitem 10178 Pathfinding.Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_innerStream); return(r); }
/// <summary> /// Saves the Zip archive to a file, specified by the Name property of the /// <c>ZipFile</c>. /// </summary> /// /// <remarks> /// <para> /// The <c>ZipFile</c> instance is written to storage, typically a zip file /// in a filesystem, only when the caller calls <c>Save</c>. In the typical /// case, the Save operation writes the zip content to a temporary file, and /// then renames the temporary file to the desired name. If necessary, this /// method will delete a pre-existing file before the rename. /// </para> /// /// <para> /// The <see cref="ZipFile.Name"/> property is specified either explicitly, /// or implicitly using one of the parameterized ZipFile constructors. For /// COM Automation clients, the <c>Name</c> property must be set explicitly, /// because COM Automation clients cannot call parameterized constructors. /// </para> /// /// <para> /// When using a filesystem file for the Zip output, it is possible to call /// <c>Save</c> multiple times on the <c>ZipFile</c> instance. With each /// call the zip content is re-written to the same output file. /// </para> /// /// <para> /// Data for entries that have been added to the <c>ZipFile</c> instance is /// written to the output when the <c>Save</c> method is called. This means /// that the input streams for those entries must be available at the time /// the application calls <c>Save</c>. If, for example, the application /// adds entries with <c>AddEntry</c> using a dynamically-allocated /// <c>MemoryStream</c>, the memory stream must not have been disposed /// before the call to <c>Save</c>. See the <see /// cref="ZipEntry.InputStream"/> property for more discussion of the /// availability requirements of the input stream for an entry, and an /// approach for providing just-in-time stream lifecycle management. /// </para> /// /// </remarks> /// /// <seealso cref="Ionic.Zip.ZipFile.AddEntry(String, System.IO.Stream)"/> /// /// <exception cref="Ionic.Zip.BadStateException"> /// Thrown if you haven't specified a location or stream for saving the zip, /// either in the constructor or by setting the Name property, or if you try /// to save a regular zip archive to a filename with a .exe extension. /// </exception> /// /// <exception cref="System.OverflowException"> /// Thrown if <see cref="MaxOutputSegmentSize"/> is non-zero, and the number /// of segments that would be generated for the spanned zip file during the /// save operation exceeds 99. If this happens, you need to increase the /// segment size. /// </exception> /// public void Save() { try { bool thisSaveUsedZip64 = false; _saveOperationCanceled = false; _numberOfSegmentsForMostRecentSave = 0; OnSaveStarted(); if (WriteStream == null) { throw new BadStateException("You haven't specified where to save the zip."); } if (_name != null && _name.EndsWith(".exe") && !_SavingSfx) { throw new BadStateException("You specified an EXE for a plain zip file."); } // check if modified, before saving. if (!_contentsChanged) { OnSaveCompleted(); if (Verbose) { StatusMessageTextWriter.WriteLine("No save is necessary...."); } return; } Reset(true); if (Verbose) { StatusMessageTextWriter.WriteLine("saving...."); } // validate the number of entries if (_entries.Count >= 0xFFFF && _zip64 == Zip64Option.Never) { throw new ZipException("The number of entries is 65535 or greater. Consider setting the UseZip64WhenSaving property on the ZipFile instance."); } // write an entry in the zip for each file int n = 0; // workitem 9831 ICollection <ZipEntry> c = (SortEntriesBeforeSaving) ? EntriesSorted : Entries; foreach (ZipEntry e in c) // _entries.Values { OnSaveEntry(n, e, true); e.Write(WriteStream); if (_saveOperationCanceled) { break; } n++; OnSaveEntry(n, e, false); if (_saveOperationCanceled) { break; } // Some entries can be skipped during the save. if (e.IncludedInMostRecentSave) { thisSaveUsedZip64 |= e.OutputUsedZip64.Value; } } if (_saveOperationCanceled) { return; } var zss = WriteStream as ZipSegmentedStream; _numberOfSegmentsForMostRecentSave = (zss != null) ? zss.CurrentSegment : 1; bool directoryNeededZip64 = ZipOutput.WriteCentralDirectoryStructure (WriteStream, c, _numberOfSegmentsForMostRecentSave, _zip64, Comment, new ZipContainer(this)); OnSaveEvent(ZipProgressEventType.Saving_AfterSaveTempArchive); _hasBeenSaved = true; _contentsChanged = false; thisSaveUsedZip64 |= directoryNeededZip64; _OutputUsesZip64 = new Nullable <bool>(thisSaveUsedZip64); // do the rename as necessary if (_name != null && (_temporaryFileName != null || zss != null)) { // _temporaryFileName may remain null if we are writing to a stream. // only close the stream if there is a file behind it. #if NETCF WriteStream.Close(); #else WriteStream.Dispose(); #endif if (_saveOperationCanceled) { return; } if (_fileAlreadyExists && this._readstream != null) { // This means we opened and read a zip file. // If we are now saving to the same file, we need to close the // orig file, first. this._readstream.Close(); this._readstream = null; // the archiveStream for each entry needs to be null foreach (var e in c) { var zss1 = e._archiveStream as ZipSegmentedStream; if (zss1 != null) #if NETCF { zss1.Close(); } #else { zss1.Dispose(); } #endif e._archiveStream = null; } } string tmpName = null; if (File.Exists(_name)) { // the steps: // // 1. Delete tmpName // 2. move existing zip to tmpName // 3. rename (File.Move) working file to name of existing zip // 4. delete tmpName // // This series of steps avoids the exception, // System.IO.IOException: // "Cannot create a file when that file already exists." // // Cannot just call File.Replace() here because // there is a possibility that the TEMP volume is different // that the volume for the final file (c:\ vs d:\). // So we need to do a Delete+Move pair. // // But, when doing the delete, Windows allows a process to // delete the file, even though it is held open by, say, a // virus scanner. It gets internally marked as "delete // pending". The file does not actually get removed from the // file system, it is still there after the File.Delete // call. // // Therefore, we need to move the existing zip, which may be // held open, to some other name. Then rename our working // file to the desired name, then delete (possibly delete // pending) the "other name". // // Ideally this would be transactional. It's possible that the // delete succeeds and the move fails. Lacking transactions, if // this kind of failure happens, we're hosed, and this logic will // throw on the next File.Move(). // //File.Delete(_name); // workitem 10447 #if NETCF || SILVERLIGHT tmpName = _name + "." + SharedUtilities.GenerateRandomStringImpl(8, 0) + ".tmp"; #else tmpName = _name + "." + Path.GetRandomFileName(); #endif if (File.Exists(tmpName)) { DeleteFileWithRetry(tmpName); } File.Move(_name, tmpName); } OnSaveEvent(ZipProgressEventType.Saving_BeforeRenameTempArchive); File.Move((zss != null) ? zss.CurrentTempName : _temporaryFileName, _name); OnSaveEvent(ZipProgressEventType.Saving_AfterRenameTempArchive); if (tmpName != null) { try { // not critical if (File.Exists(tmpName)) { File.Delete(tmpName); } } catch { // don't care about exceptions here. } } _fileAlreadyExists = true; } NotifyEntriesSaveComplete(c); OnSaveCompleted(); _JustSaved = true; } // workitem 5043 finally { CleanupAfterSaveOperation(); } return; }
private static void ReadIntoInstance(ZipFile zf) { Stream s = zf.ReadStream; try { zf._readName = zf._name; // workitem 13915 if (!s.CanSeek) { ReadIntoInstance_Orig(zf); return; } zf.OnReadStarted(); // change for workitem 8098 //zf._originPosition = s.Position; // Try reading the central directory, rather than scanning the file. uint datum = ReadFirstFourBytes(s); if (datum == ZipConstants.EndOfCentralDirectorySignature) { return; } // start at the end of the file... // seek backwards a bit, then look for the EoCD signature. int nTries = 0; bool success = false; // The size of the end-of-central-directory-footer plus 2 bytes is 18. // This implies an archive comment length of 0. We'll add a margin of // safety and start "in front" of that, when looking for the // EndOfCentralDirectorySignature long posn = s.Length - 64; long maxSeekback = Math.Max(s.Length - 0x4000, 10); do { if (posn < 0) { posn = 0; // BOF } s.Seek(posn, SeekOrigin.Begin); long bytesRead = SharedUtilities.FindSignature(s, (int)ZipConstants.EndOfCentralDirectorySignature); if (bytesRead != -1) { success = true; } else { if (posn == 0) { break; // started at the BOF and found nothing } nTries++; // Weird: with NETCF, negative offsets from SeekOrigin.End DO // NOT WORK. So rather than seek a negative offset, we seek // from SeekOrigin.Begin using a smaller number. posn -= (32 * (nTries + 1) * nTries); } }while (!success && posn > maxSeekback); if (success) { // workitem 8299 zf._locEndOfCDS = s.Position - 4; byte[] block = new byte[16]; s.Read(block, 0, block.Length); zf._diskNumberWithCd = BitConverter.ToUInt16(block, 2); if (zf._diskNumberWithCd == 0xFFFF) { throw new ZipException("Spanned archives with more than 65534 segments are not supported at this time."); } zf._diskNumberWithCd++; // I think the number in the file differs from reality by 1 int i = 12; uint offset32 = (uint)BitConverter.ToUInt32(block, i); if (offset32 == 0xFFFFFFFF) { Zip64SeekToCentralDirectory(zf); } else { zf._OffsetOfCentralDirectory = offset32; // change for workitem 8098 s.Seek(offset32, SeekOrigin.Begin); } ReadCentralDirectory(zf); } else { // Could not find the central directory. // Fallback to the old method. // workitem 8098: ok //s.Seek(zf._originPosition, SeekOrigin.Begin); s.Seek(0L, SeekOrigin.Begin); ReadIntoInstance_Orig(zf); } } catch (Exception ex1) { if (zf._ReadStreamIsOurs && zf._readstream != null) { try { #if NETCF zf._readstream.Close(); #else zf._readstream.Dispose(); #endif zf._readstream = null; } finally { } } throw new ZipException("Cannot read that as a ZipFile", ex1); } // the instance has been read in zf._contentsChanged = false; }
internal static int ReadInt(Stream s) { return(SharedUtilities._ReadFourBytes(s, "Could not read block - no data! (position 0x{0:X8})")); }
internal static string Utf8StringFromBuffer(byte[] buf) { return(SharedUtilities.StringFromBuffer(buf, SharedUtilities.utf8)); }
internal static byte[] StringToByteArray(string value) { return(SharedUtilities.StringToByteArray(value, SharedUtilities.ibm437)); }
public static string InternalGetTempFileName() { return("DotNetZip-" + SharedUtilities.GenerateRandomStringImpl(8, 0) + ".tmp"); }