trunk/Src/wptCardDlg.cpp

/* wptCardDlg.cpp - Smart Card support
 *      Copyright (C) 2003, 2004, 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 <windows.h>
#include <commctrl.h>
#include <ctype.h>

#include "resource.h"
#include "gpgme.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptErrors.h"
#include "wptRegistry.h"
#include "wptVersion.h"
#include "wptCommonCtl.h"
#include "wptDlgs.h"
#include "wptGPG.h"
#include "wptUTF8.h"
#include "wptCardEdit.h"
#include "wptCard.h"
#include "wptContext.h"

int keygen_check_date (SYSTEMTIME * st);

static const char * sex[] = {"Male", "Female", "Undefined", NULL};
static const char * lang[] = {"Undefined", "cs", "de", "en", "es", "fr", "hu",
                              "it", "nl", "pt", "ro", "ru", "zh", "at", 
                              NULL};

static pin_cb_ctx_s pincb;

struct {
    int ctlid;
    const char * err;
} attr_tab[] = {
    {IDC_CEDIT_AID,    ""},
    {IDC_CEDIT_VENDOR, "No Vendor"},
    {IDC_CEDIT_VERSION,"No Version"},
    {IDC_CEDIT_SERIAL, "No Serial-No"},
    {IDC_CEDIT_NAME,   "No Name"},
    {IDC_CEDIT_NAME2,  "No Surname"},
    {IDC_CEDIT_KEYURL, "No Key-URL"},
    {IDC_CEDIT_LOGIN,  "No Login name"},    
    {0},
};


/* XXX: simplify code. */
char*
get_printable_version (const char *version)
{
    static char buf[16];
    char tmp_maj[3]={0}, tmp_min[3]={0};

    strncpy (tmp_maj, version, 2);
    strncpy (tmp_min, version+2, 2);
    sprintf (buf, "%d.%d", atoi (tmp_maj), atoi (tmp_min));
    return buf;
}

/* Return all card attributes from @card. @n contains
   the number of items which were returned. */
char**
card_get_items (gpg_card_t card, int *n)
{
    char **p;

    *n= 8;
    p = (char **)calloc (*n+1, sizeof (char*));
    if (!p)
        BUG (0);
    p[0] = card->aid;
    p[1] = card->vendor;
    p[2] = get_printable_version (card->version);
    p[3] = card->serial;
    p[4] = card->givenname;
    p[5] = card->surname;
    p[6] = card->url;
    p[7] = card->login;
    return p;
}


static int
idx_from_lang (const char * _lang)
{
    const char * s;
    int i;

    if (!_lang)
        return 0;
    for (i=0; (s = lang[i]); i++) {
        if (!strcmp (_lang, s ))
            return i;
    }
    return 0;
}


#if 0 /* @unused@ */
int
show_card_status (void)
{
    int rc = 0;
    int cardstat;

    cardstat = pcsc_get_card_status ();
    if ((cardstat & CARD_STATE_UNAWARE) || (cardstat & CARD_STATE_UNAVAIL))
        rc = WPTERR_NOREADER;
    else if (cardstat & CARD_STATE_EMPTY)
        rc = WPTERR_NOCARD;     
    if (rc) {
        msg_box (NULL, winpt_strerror (rc), _("Card Manager"), MB_ERR);
        return -1;
    }
    return 0;
} /* show_card_status */
#endif

/* Check if there is a card in the reader and analyze the
   returned information.
   Return value: card context or NULL on error. */
gpg_card_t
gpg_card_load (void)
{
    gpgme_error_t err;
    GpgCardEdit *ce;
    gpg_card_t card = NULL;
    struct card_cb_s cb = {0};
    
    ce = new GpgCardEdit ();
    if (!ce)
        BUG (0);
    memset (&cb, 0, sizeof (cb));
    ce->setCallback (card_callback, &cb);
    err = ce->getCardStatus (&card);
    if (err) {
        msg_box (NULL, gpgme_strerror (err), _("Card Manager"), MB_ERR);
        goto leave;
    }

    if (!card->aid || strncmp (card->aid, "D276000124", 10)) {
        msg_box (NULL, winpt_strerror (WPTERR_NOPGPCARD), "WinPT", MB_ERR);
        gpg_card_release (card);
        card = NULL;
    }
    else {
        struct winpt_key_s key;
        memset (&key, 0, sizeof (key));
        winpt_get_pubkey (card->fpr[1]+32, &key);
        if (key.ext) {
            key.ext->card_type = strdup (card->card_type);
            if (!key.ext->card_type)
                BUG (NULL);
            /* memory will be released in gpg_keycache_release (). */
        }
    }

leave:
    delete ce;
    return card;
}


/* Print human friendly fingerprint to control @id in the
   dialog @dlg. @fpr contains the raw fingerprint. */
static void
print_fpr (HWND dlg, int id, const char * fpr)
{
    char buf[128], dig[2];    
    size_t i, c;

    if (!fpr)
        strcpy (buf, _("No Fingerprint"));
    else {
        memset (buf, 0, sizeof (buf));
        for( i=0, c=0; i < strlen (fpr); i++) {
            dig[0] = fpr[i]; dig[1] = 0;
            strcat (buf, dig);
            if (++c == 4) {
                strcat (buf, " ");
                c=0;
            }
        }
    }
    SetDlgItemText (dlg, id, buf);
}


/* Fill in all card information from @card. into the corresponding
   dialog item fields in the dialog @dlg.
   Return value: 0 on success. */
static int
card_status (HWND dlg, gpg_card_t card)
{
    static int fprbuf[] = {IDC_CEDIT_FPR1, IDC_CEDIT_FPR2, IDC_CEDIT_FPR3, 0};
    static int fprtime[] = {IDC_CEDIT_SIG_FPRTIME, IDC_CEDIT_DEC_FPRTIME, IDC_CEDIT_AUTH_FPRTIME, 0};
    const char *s;
    char **attrs;
    char cardinf[128];
    int idx=0, n=0;

    if (!card->aid) {
        msg_box( dlg, _("No OpenPGP smart card detected."), "WinPT", MB_ERR );
        return -1;
    }
    SetDlgItemText (dlg, IDC_CEDIT_AID, card->aid);
    SetDlgItemInt (dlg, IDC_CEDIT_SIGCOUNT, card->sig_count, TRUE);

    for (idx=0; fprbuf[idx]; idx++) {
        print_fpr (dlg, fprbuf[idx], card->fpr[idx]);
        SetDlgItemText (dlg, fprtime[idx], card->fpr_created_str[idx]);
    }

    attrs = card_get_items (card, &n);
    for (idx=1; attr_tab[idx].ctlid; idx++) {
        s = attrs[idx];
        SetDlgItemText (dlg, attr_tab[idx].ctlid, s && *s? s : attr_tab[idx].err);
    }
    free (attrs);

    idx = idx_from_lang (card->lang);    
    SendDlgItemMessage (dlg, IDC_CEDIT_LANG, CB_SETCURSEL, (WPARAM)idx, 0);

    switch (card->sex) {
    case 'm': idx=0; break;
    case 'f': idx=1; break;
    default :
    case 'u': idx=2; break;
    }
    SendDlgItemMessage (dlg, IDC_CEDIT_SEX, CB_SETCURSEL, (WPARAM)idx, 0);

    s = card->serial;
    while (s && *s == '0') s++;
    _snprintf (cardinf, sizeof (cardinf)-1, 
               "Card Edit - %s serial no. %s version %s",
               card->card_type, s, get_printable_version (card->version));
    SetWindowText (dlg, cardinf);

    return 0;
}


/* Initialize the enum combox boxes in dialog @dlg. */
static void
prepare_dialog (HWND dlg)
{
    const char * s;
    int i;

    for (i=0; (s = sex[i]); i++)
        SendDlgItemMessage (dlg, IDC_CEDIT_SEX, CB_ADDSTRING, 0, (LPARAM) s);
    SendDlgItemMessage (dlg, IDC_CEDIT_SEX, CB_SETCURSEL, 0, 0);
    for (i=0; (s = lang[i]); i++)
        SendDlgItemMessage (dlg, IDC_CEDIT_LANG, CB_ADDSTRING, 0, (LPARAM)s);
    SendDlgItemMessage (dlg, IDC_CEDIT_LANG, CB_SETCURSEL, 0, 0);
}


/* Return 0 if the given string @str has the proper format. */
static int
check_string (const char *str, int flags)
{
    size_t i;
    for (i=0; i < strlen (str); i++) {
        if (flags & 0x02 && !isalpha (str[i]))
            return -1;
    }
    return 0;
}


static int
do_proc_card_cmds (HWND dlg, struct pin_cb_ctx_s *cb, gpg_card_t card)
{
    static struct {
        int id;
        int cmd;
        int us_ascii;
        int changed;
    } idctl[] = {
        {IDC_CEDIT_NAME,  GPG_EDITCARD_NAME,  1,  0},
        {IDC_CEDIT_LANG2, GPG_EDITCARD_LANG,  1,  0},
        {IDC_CEDIT_SEX2,  GPG_EDITCARD_SEX,   1|1,0},
        {IDC_CEDIT_KEYURL,GPG_EDITCARD_KEYURL,1|4,0},
        {IDC_CEDIT_LOGIN, GPG_EDITCARD_LOGIN, 1,  0},
        {0}
    };    
    gpgme_error_t err;
    GpgCardEdit *ce;
    char buf[256], tmp[128];
    int errc=0, use_arg2 = 0;
    int i, id, n=0;

    /* XXX rewrite the entire function */
    for( i=0; idctl[i].id; i++ ) /* reset */
        idctl[i].changed = 0;
    
    if( SendMessage( GetDlgItem( dlg, IDC_CEDIT_LANG2 ), WM_GETTEXTLENGTH, 0, 0 ) ) {
        idctl[1].changed = 1; 
        n++;
    }
    if( SendMessage( GetDlgItem( dlg, IDC_CEDIT_SEX2 ), WM_GETTEXTLENGTH, 0, 0 ) ) {
        idctl[2].changed = 1; 
        n++;
    }
    
    if( SendDlgItemMessage( dlg, IDC_CEDIT_NAME2, EM_GETMODIFY, 0, 0 ) ) {
        idctl[0].changed = 1;
        n++;
    }
    for( i=0; (id = idctl[i].id); i++ ) {
        if( SendDlgItemMessage( dlg, id, EM_GETMODIFY, 0, 0 ) ) {
            idctl[i].changed = 1;
            n++;
        }
    }
    if (!cb || !card) /* just return the changed elements */
        return n;
    if (!n)
        return 0;
    if (!cb->apin) {
        msg_box (dlg, _("No PINs found."), _("Card Edit"), MB_ERR);
        return 0;
    }
    
    ce = new GpgCardEdit ();
    if (!ce)
        BUG (NULL);
    ce->setAdminPIN (cb->apin);
    /*ce->setPIN (cb->upin);*/
    for( i=0; idctl[i].id; i++ ) {
        if( idctl[i].changed ) {
            GetDlgItemText( dlg, idctl[i].id, buf, sizeof (buf)-1 );
            if (idctl[i].us_ascii && is_8bit_string (buf)) {
                msg_box (dlg, _("Only plain ASCII is currently allowed."),
                         _("Card Edit"), MB_ERR);
                errc--; continue;
            }
            if( (idctl[i].us_ascii & 2) && check_string( buf, 2 ) ) {
                msg_box( dlg, _("Only alphabetic characters are allowed."),
                         _("Card Edit"), MB_ERR );
                errc--; continue;
            }
            if ((idctl[i].us_ascii & 4) && 
                (!strchr (buf, ':') || !strstr (buf, "//"))) {
                /* XXX: better URL check. */
                msg_box (dlg, _("Invalid URL."), _("Card Edit"), MB_ERR);
                errc--; continue;
            }
            if( idctl[i].cmd == GPG_EDITCARD_NAME ) {
                /* The "name" command actually needs two fields */
                GetDlgItemText( dlg, IDC_CEDIT_NAME2, tmp, sizeof tmp-1 );
                use_arg2 = 1;
            }
            else
                use_arg2 = 0;
            err = ce->doCmd (idctl[i].cmd, buf, use_arg2? tmp : NULL);
            if (err) {
                log_box (_("Card Edit"), MB_ERR, 
                         _("Could not modify card attribute: %s"), 
                         gpgme_strerror (err));
                errc--;
                /* If no card is inserted, we leave the loop. */
                if (gpgme_err_code (err) == GPG_ERR_CARD_NOT_PRESENT)
                    break;
            }
        }
    }
    if (!errc) {
        /* if the operation(s) succeeded, reset the modify flag for each control */
        for( i = 0; idctl[i].id; i++ )
            SendDlgItemMessage( dlg, idctl[i].id, EM_SETMODIFY, (WPARAM)(UINT)FALSE, 0 );
        msg_box( dlg, _("Card attribute changed."), _("Card Edit"), MB_OK );
        SetDlgItemText( dlg, IDC_CEDIT_LANG2, "" );
        SetDlgItemText( dlg, IDC_CEDIT_SEX2, "" );
    }
    delete ce;
    return errc;
} /* do_proc_card_cmds */


/* Cleanup pin callback @ctx. */
void
free_pincb (struct pin_cb_ctx_s *ctx)
{
    if (!ctx)
        return;
    free_if_alloc (ctx->info_text);
    sfree_if_alloc (ctx->upin);
    sfree_if_alloc (ctx->apin);
}


/* Request a PIN from the user. @which decided if the
   normal PIN or the admin PIN will be requested.
   @card is used to show some information to the user.
   @pincb is the actuall callback context. 
   Return value: 0 on success. */
static int
do_askpin (HWND dlg, int which, gpg_card_t card,
           struct pin_cb_ctx_s *cb)
{
    const char * s, * fmt;
    const char * n1, * n2, * serial;
    char * p;
    size_t n;

    if( (which == CARD_ADMIN_PIN && cb->apin) ||
        (which == CARD_USER_PIN && cb->upin) )
        return 0;
    
    if (which == CARD_ADMIN_PIN)
        s = _("Please enter the 'Admin PIN'");
    else if (which == CARD_USER_PIN)
        s = _("Please enter the 'User PIN'");
    else
        s = _("Please enter the PIN");
    cb->which = which;
    free_if_alloc( cb->info_text );
    if( card ) {
        fmt = _("%s\nName: %s %s\nSerial-No: %s\n");
        n1 = card->givenname;
        n2 = card->surname;
        if( !n1 || !n2 ) {
            n1 = "No"; n2 = "Name";
        }    
        serial = card->serial;
        if (!serial)
            serial = "No Serial ID";
        n = strlen( n1 ) + strlen( n2 ) + strlen( fmt ) + strlen( serial ) + 3;
        p = cb->info_text = new char[strlen( s )+n+1 ];
        if( !p )
            BUG (0);
        sprintf( p, fmt, s, n1, n2, serial );
    }
    else {
        p = cb->info_text = m_strdup (s);
        if (!p)
            BUG (0);
    }
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_PIN, dlg,
                    pin_cb_dlg_proc, (LPARAM)cb); 
    if (!cb->apin && !cb->upin) {
        safe_free (cb->info_text);
        return -1;
    }
    return 0;
}


/* Dialog box procedure for card edit. */
BOOL CALLBACK
card_edit_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static gpg_card_t card;    
    char tmp[128];
    size_t n=0;

    switch (msg) {
    case WM_INITDIALOG:
        card = (gpg_card_t)lparam;
        if (!card)
            BUG (0);
        prepare_dialog (dlg);
        if (card_status (dlg, card ))
            EndDialog (dlg, TRUE);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        return TRUE;

    case WM_DESTROY:
        free_pincb (&pincb);
        memset (&pincb, 0, sizeof pincb);
        break;

    case WM_COMMAND:
        switch( HIWORD( wparam ) ) {
        case CBN_KILLFOCUS:
        case CBN_EDITCHANGE:
        case CBN_EDITUPDATE:
            int ctlid = GetDlgCtrlID( (HWND)lparam );
            int dstid = 0;

            switch (ctlid) {
            case IDC_CEDIT_LANG: dstid = IDC_CEDIT_LANG2; break;
            case IDC_CEDIT_SEX:  dstid = IDC_CEDIT_SEX2; break;
            }       
            GetDlgItemText (dlg, ctlid, tmp, sizeof (tmp)-1);
            SetDlgItemText (dlg, dstid, tmp);
            break;
        }
        switch (LOWORD (wparam)) {
        case IDC_CEDIT_CHPIN:
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_CHPIN, dlg,
                            card_changepin_dlg_proc, 0);
            break;

        case IDC_CEDIT_NEWKEYS:
            if (item_get_text_length (dlg, IDC_CEDIT_FPR1) > 0) {
                int id = msg_box (dlg, 
                    _("This operation will override the keys on the card.\n"
                      "Still proceed?"), _("Card Edit"), MB_WARN|MB_YESNO);
                if (id == IDNO)
                    return TRUE;
            }
            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_KEYGEN,
                            dlg, card_keygen_dlg_proc, 0);
            break;

        case IDOK:
            n = do_proc_card_cmds (dlg, NULL, NULL);
            if (n) {
                if (do_askpin (dlg, CARD_ADMIN_PIN, card, &pincb))
                    EndDialog (dlg, FALSE);
            }
            do_proc_card_cmds (dlg, &pincb, card);
            free_pincb (&pincb);
            if (!n)
                EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            EndDialog( dlg, FALSE );
            break;
        }
        break;
    }

    return FALSE;
}


static int /* fixme: works only roughly */
calc_days (int y2, int m2, int d2, 
           int y1, int m1, int d1)

{
    int n=0;
    
    if ((y2-y1) > 0)
        n += (y2-y1)*365;
    if ((m2-m1) > 0)
        n += (m2-m1)*30;
    if ((d2-d1) > 0)
        n += (d2-d1);
    else if ((d2-d1) < 0)
        n -= (d1-d2);
    return n;
}


/* Dialog box procedure for the key generation on cards. */
BOOL CALLBACK
card_keygen_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    gpgme_error_t err;
    GpgCardEdit *ce;
    char name[128], email[128], comment[128];
    char pass[128];
    int card_flags = GPG_CARDFLAG_NONE;
    int expires=0, valid=0;
    DWORD n;

    switch (msg) {
    case WM_INITDIALOG:
        center_window (dlg, NULL);
        CheckDlgButton (dlg, IDC_CKEYGEN_REPLACE, BST_CHECKED);
        CheckDlgButton (dlg, IDC_CKEYGEN_NEVER, BST_CHECKED);
        CheckDlgButton (dlg, IDC_CKEYGEN_BACKUP, BST_CHECKED);
        EnableWindow (GetDlgItem (dlg, IDC_CKEYGEN_VALID), FALSE);
        SendDlgItemMessage (dlg, IDC_CKEYGEN_ALG, CB_ADDSTRING, 0, 
                            (LPARAM)(const char*)"RSA");
        SendDlgItemMessage (dlg, IDC_CKEYGEN_ALG, CB_SETCURSEL, 0, 0);
        SetFocus (GetDlgItem (dlg, IDC_CKEYGEN_NAME));
        SetForegroundWindow (dlg);
        SetDlgItemText (dlg, IDC_CKEYGEN_NAMEINF, _("&Name"));
        SetDlgItemText (dlg, IDC_CKEYGEN_CMTINF, _("&Comment (optional)"));
        SetDlgItemText (dlg, IDC_CKEYGEN_EXPDATEINF, _("&Expire date"));
        SetDlgItemText (dlg, IDC_CKEYGEN_PWDINF, _("Off-card passphrase"));
        SetDlgItemText (dlg, IDC_CKEYGEN_NEVER, _("&Never"));
        SetDlgItemText (dlg, IDC_CKEYGEN_MAILINF, _("Email &address"));
        SetDlgItemText (dlg, IDC_CKEYGEN_REPLACE, _("Overwrite old keys on the card"));
        SetDlgItemText (dlg, IDC_CKEYGEN_BACKUP, _("Make off-card backup of encryption key"));
        SetWindowText (dlg, _("Card Key Generation"));
        return FALSE;

    case WM_SYSCOMMAND:
        if (LOWORD (wparam) == SC_CLOSE)
            EndDialog (dlg, TRUE);
        return FALSE;

    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED &&
            (LOWORD (wparam) == IDC_CKEYGEN_BACKUP) ||
             LOWORD (wparam) == IDC_CKEYGEN_NEVER) {
            EnableWindow (GetDlgItem (dlg, IDC_CKEYGEN_VALID),
                          IsDlgButtonChecked (dlg, IDC_CKEYGEN_NEVER)? 0: 1);
            EnableWindow (GetDlgItem (dlg, IDC_CKEYGEN_PASS),
                          IsDlgButtonChecked (dlg, IDC_CKEYGEN_BACKUP)? 1 : 0);
            return TRUE;
        }       

        switch (LOWORD (wparam)) {
        case IDOK:
            n = item_get_text_length (dlg, IDC_CKEYGEN_NAME);
            if (!n) {
                msg_box (dlg, _("Please enter your name."), _("Card Edit"), MB_ERR);
                return TRUE;
            }
            if (n < 5) {
                msg_box (dlg, _("Name must be at least 5 characters long."),
                         _("Card Edit"), MB_INFO);
                return TRUE;
            }
            n = item_get_text_length (dlg, IDC_CKEYGEN_EMAIL);
            if (!n) {
                msg_box (dlg, _("Please enter your e-mail address."),
                         _("Card Edit"), MB_ERR);
                return TRUE;
            }
            GetDlgItemText (dlg, IDC_CKEYGEN_NAME, name, sizeof (name)-1);
            GetDlgItemText (dlg, IDC_CKEYGEN_EMAIL, email, sizeof (email)-1);
            if (!strchr (email, '@') || n < 3) {
                msg_box (dlg, _("Please enter a valid e-mail address."),
                         _("Card Edit"), MB_ERR);
                return TRUE;
            }
            n = GetDlgItemText (dlg, IDC_CKEYGEN_PASS, pass, sizeof (pass)-1);
            if (!n && IsDlgButtonChecked (dlg, IDC_CKEYGEN_BACKUP)) {
                msg_box (dlg, _("Please enter an off-card passphrase."), _("Card Edit"), MB_ERR);
                return TRUE;
            }
            n = item_get_text_length (dlg, IDC_CKEYGEN_COMMENT);
            if (n > 0)
                GetDlgItemText (dlg, IDC_CKEYGEN_COMMENT, comment, sizeof (comment)-1);
            if (is_8bit_string (name) || n > 0 && is_8bit_string (comment)) {
                msg_box (dlg, _("Please use plain ASCII charset for the fields."), 
                         _("Card Edit"), MB_INFO);
                return TRUE;
            }
            memset (&pincb, 0, sizeof (pincb));
            if (do_askpin (dlg, CARD_ADMIN_PIN, NULL, &pincb)) {
                free_pincb (&pincb);
                return TRUE;
            }
            if (do_askpin (dlg, CARD_USER_PIN, NULL, &pincb)) {
                free_pincb (&pincb);
                return TRUE;
            }
            ce = new GpgCardEdit ();
            if (!ce)
                BUG (0);
            
            expires = !IsDlgButtonChecked (dlg, IDC_CKEYGEN_NEVER);
            if (expires) {
                SYSTEMTIME st, ct;
                DateTime_GetSystemtime (GetDlgItem (dlg, IDC_CKEYGEN_VALID), &st);
                if (!keygen_check_date (&st)) {
                    msg_box (dlg, _("The date you have chosen lies in the past."),
                             _("Card Edit"), MB_ERR);
                    free_pincb (&pincb);
                    delete ce;
                    return TRUE;
                }
                GetSystemTime (&ct);
                /* XXX this is not very precise */
                valid = calc_days (st.wYear, st.wMonth, st.wDay,
                                   ct.wYear, ct.wMonth, ct.wDay);
            }
            if (IsDlgButtonChecked (dlg, IDC_CKEYGEN_REPLACE))
                card_flags |= GPG_CARDFLAG_REPLACE;
            if (IsDlgButtonChecked (dlg, IDC_CKEYGEN_BACKUP))
                card_flags |= GPG_CARDFLAG_BAKENC;
            ce->setKeygenPassphrase (pass);
            ce->setPIN (pincb.upin);
            ce->setAdminPIN (pincb.apin);
            
            SetCursor (LoadCursor (NULL, IDC_WAIT));
            err = ce->genKey (card_flags, name, email, n? comment: NULL,
                              expires? valid : 0, NULL);
            
            SetCursor (LoadCursor (NULL, IDC_ARROW));
            
            if (gpgme_err_code (err) == GPG_ERR_CANCELED)
                msg_box (dlg, _("Operation was canceled. It seems that there are "
                                "existing\nkeys on the cards. You need to mark the "
                                "'Overwrite' flag."), _("Card Edit"), MB_INFO);
            else
            if (err)
                msg_box (dlg, "The operation does not succeed.\n"
                              "Please make sure you entered the right PIN's."
                              , _("Card Edit"), MB_ERR);
            else
                msg_box (dlg, _("Keys successfully created."), 
                         _("Card Edit"), MB_OK);
            wipememory (pass, sizeof (pass));
            free_pincb (&pincb);
            delete ce;
            return TRUE;

        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return FALSE;
        }
        break;
    }
    return FALSE;
}


/* Check if the given pinlen is valid.
   @which decided what PIN will be used.
   @pinlen is the pin length entered by the user.
   Return value: 0 on success. */
static int
check_pin_len (int which, int flag, int pinlen)
{
    if (!pinlen) {
        if (flag)
            msg_box (NULL, _("Please enter the old card PIN."), _("Card Edit"), MB_ERR);
        else
            msg_box (NULL, _("Please enter the new card PIN."), _("Card Edit"), MB_ERR);
        return -1;
    }
    if (which == CARD_ADMIN_PIN
        && pinlen < 8) {
        msg_box (NULL, _("Admin PIN must be minimal 8 characters."), _("Card Edit"), MB_ERR);
        return -1;
    }
    if (which == CARD_USER_PIN
        && pinlen < 6) {
        msg_box (NULL, _("PIN must be minimal 6 characters."), _("Card Edit"), MB_ERR);
        return -1;
    }
    return 0;
}

/* Dialog box procedure to change the PIN. */
BOOL CALLBACK
card_changepin_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{    
    static int hide = 1;
    gpgme_error_t err;
    GpgCardEdit *ce;    
    char pold[128], pnew[128], pnew2[128];
    int which = 0;
    DWORD n;

    switch( msg ) {
    case WM_INITDIALOG:
        hide = 1;
        CheckDlgButton (dlg, IDC_CHPIN_HIDE, BST_CHECKED);
        center_window (dlg, NULL);
        CheckDlgButton (dlg, IDC_CHPIN_ISWORK, BST_CHECKED);
        SetWindowText (dlg, _("Change Card PIN"));
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        if (HIWORD (wparam) == BN_CLICKED && LOWORD (wparam) == IDC_CHPIN_HIDE) {           
            HWND hwnd;
            hide ^= 1;
            hwnd = GetDlgItem (dlg, IDC_CHPIN_OLDPIN);
            SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
            SetFocus (hwnd);
            hwnd = GetDlgItem (dlg, IDC_CHPIN_NEWPIN);
            SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
            SetFocus (hwnd);
            hwnd = GetDlgItem (dlg, IDC_CHPIN_NEWPIN2);
            SendMessage (hwnd, EM_SETPASSWORDCHAR, hide? '*' : 0, 0);
            SetFocus (hwnd);
        }
        switch (LOWORD (wparam)) {
        case IDOK:
            if (IsDlgButtonChecked (dlg, IDC_CHPIN_ISADMIN))
                which = CARD_ADMIN_PIN;
            else if (IsDlgButtonChecked (dlg, IDC_CHPIN_ISWORK))
                which = CARD_USER_PIN;

            n = item_get_text_length (dlg, IDC_CHPIN_OLDPIN);
            if (check_pin_len (which, 1, n))
                return TRUE;
            n = item_get_text_length (dlg, IDC_CHPIN_NEWPIN);
            if (check_pin_len (which, 0, n))
                return TRUE;
            n = item_get_text_length (dlg, IDC_CHPIN_NEWPIN2);
            if (check_pin_len (which, 0, n))
                return TRUE;
            GetDlgItemText (dlg, IDC_CHPIN_OLDPIN, pold, sizeof (pold)-1);
            GetDlgItemText (dlg, IDC_CHPIN_NEWPIN, pnew, sizeof (pnew)-1);
            GetDlgItemText (dlg, IDC_CHPIN_NEWPIN2, pnew2, sizeof (pnew2)-1);
            if (strcmp (pnew, pnew2)) {
                wipememory (pnew2, sizeof (pnew2));
                wipememory (pnew, sizeof (pnew));
                msg_box (dlg, _("Passphrases do not match. Please try again."), 
                         _("Card Edit"), MB_ERR);
                return TRUE;
            }

            ce = new GpgCardEdit ();
            if (!ce)
                BUG (0);
            if (which == CARD_ADMIN_PIN)
                ce->setAdminPIN (pold);
            else
                ce->setPIN (pold);
            ce->setNewPIN (pnew);
            err = ce->changePIN (which == CARD_ADMIN_PIN? GPG_EDITCARD_CHAPIN :
                                 GPG_EDITCARD_CHUPIN);
            if (err)
                msg_box (dlg, gpgme_strerror (err), _("Card Edit"), MB_ERR);
            else {
                msg_box (dlg, _("PIN successfully changed."), 
                         _("Card Edit"), MB_OK);
                SetDlgItemText (dlg, IDC_CHPIN_NEWPIN, "");
                SetDlgItemText (dlg, IDC_CHPIN_OLDPIN, "");
                SetDlgItemText (dlg, IDC_CHPIN_NEWPIN2, "");
            }
            wipememory (pold, sizeof (pold));
            wipememory (pnew, sizeof (pnew));
            wipememory (pnew2, sizeof (pnew2));
            delete ce;
            break;

        case IDCANCEL:
            SetDlgItemText (dlg, IDC_CHPIN_NEWPIN, "");
            SetDlgItemText (dlg, IDC_CHPIN_OLDPIN, "");
            SetDlgItemText (dlg, IDC_CHPIN_NEWPIN2, "");
            EndDialog (dlg, FALSE);
            break;
        }
        break;
    }

    return FALSE;
}