Merge branch 'master' into improve-file
This commit is contained in:
mar-v-in
@@ -30,10 +30,14 @@ import org.sufficientlysecure.keychain.helper.ContactHelper;
|
||||
import org.sufficientlysecure.keychain.helper.EmailKeyHelper;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
public class ContactSyncAdapterService extends Service {
|
||||
|
||||
private class ContactSyncAdapter extends AbstractThreadedSyncAdapter {
|
||||
|
||||
private final AtomicBoolean importDone = new AtomicBoolean(false);
|
||||
|
||||
public ContactSyncAdapter() {
|
||||
super(ContactSyncAdapterService.this, true);
|
||||
}
|
||||
@@ -41,6 +45,8 @@ public class ContactSyncAdapterService extends Service {
|
||||
@Override
|
||||
public void onPerformSync(Account account, Bundle extras, String authority, ContentProviderClient provider,
|
||||
final SyncResult syncResult) {
|
||||
importDone.set(false);
|
||||
KeychainApplication.setupAccountAsNeeded(ContactSyncAdapterService.this);
|
||||
EmailKeyHelper.importContacts(getContext(), new Messenger(new Handler(Looper.getMainLooper(),
|
||||
new Handler.Callback() {
|
||||
@Override
|
||||
@@ -48,11 +54,16 @@ public class ContactSyncAdapterService extends Service {
|
||||
Bundle data = msg.getData();
|
||||
switch (msg.arg1) {
|
||||
case KeychainIntentServiceHandler.MESSAGE_OKAY:
|
||||
Log.d(Constants.TAG, "Syncing... Done.");
|
||||
synchronized (importDone) {
|
||||
importDone.set(true);
|
||||
importDone.notifyAll();
|
||||
}
|
||||
return true;
|
||||
case KeychainIntentServiceHandler.MESSAGE_UPDATE_PROGRESS:
|
||||
if (data.containsKey(KeychainIntentServiceHandler.DATA_PROGRESS) &&
|
||||
data.containsKey(KeychainIntentServiceHandler.DATA_PROGRESS_MAX)) {
|
||||
Log.d(Constants.TAG, "Progress: " +
|
||||
Log.d(Constants.TAG, "Syncing... Progress: " +
|
||||
data.getInt(KeychainIntentServiceHandler.DATA_PROGRESS) + "/" +
|
||||
data.getInt(KeychainIntentServiceHandler.DATA_PROGRESS_MAX));
|
||||
return false;
|
||||
@@ -63,7 +74,14 @@ public class ContactSyncAdapterService extends Service {
|
||||
}
|
||||
}
|
||||
})));
|
||||
KeychainApplication.setupAccountAsNeeded(ContactSyncAdapterService.this);
|
||||
synchronized (importDone) {
|
||||
try {
|
||||
if (!importDone.get()) importDone.wait();
|
||||
} catch (InterruptedException e) {
|
||||
Log.w(Constants.TAG, e);
|
||||
return;
|
||||
}
|
||||
}
|
||||
ContactHelper.writeKeysToContacts(ContactSyncAdapterService.this);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -44,7 +44,6 @@ import org.sufficientlysecure.keychain.pgp.PgpKeyOperation;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpSignEncrypt;
|
||||
import org.sufficientlysecure.keychain.pgp.Progressable;
|
||||
import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
|
||||
import org.sufficientlysecure.keychain.pgp.UncachedSecretKey;
|
||||
import org.sufficientlysecure.keychain.pgp.WrappedPublicKeyRing;
|
||||
import org.sufficientlysecure.keychain.pgp.WrappedSecretKey;
|
||||
import org.sufficientlysecure.keychain.pgp.WrappedSecretKeyRing;
|
||||
@@ -53,6 +52,7 @@ import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
|
||||
import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
|
||||
import org.sufficientlysecure.keychain.provider.KeychainDatabase;
|
||||
import org.sufficientlysecure.keychain.provider.ProviderHelper;
|
||||
import org.sufficientlysecure.keychain.service.OperationResultParcel.OperationLog;
|
||||
import org.sufficientlysecure.keychain.util.InputData;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
import org.sufficientlysecure.keychain.util.ProgressScaler;
|
||||
@@ -87,9 +87,6 @@ public class KeychainIntentService extends IntentService
|
||||
public static final String ACTION_DECRYPT_VERIFY = Constants.INTENT_PREFIX + "DECRYPT_VERIFY";
|
||||
|
||||
public static final String ACTION_SAVE_KEYRING = Constants.INTENT_PREFIX + "SAVE_KEYRING";
|
||||
public static final String ACTION_GENERATE_KEY = Constants.INTENT_PREFIX + "GENERATE_KEY";
|
||||
public static final String ACTION_GENERATE_DEFAULT_RSA_KEYS = Constants.INTENT_PREFIX
|
||||
+ "GENERATE_DEFAULT_RSA_KEYS";
|
||||
|
||||
public static final String ACTION_DELETE_FILE_SECURELY = Constants.INTENT_PREFIX
|
||||
+ "DELETE_FILE_SECURELY";
|
||||
@@ -131,14 +128,7 @@ public class KeychainIntentService extends IntentService
|
||||
|
||||
// save keyring
|
||||
public static final String SAVE_KEYRING_PARCEL = "save_parcel";
|
||||
public static final String SAVE_KEYRING_CAN_SIGN = "can_sign";
|
||||
|
||||
|
||||
// generate key
|
||||
public static final String GENERATE_KEY_ALGORITHM = "algorithm";
|
||||
public static final String GENERATE_KEY_KEY_SIZE = "key_size";
|
||||
public static final String GENERATE_KEY_SYMMETRIC_PASSPHRASE = "passphrase";
|
||||
public static final String GENERATE_KEY_MASTER_KEY = "master_key";
|
||||
public static final String SAVE_KEYRING_PASSPHRASE = "passphrase";
|
||||
|
||||
// delete file securely
|
||||
public static final String DELETE_FILE = "deleteFile";
|
||||
@@ -168,9 +158,6 @@ public class KeychainIntentService extends IntentService
|
||||
/*
|
||||
* possible data keys as result send over messenger
|
||||
*/
|
||||
// keys
|
||||
public static final String RESULT_NEW_KEY = "new_key";
|
||||
public static final String RESULT_KEY_USAGES = "new_key_usages";
|
||||
|
||||
// encrypt
|
||||
public static final String RESULT_BYTES = "encrypted_data";
|
||||
@@ -179,14 +166,11 @@ public class KeychainIntentService extends IntentService
|
||||
public static final String RESULT_DECRYPTED_BYTES = "decrypted_data";
|
||||
public static final String RESULT_DECRYPT_VERIFY_RESULT = "signature";
|
||||
|
||||
// import
|
||||
public static final String RESULT_IMPORT_ADDED = "added";
|
||||
public static final String RESULT_IMPORT_UPDATED = "updated";
|
||||
public static final String RESULT_IMPORT_BAD = "bad";
|
||||
|
||||
// export
|
||||
public static final String RESULT_EXPORT = "exported";
|
||||
|
||||
public static final String RESULT = "result";
|
||||
|
||||
Messenger mMessenger;
|
||||
|
||||
private boolean mIsCanceled;
|
||||
@@ -335,136 +319,39 @@ public class KeychainIntentService extends IntentService
|
||||
} else if (ACTION_SAVE_KEYRING.equals(action)) {
|
||||
try {
|
||||
/* Input */
|
||||
OldSaveKeyringParcel saveParcel = data.getParcelable(SAVE_KEYRING_PARCEL);
|
||||
String oldPassphrase = saveParcel.oldPassphrase;
|
||||
String newPassphrase = saveParcel.newPassphrase;
|
||||
boolean canSign = true;
|
||||
|
||||
if (data.containsKey(SAVE_KEYRING_CAN_SIGN)) {
|
||||
canSign = data.getBoolean(SAVE_KEYRING_CAN_SIGN);
|
||||
}
|
||||
|
||||
if (newPassphrase == null) {
|
||||
newPassphrase = oldPassphrase;
|
||||
}
|
||||
|
||||
long masterKeyId = saveParcel.keys.get(0).getKeyId();
|
||||
SaveKeyringParcel saveParcel = data.getParcelable(SAVE_KEYRING_PARCEL);
|
||||
long masterKeyId = saveParcel.mMasterKeyId;
|
||||
|
||||
/* Operation */
|
||||
ProviderHelper providerHelper = new ProviderHelper(this);
|
||||
if (!canSign) {
|
||||
setProgress(R.string.progress_building_key, 0, 100);
|
||||
WrappedSecretKeyRing keyRing = providerHelper.getWrappedSecretKeyRing(masterKeyId);
|
||||
UncachedKeyRing newKeyRing =
|
||||
keyRing.changeSecretKeyPassphrase(oldPassphrase, newPassphrase);
|
||||
setProgress(R.string.progress_saving_key_ring, 50, 100);
|
||||
providerHelper.saveSecretKeyRing(newKeyRing);
|
||||
setProgress(R.string.progress_done, 100, 100);
|
||||
} else {
|
||||
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 90, 100));
|
||||
try {
|
||||
WrappedSecretKeyRing seckey = providerHelper.getWrappedSecretKeyRing(masterKeyId);
|
||||
WrappedPublicKeyRing pubkey = providerHelper.getWrappedPublicKeyRing(masterKeyId);
|
||||
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 10, 50, 100));
|
||||
try {
|
||||
String passphrase = data.getString(SAVE_KEYRING_PASSPHRASE);
|
||||
WrappedSecretKeyRing secRing = providerHelper.getWrappedSecretKeyRing(masterKeyId);
|
||||
|
||||
PgpKeyOperation.Pair<UncachedKeyRing,UncachedKeyRing> pair =
|
||||
keyOperations.buildSecretKey(seckey, pubkey, saveParcel); // edit existing
|
||||
setProgress(R.string.progress_saving_key_ring, 90, 100);
|
||||
providerHelper.saveKeyRing(pair.first, pair.second);
|
||||
} catch (ProviderHelper.NotFoundException e) {
|
||||
PgpKeyOperation.Pair<UncachedKeyRing,UncachedKeyRing> pair =
|
||||
keyOperations.buildNewSecretKey(saveParcel); //new Keyring
|
||||
// save the pair
|
||||
setProgress(R.string.progress_saving_key_ring, 90, 100);
|
||||
providerHelper.saveKeyRing(pair.first, pair.second);
|
||||
}
|
||||
|
||||
setProgress(R.string.progress_done, 100, 100);
|
||||
OperationLog log = new OperationLog();
|
||||
UncachedKeyRing ring = keyOperations.modifySecretKeyRing(secRing, saveParcel,
|
||||
passphrase, log, 0);
|
||||
providerHelper.saveSecretKeyRing(ring, new ProgressScaler(this, 60, 95, 100));
|
||||
} catch (ProviderHelper.NotFoundException e) {
|
||||
// UncachedKeyRing ring = keyOperations.(saveParcel); //new Keyring
|
||||
// save the pair
|
||||
setProgress(R.string.progress_saving_key_ring, 95, 100);
|
||||
// providerHelper.saveSecretKeyRing(ring);
|
||||
sendErrorToHandler(e);
|
||||
}
|
||||
|
||||
setProgress(R.string.progress_done, 100, 100);
|
||||
|
||||
if (saveParcel.newPassphrase != null) {
|
||||
PassphraseCacheService.addCachedPassphrase(this, masterKeyId, saveParcel.newPassphrase);
|
||||
}
|
||||
PassphraseCacheService.addCachedPassphrase(this, masterKeyId, newPassphrase);
|
||||
|
||||
/* Output */
|
||||
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY);
|
||||
} catch (Exception e) {
|
||||
sendErrorToHandler(e);
|
||||
}
|
||||
} else if (ACTION_GENERATE_KEY.equals(action)) {
|
||||
try {
|
||||
/* Input */
|
||||
int algorithm = data.getInt(GENERATE_KEY_ALGORITHM);
|
||||
String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
||||
int keysize = data.getInt(GENERATE_KEY_KEY_SIZE);
|
||||
boolean masterKey = data.getBoolean(GENERATE_KEY_MASTER_KEY);
|
||||
|
||||
/* Operation */
|
||||
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 100, 100));
|
||||
byte[] newKey = keyOperations.createKey(algorithm, keysize, passphrase, masterKey);
|
||||
|
||||
/* Output */
|
||||
Bundle resultData = new Bundle();
|
||||
resultData.putByteArray(RESULT_NEW_KEY, newKey);
|
||||
|
||||
OtherHelper.logDebugBundle(resultData, "resultData");
|
||||
|
||||
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
||||
} catch (Exception e) {
|
||||
sendErrorToHandler(e);
|
||||
}
|
||||
} else if (ACTION_GENERATE_DEFAULT_RSA_KEYS.equals(action)) {
|
||||
// generate one RSA 4096 key for signing and one subkey for encrypting!
|
||||
try {
|
||||
/* Input */
|
||||
String passphrase = data.getString(GENERATE_KEY_SYMMETRIC_PASSPHRASE);
|
||||
ArrayList<Integer> keyUsageList = new ArrayList<Integer>();
|
||||
|
||||
/* Operation */
|
||||
int keysTotal = 3;
|
||||
int keysCreated = 0;
|
||||
setProgress(
|
||||
getApplicationContext().getResources().
|
||||
getQuantityString(R.plurals.progress_generating, keysTotal),
|
||||
keysCreated,
|
||||
keysTotal);
|
||||
PgpKeyOperation keyOperations = new PgpKeyOperation(new ProgressScaler(this, 0, 100, 100));
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
|
||||
byte[] buf;
|
||||
|
||||
buf = keyOperations.createKey(Constants.choice.algorithm.rsa,
|
||||
4096, passphrase, true);
|
||||
os.write(buf);
|
||||
keyUsageList.add(UncachedSecretKey.CERTIFY_OTHER);
|
||||
keysCreated++;
|
||||
setProgress(keysCreated, keysTotal);
|
||||
|
||||
buf = keyOperations.createKey(Constants.choice.algorithm.rsa,
|
||||
4096, passphrase, false);
|
||||
os.write(buf);
|
||||
keyUsageList.add(UncachedSecretKey.ENCRYPT_COMMS | UncachedSecretKey.ENCRYPT_STORAGE);
|
||||
keysCreated++;
|
||||
setProgress(keysCreated, keysTotal);
|
||||
|
||||
buf = keyOperations.createKey(Constants.choice.algorithm.rsa,
|
||||
4096, passphrase, false);
|
||||
os.write(buf);
|
||||
keyUsageList.add(UncachedSecretKey.SIGN_DATA);
|
||||
keysCreated++;
|
||||
setProgress(keysCreated, keysTotal);
|
||||
|
||||
// TODO: default to one master for cert, one sub for encrypt and one sub
|
||||
// for sign
|
||||
|
||||
/* Output */
|
||||
Bundle resultData = new Bundle();
|
||||
resultData.putByteArray(RESULT_NEW_KEY, os.toByteArray());
|
||||
resultData.putIntegerArrayList(RESULT_KEY_USAGES, keyUsageList);
|
||||
|
||||
OtherHelper.logDebugBundle(resultData, "resultData");
|
||||
|
||||
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
||||
} catch (Exception e) {
|
||||
sendErrorToHandler(e);
|
||||
}
|
||||
} else if (ACTION_DELETE_FILE_SECURELY.equals(action)) {
|
||||
try {
|
||||
/* Input */
|
||||
@@ -491,7 +378,10 @@ public class KeychainIntentService extends IntentService
|
||||
List<ParcelableKeyRing> entries = data.getParcelableArrayList(IMPORT_KEY_LIST);
|
||||
|
||||
PgpImportExport pgpImportExport = new PgpImportExport(this, this);
|
||||
Bundle resultData = pgpImportExport.importKeyRings(entries);
|
||||
OperationResults.ImportResult result = pgpImportExport.importKeyRings(entries);
|
||||
|
||||
Bundle resultData = new Bundle();
|
||||
resultData.putParcelable(RESULT, result);
|
||||
|
||||
sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
|
||||
} catch (Exception e) {
|
||||
|
||||
@@ -1,128 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2014 Ash Hughes <ashes-iontach@hotmail.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* 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 org.sufficientlysecure.keychain.service;
|
||||
|
||||
import android.os.Parcel;
|
||||
import android.os.Parcelable;
|
||||
|
||||
import org.sufficientlysecure.keychain.Constants;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpConversionHelper;
|
||||
import org.sufficientlysecure.keychain.pgp.UncachedSecretKey;
|
||||
import org.sufficientlysecure.keychain.util.IterableIterator;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
|
||||
/** Class for parcelling data between ui and services.
|
||||
* This class is outdated and scheduled for removal, pending a rewrite of the
|
||||
* EditKeyActivity and save keyring routines.
|
||||
*/
|
||||
@Deprecated
|
||||
public class OldSaveKeyringParcel implements Parcelable {
|
||||
|
||||
public ArrayList<String> userIds;
|
||||
public ArrayList<String> originalIDs;
|
||||
public ArrayList<String> deletedIDs;
|
||||
public boolean[] newIDs;
|
||||
public boolean primaryIDChanged;
|
||||
public boolean[] moddedKeys;
|
||||
public ArrayList<UncachedSecretKey> deletedKeys;
|
||||
public ArrayList<Calendar> keysExpiryDates;
|
||||
public ArrayList<Integer> keysUsages;
|
||||
public String newPassphrase;
|
||||
public String oldPassphrase;
|
||||
public boolean[] newKeys;
|
||||
public ArrayList<UncachedSecretKey> keys;
|
||||
public String originalPrimaryID;
|
||||
|
||||
public OldSaveKeyringParcel() {}
|
||||
|
||||
private OldSaveKeyringParcel(Parcel source) {
|
||||
userIds = (ArrayList<String>) source.readSerializable();
|
||||
originalIDs = (ArrayList<String>) source.readSerializable();
|
||||
deletedIDs = (ArrayList<String>) source.readSerializable();
|
||||
newIDs = source.createBooleanArray();
|
||||
primaryIDChanged = source.readByte() != 0;
|
||||
moddedKeys = source.createBooleanArray();
|
||||
byte[] tmp = source.createByteArray();
|
||||
if (tmp == null) {
|
||||
deletedKeys = null;
|
||||
} else {
|
||||
deletedKeys = PgpConversionHelper.BytesToPGPSecretKeyList(tmp);
|
||||
}
|
||||
keysExpiryDates = (ArrayList<Calendar>) source.readSerializable();
|
||||
keysUsages = source.readArrayList(Integer.class.getClassLoader());
|
||||
newPassphrase = source.readString();
|
||||
oldPassphrase = source.readString();
|
||||
newKeys = source.createBooleanArray();
|
||||
keys = PgpConversionHelper.BytesToPGPSecretKeyList(source.createByteArray());
|
||||
originalPrimaryID = source.readString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel destination, int flags) {
|
||||
destination.writeSerializable(userIds); //might not be the best method to store.
|
||||
destination.writeSerializable(originalIDs);
|
||||
destination.writeSerializable(deletedIDs);
|
||||
destination.writeBooleanArray(newIDs);
|
||||
destination.writeByte((byte) (primaryIDChanged ? 1 : 0));
|
||||
destination.writeBooleanArray(moddedKeys);
|
||||
destination.writeByteArray(encodeArrayList(deletedKeys));
|
||||
destination.writeSerializable(keysExpiryDates);
|
||||
destination.writeList(keysUsages);
|
||||
destination.writeString(newPassphrase);
|
||||
destination.writeString(oldPassphrase);
|
||||
destination.writeBooleanArray(newKeys);
|
||||
destination.writeByteArray(encodeArrayList(keys));
|
||||
destination.writeString(originalPrimaryID);
|
||||
}
|
||||
|
||||
public static final Creator<OldSaveKeyringParcel> CREATOR = new Creator<OldSaveKeyringParcel>() {
|
||||
public OldSaveKeyringParcel createFromParcel(final Parcel source) {
|
||||
return new OldSaveKeyringParcel(source);
|
||||
}
|
||||
|
||||
public OldSaveKeyringParcel[] newArray(final int size) {
|
||||
return new OldSaveKeyringParcel[size];
|
||||
}
|
||||
};
|
||||
|
||||
private static byte[] encodeArrayList(ArrayList<UncachedSecretKey> list) {
|
||||
if(list.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
ByteArrayOutputStream os = new ByteArrayOutputStream();
|
||||
for(UncachedSecretKey key : new IterableIterator<UncachedSecretKey>(list.iterator())) {
|
||||
try {
|
||||
key.encodeSecretKey(os);
|
||||
} catch (IOException e) {
|
||||
Log.e(Constants.TAG, "Error while converting ArrayList<UncachedSecretKey> to byte[]!", e);
|
||||
}
|
||||
}
|
||||
return os.toByteArray();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
package org.sufficientlysecure.keychain.service;
|
||||
|
||||
import android.os.Parcel;
|
||||
import android.os.Parcelable;
|
||||
|
||||
import org.sufficientlysecure.keychain.Constants;
|
||||
import org.sufficientlysecure.keychain.R;
|
||||
import org.sufficientlysecure.keychain.util.IterableIterator;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
/** Represent the result of an operation.
|
||||
*
|
||||
* This class holds a result and the log of an operation. It can be subclassed
|
||||
* to include typed additional information specific to the operation. To keep
|
||||
* the class structure (somewhat) simple, this class contains an exhaustive
|
||||
* list (ie, enum) of all possible log types, which should in all cases be tied
|
||||
* to string resource ids.
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class OperationResultParcel implements Parcelable {
|
||||
/** Holds the overall result, the number specifying varying degrees of success. The first bit
|
||||
* is 0 on overall success, 1 on overall failure. All other bits may be used for more specific
|
||||
* conditions. */
|
||||
final int mResult;
|
||||
|
||||
public static final int RESULT_OK = 0;
|
||||
public static final int RESULT_ERROR = 1;
|
||||
|
||||
/// A list of log entries tied to the operation result.
|
||||
final OperationLog mLog;
|
||||
|
||||
public OperationResultParcel(int result, OperationLog log) {
|
||||
mResult = result;
|
||||
mLog = log;
|
||||
}
|
||||
|
||||
public OperationResultParcel(Parcel source) {
|
||||
mResult = source.readInt();
|
||||
mLog = new OperationLog();
|
||||
mLog.addAll(source.createTypedArrayList(LogEntryParcel.CREATOR));
|
||||
}
|
||||
|
||||
public int getResult() {
|
||||
return mResult;
|
||||
}
|
||||
|
||||
public boolean success() {
|
||||
return (mResult & 1) == 0;
|
||||
}
|
||||
|
||||
public OperationLog getLog() {
|
||||
return mLog;
|
||||
}
|
||||
|
||||
/** One entry in the log. */
|
||||
public static class LogEntryParcel implements Parcelable {
|
||||
public final LogLevel mLevel;
|
||||
public final LogType mType;
|
||||
public final String[] mParameters;
|
||||
public final int mIndent;
|
||||
|
||||
public LogEntryParcel(LogLevel level, LogType type, String[] parameters, int indent) {
|
||||
mLevel = level;
|
||||
mType = type;
|
||||
mParameters = parameters;
|
||||
mIndent = indent;
|
||||
}
|
||||
public LogEntryParcel(LogLevel level, LogType type, String[] parameters) {
|
||||
this(level, type, parameters, 0);
|
||||
}
|
||||
|
||||
public LogEntryParcel(Parcel source) {
|
||||
mLevel = LogLevel.values()[source.readInt()];
|
||||
mType = LogType.values()[source.readInt()];
|
||||
mParameters = source.createStringArray();
|
||||
mIndent = source.readInt();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel dest, int flags) {
|
||||
dest.writeInt(mLevel.ordinal());
|
||||
dest.writeInt(mType.ordinal());
|
||||
dest.writeStringArray(mParameters);
|
||||
dest.writeInt(mIndent);
|
||||
}
|
||||
|
||||
public static final Creator<LogEntryParcel> CREATOR = new Creator<LogEntryParcel>() {
|
||||
public LogEntryParcel createFromParcel(final Parcel source) {
|
||||
return new LogEntryParcel(source);
|
||||
}
|
||||
|
||||
public LogEntryParcel[] newArray(final int size) {
|
||||
return new LogEntryParcel[size];
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
/** This is an enum of all possible log events.
|
||||
*
|
||||
* Element names should generally be prefixed with MSG_XX_ where XX is an
|
||||
* identifier based on the related activity.
|
||||
*
|
||||
* Log messages should occur for each distinguishable action group. For
|
||||
* each such group, one message is displayed followed by warnings or
|
||||
* errors, and optionally subactions. The granularity should generally be
|
||||
* optimistic: No "success" messages are printed except for the outermost
|
||||
* operations - the success of an action group is indicated by the
|
||||
* beginning message of the next action group.
|
||||
*
|
||||
* Log messages should be in present tense, There should be no trailing
|
||||
* punctuation, except for error messages which may end in an exclamation
|
||||
* mark.
|
||||
*
|
||||
*/
|
||||
public static enum LogType {
|
||||
|
||||
// import public
|
||||
MSG_IP(R.string.msg_ip),
|
||||
MSG_IP_APPLY_BATCH (R.string.msg_ip_apply_batch),
|
||||
MSG_IP_BAD_TYPE_SECRET (R.string.msg_ip_bad_type_secret),
|
||||
MSG_IP_DELETE_OLD_FAIL (R.string.msg_ip_delete_old_fail),
|
||||
MSG_IP_DELETE_OLD_OK (R.string.msg_ip_delete_old_ok),
|
||||
MSG_IP_ENCODE_FAIL (R.string.msg_ip_encode_fail),
|
||||
MSG_IP_FAIL_IO_EXC (R.string.msg_ip_fail_io_exc),
|
||||
MSG_IP_FAIL_OP_EXC (R.string.msg_ip_fail_op_exc),
|
||||
MSG_IP_FAIL_REMOTE_EX (R.string.msg_ip_fail_remote_ex),
|
||||
MSG_IP_INSERT_KEYRING (R.string.msg_ip_insert_keyring),
|
||||
MSG_IP_INSERT_SUBKEYS (R.string.msg_ip_insert_keys),
|
||||
MSG_IP_PREPARE (R.string.msg_ip_prepare),
|
||||
MSG_IP_REINSERT_SECRET (R.string.msg_ip_reinsert_secret),
|
||||
MSG_IP_MASTER (R.string.msg_ip_master),
|
||||
MSG_IP_MASTER_EXPIRED (R.string.msg_ip_master_expired),
|
||||
MSG_IP_MASTER_EXPIRES (R.string.msg_ip_master_expires),
|
||||
MSG_IP_MASTER_FLAGS_CES (R.string.msg_ip_master_flags_ces),
|
||||
MSG_IP_MASTER_FLAGS_CEX (R.string.msg_ip_master_flags_cex),
|
||||
MSG_IP_MASTER_FLAGS_CXS (R.string.msg_ip_master_flags_cxs),
|
||||
MSG_IP_MASTER_FLAGS_XES (R.string.msg_ip_master_flags_xes),
|
||||
MSG_IP_MASTER_FLAGS_CXX (R.string.msg_ip_master_flags_cxx),
|
||||
MSG_IP_MASTER_FLAGS_XEX (R.string.msg_ip_master_flags_xex),
|
||||
MSG_IP_MASTER_FLAGS_XXS (R.string.msg_ip_master_flags_xxs),
|
||||
MSG_IP_MASTER_FLAGS_XXX (R.string.msg_ip_master_flags_xxx),
|
||||
MSG_IP_SUBKEY (R.string.msg_ip_subkey),
|
||||
MSG_IP_SUBKEY_EXPIRED (R.string.msg_ip_subkey_expired),
|
||||
MSG_IP_SUBKEY_EXPIRES (R.string.msg_ip_subkey_expires),
|
||||
MSG_IP_SUBKEY_FLAGS_CES (R.string.msg_ip_subkey_flags_ces),
|
||||
MSG_IP_SUBKEY_FLAGS_CEX (R.string.msg_ip_subkey_flags_cex),
|
||||
MSG_IP_SUBKEY_FLAGS_CXS (R.string.msg_ip_subkey_flags_cxs),
|
||||
MSG_IP_SUBKEY_FLAGS_XES (R.string.msg_ip_subkey_flags_xes),
|
||||
MSG_IP_SUBKEY_FLAGS_CXX (R.string.msg_ip_subkey_flags_cxx),
|
||||
MSG_IP_SUBKEY_FLAGS_XEX (R.string.msg_ip_subkey_flags_xex),
|
||||
MSG_IP_SUBKEY_FLAGS_XXS (R.string.msg_ip_subkey_flags_xxs),
|
||||
MSG_IP_SUBKEY_FLAGS_XXX (R.string.msg_ip_subkey_flags_xxx),
|
||||
MSG_IP_SUCCESS (R.string.msg_ip_success),
|
||||
MSG_IP_SUCCESS_IDENTICAL (R.string.msg_ip_success_identical),
|
||||
MSG_IP_UID_CERT_BAD (R.string.msg_ip_uid_cert_bad),
|
||||
MSG_IP_UID_CERT_ERROR (R.string.msg_ip_uid_cert_error),
|
||||
MSG_IP_UID_CERT_GOOD (R.string.msg_ip_uid_cert_good),
|
||||
MSG_IP_UID_CERTS_UNKNOWN (R.string.msg_ip_uid_certs_unknown),
|
||||
MSG_IP_UID_CLASSIFYING (R.string.msg_ip_uid_classifying),
|
||||
MSG_IP_UID_REORDER(R.string.msg_ip_uid_reorder),
|
||||
MSG_IP_UID_PROCESSING (R.string.msg_ip_uid_processing),
|
||||
MSG_IP_UID_REVOKED (R.string.msg_ip_uid_revoked),
|
||||
|
||||
// import secret
|
||||
MSG_IS(R.string.msg_is),
|
||||
MSG_IS_BAD_TYPE_PUBLIC (R.string.msg_is_bad_type_public),
|
||||
MSG_IS_DB_EXCEPTION (R.string.msg_is_db_exception),
|
||||
MSG_IS_FAIL_IO_EXC (R.string.msg_is_io_exc),
|
||||
MSG_IS_IMPORTING_SUBKEYS (R.string.msg_is_importing_subkeys),
|
||||
MSG_IS_PUBRING_GENERATE (R.string.msg_is_pubring_generate),
|
||||
MSG_IS_SUBKEY_NONEXISTENT (R.string.msg_is_subkey_nonexistent),
|
||||
MSG_IS_SUBKEY_OK (R.string.msg_is_subkey_ok),
|
||||
MSG_IS_SUBKEY_STRIPPED (R.string.msg_is_subkey_stripped),
|
||||
MSG_IS_SUCCESS_IDENTICAL (R.string.msg_is_success_identical),
|
||||
MSG_IS_SUCCESS (R.string.msg_is_success),
|
||||
|
||||
// keyring canonicalization
|
||||
MSG_KC_PUBLIC (R.string.msg_kc_public),
|
||||
MSG_KC_SECRET (R.string.msg_kc_secret),
|
||||
MSG_KC_FATAL_NO_UID (R.string.msg_kc_fatal_no_uid),
|
||||
MSG_KC_MASTER (R.string.msg_kc_master),
|
||||
MSG_KC_REVOKE_BAD_ERR (R.string.msg_kc_revoke_bad_err),
|
||||
MSG_KC_REVOKE_BAD_LOCAL (R.string.msg_kc_revoke_bad_local),
|
||||
MSG_KC_REVOKE_BAD_TIME (R.string.msg_kc_revoke_bad_time),
|
||||
MSG_KC_REVOKE_BAD_TYPE (R.string.msg_kc_revoke_bad_type),
|
||||
MSG_KC_REVOKE_BAD (R.string.msg_kc_revoke_bad),
|
||||
MSG_KC_REVOKE_DUP (R.string.msg_kc_revoke_dup),
|
||||
MSG_KC_SUB (R.string.msg_kc_sub),
|
||||
MSG_KC_SUB_BAD(R.string.msg_kc_sub_bad),
|
||||
MSG_KC_SUB_BAD_ERR(R.string.msg_kc_sub_bad_err),
|
||||
MSG_KC_SUB_BAD_LOCAL(R.string.msg_kc_sub_bad_local),
|
||||
MSG_KC_SUB_BAD_KEYID(R.string.msg_kc_sub_bad_keyid),
|
||||
MSG_KC_SUB_BAD_TIME(R.string.msg_kc_sub_bad_time),
|
||||
MSG_KC_SUB_BAD_TYPE(R.string.msg_kc_sub_bad_type),
|
||||
MSG_KC_SUB_PRIMARY_BAD(R.string.msg_kc_sub_primary_bad),
|
||||
MSG_KC_SUB_PRIMARY_BAD_ERR(R.string.msg_kc_sub_primary_bad_err),
|
||||
MSG_KC_SUB_PRIMARY_NONE(R.string.msg_kc_sub_primary_none),
|
||||
MSG_KC_SUB_NO_CERT(R.string.msg_kc_sub_no_cert),
|
||||
MSG_KC_SUB_REVOKE_BAD_ERR (R.string.msg_kc_sub_revoke_bad_err),
|
||||
MSG_KC_SUB_REVOKE_BAD (R.string.msg_kc_sub_revoke_bad),
|
||||
MSG_KC_SUB_REVOKE_DUP (R.string.msg_kc_sub_revoke_dup),
|
||||
MSG_KC_SUCCESS_BAD (R.string.msg_kc_success_bad),
|
||||
MSG_KC_SUCCESS_BAD_AND_RED (R.string.msg_kc_success_bad_and_red),
|
||||
MSG_KC_SUCCESS_REDUNDANT (R.string.msg_kc_success_redundant),
|
||||
MSG_KC_SUCCESS (R.string.msg_kc_success),
|
||||
MSG_KC_UID_BAD_ERR (R.string.msg_kc_uid_bad_err),
|
||||
MSG_KC_UID_BAD_LOCAL (R.string.msg_kc_uid_bad_local),
|
||||
MSG_KC_UID_BAD_TIME (R.string.msg_kc_uid_bad_time),
|
||||
MSG_KC_UID_BAD_TYPE (R.string.msg_kc_uid_bad_type),
|
||||
MSG_KC_UID_BAD (R.string.msg_kc_uid_bad),
|
||||
MSG_KC_UID_DUP (R.string.msg_kc_uid_dup),
|
||||
MSG_KC_UID_FOREIGN (R.string.msg_kc_uid_foreign),
|
||||
MSG_KC_UID_NO_CERT (R.string.msg_kc_uid_no_cert),
|
||||
MSG_KC_UID_REVOKE_DUP (R.string.msg_kc_uid_revoke_dup),
|
||||
MSG_KC_UID_REVOKE_OLD (R.string.msg_kc_uid_revoke_old),
|
||||
|
||||
|
||||
// keyring consolidation
|
||||
MSG_MG_PUBLIC (R.string.msg_mg_public),
|
||||
MSG_MG_SECRET (R.string.msg_mg_secret),
|
||||
MSG_MG_FATAL_ENCODE (R.string.msg_mg_fatal_encode),
|
||||
MSG_MG_HETEROGENEOUS (R.string.msg_mg_heterogeneous),
|
||||
MSG_MG_NEW_SUBKEY (R.string.msg_mg_new_subkey),
|
||||
MSG_MG_FOUND_NEW (R.string.msg_mg_found_new),
|
||||
|
||||
// secret key modify
|
||||
MSG_MF (R.string.msg_mr),
|
||||
MSG_MF_ERROR_ENCODE (R.string.msg_mf_error_encode),
|
||||
MSG_MF_ERROR_PGP (R.string.msg_mf_error_pgp),
|
||||
MSG_MF_ERROR_SIG (R.string.msg_mf_error_sig),
|
||||
MSG_MF_PASSPHRASE (R.string.msg_mf_passphrase),
|
||||
MSG_MF_SUBKEY_CHANGE (R.string.msg_mf_subkey_change),
|
||||
MSG_MF_SUBKEY_MISSING (R.string.msg_mf_subkey_missing),
|
||||
MSG_MF_SUBKEY_NEW_ID (R.string.msg_mf_subkey_new_id),
|
||||
MSG_MF_SUBKEY_NEW (R.string.msg_mf_subkey_new),
|
||||
MSG_MF_SUBKEY_PAST_EXPIRY (R.string.msg_mf_subkey_past_expiry),
|
||||
MSG_MF_SUBKEY_REVOKE (R.string.msg_mf_subkey_revoke),
|
||||
MSG_MF_SUCCESS (R.string.msg_mf_success),
|
||||
MSG_MF_UID_ADD (R.string.msg_mf_uid_add),
|
||||
MSG_MF_UID_PRIMARY (R.string.msg_mf_uid_primary),
|
||||
MSG_MF_UID_REVOKE (R.string.msg_mf_uid_revoke),
|
||||
MSG_MF_UNLOCK_ERROR (R.string.msg_mf_unlock_error),
|
||||
MSG_MF_UNLOCK (R.string.msg_mf_unlock),
|
||||
;
|
||||
|
||||
private final int mMsgId;
|
||||
LogType(int msgId) {
|
||||
mMsgId = msgId;
|
||||
}
|
||||
public int getMsgId() {
|
||||
return mMsgId;
|
||||
}
|
||||
}
|
||||
|
||||
/** Enumeration of possible log levels. */
|
||||
public static enum LogLevel {
|
||||
DEBUG,
|
||||
INFO,
|
||||
WARN,
|
||||
ERROR, // should occur once at the end of a failed operation
|
||||
START, // should occur once at the start of each independent operation
|
||||
OK, // should occur once at the end of a successful operation
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel dest, int flags) {
|
||||
dest.writeInt(mResult);
|
||||
dest.writeTypedList(mLog);
|
||||
}
|
||||
|
||||
public static final Creator<OperationResultParcel> CREATOR = new Creator<OperationResultParcel>() {
|
||||
public OperationResultParcel createFromParcel(final Parcel source) {
|
||||
return new OperationResultParcel(source);
|
||||
}
|
||||
|
||||
public OperationResultParcel[] newArray(final int size) {
|
||||
return new OperationResultParcel[size];
|
||||
}
|
||||
};
|
||||
|
||||
public static class OperationLog extends ArrayList<LogEntryParcel> {
|
||||
|
||||
/// Simple convenience method
|
||||
public void add(LogLevel level, LogType type, String[] parameters, int indent) {
|
||||
Log.d(Constants.TAG, type.toString());
|
||||
add(new OperationResultParcel.LogEntryParcel(level, type, parameters, indent));
|
||||
}
|
||||
|
||||
public void add(LogLevel level, LogType type, int indent) {
|
||||
add(new OperationResultParcel.LogEntryParcel(level, type, null, indent));
|
||||
}
|
||||
|
||||
public boolean containsWarnings() {
|
||||
for(LogEntryParcel entry : new IterableIterator<LogEntryParcel>(iterator())) {
|
||||
if (entry.mLevel == LogLevel.WARN || entry.mLevel == LogLevel.ERROR) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
package org.sufficientlysecure.keychain.service;
|
||||
|
||||
import android.os.Parcel;
|
||||
|
||||
public abstract class OperationResults {
|
||||
|
||||
public static class ImportResult extends OperationResultParcel {
|
||||
|
||||
public final int mNewKeys, mUpdatedKeys, mBadKeys;
|
||||
|
||||
// At least one new key
|
||||
public static final int RESULT_OK_NEWKEYS = 2;
|
||||
// At least one updated key
|
||||
public static final int RESULT_OK_UPDATED = 4;
|
||||
// At least one key failed (might still be an overall success)
|
||||
public static final int RESULT_WITH_ERRORS = 8;
|
||||
// There are warnings in the log
|
||||
public static final int RESULT_WITH_WARNINGS = 16;
|
||||
|
||||
// No keys to import...
|
||||
public static final int RESULT_FAIL_NOTHING = 32 +1;
|
||||
|
||||
public boolean isOkBoth() {
|
||||
return (mResult & (RESULT_OK_NEWKEYS | RESULT_OK_UPDATED))
|
||||
== (RESULT_OK_NEWKEYS | RESULT_OK_UPDATED);
|
||||
}
|
||||
public boolean isOkNew() {
|
||||
return (mResult & RESULT_OK_NEWKEYS) == RESULT_OK_NEWKEYS;
|
||||
}
|
||||
public boolean isOkUpdated() {
|
||||
return (mResult & RESULT_OK_UPDATED) == RESULT_OK_UPDATED;
|
||||
}
|
||||
public boolean isFailNothing() {
|
||||
return (mResult & RESULT_FAIL_NOTHING) == RESULT_FAIL_NOTHING;
|
||||
}
|
||||
|
||||
public ImportResult(Parcel source) {
|
||||
super(source);
|
||||
mNewKeys = source.readInt();
|
||||
mUpdatedKeys = source.readInt();
|
||||
mBadKeys = source.readInt();
|
||||
}
|
||||
|
||||
public ImportResult(int result, OperationLog log,
|
||||
int newKeys, int updatedKeys, int badKeys) {
|
||||
super(result, log);
|
||||
mNewKeys = newKeys;
|
||||
mUpdatedKeys = updatedKeys;
|
||||
mBadKeys = badKeys;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel dest, int flags) {
|
||||
super.writeToParcel(dest, flags);
|
||||
dest.writeInt(mNewKeys);
|
||||
dest.writeInt(mUpdatedKeys);
|
||||
dest.writeInt(mBadKeys);
|
||||
}
|
||||
|
||||
public static Creator<ImportResult> CREATOR = new Creator<ImportResult>() {
|
||||
public ImportResult createFromParcel(final Parcel source) {
|
||||
return new ImportResult(source);
|
||||
}
|
||||
|
||||
public ImportResult[] newArray(final int size) {
|
||||
return new ImportResult[size];
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
public static class SaveKeyringResult extends OperationResultParcel {
|
||||
|
||||
public SaveKeyringResult(int result, OperationLog log) {
|
||||
super(result, log);
|
||||
}
|
||||
|
||||
// Some old key was updated
|
||||
public static final int UPDATED = 2;
|
||||
|
||||
// Public key was saved
|
||||
public static final int SAVED_PUBLIC = 8;
|
||||
// Secret key was saved (not exclusive with public!)
|
||||
public static final int SAVED_SECRET = 16;
|
||||
|
||||
public boolean updated() {
|
||||
return (mResult & UPDATED) == UPDATED;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -23,16 +23,16 @@ import java.util.HashMap;
|
||||
public class SaveKeyringParcel implements Parcelable {
|
||||
|
||||
// the master key id to be edited
|
||||
private final long mMasterKeyId;
|
||||
public final long mMasterKeyId;
|
||||
// the key fingerprint, for safety
|
||||
private final byte[] mFingerprint;
|
||||
public final byte[] mFingerprint;
|
||||
|
||||
public String newPassphrase;
|
||||
|
||||
public String[] addUserIds;
|
||||
public SubkeyAdd[] addSubKeys;
|
||||
|
||||
public HashMap<Long, SubkeyChange> changeSubKeys;
|
||||
public SubkeyChange[] changeSubKeys;
|
||||
public String changePrimaryUserId;
|
||||
|
||||
public String[] revokeUserIds;
|
||||
@@ -76,7 +76,7 @@ public class SaveKeyringParcel implements Parcelable {
|
||||
addUserIds = source.createStringArray();
|
||||
addSubKeys = (SubkeyAdd[]) source.readSerializable();
|
||||
|
||||
changeSubKeys = (HashMap<Long,SubkeyChange>) source.readSerializable();
|
||||
changeSubKeys = (SubkeyChange[]) source.readSerializable();
|
||||
changePrimaryUserId = source.readString();
|
||||
|
||||
revokeUserIds = source.createStringArray();
|
||||
|
||||
Reference in New Issue
Block a user