// This file is under GNU General Public License 3.0

// see LICENSE.txt

#include "platform.h"

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <ctype.h>

#include "pEp_internal.h"

#include "keymanagement.h"

#include "sync_fsm.h"

#include "blacklist.h"

#ifndef EMPTYSTR

#define EMPTYSTR(STR) ((STR) == NULL || (STR)[0] == '\0')

#endif

#define KEY_EXPIRE_DELTA (60 * 60 * 24 * 365)

static bool key_matches_address(PEP_SESSION session, const char* address,

                                const char* fpr) {

    if (!session || !address || !fpr)

        return false;

    bool retval = false;

    stringlist_t *keylist = NULL;

    PEP_STATUS status = find_keys(session, address, &keylist);

    if (status == PEP_STATUS_OK && keylist) {

        stringlist_t* curr = keylist;

        if (curr->value) {

            if (strcasecmp(curr->value, fpr)) {

                retval = true;

                break;

            }

        }

        curr = curr->next;

    }

    free_stringlist(keylist);

    return retval;                             

}

PEP_STATUS elect_pubkey(

        PEP_SESSION session, pEp_identity * identity

    )

{

    PEP_STATUS status;

    stringlist_t *keylist = NULL;

    char *_fpr = "";

    identity->comm_type = PEP_ct_unknown;

    status = find_keys(session, identity->address, &keylist);

    assert(status != PEP_OUT_OF_MEMORY);

    if (status == PEP_OUT_OF_MEMORY)

        return PEP_OUT_OF_MEMORY;

    stringlist_t *_keylist;

    for (_keylist = keylist; _keylist && _keylist->value; _keylist = _keylist->next) {

        PEP_comm_type _comm_type_key;

        status = get_key_rating(session, _keylist->value, &_comm_type_key);

        assert(status != PEP_OUT_OF_MEMORY);

        if (status == PEP_OUT_OF_MEMORY) {

            free_stringlist(keylist);

            return PEP_OUT_OF_MEMORY;

        }

        if (_comm_type_key != PEP_ct_compromized &&

            _comm_type_key != PEP_ct_unknown)

        {

            if (identity->comm_type == PEP_ct_unknown ||

                _comm_type_key > identity->comm_type)

            {

                bool blacklisted;

                status = blacklist_is_listed(session, _keylist->value, &blacklisted);

                if (status == PEP_STATUS_OK && !blacklisted) {

                    identity->comm_type = _comm_type_key;

                    _fpr = _keylist->value;

                }

            }

        }

    }

//    if (_fpr) {

    free(identity->fpr);

    identity->fpr = strdup(_fpr);

    if (identity->fpr == NULL) {

        free_stringlist(keylist);

        return PEP_OUT_OF_MEMORY;

    }

//    }

    free_stringlist(keylist);

    return PEP_STATUS_OK;

}

static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {

    if (!session || !ident || !ident->fpr)

        return PEP_ILLEGAL_VALUE;    

    char* fpr = ident->fpr;

    PEP_STATUS status = get_trust(session, ident);

    if (status != PEP_STATUS_OK)

        return ADD_TO_LOG(status);

    bool done = false;

    bool revoked, expired;

    status = key_revoked(session, fpr, &revoked);    

    assert(status == PEP_STATUS_OK);

    // switch (status) {

    //     case PEP_STATUS_OK:

    //         break;

    //     case PEP_KEY_NOT_FOUND:

    //         // Key not found in keyring

    //     case PEP_GET_KEY_FAILED:

    //         // other GPG error

    //     default:

    //         return status;

    // }

    if (status != PEP_STATUS_OK) {

         return ADD_TO_LOG(status);

     }

    status = key_expired(session, fpr, 

                         time(NULL), // NOW. For _myself, this is different.

                         &expired);

    assert(status == PEP_STATUS_OK);

    if (status != PEP_STATUS_OK)

         return ADD_TO_LOG(status);

    char* retval = fpr;

    // FIXME: bits for pEp

    if (ident->me && (ct == PEP_ct_pEp) && !revoked && expired) {

        // extend key

        timestamp *ts = new_timestamp(time(NULL) + KEY_EXPIRE_DELTA);

        status = renew_key(session, fpr, ts);

        free_timestamp(ts);

        if (status == PEP_STATUS_OK) {

            // if key is valid (second check because pEp key might be extended above)

            //      Return fpr        

            status = key_expired(session, fpr, &expired);            

            if (status != PEP_STATUS_OK)

                 return ADD_TO_LOG(status);

            // communicate key(?)

            done = true;

        }        

    }

    if (revoked)

        ct = PEP_ct_revoked; // not to be stored. To be used here.

    else if (expired)

        ct = PEP_ct_expired;

    switch (ct) {

        case PEP_ct_key_expired:

        case PEP_ct_key_revoked

        case PEP_ct_key_b0rken:

            // delete key from being default key for all users/identities

            status = remove_fpr_as_default(session, fpr);

            ident->fpr = NULL;

        default:

            break;

    }            

    if (!(revoked || expired || !done))

        return PEP_STATUS_OK;

    return PEP_UNKNOWN_ERROR; // FIXME - better error

}

// Only call on retrieval of previously stored identity!

// Also, we presume that if the stored_identity was sent in

// without an fpr, there wasn't one in the trust DB for this

// identity.

PEP_STATUS get_valid_pubkey(PEP_STATUS session,

                            PEP_STATUS stored_identity,

                            bool* is_identity_default,

                            bool* is_user_default,

                            bool* is_address_default) {

    PEP_STATUS status = PEP_STATUS_OK;

    if (!stored_identity || !stored_identity->user_id

        || !is_identity_default || !is_user_default || !is_address_default)

        return PEP_ILLEGAL_VALUE;

    *is_identity_default = *is_user_default = *is_address_default = false;

    char* stored_fpr = stored_identity->fpr;

    // Input: stored identity retrieved from database

    // if stored identity contains a default key

    if (stored_fpr) {

        status = validate_fpr(session, stored_identity);    

        if (status == PEP_STATUS_OK && stored_identity->fpr) {

            *is_identity_default = *is_address_default = true;

            return status;

        }

    }

    // if no valid default stored identity key found

    free(stored_identity->fpr);

    stored_identity->fpr = NULL;

    // try to get default key for user_data

    sqlite3_reset(session->get_user_default_key);

    sqlite3_bind_text(session->get_user_default_key, 1, stored_identity->user_id, 

                      -1, SQLITE_STATIC);

    const int result = sqlite3_step(session->get_user_default_key);

    const char* user_fpr = NULL;

    if (result == SQLITE_ROW) {

        user_fpr = 

            (const char *) sqlite3_column_text(session->get_user_default_key, 0);

    }

    sqlite3_reset(session->get_user_default_key);

    if (user_fpr) {             

        // There exists a default key for user, so validate

        stored_identity->fpr = user_fpr;

        status = validate_fpr(session, stored_identity);

        if (status == PEP_STATUS_OK && stored_identity->fpr) {

            *is_user_default = true;

            *is_address_default = key_matches_address(session, 

                                                      stored_identity->address,

                                                      stored_identity->fpr);

            return status;

        }        

    }

    return elect_pubkey(session, stored_identity);

}

PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);

DYNAMIC_API PEP_STATUS update_identity(

        PEP_SESSION session, pEp_identity * identity

    )

{

    pEp_identity *stored_identity = NULL;

    pEp_identity *temp_id = NULL;

    PEP_STATUS status;

    assert(session);

    assert(identity);

    assert(!EMPTYSTR(identity->address));

    if (!(session && identity && !EMPTYSTR(identity->address)))

        return ADD_TO_LOG(PEP_ILLEGAL_VALUE);

    char* own_id = NULL;

    status = get_own_userid(session, &own_id);    

    // Is this me, temporary or not? If so, _myself() is the right call.

    if (identity->me || 

       (own_id && identity->user_id && (strcmp(own_id, identity->user_id) == 0))) 

    {

        status = _myself(session, identity, false, true);

        free(own_id);

        return status;

    }

    // We have, at least, an address.

    // Retrieve stored identity information!    

    pEp_identity* stored_ident = NULL;

    char* identity_default_fpr = NULL;

    char* user_default_fpr = NULL;

    char* passed_in_fpr = identity->fpr;

    if (identity->user_id) {            

        // (we're gonna update the trust/fpr anyway, so we user the no-fpr-from-trust-db variant)

        //      * do get_identity() to retrieve stored identity information

        status = get_identity_without_trust_check(session, identity->address, identity->user_id, &stored_ident);

        // Before we start - if there was no stored identity, we should check to make sure we don't

        // have a stored identity with a temporary user_id that differs from the input user_id. This

        // happens in multithreaded environments sometimes.

        if (!stored_ident) {

            identity_list* id_list = NULL;

            status = get_identities_by_address(session, identity->address, &id_list);

            if (id_list) {

                identity_list* id_curr = id_list;

                while (id_curr) {

                    pEp_identity* this_id = id_curr->ident;

                    if (this_id) {

                        char* this_uid = this_id->user_id;

                        if (this_uid && (strstr(this_uid, "TOFU_") == this_uid)) {

                            // FIXME: should we also be fixing pEp_own_userId in this

                            // function here?

                            // if usernames match, we replace the userid. Or if the temp username

                            // is anonymous.

                            if (!this_id->username ||

                                strcasecmp(this_id->username, "anonymous") == 0 ||

                                (identity->username && 

                                 strcasecmp(identity->username, 

                                            this_id->username) == 0)) {

                                // Ok, we have a temp ID. We have to replace this

                                // with the real ID.

                                status = replace_userid(this_uid, identity->user_id);

                                if (status != PEP_STATUS_OK) {

                                    free_identity_list(id_list);

                                    return status;

                                }

                                free(this_uid);

                                // Reflect the change we just made to the DB

                                this_id->user_id = strdup(identity->user_id);

                                stored_ident = this_id;

                                // FIXME: free list.

                                break;                                

                            }                            

                        } 

                    }

                    id_curr = id_curr->next;

                }

            }

        } 

        if (stored_ident && stored_ident->fpr)

            identity_default_fpr = strdup(stored_ident->fpr);

        // Ok, now we start the real algorithm:

        if (status == PEP_STATUS_OK && stored_ident) { 

            //  * if identity available

            //      * patch it with username

            //          (note: this will happen when 

            //           setting automatically below...)

            //      * elect valid key for identity

            //    * if valid key exists

            //        * set return value's fpr

            bool fpr_changed = false;

            bool is_identity_default, is_user_default, is_address_default;

            status = get_valid_pubkey(session, stored_ident,

                                        &is_identity_default,

                                        &is_user_default,

                                        &is_address_default);

            if (status == PEP_STATUS_OK && stored_ident->fpr) {

            //        * set identity comm_type from trust db (user_id, FPR)

                status = get_trust(session, stored_ident);

                if (status != PEP_STATUS_OK)

                    return status; // FIXME - free mem

                if (identity->fpr &&

                         strcasecmp(stored_ident->fpr, identity->fpr) != 0) {

                    free(identity->fpr);

                    strdup(identity->fpr, stored_ident->fpr);

                    // We have to call this because we didn't get it during

                    // get identity above

                    status = get_trust(session, stored_ident);

                    identity->comm_type = stored_ident->comm_type;

                }

            }

            else {

                return status; // Couldn't find a key.

            }

            // We patch the DB with the input username, but if we didn't have

            // one, we pull it out of storage if available.

            // (also, if the input username is "anonymous" and there exists

            //  a DB username, we replace)

            if (stored_ident->username) {

                if (identity->username && 

                    (strcasecmp(identity->username, "anonymous") == 0)) {

                    free(identity->username);

                    identity->username = NULL;

                }

                if (!identity->username)

                    identity->username = strdup(stored_ident->username);

            }

            // Call set_identity() to store

            if ((is_identity_default || is_user_default) &&

                 is_address_default) {                 

                 // if we got an fpr which is default for either user

                 // or identity AND is valid for this address, set in DB

                 // as default

                 status = set_identity(identity);

            }

            else {

                // Store without default fpr/ct, but return the fpr and ct 

                // for current use

                char* save_fpr = identity->fpr;

                PEP_comm_type save_ct = identity->comm_type;

                identity->fpr = NULL;

                identity->comm_type = PEP_ct_unknown;

                status = set_identity(identity);

                identity->fpr = save_fpr;

                identity->comm_type = save_ct;

            }

        }

        //  * else (identity unavailable)

        else {

            //  if we only have user_id and address and identity not available

            //      * return error status (identity not found)

            if (!identity->username)

                status PEP_CANNOT_FIND_IDENTITY;

            // Otherwise, if we had user_id, address, and username:

            //    * create identity with user_id, address, username

            //      (this is the input id without the fpr + comm type!)

            free(identity->fpr);

            identity->fpr = NULL;

            identity->comm_type = PEP_ct_unknown;

            //    * We've already checked and retrieved

            //      any applicable temporary identities above. If we're 

            //      here, none of them fit.

            //    * call set_identity() to store

            if (status == PEP_STATUS_OK) {

                status = set_identity(session, identity);

            }

            //  * Return: created identity

        }        

    }

    else if (identity->username) {

        /*

         * Temporary identity information with username supplied

            * Input: address, username (no others)

         */

        identity_list* id_list = NULL;

        status = get_identities_by_address(session, identity->address, &id_list);

        //  * Search for an identity with non-temporary user_id with that mapping

        if (id_list) {

            identity_list* id_curr = id_list;

            while (id_curr) {

                pEp_identity* this_id = id_curr->ident;

                if (this_id) {

                    char* this_uid = this_id->user_id;

                    if (this_uid && (strstr(this_uid, "TOFU_") == NULL)) {

                        // FIXME: should we also be fixing pEp_own_userId in this

                        // function here?

                        // if usernames match, we replace the userid.

                        if (identity->username && 

                            strcasecmp(identity->username, 

                                       this_id->username) == 0) {

                            // Ok, we have a real ID. Copy it!

                            identity->user_id = strdup(this_uid);

                            if (!identity->user_id)

                                status = PEP_OUT_OF_MEMORY;

                            stored_ident = this_id;

                            break;                                

                        }                            

                    } 

                }

                id_curr = id_curr->next;

            }

        }

        if (stored_ident) {

        }

        else {

            //    * create temporary identity, store it, and Return this            

        }

    }

    else {

        /*

         * Temporary identity information without username suplied

            * Input: address (no others)

         */

        //    * Search for identity with this address

        //    * If exactly one found

        //      * elect valid key for identity (see below)

        //      * if valid key exists

        //        * set identity comm_type from trust db (user_id, FPR)

        //        * set return value's fpr

        //        * ...? (do we also set the stored fpr?)

        //      * Return this identity

        //    * else

        //      * return error status (too little information)

    }

    int _no_user_id = EMPTYSTR(identity->user_id);

    int _did_elect_new_key = 0;

    if (_no_user_id)

    {

        char* own_id = NULL;

        status = get_own_userid(session, &own_id);

        if (status == PEP_STATUS_OK && own_id) {

            status = get_identity(session, identity->address, own_id,

                    &stored_identity);

            if (status == PEP_STATUS_OK) {

                free_identity(stored_identity);

                identity->user_id = own_id;

                return _myself(session, identity, false, true);

            }

        }

        free(identity->user_id);

        identity->user_id = calloc(1, strlen(identity->address) + 6);

        if (!identity->user_id)

        {

            return PEP_OUT_OF_MEMORY;

        }

        snprintf(identity->user_id, strlen(identity->address) + 6,

                 "TOFU_%s", identity->address);

    }

    status = get_identity(session,

                          identity->address,

                          identity->user_id,

                          &stored_identity);

    assert(status != PEP_OUT_OF_MEMORY);

    if (status == PEP_OUT_OF_MEMORY)

        goto exit_free;

    temp_id = identity_dup(identity);

    /* We don't take given fpr. 

       In case there's no acceptable stored fpr, it will be elected. */

    free(temp_id->fpr);

    temp_id->fpr = NULL;

    temp_id->comm_type = PEP_ct_unknown;

    if (stored_identity) {

        bool dont_use_stored_fpr = true;

        /* if we have a stored_identity fpr */

        if (!EMPTYSTR(stored_identity->fpr)) {

            bool revoked = false;

            status = key_revoked(session, stored_identity->fpr, &revoked);

            if (status != PEP_STATUS_OK || revoked)

                dont_use_stored_fpr = true;

            if (revoked) {

                // Do stuff

                status = update_trust_for_fpr(session, stored_identity->fpr, PEP_ct_key_revoked);

                // What to do on failure? FIXME

                status = replace_identities_fpr(session, stored_identity->fpr, "");

            }

            else {    

                status = blacklist_is_listed(session, stored_identity->fpr, &dont_use_stored_fpr);

                if (status != PEP_STATUS_OK)

                    dont_use_stored_fpr = true; 

            }

        }

        if (!dont_use_stored_fpr) {

            /* Check stored comm_type */

            PEP_comm_type _comm_type_key;

            status = get_key_rating(session, stored_identity->fpr, &_comm_type_key);

            assert(status != PEP_OUT_OF_MEMORY);

            if (status == PEP_OUT_OF_MEMORY) {

                goto exit_free;

            }

            if (status == PEP_KEY_NOT_FOUND){

                /* stored key was deleted from keyring. any other candidate ?*/

                status = elect_pubkey(session, temp_id);

                if (status != PEP_STATUS_OK) {

                    goto exit_free;

                } else {

                    _did_elect_new_key = 1;

                }

            } else {

                temp_id->fpr = strdup(stored_identity->fpr);

                assert(temp_id->fpr);

                if (temp_id->fpr == NULL) {

                    status = PEP_OUT_OF_MEMORY;

                    goto exit_free;

                }

                if (_comm_type_key < PEP_ct_unconfirmed_encryption) {

                    /* if key not good anymore, 

                       downgrade eventually trusted comm_type */

                    temp_id->comm_type = _comm_type_key;

                } else {

                    /* otherwise take stored comm_type as-is except if 

                       is unknown or is expired (but key not expired anymore) */

                    temp_id->comm_type = stored_identity->comm_type;

                    if (temp_id->comm_type == PEP_ct_unknown ||

                        temp_id->comm_type == PEP_ct_key_expired) {

                        temp_id->comm_type = _comm_type_key;

                    }

                }

            }

        }

        else {

            status = elect_pubkey(session, temp_id);

            if (status != PEP_STATUS_OK){

                goto exit_free;

            } else {

                _did_elect_new_key = 1;

            }

        }

        /* ok, from here on out, use temp_id */

        /* At this point, we either have a non-blacklisted fpr we can work */

        /* with, or we've got nada.                                        */

        if (EMPTYSTR(temp_id->fpr)) {

            /* nada : set comm_type accordingly */

            temp_id->comm_type = PEP_ct_key_not_found;

        }

        if (EMPTYSTR(temp_id->username)) {

            free(temp_id->username);

            temp_id->username = strdup(stored_identity->username);

            assert(temp_id->username);

            if (temp_id->username == NULL){

                status = PEP_OUT_OF_MEMORY;

                goto exit_free;

            }

        }

        if (temp_id->lang[0] == 0) {

            temp_id->lang[0] = stored_identity->lang[0];

            temp_id->lang[1] = stored_identity->lang[1];

            temp_id->lang[2] = 0;

        }

        temp_id->flags = stored_identity->flags;

    }

    else /* stored_identity == NULL */ {

        temp_id->flags = 0;

        /* We elect a pubkey */

        status = elect_pubkey(session, temp_id);

        if (status != PEP_STATUS_OK)

            goto exit_free;

        /* Work with the elected key */

        if (!EMPTYSTR(temp_id->fpr)) {

            PEP_comm_type _comm_type_key = temp_id->comm_type;

            _did_elect_new_key = 1;

            // We don't want to lose a previous trust entry!!!

            status = get_trust(session, temp_id);

            bool has_trust_status = (status == PEP_STATUS_OK);

            if (!has_trust_status)

                temp_id->comm_type = _comm_type_key;

        }

    }

    if (temp_id->fpr == NULL) {

        temp_id->fpr = strdup("");

        if (temp_id->fpr == NULL) {

            status = PEP_OUT_OF_MEMORY;

            goto exit_free;

        }

    }

    status = PEP_STATUS_OK;

    if (temp_id->comm_type != PEP_ct_unknown && !EMPTYSTR(temp_id->user_id)) {

        if (EMPTYSTR(temp_id->username)) { // mitigate

            free(temp_id->username);

            temp_id->username = strdup("Anonymous");

            assert(temp_id->username);

            if (temp_id->username == NULL){

                status = PEP_OUT_OF_MEMORY;

                goto exit_free;

            }

        }

        // Identity doesn't get stored if call was just about checking existing

        // user by address (i.e. no user id given but already stored)

        if (!(_no_user_id && stored_identity) || _did_elect_new_key)

        {

            status = set_identity(session, temp_id);

            assert(status == PEP_STATUS_OK);

            if (status != PEP_STATUS_OK) {

                goto exit_free;

            }

        }

    }

    if (temp_id->comm_type != PEP_ct_compromized &&

            temp_id->comm_type < PEP_ct_strong_but_unconfirmed)

        if (session->examine_identity)

            session->examine_identity(temp_id, session->examine_management);

    /* ok, we got to the end. So we can assign the output identity */

    free(identity->address);

    identity->address = strdup(temp_id->address);

    free(identity->fpr);

    identity->fpr = strdup(temp_id->fpr);

    free(identity->user_id);

    identity->user_id = strdup(temp_id->user_id);

    free(identity->username);

    identity->username = strdup(temp_id->username ? temp_id->username : "Anonymous");

    identity->comm_type = temp_id->comm_type;

    identity->lang[0] = temp_id->lang[0];

    identity->lang[1] = temp_id->lang[1];

    identity->lang[2] = 0;

    identity->me = temp_id->me;

    identity->flags = temp_id->flags;

exit_free :

    free_identity(stored_identity);

    free_identity(temp_id);

    return ADD_TO_LOG(status);

}

PEP_STATUS elect_ownkey(

        PEP_SESSION session, pEp_identity * identity

    )

{

    PEP_STATUS status;

    stringlist_t *keylist = NULL;

    free(identity->fpr);

    identity->fpr = NULL;

    status = find_private_keys(session, identity->address, &keylist);

    assert(status != PEP_OUT_OF_MEMORY);

    if (status == PEP_OUT_OF_MEMORY)

        return PEP_OUT_OF_MEMORY;

    if (keylist != NULL && keylist->value != NULL)

    {

        char *_fpr = NULL;

        identity->comm_type = PEP_ct_unknown;

        stringlist_t *_keylist;

        for (_keylist = keylist; _keylist && _keylist->value; _keylist = _keylist->next) {

            bool is_own = false;

            status = own_key_is_listed(session, _keylist->value, &is_own);

            assert(status == PEP_STATUS_OK);

            if (status != PEP_STATUS_OK) {

                free_stringlist(keylist);

                return status;

            }

            if (is_own)

            {

                PEP_comm_type _comm_type_key;

                status = get_key_rating(session, _keylist->value, &_comm_type_key);

                assert(status != PEP_OUT_OF_MEMORY);

                if (status == PEP_OUT_OF_MEMORY) {

                    free_stringlist(keylist);

                    return PEP_OUT_OF_MEMORY;

                }

                if (_comm_type_key != PEP_ct_compromized &&

                    _comm_type_key != PEP_ct_unknown)

                {

                    if (identity->comm_type == PEP_ct_unknown ||

                        _comm_type_key > identity->comm_type)

                    {

                        identity->comm_type = _comm_type_key;

                        _fpr = _keylist->value;

                    }

                }

            }

        }

        if (_fpr)

        {

            identity->fpr = strdup(_fpr);

            assert(identity->fpr);

            if (identity->fpr == NULL)

            {

                free_stringlist(keylist);

                return PEP_OUT_OF_MEMORY;

            }

        }

        free_stringlist(keylist);

    }

    return PEP_STATUS_OK;

}

PEP_STATUS _has_usable_priv_key(PEP_SESSION session, char* fpr,

                                bool* is_usable) {

    bool dont_use_fpr = true;

    PEP_STATUS status = blacklist_is_listed(session, fpr, &dont_use_fpr);

    if (status == PEP_STATUS_OK && !dont_use_fpr) {

        // Make sure there is a *private* key associated with this fpr

        bool has_private = false;

        status = contains_priv_key(session, fpr, &has_private);

        if (status == PEP_STATUS_OK)

            dont_use_fpr = !has_private;

    }

    *is_usable = !dont_use_fpr;

    return ADD_TO_LOG(status);

}

PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags)

{

    pEp_identity *stored_identity = NULL;

    PEP_STATUS status;

    assert(session);

    assert(identity);

    assert(!EMPTYSTR(identity->address));

    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);

    if (!(session && identity && !EMPTYSTR(identity->address) &&

            (EMPTYSTR(identity->user_id) ||

            (own_id && strcmp(identity->user_id, own_id) == 0) ||

             !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)

        identity->flags = 0;

    if (EMPTYSTR(identity->user_id))

    {

        free(identity->user_id);

        identity->user_id = (own_id ? own_id : strdup(PEP_OWN_USERID));

        assert(identity->user_id);

        if (identity->user_id == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    if (EMPTYSTR(identity->username))

    {

        free(identity->username);

        identity->username = strdup("Anonymous");

        assert(identity->username);

        if (identity->username == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    DEBUG_LOG("myself", "debug", identity->address);

    status = get_identity(session,

                          identity->address,

                          identity->user_id,

                          &stored_identity);

    assert(status != PEP_OUT_OF_MEMORY);

    if (status == PEP_OUT_OF_MEMORY)

        return PEP_OUT_OF_MEMORY;

    bool dont_use_stored_fpr = true;

    bool dont_use_input_fpr = true;

    if (stored_identity)

    {

        if (EMPTYSTR(identity->fpr)) {

            bool has_private = false;

            status = _has_usable_priv_key(session, stored_identity->fpr, &has_private); 

            // N.B. has_private is never true if the returned status is not PEP_STATUS_OK

            if (has_private) {

                identity->fpr = strdup(stored_identity->fpr);

                assert(identity->fpr);

                if (identity->fpr == NULL)

                {

                    return PEP_OUT_OF_MEMORY;

                }

                dont_use_stored_fpr = false;

            }

        }

        identity->flags = (identity->flags & 255) | stored_identity->flags;

        free_identity(stored_identity);

    }

    if (dont_use_stored_fpr && !EMPTYSTR(identity->fpr))

    {

        // App must have a good reason to give fpr, such as explicit

        // import of private key, or similar.

        // Take given fpr as-is.

        // BUT:

        // First check to see if it's blacklisted or private part is missing?

        bool has_private = false;

        status = _has_usable_priv_key(session, identity->fpr, &has_private); 

        // N.B. has_private is never true if the returned status is not PEP_STATUS_OK

        if (has_private) {

            dont_use_input_fpr = false;

        }

    }

    // Ok, we failed to get keys either way, so let's elect one.

    if (dont_use_input_fpr && dont_use_stored_fpr)

    {

        status = elect_ownkey(session, identity);

        assert(status == PEP_STATUS_OK);

        if (status != PEP_STATUS_OK) {

            return ADD_TO_LOG(status);

        }

        bool has_private = false;

        if (identity->fpr) {

            // ok, we elected something.

            // elect_ownkey only returns private keys, so we don't check again.

            // Check to see if it's blacklisted

            bool listed;

            status = blacklist_is_listed(session, identity->fpr, &listed); 

            if (status == PEP_STATUS_OK)

                has_private = !listed;

        }

        if (has_private) {

            dont_use_input_fpr = false;

        }

        else { // OK, we've tried everything. Time to generate new keys.

            free(identity->fpr); // It can stay in this state (unallocated) because we'll generate a new key 

            identity->fpr = NULL;

        }

    }

    bool revoked = false;

    char *r_fpr = NULL;

    if (!EMPTYSTR(identity->fpr))

    {

        status = key_revoked(session, identity->fpr, &revoked);

        if (status != PEP_STATUS_OK) 

        {

            return ADD_TO_LOG(status);

        }

    }

    if (EMPTYSTR(identity->fpr) || revoked)

    {

        if(!do_keygen){

            return ADD_TO_LOG(PEP_GET_KEY_FAILED);

        }

        if(revoked)

        {

            r_fpr = identity->fpr;

            identity->fpr = NULL;

        }

        DEBUG_LOG("generating key pair", "debug", identity->address);

        status = generate_keypair(session, identity);

        assert(status != PEP_OUT_OF_MEMORY);

        if (status != PEP_STATUS_OK) {

            char buf[11];

            snprintf(buf, 11, "%d", status);

            DEBUG_LOG("generating key pair failed", "debug", buf);

            if(revoked && r_fpr)

                free(r_fpr);

            return ADD_TO_LOG(status);