hw/usb/ccid-card-emulated.c

   1 /*
   2  * CCID Card Device. Emulated card.
   3  *
   4  * Copyright (c) 2011 Red Hat.
   5  * Written by Alon Levy.
   6  *
   7  * This code is licensed under the GNU LGPL, version 2 or later.
   8  */
   9
  10 /*
  11  * It can be used to provide access to the local hardware in a non exclusive
  12  * way, or it can use certificates. It requires the usb-ccid bus.
  13  *
  14  * Usage 1: standard, mirror hardware reader+card:
  15  * qemu .. -usb -device usb-ccid -device ccid-card-emulated
  16  *
  17  * Usage 2: use certificates, no hardware required
  18  * one time: create the certificates:
  19  *  for i in 1 2 3; do
  20  *      certutil -d /etc/pki/nssdb -x -t "CT,CT,CT" -S -s "CN=user$i" -n user$i
  21  *  done
  22  * qemu .. -usb -device usb-ccid \
  23  *  -device ccid-card-emulated,cert1=user1,cert2=user2,cert3=user3
  24  *
  25  * If you use a non default db for the certificates you can specify it using
  26  * the db parameter.
  27  */
  28
  29 #include "qemu/osdep.h"
  30 #include <libcacard.h>
  31
  32 #include "qemu/thread.h"
  33 #include "qemu/lockable.h"
  34 #include "qemu/main-loop.h"
  35 #include "qemu/module.h"
  36 #include "ccid.h"
  37 #include "hw/qdev-properties.h"
  38 #include "qapi/error.h"
  39 #include "qom/object.h"
  40
  41 #define DPRINTF(card, lvl, fmt, ...) \
  42 do {\
  43     if (lvl <= card->debug) {\
  44         printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\
  45     } \
  46 } while (0)
  47
  48
  49 #define TYPE_EMULATED_CCID "ccid-card-emulated"
  50 typedef struct EmulatedState EmulatedState;
  51 DECLARE_INSTANCE_CHECKER(EmulatedState, EMULATED_CCID_CARD,
  52                          TYPE_EMULATED_CCID)
  53
  54 #define BACKEND_NSS_EMULATED_NAME "nss-emulated"
  55 #define BACKEND_CERTIFICATES_NAME "certificates"
  56
  57 enum {
  58     BACKEND_NSS_EMULATED = 1,
  59     BACKEND_CERTIFICATES
  60 };
  61
  62 #define DEFAULT_BACKEND BACKEND_NSS_EMULATED
  63
  64
  65 enum {
  66     EMUL_READER_INSERT = 0,
  67     EMUL_READER_REMOVE,
  68     EMUL_CARD_INSERT,
  69     EMUL_CARD_REMOVE,
  70     EMUL_GUEST_APDU,
  71     EMUL_RESPONSE_APDU,
  72     EMUL_ERROR,
  73 };
  74
  75 static const char *emul_event_to_string(uint32_t emul_event)
  76 {
  77     switch (emul_event) {
  78     case EMUL_READER_INSERT:
  79         return "EMUL_READER_INSERT";
  80     case EMUL_READER_REMOVE:
  81         return "EMUL_READER_REMOVE";
  82     case EMUL_CARD_INSERT:
  83         return "EMUL_CARD_INSERT";
  84     case EMUL_CARD_REMOVE:
  85         return "EMUL_CARD_REMOVE";
  86     case EMUL_GUEST_APDU:
  87         return "EMUL_GUEST_APDU";
  88     case EMUL_RESPONSE_APDU:
  89         return "EMUL_RESPONSE_APDU";
  90     case EMUL_ERROR:
  91         return "EMUL_ERROR";
  92     }
  93     return "UNKNOWN";
  94 }
  95
  96 typedef struct EmulEvent {
  97     QSIMPLEQ_ENTRY(EmulEvent) entry;
  98     union {
  99         struct {
 100             uint32_t type;
 101         } gen;
 102         struct {
 103             uint32_t type;
 104             uint64_t code;
 105         } error;
 106         struct {
 107             uint32_t type;
 108             uint32_t len;
 109             uint8_t data[];
 110         } data;
 111     } p;
 112 } EmulEvent;
 113
 114 #define MAX_ATR_SIZE 40
 115 struct EmulatedState {
 116     CCIDCardState base;
 117     uint8_t  debug;
 118     char    *backend_str;
 119     uint32_t backend;
 120     char    *cert1;
 121     char    *cert2;
 122     char    *cert3;
 123     char    *db;
 124     uint8_t  atr[MAX_ATR_SIZE];
 125     uint8_t  atr_length;
 126     QSIMPLEQ_HEAD(, EmulEvent) event_list;
 127     QemuMutex event_list_mutex;
 128     QemuThread event_thread_id;
 129     VReader *reader;
 130     QSIMPLEQ_HEAD(, EmulEvent) guest_apdu_list;
 131     QemuMutex vreader_mutex; /* and guest_apdu_list mutex */
 132     QemuMutex handle_apdu_mutex;
 133     QemuCond handle_apdu_cond;
 134     EventNotifier notifier;
 135     int      quit_apdu_thread;
 136     QemuThread apdu_thread_id;
 137 };
 138
 139 static void emulated_apdu_from_guest(CCIDCardState *base,
 140     const uint8_t *apdu, uint32_t len)
 141 {
 142     EmulatedState *card = EMULATED_CCID_CARD(base);
 143     EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len);
 144
 145     assert(event);
 146     event->p.data.type = EMUL_GUEST_APDU;
 147     event->p.data.len = len;
 148     memcpy(event->p.data.data, apdu, len);
 149     qemu_mutex_lock(&card->vreader_mutex);
 150     QSIMPLEQ_INSERT_TAIL(&card->guest_apdu_list, event, entry);
 151     qemu_mutex_unlock(&card->vreader_mutex);
 152     qemu_mutex_lock(&card->handle_apdu_mutex);
 153     qemu_cond_signal(&card->handle_apdu_cond);
 154     qemu_mutex_unlock(&card->handle_apdu_mutex);
 155 }
 156
 157 static const uint8_t *emulated_get_atr(CCIDCardState *base, uint32_t *len)
 158 {
 159     EmulatedState *card = EMULATED_CCID_CARD(base);
 160
 161     *len = card->atr_length;
 162     return card->atr;
 163 }
 164
 165 static void emulated_push_event(EmulatedState *card, EmulEvent *event)
 166 {
 167     qemu_mutex_lock(&card->event_list_mutex);
 168     QSIMPLEQ_INSERT_TAIL(&(card->event_list), event, entry);
 169     qemu_mutex_unlock(&card->event_list_mutex);
 170     event_notifier_set(&card->notifier);
 171 }
 172
 173 static void emulated_push_type(EmulatedState *card, uint32_t type)
 174 {
 175     EmulEvent *event = g_new(EmulEvent, 1);
 176
 177     assert(event);
 178     event->p.gen.type = type;
 179     emulated_push_event(card, event);
 180 }
 181
 182 static void emulated_push_error(EmulatedState *card, uint64_t code)
 183 {
 184     EmulEvent *event = g_new(EmulEvent, 1);
 185
 186     assert(event);
 187     event->p.error.type = EMUL_ERROR;
 188     event->p.error.code = code;
 189     emulated_push_event(card, event);
 190 }
 191
 192 static void emulated_push_data_type(EmulatedState *card, uint32_t type,
 193     const uint8_t *data, uint32_t len)
 194 {
 195     EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len);
 196
 197     assert(event);
 198     event->p.data.type = type;
 199     event->p.data.len = len;
 200     memcpy(event->p.data.data, data, len);
 201     emulated_push_event(card, event);
 202 }
 203
 204 static void emulated_push_reader_insert(EmulatedState *card)
 205 {
 206     emulated_push_type(card, EMUL_READER_INSERT);
 207 }
 208
 209 static void emulated_push_reader_remove(EmulatedState *card)
 210 {
 211     emulated_push_type(card, EMUL_READER_REMOVE);
 212 }
 213
 214 static void emulated_push_card_insert(EmulatedState *card,
 215     const uint8_t *atr, uint32_t len)
 216 {
 217     emulated_push_data_type(card, EMUL_CARD_INSERT, atr, len);
 218 }
 219
 220 static void emulated_push_card_remove(EmulatedState *card)
 221 {
 222     emulated_push_type(card, EMUL_CARD_REMOVE);
 223 }
 224
 225 static void emulated_push_response_apdu(EmulatedState *card,
 226     const uint8_t *apdu, uint32_t len)
 227 {
 228     emulated_push_data_type(card, EMUL_RESPONSE_APDU, apdu, len);
 229 }
 230
 231 #define APDU_BUF_SIZE 270
 232 static void *handle_apdu_thread(void* arg)
 233 {
 234     EmulatedState *card = arg;
 235     uint8_t recv_data[APDU_BUF_SIZE];
 236     int recv_len;
 237     VReaderStatus reader_status;
 238     EmulEvent *event;
 239
 240     while (1) {
 241         qemu_mutex_lock(&card->handle_apdu_mutex);
 242         qemu_cond_wait(&card->handle_apdu_cond, &card->handle_apdu_mutex);
 243         qemu_mutex_unlock(&card->handle_apdu_mutex);
 244         if (card->quit_apdu_thread) {
 245             card->quit_apdu_thread = 0; /* debugging */
 246             break;
 247         }
 248         WITH_QEMU_LOCK_GUARD(&card->vreader_mutex) {
 249             while (!QSIMPLEQ_EMPTY(&card->guest_apdu_list)) {
 250                 event = QSIMPLEQ_FIRST(&card->guest_apdu_list);
 251                 assert((unsigned long)event > 1000);
 252                 QSIMPLEQ_REMOVE_HEAD(&card->guest_apdu_list, entry);
 253                 if (event->p.data.type != EMUL_GUEST_APDU) {
 254                     DPRINTF(card, 1, "unexpected message in handle_apdu_thread\n");
 255                     g_free(event);
 256                     continue;
 257                 }
 258                 if (card->reader == NULL) {
 259                     DPRINTF(card, 1, "reader is NULL\n");
 260                     g_free(event);
 261                     continue;
 262                 }
 263                 recv_len = sizeof(recv_data);
 264                 reader_status = vreader_xfr_bytes(card->reader,
 265                         event->p.data.data, event->p.data.len,
 266                         recv_data, &recv_len);
 267                 DPRINTF(card, 2, "got back apdu of length %d\n", recv_len);
 268                 if (reader_status == VREADER_OK) {
 269                     emulated_push_response_apdu(card, recv_data, recv_len);
 270                 } else {
 271                     emulated_push_error(card, reader_status);
 272                 }
 273                 g_free(event);
 274             }
 275         }
 276     }
 277     return NULL;
 278 }
 279
 280 static void *event_thread(void *arg)
 281 {
 282     int atr_len = MAX_ATR_SIZE;
 283     uint8_t atr[MAX_ATR_SIZE];
 284     VEvent *event = NULL;
 285     EmulatedState *card = arg;
 286
 287     while (1) {
 288         const char *reader_name;
 289
 290         event = vevent_wait_next_vevent();
 291         if (event == NULL || event->type == VEVENT_LAST) {
 292             break;
 293         }
 294         if (event->type != VEVENT_READER_INSERT) {
 295             if (card->reader == NULL && event->reader != NULL) {
 296                 /* Happens after device_add followed by card remove or insert.
 297                  * XXX: create synthetic add_reader events if vcard_emul_init
 298                  * already called, which happens if device_del and device_add
 299                  * are called */
 300                 card->reader = vreader_reference(event->reader);
 301             } else {
 302                 if (event->reader != card->reader) {
 303                     fprintf(stderr,
 304                         "ERROR: wrong reader: quiting event_thread\n");
 305                     break;
 306                 }
 307             }
 308         }
 309         switch (event->type) {
 310         case VEVENT_READER_INSERT:
 311             /* TODO: take a specific reader. i.e. track which reader
 312              * we are seeing here, check it is the one we want (the first,
 313              * or by a particular name), and ignore if we don't want it.
 314              */
 315             reader_name = vreader_get_name(event->reader);
 316             if (card->reader != NULL) {
 317                 DPRINTF(card, 2, "READER INSERT - replacing %s with %s\n",
 318                     vreader_get_name(card->reader), reader_name);
 319                 qemu_mutex_lock(&card->vreader_mutex);
 320                 vreader_free(card->reader);
 321                 qemu_mutex_unlock(&card->vreader_mutex);
 322                 emulated_push_reader_remove(card);
 323             }
 324             qemu_mutex_lock(&card->vreader_mutex);
 325             DPRINTF(card, 2, "READER INSERT %s\n", reader_name);
 326             card->reader = vreader_reference(event->reader);
 327             qemu_mutex_unlock(&card->vreader_mutex);
 328             emulated_push_reader_insert(card);
 329             break;
 330         case VEVENT_READER_REMOVE:
 331             DPRINTF(card, 2, " READER REMOVE: %s\n",
 332                     vreader_get_name(event->reader));
 333             qemu_mutex_lock(&card->vreader_mutex);
 334             vreader_free(card->reader);
 335             card->reader = NULL;
 336             qemu_mutex_unlock(&card->vreader_mutex);
 337             emulated_push_reader_remove(card);
 338             break;
 339         case VEVENT_CARD_INSERT:
 340             /* get the ATR (intended as a response to a power on from the
 341              * reader */
 342             atr_len = MAX_ATR_SIZE;
 343             vreader_power_on(event->reader, atr, &atr_len);
 344             card->atr_length = (uint8_t)atr_len;
 345             DPRINTF(card, 2, " CARD INSERT\n");
 346             emulated_push_card_insert(card, atr, atr_len);
 347             break;
 348         case VEVENT_CARD_REMOVE:
 349             DPRINTF(card, 2, " CARD REMOVE\n");
 350             emulated_push_card_remove(card);
 351             break;
 352         case VEVENT_LAST: /* quit */
 353             vevent_delete(event);
 354             return NULL;
 355         default:
 356             break;
 357         }
 358         vevent_delete(event);
 359     }
 360     return NULL;
 361 }
 362
 363 static void card_event_handler(EventNotifier *notifier)
 364 {
 365     EmulatedState *card = container_of(notifier, EmulatedState, notifier);
 366     EmulEvent *event, *next;
 367
 368     event_notifier_test_and_clear(&card->notifier);
 369     QEMU_LOCK_GUARD(&card->event_list_mutex);
 370     QSIMPLEQ_FOREACH_SAFE(event, &card->event_list, entry, next) {
 371         DPRINTF(card, 2, "event %s\n", emul_event_to_string(event->p.gen.type));
 372         switch (event->p.gen.type) {
 373         case EMUL_RESPONSE_APDU:
 374             ccid_card_send_apdu_to_guest(&card->base, event->p.data.data,
 375                 event->p.data.len);
 376             break;
 377         case EMUL_READER_INSERT:
 378             ccid_card_ccid_attach(&card->base);
 379             break;
 380         case EMUL_READER_REMOVE:
 381             ccid_card_ccid_detach(&card->base);
 382             break;
 383         case EMUL_CARD_INSERT:
 384             assert(event->p.data.len <= MAX_ATR_SIZE);
 385             card->atr_length = event->p.data.len;
 386             memcpy(card->atr, event->p.data.data, card->atr_length);
 387             ccid_card_card_inserted(&card->base);
 388             break;
 389         case EMUL_CARD_REMOVE:
 390             ccid_card_card_removed(&card->base);
 391             break;
 392         case EMUL_ERROR:
 393             ccid_card_card_error(&card->base, event->p.error.code);
 394             break;
 395         default:
 396             DPRINTF(card, 2, "unexpected event\n");
 397             break;
 398         }
 399         g_free(event);
 400     }
 401     QSIMPLEQ_INIT(&card->event_list);
 402 }
 403
 404 static int init_event_notifier(EmulatedState *card, Error **errp)
 405 {
 406     if (event_notifier_init(&card->notifier, false) < 0) {
 407         error_setg(errp, "ccid-card-emul: event notifier creation failed");
 408         return -1;
 409     }
 410     event_notifier_set_handler(&card->notifier, card_event_handler);
 411     return 0;
 412 }
 413
 414 static void clean_event_notifier(EmulatedState *card)
 415 {
 416     event_notifier_set_handler(&card->notifier, NULL);
 417     event_notifier_cleanup(&card->notifier);
 418 }
 419
 420 #define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb"
 421 #define CERTIFICATES_ARGS_TEMPLATE\
 422     "db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)"
 423
 424 static int wrap_vcard_emul_init(VCardEmulOptions *options)
 425 {
 426     static int called;
 427     static int options_was_null;
 428
 429     if (called) {
 430         if ((options == NULL) != options_was_null) {
 431             printf("%s: warning: running emulated with certificates"
 432                    " and emulated side by side is not supported\n",
 433                    __func__);
 434             return VCARD_EMUL_FAIL;
 435         }
 436         vcard_emul_replay_insertion_events();
 437         return VCARD_EMUL_OK;
 438     }
 439     options_was_null = (options == NULL);
 440     called = 1;
 441     return vcard_emul_init(options);
 442 }
 443
 444 static int emulated_initialize_vcard_from_certificates(EmulatedState *card)
 445 {
 446     char emul_args[200];
 447     VCardEmulOptions *options = NULL;
 448
 449     snprintf(emul_args, sizeof(emul_args) - 1, CERTIFICATES_ARGS_TEMPLATE,
 450         card->db ? card->db : CERTIFICATES_DEFAULT_DB,
 451         card->cert1, card->cert2, card->cert3);
 452     options = vcard_emul_options(emul_args);
 453     if (options == NULL) {
 454         printf("%s: warning: not using certificates due to"
 455                " initialization error\n", __func__);
 456     }
 457     return wrap_vcard_emul_init(options);
 458 }
 459
 460 typedef struct EnumTable {
 461     const char *name;
 462     uint32_t value;
 463 } EnumTable;
 464
 465 static const EnumTable backend_enum_table[] = {
 466     {BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED},
 467     {BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES},
 468     {NULL, 0},
 469 };
 470
 471 static uint32_t parse_enumeration(char *str,
 472     const EnumTable *table, uint32_t not_found_value)
 473 {
 474     uint32_t ret = not_found_value;
 475
 476     if (str == NULL)
 477         return 0;
 478
 479     while (table->name != NULL) {
 480         if (strcmp(table->name, str) == 0) {
 481             ret = table->value;
 482             break;
 483         }
 484         table++;
 485     }
 486     return ret;
 487 }
 488
 489 static void emulated_realize(CCIDCardState *base, Error **errp)
 490 {
 491     EmulatedState *card = EMULATED_CCID_CARD(base);
 492     VCardEmulError ret;
 493     const EnumTable *ptable;
 494
 495     QSIMPLEQ_INIT(&card->event_list);
 496     QSIMPLEQ_INIT(&card->guest_apdu_list);
 497     qemu_mutex_init(&card->event_list_mutex);
 498     qemu_mutex_init(&card->vreader_mutex);
 499     qemu_mutex_init(&card->handle_apdu_mutex);
 500     qemu_cond_init(&card->handle_apdu_cond);
 501     card->reader = NULL;
 502     card->quit_apdu_thread = 0;
 503     if (init_event_notifier(card, errp) < 0) {
 504         goto out1;
 505     }
 506
 507     card->backend = 0;
 508     if (card->backend_str) {
 509         card->backend = parse_enumeration(card->backend_str,
 510                                           backend_enum_table, 0);
 511     }
 512
 513     if (card->backend == 0) {
 514         error_setg(errp, "backend must be one of:");
 515         for (ptable = backend_enum_table; ptable->name != NULL; ++ptable) {
 516             error_append_hint(errp, "%s\n", ptable->name);
 517         }
 518         goto out2;
 519     }
 520
 521     /* TODO: a passthru backened that works on local machine. third card type?*/
 522     if (card->backend == BACKEND_CERTIFICATES) {
 523         if (card->cert1 != NULL && card->cert2 != NULL && card->cert3 != NULL) {
 524             ret = emulated_initialize_vcard_from_certificates(card);
 525         } else {
 526             error_setg(errp, "%s: you must provide all three certs for"
 527                        " certificates backend", TYPE_EMULATED_CCID);
 528             goto out2;
 529         }
 530     } else {
 531         if (card->backend != BACKEND_NSS_EMULATED) {
 532             error_setg(errp, "%s: bad backend specified. The options are:%s"
 533                        " (default), %s.", TYPE_EMULATED_CCID,
 534                        BACKEND_NSS_EMULATED_NAME, BACKEND_CERTIFICATES_NAME);
 535             goto out2;
 536         }
 537         if (card->cert1 != NULL || card->cert2 != NULL || card->cert3 != NULL) {
 538             error_setg(errp, "%s: unexpected cert parameters to nss emulated "
 539                        "backend", TYPE_EMULATED_CCID);
 540             goto out2;
 541         }
 542         /* default to mirroring the local hardware readers */
 543         ret = wrap_vcard_emul_init(NULL);
 544     }
 545     if (ret != VCARD_EMUL_OK) {
 546         error_setg(errp, "%s: failed to initialize vcard", TYPE_EMULATED_CCID);
 547         goto out2;
 548     }
 549     qemu_thread_create(&card->event_thread_id, "ccid/event", event_thread,
 550                        card, QEMU_THREAD_JOINABLE);
 551     qemu_thread_create(&card->apdu_thread_id, "ccid/apdu", handle_apdu_thread,
 552                        card, QEMU_THREAD_JOINABLE);
 553
 554     return;
 555
 556 out2:
 557     clean_event_notifier(card);
 558 out1:
 559     qemu_cond_destroy(&card->handle_apdu_cond);
 560     qemu_mutex_destroy(&card->handle_apdu_mutex);
 561     qemu_mutex_destroy(&card->vreader_mutex);
 562     qemu_mutex_destroy(&card->event_list_mutex);
 563 }
 564
 565 static void emulated_unrealize(CCIDCardState *base)
 566 {
 567     EmulatedState *card = EMULATED_CCID_CARD(base);
 568     VEvent *vevent = vevent_new(VEVENT_LAST, NULL, NULL);
 569
 570     vevent_queue_vevent(vevent); /* stop vevent thread */
 571     qemu_thread_join(&card->event_thread_id);
 572
 573     card->quit_apdu_thread = 1; /* stop handle_apdu thread */
 574     qemu_cond_signal(&card->handle_apdu_cond);
 575     qemu_thread_join(&card->apdu_thread_id);
 576
 577     clean_event_notifier(card);
 578     /* threads exited, can destroy all condvars/mutexes */
 579     qemu_cond_destroy(&card->handle_apdu_cond);
 580     qemu_mutex_destroy(&card->handle_apdu_mutex);
 581     qemu_mutex_destroy(&card->vreader_mutex);
 582     qemu_mutex_destroy(&card->event_list_mutex);
 583 }
 584
 585 static Property emulated_card_properties[] = {
 586     DEFINE_PROP_STRING("backend", EmulatedState, backend_str),
 587     DEFINE_PROP_STRING("cert1", EmulatedState, cert1),
 588     DEFINE_PROP_STRING("cert2", EmulatedState, cert2),
 589     DEFINE_PROP_STRING("cert3", EmulatedState, cert3),
 590     DEFINE_PROP_STRING("db", EmulatedState, db),
 591     DEFINE_PROP_UINT8("debug", EmulatedState, debug, 0),
 592     DEFINE_PROP_END_OF_LIST(),
 593 };
 594
 595 static void emulated_class_initfn(ObjectClass *klass, void *data)
 596 {
 597     DeviceClass *dc = DEVICE_CLASS(klass);
 598     CCIDCardClass *cc = CCID_CARD_CLASS(klass);
 599
 600     cc->realize = emulated_realize;
 601     cc->unrealize = emulated_unrealize;
 602     cc->get_atr = emulated_get_atr;
 603     cc->apdu_from_guest = emulated_apdu_from_guest;
 604     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
 605     dc->desc = "emulated smartcard";
 606     device_class_set_props(dc, emulated_card_properties);
 607 }
 608
 609 static const TypeInfo emulated_card_info = {
 610     .name          = TYPE_EMULATED_CCID,
 611     .parent        = TYPE_CCID_CARD,
 612     .instance_size = sizeof(EmulatedState),
 613     .class_init    = emulated_class_initfn,
 614 };
 615
 616 static void ccid_card_emulated_register_types(void)
 617 {
 618     type_register_static(&emulated_card_info);
 619 }
 620
 621 type_init(ccid_card_emulated_register_types)