281 lines
16 KiB
Swift
281 lines
16 KiB
Swift
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
import SwiftUI
|
|
import ImageIO
|
|
import UniformTypeIdentifiers
|
|
import CryptoKit
|
|
|
|
/// Shared by the sidebar and both cover presentations.
|
|
enum SoftwareLibraryCategoryStyle {
|
|
static func symbol(for type: String) -> String {
|
|
switch type {
|
|
case "Games": return "gamecontroller"
|
|
case "Applications": return "macwindow"
|
|
case "Blank Media": return "document"
|
|
case "Hardware": return "airport.extreme"
|
|
case "Operating Systems": return "desktopcomputer.and.arrow.down"
|
|
case "Music": return "music.note"
|
|
case "Educational": return "graduationcap"
|
|
case "Programming": return "curlybraces"
|
|
case "Utilities": return "wrench.and.screwdriver"
|
|
case "Pictures": return "photo.on.rectangle"
|
|
case "Books", "Magazines": return "book"
|
|
case "Demos": return "play.rectangle"
|
|
default: return "books.vertical"
|
|
}
|
|
}
|
|
|
|
static func tint(for type: String) -> Color {
|
|
switch type {
|
|
case "Games": return .indigo
|
|
case "Applications", "Operating Systems": return .blue
|
|
case "Educational": return .teal
|
|
case "Music": return .purple
|
|
case "Programming", "Utilities": return .orange
|
|
default: return .secondary
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Only appearance starts a request. Hosted, fingerprinted PNG thumbnails are
|
|
/// cached locally; originals and PDF manuals never pass through this loader.
|
|
struct SoftwareLibraryArtworkView: View {
|
|
@Environment(\.companionLibraryAccess) private var companion
|
|
let asset: SoftwareLibraryAsset?
|
|
let cacheDirectory: URL
|
|
let softwareType: String
|
|
@State private var image: CGImage?
|
|
@State private var loading = false
|
|
|
|
var body: some View {
|
|
ZStack {
|
|
RoundedRectangle(cornerRadius: 9).fill(.quaternary.opacity(0.35))
|
|
if let image {
|
|
Image(decorative: image, scale: 1).resizable().scaledToFit().padding(5)
|
|
} else {
|
|
VStack(spacing: 12) {
|
|
Image(systemName: SoftwareLibraryCategoryStyle.symbol(for: softwareType))
|
|
.font(.system(size: 48, weight: .light))
|
|
.foregroundStyle(SoftwareLibraryCategoryStyle.tint(for: softwareType).opacity(0.7))
|
|
Text(softwareType == "Other" ? "Software" : softwareType)
|
|
.font(.caption.weight(.medium)).foregroundStyle(.secondary)
|
|
.lineLimit(1).minimumScaleFactor(0.8)
|
|
}.padding(16)
|
|
if loading { ProgressView().controlSize(.small).frame(maxHeight: .infinity, alignment: .bottom).padding(8) }
|
|
}
|
|
}
|
|
.accessibilityElement(children: .ignore)
|
|
.accessibilityLabel(image != nil ? "Artwork: " + (asset?.name ?? "") : softwareType + " category cover")
|
|
.accessibilityValue(image != nil ? "Loaded" : (loading ? "Loading artwork" : "Category illustration"))
|
|
.task(id: asset.map { SoftwareLibraryArtworkCache.cacheKey(for: $0) }) {
|
|
image = nil
|
|
loading = false
|
|
guard let asset else { return }
|
|
loading = true
|
|
defer { loading = false }
|
|
do {
|
|
let data: Data
|
|
if let companion {
|
|
let response = try await companion.libraryRequest(.init(operation: .thumbnail, assetID: asset.id))
|
|
if let message = response.errorMessage { throw CompanionLibraryFailure(message: message) }
|
|
guard let received = response.assetData else { throw SoftwareLibraryArtworkCache.Failure.response }
|
|
data = received
|
|
} else {
|
|
data = try await SoftwareLibraryArtworkCache.shared.thumbnail(for: asset, directory: cacheDirectory)
|
|
}
|
|
try Task.checkCancellation()
|
|
image = SoftwareLibraryArtworkCache.image(from: data)
|
|
} catch { /* Quiet placeholder: art availability never blocks browsing. */ }
|
|
}
|
|
}
|
|
}
|
|
|
|
actor SoftwareLibraryArtworkCache {
|
|
static let shared = SoftwareLibraryArtworkCache()
|
|
static let maximumSourceBytes = 8 * 1024 * 1024
|
|
static let maximumThumbnailBytes = 2 * 1024 * 1024
|
|
static let maximumPixelSize = 640
|
|
private var active = 0
|
|
private let session: URLSession
|
|
|
|
init(session: URLSession? = nil) {
|
|
if let session { self.session = session }
|
|
else {
|
|
let configuration = URLSessionConfiguration.ephemeral
|
|
configuration.timeoutIntervalForRequest = 20
|
|
configuration.timeoutIntervalForResource = 45
|
|
configuration.httpMaximumConnectionsPerHost = 4
|
|
configuration.urlCache = nil
|
|
self.session = URLSession(configuration: configuration, delegate: LibraryArtworkRedirects(), delegateQueue: nil)
|
|
}
|
|
}
|
|
|
|
enum Failure: Error { case unsupported, oversized, response, fingerprint, invalidImage, invalidCache }
|
|
|
|
static func accepts(_ url: URL) -> Bool {
|
|
guard url.scheme?.lowercased() == "https", url.host?.lowercased() == "vccplus.brianholman.com",
|
|
url.user == nil, url.password == nil, url.port == nil || url.port == 443,
|
|
url.path.hasPrefix("/dl/software/CoCoLibrary/Artwork/Thumbnails/"),
|
|
url.pathExtension.lowercased() == "png", url.query == nil, url.fragment == nil,
|
|
!url.path.contains("\\"), !url.pathComponents.contains(".."),
|
|
!url.pathComponents.contains(".") else { return false }
|
|
return true
|
|
}
|
|
|
|
static func canDisplay(_ asset: SoftwareLibraryAsset) -> Bool {
|
|
guard let url = asset.thumbnailURL, accepts(url) || (asset.matchStatus == "personal" && url.isFileURL),
|
|
let checksum = asset.thumbnailSHA256, checksum.count == 64,
|
|
checksum.allSatisfy({ $0.isHexDigit }),
|
|
let size = asset.thumbnailByteSize, size > 0, size <= (asset.matchStatus == "personal" ? Int64(maximumSourceBytes) : Int64(maximumThumbnailBytes)) else { return false }
|
|
return true
|
|
}
|
|
|
|
static func cacheKey(for asset: SoftwareLibraryAsset) -> String {
|
|
let identity = "hosted-thumbnail-v2\n" + (asset.thumbnailURL ?? asset.sourceURL).absoluteString + "\n" + (asset.thumbnailSHA256 ?? "unverified")
|
|
return SHA256.hash(data: Data(identity.utf8)).map { String(format: "%02x", $0) }.joined()
|
|
}
|
|
|
|
static func image(from data: Data) -> CGImage? {
|
|
guard data.count <= maximumThumbnailBytes,
|
|
let source = CGImageSourceCreateWithData(data as CFData, nil),
|
|
let properties = CGImageSourceCopyPropertiesAtIndex(source, 0, nil) as? [CFString: Any],
|
|
let width = properties[kCGImagePropertyPixelWidth] as? Int,
|
|
let height = properties[kCGImagePropertyPixelHeight] as? Int,
|
|
width > 0, height > 0, width <= maximumPixelSize, height <= maximumPixelSize else { return nil }
|
|
return CGImageSourceCreateImageAtIndex(source, 0, [kCGImageSourceShouldCache: false] as CFDictionary)
|
|
}
|
|
|
|
static func downsample(_ data: Data, expectedSHA256: String?) throws -> Data {
|
|
guard data.count <= maximumSourceBytes else { throw Failure.oversized }
|
|
if let expectedSHA256 {
|
|
let actual = SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
|
|
guard actual == expectedSHA256.lowercased() else { throw Failure.fingerprint }
|
|
}
|
|
guard let source = CGImageSourceCreateWithData(data as CFData, [kCGImageSourceShouldCache: false] as CFDictionary),
|
|
let thumbnail = CGImageSourceCreateThumbnailAtIndex(source, 0, [
|
|
kCGImageSourceCreateThumbnailFromImageAlways: true,
|
|
kCGImageSourceCreateThumbnailWithTransform: true,
|
|
kCGImageSourceThumbnailMaxPixelSize: maximumPixelSize,
|
|
kCGImageSourceShouldCacheImmediately: false
|
|
] as CFDictionary) else { throw Failure.invalidImage }
|
|
let output = NSMutableData()
|
|
guard let destination = CGImageDestinationCreateWithData(output, UTType.png.identifier as CFString, 1, nil) else { throw Failure.invalidImage }
|
|
CGImageDestinationAddImage(destination, thumbnail, nil)
|
|
guard CGImageDestinationFinalize(destination), output.length <= maximumThumbnailBytes else { throw Failure.invalidImage }
|
|
return output as Data
|
|
}
|
|
|
|
func thumbnail(for asset: SoftwareLibraryAsset, directory: URL) async throws -> Data {
|
|
if asset.matchStatus == "personal", let url = asset.thumbnailURL, url.isFileURL {
|
|
try SoftwareLibraryLocalAsset.validate(asset, url: url, maximumBytes: Int(Self.maximumSourceBytes))
|
|
return try Self.downsample(Data(contentsOf: url), expectedSHA256: asset.thumbnailSHA256)
|
|
}
|
|
|
|
try Task.checkCancellation()
|
|
guard Self.canDisplay(asset), let url = asset.thumbnailURL,
|
|
let fingerprint = asset.thumbnailSHA256 else { throw Failure.unsupported }
|
|
guard directory.isFileURL else { throw Failure.invalidCache }
|
|
let path = directory.appendingPathComponent(Self.cacheKey(for: asset) + ".png")
|
|
if let cached = cachedThumbnail(path, expectedSHA256: fingerprint) { return cached }
|
|
while active >= 4 {
|
|
try await Task.sleep(nanoseconds: 50_000_000)
|
|
}
|
|
try Task.checkCancellation()
|
|
// Another visible cell may have populated this shared cache while waiting.
|
|
if let cached = cachedThumbnail(path, expectedSHA256: fingerprint) { return cached }
|
|
active += 1
|
|
defer { active -= 1 }
|
|
var request = URLRequest(url: url)
|
|
request.setValue("VCCPlus/SoftwareLibrary-Artwork", forHTTPHeaderField: "User-Agent")
|
|
let (bytes, response) = try await session.bytes(for: request)
|
|
guard let http = response as? HTTPURLResponse, http.statusCode == 200,
|
|
let finalURL = http.url, Self.accepts(finalURL) else { throw Failure.response }
|
|
guard http.expectedContentLength <= Self.maximumThumbnailBytes else { throw Failure.oversized }
|
|
var data = Data()
|
|
data.reserveCapacity(min(max(Int(http.expectedContentLength), 0), Self.maximumThumbnailBytes))
|
|
for try await byte in bytes {
|
|
guard data.count < Self.maximumThumbnailBytes else { throw Failure.oversized }
|
|
data.append(byte)
|
|
if data.count.isMultiple(of: 4096) { try Task.checkCancellation() }
|
|
}
|
|
try Task.checkCancellation()
|
|
guard Int64(data.count) == asset.thumbnailByteSize,
|
|
SHA256.hash(data: data).map({ String(format: "%02x", $0) }).joined() == fingerprint.lowercased()
|
|
else { throw Failure.fingerprint }
|
|
guard Self.image(from: data) != nil else { throw Failure.invalidImage }
|
|
let thumbnail = data
|
|
try Task.checkCancellation()
|
|
// A missing/unwritable cache must not suppress successfully decoded art.
|
|
do {
|
|
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
|
|
guard !((try? path.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink) ?? false) else { throw Failure.invalidCache }
|
|
try thumbnail.write(to: path, options: .atomic)
|
|
trim(directory)
|
|
} catch { }
|
|
return thumbnail
|
|
}
|
|
|
|
private func cachedThumbnail(_ path: URL, expectedSHA256: String) -> Data? {
|
|
guard let values = try? path.resourceValues(forKeys: [.isRegularFileKey, .isSymbolicLinkKey, .fileSizeKey]),
|
|
values.isRegularFile == true, values.isSymbolicLink != true,
|
|
let size = values.fileSize, size <= Self.maximumThumbnailBytes,
|
|
let data = try? Data(contentsOf: path), Self.image(from: data) != nil,
|
|
SHA256.hash(data: data).map({ String(format: "%02x", $0) }).joined() == expectedSHA256.lowercased() else { return nil }
|
|
return data
|
|
}
|
|
|
|
private func trim(_ directory: URL) {
|
|
let keys: Set<URLResourceKey> = [.fileSizeKey, .contentModificationDateKey, .isRegularFileKey, .isSymbolicLinkKey]
|
|
guard let urls = try? FileManager.default.contentsOfDirectory(at: directory, includingPropertiesForKeys: Array(keys)) else { return }
|
|
let entries = urls.compactMap { url -> (URL, Int, Date)? in
|
|
let stem = url.deletingPathExtension().lastPathComponent
|
|
guard url.pathExtension == "png", stem.count == 64, stem.allSatisfy({ $0.isHexDigit }),
|
|
let values = try? url.resourceValues(forKeys: keys), values.isRegularFile == true,
|
|
values.isSymbolicLink != true else { return nil }
|
|
return (url, values.fileSize ?? 0, values.contentModificationDate ?? .distantPast)
|
|
}.sorted { $0.2 < $1.2 }
|
|
var total = entries.reduce(0) { $0 + $1.1 }
|
|
for entry in entries where total > 128 * 1024 * 1024 {
|
|
do { try FileManager.default.removeItem(at: entry.0); total -= entry.1 } catch { }
|
|
}
|
|
}
|
|
}
|
|
|
|
private final class LibraryArtworkRedirects: NSObject, URLSessionTaskDelegate {
|
|
func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse,
|
|
newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
|
|
completionHandler(request.url.map(SoftwareLibraryArtworkCache.accepts) == true ? request : nil)
|
|
}
|
|
}
|
|
|
|
/// Local assets are accepted only from a namespaced private entry's Assets tree.
|
|
/// The public catalog/cache URL allowlists remain unchanged.
|
|
enum SoftwareLibraryLocalAsset {
|
|
static func validate(_ asset: SoftwareLibraryAsset, url: URL, maximumBytes: Int) throws {
|
|
guard asset.matchStatus == "personal", url.isFileURL, url.host == nil || url.host == "localhost",
|
|
url.query == nil, url.fragment == nil, let expected = asset.sha256,
|
|
expected.count == 64, expected.allSatisfy(\.isHexDigit), let size = asset.byteSize,
|
|
size > 0, size <= maximumBytes else { throw SoftwareLibraryManualCache.Failure.unavailable }
|
|
let parts = url.standardizedFileURL.pathComponents
|
|
guard let index = parts.lastIndex(of: "PersonalLibrary"), parts.count > index + 3,
|
|
UUID(uuidString: parts[index + 1]) != nil, parts[index + 2] == "Assets",
|
|
asset.id.hasPrefix("personal:" + parts[index + 1].lowercased() + ":asset:") else { throw SoftwareLibraryManualCache.Failure.unavailable }
|
|
// System parent aliases such as /var are legitimate. The private
|
|
// library root and every component beneath it must be nonsymlink.
|
|
var checked = URL(fileURLWithPath: NSString.path(withComponents: Array(parts.prefix(index))), isDirectory: true)
|
|
for part in parts.dropFirst(index) {
|
|
checked.appendPathComponent(part)
|
|
guard try checked.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink != true else { throw SoftwareLibraryManualCache.Failure.unavailable }
|
|
}
|
|
let values = try url.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey])
|
|
guard values.isRegularFile == true, values.fileSize == Int(size) else { throw SoftwareLibraryManualCache.Failure.changed }
|
|
let handle = try FileHandle(forReadingFrom: url); defer { try? handle.close() }
|
|
var hash = SHA256(), count = 0
|
|
while let block = try handle.read(upToCount: 1024 * 1024), !block.isEmpty {
|
|
try Task.checkCancellation(); count += block.count
|
|
guard count <= maximumBytes else { throw SoftwareLibraryManualCache.Failure.changed }
|
|
hash.update(data: block)
|
|
}
|
|
guard count == Int(size), hash.finalize().map({ String(format: "%02x", $0) }).joined() == expected.lowercased() else { throw SoftwareLibraryManualCache.Failure.changed }
|
|
}
|
|
}
|