trunk/Src/wptCardEdit.cpp

/* wptCardEdit.cpp - OpenPGP editing interface
 *      Copyright (C) 2005 Timo Schulz
 *
 * 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
 */

#include <windows.h>
#include <time.h>

#include "gpgme.h"
#include "wptCard.h"
#include "wptCardEdit.h"
#include "wptGPG.h"
#include "wptErrors.h"

/* Create a new Smartcard context. */
static gpgme_error_t
gpg_card_new (gpg_card_t *ret_card)
{
    gpg_card_t c;

    if (!ret_card)
        return gpg_error (GPG_ERR_INV_ARG);
    *ret_card = NULL;
    c = (gpg_card_t)calloc (1, sizeof *c);
    if (!c)
        return gpg_error (GPG_ERR_ENOMEM);
    *ret_card = c;
    return 0;
}


/* Release an existing Smartcard context. @card. */
void
gpg_card_release (gpg_card_t card)
{
    int i;

    if (!card)
        return;
    if (card->aid)
        free (card->aid);   
    if (card->version)
        free (card->version);
    if (card->lang)
        free (card->lang);
    if (card->login)
        free (card->login);
    for (i=0; i < 3; i++) {
        if (card->fpr[i])
            free (card->fpr[i]);
        if (card->ca_fpr[i])
            free (card->ca_fpr[i]);
        if (card->fpr_created_str[i])
            free (card->fpr_created_str[i]);
    }
    if (card->surname)
        free (card->surname);
    if (card->givenname)
        free (card->givenname);
    if (card->serial)
        free (card->serial);
    if (card->vendor)
        free (card->vendor);
    if (card->url)
        free (card->url);
    if (card->card_type)
        free (card->card_type);
    free (card);

}


/* Parse the timestamp @long_ts and return a string
   representation of it (format: YYYY-DD-MM HH:MM:SS). */
static char*
get_str_timestamp (long long_ts)
{
    struct tm *tm;
    char *p, *fmt;

    tm = localtime (&long_ts);
    fmt = "%04d-%02d-%02d %02d:%02d:%02d";
    p = (char*)calloc (1, strlen (fmt)+32);
    if (!p)
        abort ();
    sprintf (p, fmt,
             tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
             tm->tm_hour, tm->tm_min, tm->tm_sec);
    return p;
}


/* Colon handler for parsing the GPG card colon output. */
static gpgme_error_t
statuscard_colon_handler (gpg_card_t card, char * line)
{
    enum rectype_t {
        CARD_None = 0,
        CARD_AID,
        CARD_Version,
        CARD_Vendor,
        CARD_Serial,
        CARD_Name,
        CARD_Lang,
        CARD_Sex,
        CARD_Url,
        CARD_Login,
        CARD_MaxPinLen,
        CARD_SigCount,
        CARD_CAFpr,
        CARD_Fpr,
        CARD_FprTime
    };
    enum rectype_t rectype;    
    char *p, *pend;
    int field = 0;

    if (!line)
        return gpg_error (GPG_ERR_EOF);

    for (p = line; p; p = pend) {
        field++;
        pend = strchr (p, ':');
        if (pend)
            *pend++ = 0;

        if (field == 1) {
            if (!strcmp (p, "AID"))
                rectype = CARD_AID;
            else if( !strcmp( p, "version" ) )
                rectype = CARD_Version;
            else if( !strcmp( p, "vendor" ) )
                rectype = CARD_Vendor;
            else if( !strcmp( p, "serial" ) )
                rectype = CARD_Serial;
            else if( !strcmp( p, "name" ) )
                rectype = CARD_Name;
            else if( !strcmp( p, "lang" ) )
                rectype = CARD_Lang;
            else if( !strcmp( p, "sex" ) )
                rectype = CARD_Sex;
            else if( !strcmp( p, "url" ) )
                rectype = CARD_Url;
            else if( !strcmp( p, "login" ) )
                rectype = CARD_Login;
            else if( !strcmp( p, "maxpinlen" ) )
                rectype = CARD_MaxPinLen;
            else if( !strcmp( p, "sigcount" ) )
                rectype = CARD_SigCount;
            else if (!strcmp (p, "cafpr"))
                rectype = CARD_CAFpr;
            else if (!strcmp (p, "fpr"))
                rectype = CARD_Fpr;         
            else if (!strcmp (p, "fprtime"))
                rectype = CARD_FprTime;
            else
                rectype = CARD_None;
        }
        switch (rectype) {
        case CARD_AID:
            if (field == 2) {
                card->aid = strdup (p);
                if (!card->aid)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            else if (field == 3) {
                card->card_type = strdup (p);
                if (!card->card_type)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;

        case CARD_Version:
            if (field == 2) {
                card->version = strdup (p);
                if (!card->version)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;

        case CARD_Vendor:
            if (field == 3) {
                card->vendor = strdup (p);
                if (!card->vendor)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;

        case CARD_Serial:
            if (field == 2) {
                card->serial = strdup (p);
                if (!card->serial)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;
        case CARD_Name:
            if (field == 2) {
                card->givenname = strdup (p);
                if (!card->givenname)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            else if (field == 3) {
                card->surname = strdup (p);
                if (!card->surname)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;
        case CARD_Lang:
            if( field == 2 ) {
                card->lang = strdup (p);
                if (!card->lang)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;
        case CARD_Sex:
            if( field == 2 )
                card->sex = *p;
            break;

        case CARD_Url:
            if( field == 2 ) {
                if (card->url)
                    free (card->url);
                card->url = (char*)calloc (1, strlen (p) + 1);
                if( !card->url ) {
                    return gpg_error (GPG_ERR_ENOMEM);
                }
                gpg_decode_c_string (p, &card->url, strlen (p) + 1);
                if (!card->url)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;

        case CARD_Login:
            if (field == 2) {
                card->login = strdup (p);
                if (!card->login)
                    return gpg_error (GPG_ERR_ENOMEM);
            }
            break;

        case CARD_MaxPinLen:
            break;

        case CARD_SigCount:
            if (field == 2)
                card->sig_count = atol (p);
            break;

        case CARD_CAFpr:
            if (!p)
                break;
            if (field > 4 || field == 1)
                break;
            card->ca_fpr[field-2] = strdup (p);
            if (!card->ca_fpr[field-2])
                return gpg_error (GPG_ERR_ENOMEM);
            break;

        case CARD_Fpr:
            if (field > 4 || field == 1) /* max 3 fprs */
                break;
            card->fpr[field-2] = strdup (p);
            if (!card->fpr[field-2])
                return gpg_error (GPG_ERR_ENOMEM);
            break;

        case CARD_FprTime:
            if (field > 4 || field == 1)
                break;
            card->fpr_created[field-2] = strtoul (p, NULL, 10);
            card->fpr_created_str[field-2] = get_str_timestamp (strtoul (p, NULL, 10));
            if (!card->fpr_created_str[field-2])
                return gpg_error (GPG_ERR_ENOMEM);
            break;

        }
    }
    return 0;
}


/* Dummy handler to get the colon data and then quit. */
static gpgme_error_t
list_handler (void *opaque, gpgme_status_code_t code, const char *key, int fd)
{
    GpgCardEdit *ce = (GpgCardEdit *)opaque;
    const char *s="";
    DWORD n;

    if (code == GPGME_STATUS_CARDCTRL && *key == '5')
        ce->setResult (GPG_CARDRES_NOCARD);
    if (!strcmp (key, "cardedit.prompt")) {
        s = "quit\n";
        if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))
            log_debug ("list_handler: WriteFile() failed ec=%d\r\n", 
                       (int)GetLastError ());
    }
    return 0;
}


/* Construct an empty object. */
GpgCardEdit::GpgCardEdit (void)
{
    pin = NULL;
    pin_new = NULL;
    admin_pin = NULL;

    keygen.comment = NULL;
    keygen.email = NULL;
    keygen.name = NULL;
    keygen.expdate = NULL;
    keygen.key_fpr = NULL;

    type = 0;
    cnt = 0;
    cancel = 0;
    result = 0;

    gpgme_new (&ctx); /* XXX: check return code */
}

/* Release the object. */
GpgCardEdit::~GpgCardEdit (void)
{    
    if (keygen.name)
        free (keygen.name);
    if (keygen.comment)
        free (keygen.comment);
    if (keygen.email)
        free (keygen.email);
    if (keygen.expdate)
        free (keygen.expdate);
    if (keygen.key_fpr)
        free (keygen.key_fpr);
    gpgme_release (ctx);
}


/* Set the user PIN for the object to @pin. */
void
GpgCardEdit::setPIN (const char *pin)
{
    this->pin = pin;
}

/* Set the admin PIN for the object to @admin_pin. */
void
GpgCardEdit::setAdminPIN (const char *admin_pin)
{
    this->admin_pin = admin_pin;
}


/* Set the new user PIN for the object to @new_pin. */
void 
GpgCardEdit::setNewPIN (const char *new_pin)
{
    this->pin_new = new_pin;
}


/* Set the passphrase needed when generating a key to @pass. */
void
GpgCardEdit::setKeygenPassphrase (const char *pass)
{
    this->keygen.pass = pass;
}


/* Set the callback to @cb and the hook value to @cb_value. */
void
GpgCardEdit::setCallback (const char* (*cb)(int code, void *opaque), 
                          void *cb_value)
{
    this->cb_value = cb_value;
    this->card_cb = cb;
}


/* Read the information from the inserted card and return
   it in form of a card context @r_card.
   Return value: 0 on success. */
gpgme_error_t
GpgCardEdit::getCardStatus (gpg_card_t *r_card)
{
    gpgme_data_t out = NULL;
    gpgme_key_t key=NULL;    
    gpgme_error_t err;
    gpg_card_t card=NULL;
    char buf[200];

    if (!r_card)
        return gpg_error (GPG_ERR_INV_ARG);

    /* XXX: dummy key */
    key = (gpgme_key_t)calloc (1, sizeof *key);
    key->subkeys = (gpgme_subkey_t)calloc (1, sizeof *key->subkeys);
    key->subkeys->fpr = strdup ("foo");

    err = gpg_card_new (&card);
    if (err)
        return err;

    err = gpgme_data_new (&out);
    if (err) {
        gpg_card_release (card);
        return err;
    }
    
    err = gpgme_op_card_edit  (ctx, key, list_handler, this, out);
    gpgme_data_rewind (out);
    if (err) {
        gpgme_data_release (out);
        gpg_card_release (card);
        return err;
    }
    if (getResult () & GPG_CARDRES_NOCARD) {
        gpg_card_release (card);
        gpgme_data_release (out);
        return gpg_error (GPG_ERR_CARD_REMOVED);
    }

    *r_card = card;
    while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {
        err = statuscard_colon_handler (card, buf);
        if (err)
            break;
    }
    gpgme_data_release (out);

    if (key) { /* XXX */
        free (key->subkeys->keyid);
        free (key->subkeys);
        free (key);
    }

    return err;
}


/* Generate a key on a smart card with the following params:
   @flags: user specific params.
   @name: name of the key holder.
   @email: email of the key holder.
   @comment: optional comment.
   @valid: how long is the key valid in days.
   Return value: 0 on success. */
gpgme_error_t
GpgCardEdit::genKey (int flags, const char *name,
                     const char *email, const char *comment, long valid,
                     char **r_key_fpr)
{
    gpgme_error_t err;

    if (!name || !email)
        return gpg_error (GPG_ERR_INV_ARG);
    if (!this->keygen.pass)
        return gpg_error (GPG_ERR_INV_OBJ);

    type = GPG_EDITCARD_GENKEY;
    this->keygen.flags = flags;

    if (this->keygen.name)
        free (this->keygen.name);
    this->keygen.name = strdup (name);
    if (this->keygen.email)
        free (this->keygen.email);
    this->keygen.email = strdup (email);
    if (this->keygen.comment)
        free (this->keygen.comment);
    this->keygen.comment = comment? strdup (comment) : strdup ("");
    if (this->keygen.expdate)
        free (this->keygen.expdate);
    this->keygen.expdate = (char*)calloc (1, 16);
    if (this->keygen.expdate)
        sprintf (this->keygen.expdate, "%d", valid);

    if (!this->keygen.name || !this->keygen.email)
        return gpg_error (GPG_ERR_ENOMEM);

    err = gpg_card_edit (ctx, this);
    if (!err && r_key_fpr)
        *r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");
    return err;
}


/* Change the pin from @pin to @pin_new.
   Return value: 0 on success. */
gpgme_error_t 
GpgCardEdit::changePIN (int type)
{
    gpgme_error_t err;

    if (!this->pin_new)
        return gpg_error (GPG_ERR_INV_ARG);

    if (!type) {
        if (this->pin && this->pin_new)
            this->type = GPG_EDITCARD_CHUPIN;
        else if (this->pin && this->admin_pin)
            this->type = GPG_EDITCARD_CHAPIN;
        else
            this->type = GPG_EDITCARD_UNBPIN;
    }
    else
        this->type = type;
    /* check if the user provided the needed PIN. */
    if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) ||
        (this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))
        return gpg_error (GPG_ERR_INV_ARG);

    err = gpg_card_edit (ctx, this);
    return err;
}


gpgme_error_t
GpgCardEdit::updateName (const char *given, const char *sur)
{
    gpgme_error_t err;

    if (!this->admin_pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    this->type = GPG_EDITCARD_NAME;
    this->edit.surname = sur;
    this->edit.givenname = given;

    err = gpg_card_edit (ctx, this);
    return err;
}
    
gpgme_error_t
GpgCardEdit::updateURL (const char *url)
{
    gpgme_error_t err;

    if (!this->admin_pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    type = GPG_EDITCARD_KEYURL;
    this->edit.keyurl = url;

    err = gpg_card_edit (ctx, this);
    return err;
}


gpgme_error_t
GpgCardEdit::updateLogin (const char *login)
{
    gpgme_error_t err;

    if (!this->admin_pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    this->type = GPG_EDITCARD_LOGIN;
    this->edit.login = login;

    err = gpg_card_edit (ctx, this);
    return err;
}

gpgme_error_t
GpgCardEdit::updateSex (char sex)
{
    gpgme_error_t err;

    if (!this->admin_pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    type = GPG_EDITCARD_SEX;
    this->edit.sex = sex;

    err = gpg_card_edit (ctx, this);
    return err;
}

gpgme_error_t
GpgCardEdit::updateLanguage (const char *lang)
{
    gpgme_error_t err;

    if (!this->admin_pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    type = GPG_EDITCARD_LANG;
    this->edit.lang = lang;

    err = gpg_card_edit (ctx, this);
    return err;
}


/* Fetch the key specified by the url stored on the card.
   Return value: 0 on success. */
gpgme_error_t
GpgCardEdit::fetchKey (void)
{
    gpgme_error_t err = 0;

    if (!this->pin)
        return gpg_error (GPG_ERR_INV_OBJ);

    return 0;
}


/* Dispatcher for the various commands. @cmd is the card command ID
   and @arg1 and @arg2 the actual values for the command.
   Return value: 0 on success. */
gpgme_error_t
GpgCardEdit:: doCmd (int cmd, const char *arg1, const char *arg2)
{
    switch (cmd) {
    case GPG_EDITCARD_NAME:
        return updateName (arg1, arg2); /* given, surname */

    case GPG_EDITCARD_LANG:
        return updateLanguage (arg1); /* lang */

    case GPG_EDITCARD_SEX:
        return updateSex (*arg1); /* sex */

    case GPG_EDITCARD_KEYURL:
        return updateURL (arg1); /* url */

    case GPG_EDITCARD_LOGIN:
        return updateLogin (arg1); /* login */

    default:
        return gpg_error (GPG_ERR_INV_VALUE);
    }

    return 0;
}


/* Set the result for the executed operation.
   The values will be ORed. */
void
GpgCardEdit::setResult (int res)
{
    result |= res;
}


/* Return the result of the executed operation. */
int
GpgCardEdit::getResult (void)
{
    return result;
}


/* Reset the object state. */
void
GpgCardEdit::reset (void)
{
    cnt = 0;
}
1	twoaday	23	/* wptCardEdit.cpp - OpenPGP editing interface
2			* Copyright (C) 2005 Timo Schulz
3			*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <windows.h>
22	twoaday	26	#include <time.h>
23	twoaday	25
24			#include "gpgme.h"
25	twoaday	26	#include "wptCard.h"
26	twoaday	23	#include "wptCardEdit.h"
27	twoaday	25	#include "wptGPG.h"
28	twoaday	26	#include "wptErrors.h"
29	twoaday	23
30			/* Create a new Smartcard context. */
31			static gpgme_error_t
32	twoaday	25	gpg_card_new (gpg_card_t *ret_card)
33	twoaday	23	{
34			gpg_card_t c;
35
36			if (!ret_card)
37			return gpg_error (GPG_ERR_INV_ARG);
38			*ret_card = NULL;
39			c = (gpg_card_t)calloc (1, sizeof *c);
40	twoaday	26	if (!c)
41	twoaday	23	return gpg_error (GPG_ERR_ENOMEM);
42			*ret_card = c;
43			return 0;
44			}
45
46
47			/* Release an existing Smartcard context. @card. */
48			void
49			gpg_card_release (gpg_card_t card)
50			{
51			int i;
52
53			if (!card)
54			return;
55			if (card->aid)
56			free (card->aid);
57			if (card->version)
58			free (card->version);
59			if (card->lang)
60			free (card->lang);
61			if (card->login)
62			free (card->login);
63			for (i=0; i < 3; i++) {
64			if (card->fpr[i])
65			free (card->fpr[i]);
66	twoaday	26	if (card->ca_fpr[i])
67			free (card->ca_fpr[i]);
68			if (card->fpr_created_str[i])
69			free (card->fpr_created_str[i]);
70	twoaday	23	}
71			if (card->surname)
72			free (card->surname);
73			if (card->givenname)
74			free (card->givenname);
75			if (card->serial)
76			free (card->serial);
77			if (card->vendor)
78			free (card->vendor);
79			if (card->url)
80			free (card->url);
81	twoaday	26	if (card->card_type)
82			free (card->card_type);
83	twoaday	23	free (card);
84
85			}
86
87
88	twoaday	26	/* Parse the timestamp @long_ts and return a string
89			representation of it (format: YYYY-DD-MM HH:MM:SS). */
90			static char*
91			get_str_timestamp (long long_ts)
92			{
93			struct tm *tm;
94			char p, fmt;
95
96			tm = localtime (&long_ts);
97			fmt = "%04d-%02d-%02d %02d:%02d:%02d";
98			p = (char*)calloc (1, strlen (fmt)+32);
99			if (!p)
100			abort ();
101			sprintf (p, fmt,
102			tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday,
103			tm->tm_hour, tm->tm_min, tm->tm_sec);
104			return p;
105			}
106
107
108	twoaday	23	/* Colon handler for parsing the GPG card colon output. */
109			static gpgme_error_t
110	twoaday	26	statuscard_colon_handler (gpg_card_t card, char * line)
111	twoaday	23	{
112			enum rectype_t {
113			CARD_None = 0,
114			CARD_AID,
115			CARD_Version,
116			CARD_Vendor,
117			CARD_Serial,
118			CARD_Name,
119			CARD_Lang,
120			CARD_Sex,
121			CARD_Url,
122			CARD_Login,
123			CARD_MaxPinLen,
124			CARD_SigCount,
125	twoaday	26	CARD_CAFpr,
126			CARD_Fpr,
127			CARD_FprTime
128			};
129	twoaday	23	enum rectype_t rectype;
130			char p, pend;
131			int field = 0;
132
133			if (!line)
134			return gpg_error (GPG_ERR_EOF);
135
136	twoaday	26	for (p = line; p; p = pend) {
137	twoaday	23	field++;
138			pend = strchr (p, ':');
139	twoaday	26	if (pend)
140	twoaday	23	*pend++ = 0;
141
142			if (field == 1) {
143			if (!strcmp (p, "AID"))
144			rectype = CARD_AID;
145			else if( !strcmp( p, "version" ) )
146			rectype = CARD_Version;
147			else if( !strcmp( p, "vendor" ) )
148			rectype = CARD_Vendor;
149			else if( !strcmp( p, "serial" ) )
150			rectype = CARD_Serial;
151			else if( !strcmp( p, "name" ) )
152			rectype = CARD_Name;
153			else if( !strcmp( p, "lang" ) )
154			rectype = CARD_Lang;
155			else if( !strcmp( p, "sex" ) )
156			rectype = CARD_Sex;
157			else if( !strcmp( p, "url" ) )
158			rectype = CARD_Url;
159			else if( !strcmp( p, "login" ) )
160			rectype = CARD_Login;
161			else if( !strcmp( p, "maxpinlen" ) )
162			rectype = CARD_MaxPinLen;
163			else if( !strcmp( p, "sigcount" ) )
164			rectype = CARD_SigCount;
165	twoaday	26	else if (!strcmp (p, "cafpr"))
166			rectype = CARD_CAFpr;
167			else if (!strcmp (p, "fpr"))
168			rectype = CARD_Fpr;
169			else if (!strcmp (p, "fprtime"))
170			rectype = CARD_FprTime;
171	twoaday	23	else
172			rectype = CARD_None;
173			}
174	twoaday	26	switch (rectype) {
175	twoaday	23	case CARD_AID:
176	twoaday	26	if (field == 2) {
177	twoaday	23	card->aid = strdup (p);
178			if (!card->aid)
179			return gpg_error (GPG_ERR_ENOMEM);
180			}
181	twoaday	26	else if (field == 3) {
182			card->card_type = strdup (p);
183			if (!card->card_type)
184			return gpg_error (GPG_ERR_ENOMEM);
185			}
186	twoaday	23	break;
187	twoaday	26
188	twoaday	23	case CARD_Version:
189	twoaday	26	if (field == 2) {
190	twoaday	23	card->version = strdup (p);
191			if (!card->version)
192			return gpg_error (GPG_ERR_ENOMEM);
193			}
194			break;
195	twoaday	26
196	twoaday	23	case CARD_Vendor:
197	twoaday	26	if (field == 3) {
198			card->vendor = strdup (p);
199	twoaday	23	if (!card->vendor)
200			return gpg_error (GPG_ERR_ENOMEM);
201			}
202			break;
203	twoaday	26
204	twoaday	23	case CARD_Serial:
205	twoaday	26	if (field == 2) {
206			card->serial = strdup (p);
207	twoaday	23	if (!card->serial)
208			return gpg_error (GPG_ERR_ENOMEM);
209			}
210			break;
211			case CARD_Name:
212	twoaday	26	if (field == 2) {
213			card->givenname = strdup (p);
214	twoaday	23	if (!card->givenname)
215			return gpg_error (GPG_ERR_ENOMEM);
216			}
217	twoaday	26	else if (field == 3) {
218			card->surname = strdup (p);
219	twoaday	23	if (!card->surname)
220			return gpg_error (GPG_ERR_ENOMEM);
221			}
222			break;
223			case CARD_Lang:
224			if( field == 2 ) {
225	twoaday	26	card->lang = strdup (p);
226	twoaday	23	if (!card->lang)
227			return gpg_error (GPG_ERR_ENOMEM);
228			}
229			break;
230			case CARD_Sex:
231			if( field == 2 )
232			card->sex = *p;
233			break;
234	twoaday	26
235	twoaday	23	case CARD_Url:
236			if( field == 2 ) {
237			if (card->url)
238			free (card->url);
239	twoaday	24	card->url = (char*)calloc (1, strlen (p) + 1);
240	twoaday	23	if( !card->url ) {
241	twoaday	24	return gpg_error (GPG_ERR_ENOMEM);
242	twoaday	23	}
243	twoaday	24	gpg_decode_c_string (p, &card->url, strlen (p) + 1);
244	twoaday	23	if (!card->url)
245			return gpg_error (GPG_ERR_ENOMEM);
246			}
247			break;
248	twoaday	26
249	twoaday	23	case CARD_Login:
250	twoaday	26	if (field == 2) {
251	twoaday	23	card->login = strdup (p);
252			if (!card->login)
253			return gpg_error (GPG_ERR_ENOMEM);
254			}
255			break;
256	twoaday	26
257	twoaday	23	case CARD_MaxPinLen:
258			break;
259	twoaday	26
260	twoaday	23	case CARD_SigCount:
261	twoaday	26	if (field == 2)
262			card->sig_count = atol (p);
263	twoaday	23	break;
264	twoaday	26
265			case CARD_CAFpr:
266			if (!p)
267			break;
268			if (field > 4 \|\| field == 1)
269			break;
270			card->ca_fpr[field-2] = strdup (p);
271			if (!card->ca_fpr[field-2])
272			return gpg_error (GPG_ERR_ENOMEM);
273			break;
274
275	twoaday	23	case CARD_Fpr:
276	twoaday	26	if (field > 4 \|\| field == 1) /* max 3 fprs */
277			break;
278			card->fpr[field-2] = strdup (p);
279			if (!card->fpr[field-2])
280			return gpg_error (GPG_ERR_ENOMEM);
281	twoaday	23	break;
282	twoaday	26
283			case CARD_FprTime:
284			if (field > 4 \|\| field == 1)
285			break;
286			card->fpr_created[field-2] = strtoul (p, NULL, 10);
287			card->fpr_created_str[field-2] = get_str_timestamp (strtoul (p, NULL, 10));
288			if (!card->fpr_created_str[field-2])
289			return gpg_error (GPG_ERR_ENOMEM);
290			break;
291
292	twoaday	23	}
293			}
294			return 0;
295			}
296
297
298			/* Dummy handler to get the colon data and then quit. */
299			static gpgme_error_t
300			list_handler (void opaque, gpgme_status_code_t code, const char key, int fd)
301			{
302	twoaday	26	GpgCardEdit ce = (GpgCardEdit )opaque;
303	twoaday	24	const char *s="";
304			DWORD n;
305
306	twoaday	26	if (code == GPGME_STATUS_CARDCTRL && *key == '5')
307			ce->setResult (GPG_CARDRES_NOCARD);
308			if (!strcmp (key, "cardedit.prompt")) {
309	twoaday	24	s = "quit\n";
310	twoaday	26	if (!WriteFile ((HANDLE)fd, s, strlen (s), &n, NULL))
311			log_debug ("list_handler: WriteFile() failed ec=%d\r\n",
312			(int)GetLastError ());
313	twoaday	24	}
314	twoaday	23	return 0;
315			}
316
317
318			/* Construct an empty object. */
319			GpgCardEdit::GpgCardEdit (void)
320			{
321			pin = NULL;
322			pin_new = NULL;
323			admin_pin = NULL;
324
325	twoaday	26	keygen.comment = NULL;
326			keygen.email = NULL;
327			keygen.name = NULL;
328			keygen.expdate = NULL;
329			keygen.key_fpr = NULL;
330
331	twoaday	23	type = 0;
332			cnt = 0;
333			cancel = 0;
334	twoaday	26	result = 0;
335	twoaday	23
336	twoaday	26	gpgme_new (&ctx); /* XXX: check return code */
337	twoaday	23	}
338
339			/* Release the object. */
340			GpgCardEdit::~GpgCardEdit (void)
341	twoaday	26	{
342			if (keygen.name)
343			free (keygen.name);
344			if (keygen.comment)
345			free (keygen.comment);
346			if (keygen.email)
347			free (keygen.email);
348			if (keygen.expdate)
349			free (keygen.expdate);
350			if (keygen.key_fpr)
351			free (keygen.key_fpr);
352			gpgme_release (ctx);
353	twoaday	23	}
354
355
356			/* Set the user PIN for the object to @pin. */
357			void
358			GpgCardEdit::setPIN (const char *pin)
359			{
360			this->pin = pin;
361			}
362
363			/* Set the admin PIN for the object to @admin_pin. */
364			void
365			GpgCardEdit::setAdminPIN (const char *admin_pin)
366			{
367			this->admin_pin = admin_pin;
368			}
369
370
371			/* Set the new user PIN for the object to @new_pin. */
372			void
373			GpgCardEdit::setNewPIN (const char *new_pin)
374			{
375			this->pin_new = new_pin;
376			}
377
378
379			/* Set the passphrase needed when generating a key to @pass. */
380			void
381			GpgCardEdit::setKeygenPassphrase (const char *pass)
382			{
383			this->keygen.pass = pass;
384			}
385
386
387			/* Set the callback to @cb and the hook value to @cb_value. */
388			void
389			GpgCardEdit::setCallback (const char* (cb)(int code, void opaque),
390			void *cb_value)
391			{
392			this->cb_value = cb_value;
393			this->card_cb = cb;
394			}
395
396
397			/* Read the information from the inserted card and return
398			it in form of a card context @r_card.
399			Return value: 0 on success. */
400			gpgme_error_t
401			GpgCardEdit::getCardStatus (gpg_card_t *r_card)
402			{
403	twoaday	26	gpgme_data_t out = NULL;
404			gpgme_key_t key=NULL;
405	twoaday	23	gpgme_error_t err;
406	twoaday	26	gpg_card_t card=NULL;
407	twoaday	23	char buf[200];
408
409			if (!r_card)
410			return gpg_error (GPG_ERR_INV_ARG);
411
412	twoaday	26	/* XXX: dummy key */
413			key = (gpgme_key_t)calloc (1, sizeof *key);
414			key->subkeys = (gpgme_subkey_t)calloc (1, sizeof *key->subkeys);
415			key->subkeys->fpr = strdup ("foo");
416
417			err = gpg_card_new (&card);
418	twoaday	23	if (err)
419			return err;
420	twoaday	26
421			err = gpgme_data_new (&out);
422			if (err) {
423			gpg_card_release (card);
424			return err;
425			}
426	twoaday	23
427	twoaday	26	err = gpgme_op_card_edit (ctx, key, list_handler, this, out);
428			gpgme_data_rewind (out);
429	twoaday	23	if (err) {
430	twoaday	26	gpgme_data_release (out);
431			gpg_card_release (card);
432	twoaday	23	return err;
433			}
434	twoaday	26	if (getResult () & GPG_CARDRES_NOCARD) {
435			gpg_card_release (card);
436			gpgme_data_release (out);
437			return gpg_error (GPG_ERR_CARD_REMOVED);
438			}
439	twoaday	23
440	twoaday	26	*r_card = card;
441			while (gpg_data_readline (out, buf, sizeof (buf)-2) > 0) {
442			err = statuscard_colon_handler (card, buf);
443			if (err)
444			break;
445			}
446			gpgme_data_release (out);
447	twoaday	23
448	twoaday	26	if (key) { /* XXX */
449			free (key->subkeys->keyid);
450			free (key->subkeys);
451			free (key);
452			}
453
454	twoaday	23	return err;
455			}
456
457
458			/* Generate a key on a smart card with the following params:
459			@flags: user specific params.
460			@name: name of the key holder.
461			@email: email of the key holder.
462			@comment: optional comment.
463			@valid: how long is the key valid in days.
464			Return value: 0 on success. */
465			gpgme_error_t
466			GpgCardEdit::genKey (int flags, const char *name,
467	twoaday	26	const char email, const char comment, long valid,
468			char **r_key_fpr)
469	twoaday	23	{
470			gpgme_error_t err;
471
472			if (!name \|\| !email)
473			return gpg_error (GPG_ERR_INV_ARG);
474			if (!this->keygen.pass)
475			return gpg_error (GPG_ERR_INV_OBJ);
476
477			type = GPG_EDITCARD_GENKEY;
478			this->keygen.flags = flags;
479
480			if (this->keygen.name)
481			free (this->keygen.name);
482			this->keygen.name = strdup (name);
483			if (this->keygen.email)
484			free (this->keygen.email);
485			this->keygen.email = strdup (email);
486			if (this->keygen.comment)
487			free (this->keygen.comment);
488			this->keygen.comment = comment? strdup (comment) : strdup ("");
489			if (this->keygen.expdate)
490	twoaday	26	free (this->keygen.expdate);
491	twoaday	23	this->keygen.expdate = (char*)calloc (1, 16);
492			if (this->keygen.expdate)
493			sprintf (this->keygen.expdate, "%d", valid);
494
495	twoaday	26	if (!this->keygen.name \|\| !this->keygen.email)
496	twoaday	23	return gpg_error (GPG_ERR_ENOMEM);
497
498			err = gpg_card_edit (ctx, this);
499	twoaday	26	if (!err && r_key_fpr)
500			*r_key_fpr = strdup (keygen.key_fpr? keygen.key_fpr : "");
501	twoaday	23	return err;
502			}
503
504
505			/* Change the pin from @pin to @pin_new.
506			Return value: 0 on success. */
507			gpgme_error_t
508	twoaday	26	GpgCardEdit::changePIN (int type)
509	twoaday	23	{
510			gpgme_error_t err;
511
512	twoaday	26	if (!this->pin_new)
513	twoaday	23	return gpg_error (GPG_ERR_INV_ARG);
514
515			if (!type) {
516			if (this->pin && this->pin_new)
517	twoaday	26	this->type = GPG_EDITCARD_CHUPIN;
518	twoaday	23	else if (this->pin && this->admin_pin)
519	twoaday	26	this->type = GPG_EDITCARD_CHAPIN;
520	twoaday	23	else
521	twoaday	26	this->type = GPG_EDITCARD_UNBPIN;
522	twoaday	23	}
523	twoaday	26	else
524			this->type = type;
525			/* check if the user provided the needed PIN. */
526			if ((this->type == GPG_EDITCARD_CHUPIN && !this->pin) \|\|
527			(this->type == GPG_EDITCARD_CHAPIN && !this->admin_pin))
528			return gpg_error (GPG_ERR_INV_ARG);
529	twoaday	23
530			err = gpg_card_edit (ctx, this);
531			return err;
532			}
533
534
535			gpgme_error_t
536			GpgCardEdit::updateName (const char given, const char sur)
537			{
538			gpgme_error_t err;
539
540	twoaday	26	if (!this->admin_pin)
541	twoaday	23	return gpg_error (GPG_ERR_INV_OBJ);
542
543	twoaday	26	this->type = GPG_EDITCARD_NAME;
544	twoaday	23	this->edit.surname = sur;
545			this->edit.givenname = given;
546
547			err = gpg_card_edit (ctx, this);
548			return err;
549			}
550
551			gpgme_error_t
552			GpgCardEdit::updateURL (const char *url)
553			{
554			gpgme_error_t err;
555
556	twoaday	26	if (!this->admin_pin)
557	twoaday	23	return gpg_error (GPG_ERR_INV_OBJ);
558
559	twoaday	26	type = GPG_EDITCARD_KEYURL;
560	twoaday	23	this->edit.keyurl = url;
561
562			err = gpg_card_edit (ctx, this);
563			return err;
564			}
565
566
567			gpgme_error_t
568			GpgCardEdit::updateLogin (const char *login)
569			{
570			gpgme_error_t err;
571
572	twoaday	26	if (!this->admin_pin)
573	twoaday	23	return gpg_error (GPG_ERR_INV_OBJ);
574
575	twoaday	26	this->type = GPG_EDITCARD_LOGIN;
576	twoaday	23	this->edit.login = login;
577
578			err = gpg_card_edit (ctx, this);
579			return err;
580			}
581
582			gpgme_error_t
583			GpgCardEdit::updateSex (char sex)
584			{
585			gpgme_error_t err;
586
587	twoaday	26	if (!this->admin_pin)
588	twoaday	23	return gpg_error (GPG_ERR_INV_OBJ);
589
590	twoaday	26	type = GPG_EDITCARD_SEX;
591	twoaday	23	this->edit.sex = sex;
592	twoaday	26
593	twoaday	23	err = gpg_card_edit (ctx, this);
594			return err;
595			}
596
597			gpgme_error_t
598			GpgCardEdit::updateLanguage (const char *lang)
599			{
600			gpgme_error_t err;
601
602	twoaday	26	if (!this->admin_pin)
603	twoaday	23	return gpg_error (GPG_ERR_INV_OBJ);
604
605	twoaday	26	type = GPG_EDITCARD_LANG;
606	twoaday	23	this->edit.lang = lang;
607	twoaday	26
608	twoaday	23	err = gpg_card_edit (ctx, this);
609			return err;
610			}
611
612
613			/* Fetch the key specified by the url stored on the card.
614			Return value: 0 on success. */
615			gpgme_error_t
616			GpgCardEdit::fetchKey (void)
617			{
618			gpgme_error_t err = 0;
619
620			if (!this->pin)
621			return gpg_error (GPG_ERR_INV_OBJ);
622
623			return 0;
624			}
625
626
627	twoaday	26	/* Dispatcher for the various commands. @cmd is the card command ID
628			and @arg1 and @arg2 the actual values for the command.
629			Return value: 0 on success. */
630	twoaday	23	gpgme_error_t
631			GpgCardEdit:: doCmd (int cmd, const char arg1, const char arg2)
632			{
633			switch (cmd) {
634			case GPG_EDITCARD_NAME:
635			return updateName (arg1, arg2); /* given, surname */
636
637			case GPG_EDITCARD_LANG:
638			return updateLanguage (arg1); /* lang */
639
640			case GPG_EDITCARD_SEX:
641			return updateSex (arg1); / sex */
642
643			case GPG_EDITCARD_KEYURL:
644			return updateURL (arg1); /* url */
645
646			case GPG_EDITCARD_LOGIN:
647			return updateLogin (arg1); /* login */
648	twoaday	26
649			default:
650			return gpg_error (GPG_ERR_INV_VALUE);
651	twoaday	23	}
652
653			return 0;
654			}
655	twoaday	26
656
657			/* Set the result for the executed operation.
658			The values will be ORed. */
659			void
660			GpgCardEdit::setResult (int res)
661			{
662			result \|= res;
663			}
664
665
666			/* Return the result of the executed operation. */
667			int
668			GpgCardEdit::getResult (void)
669			{
670			return result;
671			}
672
673
674			/* Reset the object state. */
675			void
676			GpgCardEdit::reset (void)
677			{
678			cnt = 0;
679			}