scsi: move request-related callbacks from SCSIDeviceInfo to SCSIReqOps
[qemu.git] / hw / ccid-card-emulated.c
blob4762e85116b1e2ebc9b7955a08b0efa8f8288167
1 /*
2 * CCID Card Device. Emulated card.
4 * Copyright (c) 2011 Red Hat.
5 * Written by Alon Levy.
7 * This code is licensed under the GNU LGPL, version 2 or later.
8 */
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.
14 * Usage 1: standard, mirror hardware reader+card:
15 * qemu .. -usb -device usb-ccid -device ccid-card-emulated
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
25 * If you use a non default db for the certificates you can specify it using
26 * the db parameter.
29 #include <eventt.h>
30 #include <vevent.h>
31 #include <vreader.h>
32 #include <vcard_emul.h>
34 #include "qemu-thread.h"
35 #include "qemu-char.h"
36 #include "monitor.h"
37 #include "hw/ccid.h"
39 #define DPRINTF(card, lvl, fmt, ...) \
40 do {\
41 if (lvl <= card->debug) {\
42 printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\
43 } \
44 } while (0)
46 #define EMULATED_DEV_NAME "ccid-card-emulated"
48 #define BACKEND_NSS_EMULATED_NAME "nss-emulated"
49 #define BACKEND_CERTIFICATES_NAME "certificates"
51 enum {
52 BACKEND_NSS_EMULATED = 1,
53 BACKEND_CERTIFICATES
56 #define DEFAULT_BACKEND BACKEND_NSS_EMULATED
58 typedef struct EmulatedState EmulatedState;
60 enum {
61 EMUL_READER_INSERT = 0,
62 EMUL_READER_REMOVE,
63 EMUL_CARD_INSERT,
64 EMUL_CARD_REMOVE,
65 EMUL_GUEST_APDU,
66 EMUL_RESPONSE_APDU,
67 EMUL_ERROR,
70 static const char *emul_event_to_string(uint32_t emul_event)
72 switch (emul_event) {
73 case EMUL_READER_INSERT:
74 return "EMUL_READER_INSERT";
75 case EMUL_READER_REMOVE:
76 return "EMUL_READER_REMOVE";
77 case EMUL_CARD_INSERT:
78 return "EMUL_CARD_INSERT";
79 case EMUL_CARD_REMOVE:
80 return "EMUL_CARD_REMOVE";
81 case EMUL_GUEST_APDU:
82 return "EMUL_GUEST_APDU";
83 case EMUL_RESPONSE_APDU:
84 return "EMUL_RESPONSE_APDU";
85 case EMUL_ERROR:
86 return "EMUL_ERROR";
88 return "UNKNOWN";
91 typedef struct EmulEvent {
92 QSIMPLEQ_ENTRY(EmulEvent) entry;
93 union {
94 struct {
95 uint32_t type;
96 } gen;
97 struct {
98 uint32_t type;
99 uint64_t code;
100 } error;
101 struct {
102 uint32_t type;
103 uint32_t len;
104 uint8_t data[];
105 } data;
106 } p;
107 } EmulEvent;
109 #define MAX_ATR_SIZE 40
110 struct EmulatedState {
111 CCIDCardState base;
112 uint8_t debug;
113 char *backend_str;
114 uint32_t backend;
115 char *cert1;
116 char *cert2;
117 char *cert3;
118 char *db;
119 uint8_t atr[MAX_ATR_SIZE];
120 uint8_t atr_length;
121 QSIMPLEQ_HEAD(event_list, EmulEvent) event_list;
122 QemuMutex event_list_mutex;
123 VReader *reader;
124 QSIMPLEQ_HEAD(guest_apdu_list, EmulEvent) guest_apdu_list;
125 QemuMutex vreader_mutex; /* and guest_apdu_list mutex */
126 QemuMutex handle_apdu_mutex;
127 QemuCond handle_apdu_cond;
128 int pipe[2];
129 int quit_apdu_thread;
130 QemuMutex apdu_thread_quit_mutex;
131 QemuCond apdu_thread_quit_cond;
134 static void emulated_apdu_from_guest(CCIDCardState *base,
135 const uint8_t *apdu, uint32_t len)
137 EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
138 EmulEvent *event = (EmulEvent *)qemu_malloc(sizeof(EmulEvent) + len);
140 assert(event);
141 event->p.data.type = EMUL_GUEST_APDU;
142 event->p.data.len = len;
143 memcpy(event->p.data.data, apdu, len);
144 qemu_mutex_lock(&card->vreader_mutex);
145 QSIMPLEQ_INSERT_TAIL(&card->guest_apdu_list, event, entry);
146 qemu_mutex_unlock(&card->vreader_mutex);
147 qemu_mutex_lock(&card->handle_apdu_mutex);
148 qemu_cond_signal(&card->handle_apdu_cond);
149 qemu_mutex_unlock(&card->handle_apdu_mutex);
152 static const uint8_t *emulated_get_atr(CCIDCardState *base, uint32_t *len)
154 EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
156 *len = card->atr_length;
157 return card->atr;
160 static void emulated_push_event(EmulatedState *card, EmulEvent *event)
162 qemu_mutex_lock(&card->event_list_mutex);
163 QSIMPLEQ_INSERT_TAIL(&(card->event_list), event, entry);
164 qemu_mutex_unlock(&card->event_list_mutex);
165 if (write(card->pipe[1], card, 1) != 1) {
166 DPRINTF(card, 1, "write to pipe failed\n");
170 static void emulated_push_type(EmulatedState *card, uint32_t type)
172 EmulEvent *event = (EmulEvent *)qemu_malloc(sizeof(EmulEvent));
174 assert(event);
175 event->p.gen.type = type;
176 emulated_push_event(card, event);
179 static void emulated_push_error(EmulatedState *card, uint64_t code)
181 EmulEvent *event = (EmulEvent *)qemu_malloc(sizeof(EmulEvent));
183 assert(event);
184 event->p.error.type = EMUL_ERROR;
185 event->p.error.code = code;
186 emulated_push_event(card, event);
189 static void emulated_push_data_type(EmulatedState *card, uint32_t type,
190 const uint8_t *data, uint32_t len)
192 EmulEvent *event = (EmulEvent *)qemu_malloc(sizeof(EmulEvent) + len);
194 assert(event);
195 event->p.data.type = type;
196 event->p.data.len = len;
197 memcpy(event->p.data.data, data, len);
198 emulated_push_event(card, event);
201 static void emulated_push_reader_insert(EmulatedState *card)
203 emulated_push_type(card, EMUL_READER_INSERT);
206 static void emulated_push_reader_remove(EmulatedState *card)
208 emulated_push_type(card, EMUL_READER_REMOVE);
211 static void emulated_push_card_insert(EmulatedState *card,
212 const uint8_t *atr, uint32_t len)
214 emulated_push_data_type(card, EMUL_CARD_INSERT, atr, len);
217 static void emulated_push_card_remove(EmulatedState *card)
219 emulated_push_type(card, EMUL_CARD_REMOVE);
222 static void emulated_push_response_apdu(EmulatedState *card,
223 const uint8_t *apdu, uint32_t len)
225 emulated_push_data_type(card, EMUL_RESPONSE_APDU, apdu, len);
228 #define APDU_BUF_SIZE 270
229 static void *handle_apdu_thread(void* arg)
231 EmulatedState *card = arg;
232 uint8_t recv_data[APDU_BUF_SIZE];
233 int recv_len;
234 VReaderStatus reader_status;
235 EmulEvent *event;
237 while (1) {
238 qemu_mutex_lock(&card->handle_apdu_mutex);
239 qemu_cond_wait(&card->handle_apdu_cond, &card->handle_apdu_mutex);
240 qemu_mutex_unlock(&card->handle_apdu_mutex);
241 if (card->quit_apdu_thread) {
242 card->quit_apdu_thread = 0; /* debugging */
243 break;
245 qemu_mutex_lock(&card->vreader_mutex);
246 while (!QSIMPLEQ_EMPTY(&card->guest_apdu_list)) {
247 event = QSIMPLEQ_FIRST(&card->guest_apdu_list);
248 assert((unsigned long)event > 1000);
249 QSIMPLEQ_REMOVE_HEAD(&card->guest_apdu_list, entry);
250 if (event->p.data.type != EMUL_GUEST_APDU) {
251 DPRINTF(card, 1, "unexpected message in handle_apdu_thread\n");
252 qemu_free(event);
253 continue;
255 if (card->reader == NULL) {
256 DPRINTF(card, 1, "reader is NULL\n");
257 qemu_free(event);
258 continue;
260 recv_len = sizeof(recv_data);
261 reader_status = vreader_xfr_bytes(card->reader,
262 event->p.data.data, event->p.data.len,
263 recv_data, &recv_len);
264 DPRINTF(card, 2, "got back apdu of length %d\n", recv_len);
265 if (reader_status == VREADER_OK) {
266 emulated_push_response_apdu(card, recv_data, recv_len);
267 } else {
268 emulated_push_error(card, reader_status);
270 qemu_free(event);
272 qemu_mutex_unlock(&card->vreader_mutex);
274 qemu_mutex_lock(&card->apdu_thread_quit_mutex);
275 qemu_cond_signal(&card->apdu_thread_quit_cond);
276 qemu_mutex_unlock(&card->apdu_thread_quit_mutex);
277 return NULL;
280 static void *event_thread(void *arg)
282 int atr_len = MAX_ATR_SIZE;
283 uint8_t atr[MAX_ATR_SIZE];
284 VEvent *event = NULL;
285 EmulatedState *card = arg;
287 while (1) {
288 const char *reader_name;
290 event = vevent_wait_next_vevent();
291 if (event == NULL || event->type == VEVENT_LAST) {
292 break;
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;
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.
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);
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 break;
356 default:
357 break;
359 vevent_delete(event);
361 return NULL;
364 static void pipe_read(void *opaque)
366 EmulatedState *card = opaque;
367 EmulEvent *event, *next;
368 char dummy;
369 int len;
371 do {
372 len = read(card->pipe[0], &dummy, sizeof(dummy));
373 } while (len == sizeof(dummy));
374 qemu_mutex_lock(&card->event_list_mutex);
375 QSIMPLEQ_FOREACH_SAFE(event, &card->event_list, entry, next) {
376 DPRINTF(card, 2, "event %s\n", emul_event_to_string(event->p.gen.type));
377 switch (event->p.gen.type) {
378 case EMUL_RESPONSE_APDU:
379 ccid_card_send_apdu_to_guest(&card->base, event->p.data.data,
380 event->p.data.len);
381 break;
382 case EMUL_READER_INSERT:
383 ccid_card_ccid_attach(&card->base);
384 break;
385 case EMUL_READER_REMOVE:
386 ccid_card_ccid_detach(&card->base);
387 break;
388 case EMUL_CARD_INSERT:
389 assert(event->p.data.len <= MAX_ATR_SIZE);
390 card->atr_length = event->p.data.len;
391 memcpy(card->atr, event->p.data.data, card->atr_length);
392 ccid_card_card_inserted(&card->base);
393 break;
394 case EMUL_CARD_REMOVE:
395 ccid_card_card_removed(&card->base);
396 break;
397 case EMUL_ERROR:
398 ccid_card_card_error(&card->base, event->p.error.code);
399 break;
400 default:
401 DPRINTF(card, 2, "unexpected event\n");
402 break;
404 qemu_free(event);
406 QSIMPLEQ_INIT(&card->event_list);
407 qemu_mutex_unlock(&card->event_list_mutex);
410 static int init_pipe_signaling(EmulatedState *card)
412 if (pipe(card->pipe) < 0) {
413 DPRINTF(card, 2, "pipe creation failed\n");
414 return -1;
416 fcntl(card->pipe[0], F_SETFL, O_NONBLOCK);
417 fcntl(card->pipe[1], F_SETFL, O_NONBLOCK);
418 fcntl(card->pipe[0], F_SETOWN, getpid());
419 qemu_set_fd_handler(card->pipe[0], pipe_read, NULL, card);
420 return 0;
423 #define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb"
424 #define CERTIFICATES_ARGS_TEMPLATE\
425 "db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)"
427 static int wrap_vcard_emul_init(VCardEmulOptions *options)
429 static int called;
430 static int options_was_null;
432 if (called) {
433 if ((options == NULL) != options_was_null) {
434 printf("%s: warning: running emulated with certificates"
435 " and emulated side by side is not supported\n",
436 __func__);
437 return VCARD_EMUL_FAIL;
439 vcard_emul_replay_insertion_events();
440 return VCARD_EMUL_OK;
442 options_was_null = (options == NULL);
443 called = 1;
444 return vcard_emul_init(options);
447 static int emulated_initialize_vcard_from_certificates(EmulatedState *card)
449 char emul_args[200];
450 VCardEmulOptions *options = NULL;
452 snprintf(emul_args, sizeof(emul_args) - 1, CERTIFICATES_ARGS_TEMPLATE,
453 card->db ? card->db : CERTIFICATES_DEFAULT_DB,
454 card->cert1, card->cert2, card->cert3);
455 options = vcard_emul_options(emul_args);
456 if (options == NULL) {
457 printf("%s: warning: not using certificates due to"
458 " initialization error\n", __func__);
460 return wrap_vcard_emul_init(options);
463 typedef struct EnumTable {
464 const char *name;
465 uint32_t value;
466 } EnumTable;
468 EnumTable backend_enum_table[] = {
469 {BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED},
470 {BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES},
471 {NULL, 0},
474 static uint32_t parse_enumeration(char *str,
475 EnumTable *table, uint32_t not_found_value)
477 uint32_t ret = not_found_value;
479 while (table->name != NULL) {
480 if (strcmp(table->name, str) == 0) {
481 ret = table->value;
482 break;
484 table++;
486 return ret;
489 static int emulated_initfn(CCIDCardState *base)
491 EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
492 QemuThread thread_id;
493 VCardEmulError ret;
494 EnumTable *ptable;
496 QSIMPLEQ_INIT(&card->event_list);
497 QSIMPLEQ_INIT(&card->guest_apdu_list);
498 qemu_mutex_init(&card->event_list_mutex);
499 qemu_mutex_init(&card->vreader_mutex);
500 qemu_mutex_init(&card->handle_apdu_mutex);
501 qemu_cond_init(&card->handle_apdu_cond);
502 card->reader = NULL;
503 card->quit_apdu_thread = 0;
504 if (init_pipe_signaling(card) < 0) {
505 return -1;
507 card->backend = parse_enumeration(card->backend_str, backend_enum_table, 0);
508 if (card->backend == 0) {
509 printf("unknown backend, must be one of:\n");
510 for (ptable = backend_enum_table; ptable->name != NULL; ++ptable) {
511 printf("%s\n", ptable->name);
513 return -1;
516 /* TODO: a passthru backened that works on local machine. third card type?*/
517 if (card->backend == BACKEND_CERTIFICATES) {
518 if (card->cert1 != NULL && card->cert2 != NULL && card->cert3 != NULL) {
519 ret = emulated_initialize_vcard_from_certificates(card);
520 } else {
521 printf("%s: you must provide all three certs for"
522 " certificates backend\n", EMULATED_DEV_NAME);
523 return -1;
525 } else {
526 if (card->backend != BACKEND_NSS_EMULATED) {
527 printf("%s: bad backend specified. The options are:\n%s (default),"
528 " %s.\n", EMULATED_DEV_NAME, BACKEND_NSS_EMULATED_NAME,
529 BACKEND_CERTIFICATES_NAME);
530 return -1;
532 if (card->cert1 != NULL || card->cert2 != NULL || card->cert3 != NULL) {
533 printf("%s: unexpected cert parameters to nss emulated backend\n",
534 EMULATED_DEV_NAME);
535 return -1;
537 /* default to mirroring the local hardware readers */
538 ret = wrap_vcard_emul_init(NULL);
540 if (ret != VCARD_EMUL_OK) {
541 printf("%s: failed to initialize vcard\n", EMULATED_DEV_NAME);
542 return -1;
544 qemu_thread_create(&thread_id, event_thread, card);
545 qemu_thread_create(&thread_id, handle_apdu_thread, card);
546 return 0;
549 static int emulated_exitfn(CCIDCardState *base)
551 EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
552 VEvent *vevent = vevent_new(VEVENT_LAST, NULL, NULL);
554 vevent_queue_vevent(vevent); /* stop vevent thread */
555 qemu_mutex_lock(&card->apdu_thread_quit_mutex);
556 card->quit_apdu_thread = 1; /* stop handle_apdu thread */
557 qemu_cond_signal(&card->handle_apdu_cond);
558 qemu_cond_wait(&card->apdu_thread_quit_cond,
559 &card->apdu_thread_quit_mutex);
560 /* handle_apdu thread stopped, can destroy all of it's mutexes */
561 qemu_cond_destroy(&card->handle_apdu_cond);
562 qemu_cond_destroy(&card->apdu_thread_quit_cond);
563 qemu_mutex_destroy(&card->apdu_thread_quit_mutex);
564 qemu_mutex_destroy(&card->handle_apdu_mutex);
565 qemu_mutex_destroy(&card->vreader_mutex);
566 qemu_mutex_destroy(&card->event_list_mutex);
567 return 0;
570 static CCIDCardInfo emulated_card_info = {
571 .qdev.name = EMULATED_DEV_NAME,
572 .qdev.desc = "emulated smartcard",
573 .qdev.size = sizeof(EmulatedState),
574 .initfn = emulated_initfn,
575 .exitfn = emulated_exitfn,
576 .get_atr = emulated_get_atr,
577 .apdu_from_guest = emulated_apdu_from_guest,
578 .qdev.unplug = qdev_simple_unplug_cb,
579 .qdev.props = (Property[]) {
580 DEFINE_PROP_STRING("backend", EmulatedState, backend_str),
581 DEFINE_PROP_STRING("cert1", EmulatedState, cert1),
582 DEFINE_PROP_STRING("cert2", EmulatedState, cert2),
583 DEFINE_PROP_STRING("cert3", EmulatedState, cert3),
584 DEFINE_PROP_STRING("db", EmulatedState, db),
585 DEFINE_PROP_UINT8("debug", EmulatedState, debug, 0),
586 DEFINE_PROP_END_OF_LIST(),
590 static void ccid_card_emulated_register_devices(void)
592 ccid_card_qdev_register(&emulated_card_info);
595 device_init(ccid_card_emulated_register_devices)