trunk/MyGPGME/editcard.c

/* editcard.c - OpenPGP Smartcard Support
 *      Copyright (C) 2003, 2004 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME 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.
 *
 * MyGPGME 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 this program; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <stdio.h>

#include "gpgme-config.h"
#ifdef WITH_EDITCARD
#include "ops.h"
#include "context.h"
#include "util.h"
#include "types.h"


#define save_write(val) ((val)? (val) : "")

#define ON_EVENT(_code, _key) (code == (_code) && !strcmp (key, _key))


static void
card_status_handler (gpgme_ctx_t ctx, gpg_status_code_t code, char * args)
{
    if (!ctx || ctx->out_of_core)
        return;
    
    switch( code ) {
    case STATUS_CARDCTRL:
        break;

    case STATUS_KEY_CREATED:    
        safe_free (ctx->keygen_fpr);
        ctx->keygen_fpr = strdup (args+2);
        if (!ctx->keygen_fpr)
            ctx->out_of_core = 1;
        break;
    }
} /* card_status_handler */


static const char *
statuscard_command_handler (void * opaque, gpg_status_code_t code, 
                            const char * key)
{
    gpgme_ctx_t ctx = opaque;
    gpgme_editcard_t c = ctx->edit_opaque;

    if (!c || ctx->out_of_core)
        return NULL;

    if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card.okay")) 
    {
        if (c->card_cb )
            return c->card_cb (1, c->cb_value);
    }

    return NULL;
} /* statuscard_command_handler */


static const char *
changepin_command_handler (void * opaque, gpg_status_code_t code, 
                           const char * key)
{
    gpgme_ctx_t ctx = opaque;
    gpgme_editcard_t c = ctx->edit_opaque;
    const char * s = "";

    if( !c || ctx->out_of_core )
        return NULL;

    if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card_okay")) 
    {
        if (c->card_cb)
            return c->card_cb (1, c->cb_value);
    }
    if (ON_EVENT (STATUS_GET_LINE, "cardutil.change_pin.menu")) 
    {
        if (c->cnt == 0) {
            c->cnt++;
            switch (ctx->edit_cmd) {
            case GPGME_EDITCARD_CHUPIN: return "1";
            case GPGME_EDITCARD_UNBPIN: return "2";
            case GPGME_EDITCARD_CHAPIN: return "3";
            default: c->cnt = 0;        return "Q";
            }
        }
        else if (c->cnt) {
            c->cnt = 0;
            return "Q";
        }
    }
    if (ctx->edit_cmd == GPGME_EDITCARD_CHUPIN) 
    {
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.ask")) {
            s = c->u.pin.pinold;
            c->cnt++;
        }
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.new.ask")) {
            s = c->u.pin.pinnew;
            c->cnt++;
        }
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.repeat")) {
            s = c->u.pin.pinnew;
            c->cnt++;
        }
        return s;
    }
    else if (ctx->edit_cmd == GPGME_EDITCARD_CHAPIN) 
    {
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.adminpin.ask")) {
            s = c->u.pin.pinold;
            c->cnt++;
        }
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.adminpin.new.ask")) {
            s = c->u.pin.pinnew;
            c->cnt++;
        }
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.repeat")) {
            s = c->u.pin.pinnew;
            c->cnt++;
        }
        return s;
    }
    else if (ctx->edit_cmd == GPGME_EDITCARD_UNBPIN) 
    {
        /* todo */
    }

    return NULL;
} /* changepin_command_handler */


static const char *
editcard_command_handler (void * opaque, gpg_status_code_t code, const char * key)
{
    gpgme_ctx_t ctx = opaque;
    gpgme_editcard_t c = ctx->edit_opaque;
    
    DEBUG3 ("type=%d code=%d key=%s\n", c->type, code, key);

    if (!c || ctx->out_of_core)
        return NULL;
    
    if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card.okay")) {
        if (c->card_cb)
            return c->card_cb (1, c->cb_value);
    }

    if (ON_EVENT (STATUS_GET_LINE, "cardedit.prompt")) 
    {
        if (c->cnt == 0) /* first switch in the admin mode */
        {
            c->cnt++;
            return "admin";
        }
        if (c->cnt == 1) /* then run the send command */
        { 
            c->cnt++;
            switch (ctx->edit_cmd) 
            {
            case GPGME_EDITCARD_NAME:   return "name";
            case GPGME_EDITCARD_KEYURL: return "url";
            case GPGME_EDITCARD_LOGIN:  return "login";
            case GPGME_EDITCARD_SEX:    return "sex";
            case GPGME_EDITCARD_LANG:   return "lang";
            case GPGME_EDITCARD_GENKEY: return "generate";
            default:                    return "quit";
            }
        }
        else if (c->cnt >= 2) /* done: send exit */
        { 
            c->cnt = 0;
            return "quit";
        }
    }
    if (c->cnt > 0 && code == STATUS_GET_HIDDEN) 
    {
        if (!strcmp (key, "passphrase.adminpin.ask"))
            return c->apin;
        if (!strcmp (key, "passphrase.pin.ask"))
            return c->upin;
    }
    switch (ctx->edit_cmd) 
    {
    case GPGME_EDITCARD_NAME:
        if (ON_EVENT (STATUS_GET_LINE, "keygen.smartcard.surname"))
            return save_write (c->u.edit.surname);
        else if (ON_EVENT (STATUS_GET_LINE, "keygen.smartcard.givenname"))
            return save_write (c->u.edit.givenname);
        break;

    case GPGME_EDITCARD_KEYURL:
        if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_url"))
            return save_write (c->u.edit.keyurl);
        break;

    case GPGME_EDITCARD_LOGIN:
        if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_login"))
            return save_write (c->u.edit.login);
        break;

    case GPGME_EDITCARD_SEX:
        if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_sex")) 
        {
            if (c->u.edit.sex != 'M'
                && c->u.edit.sex != 'F'
                && c->u.edit.sex != ' ')
                return " ";
            else 
            {
                static char buf[2];
                buf[0] = c->u.edit.sex; buf[1] = 0;
                return buf;
            }
        }
        break;

    case GPGME_EDITCARD_LANG:
        if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_lang"))
            return save_write (c->u.edit.lang);
        break;

    case GPGME_EDITCARD_GENKEY:
        if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.enter"))
            return c->keygen.passwd;
        if (ON_EVENT (STATUS_GET_BOOL, "cardedit.genkeys.backup_enc") ||
            ON_EVENT (STATUS_GET_LINE, "cardedit.genkeys.backup_enc"))
            return c->keygen.flags & GPGME_CARDFLAG_BAKENC? "Y" : "N";
        if (ON_EVENT (STATUS_GET_BOOL, "cardedit.genkeys.replace_keys")) 
        {
            if (! (c->keygen.flags & GPGME_CARDFLAG_REPLACE))
                c->cancel = 1;
            return c->keygen.flags & GPGME_CARDFLAG_REPLACE? "Y" : "N";
        }
        else if (ON_EVENT (STATUS_GET_LINE, "keygen.valid"))
            return save_write (c->keygen.expdate);
        else if (ON_EVENT (STATUS_GET_LINE, "keygen.name"))
            return save_write (c->keygen.name);
        else if (ON_EVENT (STATUS_GET_LINE, "keygen.email"))
            return save_write (c->keygen.email);
        else if (ON_EVENT (STATUS_GET_LINE, "keygen.comment"))
            return save_write (c->keygen.comment);
        break;

    default:
        return NULL;
    }
    return NULL;
} /* editcard_command_handler */


static gpgme_error_t
changepin_start( gpgme_ctx_t ctx )
{
    gpgme_error_t rc;

    ctx->pending=1;

    _gpgme_gpg_release( &ctx->gpg );
    rc = _gpgme_gpg_new( &ctx->gpg );
    if( rc )
        return rc;

    _gpgme_gpg_set_status_handler( ctx->gpg, card_status_handler, ctx );
    _gpgme_gpg_set_command_handler( ctx->gpg, changepin_command_handler, ctx );

    _gpgme_gpg_add_arg( ctx->gpg, "--change-pin" );

    rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
    if( rc ) {
        ctx->pending =0;
        _gpgme_gpg_release( &ctx->gpg );
    }

    return rc;
} /* changepin_start */


gpgme_error_t
gpgme_op_changepin( gpgme_ctx_t ctx )
{
    gpgme_error_t rc;

    rc = changepin_start( ctx );
    if( !rc ) {
        gpgme_wait( ctx, 1 );
        ctx->pending = 0;
        if( gpgme_get_process_rc( ctx ) )
            rc = mk_error( Interal_GPG_Problem );
    }
    return rc;
} /* gpgme_op_changepin */


gpgme_error_t
gpgme_changepin_set (gpgme_editcard_t chpin, int which,
                     const char * pinold, const char * pinnew)
{
    if (!chpin)
        return mk_error (Invalid_Value);
    chpin->type = which;
    chpin->u.pin.pinnew = pinnew;
    chpin->u.pin.pinold = pinold;
    return 0;
} /* gpgme_changepin_set */


static gpgme_error_t
editcard_start (gpgme_ctx_t ctx)
{
    gpgme_error_t rc;

    ctx->pending = 1;

    _gpgme_gpg_release (&ctx->gpg);
    rc = _gpgme_gpg_new (&ctx->gpg);
    if (rc)
        return rc;

    _gpgme_gpg_set_status_handler (ctx->gpg, card_status_handler, ctx);
    if (ctx->edit_cmd)
        _gpgme_gpg_set_command_handler (ctx->gpg, editcard_command_handler, ctx);

    _gpgme_gpg_add_arg (ctx->gpg, "--card-edit");

    rc = _gpgme_gpg_spawn (ctx->gpg, ctx);
    if (rc) {
        ctx->pending = 0;
        _gpgme_gpg_release (&ctx->gpg);
    }

    return rc;
} /* editcard_start */


gpgme_error_t
gpgme_op_editcard (gpgme_ctx_t ctx)
{
    gpgme_error_t rc;

    rc = editcard_start (ctx);
    if (!rc) {
        gpgme_wait (ctx, 1);
        ctx->pending = 0;
        if (((gpgme_editcard_t)ctx->edit_opaque)->cancel)
            rc = mk_error (Canceled);
        else if (ctx->keygen_fpr)
            rc = mk_error (No_Error);
        else if (gpgme_get_process_rc (ctx))
            rc = mk_error (Interal_GPG_Problem);
    }
    return rc;
} /* gpgme_op_editcard */


gpgme_error_t
gpgme_editcard_new (gpgme_editcard_t * r_ctx)
{
    gpgme_editcard_t ctx;

    if (!r_ctx)
        return mk_error (Invalid_Value);
    *r_ctx = NULL;
    ctx = calloc (1, sizeof * ctx);
    if (!ctx)
        return mk_error (Out_Of_Core);
    *r_ctx = ctx;
    return 0;
} /* gpgme_editcard_new */


void
gpgme_editcard_release (gpgme_editcard_t ctx)
{
    if (!ctx)
        return;
    safe_free (ctx->keygen.name);
    safe_free (ctx->keygen.comment);
    safe_free (ctx->keygen.email);
    safe_free (ctx->keygen.expdate);
    safe_free (ctx );
} /* gpgme_editcard_release */


gpgme_error_t
gpgme_editcard_set_passwd (gpgme_editcard_t ctx, const char * passwd)
{
    if (!ctx)
        return mk_error (Invalid_Value);
    ctx->type = GPGME_EDITCARD_GENKEY;
    ctx->keygen.passwd = passwd;
    return 0;
}

gpgme_error_t
gpgme_editcard_set_keygen_params (gpgme_editcard_t ctx, int flags,
                                  const char * name, const char * email,
                                  const char * comment, const char * expdate)
{
    char * p;

    if (!ctx)
        return mk_error (Invalid_Value);
    if (!name || !email)
        return mk_error (Invalid_Value);

    ctx->type = GPGME_EDITCARD_GENKEY;
    ctx->keygen.flags = flags;

    p = ctx->keygen.name = strdup (name);
    if (!p)
        return mk_error (Out_Of_Core);
    p = ctx->keygen.email = strdup (email);
    if (!p)
        return mk_error (Out_Of_Core);
    p = ctx->keygen.comment = comment? strdup (comment) : strdup ("");
    if (!p)
        return mk_error (Out_Of_Core);
    p = ctx->keygen.expdate = expdate? strdup (expdate) : strdup ("0");
    if (!p)
        return mk_error(Out_Of_Core);
    return 0;
} /* gpgme_editcard_set_keygen_params */


void
gpgme_editcard_set_callback (gpgme_editcard_t ctx, 
                             const char *(*cb) (int code, void * opaque),
                             void * cb_value)
{
    if (!ctx)
        return;
    ctx->card_cb = cb;
    ctx->cb_value = cb_value;
} /* gpgme_editcard_set_callback */


gpgme_error_t
gpgme_editcard_control (gpgme_editcard_t ctx, int cmd, const void * val)
{
    const char * p;

    if (!ctx)
        return mk_error (Invalid_Value);

    switch (cmd) {
    case GPGME_EDITCARD_NAME:  
        ctx->u.edit.givenname = (const char *)val;
        break;

    case GPGME_EDITCARD_NAME2: 
        ctx->u.edit.surname = (const char *)val; 
        break;

    case GPGME_EDITCARD_KEYURL:
        ctx->u.edit.keyurl = (const char *)val; 
        break;

    case GPGME_EDITCARD_LOGIN:
        ctx->u.edit.login = (const char *)val;
        break;

    case GPGME_EDITCARD_SEX:
        p = (const char *)val; 
        ctx->u.edit.sex = *p; 
        break;

    case GPGME_EDITCARD_LANG:  
        ctx->u.edit.lang = (const char *)val;
        break;

    case GPGME_EDITCARD_APIN:
        ctx->apin = (const char *)val; 
        break;

    case GPGME_EDITCARD_UPIN:
        ctx->upin = (const char *)val; 
        break;

    default:
        return mk_error (Invalid_Mode);
    }
    /* in some cases we do not want to change the command ID:
       1. when the given name will be set but the surname command
          already set the command ID.
       2. the pin is stored because the pin is no real command */
    if (cmd == GPGME_EDITCARD_NAME2
        || cmd == GPGME_EDITCARD_APIN
        || cmd == GPGME_EDITCARD_UPIN)
        ;
    else
        ctx->type = cmd;
    return 0;
} /* gpgme_editcard_control */


static void
statuscard_colon_handler( gpgme_ctx_t ctx, 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_Fpr
    };
    enum rectype_t rectype;
    gpgme_card_t card;
    char * t, * p, * pend;
    int field = 0;

    if( ctx->out_of_core )
        return;

    if( !line )
        return ; /* EOF */
    
    if( !ctx->card && gpgme_card_new( &ctx->card ) ) {
        ctx->out_of_core = 1;
        return;
    }
    card = ctx->card;

    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, "fpr" ) )
                rectype = CARD_Fpr;
            else
                rectype = CARD_None;
        }
        switch( rectype ) {
        case CARD_AID:
            if( field == 2 ) {
                t = card->aid = strdup( p ); 
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_Version:
            if( field == 2 ) {
                t = card->version = strdup( p );
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_Vendor:
            if( field == 3 ) {
                t = card->vendor = strdup( p ); 
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_Serial:
            if( field == 2 ) {
                t = card->serial = strdup( p );
                if( !t ) 
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_Name:
            if( field == 2 ) {
                t = card->givenname = strdup( p );
                if( !t )
                    ctx->out_of_core = 1;
            }
            else if( field == 3 ) {
                t = card->surname = strdup( p );
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_Lang:
            if( field == 2 )
                card->lang = strdup( p ) ;
            break;
        case CARD_Sex:
            if( field == 2 )
                card->sex = *p;
            break;
        case CARD_Url:
            if( field == 2 ) {
                safe_free( card->url );
                card->url = calloc( 1, strlen( p ) + 1 );
                if( !card->url ) {
                    ctx->out_of_core = 1;
                    return;
                }
                _gpgme_decode_c_string (p, &card->url, strlen (p) + 1);
            }
            break;
        case CARD_Login:
            if( field == 2 ) {
                t = card->login = strdup( p );
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        case CARD_MaxPinLen:
            break;
        case CARD_SigCount:
            if( field == 2 )
                card->sig_count = atol( p );
            break;
        case CARD_Fpr:
            if( field == 2 || field == 3 || field == 4 ) {
                t = card->fpr[ctx->tmp_i++] = strdup( p );
                if( !t )
                    ctx->out_of_core = 1;
            }
            break;
        }
    }
} /* statuscard_colon_handler */


static gpgme_error_t
status_card_start( gpgme_ctx_t ctx, gpgme_data_t tmp_out )
{
    gpgme_error_t rc;

    if( !ctx || !tmp_out )
        return mk_error( Invalid_Value );
    _gpgme_data_set_mode( tmp_out, GPGME_DATA_MODE_IN );

    ctx->pending = 1;

    _gpgme_gpg_release( &ctx->gpg );
    rc = _gpgme_gpg_new( &ctx->gpg );
    if( rc )
        return rc;

    _gpgme_gpg_set_command_handler( ctx->gpg,  statuscard_command_handler, ctx );
    if( ctx->use_logging )
        _gpgme_gpg_set_logging_handler( ctx->gpg, ctx );

    _gpgme_gpg_add_arg( ctx->gpg, "--with-colons" );
    _gpgme_gpg_add_arg( ctx->gpg, "--card-status" );
    _gpgme_gpg_add_arg( ctx->gpg, "--output" );
    _gpgme_gpg_add_arg( ctx->gpg, "-" );
    _gpgme_gpg_add_data( ctx->gpg, tmp_out, 1 );

    rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
    if( rc ) {
        ctx->pending = 0;
        _gpgme_gpg_release( &ctx->gpg );
    }
    return rc;
} /* status_card_start */


gpgme_error_t
gpgme_op_statuscard( gpgme_ctx_t ctx, gpgme_card_t * ret_card )
{
    gpgme_data_t tmp = NULL;
    gpgme_error_t rc;
    char buf[200];

    if (!ret_card || !ctx)
        return mk_error (Invalid_Value);

    rc = gpgme_data_new (&tmp);
    if (rc)
        return rc;
    
    rc = status_card_start( ctx, tmp );
    if( !rc ) {
        gpgme_wait( ctx, 1 );
        ctx->pending = 0;
        if( gpgme_get_process_rc( ctx ) )
            rc = mk_error( Interal_GPG_Problem );
    }

    gpgme_data_rewind( tmp );
    while( !rc && gpgme_data_readline( tmp, buf, sizeof buf-2 ) )
        statuscard_colon_handler( ctx, buf );
    gpgme_data_release( tmp );
    ctx->tmp_i = 0;
    *ret_card = ctx->card;
    return rc;
} /* gpgme_op_statuscard */


gpgme_error_t
gpgme_card_new( gpgme_card_t * ret_card )
{
    gpgme_card_t c;

    if (!ret_card)
        return mk_error( Invalid_Value );
    *ret_card = NULL;
    c = calloc( 1, sizeof * c );
    if( !c )
        return mk_error( Out_Of_Core );
    *ret_card = c;
    return 0;
} /* gpgme_card_new */


void
gpgme_card_release( gpgme_card_t card )
{
    int i;

    if( !card )
        return;
    safe_free( card->aid );
    safe_free( card->version );
    safe_free( card->lang );
    safe_free( card->login );
    for( i=0; i < 3; i++ )
        safe_free( card->fpr[i] );
    safe_free( card->surname );
    safe_free( card->givenname );
    safe_free( card->serial );
    safe_free( card->vendor );
    safe_free( card->url );
    safe_free( card );
} /* gpgme_card_release */


const char *
gpgme_card_get_string_attr( gpgme_card_t card, gpgme_attr_t what, 
                            void ** reserved, int idx )
{
    const char * s;

    if( !card )
        return NULL;

    switch( what ) {
    case GPGME_ATTR_CARD_AID:   
        s=card->aid; 
        break;

    case GPGME_ATTR_CARD_VER:   
        s=card->version; 
        break;

    case GPGME_ATTR_CARD_VENDOR:
        s=card->vendor; 
        break;

    case GPGME_ATTR_CARD_NAME:  
        s=card->givenname; 
        break;

    case GPGME_ATTR_CARD_NAME2: 
        s=card->surname; 
        break;

    case GPGME_ATTR_CARD_LANG:  
        s=card->lang; 
        break;

    case GPGME_ATTR_CARD_URL:   
        s=card->url; 
        break;

    case GPGME_ATTR_CARD_LOGIN: 
        s=card->login; 
        break;

    case GPGME_ATTR_CARD_FPR:   
        if( idx >= 0 && idx <= 3 ) 
            s=card->fpr[idx];       
        else                       
            s=NULL;
        break;

    case GPGME_ATTR_CARD_SERIAL:
        s=card->serial; 
        break;

    default:
        s=NULL; 
        break;
    }
    return s;
} /* gpgme_card_get_string_attr */


unsigned long
gpgme_card_get_ulong_attr( gpgme_card_t card, gpgme_attr_t what,
                           void ** reserved, int idx )
{
    unsigned long t;

    if( !card )
        return 0;

    switch( what ) {
    case GPGME_ATTR_CARD_SIGCOUNT:
        t = card->sig_count;
        break;

    case GPGME_ATTR_CARD_SEX:
        t = card->sex; 
        break;

    default:                       
        t = 0; 
        break;
    }
    return t;
} /* gpgme_card_get_ulong_attr */

#endif /* WITH_EDITCARD */
1	twoaday	2	/* editcard.c - OpenPGP Smartcard Support
2			* Copyright (C) 2003, 2004 Timo Schulz
3			*
4			* This file is part of MyGPGME.
5			*
6			* MyGPGME 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			* MyGPGME 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 this program; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <stdio.h>
22
23			#include "gpgme-config.h"
24			#ifdef WITH_EDITCARD
25			#include "ops.h"
26			#include "context.h"
27			#include "util.h"
28			#include "types.h"
29
30
31			#define save_write(val) ((val)? (val) : "")
32
33			#define ON_EVENT(_code, _key) (code == (_code) && !strcmp (key, _key))
34
35
36			static void
37			card_status_handler (gpgme_ctx_t ctx, gpg_status_code_t code, char * args)
38			{
39			if (!ctx \|\| ctx->out_of_core)
40			return;
41
42			switch( code ) {
43			case STATUS_CARDCTRL:
44			break;
45
46			case STATUS_KEY_CREATED:
47			safe_free (ctx->keygen_fpr);
48			ctx->keygen_fpr = strdup (args+2);
49			if (!ctx->keygen_fpr)
50			ctx->out_of_core = 1;
51			break;
52			}
53			} /* card_status_handler */
54
55
56			static const char *
57			statuscard_command_handler (void * opaque, gpg_status_code_t code,
58			const char * key)
59			{
60			gpgme_ctx_t ctx = opaque;
61			gpgme_editcard_t c = ctx->edit_opaque;
62
63			if (!c \|\| ctx->out_of_core)
64			return NULL;
65
66			if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card.okay"))
67			{
68			if (c->card_cb )
69			return c->card_cb (1, c->cb_value);
70			}
71
72			return NULL;
73			} /* statuscard_command_handler */
74
75
76			static const char *
77			changepin_command_handler (void * opaque, gpg_status_code_t code,
78			const char * key)
79			{
80			gpgme_ctx_t ctx = opaque;
81			gpgme_editcard_t c = ctx->edit_opaque;
82			const char * s = "";
83
84			if( !c \|\| ctx->out_of_core )
85			return NULL;
86
87			if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card_okay"))
88			{
89			if (c->card_cb)
90			return c->card_cb (1, c->cb_value);
91			}
92			if (ON_EVENT (STATUS_GET_LINE, "cardutil.change_pin.menu"))
93			{
94	twoaday	5	if (c->cnt == 0) {
95	twoaday	2	c->cnt++;
96			switch (ctx->edit_cmd) {
97			case GPGME_EDITCARD_CHUPIN: return "1";
98			case GPGME_EDITCARD_UNBPIN: return "2";
99			case GPGME_EDITCARD_CHAPIN: return "3";
100	twoaday	5	default: c->cnt = 0; return "Q";
101	twoaday	2	}
102			}
103			else if (c->cnt) {
104			c->cnt = 0;
105			return "Q";
106			}
107			}
108			if (ctx->edit_cmd == GPGME_EDITCARD_CHUPIN)
109			{
110	twoaday	5	if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.ask")) {
111			s = c->u.pin.pinold;
112	twoaday	2	c->cnt++;
113			}
114	twoaday	5	if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.new.ask")) {
115			s = c->u.pin.pinnew;
116			c->cnt++;
117			}
118			if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.repeat")) {
119			s = c->u.pin.pinnew;
120			c->cnt++;
121			}
122	twoaday	2	return s;
123			}
124			else if (ctx->edit_cmd == GPGME_EDITCARD_CHAPIN)
125			{
126	twoaday	5	if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.adminpin.ask")) {
127			s = c->u.pin.pinold;
128	twoaday	2	c->cnt++;
129			}
130	twoaday	5	if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.adminpin.new.ask")) {
131			s = c->u.pin.pinnew;
132			c->cnt++;
133			}
134			if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.pin.repeat")) {
135			s = c->u.pin.pinnew;
136			c->cnt++;
137			}
138	twoaday	2	return s;
139			}
140			else if (ctx->edit_cmd == GPGME_EDITCARD_UNBPIN)
141			{
142			/* todo */
143			}
144
145			return NULL;
146			} /* changepin_command_handler */
147
148
149			static const char *
150			editcard_command_handler (void * opaque, gpg_status_code_t code, const char * key)
151			{
152			gpgme_ctx_t ctx = opaque;
153			gpgme_editcard_t c = ctx->edit_opaque;
154
155			DEBUG3 ("type=%d code=%d key=%s\n", c->type, code, key);
156
157			if (!c \|\| ctx->out_of_core)
158			return NULL;
159
160			if (ON_EVENT (STATUS_GET_LINE, "cardctrl.insert_card.okay")) {
161			if (c->card_cb)
162			return c->card_cb (1, c->cb_value);
163			}
164
165			if (ON_EVENT (STATUS_GET_LINE, "cardedit.prompt"))
166			{
167			if (c->cnt == 0) /* first switch in the admin mode */
168			{
169			c->cnt++;
170			return "admin";
171			}
172			if (c->cnt == 1) /* then run the send command */
173			{
174			c->cnt++;
175			switch (ctx->edit_cmd)
176			{
177			case GPGME_EDITCARD_NAME: return "name";
178			case GPGME_EDITCARD_KEYURL: return "url";
179			case GPGME_EDITCARD_LOGIN: return "login";
180			case GPGME_EDITCARD_SEX: return "sex";
181			case GPGME_EDITCARD_LANG: return "lang";
182			case GPGME_EDITCARD_GENKEY: return "generate";
183			default: return "quit";
184			}
185			}
186			else if (c->cnt >= 2) /* done: send exit */
187			{
188			c->cnt = 0;
189			return "quit";
190			}
191			}
192			if (c->cnt > 0 && code == STATUS_GET_HIDDEN)
193			{
194			if (!strcmp (key, "passphrase.adminpin.ask"))
195			return c->apin;
196			if (!strcmp (key, "passphrase.pin.ask"))
197			return c->upin;
198			}
199			switch (ctx->edit_cmd)
200			{
201			case GPGME_EDITCARD_NAME:
202			if (ON_EVENT (STATUS_GET_LINE, "keygen.smartcard.surname"))
203			return save_write (c->u.edit.surname);
204			else if (ON_EVENT (STATUS_GET_LINE, "keygen.smartcard.givenname"))
205			return save_write (c->u.edit.givenname);
206			break;
207
208			case GPGME_EDITCARD_KEYURL:
209			if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_url"))
210			return save_write (c->u.edit.keyurl);
211			break;
212
213			case GPGME_EDITCARD_LOGIN:
214			if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_login"))
215			return save_write (c->u.edit.login);
216			break;
217
218			case GPGME_EDITCARD_SEX:
219			if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_sex"))
220			{
221			if (c->u.edit.sex != 'M'
222			&& c->u.edit.sex != 'F'
223			&& c->u.edit.sex != ' ')
224			return " ";
225			else
226			{
227			static char buf[2];
228			buf[0] = c->u.edit.sex; buf[1] = 0;
229			return buf;
230			}
231			}
232			break;
233
234			case GPGME_EDITCARD_LANG:
235			if (ON_EVENT (STATUS_GET_LINE, "cardedit.change_lang"))
236			return save_write (c->u.edit.lang);
237			break;
238
239			case GPGME_EDITCARD_GENKEY:
240			if (ON_EVENT (STATUS_GET_HIDDEN, "passphrase.enter"))
241			return c->keygen.passwd;
242			if (ON_EVENT (STATUS_GET_BOOL, "cardedit.genkeys.backup_enc") \|\|
243			ON_EVENT (STATUS_GET_LINE, "cardedit.genkeys.backup_enc"))
244			return c->keygen.flags & GPGME_CARDFLAG_BAKENC? "Y" : "N";
245			if (ON_EVENT (STATUS_GET_BOOL, "cardedit.genkeys.replace_keys"))
246			{
247			if (! (c->keygen.flags & GPGME_CARDFLAG_REPLACE))
248			c->cancel = 1;
249			return c->keygen.flags & GPGME_CARDFLAG_REPLACE? "Y" : "N";
250			}
251			else if (ON_EVENT (STATUS_GET_LINE, "keygen.valid"))
252			return save_write (c->keygen.expdate);
253			else if (ON_EVENT (STATUS_GET_LINE, "keygen.name"))
254			return save_write (c->keygen.name);
255			else if (ON_EVENT (STATUS_GET_LINE, "keygen.email"))
256			return save_write (c->keygen.email);
257			else if (ON_EVENT (STATUS_GET_LINE, "keygen.comment"))
258			return save_write (c->keygen.comment);
259			break;
260
261			default:
262			return NULL;
263			}
264			return NULL;
265			} /* editcard_command_handler */
266
267
268			static gpgme_error_t
269			changepin_start( gpgme_ctx_t ctx )
270			{
271			gpgme_error_t rc;
272
273			ctx->pending=1;
274
275			_gpgme_gpg_release( &ctx->gpg );
276			rc = _gpgme_gpg_new( &ctx->gpg );
277			if( rc )
278			return rc;
279
280			_gpgme_gpg_set_status_handler( ctx->gpg, card_status_handler, ctx );
281			_gpgme_gpg_set_command_handler( ctx->gpg, changepin_command_handler, ctx );
282
283			_gpgme_gpg_add_arg( ctx->gpg, "--change-pin" );
284
285			rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
286			if( rc ) {
287			ctx->pending =0;
288			_gpgme_gpg_release( &ctx->gpg );
289			}
290
291			return rc;
292			} /* changepin_start */
293
294
295			gpgme_error_t
296			gpgme_op_changepin( gpgme_ctx_t ctx )
297			{
298			gpgme_error_t rc;
299
300			rc = changepin_start( ctx );
301			if( !rc ) {
302			gpgme_wait( ctx, 1 );
303			ctx->pending = 0;
304			if( gpgme_get_process_rc( ctx ) )
305			rc = mk_error( Interal_GPG_Problem );
306			}
307			return rc;
308			} /* gpgme_op_changepin */
309
310
311			gpgme_error_t
312	twoaday	5	gpgme_changepin_set (gpgme_editcard_t chpin, int which,
313			const char * pinold, const char * pinnew)
314	twoaday	2	{
315	twoaday	5	if (!chpin)
316			return mk_error (Invalid_Value);
317	twoaday	2	chpin->type = which;
318			chpin->u.pin.pinnew = pinnew;
319			chpin->u.pin.pinold = pinold;
320			return 0;
321			} /* gpgme_changepin_set */
322
323
324			static gpgme_error_t
325			editcard_start (gpgme_ctx_t ctx)
326			{
327			gpgme_error_t rc;
328
329			ctx->pending = 1;
330
331			_gpgme_gpg_release (&ctx->gpg);
332			rc = _gpgme_gpg_new (&ctx->gpg);
333			if (rc)
334			return rc;
335
336			_gpgme_gpg_set_status_handler (ctx->gpg, card_status_handler, ctx);
337			if (ctx->edit_cmd)
338			_gpgme_gpg_set_command_handler (ctx->gpg, editcard_command_handler, ctx);
339
340			_gpgme_gpg_add_arg (ctx->gpg, "--card-edit");
341
342			rc = _gpgme_gpg_spawn (ctx->gpg, ctx);
343			if (rc) {
344			ctx->pending = 0;
345			_gpgme_gpg_release (&ctx->gpg);
346			}
347
348			return rc;
349			} /* editcard_start */
350
351
352			gpgme_error_t
353			gpgme_op_editcard (gpgme_ctx_t ctx)
354			{
355			gpgme_error_t rc;
356
357			rc = editcard_start (ctx);
358			if (!rc) {
359			gpgme_wait (ctx, 1);
360			ctx->pending = 0;
361			if (((gpgme_editcard_t)ctx->edit_opaque)->cancel)
362			rc = mk_error (Canceled);
363			else if (ctx->keygen_fpr)
364			rc = mk_error (No_Error);
365			else if (gpgme_get_process_rc (ctx))
366			rc = mk_error (Interal_GPG_Problem);
367			}
368			return rc;
369			} /* gpgme_op_editcard */
370
371
372			gpgme_error_t
373			gpgme_editcard_new (gpgme_editcard_t * r_ctx)
374			{
375			gpgme_editcard_t ctx;
376
377			if (!r_ctx)
378			return mk_error (Invalid_Value);
379			*r_ctx = NULL;
380			ctx = calloc (1, sizeof * ctx);
381			if (!ctx)
382			return mk_error (Out_Of_Core);
383			*r_ctx = ctx;
384			return 0;
385			} /* gpgme_editcard_new */
386
387
388			void
389			gpgme_editcard_release (gpgme_editcard_t ctx)
390			{
391			if (!ctx)
392			return;
393			safe_free (ctx->keygen.name);
394			safe_free (ctx->keygen.comment);
395			safe_free (ctx->keygen.email);
396			safe_free (ctx->keygen.expdate);
397			safe_free (ctx );
398			} /* gpgme_editcard_release */
399
400
401			gpgme_error_t
402			gpgme_editcard_set_passwd (gpgme_editcard_t ctx, const char * passwd)
403			{
404			if (!ctx)
405			return mk_error (Invalid_Value);
406			ctx->type = GPGME_EDITCARD_GENKEY;
407			ctx->keygen.passwd = passwd;
408			return 0;
409			}
410
411			gpgme_error_t
412			gpgme_editcard_set_keygen_params (gpgme_editcard_t ctx, int flags,
413			const char * name, const char * email,
414			const char * comment, const char * expdate)
415			{
416			char * p;
417
418			if (!ctx)
419			return mk_error (Invalid_Value);
420			if (!name \|\| !email)
421			return mk_error (Invalid_Value);
422
423			ctx->type = GPGME_EDITCARD_GENKEY;
424			ctx->keygen.flags = flags;
425
426			p = ctx->keygen.name = strdup (name);
427			if (!p)
428			return mk_error (Out_Of_Core);
429			p = ctx->keygen.email = strdup (email);
430			if (!p)
431			return mk_error (Out_Of_Core);
432			p = ctx->keygen.comment = comment? strdup (comment) : strdup ("");
433			if (!p)
434			return mk_error (Out_Of_Core);
435			p = ctx->keygen.expdate = expdate? strdup (expdate) : strdup ("0");
436			if (!p)
437			return mk_error(Out_Of_Core);
438			return 0;
439			} /* gpgme_editcard_set_keygen_params */
440
441
442			void
443			gpgme_editcard_set_callback (gpgme_editcard_t ctx,
444			const char (cb) (int code, void * opaque),
445			void * cb_value)
446			{
447			if (!ctx)
448			return;
449			ctx->card_cb = cb;
450			ctx->cb_value = cb_value;
451			} /* gpgme_editcard_set_callback */
452
453
454			gpgme_error_t
455			gpgme_editcard_control (gpgme_editcard_t ctx, int cmd, const void * val)
456			{
457			const char * p;
458
459			if (!ctx)
460			return mk_error (Invalid_Value);
461
462			switch (cmd) {
463			case GPGME_EDITCARD_NAME:
464			ctx->u.edit.givenname = (const char *)val;
465			break;
466
467			case GPGME_EDITCARD_NAME2:
468			ctx->u.edit.surname = (const char *)val;
469			break;
470
471			case GPGME_EDITCARD_KEYURL:
472			ctx->u.edit.keyurl = (const char *)val;
473			break;
474
475			case GPGME_EDITCARD_LOGIN:
476			ctx->u.edit.login = (const char *)val;
477			break;
478
479			case GPGME_EDITCARD_SEX:
480			p = (const char *)val;
481			ctx->u.edit.sex = *p;
482			break;
483
484			case GPGME_EDITCARD_LANG:
485			ctx->u.edit.lang = (const char *)val;
486			break;
487
488			case GPGME_EDITCARD_APIN:
489			ctx->apin = (const char *)val;
490			break;
491
492			case GPGME_EDITCARD_UPIN:
493			ctx->upin = (const char *)val;
494			break;
495
496			default:
497			return mk_error (Invalid_Mode);
498			}
499			/* in some cases we do not want to change the command ID:
500			1. when the given name will be set but the surname command
501			already set the command ID.
502			2. the pin is stored because the pin is no real command */
503			if (cmd == GPGME_EDITCARD_NAME2
504			\|\| cmd == GPGME_EDITCARD_APIN
505			\|\| cmd == GPGME_EDITCARD_UPIN)
506			;
507			else
508			ctx->type = cmd;
509			return 0;
510			} /* gpgme_editcard_control */
511
512
513			static void
514			statuscard_colon_handler( gpgme_ctx_t ctx, char * line )
515			{
516			enum rectype_t {
517			CARD_None = 0,
518			CARD_AID,
519			CARD_Version,
520			CARD_Vendor,
521			CARD_Serial,
522			CARD_Name,
523			CARD_Lang,
524			CARD_Sex,
525			CARD_Url,
526			CARD_Login,
527			CARD_MaxPinLen,
528			CARD_SigCount,
529			CARD_Fpr
530			};
531			enum rectype_t rectype;
532			gpgme_card_t card;
533			char * t, * p, * pend;
534			int field = 0;
535
536			if( ctx->out_of_core )
537			return;
538
539			if( !line )
540			return ; /* EOF */
541
542			if( !ctx->card && gpgme_card_new( &ctx->card ) ) {
543			ctx->out_of_core = 1;
544			return;
545			}
546			card = ctx->card;
547
548			for( p = line; p; p = pend ) {
549			field++;
550			pend = strchr( p, ':' );
551			if( pend )
552			*pend++ = 0;
553
554			if( field == 1 ) {
555			if( !strcmp( p, "AID" ) )
556			rectype = CARD_AID;
557			else if( !strcmp( p, "version" ) )
558			rectype = CARD_Version;
559			else if( !strcmp( p, "vendor" ) )
560			rectype = CARD_Vendor;
561			else if( !strcmp( p, "serial" ) )
562			rectype = CARD_Serial;
563			else if( !strcmp( p, "name" ) )
564			rectype = CARD_Name;
565			else if( !strcmp( p, "lang" ) )
566			rectype = CARD_Lang;
567			else if( !strcmp( p, "sex" ) )
568			rectype = CARD_Sex;
569			else if( !strcmp( p, "url" ) )
570			rectype = CARD_Url;
571			else if( !strcmp( p, "login" ) )
572			rectype = CARD_Login;
573			else if( !strcmp( p, "maxpinlen" ) )
574			rectype = CARD_MaxPinLen;
575			else if( !strcmp( p, "sigcount" ) )
576			rectype = CARD_SigCount;
577			else if( !strcmp( p, "fpr" ) )
578			rectype = CARD_Fpr;
579			else
580			rectype = CARD_None;
581			}
582			switch( rectype ) {
583			case CARD_AID:
584			if( field == 2 ) {
585			t = card->aid = strdup( p );
586			if( !t )
587			ctx->out_of_core = 1;
588			}
589			break;
590			case CARD_Version:
591			if( field == 2 ) {
592			t = card->version = strdup( p );
593			if( !t )
594			ctx->out_of_core = 1;
595			}
596			break;
597			case CARD_Vendor:
598			if( field == 3 ) {
599			t = card->vendor = strdup( p );
600			if( !t )
601			ctx->out_of_core = 1;
602			}
603			break;
604			case CARD_Serial:
605			if( field == 2 ) {
606			t = card->serial = strdup( p );
607			if( !t )
608			ctx->out_of_core = 1;
609			}
610			break;
611			case CARD_Name:
612			if( field == 2 ) {
613			t = card->givenname = strdup( p );
614			if( !t )
615			ctx->out_of_core = 1;
616			}
617			else if( field == 3 ) {
618			t = card->surname = strdup( p );
619			if( !t )
620			ctx->out_of_core = 1;
621			}
622			break;
623			case CARD_Lang:
624			if( field == 2 )
625			card->lang = strdup( p ) ;
626			break;
627			case CARD_Sex:
628			if( field == 2 )
629			card->sex = *p;
630			break;
631			case CARD_Url:
632			if( field == 2 ) {
633			safe_free( card->url );
634			card->url = calloc( 1, strlen( p ) + 1 );
635			if( !card->url ) {
636			ctx->out_of_core = 1;
637			return;
638			}
639			_gpgme_decode_c_string (p, &card->url, strlen (p) + 1);
640			}
641			break;
642			case CARD_Login:
643			if( field == 2 ) {
644			t = card->login = strdup( p );
645			if( !t )
646			ctx->out_of_core = 1;
647			}
648			break;
649			case CARD_MaxPinLen:
650			break;
651			case CARD_SigCount:
652			if( field == 2 )
653			card->sig_count = atol( p );
654			break;
655			case CARD_Fpr:
656			if( field == 2 \|\| field == 3 \|\| field == 4 ) {
657			t = card->fpr[ctx->tmp_i++] = strdup( p );
658			if( !t )
659			ctx->out_of_core = 1;
660			}
661			break;
662			}
663			}
664			} /* statuscard_colon_handler */
665
666
667			static gpgme_error_t
668			status_card_start( gpgme_ctx_t ctx, gpgme_data_t tmp_out )
669			{
670			gpgme_error_t rc;
671
672			if( !ctx \|\| !tmp_out )
673			return mk_error( Invalid_Value );
674			_gpgme_data_set_mode( tmp_out, GPGME_DATA_MODE_IN );
675
676			ctx->pending = 1;
677
678			_gpgme_gpg_release( &ctx->gpg );
679			rc = _gpgme_gpg_new( &ctx->gpg );
680			if( rc )
681			return rc;
682
683			_gpgme_gpg_set_command_handler( ctx->gpg, statuscard_command_handler, ctx );
684			if( ctx->use_logging )
685			_gpgme_gpg_set_logging_handler( ctx->gpg, ctx );
686
687			_gpgme_gpg_add_arg( ctx->gpg, "--with-colons" );
688			_gpgme_gpg_add_arg( ctx->gpg, "--card-status" );
689			_gpgme_gpg_add_arg( ctx->gpg, "--output" );
690			_gpgme_gpg_add_arg( ctx->gpg, "-" );
691			_gpgme_gpg_add_data( ctx->gpg, tmp_out, 1 );
692
693			rc = _gpgme_gpg_spawn( ctx->gpg, ctx );
694			if( rc ) {
695			ctx->pending = 0;
696			_gpgme_gpg_release( &ctx->gpg );
697			}
698			return rc;
699			} /* status_card_start */
700
701
702			gpgme_error_t
703			gpgme_op_statuscard( gpgme_ctx_t ctx, gpgme_card_t * ret_card )
704			{
705			gpgme_data_t tmp = NULL;
706			gpgme_error_t rc;
707			char buf[200];
708
709			if (!ret_card \|\| !ctx)
710			return mk_error (Invalid_Value);
711
712			rc = gpgme_data_new (&tmp);
713			if (rc)
714			return rc;
715
716			rc = status_card_start( ctx, tmp );
717			if( !rc ) {
718			gpgme_wait( ctx, 1 );
719			ctx->pending = 0;
720			if( gpgme_get_process_rc( ctx ) )
721			rc = mk_error( Interal_GPG_Problem );
722			}
723
724			gpgme_data_rewind( tmp );
725			while( !rc && gpgme_data_readline( tmp, buf, sizeof buf-2 ) )
726			statuscard_colon_handler( ctx, buf );
727			gpgme_data_release( tmp );
728			ctx->tmp_i = 0;
729			*ret_card = ctx->card;
730			return rc;
731			} /* gpgme_op_statuscard */
732
733
734			gpgme_error_t
735			gpgme_card_new( gpgme_card_t * ret_card )
736			{
737			gpgme_card_t c;
738
739			if (!ret_card)
740			return mk_error( Invalid_Value );
741			*ret_card = NULL;
742			c = calloc( 1, sizeof * c );
743			if( !c )
744			return mk_error( Out_Of_Core );
745			*ret_card = c;
746			return 0;
747			} /* gpgme_card_new */
748
749
750			void
751			gpgme_card_release( gpgme_card_t card )
752			{
753			int i;
754
755			if( !card )
756			return;
757			safe_free( card->aid );
758			safe_free( card->version );
759			safe_free( card->lang );
760			safe_free( card->login );
761			for( i=0; i < 3; i++ )
762			safe_free( card->fpr[i] );
763			safe_free( card->surname );
764			safe_free( card->givenname );
765			safe_free( card->serial );
766			safe_free( card->vendor );
767			safe_free( card->url );
768			safe_free( card );
769			} /* gpgme_card_release */
770
771
772			const char *
773			gpgme_card_get_string_attr( gpgme_card_t card, gpgme_attr_t what,
774			void ** reserved, int idx )
775			{
776			const char * s;
777
778			if( !card )
779			return NULL;
780
781			switch( what ) {
782			case GPGME_ATTR_CARD_AID:
783			s=card->aid;
784			break;
785
786			case GPGME_ATTR_CARD_VER:
787			s=card->version;
788			break;
789
790			case GPGME_ATTR_CARD_VENDOR:
791			s=card->vendor;
792			break;
793
794			case GPGME_ATTR_CARD_NAME:
795			s=card->givenname;
796			break;
797
798			case GPGME_ATTR_CARD_NAME2:
799			s=card->surname;
800			break;
801
802			case GPGME_ATTR_CARD_LANG:
803			s=card->lang;
804			break;
805
806			case GPGME_ATTR_CARD_URL:
807			s=card->url;
808			break;
809
810			case GPGME_ATTR_CARD_LOGIN:
811			s=card->login;
812			break;
813
814			case GPGME_ATTR_CARD_FPR:
815			if( idx >= 0 && idx <= 3 )
816			s=card->fpr[idx];
817			else
818			s=NULL;
819			break;
820
821			case GPGME_ATTR_CARD_SERIAL:
822			s=card->serial;
823			break;
824
825			default:
826			s=NULL;
827			break;
828			}
829			return s;
830			} /* gpgme_card_get_string_attr */
831
832
833			unsigned long
834			gpgme_card_get_ulong_attr( gpgme_card_t card, gpgme_attr_t what,
835			void ** reserved, int idx )
836			{
837			unsigned long t;
838
839			if( !card )
840			return 0;
841
842			switch( what ) {
843			case GPGME_ATTR_CARD_SIGCOUNT:
844			t = card->sig_count;
845			break;
846
847			case GPGME_ATTR_CARD_SEX:
848			t = card->sex;
849			break;
850
851			default:
852			t = 0;
853			break;
854			}
855			return t;
856			} /* gpgme_card_get_ulong_attr */
857
858			#endif /* WITH_EDITCARD */