public void Overwrites()
        {
            var files = new[]
            {
                "a.txt",
                "dir/b.txt"
            };

            var dest   = CreateZip(files);
            var outDir = Path.Combine(_tempDir, "out");

            var task = new UnzipArchive
            {
                File        = dest,
                Destination = outDir,
                BuildEngine = new MockEngine(),
                Overwrite   = true
            };

            Directory.CreateDirectory(outDir);

            // Create a.txt before trying to unzip
            var path = Path.Combine(outDir, "a.txt");

            File.WriteAllText(path, "contents!");
            Assert.True(task.Execute(), "The task failed but should have passed.");
            Assert.Empty(File.ReadAllText(path));
        }
        public void UnzipsSubdirectories()
        {
            var files = new[]
            {
                "a/b/c/d.dll",
                "e/f/j/k/l.json",
                "e/f/m/n/o.json"
            };

            var dest   = CreateZip(files);
            var outDir = Path.Combine(_tempDir, "out");

            var task = new UnzipArchive
            {
                File        = dest,
                Destination = outDir,
                BuildEngine = new MockEngine(),
            };

            Assert.True(task.Execute(), "The task failed but should have passed.");
            Assert.True(Directory.Exists(outDir), outDir + " does not exist");
            Assert.Equal(files.Length, task.OutputFiles.Length);

            Assert.All(task.OutputFiles,
                       f => Assert.True(Path.IsPathRooted(f.ItemSpec), $"Entry {f} should be a fullpath rooted"));

            foreach (var file in files)
            {
                var outFile = Path.Combine(outDir, file);
                Assert.True(File.Exists(outFile), outFile + " does not exist");
            }
        }
        public void DoesNotOverwrite()
        {
            var files = new[]
            {
                "a.txt",
                "dir/b.txt"
            };

            var dest   = CreateZip(files);
            var outDir = Path.Combine(_tempDir, "out");

            var task = new UnzipArchive
            {
                File        = dest,
                Destination = outDir,
                BuildEngine = new MockEngine(),
                Overwrite   = false
            };

            Directory.CreateDirectory(outDir);

            // Create a.txt before trying to unzip
            var path     = Path.Combine(outDir, "a.txt");
            var contents = "contents!";

            File.WriteAllText(path, contents);

            Assert.Throws <IOException>(() => task.Execute());

            Assert.Equal(contents, File.ReadAllText(path));
        }
示例#4
0
        void LoadParts()
        {
            parts = new Dictionary <Uri, ZipPackagePart> (new  UriComparer());
            try
            {
                using (UnzipArchive archive = new UnzipArchive(PackageStream))
                {
                    // Load the content type map file
                    XmlDocument doc = new XmlDocument();
                    using (Stream s = archive.GetStream(ContentUri))
                        doc.Load(s);

                    XmlNamespaceManager manager = new XmlNamespaceManager(doc.NameTable);
                    manager.AddNamespace("content", ContentNamespace);

                    // The file names in the zip archive are not prepended with '/'
                    foreach (string file in archive.GetFiles())
                    {
                        if (file.Equals(ContentUri, StringComparison.Ordinal))
                        {
                            continue;
                        }

                        XmlNode           node;
                        CompressionOption compression = archive.GetCompressionLevel(file);

                        if (file == RelationshipUri.ToString().Substring(1))
                        {
                            CreatePartCore(RelationshipUri, RelationshipContentType, compression);
                            continue;
                        }

                        string xPath = string.Format("/content:Types/content:Override[@PartName='/{0}']", file);
                        node = doc.SelectSingleNode(xPath, manager);

                        if (node == null)
                        {
                            string ext = Path.GetExtension(file);
                            if (ext.StartsWith("."))
                            {
                                ext = ext.Substring(1);
                            }
                            xPath = string.Format("/content:Types/content:Default[@Extension='{0}']", ext);
                            node  = doc.SelectSingleNode(xPath, manager);
                        }

                        // What do i do if the node is null? This means some has tampered with the
                        // package file manually
                        if (node != null)
                        {
                            CreatePartCore(new Uri("/" + file, UriKind.Relative), node.Attributes["ContentType"].Value, compression);
                        }
                    }
                }
            }
            catch
            {
                // The archive is invalid - therefore no parts
            }
        }
示例#5
0
        protected override Stream GetStreamCore(FileMode mode, FileAccess access)
        {
            ZipPartStream zps;
            MemoryStream  stream;

            if (Package.PartStreams.TryGetValue(Uri, out stream))
            {
                zps = new ZipPartStream(Package, stream, access);
                if (mode == FileMode.Create)
                {
                    stream.SetLength(0);
                }
                return(new ZipPartStream(Package, stream, access));
            }

            stream = new MemoryStream();
            try
            {
                using (UnzipArchive archive = new UnzipArchive(Package.PackageStream))
                {
                    foreach (string file in archive.GetFiles())
                    {
                        if (file != Uri.ToString().Substring(1))
                        {
                            continue;
                        }

                        using (Stream archiveStream = archive.GetStream(file))
                        {
                            int    read   = 0;
                            byte[] buffer = new byte [Math.Min(archiveStream.Length, 2 * 1024)];
                            while ((read = archiveStream.Read(buffer, 0, buffer.Length)) != 0)
                            {
                                stream.Write(buffer, 0, read);
                            }
                        }
                    }
                }
            }
            catch
            {
                // The zipfile is invalid, so just create the file
                // as if it didn't exist
                stream.SetLength(0);
            }

            Package.PartStreams.Add(Uri, stream);
            if (mode == FileMode.Create)
            {
                stream.SetLength(0);
            }
            return(new ZipPartStream(Package, stream, access));
        }
        public void ItNormalizesBacklashesInPath()
        {
            var files = new[]
            {
                @"dir\b.txt"
            };

            var dest   = CreateZip(files);
            var outDir = Path.Combine(_tempDir, "out");

            var engine = new MockEngine();
            var task   = new UnzipArchive
            {
                File        = dest,
                Destination = outDir,
                BuildEngine = engine,
                Overwrite   = false
            };

            Assert.True(task.Execute(), "The task failed but should have passed.");
            Assert.True(File.Exists(Path.Combine(outDir, "dir", "b.txt")), "File should exist.");
        }