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 Dictionary<string, 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                         if (mode != ZipArchiveMode.Read && mode != ZipArchiveMode.Create && mode != ZipArchiveMode.Update)
  91                                 throw new ArgumentOutOfRangeException("mode");
  92
  93                         // If the mode parameter is set to Read, the stream must support reading.
  94                         if (mode == ZipArchiveMode.Read && !stream.CanRead)
  95                                 throw new ArgumentException("Stream must support reading for Read archive mode");
  96
  97                         // If the mode parameter is set to Create, the stream must support writing.
  98                         if (mode == ZipArchiveMode.Create && !stream.CanWrite)
  99                                 throw new ArgumentException("Stream must support writing for Create archive mode");
 100
 101                         // If the mode parameter is set to Update, the stream must support reading, writing, and seeking.
 102                         if (mode == ZipArchiveMode.Update && (!stream.CanRead || !stream.CanWrite || !stream.CanSeek))
 103                                 throw new ArgumentException("Stream must support reading, writing and seeking for Update archive mode");
 104
 105                         try {
 106                                 zipFile = mode == ZipArchiveMode.Create ?
 107                                         SharpCompress.Archive.Zip.ZipArchive.Create() :
 108                                         SharpCompress.Archive.Zip.ZipArchive.Open(stream);
 109                         } catch (Exception e) {
 110                                 throw new InvalidDataException("The contents of the stream are not in the zip archive format.", e);
 111                         }
 112
 113                         entries = new Dictionary<string, ZipArchiveEntry>();
 114                         if (Mode != ZipArchiveMode.Create) {
 115                                 foreach (var entry in zipFile.Entries) {
 116                                         var zipEntry = new ZipArchiveEntry(this, entry);
 117                                         entries[entry.Key] = zipEntry;
 118                                 }
 119                         }
 120                 }
 121
 122                 public ReadOnlyCollection<ZipArchiveEntry> Entries {
 123                         get {
 124                                 if (disposed)
 125                                         throw new ObjectDisposedException("The zip archive has been disposed.");
 126
 127                                 if (Mode == ZipArchiveMode.Create)
 128                                         throw new NotSupportedException("Cannot access entries in Create mode.");
 129
 130                                 if (zipFile == null)
 131                                         throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 132
 133                                 if (entries == null)
 134                                         return new ReadOnlyCollection<ZipArchiveEntry>(new List<ZipArchiveEntry>());
 135
 136                                 return new ReadOnlyCollection<ZipArchiveEntry>(entries.Values.ToList());
 137                         }
 138                 }
 139
 140                 public ZipArchiveMode Mode {
 141                         get {
 142                                 if (disposed)
 143                                         throw new ObjectDisposedException("The zip archive has been disposed.");
 144
 145                                 return mode;
 146                         }
 147                 }
 148
 149                 public ZipArchiveEntry CreateEntry (string entryName)
 150                 {
 151                         if (disposed)
 152                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 153
 154                         return CreateEntry(entryName, CompressionLevel.Optimal);
 155                 }
 156
 157                 public ZipArchiveEntry CreateEntry (string entryName, CompressionLevel compressionLevel)
 158                 {
 159                         if (disposed)
 160                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 161
 162                         if (entryName == string.Empty)
 163                                 throw new ArgumentException("Entry name cannot be empty.");
 164
 165                         if (entryName == null)
 166                                 throw new ArgumentNullException("entryName");
 167
 168                         if (mode != ZipArchiveMode.Create && mode != ZipArchiveMode.Update)
 169                                 throw new NotSupportedException("The zip archive does not support writing.");
 170
 171                         if (zipFile == null)
 172                                 throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 173
 174                         var memoryStream = new MemoryStream();
 175                         var entry = zipFile.AddEntry(entryName, memoryStream);
 176                         var archiveEntry = new ZipArchiveEntry(this, entry);
 177                         entries[entryName] = archiveEntry;
 178
 179                         return archiveEntry;
 180                 }
 181
 182                 public ZipArchiveEntry GetEntry (string entryName)
 183                 {
 184                         if (disposed)
 185                                 throw new ObjectDisposedException("The zip archive has been disposed.");
 186
 187                         if (entryName == string.Empty)
 188                                 throw new ArgumentException("Entry name cannot be empty.");
 189
 190                         if (entryName == null)
 191                                 throw new ArgumentNullException("entryName");
 192
 193                         if (mode != ZipArchiveMode.Read && mode != ZipArchiveMode.Update)
 194                                 throw new NotSupportedException("The zip archive does not support reading.");
 195
 196                         if (zipFile == null)
 197                                 throw new InvalidDataException("The zip archive is corrupt, and its entries cannot be retrieved.");
 198
 199                         return entries.ContainsKey(entryName) ? entries[entryName] : null;
 200                 }
 201
 202                 private void Save()
 203                 {
 204                         using (var newZip = new MemoryStream()) {
 205                                 zipFile.SaveTo(newZip, CompressionType.Deflate, entryNameEncoding ?? Encoding.UTF8);
 206
 207                                 stream.SetLength(0);
 208                                 stream.Position = 0;
 209                                 newZip.Position = 0;
 210                                 newZip.CopyTo(stream);
 211                         }
 212                 }
 213
 214                 protected virtual void Dispose (bool disposing)
 215                 {
 216                         if (disposed)
 217                                 return;
 218
 219                         if (mode != ZipArchiveMode.Read)
 220                                 Save();
 221
 222                         disposed = true;
 223
 224                         if (leaveStreamOpen)
 225                                 return;
 226
 227                         if (stream != null) {
 228                                 stream.Dispose();
 229                                 stream = null;
 230                         }
 231                 }
 232
 233                 public void Dispose ()
 234                 {
 235                         Dispose(true);
 236                         GC.SuppressFinalize(this);
 237                 }
 238         }
 239 }
 240