Improved symlinks support

Author: p.volkhin

Sources/ZIPFoundation/Archive+Helpers.swift

@@ -42,6 +42,27 @@ extension Archive {
                                    })
     }
 
+    func readSymbolicLink(entry: Entry, bufferSize: Int, skipCRC32: Bool,
+                          progress: Progress? = nil, with consumer: Consumer) throws -> CRC32 {
+        var checksum = CRC32(0)
+        let localFileHeader = entry.localFileHeader
+        guard let compressionMethod = CompressionMethod(rawValue: entry.localFileHeader.compressionMethod) else {
+            throw ArchiveError.invalidCompressionMethod
+        }
+        switch compressionMethod {
+        case .none:
+            let localFileHeader = entry.localFileHeader
+            let size = Int(localFileHeader.compressedSize)
+            let data = try Data.readChunk(of: size, from: self.archiveFile)
+            checksum = data.crc32(checksum: 0)
+            try consumer(data)
+            progress?.completedUnitCount = self.totalUnitCountForReading(entry)
+        case .deflate: checksum = try self.readCompressed(entry: entry, bufferSize: bufferSize,
+                                                          skipCRC32: skipCRC32, progress: progress, with: consumer)
+        }
+        return checksum
+    }
+
     // MARK: - Writing
 
     func writeEntry(uncompressedSize: Int64, type: Entry.EntryType,

Sources/ZIPFoundation/Archive+Reading.swift

@@ -18,12 +18,14 @@ extension Archive {
     ///   - url: The destination file URL.
     ///   - bufferSize: The maximum size of the read buffer and the decompression buffer (if needed).
     ///   - skipCRC32: Optional flag to skip calculation of the CRC32 checksum to improve performance.
+    ///   - symlinksValidWithin: Symbolic links are valid within the url
     ///   - allowUncontainedSymlinks: Optional flag to allow symlinks that point to paths outside the destination.
     ///   - progress: A progress object that can be used to track or cancel the extract operation.
     /// - Returns: The checksum of the processed content or 0 if the `skipCRC32` flag was set to `true`.
     /// - Throws: An error if the destination file cannot be written or the entry contains malformed content.
     public func extract(_ entry: Entry, to url: URL, bufferSize: Int = defaultReadChunkSize,
-                        skipCRC32: Bool = false, allowUncontainedSymlinks: Bool = false,
+                        skipCRC32: Bool = false,
+                        symlinksValidWithin: URL? = nil, allowUncontainedSymlinks: Bool = false,
                         progress: Progress? = nil) throws -> CRC32 {
         guard bufferSize > 0 else {
             throw ArchiveError.invalidBufferSize
@@ -60,7 +62,7 @@ extension Archive {
                 let parentURL = url.deletingLastPathComponent()
                 let isAbsolutePath = (linkPath as NSString).isAbsolutePath
                 let linkURL = URL(fileURLWithPath: linkPath, relativeTo: isAbsolutePath ? nil : parentURL)
-                let isContained = allowUncontainedSymlinks || linkURL.isContained(in: parentURL)
+                let isContained = allowUncontainedSymlinks || linkURL.isContained(in: symlinksValidWithin ?? parentURL)
                 guard isContained else { throw ArchiveError.uncontainedSymlink }
 
                 try fileManager.createParentDirectoryStructure(for: url)
@@ -108,12 +110,9 @@ extension Archive {
             try consumer(Data())
             progress?.completedUnitCount = self.totalUnitCountForReading(entry)
         case .symlink:
-            let localFileHeader = entry.localFileHeader
-            let size = Int(localFileHeader.compressedSize)
-            let data = try Data.readChunk(of: size, from: self.archiveFile)
-            checksum = data.crc32(checksum: 0)
-            try consumer(data)
-            progress?.completedUnitCount = self.totalUnitCountForReading(entry)
+            checksum = try self.readSymbolicLink(entry: entry, bufferSize: bufferSize,
+                                                 skipCRC32: skipCRC32, progress: progress, with: consumer)
+
         }
         return checksum
     }

Sources/ZIPFoundation/FileManager+ZIP.swift

@@ -117,11 +117,15 @@ extension FileManager {
                 let entryProgress = archive.makeProgressForReading(entry)
                 progress.addChild(entryProgress, withPendingUnitCount: entryProgress.totalUnitCount)
                 crc32 = try archive.extract(entry, to: entryURL,
-                                            skipCRC32: skipCRC32, allowUncontainedSymlinks: allowUncontainedSymlinks,
+                                            skipCRC32: skipCRC32,
+                                            symlinksValidWithin: destinationURL,
+                                            allowUncontainedSymlinks: allowUncontainedSymlinks,
                                             progress: entryProgress)
             } else {
                 crc32 = try archive.extract(entry, to: entryURL,
-                                            skipCRC32: skipCRC32, allowUncontainedSymlinks: allowUncontainedSymlinks)
+                                            skipCRC32: skipCRC32,
+                                            symlinksValidWithin: destinationURL,
+                                            allowUncontainedSymlinks: allowUncontainedSymlinks)
             }
 
             func verifyChecksumIfNecessary() throws {

Tests/ZIPFoundationTests/Resources/testUnzipCompressedSymlink.zip

@@ -100,6 +100,34 @@ extension ZIPFoundationTests {
         }
     }
 
+    func testUnzipSymlink() {
+        // stored by zip 3.0 via command line: zip -ry
+        //
+        // testUnzipSymlink.zip/
+        //   ├─ directory1
+        //     ├─ testUnzipSymlink
+        //   ├─ directory2
+        //     ├─ testUnzipSymlink.png
+        do {
+            try unarchiveZIP64Item(for: #function)
+        } catch {
+            XCTFail("\(error)")
+        }
+    }
+
+    func testUnzipCompressedSymlink() {
+        // testUnzipCompressedSymlink.zip/
+        //   ├─ directory1
+        //     ├─ testUnzipSymlink (compressed)
+        //   ├─ directory2
+        //     ├─ testUnzipSymlink.png
+        do {
+            try unarchiveZIP64Item(for: #function)
+        } catch {
+            XCTFail("\(error)")
+        }
+    }
+
     // MARK: - Helpers
 
     private func archiveZIP64Item(for testFunction: String, compressionMethod: CompressionMethod) throws {

Tests/ZIPFoundationTests/Resources/testUnzipSymlink.zip

@@ -289,7 +289,9 @@ extension ZIPFoundationTests {
             ("testWriteLargeChunk", testWriteLargeChunk),
             ("testExtractUncompressedZIP64Entries", testExtractUncompressedZIP64Entries),
             ("testExtractCompressedZIP64Entries", testExtractCompressedZIP64Entries),
-            ("testExtractEntryWithZIP64DataDescriptor", testExtractEntryWithZIP64DataDescriptor)
+            ("testExtractEntryWithZIP64DataDescriptor", testExtractEntryWithZIP64DataDescriptor),
+            ("testUnzipSymlink", testUnzipSymlink),
+            ("testUnzipCompressedSymlink", testUnzipCompressedSymlink)
         ]
     }