ENGINE-293: initialise_own_identities (cheap myself() only keygen/retrieval) + additional internal fprless get_identity function added so that temporary identities w/o fpr can be retrieved

src/keymanagement.c

@@ -437,6 +437,7 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
     char* own_id = NULL;
     status = get_own_userid(session, &own_id);
 
+
     assert(EMPTYSTR(identity->user_id) ||
            (own_id && strcmp(identity->user_id, own_id) == 0) ||
            !own_id);
@@ -447,6 +448,11 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
              !own_id)))
         return ADD_TO_LOG(PEP_ILLEGAL_VALUE);
 
+    if (!own_id) {
+        // check to see if we have ANY identity for this address... could have
+        // happened due to race condition
+    }
+    
     identity->comm_type = PEP_ct_pEp;
     identity->me = true;
     if(ignore_flags)
@@ -635,6 +641,45 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
     return ADD_TO_LOG(PEP_STATUS_OK);
 }
 
+DYNAMIC_API PEP_STATUS initialise_own_identities(PEP_SESSION session,
+                                                 identity_list* my_idents) {
+    PEP_STATUS status = PEP_STATUS_OK;
+    if (!session)
+        return PEP_ILLEGAL_VALUE;
+        
+    char* stored_own_userid = NULL;
+    get_own_userid(session, &stored_own_userid);
+    
+    identity_list* ident_curr = my_idents;
+    while (ident_curr) {
+        pEp_identity* ident = ident_curr->ident;
+        if (!ident)
+            return PEP_ILLEGAL_VALUE;
+            
+        if (stored_own_userid) {
+            if (!ident->user_id) 
+                ident->user_id = strdup(stored_own_userid);
+            else if (strcmp(stored_own_userid, ident->user_id) != 0)
+                return PEP_ILLEGAL_VALUE;
+        }
+        else if (!ident->user_id) {
+            stored_own_userid = PEP_OWN_USERID;
+            ident->user_id = strdup(PEP_OWN_USERID);
+        }
+        
+        ident->me = true; // Just in case.
+        
+        // Ok, do it...
+        status = set_identity(session, ident);
+        if (status != PEP_STATUS_OK)
+            return status;
+        
+        ident_curr = ident_curr->next;
+    }
+    
+    return status;
+}
+
 DYNAMIC_API PEP_STATUS myself(PEP_SESSION session, pEp_identity * identity)
 {
     return ADD_TO_LOG(_myself(session, identity, true, false));

src/keymanagement.h

@@ -34,6 +34,8 @@ DYNAMIC_API PEP_STATUS update_identity(
         PEP_SESSION session, pEp_identity * identity
     );
 
+DYNAMIC_API PEP_STATUS initialise_own_identities(PEP_SESSION session,
+                                                 identity_list* my_idents);
 
 // myself() - ensures that an own identity is complete
 //

src/pEpEngine.c

@@ -47,7 +47,6 @@ static const char *sql_trustword =
     "select id, word from wordlist where lang = lower(?1) "
     "and id = ?2 ;";
 
-
 static const char *sql_get_identity =  
     "select fpr, username, comm_type, lang,"
     "   identity.flags | pgp_keypair.flags,"
@@ -64,6 +63,18 @@ static const char *sql_get_identity =
     "          end) = 1"
     "   and identity.user_id = ?2;";
 
+static const char *sql_get_identity_without_fpr =  
+    "select main_key_id, username, comm_type, lang,"
+    "   identity.flags, is_own"
+    "   from identity"
+    "   join person on id = identity.user_id"
+    "   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.user_id = ?2;";
+
 static const char *sql_replace_identities_fpr =  
     "update identity"
     "   set main_key_id = ?1 "
@@ -692,6 +703,11 @@ DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
             (int)strlen(sql_get_identity), &_session->get_identity, NULL);
     assert(int_result == SQLITE_OK);
 
+    int_result = sqlite3_prepare_v2(_session->db, sql_get_identity_without_fpr,
+            (int)strlen(sql_get_identity_without_fpr), 
+            &_session->get_identity_without_fpr, NULL);
+    assert(int_result == SQLITE_OK);
+
     int_result = sqlite3_prepare_v2(_session->db, sql_get_own_userid,
             (int)strlen(sql_get_own_userid), &_session->get_own_userid, NULL);
     assert(int_result == SQLITE_OK);
@@ -937,6 +953,8 @@ DYNAMIC_API void release(PEP_SESSION session)
                 sqlite3_finalize(session->trustword);
             if (session->get_identity)
                 sqlite3_finalize(session->get_identity);
+            if (session->get_identity_without_fpr)
+                sqlite3_finalize(session->get_identity_without_fpr);    
             if (session->get_own_userid)
                 sqlite3_finalize(session->get_own_userid);
             if (session->replace_identities_fpr)
@@ -1350,11 +1368,13 @@ DYNAMIC_API PEP_STATUS get_own_userid(
     return status;
 }
 
-DYNAMIC_API PEP_STATUS get_identity(
+
+static PEP_STATUS _get_identity_internal(
         PEP_SESSION session,
         const char *address,
         const char *user_id,
-        pEp_identity **identity
+        pEp_identity **identity,
+        sqlite3_stmt* get_id_stmt
     )
 {
     PEP_STATUS status = PEP_STATUS_OK;
@@ -1370,27 +1390,27 @@ DYNAMIC_API PEP_STATUS get_identity(
 
     *identity = NULL;
 
-    sqlite3_reset(session->get_identity);
-    sqlite3_bind_text(session->get_identity, 1, address, -1, SQLITE_STATIC);
-    sqlite3_bind_text(session->get_identity, 2, user_id, -1, SQLITE_STATIC);
+    sqlite3_reset(get_id_stmt);
+    sqlite3_bind_text(get_id_stmt, 1, address, -1, SQLITE_STATIC);
+    sqlite3_bind_text(get_id_stmt, 2, user_id, -1, SQLITE_STATIC);
 
-    const int result = sqlite3_step(session->get_identity);
+    const int result = sqlite3_step(get_id_stmt);
     switch (result) {
     case SQLITE_ROW:
         _identity = new_identity(
                 address,
-                (const char *) sqlite3_column_text(session->get_identity, 0),
+                (const char *) sqlite3_column_text(get_id_stmt, 0),
                 user_id,
-                (const char *) sqlite3_column_text(session->get_identity, 1)
+                (const char *) sqlite3_column_text(get_id_stmt, 1)
                 );
         assert(_identity);
         if (_identity == NULL)
             return PEP_OUT_OF_MEMORY;
 
         _identity->comm_type = (PEP_comm_type)
-            sqlite3_column_int(session->get_identity, 2);
+            sqlite3_column_int(get_id_stmt, 2);
         const char* const _lang = (const char *)
-            sqlite3_column_text(session->get_identity, 3);
+            sqlite3_column_text(get_id_stmt, 3);
         if (_lang && _lang[0]) {
             assert(_lang[0] >= 'a' && _lang[0] <= 'z');
             assert(_lang[1] >= 'a' && _lang[1] <= 'z');
@@ -1400,9 +1420,9 @@ DYNAMIC_API PEP_STATUS get_identity(
             _identity->lang[2] = 0;
         }
         _identity->flags = (unsigned int)
-            sqlite3_column_int(session->get_identity, 4);
+            sqlite3_column_int(get_id_stmt, 4);
         _identity->me = (unsigned int)
-            sqlite3_column_int(session->get_identity, 5);
+            sqlite3_column_int(get_id_stmt, 5);
     
         *identity = _identity;
         break;
@@ -1411,10 +1431,33 @@ DYNAMIC_API PEP_STATUS get_identity(
         *identity = NULL;
     }
 
-    sqlite3_reset(session->get_identity);
+    sqlite3_reset(get_id_stmt);
     return status;
 }
 
+DYNAMIC_API PEP_STATUS get_identity(
+        PEP_SESSION session,
+        const char *address,
+        const char *user_id,
+        pEp_identity **identity
+    )
+{
+    return _get_identity_internal(session, address, user_id, identity,
+                                  session->get_identity);
+}
+
+PEP_STATUS get_identity_without_fpr(
+        PEP_SESSION session,
+        const char *address,
+        const char *user_id,
+        pEp_identity **identity
+    )
+{
+    return _get_identity_internal(session, address, user_id, identity,
+                                  session->get_identity_without_fpr);
+}
+
+
 DYNAMIC_API PEP_STATUS set_identity(
         PEP_SESSION session, const pEp_identity *identity
     )

src/pEpEngine.h

@@ -1149,6 +1149,16 @@ DYNAMIC_API const char* get_engine_version();
 
 DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session);
 
+// This is used internally when there is a temporary identity to be retrieved
+// that may not yet have an FPR attached. See get_identity() for functionality,
+// params and caveats.
+PEP_STATUS get_identity_without_fpr(
+        PEP_SESSION session,
+        const char *address,
+        const char *user_id,
+        pEp_identity **identity
+    );
+    
 #ifdef __cplusplus
 }
 #endif

src/pEp_internal.h

@@ -124,6 +124,7 @@ struct _pEpSession {
     sqlite3_stmt *log;
     sqlite3_stmt *trustword;
     sqlite3_stmt *get_identity;
+    sqlite3_stmt *get_identity_without_fpr;    
     sqlite3_stmt *replace_identities_fpr;
     sqlite3_stmt *set_person;
     sqlite3_stmt *set_device_group;

test/case_and_dot_address_test.cc

@@ -39,36 +39,42 @@ int main() {
     assert(statuspub == PEP_STATUS_OK);
     assert(statuspriv == PEP_STATUS_OK);
 
-    pEp_identity * alice_id = new_identity("pep.test.alice@pep-project.org", NULL, PEP_OWN_USERID, "Alice Test");
-    status = update_identity(session, alice_id);
-    assert(alice_id->fpr);
-    assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
+    pEp_identity * alice_id = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
+    identity_list* own_id = new_identity_list(alice_id);
+    status = initialise_own_identities(session, own_id);
+    status = trust_personal_key(session, alice_id);
+    pEp_identity * new_alice_id = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
+    status = update_identity(session, new_alice_id);
+    assert(new_alice_id->fpr);
+    assert(strcmp(new_alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
+    free_identity(new_alice_id);
     free_identity(alice_id);
     alice_id = NULL;
+    new_alice_id = NULL;
 
     alice_id = new_identity(alice_email_case, NULL, PEP_OWN_USERID, "Alice Test");
-    status = update_identity(session, alice_id);
+    status = myself(session, alice_id);
     assert(alice_id->fpr);
     assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
     free_identity(alice_id);
     alice_id = NULL;
 
     alice_id = new_identity(alice_email_dot, NULL, PEP_OWN_USERID, "Alice Test");
-    status = update_identity(session, alice_id);
+    status = myself(session, alice_id);
     assert(alice_id->fpr);
     assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
     free_identity(alice_id);
     alice_id = NULL;
 
     alice_id = new_identity(alice_email_dotless, NULL, PEP_OWN_USERID, "Alice Test");
-    status = update_identity(session, alice_id);
+    status = myself(session, alice_id);
     assert(alice_id->fpr);
     assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
     free_identity(alice_id);
     alice_id = NULL;
 
     alice_id = new_identity(alice_email_case_and_dot, NULL, PEP_OWN_USERID, "Alice Test");
-    status = update_identity(session, alice_id);
+    status = myself(session, alice_id);
     assert(alice_id->fpr);
     assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
     free_identity(alice_id);