mcs/class/System.IO.Compression/ZipArchive.cs

   1 //
   2 // ZipArchiveEntry.cs
   3 //
   4 // Author:
   5 //       Joao Matos <joao.matos@xamarin.com>
   6 //       Martin Baulig <martin.baulig@xamarin.com>
   7 //
   8 // Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining a copy
  11 // of this software and associated documentation files (the "Software"), to deal
  12 // in the Software without restriction, including without limitation the rights
  13 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14 // copies of the Software, and to permit persons to whom the Software is
  15 // furnished to do so, subject to the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be included in
  18 // all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26 // THE SOFTWARE.
  27 using System.Collections.Generic;
  28 using System.Collections.ObjectModel;
  29 using System.Linq;
  30 using System.Text;
  31 using SharpCompress.Common;
  32
  33 namespace System.IO.Compression
  34 {
  35         public class ZipArchive : IDisposable
  36         {
  37                 internal Stream stream;
  38                 internal readonly bool leaveStreamOpen;
  39                 internal readonly ZipArchiveMode mode;
  40                 internal Encoding entryNameEncoding;
  41                 internal bool disposed;
  42                 internal List<ZipArchiveEntry> entries;
  43                 internal SharpCompress.Archive.Zip.ZipArchive zipFile;
  44
  45                 public ZipArchive (Stream stream)
  46                 {
  47                         if (stream == null)
  48                                 throw new ArgumentNullException("stream");
  49
  50                         this.stream = stream;
  51                         mode = ZipArchiveMode.Read;
  52                         CreateZip(stream, mode);
  53                 }
  54
  55                 public ZipArchive (Stream stream, ZipArchiveMode mode)
  56                 {
  57                         if (stream == null)
  58                                 throw new ArgumentNullException("stream");
  59
  60                         this.stream = stream;
  61                         this.mode = mode;
  62                         CreateZip(stream, mode);
  63                 }
  64
  65                 public ZipArchive (Stream stream, ZipArchiveMode mode, bool leaveOpen)
  66                 {
  67                         if (stream == null)
  68                                 throw new ArgumentNullException("stream");
  69
  70                         this.stream = stream;
  71                         this.mode = mode;
  72                         leaveStreamOpen = leaveOpen;
  73                         CreateZip(stream, mode);
  74                 }
  75
  76                 public ZipArchive (Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding entryNameEncoding)
  77                 {
  78                         if (stream == null)
  79                                 throw new ArgumentNullException("stream");
  80
  81                         this.stream = stream;
  82                         this.mode = mode;
  83                         leaveStreamOpen = leaveOpen;
  84                         this.entryNameEncoding = entryNameEncoding;
  85                         CreateZip(stream, mode);
  86                 }
  87
  88                 private void CreateZip(Stream stream, ZipArchiveMode mode)
  89                 {
  90                         try {
  91                                 if (mode != ZipArchiveMode.Read && mode != ZipArchiveMode.Create && mode != ZipArchiveMode.Update)
  92                                         throw new ArgumentOutOfRangeException("mode");
  93
  94                                 // If the mode parameter is set to Read, the stream must support reading.
  95                                 if (mode == ZipArchiveMode.Read && !stream.CanRead)
  96                                         throw new ArgumentException("Stream must support reading for Read archive mode");
  97
  98                                 // If the mode parameter is set to Create, the stream must support writing.
  99                                 if (mode == ZipArchiveMode.Create && !stream.CanWrite)
 100                                         throw new ArgumentException("Stream must support writing for Create archive mode");
 101
 102                                 // If the mode parameter is set to Update, the stream must support reading, writing, and seeking.
 103                                 if (mode == ZipArchiveMode.Update && (!stream.CanRead || !stream.CanWrite || !stream.CanSeek))
 104                                         throw new ArgumentException("Stream must support reading, writing and seeking for Update archive mode");
 105
 106                                 try {
 107                                         zipFile = mode != ZipArchiveMode.Create && stream.Length != 0
 108                                                 ? SharpCompress.Archive.Zip.ZipArchive.Open(stream)
 109                                                 : SharpCompress.Archive.Zip.ZipArchive.Create();
 110                                 } catch (Exception e) {
 111                                         throw new InvalidDataException("The contents of the stream are not in the zip archive format.", e);
 112                                 }
 113
 114                                 entries = new List<ZipArchiveEntry>();
 115                                 if (Mode != ZipArchiveMode.Create) {
 116                                         foreach (var entry in zipFile.Entries) {
 117                                                 var zipEntry = new ZipArchiveEntry(this, entry);
 118                                                 entries.Add(zipEntry);
 119                                         }
 120                                 }
 121                         }
 122                         catch {
 123                                 if (!leaveStreamOpen)
 124                                         stream.Dispose();
 125                                 throw;
 126                         }
 127                 }
 128
 129                 public ReadOnlyCollection<ZipArchiveEntry> Entries {
 130                         get {
 131                                 if (disposed)
 132                                         throw new ObjectDisposedException("The zip archive has been disposed.");
 133
 134                                 if (Mode == ZipArchiveMode.Create)
 135                                         throw new NotSupportedException("Cannot access entries in Create mode.");
 136
 137                                 if (zipFile == null)
 138                                         throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 139
 140                                 if (entries == null)
 141                                         return new ReadOnlyCollection<ZipArchiveEntry>(new List<ZipArchiveEntry>());
 142
 143                                 return new ReadOnlyCollection<ZipArchiveEntry>(entries);
 144                         }
 145                 }
 146
 147                 public ZipArchiveMode Mode {
 148                         get {
 149                                 if (disposed)
 150                                         throw new ObjectDisposedException("The zip archive has been disposed.");
 151
 152                                 return mode;
 153                         }
 154                 }
 155
 156                 public ZipArchiveEntry CreateEntry (string entryName)
 157                 {
 158                         if (disposed)
 159                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 160
 161                         return CreateEntry(entryName, CompressionLevel.Optimal);
 162                 }
 163
 164                 internal SharpCompress.Archive.Zip.ZipArchiveEntry CreateEntryInternal(string entryName)
 165                 {
 166                         var memoryStream = new MemoryStream();
 167                         var entry = zipFile.AddEntry(entryName, memoryStream);
 168
 169                         return entry;
 170                 }
 171
 172                 public ZipArchiveEntry CreateEntry (string entryName, CompressionLevel compressionLevel)
 173                 {
 174                         if (disposed)
 175                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 176
 177                         if (entryName == string.Empty)
 178                                 throw new ArgumentException("Entry name cannot be empty.");
 179
 180                         if (entryName == null)
 181                                 throw new ArgumentNullException("entryName");
 182
 183                         if (mode != ZipArchiveMode.Create && mode != ZipArchiveMode.Update)
 184                                 throw new NotSupportedException("The zip archive does not support writing.");
 185
 186                         if (zipFile == null)
 187                                 throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 188
 189                         var internalEntry = CreateEntryInternal(entryName);
 190                         var archiveEntry = new ZipArchiveEntry(this, internalEntry);
 191                         entries.Add(archiveEntry);
 192
 193                         return archiveEntry;
 194                 }
 195
 196                 public ZipArchiveEntry GetEntry (string entryName)
 197                 {
 198                         if (disposed)
 199                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 200
 201                         if (entryName == string.Empty)
 202                                 throw new ArgumentException("Entry name cannot be empty.");
 203
 204                         if (entryName == null)
 205                                 throw new ArgumentNullException("entryName");
 206
 207                         if (mode != ZipArchiveMode.Read && mode != ZipArchiveMode.Update)
 208                                 throw new NotSupportedException("The zip archive does not support reading.");
 209
 210                         if (zipFile == null)
 211                                 throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 212
 213                         return entries.FirstOrDefault(e => e.FullName == entryName);
 214                 }
 215
 216                 private void Save()
 217                 {
 218                         using (var newZip = new MemoryStream()) {
 219                                 zipFile.SaveTo(newZip, CompressionType.Deflate, entryNameEncoding ?? Encoding.UTF8);
 220
 221                                 stream.SetLength(0);
 222                                 stream.Position = 0;
 223                                 newZip.Position = 0;
 224                                 newZip.CopyTo(stream);
 225                         }
 226                 }
 227
 228                 protected virtual void Dispose (bool disposing)
 229                 {
 230                         if (disposed)
 231                                 return;
 232
 233                         if (mode != ZipArchiveMode.Read)
 234                                 Save();
 235
 236                         disposed = true;
 237
 238                         if (leaveStreamOpen)
 239                                 return;
 240
 241                         if (stream != null) {
 242                                 stream.Dispose();
 243                                 stream = null;
 244                         }
 245                 }
 246
 247                 public void Dispose ()
 248                 {
 249                         Dispose(true);
 250                         GC.SuppressFinalize(this);
 251                 }
 252         }
 253 }
 254