Fix Android compile: explicit Bionic imports + Bionic-strict pointer signatures

Package.swift

@@ -8,8 +8,15 @@ let targets: [Target] = [
 ]
 #else
 let targets: [Target] = [
-    .systemLibrary(name: "CZLib", pkgConfig: "zlib", providers: [.brew(["zlib"]), .apt(["zlib"])]),
-    .target(name: "ZIPFoundation", dependencies: ["CZLib"], cSettings: [.define("_GNU_SOURCE", to: "1")]),
+    .systemLibrary(
+        name: "CZLib",
+        pkgConfig: "zlib",
+        providers: [.brew(["zlib"]), .apt(["zlib"])]),
+    .target(
+        name: "ZIPFoundation",
+        dependencies: ["CZLib"],
+        cSettings: [.define("_GNU_SOURCE", to: "1")],
+        linkerSettings: [.linkedLibrary("z")]),
     .testTarget(name: "ZIPFoundationTests", dependencies: ["ZIPFoundation"])
 ]
 #endif

Package@swift-5.9.swift

@@ -1,21 +1,8 @@
 // swift-tools-version:5.9
 import PackageDescription
 
-#if canImport(Compression)
-let targets: [Target] = [
-    .target(name: "ZIPFoundation",
-            resources: [
-                .copy("Resources/PrivacyInfo.xcprivacy")
-            ]),
-    .testTarget(name: "ZIPFoundationTests", dependencies: ["ZIPFoundation"])
-]
-#else
-let targets: [Target] = [
-    .systemLibrary(name: "CZLib", pkgConfig: "zlib", providers: [.brew(["zlib"]), .apt(["zlib"])]),
-    .target(name: "ZIPFoundation", dependencies: ["CZLib"], cSettings: [.define("_GNU_SOURCE", to: "1")]),
-    .testTarget(name: "ZIPFoundationTests", dependencies: ["ZIPFoundation"])
-]
-#endif
+let zlibPlatforms: [Platform] = [.linux, .android, .windows]
+let unixZlibPlatforms: [Platform] = [.linux, .android]
 
 let package = Package(
     name: "ZIPFoundation",
@@ -25,6 +12,27 @@ let package = Package(
     products: [
         .library(name: "ZIPFoundation", targets: ["ZIPFoundation"])
     ],
-    targets: targets,
+    targets: [
+        .target(
+            name: "ZIPFoundation",
+            dependencies: [
+                .target(name: "CZLib", condition: .when(platforms: zlibPlatforms))
+            ],
+            resources: [
+                .copy("Resources/PrivacyInfo.xcprivacy")
+            ],
+            cSettings: [
+                .define("_GNU_SOURCE", to: "1", .when(platforms: unixZlibPlatforms))
+            ],
+            linkerSettings: [
+                .linkedLibrary("z", .when(platforms: unixZlibPlatforms)),
+                .linkedLibrary("zlib", .when(platforms: [.windows]))
+            ]),
+        .systemLibrary(
+            name: "CZLib",
+            pkgConfig: "zlib",
+            providers: [.brew(["zlib"]), .apt(["zlib"])]),
+        .testTarget(name: "ZIPFoundationTests", dependencies: ["ZIPFoundation"])
+    ],
     swiftLanguageVersions: [.v4, .v4_2, .v5]
 )

Sources/CZLib/module.modulemap

@@ -10,6 +10,5 @@
 
 module CZlib {
     header "shim.h"
-    link "z"
     export *
 }

Sources/CZLib/shim.h

@@ -8,11 +8,15 @@
 //  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
 //
 
-#ifndef zlib_shim_h 
+#ifndef zlib_shim_h
 #define zlib_shim_h
 
-#import <stdio.h>
-#import <zlib.h>
+// `#include` instead of `#import`: clang on MSVC parses `#import` as
+// the Microsoft type-library directive (not the Apple-style header
+// once-include) and rejects it. `#include` works identically here on
+// every other clang flavour.
+#include <stdio.h>
+#include <zlib.h>
 
 // [zlib] provide 64-bit offset functions if _LARGEFILE64_SOURCE defined
 #ifndef _LARGEFILE64_SOURCE

Sources/ZIPFoundation/Archive+BackingConfiguration.swift

@@ -9,14 +9,17 @@
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
 extension Archive {
 
     struct BackingConfiguration {
         let file: FILEPointer
         let endOfCentralDirectoryRecord: EndOfCentralDirectoryRecord
         let zip64EndOfCentralDirectory: ZIP64EndOfCentralDirectory?
-        #if swift(>=5.0)
+        #if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
         let memoryFile: MemoryFile?
 
         init(file: FILEPointer,
@@ -82,7 +85,7 @@ extension Archive {
         }
     }
 
-    #if swift(>=5.0)
+    #if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
     static func makeBackingConfiguration(for data: Data, mode: AccessMode) throws
     -> BackingConfiguration {
         let memoryFile = MemoryFile(data: data)

Sources/ZIPFoundation/Archive+Deprecated.swift

@@ -2,7 +2,10 @@
 //  Archive+Deprecated.swift
 //  ZIPFoundation
 //
-//  Created by Thomas Zoechling on 06.02.23.
+//  Copyright © 2017-2026 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
+//  Released under the MIT License.
+//
+//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
 //
 
 import Foundation
@@ -14,7 +17,7 @@ public extension Archive {
         try? self.init(url: url, accessMode: mode, pathEncoding: preferredEncoding)
     }
 
-#if swift(>=5.0)
+#if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
     @available(*, deprecated, message: "Please use the throwing initializer.")
     convenience init?(data: Data = Data(), accessMode mode: AccessMode, preferredEncoding: String.Encoding? = nil) {
         try? self.init(data: data, accessMode: mode, pathEncoding: preferredEncoding)

Sources/ZIPFoundation/Archive+MemoryFile.swift

@@ -14,7 +14,10 @@ extension Archive {
     var isMemoryArchive: Bool { return self.url.scheme == memoryURLScheme }
 }
 
-#if swift(>=5.0)
+// In-memory archives rely on a `FILE*`-shaped userspace stream API:
+// `funopen` on Apple, `fopencookie` on Linux glibc. File-backed archives
+// continue to work on platforms without a compatible userspace stream API.
+#if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
 
 extension Archive {
 
@@ -29,7 +32,7 @@ extension Archive {
 
         func open(mode: AccessMode) throws -> FILEPointer {
             let cookie = Unmanaged.passRetained(self)
-            #if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Android)
+            #if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS)
             guard let result = mode.isWritable
                 ? funopen(cookie.toOpaque(), readStub, writeStub, seekStub, closeStub)
                 : funopen(cookie.toOpaque(), readStub, nil, seekStub, closeStub)
@@ -106,7 +109,7 @@ private func closeStub(_ cookie: UnsafeMutableRawPointer?) -> Int32 {
     return 0
 }
 
-#if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Android)
+#if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS)
 
 private func readStub(_ cookie: UnsafeMutableRawPointer?,
                       _ bytePtr: UnsafeMutablePointer<Int8>?,

Sources/ZIPFoundation/Archive+Reading.swift

@@ -9,6 +9,9 @@
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
 extension Archive {
     /// Read a ZIP `Entry` from the receiver and write it to `url`.
@@ -93,7 +96,7 @@ extension Archive {
         var checksum = CRC32(0)
         let localFileHeader = entry.localFileHeader
         guard entry.dataOffset <= .max else { throw ArchiveError.invalidLocalHeaderDataOffset }
-        fseeko(self.archiveFile, off_t(entry.dataOffset), SEEK_SET)
+        fseeko(self.archiveFile, zip_off_t(entry.dataOffset), SEEK_SET)
         progress?.totalUnitCount = self.totalUnitCountForReading(entry)
         switch entry.type {
         case .file:

Sources/ZIPFoundation/Archive+Writing.swift

@@ -9,6 +9,9 @@
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
 extension Archive {
     enum ModifyOperation: Int {
@@ -124,10 +127,10 @@ extension Archive {
         let (eocdRecord, zip64EOCD) = (self.endOfCentralDirectoryRecord, self.zip64EndOfCentralDirectory)
         guard self.offsetToStartOfCentralDirectory <= .max else { throw ArchiveError.invalidCentralDirectoryOffset }
         var startOfCD = Int64(self.offsetToStartOfCentralDirectory)
-        fseeko(self.archiveFile, off_t(startOfCD), SEEK_SET)
+        fseeko(self.archiveFile, zip_off_t(startOfCD), SEEK_SET)
         let existingSize = self.sizeOfCentralDirectory
         let existingData = try Data.readChunk(of: Int(existingSize), from: self.archiveFile)
-        fseeko(self.archiveFile, off_t(startOfCD), SEEK_SET)
+        fseeko(self.archiveFile, zip_off_t(startOfCD), SEEK_SET)
         let fileHeaderStart = Int64(ftello(self.archiveFile))
         guard fileHeaderStart >= 0 else { throw ArchiveError.unwritableArchive }
 
@@ -146,12 +149,12 @@ extension Archive {
             guard startOfCD >= 0 else { throw ArchiveError.unwritableArchive }
 
             // Write the local file header a second time. Now with compressedSize (if applicable) and a valid checksum.
-            fseeko(self.archiveFile, off_t(fileHeaderStart), SEEK_SET)
+            fseeko(self.archiveFile, zip_off_t(fileHeaderStart), SEEK_SET)
             localFileHeader = try self.writeLocalFileHeader(path: path, compressionMethod: compressionMethod,
                                                             size: (UInt64(uncompressedSize), UInt64(written)),
                                                             checksum: checksum, modificationDateTime: modDateTime)
             // Central Directory
-            fseeko(self.archiveFile, off_t(startOfCD), SEEK_SET)
+            fseeko(self.archiveFile, zip_off_t(startOfCD), SEEK_SET)
             _ = try Data.writeLargeChunk(existingData, size: existingSize, bufferSize: bufferSize, to: archiveFile)
             let permissions = permissions ?? (type == .directory ? defaultDirectoryPermissions : defaultFilePermissions)
             let externalAttributes = FileManager.externalFileAttributesForEntry(of: type, permissions: permissions)
@@ -191,7 +194,7 @@ extension Archive {
             let cds = currentEntry.centralDirectoryStructure
             if currentEntry != entry {
                 let entryStart = cds.effectiveRelativeOffsetOfLocalHeader
-                fseeko(self.archiveFile, off_t(entryStart), SEEK_SET)
+                fseeko(self.archiveFile, zip_off_t(entryStart), SEEK_SET)
                 let provider: Provider = { (_, chunkSize) -> Data in
                     return try Data.readChunk(of: chunkSize, from: self.archiveFile)
                 }
@@ -230,7 +233,7 @@ extension Archive {
 
     func replaceCurrentArchive(with archive: Archive) throws {
         if self.isMemoryArchive {
-            #if swift(>=5.0)
+            #if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
             guard let data = archive.data else {
                 throw ArchiveError.unwritableArchive
             }
@@ -280,8 +283,8 @@ private extension Archive {
                   _ bufferSize: Int, _ endOfCentralDirRecord: EndOfCentralDirectoryRecord,
                   _ zip64EndOfCentralDirectory: ZIP64EndOfCentralDirectory?) throws {
         fflush(self.archiveFile)
-        ftruncate(fileno(self.archiveFile), off_t(localFileHeaderStart))
-        fseeko(self.archiveFile, off_t(localFileHeaderStart), SEEK_SET)
+        ftruncate(fileno(self.archiveFile), zip_off_t(localFileHeaderStart))
+        fseeko(self.archiveFile, zip_off_t(localFileHeaderStart), SEEK_SET)
         _ = try Data.writeLargeChunk(existingCentralDirectory.data, size: existingCentralDirectory.size,
                                      bufferSize: bufferSize, to: archiveFile)
         _ = try Data.write(chunk: existingCentralDirectory.data, to: self.archiveFile)
@@ -295,7 +298,7 @@ private extension Archive {
         var archive: Archive
         var url: URL?
         if self.isMemoryArchive {
-            #if swift(>=5.0)
+            #if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
             archive = try Archive(data: Data(), accessMode: .create,
                                   pathEncoding: self.pathEncoding)
             #else

Sources/ZIPFoundation/Archive.swift

@@ -9,6 +9,9 @@
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
 /// The default chunk size when reading entry data from an archive.
 public let defaultReadChunkSize = Int(16*1024)
@@ -187,7 +190,7 @@ public final class Archive: Sequence {
         setvbuf(self.archiveFile, nil, _IOFBF, Int(defaultPOSIXBufferSize))
     }
 
-    #if swift(>=5.0)
+    #if swift(>=5.0) && (os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux))
     var memoryFile: MemoryFile?
 
     /// Initializes a new in-memory ZIP `Archive`.
@@ -287,7 +290,7 @@ public final class Archive: Sequence {
         guard archiveLength >= 0 else { return nil }
 
         while eocdOffset == 0 && index < maxDirectoryEndOffset && index <= archiveLength {
-            fseeko(file, off_t(archiveLength - index), SEEK_SET)
+            fseeko(file, zip_off_t(archiveLength - index), SEEK_SET)
             var potentialDirectoryEndTag: UInt32 = UInt32()
             fread(&potentialDirectoryEndTag, 1, MemoryLayout<UInt32>.size, file)
             if potentialDirectoryEndTag == UInt32(endOfCentralDirectoryStructSignature) {

Sources/ZIPFoundation/Data+Serialization.swift

@@ -9,7 +9,13 @@
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
+// The Swift Android SDK imports `FILE` as opaque; everywhere else
+// (including Windows MSVC, where it's `_iobuf`) it's a typed struct so
+// we can take a typed pointer.
 #if os(Android)
 public typealias FILEPointer = OpaquePointer
 #else
@@ -37,7 +43,7 @@ extension Data {
     static func readStruct<T>(from file: FILEPointer, at offset: UInt64)
     -> T? where T: DataSerializable {
         guard offset <= .max else { return nil }
-        fseeko(file, off_t(offset), SEEK_SET)
+        fseeko(file, zip_off_t(offset), SEEK_SET)
         guard let data = try? self.readChunk(of: T.size, from: file) else {
             return nil
         }

Sources/ZIPFoundation/Date+ZIP.swift

@@ -2,10 +2,16 @@
 //  Date+ZIP.swift
 //  ZIPFoundation
 //
-//  Created by Thomas Zoechling on 20.12.22.
+//  Copyright © 2017-2026 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
+//  Released under the MIT License.
+//
+//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
 //
 
 import Foundation
+#if canImport(Android)
+import Android
+#endif
 
 extension Date {
 
@@ -55,12 +61,14 @@ extension Date {
         self = Date(timeIntervalSince1970: TimeInterval(time))
     }
 
+    #if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux) || os(Android)
     init(timespec: timespec) {
         let seconds = 1.0e-9 * Double(timespec.tv_nsec)
         let timeIntervalSince1970 = TimeInterval(timespec.tv_sec)
         let absoluteTimeIntervalSince1970 = Constants.absoluteTimeIntervalSince1970
         self.init(timeIntervalSinceReferenceDate: (timeIntervalSince1970 - absoluteTimeIntervalSince1970) + seconds)
     }
+    #endif
 }
 
 private extension Date {
@@ -74,6 +82,7 @@ private extension Date {
     }
 }
 
+#if os(macOS) || os(iOS) || os(tvOS) || os(visionOS) || os(watchOS) || os(Linux) || os(Android)
 extension stat {
 
     var lastAccessDate: Date {
@@ -92,3 +101,4 @@ extension timeval {
         self.init(tv_sec: time_t(integral), tv_usec: suseconds_t(1.0e6 * fractional))
     }
 }
+#endif