Ejemplo n.º 1
0
 public DiskArchiveStorage(ZipFile file, FileUpdateMode updateMode = FileUpdateMode.Safe)
     : base(updateMode)
 {
     if (file.Name == null)
     {
         throw new ZipException("Cant handle non file archives");
     }
     _fileName = file.Name;
 }
Ejemplo n.º 2
0
		/// <summary>
		/// Extract the contents of a zip file.
		/// </summary>
		/// <param name="zipFileName">The zip file to extract from.</param>
		/// <param name="targetDirectory">The directory to save extracted information in.</param>
		/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
		/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
		/// <param name="fileFilter">A filter to apply to files.</param>
		/// <param name="directoryFilter">A filter to apply to directories.</param>
		/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
		public void ExtractZip(string zipFileName, string targetDirectory, 
							   Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate, 
							   string fileFilter, string directoryFilter, bool restoreDateTime)
		{
			if ( (overwrite == Overwrite.Prompt) && (confirmDelegate == null) ) {
				throw new ArgumentNullException("confirmDelegate");
			}

			continueRunning_ = true;
			overwrite_ = overwrite;
			confirmDelegate_ = confirmDelegate;
			targetDirectory_ = targetDirectory;
			fileFilter_ = new NameFilter(fileFilter);
			directoryFilter_ = new NameFilter(directoryFilter);
			restoreDateTimeOnExtract_ = restoreDateTime;
			
			using ( zipFile_ = new ZipFile(zipFileName) ) {

#if !NETCF_1_0
				if (password_ != null) {
					zipFile_.Password = password_;
				}
#endif

				System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
				while ( continueRunning_ && enumerator.MoveNext()) {
					ZipEntry entry = (ZipEntry) enumerator.Current;
					if ( entry.IsFile )
					{
						if ( directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name) ) {
							ExtractEntry(entry);
						}
					}
					else if ( entry.IsDirectory ) {
						if ( directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories ) {
							ExtractEntry(entry);
						}
					}
					else {
						// Do nothing for volume labels etc...
					}
				}
			}
		}
Ejemplo n.º 3
0
 /// <summary>
 /// Initialise a new instance of <see cref="TestStatus"/>
 /// </summary>
 /// <param name="file">The <see cref="ZipFile"/> this status applies to.</param>
 public TestStatus(ZipFile file)
 {
     file_ = file;
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DiskArchiveStorage"/> class.
 /// </summary>
 /// <param name="file">The file.</param>
 public DiskArchiveStorage(ZipFile file)
     : this(file, FileUpdateMode.Safe)
 {
 }
Ejemplo n.º 5
0
        void ModifyEntry(ZipFile workFile, ZipUpdate update)
        {
            workFile.WriteLocalEntryHeader(update);
            long dataStart = workFile.baseStream_.Position;

            // TODO: This is slow if the changes don't effect the data!!
            if ( update.Entry.IsFile && (update.Filename != null) ) {
                using ( Stream output = workFile.GetOutputStream(update.OutEntry) ) {
                    using ( Stream source = this.GetInputStream(update.Entry) ) {
                        CopyBytes(update, output, source, source.Length, true);
                    }
                }
            }

            long dataEnd = workFile.baseStream_.Position;
            update.Entry.CompressedSize = dataEnd - dataStart;
        }
Ejemplo n.º 6
0
        void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition)
        {
            bool skipOver = false;
            if ( update.Entry.Offset == destinationPosition ) {
                skipOver = true;
            }

            if ( !skipOver ) {
                baseStream_.Position = destinationPosition;
                workFile.WriteLocalEntryHeader(update);
                destinationPosition = baseStream_.Position;
            }

            long sourcePosition = 0;

            const int NameLengthOffset = 26;
            // TODO: Add base for SFX friendly handling
            long entryDataOffset = update.Entry.Offset + NameLengthOffset;

            baseStream_.Seek(entryDataOffset, SeekOrigin.Begin);

            // Clumsy way of handling retrieving the original name and extra data length for now.
            uint nameLength = ReadLEUshort();
            uint extraLength = ReadLEUshort();

            sourcePosition = baseStream_.Position + nameLength + extraLength;

            if ( skipOver ) {
                destinationPosition +=
                    (sourcePosition - entryDataOffset) + NameLengthOffset +	// Header size
                    update.Entry.CompressedSize + GetDescriptorSize(update);
            }
            else {
                if ( update.Entry.CompressedSize > 0 ) {
                    CopyEntryDataDirect(update, baseStream_, false, ref destinationPosition, ref sourcePosition );
                }
                CopyDescriptorBytesDirect(update, baseStream_, ref destinationPosition, sourcePosition);
            }
        }
Ejemplo n.º 7
0
        void CopyEntry(ZipFile workFile, ZipUpdate update)
        {
            workFile.WriteLocalEntryHeader(update);

            if ( update.Entry.CompressedSize > 0 ) {
                const int NameLengthOffset = 26;

                long entryDataOffset = update.Entry.Offset + NameLengthOffset;

                // TODO: This wont work for SFX files!
                baseStream_.Seek(entryDataOffset, SeekOrigin.Begin);

                uint nameLength = ReadLEUshort();
                uint extraLength = ReadLEUshort();

                baseStream_.Seek(nameLength + extraLength, SeekOrigin.Current);

                CopyBytes(update, workFile.baseStream_, baseStream_, update.Entry.CompressedSize, false);
            }
            CopyDescriptorBytes(update, workFile.baseStream_, baseStream_);
        }
Ejemplo n.º 8
0
        void AddEntry(ZipFile workFile, ZipUpdate update)
        {
            long dataStart = 0;
            Stream source = null;

            if ( update.Entry.IsFile ) {
                source = update.GetSource();

                if ( source == null ) {
                    source = updateDataSource_.GetSource(update.Entry, update.Filename);
                }
            }

            if ( source != null ) {
                using ( source ) {
                    long sourceStreamLength = source.Length;
                    if ( update.OutEntry.Size < 0 ) {
                        update.OutEntry.Size = sourceStreamLength;
                    }
                    else {
                        // Check for errant entries.
                        if ( update.OutEntry.Size != sourceStreamLength ) {
                            throw new ZipException("Entry size/stream size mismatch");
                        }
                    }

                    workFile.WriteLocalEntryHeader(update);
                    dataStart = workFile.baseStream_.Position;

                    using ( Stream output = workFile.GetOutputStream(update.OutEntry) ) {
                        CopyBytes(update, output, source, sourceStreamLength, true);
                    }
                }
            }
            else {
                workFile.WriteLocalEntryHeader(update);
                dataStart = workFile.baseStream_.Position;
            }

            long dataEnd = workFile.baseStream_.Position;
            update.OutEntry.CompressedSize = dataEnd - dataStart;
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Create a new <see cref="ZipFile"/> whose data will be stored on a stream.
        /// </summary>
        /// <param name="outStream">The stream providing data storage.</param>
        /// <returns>Returns the newly created <see cref="ZipFile"/></returns>
        public static ZipFile Create(Stream outStream)
        {
            if ( outStream == null ) {
                throw new ArgumentNullException("outStream");
            }

            if ( !outStream.CanWrite ) {
                throw new ArgumentException("Stream is not writeable", "outStream");
            }

            if ( !outStream.CanSeek ) {
                throw new ArgumentException("Stream is not seekable", "outStream");
            }

            ZipFile result = new ZipFile();
            result.baseStream_ = outStream;
            return result;
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Create a new <see cref="ZipFile"/> whose data will be stored in a file.
        /// </summary>
        /// <param name="fileName">The name of the archive to create.</param>
        /// <returns>Returns the newly created <see cref="ZipFile"/></returns>
        public static ZipFile Create(string fileName)
        {
            if ( fileName == null ) {
                throw new ArgumentNullException("fileName");
            }

            ZipFile result = new ZipFile();
            result.name_ = fileName;
            result.baseStream_ = File.Create(fileName);
            return result;
        }
Ejemplo n.º 11
0
 public void ExtractZip(Stream inputStream, string targetDirectory, Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate, string fileFilter, string directoryFilter, bool restoreDateTime, bool isStreamOwner)
 {
     if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
     {
         throw new ArgumentNullException(nameof(confirmDelegate));
     }
     _continueRunning = true;
     _overwrite = overwrite;
     _confirmDelegate = confirmDelegate;
     _extractNameTransform = new WindowsNameTransform(targetDirectory);
     _fileFilter = new NameFilter(fileFilter);
     _directoryFilter = new NameFilter(directoryFilter);
     _restoreDateTimeOnExtract = restoreDateTime;
     using (_zipFile = new ZipFile(inputStream))
     {
         if (_password != null)
         {
             _zipFile.Password = _password;
         }
         _zipFile.IsStreamOwner = isStreamOwner;
         IEnumerator enumerator = _zipFile.GetEnumerator();
         while (_continueRunning && enumerator.MoveNext())
         {
             ZipEntry current = (ZipEntry)enumerator.Current;
             if (current.IsFile)
             {
                 if (_directoryFilter.IsMatch(Path.GetDirectoryName(current.Name)) && _fileFilter.IsMatch(current.Name))
                 {
                     ExtractEntry(current);
                 }
             }
             else if ((current.IsDirectory && _directoryFilter.IsMatch(current.Name)) && CreateEmptyDirectories)
             {
                 ExtractEntry(current);
             }
         }
     }
 }
Ejemplo n.º 12
0
 private void ModifyEntry(ZipFile workFile, ZipUpdate update)
 {
     workFile.WriteLocalEntryHeader(update);
     var position = workFile._baseStream.Position;
     if (update.Entry.IsFile && (update.Filename != null))
     {
         using (var stream = workFile.GetOutputStream(update.OutEntry))
         {
             using (var stream2 = GetInputStream(update.Entry))
             {
                 CopyBytes(update, stream, stream2, stream2.Length, true);
             }
         }
     }
     var num2 = workFile._baseStream.Position;
     update.Entry.CompressedSize = num2 - position;
 }
Ejemplo n.º 13
0
 private void CopyEntryDirect(ZipFile workFile, ZipUpdate update, ref long destinationPosition)
 {
     var flag = update.Entry.Offset == destinationPosition;
     if (!flag)
     {
         _baseStream.Position = destinationPosition;
         workFile.WriteLocalEntryHeader(update);
         destinationPosition = _baseStream.Position;
     }
     var offset = update.Entry.Offset + 0x1aL;
     _baseStream.Seek(offset, SeekOrigin.Begin);
     uint num3 = ReadLeUshort();
     uint num4 = ReadLeUshort();
     var sourcePosition = (_baseStream.Position + num3) + num4;
     if (flag)
     {
         if (update.OffsetBasedSize != -1L)
         {
             destinationPosition += update.OffsetBasedSize;
         }
         else
         {
             destinationPosition += (((sourcePosition - offset) + 0x1aL) + update.Entry.CompressedSize) + GetDescriptorSize(update);
         }
     }
     else
     {
         if (update.Entry.CompressedSize > 0L)
         {
             CopyEntryDataDirect(update, _baseStream, false, ref destinationPosition, ref sourcePosition);
         }
         CopyDescriptorBytesDirect(update, _baseStream, ref destinationPosition, sourcePosition);
     }
 }
Ejemplo n.º 14
0
 private void CopyEntry(ZipFile workFile, ZipUpdate update)
 {
     workFile.WriteLocalEntryHeader(update);
     if (update.Entry.CompressedSize > 0L)
     {
         var offset = update.Entry.Offset + 0x1aL;
         _baseStream.Seek(offset, SeekOrigin.Begin);
         uint num2 = ReadLeUshort();
         uint num3 = ReadLeUshort();
         _baseStream.Seek(num2 + num3, SeekOrigin.Current);
         CopyBytes(update, workFile._baseStream, _baseStream, update.Entry.CompressedSize, false);
     }
     CopyDescriptorBytes(update, workFile._baseStream, _baseStream);
 }
Ejemplo n.º 15
0
 private void AddEntry(ZipFile workFile, ZipUpdate update)
 {
     Stream source = null;
     if (update.Entry.IsFile)
     {
         source = update.GetSource();
         if (source == null)
         {
             source = _updateDataSource.GetSource(update.Entry, update.Filename);
         }
     }
     if (source != null)
     {
         using (source)
         {
             var length = source.Length;
             if (update.OutEntry.Size < 0L)
             {
                 update.OutEntry.Size = length;
             }
             else if (update.OutEntry.Size != length)
             {
                 throw new ZipException("Entry size/stream size mismatch");
             }
             workFile.WriteLocalEntryHeader(update);
             var position = workFile._baseStream.Position;
             using (var stream2 = workFile.GetOutputStream(update.OutEntry))
             {
                 CopyBytes(update, stream2, source, length, true);
             }
             var num3 = workFile._baseStream.Position;
             update.OutEntry.CompressedSize = num3 - position;
             if ((update.OutEntry.Flags & 8) == 8)
             {
                 new ZipHelperStream(workFile._baseStream).WriteDataDescriptor(update.OutEntry);
             }
             return;
         }
     }
     workFile.WriteLocalEntryHeader(update);
     update.OutEntry.CompressedSize = 0L;
 }
Ejemplo n.º 16
0
 public PartialInputStream(ZipFile zipFile, long start, long length)
 {
     _start = start;
     _length = length;
     _baseStream = zipFile._baseStream;
     _readPos = start;
     _end = start + length;
 }