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

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

    char* fpr = ident->fpr;

    PEP_comm_type ct = ident->comm_type;

    bool done = false;

    bool revoked, expired;

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

    assert(status == PEP_STATUS_OK);

    if (status != PEP_STATUS_OK) {

         // only happens when there was a problem

         // retrieving key.

         ADD_TO_LOG(status);

     }

    status = key_expired(session, identity->fpr, 

                         time(NULL) + (7*24*3600), // In a week

                         &expired);

    assert(status == PEP_STATUS_OK);

    if (status != PEP_STATUS_OK)

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

            // 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

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

    PEP_STATUS status = PEP_STATUS_OK;

    if (!stored_identity || !stored_identity->user_id)

        return PEP_ILLEGAL_VALUE;

    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)

            return status;

    }

    // if no valid default stored identity key found

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

    bool found = false;

    if (result == SQLITE_ROW) {

        user_fpr = 

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

        if (user_fpr)

            found = true;

    }

    if (!found)

        return NULL;

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

    // FIXME: we have to be able to validate comm_type too.

    retval = validate_fpr(session, user_fpr, WTF,

                          stored_identity->me);

    if (!retval) {

    }

    return retval;

}

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;

    if (identity->user_id) {            

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

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

        status = get_identity_without_fpr(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?

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

                }

            }

        } 

        // Ok, now we start the real algorithm:

        if (identity->username) {

            /*

             * Retrieving information of an identity with username supplied

             *      Input: user_id, address, username

             */

            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

                status = get_valid_pubkey(session, stored_ident);

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

                        identity->comm_type = stored_ident->comm_type;

                    }

                }

                else {

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

                }

                //    * call set_identity() to store

                status = set_identity(identity);

            }

            //  * else (identity unavailable)

            else {

            //      * create identity with user_id, address, username

            //    * search for a temporary identity for address and username

            //    * if temporary identity available

            //      * modify identity with username

            //    * else

            //    * call set_identity() to store

            //  * Return: modified or created identity

             // 

            }

        }

        else {

            /*

             * Retrieving information of an identity without username supplied

             *      Input: user_id, address

             */

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

            //    * if identity not available

            //      * return error status (identity not found)

            //    * else

            //      * 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: identity if available

        }

    }

    else if (identity->username) {

        /*

         * Temporary identity information with username supplied

            * Input: address, username (no others)

         */

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

        //  * if one found

        //    * find 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

        //  * if many found

        //    * Return the one with newest modification date (yes, this is a heuristics)

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

        }

        if(revoked)

        {

            status = set_revoked(session, r_fpr,

                                 identity->fpr, time(NULL));

            free(r_fpr);

            if (status != PEP_STATUS_OK) {

                return ADD_TO_LOG(status);

            }

        }

    }

    else

    {

        bool expired;

        status = key_expired(session, identity->fpr, 

                             time(NULL) + (7*24*3600), // In a week

                             &expired);

        assert(status == PEP_STATUS_OK);

        if (status != PEP_STATUS_OK) {

            return ADD_TO_LOG(status);

        }

        if (status == PEP_STATUS_OK && expired) {

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

            renew_key(session, identity->fpr, ts);

            free_timestamp(ts);

        }

    }

    if (!identity->username)

        identity->username = strdup("");

    status = set_identity(session, identity);

    assert(status == PEP_STATUS_OK);

    if (status != PEP_STATUS_OK) {

        return status;

    }

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

}

DYNAMIC_API PEP_STATUS register_examine_function(

        PEP_SESSION session, 

        examine_identity_t examine_identity,

        void *management

    )

{

    assert(session);

    if (!session)

        return PEP_ILLEGAL_VALUE;

    session->examine_management = management;

    session->examine_identity = examine_identity;

    return PEP_STATUS_OK;

}

DYNAMIC_API PEP_STATUS do_keymanagement(

        retrieve_next_identity_t retrieve_next_identity,

        void *management

    )

{

    PEP_SESSION session;

    pEp_identity *identity;

    PEP_STATUS status;

    assert(retrieve_next_identity);

    assert(management);

    if (!retrieve_next_identity || !management)

        return PEP_ILLEGAL_VALUE;

    status = init(&session);

    assert(status == PEP_STATUS_OK);

    if (status != PEP_STATUS_OK)

        return status;

    log_event(session, "keymanagement thread started", "pEp engine", NULL, NULL);