mcs/class/WindowsBase/System.IO.Packaging/ZipPackage.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  19 //
  20 // Copyright (c) 2007 Novell, Inc. (http://www.novell.com)
  21 //
  22 // Authors:
  23 //      Chris Toshok (toshok@ximian.com)
  24 //
  25
  26 using System;
  27 using System.Collections.Generic;
  28 using System.IO;
  29 using System.Xml;
  30 using zipsharp;
  31
  32 namespace System.IO.Packaging {
  33
  34         class UriComparer : IEqualityComparer<Uri>
  35         {
  36                 public int GetHashCode(Uri uri)
  37                 {
  38                         return 1;
  39                 }
  40
  41                 public bool Equals(Uri x, Uri y)
  42                 {
  43                         return x.OriginalString.Equals (y.OriginalString, StringComparison.OrdinalIgnoreCase);
  44                 }
  45         }
  46
  47         public sealed class ZipPackage : Package
  48         {
  49                 private const string ContentNamespace = "http://schemas.openxmlformats.org/package/2006/content-types";
  50                 private const string ContentUri = "[Content_Types].xml";
  51
  52                 bool OwnsStream {
  53                         get; set;
  54                 }
  55
  56                 Dictionary<Uri, ZipPackagePart> parts;
  57                 internal Dictionary<Uri, MemoryStream> PartStreams = new Dictionary<Uri, MemoryStream> (new  UriComparer());
  58
  59                 internal Stream PackageStream { get; set; }
  60
  61                 Dictionary<Uri, ZipPackagePart> Parts {
  62                         get {
  63                                 if (parts == null)
  64                                         LoadParts ();
  65                                 return parts;
  66                         }
  67                 }
  68
  69                 internal ZipPackage (FileAccess access, bool ownsStream, Stream stream)
  70                         : base (access)
  71                 {
  72                         OwnsStream = ownsStream;
  73                         PackageStream = stream;
  74                 }
  75
  76                 internal ZipPackage (FileAccess access, bool ownsStream, Stream stream, bool streaming)
  77                         : base (access, streaming)
  78                 {
  79                         OwnsStream = ownsStream;
  80                         PackageStream = stream;
  81                 }
  82
  83                 protected override void Dispose (bool disposing)
  84                 {
  85                         foreach (Stream s in PartStreams.Values)
  86                                 s.Close ();
  87
  88                         base.Dispose (disposing);
  89
  90                         if (OwnsStream)
  91                                 PackageStream.Close ();
  92                 }
  93
  94                 protected override void FlushCore ()
  95                 {
  96                         // Ensure that all the data has been read out of the package
  97                         // stream already. Otherwise we'll lose data when we recreate the zip
  98                         foreach (ZipPackagePart part in Parts.Values)
  99                                 part.GetStream ().Dispose ();
 100
 101                         // Empty the package stream
 102                         PackageStream.Position = 0;
 103                         PackageStream.SetLength (0);
 104
 105                         // Recreate the zip file
 106                         using (ZipArchive archive = new ZipArchive(PackageStream, Append.Create, false)) {
 107
 108                                 // Write all the part streams
 109                                 foreach (ZipPackagePart part in Parts.Values) {
 110                                         Stream partStream = part.GetStream ();
 111                                         partStream.Seek (0, SeekOrigin.Begin);
 112
 113                                         using (Stream destination = archive.GetStream (part.Uri.ToString ().Substring(1), part.CompressionOption)) {
 114                                                 int count = (int) Math.Min (2048, partStream.Length);
 115                                                 byte[] buffer = new byte [count];
 116
 117                                                 while ((count = partStream.Read (buffer, 0, buffer.Length)) != 0)
 118                                                         destination.Write (buffer, 0, count);
 119                                         }
 120                                 }
 121
 122                                 using (Stream s = archive.GetStream (ContentUri, CompressionOption.Maximum))
 123                                         WriteContentType (s);
 124                         }
 125                 }
 126
 127                 protected override PackagePart CreatePartCore (Uri partUri, string contentType, CompressionOption compressionOption)
 128                 {
 129                         ZipPackagePart part = new ZipPackagePart (this, partUri, contentType, compressionOption);
 130                         Parts.Add (part.Uri, part);
 131                         return part;
 132                 }
 133
 134                 protected override void DeletePartCore (Uri partUri)
 135                 {
 136                         Parts.Remove (partUri);
 137                 }
 138
 139                 protected override PackagePart GetPartCore (Uri partUri)
 140                 {
 141                         ZipPackagePart part;
 142                         Parts.TryGetValue (partUri, out part);
 143                         return part;
 144                 }
 145
 146                 protected override PackagePart[] GetPartsCore ()
 147                 {
 148                         ZipPackagePart[] p = new ZipPackagePart [Parts.Count];
 149                         Parts.Values.CopyTo (p, 0);
 150                         return p;
 151                 }
 152
 153                 void LoadParts ()
 154                 {
 155                         parts = new Dictionary<Uri, ZipPackagePart> (new  UriComparer());
 156                         try {
 157                                 using (UnzipArchive archive = new UnzipArchive (PackageStream)) {
 158
 159                                         // Load the content type map file
 160                                         XmlDocument doc = new XmlDocument ();
 161                                         using (Stream s = archive.GetStream (ContentUri))
 162                                                 doc.Load (s);
 163
 164                                         XmlNamespaceManager manager = new XmlNamespaceManager (doc.NameTable);
 165                                         manager.AddNamespace ("content", ContentNamespace);
 166
 167                                         // The file names in the zip archive are not prepended with '/'
 168                                         foreach (string file in archive.GetFiles ()) {
 169                                                 if (file.Equals (ContentUri, StringComparison.Ordinal))
 170                                                         continue;
 171
 172                                                 XmlNode node;
 173                                                 CompressionOption compression = archive.GetCompressionLevel (file);
 174
 175                                                 if (file == RelationshipUri.ToString ().Substring (1))
 176                                                 {
 177                                                         CreatePartCore (RelationshipUri, RelationshipContentType, compression);
 178                                                         continue;
 179                                                 }
 180
 181                                                 string xPath = string.Format ("/content:Types/content:Override[@PartName='/{0}']", file);
 182                                                 node = doc.SelectSingleNode (xPath, manager);
 183
 184                                                 if (node == null)
 185                                                 {
 186                                                         string ext = Path.GetExtension (file);
 187                                                         if (ext.StartsWith("."))
 188                                                                 ext = ext.Substring (1);
 189                                                         xPath = string.Format("/content:Types/content:Default[@Extension='{0}']", ext);
 190                                                         node = doc.SelectSingleNode (xPath, manager);
 191                                                 }
 192
 193                                                 // What do i do if the node is null? This means some has tampered with the
 194                                                 // package file manually
 195                                                 if (node != null)
 196                                                         CreatePartCore (new Uri ("/" + file, UriKind.Relative), node.Attributes["ContentType"].Value, compression);
 197                                         }
 198                                 }
 199                         } catch {
 200                                 // The archive is invalid - therefore no parts
 201                         }
 202                 }
 203
 204                 void WriteContentType (Stream s)
 205                 {
 206                         XmlDocument doc = new XmlDocument ();
 207                         XmlNamespaceManager manager = new XmlNamespaceManager (doc.NameTable);
 208                         Dictionary<string, string> mimes = new Dictionary<string, string> ();
 209
 210                         manager.AddNamespace ("content", ContentNamespace);
 211
 212                         doc.AppendChild(doc.CreateNode (XmlNodeType.XmlDeclaration, "", ""));
 213
 214                         XmlNode root = doc.CreateNode (XmlNodeType.Element, "Types", ContentNamespace);
 215                         doc.AppendChild (root);
 216                         foreach (ZipPackagePart part in Parts.Values)
 217                         {
 218                                 XmlNode node = null;
 219                                 string existingMimeType;
 220
 221                                 var extension = Path.GetExtension (part.Uri.OriginalString);
 222                                 if (extension.Length > 0)
 223                                         extension = extension.Substring (1);
 224
 225                                 if (!mimes.TryGetValue (extension, out existingMimeType)) {
 226                                         node = doc.CreateNode (XmlNodeType.Element, "Default", ContentNamespace);
 227
 228                                         XmlAttribute ext = doc.CreateAttribute ("Extension");
 229                                         ext.Value = extension;
 230                                         node.Attributes.Append (ext);
 231                                         mimes [extension] = part.ContentType;
 232                                 } else if (part.ContentType != existingMimeType) {
 233                                         node = doc.CreateNode (XmlNodeType.Element, "Override", ContentNamespace);
 234
 235                                         XmlAttribute name = doc.CreateAttribute ("PartName");
 236                                         name.Value = part.Uri.ToString ();
 237                                         node.Attributes.Append (name);
 238                                 }
 239
 240                                 if (node != null) {
 241                                         XmlAttribute contentType = doc.CreateAttribute ("ContentType");
 242                                         contentType.Value = part.ContentType;
 243                                         node.Attributes.Prepend (contentType);
 244
 245                                         root.AppendChild (node);
 246                                 }
 247                         }
 248
 249                         using (XmlTextWriter writer = new XmlTextWriter (s, System.Text.Encoding.UTF8))
 250                                 doc.WriteTo (writer);
 251                 }
 252         }
 253 }