trunk/Src/wptKeyEditCB.cpp

/* wptKeyEditCB.cpp - Key edit callback handling
 *      Copyright (C) 2005 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of WinPT.
 *
 * WinPT 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 2 
 * of the License, or (at your option) any later version.
 *  
 * WinPT 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 WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <windows.h>

#include "gpgme.h"
#include "wptCommonCtl.h"
#include "wptContext.h"
#include "wptKeyEdit.h"
#include "wptErrors.h"

/* Possible errors for the edit key operation. */
enum editkey_error_t {
    EDITKEY_ERR_ALREADY_SIGNED = 1,
    EDITKEY_ERR_BAD_PASSPHRASE = 2
};

/* 'keyserver' command handler. */
static const char*
cmd_keyserv_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    static char buf[32];

    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        sprintf (buf, "uid %d", ctx->uid_index);
        return buf;
    }
    if (!strcmp (key, "keyedit.prompt") && !ctx->cnt) {
        ctx->cnt = 1;
        return "keyserver";
    }
    if (!strcmp (key, "keyedit.add_keyserver"))
        return ctx->url;
    if ( !strcmp (key, "keyedit.confirm_keyserver"))
        return "Y";
    if (!strcmp (key, "passphrase.enter"))
        return ctx->pass;
    if (!strcmp (key, "keyedit.prompt") && ctx->cnt == 1) {
        ctx->reset ();
        return "save";
    }

    return NULL;
}


/* 'sign' command handler. */
static const char*
cmd_sign_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    static char buf[32];

    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        switch (ctx->getType ()) {
        case GPG_EDITKEY_SIGN: return "sign";
        case GPG_EDITKEY_TSIGN: return "tsign";
        case GPG_EDITKEY_LSIGN: return "lsign";
        case GPG_EDITKEY_NRSIGN: return"nrsign";
        case GPG_EDITKEY_NRLSIGN: return "nrlsign";
        }
    }
    if (!strcmp (key, "sign_uid.class")) {
        sprintf (buf, "%d", ctx->sig_class);
        return buf;
    }
    if (!strcmp (key, "sign_uid.expire"))
        return "Y"; /* the sig expires when the key expires */
    if (!strcmp (key, "siggen.valid"))
        return ctx->exp_date;
    if (!strcmp (key, "trustsig_prompt.trust_value")) {
        sprintf (buf, "%d", ctx->trust_id);
        return buf;
    }
    if (!strcmp (key, "trustsig_prompt.trust_depth"))
        return ""; /* fixme */
    if (!strcmp (key, "trustsig_prompt.trust_regexp"))
        return ""; /* fixme */
    if (!strcmp (key, "sign_uid.local_promote_okay" ) )
        return "Y";
    if (!strcmp (key, "sign_uid.okay" ) )
        return "Y";
    if (!strcmp (key, "keyedit.sign_all.okay"))
        return "Y";
    if (!strcmp ( key, "passphrase.enter")) 
        return ctx->pass;
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }
    
    return NULL;
}

/* 'trust' command handler. */
static const char*
cmd_trust_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    static char buf[4];

    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "trust";
    }
    if (!strcmp (key, "edit_ownertrust.set_ultimate.okay"))
        return "Y";
    if (!strcmp (key, "edit_ownertrust.value" )) {
        sprintf (buf, "%d", ctx->trust_id);
        return buf;
    }
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }

    return NULL;
}


/* 'adduid' command handler. */
static const char*
cmd_adduid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "adduid";
    }
    if (!strcmp (key, "keygen.name"))
        return ctx->name;
    if (!strcmp (key, "keygen.email"))
        return ctx->email;
    if (!strcmp (key, "keygen.comment"))
        return ctx->cmt? ctx->cmt : "";
    if (!strcmp (key, "passphrase.enter"))
        return ctx->pass;
    if( !strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }
 
    return NULL;
}


static const char*
cmd_deluid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key,
                    int *r_step)
{
    static char buf[64];
    int step = *r_step;

    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        sprintf (buf, "uid %d", ctx->uid_index);
        *r_step = step = 1;
        return buf;
    }
    if (step == 1 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 2;
        return "deluid";
    }
    if (step == 2 && !strcmp (key, "keyedit.remove.uid.okay")) {
        *r_step = step = 3;
        return "Y";
    }
    if (step == 3 && !strcmp (key, "keyedit.prompt" )) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    
    return NULL;
}


static const char *
cmd_delsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char * key,
                    int * r_step)
{
    static char buf[64];
    int step = *r_step;

    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        sprintf (buf, "uid %d", ctx->uid_index);
        *r_step = step = 1;
        return buf;
    }
    if (step == 1 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 2;
        return "delsig";
    }
    if (!strcmp (key, "keyedit.delsig.unknown") ||
        !strcmp (key, "keyedit.delsig.valid")) {
        if (++ctx->cnt == ctx->sig_index)
            return "Y";
        else
            return "N";
    }
    if (!strcmp (key, "keyedit.delsig.selfsig"))
        return "Y";
    if (step == 2 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    return NULL;
}


/* 'delkey' command handler. */
static const char*
cmd_delkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                    const char *key, int *r_step )
{
    static char buf[64];
    int step = *r_step;

    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        sprintf (buf, "key %d", ctx->key_index);
        *r_step = step = 1;
        return buf;
    }
    if (step == 1 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 2;
        return "delkey";
    }
    if (step == 2 && !strcmp (key, "keyedit.remove.subkey.okay")) {
        *r_step = step = 3;
        return "Y";
    }
    if (step == 3 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }

    return NULL;
}


/* 'addkey' command handler. */
static const char*
cmd_addkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    static char buf[64];

    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "addkey";
    }

    if (!strcmp (key, "passphrase.enter"))
        return ctx->pass;
    if (!strcmp (key, "keygen.algo")) {
        _snprintf (buf, sizeof (buf)-1, "%d", ctx->pubkey_algo);
        return buf;
    }   
    if (!strcmp (key, "keygen.size")) {
        _snprintf (buf, sizeof (buf)-1, "%d", ctx->pubkey_size);
        return buf;
    }
    if (!strcmp (key, "keygen.valid")) {
        _snprintf (buf, sizeof (buf)-1, "%d", ctx->valid);
        return buf;        
    }
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }
    return NULL;
}

/* 'passwd' command handler. */
static const char*
cmd_passwd_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "passwd";
    }
    if (!ctx->cnt && !strcmp (key, "passphrase.enter")) {
        ctx->cnt = 1;
        return ctx->pass;
    }
    if (!strcmp (key, "passphrase.enter" ))
        return ctx->new_pass;
    if (!strcmp (key, "change_passwd.empty.okay" ))
        return ctx->flags?  "Y" : "N";
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }

    return NULL;
} 


static const char*
cmd_setpref_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char * key)
{
    static char buf[128];

    /* XXX: check the code. */
#if 0
    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "";
    }
    if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 0) {
        ctx->u.pref.id++;
        _snprintf (buf, sizeof buf-1, "setpref %s", ctx->u.pref.new_prefs);
        return buf;
    }
    if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 1) {
        ctx->u.pref.id++;
        return "updpref";
    }
    if (!strcmp ( key, "keyedit.updpref.okay"))
        return "Y";
    if (!strcmp (key, "passphrase.enter"))
        return ctx->u.pref.passwd;
    if (!strcmp (key, "keyedit.prompt") && ctx->u.pref.id == 2) {
        ctx->u.pref.id = 0;
        ctx->reset ();
        return "save";
    }
#endif
    return NULL;
}


/* 'primary' command handler. */
static const char*
cmd_primary_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                     const char *key, int *r_step )
{
    static char buf[64];
    int step = *r_step;

    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        sprintf (buf, "uid %d", ctx->uid_index);
        *r_step = step = 1;
        return buf;
    }
    if (step == 1 && !strcmp (key, "keyedit.prompt" )) {
        *r_step = step = 2;
        return "primary";
    }
    if (step == 2 && !strcmp (key, "passphrase.enter")) {
        *r_step = step = 3;
        return ctx->pass;
    }
    if (step == 3 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    return NULL;
}

/* 'expire' command handler. */
static const char*
cmd_expire_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                    const char *key, int *r_step )
{
    static char buf[64];
    int step = *r_step;

    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        sprintf (buf, "key %d", ctx->key_index);
        *r_step = step = 1;
        return buf;
    }
    if (step == 1 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 2;
        return "expire";
    }
    if( step == 2 && !strcmp ( key, "keygen.valid" ) ) {
        *r_step = step = 3;
        sprintf (buf, "%d", ctx->valid);
        return buf;
    }
    if (step == 3 && !strcmp (key, "passphrase.enter")) {
        *r_step = step = 4; 
        return ctx->pass;
    }
    if (step == 4 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    
    return NULL;
}


/* 'revuid' command handler. */
const char*
cmd_revuid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
                    const char *key, int *r_step)
{
    static char buf[32];
    int step = *r_step;
    
    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 1;
        sprintf (buf, "uid %d", ctx->uid_index);
        return buf;
    }
    else if (step == 1 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 2;
        return "revuid";
    }
    else if (step == 2 && !strcmp (key, "keyedit.revoke.uid.okay")) {
        *r_step = step = 3;
        return "Y";
    }
    else if (step == 3 && !strcmp (key, "ask_revocation_reason.code")) {
        *r_step = step = 4;
        return "4";
    }
    else if (step == 4 && !strcmp (key, "ask_revocation_reason.text")) {
        *r_step = step = 5;
        return "";
    }
    else if (step == 5 && !strcmp (key, "ask_revocation_reason.okay")) {
        *r_step = step = 6;
        return "Y";
    }
    else if (step == 6 && !strcmp (key, "passphrase.enter")) {
        *r_step = step = 7;
        return ctx->pass;
    }
    else if (step == 7 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    return NULL;
}


const char*
cmd_revsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                    const char *key, int *r_step)
{
    static char buf[64];
    int step = *r_step;
    
    if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {
        sprintf( buf, "uid %d", ctx->uid_index);
        *r_step = step = 1;
        return buf;
    }
    if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {
        *r_step = step = 2;
        return "revsig";
    }
    if( step == 2 && !strcmp (key, "ask_revoke_sig.one" ) ) {
        *r_step = step = 3;
        return "Y";
    }
    if( step == 3 && !strcmp (key, "ask_revoke_sig.okay" ) ) {
        *r_step = step = 4;
        return "Y";
    }
    if( step == 4 && !strcmp ( key, "ask_revocation_reason.code" ) ) {
        *r_step = step = 5;
        return "0";
    }
    if( step == 5 && !strcmp ( key, "ask_revocation_reason.text" ) ) {
        *r_step = step = 6;
        return "";
    }
    if( step == 6 && !strcmp (key, "ask_revocation_reason.okay" ) ) {
        *r_step = step = 7;
        return "Y";
    }
    if( step == 7 && !strcmp (key, "passphrase.enter" ) ) {
        *r_step = step = 8;
        return ctx->pass;
    }
    if( step == 8 && !strcmp ( key, "keyedit.prompt" ) ) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    
    return NULL;
}


/* 'revoke' command handler. */
static const char *
cmd_revkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                    const char * key, int *r_step)
{
    int step = *r_step;
    static char buf[64];

    if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {
        sprintf( buf, "key %d", ctx->key_index);
        *r_step = step = 1;
        return buf;
    }
    if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {
        *r_step = step = 2;
        return "revkey";
    }
    if( step == 2 && !strcmp (key, "keyedit.revoke.subkey.okay" ) ) {
        *r_step = step = 3;
        return "Y";
    }
    if( step == 3 &&  !strcmp ( key, "ask_revocation_reason.code" ) ) {
        sprintf( buf, "%d", ctx->reason);
        *r_step = step = 4;
        return buf;
    }
    if( step == 4 && !strcmp ( key, "ask_revocation_reason.text" ) ) {
        *r_step = step = 5;
        return "";
    }
    if( step == 5 && !strcmp (key, "ask_revocation_reason.okay" ) ) {
        *r_step = step = 6;
        return "Y";
    }
    if( step == 6 && !strcmp (key, "passphrase.enter" ) ) {
        *r_step = step = 7;
        return ctx->pass;
    }
    if( step == 7 && !strcmp ( key, "keyedit.prompt" ) ) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }
    return NULL;
}


/* 'addrevoker' command handler. */
static const char *
cmd_addrev_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                    const char *key, int *r_step)
{
    int step = *r_step;

    /* If the isuser already signed the key, send an empty
           string and jump to quit. */
    if (ctx->getResult () & EDITKEY_ERR_ALREADY_SIGNED 
        && *r_step != -1 && *r_step != 4) {
        *r_step = step = -1;
        return "";
    }
    if (*r_step == -1) {
        *r_step = step = 4;
        return ""; /* empty value to abort. */
    }
    if (step == 0 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 1;
        return "addrevoker";
    }
    if (step == 1 && !strcmp (key, "keyedit.add_revoker")) {
        *r_step = step = 2;
        return ctx->name;
    }
    if (step == 2 && !strcmp (key, "keyedit.add_revoker.okay")) {
        *r_step = step = 3;
        return "Y";
    }
    if (step == 3 && !strcmp (key, "passphrase.enter")) {
        *r_step = step = 4;
        return ctx->pass;
    }
    if (step == 4 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 0;
        ctx->reset ();
        return "save";
    }

    return NULL;
}


/* 'addphoto' command handler. */
static const char*
cmd_addphoto_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
        ctx->cmd_sent = 1;
        return "addphoto";
    }
    if (!strcmp (key, "photoid.jpeg.add"))
        return ctx->url;
    if (!strcmp (key, "photoid.jpeg.size"))
        return "Y";
    if (!strcmp (key, "passphrase.enter"))
        return ctx->pass;
    if (!strcmp (key, "keyedit.prompt")) {      
        ctx->reset ();
        return "save";
    }
    return NULL;
}


/* 'clean' command handler. */
static const char*
cmd_clean_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, const char *key)
{
    if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
        ctx->cmd_sent = 1;
        return "clean";
    }
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }
    return NULL;
}


/* 'enable' and 'disable' command handler. */
static const char *
cmd_enable_disable_handler (GpgKeyEdit *ctx, gpgme_status_code_t code, 
                            const char * key, int mode)
{
    if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
        ctx->cmd_sent = 1;
        if (mode)
            return "disable";
        return "enable";
    }
    if (!strcmp (key, "keyedit.prompt")) {
        ctx->reset ();
        return "save";
    }
    return NULL;
}


/* edit key dispatch handler. */
static gpgme_error_t                     
editkey_command_handler (void *opaque, gpgme_status_code_t code, 
                         const char *key, int fd)
{
    static int step = 0; /* XXX use ke->cnt */
    const char *out = NULL;
    GpgKeyEdit *ke = (GpgKeyEdit *)opaque;
    HANDLE hd = (HANDLE)fd;
    DWORD n;
    
    if (!ke)
        return gpg_error (GPG_ERR_INV_ARG);

    /*log_debug ("key=%s code=%d\r\n", key, code);*/
    switch (code) {
    case GPGME_STATUS_ALREADY_SIGNED:
        ke->setResult (EDITKEY_ERR_ALREADY_SIGNED);
        break;

    case GPGME_STATUS_BAD_PASSPHRASE:
        ke->setResult (EDITKEY_ERR_BAD_PASSPHRASE);
        break;

    default:
        break;
    }

    if (ke->getResult () & EDITKEY_ERR_BAD_PASSPHRASE) {
        /* If the entered passphrase is bad, we supply empty
           passphrase to abort and send 'quit' as soon as possible. */
        if (!strcmp (key, "passphrase.enter"))
            WriteFile (hd, "\n", 1, &n, NULL);
        if (!strcmp (key, "keyedit.prompt"))
            WriteFile (hd, "quit\n", 5, &n, NULL);
        ke->reset ();
        step = 0;
        return 0;
    }
    
    switch (ke->getType ()) {
    case GPG_EDITKEY_LSIGN:
    case GPG_EDITKEY_SIGN:
    case GPG_EDITKEY_NRSIGN:
    case GPG_EDITKEY_TSIGN:
    case GPG_EDITKEY_NRLSIGN:
        out = cmd_sign_handler (ke, code, key);
        break;
        
    case GPG_EDITKEY_TRUST:
        out =  cmd_trust_handler (ke, code, key);
        break;
        
    case GPG_EDITKEY_ADDUID:
        out =  cmd_adduid_handler (ke, code, key);
        break;
        
    case GPG_EDITKEY_DELUID:
        out =  cmd_deluid_handler (ke, code, key, &step);
        break;
        
    case GPG_EDITKEY_DELSIG:
        out =  cmd_delsig_handler (ke, code, key, &step);
        break;

    case GPG_EDITKEY_DELKEY:
        out =  cmd_delkey_handler(ke, code, key, &step );
        break;
        
    case GPG_EDITKEY_ADDKEY:
        out =  cmd_addkey_handler (ke, code, key);
        break;
        
    case GPG_EDITKEY_PASSWD:
        out =  cmd_passwd_handler (ke, code, key);
        break;
        
    case GPG_EDITKEY_PRIMARY:
        out =  cmd_primary_handler (ke, code, key, &step);
        break;
        
    case GPG_EDITKEY_EXPIRE:
        out =  cmd_expire_handler (ke, code, key, &step);
        break;

    case GPG_EDITKEY_REVSIG:
        out =  cmd_revsig_handler (ke, code, key, &step);
        break;

    case GPG_EDITKEY_REVKEY:
        out =  cmd_revkey_handler (ke, code, key, &step);
        break;
            
    case GPG_EDITKEY_REVUID:
        out = cmd_revuid_handler (ke, code, key, &step);
        break;

    case GPG_EDITKEY_ADDREV:
        out =  cmd_addrev_handler (ke, code, key, &step);
        break;

    case GPG_EDITKEY_ADDPHOTO:
        out =  cmd_addphoto_handler (ke, code, key);
        break;

    case GPG_EDITKEY_CLEAN:
        out = cmd_clean_handler (ke, code, key);
        break;

    case GPG_EDITKEY_ENABLE:
    case GPG_EDITKEY_DISABLE:
        out = cmd_enable_disable_handler (ke, code, key, 
                                          ke->getType () == GPG_EDITKEY_DISABLE? 1: 0);
        break; 

    case GPG_EDITKEY_SETPREF:
        out =  cmd_setpref_handler (ke, code, key);
        break;

    case GPG_EDITKEY_KEYSERV:
        out =  cmd_keyserv_handler (ke, code, key);
        break;
    }

    if (out != NULL) {
        /* XXX: check return codes. */
        WriteFile (hd, out, strlen (out), &n, NULL);
        WriteFile (hd, "\n", 1, &n, NULL);
    }
    return 0;
}


/* Check if a GPG status code occured which marks the
   current operation as failed.
   Return value: gpg error constant. */
static gpgme_error_t 
map_result (GpgKeyEdit *ke)
{
    /* XXX Sometimes ALREADY_SIGNED indicates an failure. */
    if (!ke->getResult ())
        return gpg_error (GPG_ERR_NO_ERROR);
    if (ke->getResult () & EDITKEY_ERR_BAD_PASSPHRASE)
        return gpg_error (GPG_ERR_BAD_PASSPHRASE);
    return 0;
}


/* Wrapper around the gpgme edit interface.
   @ctx context to use.
   @key key on which the operation should be performed.
   @ek  key edit context.
   Return value: 0 on success. */
gpgme_error_t
gpg_editkey (gpgme_ctx_t ctx, gpgme_key_t key, GpgKeyEdit *ek)
{
    gpgme_error_t err;
    gpgme_data_t out;
  
    err = gpgme_data_new (&out);
    if (err)
        return err;
    err = gpgme_op_edit (ctx, key, editkey_command_handler, ek, out);
    if (!err)
        err = map_result (ek);

    gpgme_data_release (out);
    return err;
}