mirror of https://github.com/nextcloud/android
359 lines
15 KiB
Java
359 lines
15 KiB
Java
/*
|
|
* ownCloud Android client application
|
|
*
|
|
* @author David A. Velasco
|
|
* @author masensio
|
|
* Copyright (C) 2015 ownCloud Inc.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2,
|
|
* as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
package com.owncloud.android.operations;
|
|
|
|
import android.content.Context;
|
|
import android.util.Pair;
|
|
|
|
import com.nextcloud.client.account.User;
|
|
import com.owncloud.android.datamodel.ArbitraryDataProvider;
|
|
import com.owncloud.android.datamodel.ArbitraryDataProviderImpl;
|
|
import com.owncloud.android.datamodel.DecryptedFolderMetadata;
|
|
import com.owncloud.android.datamodel.EncryptedFolderMetadata;
|
|
import com.owncloud.android.datamodel.FileDataStorageManager;
|
|
import com.owncloud.android.datamodel.OCFile;
|
|
import com.owncloud.android.lib.common.OwnCloudClient;
|
|
import com.owncloud.android.lib.common.operations.OnRemoteOperationListener;
|
|
import com.owncloud.android.lib.common.operations.RemoteOperation;
|
|
import com.owncloud.android.lib.common.operations.RemoteOperationResult;
|
|
import com.owncloud.android.lib.common.utils.Log_OC;
|
|
import com.owncloud.android.lib.resources.e2ee.ToggleEncryptionRemoteOperation;
|
|
import com.owncloud.android.lib.resources.files.CreateFolderRemoteOperation;
|
|
import com.owncloud.android.lib.resources.files.ReadFolderRemoteOperation;
|
|
import com.owncloud.android.lib.resources.files.model.RemoteFile;
|
|
import com.owncloud.android.operations.common.SyncOperation;
|
|
import com.owncloud.android.utils.EncryptionUtils;
|
|
import com.owncloud.android.utils.FileStorageUtils;
|
|
import com.owncloud.android.utils.MimeType;
|
|
|
|
import java.io.File;
|
|
import java.util.UUID;
|
|
|
|
import androidx.annotation.NonNull;
|
|
|
|
import static com.owncloud.android.datamodel.OCFile.PATH_SEPARATOR;
|
|
import static com.owncloud.android.datamodel.OCFile.ROOT_PATH;
|
|
|
|
/**
|
|
* Access to remote operation performing the creation of a new folder in the ownCloud server.
|
|
* Save the new folder in Database.
|
|
*/
|
|
public class CreateFolderOperation extends SyncOperation implements OnRemoteOperationListener {
|
|
|
|
private static final String TAG = CreateFolderOperation.class.getSimpleName();
|
|
|
|
protected String remotePath;
|
|
private RemoteFile createdRemoteFolder;
|
|
private User user;
|
|
private Context context;
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
public CreateFolderOperation(String remotePath, User user, Context context, FileDataStorageManager storageManager) {
|
|
super(storageManager);
|
|
|
|
this.remotePath = remotePath;
|
|
this.user = user;
|
|
this.context = context;
|
|
}
|
|
|
|
@Override
|
|
protected RemoteOperationResult run(OwnCloudClient client) {
|
|
String remoteParentPath = new File(getRemotePath()).getParent();
|
|
remoteParentPath = remoteParentPath.endsWith(PATH_SEPARATOR) ?
|
|
remoteParentPath : remoteParentPath + PATH_SEPARATOR;
|
|
|
|
OCFile parent = getStorageManager().getFileByDecryptedRemotePath(remoteParentPath);
|
|
|
|
String tempRemoteParentPath = remoteParentPath;
|
|
while (parent == null) {
|
|
tempRemoteParentPath = new File(tempRemoteParentPath).getParent();
|
|
|
|
if (!tempRemoteParentPath.endsWith(PATH_SEPARATOR)) {
|
|
tempRemoteParentPath = tempRemoteParentPath + PATH_SEPARATOR;
|
|
}
|
|
|
|
parent = getStorageManager().getFileByDecryptedRemotePath(tempRemoteParentPath);
|
|
}
|
|
|
|
// check if any parent is encrypted
|
|
boolean encryptedAncestor = FileStorageUtils.checkEncryptionStatus(parent, getStorageManager());
|
|
|
|
if (encryptedAncestor) {
|
|
return encryptedCreate(parent, client);
|
|
} else {
|
|
return normalCreate(client);
|
|
}
|
|
}
|
|
|
|
private RemoteOperationResult encryptedCreate(OCFile parent, OwnCloudClient client) {
|
|
ArbitraryDataProvider arbitraryDataProvider = new ArbitraryDataProviderImpl(context);
|
|
String privateKey = arbitraryDataProvider.getValue(user.getAccountName(), EncryptionUtils.PRIVATE_KEY);
|
|
String publicKey = arbitraryDataProvider.getValue(user.getAccountName(), EncryptionUtils.PUBLIC_KEY);
|
|
|
|
String token = null;
|
|
Boolean metadataExists;
|
|
DecryptedFolderMetadata metadata;
|
|
String encryptedRemotePath = null;
|
|
|
|
String filename = new File(remotePath).getName();
|
|
|
|
try {
|
|
// lock folder
|
|
token = EncryptionUtils.lockFolder(parent, client);
|
|
|
|
// get metadata
|
|
Pair<Boolean, DecryptedFolderMetadata> metadataPair = EncryptionUtils.retrieveMetadata(parent,
|
|
client,
|
|
privateKey,
|
|
publicKey,
|
|
arbitraryDataProvider,
|
|
user);
|
|
|
|
metadataExists = metadataPair.first;
|
|
metadata = metadataPair.second;
|
|
|
|
// check if filename already exists
|
|
if (isFileExisting(metadata, filename)) {
|
|
return new RemoteOperationResult(RemoteOperationResult.ResultCode.FOLDER_ALREADY_EXISTS);
|
|
}
|
|
|
|
// generate new random file name, check if it exists in metadata
|
|
String encryptedFileName = createRandomFileName(metadata);
|
|
encryptedRemotePath = parent.getRemotePath() + encryptedFileName;
|
|
|
|
RemoteOperationResult result = new CreateFolderRemoteOperation(encryptedRemotePath,
|
|
true,
|
|
token)
|
|
.execute(client);
|
|
|
|
if (result.isSuccess()) {
|
|
// update metadata
|
|
metadata.getFiles().put(encryptedFileName, createDecryptedFile(filename));
|
|
|
|
EncryptedFolderMetadata encryptedFolderMetadata = EncryptionUtils.encryptFolderMetadata(metadata,
|
|
privateKey,
|
|
publicKey,
|
|
arbitraryDataProvider,
|
|
user,
|
|
parent.getLocalId());
|
|
String serializedFolderMetadata = EncryptionUtils.serializeJSON(encryptedFolderMetadata);
|
|
|
|
// upload metadata
|
|
EncryptionUtils.uploadMetadata(parent,
|
|
serializedFolderMetadata,
|
|
token,
|
|
client,
|
|
metadataExists);
|
|
|
|
// unlock folder
|
|
if (token != null) {
|
|
RemoteOperationResult unlockFolderResult = EncryptionUtils.unlockFolder(parent, client, token);
|
|
|
|
if (unlockFolderResult.isSuccess()) {
|
|
token = null;
|
|
} else {
|
|
// TODO do better
|
|
throw new RuntimeException("Could not unlock folder!");
|
|
}
|
|
}
|
|
|
|
RemoteOperationResult remoteFolderOperationResult = new ReadFolderRemoteOperation(encryptedRemotePath)
|
|
.execute(client);
|
|
|
|
createdRemoteFolder = (RemoteFile) remoteFolderOperationResult.getData().get(0);
|
|
OCFile newDir = createRemoteFolderOcFile(parent, filename, createdRemoteFolder);
|
|
getStorageManager().saveFile(newDir);
|
|
|
|
RemoteOperationResult encryptionOperationResult = new ToggleEncryptionRemoteOperation(
|
|
newDir.getLocalId(),
|
|
newDir.getRemotePath(),
|
|
true)
|
|
.execute(client);
|
|
|
|
if (!encryptionOperationResult.isSuccess()) {
|
|
throw new RuntimeException("Error creating encrypted subfolder!");
|
|
}
|
|
} else {
|
|
// revert to sane state in case of any error
|
|
Log_OC.e(TAG, remotePath + " hasn't been created");
|
|
}
|
|
|
|
return result;
|
|
} catch (Exception e) {
|
|
if (!EncryptionUtils.unlockFolder(parent, client, token).isSuccess()) {
|
|
throw new RuntimeException("Could not clean up after failing folder creation!", e);
|
|
}
|
|
|
|
// remove folder
|
|
if (encryptedRemotePath != null) {
|
|
RemoteOperationResult removeResult = new RemoveRemoteEncryptedFileOperation(encryptedRemotePath,
|
|
parent.getLocalId(),
|
|
user,
|
|
context,
|
|
filename).execute(client);
|
|
|
|
if (!removeResult.isSuccess()) {
|
|
throw new RuntimeException("Could not clean up after failing folder creation!");
|
|
}
|
|
}
|
|
|
|
// TODO do better
|
|
return new RemoteOperationResult(e);
|
|
} finally {
|
|
// unlock folder
|
|
if (token != null) {
|
|
RemoteOperationResult unlockFolderResult = EncryptionUtils.unlockFolder(parent, client, token);
|
|
|
|
if (!unlockFolderResult.isSuccess()) {
|
|
// TODO do better
|
|
throw new RuntimeException("Could not unlock folder!");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isFileExisting(DecryptedFolderMetadata metadata, String filename) {
|
|
for (String key : metadata.getFiles().keySet()) {
|
|
DecryptedFolderMetadata.DecryptedFile file = metadata.getFiles().get(key);
|
|
|
|
if (file != null && filename.equalsIgnoreCase(file.getEncrypted().getFilename())) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@NonNull
|
|
private OCFile createRemoteFolderOcFile(OCFile parent, String filename, RemoteFile remoteFolder) {
|
|
OCFile newDir = new OCFile(remoteFolder.getRemotePath());
|
|
|
|
newDir.setMimeType(MimeType.DIRECTORY);
|
|
newDir.setParentId(parent.getFileId());
|
|
newDir.setRemoteId(remoteFolder.getRemoteId());
|
|
newDir.setModificationTimestamp(System.currentTimeMillis());
|
|
newDir.setEncrypted(true);
|
|
newDir.setPermissions(remoteFolder.getPermissions());
|
|
newDir.setDecryptedRemotePath(parent.getDecryptedRemotePath() + filename + "/");
|
|
|
|
return newDir;
|
|
}
|
|
|
|
@NonNull
|
|
private DecryptedFolderMetadata.DecryptedFile createDecryptedFile(String filename) {
|
|
// Key, always generate new one
|
|
byte[] key = EncryptionUtils.generateKey();
|
|
|
|
// IV, always generate new one
|
|
byte[] iv = EncryptionUtils.randomBytes(EncryptionUtils.ivLength);
|
|
|
|
DecryptedFolderMetadata.DecryptedFile decryptedFile = new DecryptedFolderMetadata.DecryptedFile();
|
|
DecryptedFolderMetadata.Data data = new DecryptedFolderMetadata.Data();
|
|
data.setFilename(filename);
|
|
data.setMimetype(MimeType.WEBDAV_FOLDER);
|
|
data.setKey(EncryptionUtils.encodeBytesToBase64String(key));
|
|
|
|
decryptedFile.setEncrypted(data);
|
|
decryptedFile.setInitializationVector(EncryptionUtils.encodeBytesToBase64String(iv));
|
|
|
|
return decryptedFile;
|
|
}
|
|
|
|
@NonNull
|
|
private String createRandomFileName(DecryptedFolderMetadata metadata) {
|
|
String encryptedFileName = UUID.randomUUID().toString().replaceAll("-", "");
|
|
|
|
while (metadata.getFiles().get(encryptedFileName) != null) {
|
|
encryptedFileName = UUID.randomUUID().toString().replaceAll("-", "");
|
|
}
|
|
return encryptedFileName;
|
|
}
|
|
|
|
private RemoteOperationResult normalCreate(OwnCloudClient client) {
|
|
RemoteOperationResult result = new CreateFolderRemoteOperation(remotePath, true).execute(client);
|
|
|
|
if (result.isSuccess()) {
|
|
RemoteOperationResult remoteFolderOperationResult = new ReadFolderRemoteOperation(remotePath)
|
|
.execute(client);
|
|
|
|
createdRemoteFolder = (RemoteFile) remoteFolderOperationResult.getData().get(0);
|
|
saveFolderInDB();
|
|
} else {
|
|
Log_OC.e(TAG, remotePath + " hasn't been created");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
@Override
|
|
public void onRemoteOperationFinish(RemoteOperation operation, RemoteOperationResult result) {
|
|
if (operation instanceof CreateFolderRemoteOperation) {
|
|
onCreateRemoteFolderOperationFinish(result);
|
|
}
|
|
}
|
|
|
|
private void onCreateRemoteFolderOperationFinish(RemoteOperationResult result) {
|
|
if (result.isSuccess()) {
|
|
saveFolderInDB();
|
|
} else {
|
|
Log_OC.e(TAG, remotePath + " hasn't been created");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save new directory in local database.
|
|
*/
|
|
private void saveFolderInDB() {
|
|
if (getStorageManager().getFileByPath(FileStorageUtils.getParentPath(remotePath)) == null) {
|
|
// When parent of remote path is not created
|
|
String[] subFolders = remotePath.split(PATH_SEPARATOR);
|
|
String composedRemotePath = ROOT_PATH;
|
|
|
|
// For each ancestor folders create them recursively
|
|
for (String subFolder : subFolders) {
|
|
if (!subFolder.isEmpty()) {
|
|
composedRemotePath = composedRemotePath + subFolder + PATH_SEPARATOR;
|
|
remotePath = composedRemotePath;
|
|
saveFolderInDB();
|
|
}
|
|
}
|
|
} else { // Create directory on DB
|
|
OCFile newDir = new OCFile(remotePath);
|
|
newDir.setMimeType(MimeType.DIRECTORY);
|
|
long parentId = getStorageManager().getFileByPath(FileStorageUtils.getParentPath(remotePath)).getFileId();
|
|
newDir.setParentId(parentId);
|
|
newDir.setRemoteId(createdRemoteFolder.getRemoteId());
|
|
newDir.setModificationTimestamp(System.currentTimeMillis());
|
|
newDir.setEncrypted(FileStorageUtils.checkEncryptionStatus(newDir, getStorageManager()));
|
|
newDir.setPermissions(createdRemoteFolder.getPermissions());
|
|
getStorageManager().saveFile(newDir);
|
|
|
|
Log_OC.d(TAG, "Create directory " + remotePath + " in Database");
|
|
}
|
|
}
|
|
|
|
public String getRemotePath() {
|
|
return remotePath;
|
|
}
|
|
}
|