Allow access to the LCP License Document even if the status check fails (#647)

Author: mickael-menu

CHANGELOG.md

@@ -2,7 +2,14 @@
 
 All notable changes to this project will be documented in this file. Take a look at [the migration guide](docs/Migration%20Guide.md) to upgrade between two major versions.
 
-<!-- ## [Unreleased] -->
+## [Unreleased]
+
+### Changed
+
+#### LCP
+
+* The LCP License Document is now accessible via `publication.lcpLicense?.license`, even if the license validation fails with a status error. This is useful for checking the end date of an expired license, for example.
+
 
 ## [3.4.0]
 

Sources/LCP/Content Protection/LCPContentProtection.swift

@@ -156,7 +156,7 @@ private final class LCPContentProtectionService: ContentProtectionService {
 
     init(license: LCPLicense? = nil, error: Error? = nil) {
         self.license = license
-        self.error = error
+        self.error = error ?? license?.error.map { LCPError.licenseStatus($0) }
     }
 
     convenience init(result: Result<LCPLicense, LCPError>) {
@@ -179,7 +179,7 @@ private final class LCPContentProtectionService: ContentProtectionService {
     let scheme: ContentProtectionScheme = .lcp
 
     var isRestricted: Bool {
-        license == nil
+        license?.isRestricted ?? true
     }
 
     var rights: UserRights {

Sources/LCP/LCPLicense.swift

@@ -14,6 +14,13 @@ public protocol LCPLicense: UserRights {
     var license: LicenseDocument { get }
     var status: StatusDocument? { get }
 
+    /// The license is restricted if there is a status error.
+    var isRestricted: Bool { get }
+
+    /// Status error detected while validating the license, e.g. if the license
+    /// is expired or revoked.
+    var error: StatusError? { get }
+
     /// Deciphers the given encrypted data to be displayed in the reader.
     func decipher(_ data: Data) throws -> Data?
 

Sources/LCP/License/License.swift

@@ -45,16 +45,31 @@ extension License: LCPLicense {
         documents.status
     }
 
+    public var isRestricted: Bool {
+        error != nil
+    }
+
+    public var error: StatusError? {
+        switch documents.context {
+        case .success:
+            return nil
+        case let .failure(error):
+            return error
+        }
+    }
+
     public var encryptionProfile: String? {
         license.encryption.profile
     }
 
     public func decipher(_ data: Data) throws -> Data? {
-        let context = try documents.getContext()
+        let context = try documents.context.get()
         return client.decrypt(data: data, using: context)
     }
 
     func charactersToCopyLeft() async -> Int? {
+        guard !isRestricted else { return 0 }
+
         do {
             return try await licenses.userRights(for: license.id).copy
         } catch {
@@ -64,13 +79,17 @@ extension License: LCPLicense {
     }
 
     func canCopy(text: String) async -> Bool {
+        guard !isRestricted else { return false }
+
         guard let charactersLeft = await charactersToCopyLeft() else {
             return true
         }
         return text.count <= charactersLeft
     }
 
     func copy(text: String) async -> Bool {
+        guard !isRestricted else { return false }
+
         do {
             var allowed = true
             try await licenses.updateUserRights(for: license.id) { rights in
@@ -94,6 +113,8 @@ extension License: LCPLicense {
     }
 
     func pagesToPrintLeft() async -> Int? {
+        guard !isRestricted else { return 0 }
+
         do {
             return try await licenses.userRights(for: license.id).print
         } catch {
@@ -103,13 +124,17 @@ extension License: LCPLicense {
     }
 
     func canPrint(pageCount: Int) async -> Bool {
+        guard !isRestricted else { return false }
+
         guard let pageLeft = await pagesToPrintLeft() else {
             return true
         }
         return pageCount <= pageLeft
     }
 
     func print(pageCount: Int) async -> Bool {
+        guard !isRestricted else { return false }
+
         do {
             var allowed = true
             try await licenses.updateUserRights(for: license.id) { rights in

Sources/LCP/License/LicenseValidation.swift

@@ -23,28 +23,19 @@ private let supportedProfiles = [
     "http://readium.org/lcp/profile-2.9",
 ]
 
-typealias Context = Either<LCPClientContext, StatusError>
+typealias Context = Result<LCPClientContext, StatusError>
 
 // Holds the License/Status Documents and the DRM context, once validated.
 struct ValidatedDocuments {
     let license: LicenseDocument
-    fileprivate let context: Context
+    let context: Context
     let status: StatusDocument?
 
     fileprivate init(_ license: LicenseDocument, _ context: Context, _ status: StatusDocument? = nil) {
         self.license = license
         self.context = context
         self.status = status
     }
-
-    func getContext() throws -> LCPClientContext {
-        switch context {
-        case let .left(context):
-            return context
-        case let .right(error):
-            throw error
-        }
-    }
 }
 
 /// Validation workflow of the License and Status Documents.
@@ -195,7 +186,7 @@ extension LicenseValidation {
             // 4. Check the dates and license status
             case let (.checkLicenseStatus(license, status, _), .checkedLicenseStatus(error)):
                 if let error = error {
-                    self = .valid(ValidatedDocuments(license, .right(error), status))
+                    self = .valid(ValidatedDocuments(license, .failure(error), status))
                 } else {
                     self = .requestPassphrase(license, status)
                 }
@@ -210,7 +201,7 @@ extension LicenseValidation {
 
             // 6. Validate the license integrity
             case let (.validateIntegrity(license, status, _), .validatedIntegrity(context)):
-                let documents = ValidatedDocuments(license, .left(context), status)
+                let documents = ValidatedDocuments(license, .success(context), status)
                 if let link = status?.link(for: .register) {
                     self = .registerDevice(documents, link)
                 } else {

Sources/LCP/Services/LicensesService.swift

@@ -102,11 +102,6 @@ final class LicensesService: Loggable {
             throw LCPError.missingPassphrase
         }
 
-        // Check the license status error if there's any
-        // Note: Right now we don't want to return a License if it fails the Status check, that's why we attempt to get the DRM context. But it could change if we want to access, for example, the License metadata or perform an LSD interaction, but without being able to decrypt the book. In which case, we could remove this line.
-        // Note2: The License already gets in this state when we perform a `return` successfully. We can't decrypt anymore but we still have access to the License Documents and LSD interactions.
-        _ = try documents.getContext()
-
         return License(documents: documents, client: client, validation: validation, licenses: licenses, device: device, httpClient: httpClient)
     }