Browse Source

ENGINE-527: part 1, myself now doesn't write when called from decrypt_message (directly or, hoepfully, indirectly)

doc_update_sequoia
parent
commit
b19931457e
5 changed files with 107 additions and 31 deletions
  1. +34
    -22
      src/keymanagement.c
  2. +6
    -2
      src/keymanagement.h
  3. +11
    -7
      src/message_api.c
  4. +55
    -0
      src/pEpEngine.c
  5. +1
    -0
      src/pEp_internal.h

+ 34
- 22
src/keymanagement.c View File

@ -663,7 +663,7 @@ DYNAMIC_API PEP_STATUS update_identity(
// here, none of them fit.
// * call set_identity() to store
// FIXME: Do we set if we had to copy in the address?
adjust_pep_trust_status(session, identity);
adjust_pep_trust_status(session, identity);
status = set_identity(session, identity);
// * Return: created identity
}
@ -958,7 +958,11 @@ PEP_STATUS _has_usable_priv_key(PEP_SESSION session, char* fpr,
return status;
}
PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags)
PEP_STATUS _myself(PEP_SESSION session,
pEp_identity * identity,
bool do_keygen,
bool ignore_flags,
bool read_only)
{
PEP_STATUS status;
@ -980,18 +984,24 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
status = get_default_own_userid(session, &default_own_id);
// Deal with non-default user_ids.
// FIXME: if non-default and read-only, reject totally?
if (default_own_id && strcmp(default_own_id, identity->user_id) != 0) {
status = set_userid_alias(session, default_own_id, identity->user_id);
// Do we want this to be fatal? For now, we'll do it...
if (status != PEP_STATUS_OK)
goto pep_free;
free(identity->user_id);
identity->user_id = strdup(default_own_id);
if (identity->user_id == NULL) {
status = PEP_OUT_OF_MEMORY;
goto pep_free;
if (read_only) {
free(identity->user_id);
identity->user_id = strdup(default_own_id);
}
else {
status = set_userid_alias(session, default_own_id, identity->user_id);
// Do we want this to be fatal? For now, we'll do it...
if (status != PEP_STATUS_OK)
goto pep_free;
free(identity->user_id);
identity->user_id = strdup(default_own_id);
if (identity->user_id == NULL) {
status = PEP_OUT_OF_MEMORY;
goto pep_free;
}
}
}
@ -1024,7 +1034,7 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
// Set usernames - priority is input username > stored name > address
// If there's an input username, we always patch the username with that
// input.
if (EMPTYSTR(identity->username)) {
if (EMPTYSTR(identity->username) || read_only) {
bool stored_uname = (stored_identity && !EMPTYSTR(stored_identity->username));
char* uname = (stored_uname ? stored_identity->username : identity->address);
free(identity->username);
@ -1077,7 +1087,7 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
// Nothing left to do but generate a key
if (!valid_key_found) {
if (!do_keygen)
if (!do_keygen || read_only)
status = PEP_GET_KEY_FAILED;
else {
// / DEBUG_LOG("Generating key pair", "debug", identity->address);
@ -1115,12 +1125,14 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
// We want to set an identity in the DB even if a key isn't found, but we have to preserve the status if
// it's NOT ok
PEP_STATUS set_id_status = set_identity(session, identity);
if (set_id_status == PEP_STATUS_OK)
set_id_status = set_as_pep_user(session, identity);
status = (status == PEP_STATUS_OK ? set_id_status : status);
if (!read_only) {
PEP_STATUS set_id_status = set_identity(session, identity);
if (set_id_status == PEP_STATUS_OK)
set_id_status = set_as_pep_user(session, identity);
status = (status == PEP_STATUS_OK ? set_id_status : status);
}
pep_free:
free(default_own_id);
free(revoked_fpr);
@ -1156,7 +1168,7 @@ pep_free:
DYNAMIC_API PEP_STATUS myself(PEP_SESSION session, pEp_identity * identity)
{
return _myself(session, identity, true, false);
return _myself(session, identity, true, false, false);
}
DYNAMIC_API PEP_STATUS register_examine_function(
@ -1804,7 +1816,7 @@ DYNAMIC_API PEP_STATUS set_own_key(
EMPTYSTR(me->user_id) || EMPTYSTR(me->username))
return PEP_ILLEGAL_VALUE;
status = _myself(session, me, false, true);
status = _myself(session, me, false, true, false);
// we do not need a valid key but dislike other errors
if (status != PEP_STATUS_OK && status != PEP_GET_KEY_FAILED && status != PEP_KEY_UNSUITABLE)
return status;


+ 6
- 2
src/keymanagement.h View File

@ -114,7 +114,11 @@ DYNAMIC_API PEP_STATUS update_identity(
DYNAMIC_API PEP_STATUS myself(PEP_SESSION session, pEp_identity * identity);
PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);
PEP_STATUS _myself(PEP_SESSION session,
pEp_identity * identity,
bool do_keygen,
bool ignore_flags,
bool read_only);
// retrieve_next_identity() - callback being called by do_keymanagement()
//
@ -387,7 +391,7 @@ DYNAMIC_API PEP_STATUS set_own_key(
const char *fpr
);
PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);
//PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);
PEP_STATUS add_mistrusted_key(PEP_SESSION session, const char* fpr);
PEP_STATUS delete_mistrusted_key(PEP_SESSION session, const char* fpr);


+ 11
- 7
src/message_api.c View File

@ -987,7 +987,7 @@ static PEP_STATUS update_identity_recip_list(PEP_SESSION session,
}
}
else
status = myself(session, curr_identity);
status = _myself(session, curr_identity, false, false, true);
if (status == PEP_ILLEGAL_VALUE || status == PEP_OUT_OF_MEMORY)
return status;
}
@ -1322,7 +1322,8 @@ static PEP_comm_type _get_comm_type(
if (!is_me(session, ident))
status = update_identity(session, ident);
else
status = myself(session, ident);
// ???
status = _myself(session, ident, false, false, true);
if (status == PEP_STATUS_OK) {
if (ident->comm_type == PEP_ct_compromised)
@ -2970,6 +2971,7 @@ static PEP_STATUS import_priv_keys_from_decrypted_msg(PEP_SESSION session,
return status;
}
// FIXME: myself ??????
static PEP_STATUS update_sender_to_pep_trust(
PEP_SESSION session,
pEp_identity* sender,
@ -3238,6 +3240,7 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
stringlist_t *_keylist = NULL;
char* signer_fpr = NULL;
bool is_pep_msg = is_a_pEpmessage(src);
bool myself_read_only = (src->dir == PEP_dir_incoming);
// Grab input flags
bool reencrypt = (((*flags & PEP_decrypt_flag_untrusted_server) > 0) && *keylist && !EMPTYSTR((*keylist)->value));
@ -3301,7 +3304,7 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
if (!is_me(session, src->from))
status = update_identity(session, src->from);
else
status = myself(session, src->from);
status = _myself(session, src->from, false, false, myself_read_only);
// We absolutely should NOT be bailing here unless it's a serious error
if (status == PEP_OUT_OF_MEMORY)
@ -3517,7 +3520,7 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
if (!is_me(session, src->from))
update_identity(session, (src->from));
else
myself(session, src->from);
_myself(session, src->from, false, false, myself_read_only);
}
break;
}
@ -3882,7 +3885,7 @@ DYNAMIC_API PEP_STATUS identity_rating(
return PEP_ILLEGAL_VALUE;
if (ident->me)
status = _myself(session, ident, false, true);
status = _myself(session, ident, false, true, true);
else
status = update_identity(session, ident);
@ -4280,12 +4283,13 @@ DYNAMIC_API PEP_STATUS MIME_decrypt_message(
if (status != PEP_STATUS_OK)
goto pep_error;
tmp_msg->dir = PEP_dir_incoming;
// MIME decode message delivers only addresses. We need more.
if (tmp_msg->from) {
if (!is_me(session, tmp_msg->from))
status = update_identity(session, (tmp_msg->from));
else
status = myself(session, tmp_msg->from);
status = _myself(session, tmp_msg->from, false, false, true);
if (status == PEP_ILLEGAL_VALUE || status == PEP_OUT_OF_MEMORY)
goto pep_error;
@ -4603,7 +4607,7 @@ got_keylist:
if (!is_me(session, msg->from))
status = update_identity(session, msg->from);
else
status = myself(session, msg->from);
status = _myself(session, msg->from, false, false, true);
switch (status) {
case PEP_KEY_NOT_FOUND:


+ 55
- 0
src/pEpEngine.c View File

@ -367,6 +367,17 @@ static const char *sql_own_key_is_listed =
" where pgp_keypair_fpr = upper(replace(?1,' ',''))"
" and identity.is_own = 1"
");";
static const char *sql_is_own_address =
"select count(*) from ("
" select address from identity"
" where (case when (address = ?1) then (1)"
" when (lower(address) = lower(?1)) then (1)"
" when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
" else 0"
" end) = 1 "
" and identity.is_own = 1"
");";
static const char *sql_own_identities_retrieve =
"select address, fpr, username, identity.user_id, "
@ -1268,6 +1279,11 @@ DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
(int)strlen(sql_own_key_is_listed), &_session->own_key_is_listed,
NULL);
assert(int_result == SQLITE_OK);
int_result = sqlite3_prepare_v2(_session->db, sql_is_own_address,
(int)strlen(sql_is_own_address), &_session->is_own_address,
NULL);
assert(int_result == SQLITE_OK);
int_result = sqlite3_prepare_v2(_session->db, sql_own_identities_retrieve,
(int)strlen(sql_own_identities_retrieve),
@ -1489,6 +1505,8 @@ DYNAMIC_API void release(PEP_SESSION session)
sqlite3_finalize(session->blacklist_retrieve);
if (session->own_key_is_listed)
sqlite3_finalize(session->own_key_is_listed);
if (session->is_own_address)
sqlite3_finalize(session->is_own_address);
if (session->own_identities_retrieve)
sqlite3_finalize(session->own_identities_retrieve);
if (session->own_keys_retrieve)
@ -2722,6 +2740,43 @@ DYNAMIC_API PEP_STATUS is_pep_user(PEP_SESSION session, pEp_identity *identity,
return PEP_STATUS_OK;
}
DYNAMIC_API PEP_STATUS is_own_address(PEP_SESSION session, pEp_identity *identity, bool* is_own_addr)
{
assert(session);
assert(is_own_addr);
assert(identity);
assert(!EMPTYSTR(identity->user_id));
if (!session || !is_own_addr || !identity || EMPTYSTR(identity->address))
return PEP_ILLEGAL_VALUE;
*is_own_addr = false;
const char* address = identity->address;
if (!session || EMPTYSTR(address))
return PEP_ILLEGAL_VALUE;
sqlite3_reset(session->is_own_address);
sqlite3_bind_text(session->is_own_address, 1, address, -1,
SQLITE_STATIC);
int result = sqlite3_step(session->is_own_address);
switch (result) {
case SQLITE_ROW: {
// yeah yeah, I know, we could be lazy here, but it looks bad.
*is_own_addr = (sqlite3_column_int(session->is_own_address, 0) != 0);
break;
}
default:
sqlite3_reset(session->is_own_address);
return PEP_RECORD_NOT_FOUND;
}
sqlite3_reset(session->is_own_address);
return PEP_STATUS_OK;
}
PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
const char* fpr)


+ 1
- 0
src/pEp_internal.h View File

@ -174,6 +174,7 @@ struct _pEpSession {
// Own keys
sqlite3_stmt *own_key_is_listed;
sqlite3_stmt *is_own_address;
sqlite3_stmt *own_identities_retrieve;
sqlite3_stmt *own_keys_retrieve;
sqlite3_stmt *get_user_default_key;


Loading…
Cancel
Save