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


/* '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;
}


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 (ctx->sig_index == 0 &&
        !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( !strcmp (key, "passphrase.enter") && !ctx->cnt) {
        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)
{
    /* XXX: check the code. */
#if 0
    static char buf[128];
    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 (step == 0 && !strcmp (key, "keyedit.prompt")) {
        *r_step = step = 1;
        return "addrevoker";
    }
    if (step == 1 && !strcmp (key, "keyedit.add_revoker")) {
        *r_step = step = 2;
        /* XXX: handle already-signed. */
        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;
}

/* '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;
    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 (GPG_EDITRES_ALREADY_SIGNED);
        break;
    case GPGME_STATUS_BAD_PASSPHRASE:
        ke->setResult (GPG_EDITRES_BAD_PASSPHRASE);
        break;
        
    default:
        break;
    }

    if (ke->getResult () & GPG_EDITRES_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);
    }
    
    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_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)
{
    if (!ke->getResult ())
        return gpg_error (GPG_ERR_NO_ERROR);
    if (ke->getResult () & GPG_EDITRES_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;
}
1	/* wptKeyEditCB.cpp - Key edit callback handling
2	* Copyright (C) 2005 Timo Schulz
3	* Copyright (C) 2005 g10 Code GmbH
4	*
5	* This file is part of WinPT.
6	*
7	* WinPT is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU General Public License
9	* as published by the Free Software Foundation; either version 2
10	* of the License, or (at your option) any later version.
11	*
12	* WinPT is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	* General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with WinPT; if not, write to the Free Software Foundation,
19	* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20	*/
21	#ifdef HAVE_CONFIG_H
22	#include <config.h>
23	#endif
24
25	#include <stdio.h>
26	#include <stdio.h>
27	#include <string.h>
28	#include <stdlib.h>
29	#include <assert.h>
30	#include <windows.h>
31
32	#include "gpgme.h"
33	#include "wptCommonCtl.h"
34	#include "wptContext.h"
35	#include "wptKeyEdit.h"
36	#include "wptErrors.h"
37
38
39	/* 'keyserver' command handler. */
40	static const char*
41	cmd_keyserv_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
42	{
43	static char buf[32];
44
45	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
46	ctx->cmd_sent = 1;
47	sprintf (buf, "uid %d", ctx->uid_index);
48	return buf;
49	}
50	if (!strcmp (key, "keyedit.prompt") && !ctx->cnt) {
51	ctx->cnt = 1;
52	return "keyserver";
53	}
54	if (!strcmp (key, "keyedit.add_keyserver"))
55	return ctx->url;
56	if ( !strcmp (key, "keyedit.confirm_keyserver"))
57	return "Y";
58	if (!strcmp (key, "passphrase.enter"))
59	return ctx->pass;
60	if (!strcmp (key, "keyedit.prompt") && ctx->cnt == 1) {
61	ctx->reset ();
62	return "save";
63	}
64
65	return NULL;
66	}
67
68
69	static const char*
70	cmd_sign_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
71	{
72	static char buf[32];
73
74	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
75	ctx->cmd_sent = 1;
76	switch (ctx->getType ()) {
77	case GPG_EDITKEY_SIGN: return "sign";
78	case GPG_EDITKEY_TSIGN: return "tsign";
79	case GPG_EDITKEY_LSIGN: return "lsign";
80	case GPG_EDITKEY_NRSIGN: return"nrsign";
81	case GPG_EDITKEY_NRLSIGN: return "nrlsign";
82	}
83	}
84	if (!strcmp (key, "sign_uid.class")) {
85	sprintf (buf, "%d", ctx->sig_class);
86	return buf;
87	}
88	if (!strcmp (key, "sign_uid.expire"))
89	return "Y"; /* the sig expires when the key expires */
90	if (!strcmp (key, "siggen.valid"))
91	return ctx->exp_date;
92	if (!strcmp (key, "trustsig_prompt.trust_value")) {
93	sprintf (buf, "%d", ctx->trust_id);
94	return buf;
95	}
96	if (!strcmp (key, "trustsig_prompt.trust_depth"))
97	return ""; /* fixme */
98	if (!strcmp (key, "trustsig_prompt.trust_regexp"))
99	return ""; /* fixme */
100	if (!strcmp (key, "sign_uid.local_promote_okay" ) )
101	return "Y";
102	if (!strcmp (key, "sign_uid.okay" ) )
103	return "Y";
104	if (!strcmp (key, "keyedit.sign_all.okay"))
105	return "Y";
106	if (!strcmp ( key, "passphrase.enter"))
107	return ctx->pass;
108	if (!strcmp (key, "keyedit.prompt")) {
109	ctx->reset ();
110	return "save";
111	}
112
113	return NULL;
114	}
115
116	/* 'trust' command handler. */
117	static const char*
118	cmd_trust_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
119	{
120	static char buf[4];
121
122	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
123	ctx->cmd_sent = 1;
124	return "trust";
125	}
126	if (!strcmp (key, "edit_ownertrust.set_ultimate.okay"))
127	return "Y";
128	if (!strcmp (key, "edit_ownertrust.value" )) {
129	sprintf (buf, "%d", ctx->trust_id);
130	return buf;
131	}
132	if (!strcmp (key, "keyedit.prompt")) {
133	ctx->reset ();
134	return "save";
135	}
136
137	return NULL;
138	}
139
140
141	/* 'adduid' command handler. */
142	static const char*
143	cmd_adduid_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
144	{
145	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
146	ctx->cmd_sent = 1;
147	return "adduid";
148	}
149	if (!strcmp (key, "keygen.name"))
150	return ctx->name;
151	if (!strcmp (key, "keygen.email"))
152	return ctx->email;
153	if (!strcmp (key, "keygen.comment"))
154	return ctx->cmt? ctx->cmt : "";
155	if (!strcmp (key, "passphrase.enter"))
156	return ctx->pass;
157	if( !strcmp (key, "keyedit.prompt")) {
158	ctx->reset ();
159	return "save";
160	}
161
162	return NULL;
163	}
164
165
166	static const char*
167	cmd_deluid_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key,
168	int *r_step)
169	{
170	static char buf[64];
171	int step = *r_step;
172
173	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
174	sprintf (buf, "uid %d", ctx->uid_index);
175	*r_step = step = 1;
176	return buf;
177	}
178	if (step == 1 && !strcmp (key, "keyedit.prompt")) {
179	*r_step = step = 2;
180	return "deluid";
181	}
182	if (step == 2 && !strcmp (key, "keyedit.remove.uid.okay")) {
183	*r_step = step = 3;
184	return "Y";
185	}
186	if (step == 3 && !strcmp (key, "keyedit.prompt" )) {
187	*r_step = step = 0;
188	ctx->reset ();
189	return "save";
190	}
191
192	return NULL;
193	}
194
195
196	static const char *
197	cmd_delsig_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key,
198	int * r_step)
199	{
200	static char buf[64];
201	int step = *r_step;
202
203	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
204	sprintf (buf, "uid %d", ctx->uid_index);
205	*r_step = step = 1;
206	return buf;
207	}
208	if (step == 1 && !strcmp (key, "keyedit.prompt")) {
209	*r_step = step = 2;
210	return "delsig";
211	}
212	if (!strcmp (key, "keyedit.delsig.unknown") \|\|
213	!strcmp (key, "keyedit.delsig.valid")) {
214	if (++ctx->cnt == ctx->sig_index)
215	return "Y";
216	else
217	return "N";
218	}
219	if (ctx->sig_index == 0 &&
220	!strcmp (key, "keyedit.delsig.selfsig"))
221	return "Y";
222	if (step == 2 && !strcmp (key, "keyedit.prompt")) {
223	*r_step = step = 0;
224	ctx->reset ();
225	return "save";
226	}
227	return NULL;
228	}
229
230
231	/* 'delkey' command handler. */
232	static const char*
233	cmd_delkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
234	const char key, int r_step )
235	{
236	static char buf[64];
237	int step = *r_step;
238
239	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
240	sprintf (buf, "key %d", ctx->key_index);
241	*r_step = step = 1;
242	return buf;
243	}
244	if (step == 1 && !strcmp (key, "keyedit.prompt")) {
245	*r_step = step = 2;
246	return "delkey";
247	}
248	if (step == 2 && !strcmp (key, "keyedit.remove.subkey.okay")) {
249	*r_step = step = 3;
250	return "Y";
251	}
252	if (step == 3 && !strcmp (key, "keyedit.prompt")) {
253	*r_step = step = 0;
254	ctx->reset ();
255	return "save";
256	}
257
258	return NULL;
259	}
260
261
262	/* 'addkey' command handler. */
263	static const char*
264	cmd_addkey_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
265	{
266	static char buf[64];
267
268	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
269	ctx->cmd_sent = 1;
270	return "addkey";
271	}
272
273	if (!strcmp (key, "passphrase.enter"))
274	return ctx->pass;
275	if (!strcmp (key, "keygen.algo")) {
276	_snprintf (buf, sizeof buf-1, "%d", ctx->pubkey_algo);
277	return buf;
278	}
279	if (!strcmp (key, "keygen.size")) {
280	_snprintf (buf, sizeof buf-1, "%d", ctx->pubkey_size);
281	return buf;
282	}
283	if (!strcmp (key, "keygen.valid")) {
284	_snprintf (buf, sizeof buf-1, "%d", ctx->valid);
285	return buf;
286	}
287	if (!strcmp (key, "keyedit.prompt")) {
288	ctx->reset ();
289	return "save";
290	}
291	return NULL;
292	}
293
294	/* 'passwd' command handler. */
295	static const char*
296	cmd_passwd_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
297	{
298	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
299	ctx->cmd_sent = 1;
300	return "passwd";
301	}
302	if( !strcmp (key, "passphrase.enter") && !ctx->cnt) {
303	ctx->cnt = 1;
304	return ctx->pass;
305	}
306	if( !strcmp (key, "passphrase.enter" ))
307	return ctx->new_pass;
308	if( !strcmp (key, "change_passwd.empty.okay" ))
309	return ctx->flags? "Y" : "N";
310	if (!strcmp (key, "keyedit.prompt")) {
311	ctx->reset ();
312	return "save";
313	}
314	return NULL;
315	}
316
317
318	static const char*
319	cmd_setpref_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
320	{
321	/* XXX: check the code. */
322	#if 0
323	static char buf[128];
324	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
325	ctx->cmd_sent = 1;
326	return "";
327	}
328	if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 0) {
329	ctx->u.pref.id++;
330	_snprintf (buf, sizeof buf-1, "setpref %s", ctx->u.pref.new_prefs);
331	return buf;
332	}
333	if (!strcmp ( key, "keyedit.prompt") && ctx->u.pref.id == 1) {
334	ctx->u.pref.id++;
335	return "updpref";
336	}
337	if (!strcmp ( key, "keyedit.updpref.okay"))
338	return "Y";
339	if (!strcmp (key, "passphrase.enter"))
340	return ctx->u.pref.passwd;
341	if (!strcmp (key, "keyedit.prompt") && ctx->u.pref.id == 2) {
342	ctx->u.pref.id = 0;
343	ctx->reset ();
344	return "save";
345	}
346	#endif
347	return NULL;
348	}
349
350
351	/* 'primary' command handler. */
352	static const char*
353	cmd_primary_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
354	const char key, int r_step )
355	{
356	static char buf[64];
357	int step = *r_step;
358
359	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
360	sprintf (buf, "uid %d", ctx->uid_index);
361	*r_step = step = 1;
362	return buf;
363	}
364	if (step == 1 && !strcmp (key, "keyedit.prompt" )) {
365	*r_step = step = 2;
366	return "primary";
367	}
368	if (step == 2 && !strcmp (key, "passphrase.enter")) {
369	*r_step = step = 3;
370	return ctx->pass;
371	}
372	if (step == 3 && !strcmp (key, "keyedit.prompt")) {
373	*r_step = step = 0;
374	ctx->reset ();
375	return "save";
376	}
377	return NULL;
378	}
379
380	/* 'expire' command handler. */
381	static const char*
382	cmd_expire_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
383	const char key, int r_step )
384	{
385	static char buf[64];
386	int step = *r_step;
387
388	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
389	sprintf (buf, "key %d", ctx->key_index);
390	*r_step = step = 1;
391	return buf;
392	}
393	if (step == 1 && !strcmp (key, "keyedit.prompt")) {
394	*r_step = step = 2;
395	return "expire";
396	}
397	if( step == 2 && !strcmp ( key, "keygen.valid" ) ) {
398	*r_step = step = 3;
399	sprintf (buf, "%d", ctx->valid);
400	return buf;
401	}
402	if (step == 3 && !strcmp (key, "passphrase.enter")) {
403	*r_step = step = 4;
404	return ctx->pass;
405	}
406	if (step == 4 && !strcmp (key, "keyedit.prompt")) {
407	*r_step = step = 0;
408	ctx->reset ();
409	return "save";
410	}
411
412	return NULL;
413	}
414
415
416	/* 'revuid' command handler. */
417	const char*
418	cmd_revuid_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
419	const char key, int r_step)
420	{
421	static char buf[32];
422	int step = *r_step;
423
424	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
425	*r_step = step = 1;
426	sprintf (buf, "uid %d", ctx->uid_index);
427	return buf;
428	}
429	else if (step == 1 && !strcmp (key, "keyedit.prompt")) {
430	*r_step = step = 2;
431	return "revuid";
432	}
433	else if (step == 2 && !strcmp (key, "keyedit.revoke.uid.okay")) {
434	*r_step = step = 3;
435	return "Y";
436	}
437	else if (step == 3 && !strcmp (key, "ask_revocation_reason.code")) {
438	*r_step = step = 4;
439	return "4";
440	}
441	else if (step == 4 && !strcmp (key, "ask_revocation_reason.text")) {
442	*r_step = step = 5;
443	return "";
444	}
445	else if (step == 5 && !strcmp (key, "ask_revocation_reason.okay")) {
446	*r_step = step = 6;
447	return "Y";
448	}
449	else if (step == 6 && !strcmp (key, "passphrase.enter")) {
450	*r_step = step = 7;
451	return ctx->pass;
452	}
453	else if (step == 7 && !strcmp (key, "keyedit.prompt")) {
454	*r_step = step = 0;
455	ctx->reset ();
456	return "save";
457	}
458	return NULL;
459	}
460
461
462	const char*
463	cmd_revsig_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
464	const char key, int r_step)
465	{
466	static char buf[64];
467	int step = *r_step;
468
469	if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {
470	sprintf( buf, "uid %d", ctx->uid_index);
471	*r_step = step = 1;
472	return buf;
473	}
474	if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {
475	*r_step = step = 2;
476	return "revsig";
477	}
478	if( step == 2 && !strcmp (key, "ask_revoke_sig.one" ) ) {
479	*r_step = step = 3;
480	return "Y";
481	}
482	if( step == 3 && !strcmp (key, "ask_revoke_sig.okay" ) ) {
483	*r_step = step = 4;
484	return "Y";
485	}
486	if( step == 4 && !strcmp ( key, "ask_revocation_reason.code" ) ) {
487	*r_step = step = 5;
488	return "0";
489	}
490	if( step == 5 && !strcmp ( key, "ask_revocation_reason.text" ) ) {
491	*r_step = step = 6;
492	return "";
493	}
494	if( step == 6 && !strcmp (key, "ask_revocation_reason.okay" ) ) {
495	*r_step = step = 7;
496	return "Y";
497	}
498	if( step == 7 && !strcmp (key, "passphrase.enter" ) ) {
499	*r_step = step = 8;
500	return ctx->pass;
501	}
502	if( step == 8 && !strcmp ( key, "keyedit.prompt" ) ) {
503	*r_step = step = 0;
504	ctx->reset ();
505	return "save";
506	}
507
508	return NULL;
509	}
510
511
512	/* 'revoke' command handler. */
513	static const char *
514	cmd_revkey_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
515	const char * key, int *r_step)
516	{
517	int step = *r_step;
518	static char buf[64];
519
520	if( step == 0 && !strcmp ( key, "keyedit.prompt" ) ) {
521	sprintf( buf, "key %d", ctx->key_index);
522	*r_step = step = 1;
523	return buf;
524	}
525	if( step == 1 && !strcmp ( key, "keyedit.prompt" ) ) {
526	*r_step = step = 2;
527	return "revkey";
528	}
529	if( step == 2 && !strcmp (key, "keyedit.revoke.subkey.okay" ) ) {
530	*r_step = step = 3;
531	return "Y";
532	}
533	if( step == 3 && !strcmp ( key, "ask_revocation_reason.code" ) ) {
534	sprintf( buf, "%d", ctx->reason);
535	*r_step = step = 4;
536	return buf;
537	}
538	if( step == 4 && !strcmp ( key, "ask_revocation_reason.text" ) ) {
539	*r_step = step = 5;
540	return "";
541	}
542	if( step == 5 && !strcmp (key, "ask_revocation_reason.okay" ) ) {
543	*r_step = step = 6;
544	return "Y";
545	}
546	if( step == 6 && !strcmp (key, "passphrase.enter" ) ) {
547	*r_step = step = 7;
548	return ctx->pass;
549	}
550	if( step == 7 && !strcmp ( key, "keyedit.prompt" ) ) {
551	*r_step = step = 0;
552	ctx->reset ();
553	return "save";
554	}
555	return NULL;
556	}
557
558
559	/* 'addrevoker' command handler. */
560	static const char *
561	cmd_addrev_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
562	const char * key, int * r_step)
563	{
564	int step = *r_step;
565
566	if (step == 0 && !strcmp (key, "keyedit.prompt")) {
567	*r_step = step = 1;
568	return "addrevoker";
569	}
570	if (step == 1 && !strcmp (key, "keyedit.add_revoker")) {
571	*r_step = step = 2;
572	/* XXX: handle already-signed. */
573	return ctx->name;
574	}
575	if (step == 2 && !strcmp (key, "keyedit.add_revoker.okay")) {
576	*r_step = step = 3;
577	return "Y";
578	}
579	if (step == 3 && !strcmp (key, "passphrase.enter")) {
580	*r_step = step = 4;
581	return ctx->pass;
582	}
583	if (step == 4 && !strcmp (key, "keyedit.prompt")) {
584	*r_step = step = 0;
585	ctx->reset ();
586	return "save";
587	}
588
589	return NULL;
590	}
591
592
593	/* 'addphoto' command handler. */
594	static const char*
595	cmd_addphoto_handler (GpgKeyEdit ctx, gpgme_status_code_t code, const char key)
596	{
597	if (!ctx->cmd_sent && !strcmp (key, "keyedit.prompt")) {
598	ctx->cmd_sent = 1;
599	return "addphoto";
600	}
601	if (!strcmp (key, "photoid.jpeg.add"))
602	return ctx->url;
603	if (!strcmp (key, "photoid.jpeg.size"))
604	return "Y";
605	if (!strcmp (key, "passphrase.enter"))
606	return ctx->pass;
607	if (!strcmp (key, "keyedit.prompt")) {
608	ctx->reset ();
609	return "save";
610	}
611	return NULL;
612	}
613
614	/* 'enable' and 'disable' command handler. */
615	static const char *
616	cmd_enable_disable_handler (GpgKeyEdit *ctx, gpgme_status_code_t code,
617	const char * key, int mode)
618	{
619	if (!strcmp (key, "keyedit.prompt") && !ctx->cmd_sent) {
620	ctx->cmd_sent = 1;
621	if (mode)
622	return "disable";
623	return "enable";
624	}
625	if (!strcmp (key, "keyedit.prompt")) {
626	ctx->reset ();
627	return "save";
628	}
629	return NULL;
630	}
631
632
633	/* edit key dispatch handler. */
634	static gpgme_error_t
635	editkey_command_handler (void *opaque, gpgme_status_code_t code,
636	const char *key, int fd)
637	{
638	static int step = 0;
639	const char *out = NULL;
640	GpgKeyEdit ke = (GpgKeyEdit )opaque;
641	HANDLE hd = (HANDLE)fd;
642	DWORD n;
643
644	if (!ke)
645	return gpg_error (GPG_ERR_INV_ARG);
646
647	/log_debug ("key=%s code=%d\r\n", key, code);/
648	switch (code) {
649	case GPGME_STATUS_ALREADY_SIGNED:
650	ke->setResult (GPG_EDITRES_ALREADY_SIGNED);
651	break;
652	case GPGME_STATUS_BAD_PASSPHRASE:
653	ke->setResult (GPG_EDITRES_BAD_PASSPHRASE);
654	break;
655
656	default:
657	break;
658	}
659
660	if (ke->getResult () & GPG_EDITRES_BAD_PASSPHRASE) {
661	/* If the entered passphrase is bad, we supply empty
662	passphrase to abort and send 'quit' as soon as possible. */
663	if (!strcmp (key, "passphrase.enter"))
664	WriteFile (hd, "\n", 1, &n, NULL);
665	if (!strcmp (key, "keyedit.prompt"))
666	WriteFile (hd, "quit\n", 5, &n, NULL);
667	}
668
669	switch (ke->getType ()) {
670	case GPG_EDITKEY_LSIGN:
671	case GPG_EDITKEY_SIGN:
672	case GPG_EDITKEY_NRSIGN:
673	case GPG_EDITKEY_TSIGN:
674	case GPG_EDITKEY_NRLSIGN:
675	out = cmd_sign_handler (ke, code, key);
676	break;
677
678	case GPG_EDITKEY_TRUST:
679	out = cmd_trust_handler (ke, code, key);
680	break;
681
682	case GPG_EDITKEY_ADDUID:
683	out = cmd_adduid_handler (ke, code, key);
684	break;
685
686	case GPG_EDITKEY_DELUID:
687	out = cmd_deluid_handler (ke, code, key, &step);
688	break;
689
690	case GPG_EDITKEY_DELSIG:
691	out = cmd_delsig_handler (ke, code, key, &step);
692	break;
693
694	case GPG_EDITKEY_DELKEY:
695	out = cmd_delkey_handler(ke, code, key, &step );
696	break;
697
698	case GPG_EDITKEY_ADDKEY:
699	out = cmd_addkey_handler (ke, code, key);
700	break;
701
702	case GPG_EDITKEY_PASSWD:
703	out = cmd_passwd_handler (ke, code, key);
704	break;
705
706	case GPG_EDITKEY_PRIMARY:
707	out = cmd_primary_handler (ke, code, key, &step);
708	break;
709
710	case GPG_EDITKEY_EXPIRE:
711	out = cmd_expire_handler (ke, code, key, &step);
712	break;
713
714	case GPG_EDITKEY_REVSIG:
715	out = cmd_revsig_handler (ke, code, key, &step);
716	break;
717
718	case GPG_EDITKEY_REVKEY:
719	out = cmd_revkey_handler (ke, code, key, &step);
720	break;
721
722	case GPG_EDITKEY_REVUID:
723	out = cmd_revuid_handler (ke, code, key, &step);
724	break;
725
726	case GPG_EDITKEY_ADDREV:
727	out = cmd_addrev_handler (ke, code, key, &step);
728	break;
729
730	case GPG_EDITKEY_ADDPHOTO:
731	out = cmd_addphoto_handler (ke, code, key);
732	break;
733
734	case GPG_EDITKEY_ENABLE:
735	case GPG_EDITKEY_DISABLE:
736	out = cmd_enable_disable_handler (ke, code, key,
737	ke->getType () == GPG_EDITKEY_DISABLE? 1: 0);
738	break;
739
740	case GPG_EDITKEY_SETPREF:
741	out = cmd_setpref_handler (ke, code, key);
742	break;
743
744	case GPG_EDITKEY_KEYSERV:
745	out = cmd_keyserv_handler (ke, code, key);
746	break;
747	}
748
749	if (out != NULL) {
750	/* XXX: check return codes. */
751	WriteFile (hd, out, strlen (out), &n, NULL);
752	WriteFile (hd, "\n", 1, &n, NULL);
753	}
754	return 0;
755	}
756
757
758	/* Check if a GPG status code occured which marks the
759	current operation as failed.
760	Return value: gpg error constant. */
761	static gpgme_error_t
762	map_result (GpgKeyEdit *ke)
763	{
764	if (!ke->getResult ())
765	return gpg_error (GPG_ERR_NO_ERROR);
766	if (ke->getResult () & GPG_EDITRES_BAD_PASSPHRASE)
767	return gpg_error (GPG_ERR_BAD_PASSPHRASE);
768	return 0;
769	}
770
771
772	/* Wrapper around the gpgme edit interface.
773	@ctx context to use.
774	@key key on which the operation should be performed.
775	@ek key edit context.
776	Return value: 0 on success. */
777	gpgme_error_t
778	gpg_editkey (gpgme_ctx_t ctx, gpgme_key_t key, GpgKeyEdit *ek)
779	{
780	gpgme_error_t err;
781	gpgme_data_t out;
782
783	err = gpgme_data_new (&out);
784	if (err)
785	return err;
786	err = gpgme_op_edit (ctx, key, editkey_command_handler, ek, out);
787	if (!err)
788	err = map_result (ek);
789
790	gpgme_data_release (out);
791	return err;
792	}