coding

iOSClient/Networking/NCNetworkingE2EE.swift

@@ -38,28 +38,23 @@ import NCCommunication
         var fileNameIdentifier = ""
         var key: NSString?
         var initializationVector: NSString?
-        var e2eToken: String?
         
         fileNameFolder = NCUtility.sharedInstance.createFileName(fileNameFolder, serverUrl: serverUrl, account: account)
         if fileNameFolder.count == 0 {
-            self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": Int(0)], errorDescription: "", completion: completion)
+            self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": Int(0)], errorDescription: "", completion: completion)
             return
         }
         fileNameIdentifier = CCUtility.generateRandomIdentifier()
         fileNameFolderUrl = serverUrl + "/" + fileNameIdentifier
        
         guard let directory = NCManageDatabase.sharedInstance.getTableDirectory(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
-            self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": k_CCErrorInternalError], errorDescription: "Directory not found", completion: completion)
+            self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": k_CCErrorInternalError], errorDescription: "Directory not found", completion: completion)
             return
         }
         
-        if let tableLock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: serverUrl) {
-            e2eToken = tableLock.e2eToken
-        }
-        
-        NCCommunication.shared.lockE2EEFolder(fileId: directory.fileId, e2eToken: e2eToken, delete: false) { (account, e2eToken, errorCode, errorDescription) in
+        self.lock(serverUrl: serverUrl, fileId: directory.fileId) { (e2eToken, errorCode, errorDescription) in
+           
             if errorCode == 0 && e2eToken != nil {
-                
                 NCManageDatabase.sharedInstance.setE2ETokenLock(serverUrl: serverUrl, fileId: directory.fileId, e2eToken: e2eToken!)
                 
                 NCCommunication.shared.createFolder(fileNameFolderUrl, addCustomHeaders: ["e2e-token" : e2eToken!]) { (account, ocId, date, errorCode, errorDescription) in
@@ -72,10 +67,8 @@ import NCCommunication
                                 NCManageDatabase.sharedInstance.addMetadata(metadataFolder!)
                                 // Add folder
                                 NCManageDatabase.sharedInstance.addDirectory(encrypted: true, favorite: metadataFolder!.favorite, ocId: metadataFolder!.ocId, fileId: metadataFolder!.fileId, etag: nil, permissions: metadataFolder!.permissions, serverUrl: fileNameFolderUrl, richWorkspace: metadataFolder!.richWorkspace, account: account)
-                                
-                                let fileId = metadataFolder?.fileId
-                                
-                                NCCommunication.shared.markE2EEFolder(fileId: fileId!,delete: false) { (account, errorCode, errorDescription) in
+                                                                
+                                NCCommunication.shared.markE2EEFolder(fileId: metadataFolder!.fileId, delete: false) { (account, errorCode, errorDescription) in
                                     if errorCode == 0 {
                                         
                                         let newobject = tableE2eEncryption()
@@ -106,23 +99,23 @@ import NCCommunication
                                         }
                                         
                                         let _ = NCManageDatabase.sharedInstance.addE2eEncryption(newobject)
-                                        self.sendE2EMetadata(account: account, serverUrl: serverUrl, fileNameRename: nil, fileNameNewRename: nil, url: url) { (errorCode, errorDescription) in
-                                            self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                                        self.sendE2EMetadata(account: account, serverUrl: serverUrl, fileId: directory.fileId, fileNameRename: nil, fileNameNewRename: nil, url: url) { (errorCode, errorDescription) in
+                                            self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
                                         }
                                     } else {
-                                        self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                                        self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
                                     }
                                 }
                             } else {
-                                self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                                self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
                             }
                         }
                     } else {
-                        self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                        self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
                     }
                 }
             } else {
-                self.NotificationPost(name: k_notificationCenter_createFolder, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                self.NotificationPost(name: k_notificationCenter_createFolder, serverUrl: serverUrl, userInfo: ["fileName": fileName, "serverUrl": serverUrl, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
             }
         }
     }
@@ -138,7 +131,7 @@ import NCCommunication
             DispatchQueue.main.async {
                 if error == nil {
                     guard let lock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: directory.serverUrl) else {
-                        self.NotificationPost(name: k_notificationCenter_deleteFile, userInfo: ["metadata": metadata, "errorCode": k_CCErrorInternalError], errorDescription: "Lock not found", completion: completion)
+                        self.NotificationPost(name: k_notificationCenter_deleteFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": k_CCErrorInternalError], errorDescription: "Lock not found", completion: completion)
                         return
                     }
                     NCNetworking.sharedInstance.deleteMetadataPlain(metadata, addCustomHeaders: ["e2e-token" : lock.e2eToken]) { (errorCode, errorDescription) in
@@ -151,11 +144,11 @@ import NCCommunication
                             NCNetworkingEndToEnd.sharedManager().rebuildAndSendMetadata(onServerUrl: directory.serverUrl, account: account, user: user, userID: userID, password: password, url: url)
                         }
                         
-                        self.NotificationPost(name: k_notificationCenter_deleteFile, userInfo: ["metadata": metadata, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
+                        self.NotificationPost(name: k_notificationCenter_deleteFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": errorCode], errorDescription: errorDescription, completion: completion)
                     }
                 } else {
                     
-                    self.NotificationPost(name: k_notificationCenter_deleteFile, userInfo: ["metadata": metadata, "errorCode": error!.code], errorDescription: error?.localizedDescription, completion: completion)
+                    self.NotificationPost(name: k_notificationCenter_deleteFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": error!.code], errorDescription: error?.localizedDescription, completion: completion)
                 }
             }
         }
@@ -168,7 +161,7 @@ import NCCommunication
         // verify if exists the new fileName
         if NCManageDatabase.sharedInstance.getE2eEncryption(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@ AND fileName == %@", metadata.account, metadata.serverUrl, fileNameNew)) != nil {
             
-            self.NotificationPost(name: k_notificationCenter_renameFile, userInfo: ["metadata": metadata, "errorCode": Int(k_CCErrorInternalError)], errorDescription: "_file_already_exists_", completion: completion)
+            self.NotificationPost(name: k_notificationCenter_renameFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": Int(k_CCErrorInternalError)], errorDescription: "_file_already_exists_", completion: completion)
 
         } else {
             
@@ -176,7 +169,7 @@ import NCCommunication
                 
                 if let error = NCNetworkingEndToEnd.sharedManager()?.sendMetadata(onServerUrl: metadata.serverUrl, fileNameRename: metadata.fileName, fileNameNewRename: fileNameNew, unlock: false, account: metadata.account, user: user, userID: userID, password: password, url: url) as NSError? {
                     
-                    self.NotificationPost(name: k_notificationCenter_renameFile, userInfo: ["metadata": metadata, "errorCode": error.code], errorDescription: error.localizedDescription, completion: completion)
+                    self.NotificationPost(name: k_notificationCenter_renameFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": error.code], errorDescription: error.localizedDescription, completion: completion)
                     
                 } else {
                     NCManageDatabase.sharedInstance.setMetadataFileNameView(serverUrl: metadata.serverUrl, fileName: metadata.fileName, newFileNameView: fileNameNew, account: metadata.account)
@@ -193,91 +186,107 @@ import NCCommunication
                         try FileManager.default.moveItem(atPath: atPathIcon, toPath: toPathIcon)
                     } catch { }
                     
-                    self.NotificationPost(name: k_notificationCenter_renameFile, userInfo: ["metadata": metadata, "errorCode": Int(0)], errorDescription: "", completion: completion)
+                    self.NotificationPost(name: k_notificationCenter_renameFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": Int(0)], errorDescription: "", completion: completion)
                 }
                 
                 // UNLOCK
                 if let tableLock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: metadata.serverUrl) {
                     if let error = NCNetworkingEndToEnd.sharedManager()?.unlockFolderEncrypted(onServerUrl: metadata.serverUrl, fileId: directory.fileId, e2eToken: tableLock.e2eToken, user: user, userID: userID, password: password, url: url) as NSError? {
                         
-                        self.NotificationPost(name: k_notificationCenter_renameFile, userInfo: ["metadata": metadata, "errorCode": error.code], errorDescription: error.localizedDescription, completion: completion)
+                        self.NotificationPost(name: k_notificationCenter_renameFile, serverUrl: metadata.serverUrl, userInfo: ["metadata": metadata, "errorCode": error.code], errorDescription: error.localizedDescription, completion: completion)
                     }
                 }
             }
         }
     }
     
-    //MARK: - Metadata
+    //MARK: - E2EE
     
-    private func sendE2EMetadata(account: String, serverUrl: String, fileNameRename: String?, fileNameNewRename: String?, url: String, completion: @escaping (_ errorCode: Int, _ errorDescription: String?)->()) {
+    private func lock(serverUrl: String, fileId: String, completion: @escaping (_ e2eToken: String?, _ errorCode: Int, _ errorDescription: String?)->()) {
         
         var e2eToken: String?
-        var method = ""
         
-        guard let directory = NCManageDatabase.sharedInstance.getTableDirectory(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
-            completion(Int(k_CCErrorInternalError), NSLocalizedString("_internal_generic_error_", comment: ""))
-            return
+        if let tableLock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: serverUrl) {
+            e2eToken = tableLock.e2eToken
         }
-        let fileId = directory.fileId
         
-        if CCUtility.isEnd(toEndEnabled: account) == false {
-            completion(Int(k_CCErrorInternalError), NSLocalizedString("_e2e_error_not_enabled_", comment: ""))
-            return
+        NCCommunication.shared.lockE2EEFolder(fileId: fileId, e2eToken: e2eToken, delete: false) { (account, e2eToken, errorCode, errorDescription) in
+            if errorCode == 0 && e2eToken != nil {
+                NCManageDatabase.sharedInstance.setE2ETokenLock(serverUrl: serverUrl, fileId: fileId, e2eToken: e2eToken!)
+            }
+            completion(e2eToken, errorCode, errorDescription)
         }
+    }
+    
+    private func unlock(serverUrl: String, fileId: String, completion: @escaping (_ errorCode: Int, _ errorDescription: String?)->()) {
+        
+        var e2eToken: String?
         
         if let tableLock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: serverUrl) {
             e2eToken = tableLock.e2eToken
         }
         
-        NCCommunication.shared.getE2EEMetadata(fileId: fileId, e2eToken: nil) { (account, existsMetadata, errorCode, errorDescription) in
-                
-            if (fileNameRename != nil && fileNameNewRename != nil) {
-                NCManageDatabase.sharedInstance.renameFileE2eEncryption(serverUrl: serverUrl, fileNameIdentifier: fileNameRename!, newFileName: fileNameNewRename!, newFileNamePath: CCUtility.returnFileNamePath(fromFileName: fileNameNewRename!, serverUrl: serverUrl, activeUrl: url))
-            }
-                
-            guard let tableE2eEncryption = NCManageDatabase.sharedInstance.getE2eEncryptions(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
-                completion(Int(k_CCErrorInternalError), NSLocalizedString("_e2e_error_record_not_found_", comment: ""))
-                return
-            }
-            guard let metadata = NCEndToEndMetadata.sharedInstance.encoderMetadata(tableE2eEncryption, privateKey: CCUtility.getEndToEndPrivateKey(account), serverUrl: serverUrl) else {
-                completion(Int(k_CCErrorInternalError), NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
-                return
+        NCCommunication.shared.lockE2EEFolder(fileId: fileId, e2eToken: e2eToken, delete: true) { (account, e2eToken, errorCode, errorDescription) in
+            if errorCode == 0 {
+                NCManageDatabase.sharedInstance.deteleE2ETokenLock(serverUrl: serverUrl)
             }
+            completion(errorCode, errorDescription)
+        }
+    }
+    
+    private func sendE2EMetadata(account: String, serverUrl: String, fileId: String, fileNameRename: String?, fileNameNewRename: String?, url: String, completion: @escaping (_ errorCode: Int, _ errorDescription: String?)->()) {
+    
+        self.lock(serverUrl: serverUrl, fileId: fileId) { (e2eToken, errorCode, errorDescription) in
             
-            if errorCode == 0 && existsMetadata != nil {
-                method = "PUT"
-            } else if  errorCode == 404 {
-                method = "POST"
-            } else {
-                completion(errorCode, errorDescription)
-            }
+            if errorCode == 0 && e2eToken != nil {
             
-            NCCommunication.shared.lockE2EEFolder(fileId: fileId, e2eToken: e2eToken, delete: false) { (account, e2eToken, errorCode, errorDescription) in
-                if errorCode == 0 && e2eToken != nil {
-                    NCManageDatabase.sharedInstance.setE2ETokenLock(serverUrl: serverUrl, fileId: fileId, e2eToken: e2eToken!)
+                NCCommunication.shared.getE2EEMetadata(fileId: fileId, e2eToken: e2eToken) { (account, existsMetadata, errorCode, errorDescription) in
+                
+                    if (fileNameRename != nil && fileNameNewRename != nil) {
+                        NCManageDatabase.sharedInstance.renameFileE2eEncryption(serverUrl: serverUrl, fileNameIdentifier: fileNameRename!, newFileName: fileNameNewRename!, newFileNamePath: CCUtility.returnFileNamePath(fromFileName: fileNameNewRename!, serverUrl: serverUrl, activeUrl: url))
+                    }
+                
+                    guard let tableE2eEncryption = NCManageDatabase.sharedInstance.getE2eEncryptions(predicate: NSPredicate(format: "account == %@ AND serverUrl == %@", account, serverUrl)) else {
+                        completion(Int(k_CCErrorInternalError), NSLocalizedString("_e2e_error_record_not_found_", comment: ""))
+                        return
+                    }
+                    guard let metadata = NCEndToEndMetadata.sharedInstance.encoderMetadata(tableE2eEncryption, privateKey: CCUtility.getEndToEndPrivateKey(account), serverUrl: serverUrl) else {
+                        completion(Int(k_CCErrorInternalError), NSLocalizedString("_e2e_error_encode_metadata_", comment: ""))
+                        return
+                    }
+            
+                    var method = ""
+                    if errorCode == 0 && existsMetadata != nil {
+                        method = "PUT"
+                    } else if  errorCode == 404 {
+                        method = "POST"
+                    } else {
+                        completion(errorCode, errorDescription)
+                    }
+               
                     NCCommunication.shared.putE2EEMetadata(fileId: fileId, e2eToken: e2eToken!, method: method, metadata: metadata) { (account, metadata, errorCodeSendMetadata, errorDescriptionSendMetadata) in
-                        NCCommunication.shared.lockE2EEFolder(fileId: fileId, e2eToken: e2eToken, delete: true) { (account, e2eToken, errorCode, errorDescription) in
-                            if errorCode == 0 { NCManageDatabase.sharedInstance.deteleE2ETokenLock(serverUrl: serverUrl) }
-                            if errorCodeSendMetadata != 0 {
-                                completion(errorCodeSendMetadata, errorDescriptionSendMetadata)
-                            } else {
-                                completion(errorCode, errorDescription)
-                            }
-                        }
+                        
+                        self.unlock(serverUrl: serverUrl, fileId: fileId) { (errorCode, errorDescription) in }
+                        completion(errorCode, errorDescription)
                     }
-                } else {
-                    completion(errorCode, errorDescription)
                 }
+            } else {
+                completion(errorCode, errorDescription)
             }
         }
     }
     
     //MARK: - Notification Post
        
-    private func NotificationPost(name: String, userInfo: [AnyHashable : Any], errorDescription: Any?, completion: @escaping (_ errorCode: Int, _ errorDescription: String)->()) {
+    private func NotificationPost(name: String, serverUrl: String, userInfo: [AnyHashable : Any], errorDescription: Any?, completion: @escaping (_ errorCode: Int, _ errorDescription: String)->()) {
         var userInfo = userInfo
         DispatchQueue.main.async {
-               
+            
+            // unlock
+            if let tableLock = NCManageDatabase.sharedInstance.getE2ETokenLock(serverUrl: serverUrl) {
+                NCCommunication.shared.lockE2EEFolder(fileId: tableLock.fileId, e2eToken: tableLock.e2eToken, delete: true) { (_, _, _, _) in }
+            }
+            
             if errorDescription == nil { userInfo["errorDescription"] = "" }
             else { userInfo["errorDescription"] = NSLocalizedString(errorDescription as! String, comment: "") }