trap signals for "-serial mon:stdio"
[qemu.git] / libcacard / vreader.c
1 /*
2 * emulate the reader
3 *
4 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
5 * See the COPYING.LIB file in the top-level directory.
6 */
7
8 #ifdef G_LOG_DOMAIN
9 #undef G_LOG_DOMAIN
10 #endif
11 #define G_LOG_DOMAIN "libcacard"
12 #include <glib.h>
13
14 #include "qemu-common.h"
15 #include "qemu/thread.h"
16
17 #include "vcard.h"
18 #include "vcard_emul.h"
19 #include "card_7816.h"
20 #include "vreader.h"
21 #include "vevent.h"
22 #include "cac.h" /* just for debugging defines */
23
24 #define LIBCACARD_LOG_DOMAIN "libcacard"
25
26 struct VReaderStruct {
27 int reference_count;
28 VCard *card;
29 char *name;
30 vreader_id_t id;
31 QemuMutex lock;
32 VReaderEmul *reader_private;
33 VReaderEmulFree reader_private_free;
34 };
35
36 /*
37 * Debug helpers
38 */
39
40 static const char *
41 apdu_ins_to_string(int ins)
42 {
43 switch (ins) {
44 case VCARD7816_INS_MANAGE_CHANNEL:
45 return "manage channel";
46 case VCARD7816_INS_EXTERNAL_AUTHENTICATE:
47 return "external authenticate";
48 case VCARD7816_INS_GET_CHALLENGE:
49 return "get challenge";
50 case VCARD7816_INS_INTERNAL_AUTHENTICATE:
51 return "internal authenticate";
52 case VCARD7816_INS_ERASE_BINARY:
53 return "erase binary";
54 case VCARD7816_INS_READ_BINARY:
55 return "read binary";
56 case VCARD7816_INS_WRITE_BINARY:
57 return "write binary";
58 case VCARD7816_INS_UPDATE_BINARY:
59 return "update binary";
60 case VCARD7816_INS_READ_RECORD:
61 return "read record";
62 case VCARD7816_INS_WRITE_RECORD:
63 return "write record";
64 case VCARD7816_INS_UPDATE_RECORD:
65 return "update record";
66 case VCARD7816_INS_APPEND_RECORD:
67 return "append record";
68 case VCARD7816_INS_ENVELOPE:
69 return "envelope";
70 case VCARD7816_INS_PUT_DATA:
71 return "put data";
72 case VCARD7816_INS_GET_DATA:
73 return "get data";
74 case VCARD7816_INS_SELECT_FILE:
75 return "select file";
76 case VCARD7816_INS_VERIFY:
77 return "verify";
78 case VCARD7816_INS_GET_RESPONSE:
79 return "get response";
80 case CAC_GET_PROPERTIES:
81 return "get properties";
82 case CAC_GET_ACR:
83 return "get acr";
84 case CAC_READ_BUFFER:
85 return "read buffer";
86 case CAC_UPDATE_BUFFER:
87 return "update buffer";
88 case CAC_SIGN_DECRYPT:
89 return "sign decrypt";
90 case CAC_GET_CERTIFICATE:
91 return "get certificate";
92 }
93 return "unknown";
94 }
95
96 /* manage locking */
97 static inline void
98 vreader_lock(VReader *reader)
99 {
100 qemu_mutex_lock(&reader->lock);
101 }
102
103 static inline void
104 vreader_unlock(VReader *reader)
105 {
106 qemu_mutex_unlock(&reader->lock);
107 }
108
109 /*
110 * vreader constructor
111 */
112 VReader *
113 vreader_new(const char *name, VReaderEmul *private,
114 VReaderEmulFree private_free)
115 {
116 VReader *reader;
117
118 reader = (VReader *)g_malloc(sizeof(VReader));
119 qemu_mutex_init(&reader->lock);
120 reader->reference_count = 1;
121 reader->name = g_strdup(name);
122 reader->card = NULL;
123 reader->id = (vreader_id_t)-1;
124 reader->reader_private = private;
125 reader->reader_private_free = private_free;
126 return reader;
127 }
128
129 /* get a reference */
130 VReader*
131 vreader_reference(VReader *reader)
132 {
133 if (reader == NULL) {
134 return NULL;
135 }
136 vreader_lock(reader);
137 reader->reference_count++;
138 vreader_unlock(reader);
139 return reader;
140 }
141
142 /* free a reference */
143 void
144 vreader_free(VReader *reader)
145 {
146 if (reader == NULL) {
147 return;
148 }
149 vreader_lock(reader);
150 if (reader->reference_count-- > 1) {
151 vreader_unlock(reader);
152 return;
153 }
154 vreader_unlock(reader);
155 if (reader->card) {
156 vcard_free(reader->card);
157 }
158 if (reader->name) {
159 g_free(reader->name);
160 }
161 if (reader->reader_private_free) {
162 reader->reader_private_free(reader->reader_private);
163 }
164 g_free(reader);
165 }
166
167 static VCard *
168 vreader_get_card(VReader *reader)
169 {
170 VCard *card;
171
172 vreader_lock(reader);
173 card = vcard_reference(reader->card);
174 vreader_unlock(reader);
175 return card;
176 }
177
178 VReaderStatus
179 vreader_card_is_present(VReader *reader)
180 {
181 VCard *card = vreader_get_card(reader);
182
183 if (card == NULL) {
184 return VREADER_NO_CARD;
185 }
186 vcard_free(card);
187 return VREADER_OK;
188 }
189
190 vreader_id_t
191 vreader_get_id(VReader *reader)
192 {
193 if (reader == NULL) {
194 return (vreader_id_t)-1;
195 }
196 return reader->id;
197 }
198
199 VReaderStatus
200 vreader_set_id(VReader *reader, vreader_id_t id)
201 {
202 if (reader == NULL) {
203 return VREADER_NO_CARD;
204 }
205 reader->id = id;
206 return VREADER_OK;
207 }
208
209 const char *
210 vreader_get_name(VReader *reader)
211 {
212 if (reader == NULL) {
213 return NULL;
214 }
215 return reader->name;
216 }
217
218 VReaderEmul *
219 vreader_get_private(VReader *reader)
220 {
221 return reader->reader_private;
222 }
223
224 static VReaderStatus
225 vreader_reset(VReader *reader, VCardPower power, unsigned char *atr, int *len)
226 {
227 VCard *card = vreader_get_card(reader);
228
229 if (card == NULL) {
230 return VREADER_NO_CARD;
231 }
232 /*
233 * clean up our state
234 */
235 vcard_reset(card, power);
236 if (atr) {
237 vcard_get_atr(card, atr, len);
238 }
239 vcard_free(card); /* free our reference */
240 return VREADER_OK;
241 }
242
243 VReaderStatus
244 vreader_power_on(VReader *reader, unsigned char *atr, int *len)
245 {
246 return vreader_reset(reader, VCARD_POWER_ON, atr, len);
247 }
248
249 VReaderStatus
250 vreader_power_off(VReader *reader)
251 {
252 return vreader_reset(reader, VCARD_POWER_OFF, NULL, 0);
253 }
254
255
256 VReaderStatus
257 vreader_xfr_bytes(VReader *reader,
258 unsigned char *send_buf, int send_buf_len,
259 unsigned char *receive_buf, int *receive_buf_len)
260 {
261 VCardAPDU *apdu;
262 VCardResponse *response = NULL;
263 VCardStatus card_status;
264 unsigned short status;
265 VCard *card = vreader_get_card(reader);
266
267 if (card == NULL) {
268 return VREADER_NO_CARD;
269 }
270
271 apdu = vcard_apdu_new(send_buf, send_buf_len, &status);
272 if (apdu == NULL) {
273 response = vcard_make_response(status);
274 card_status = VCARD_DONE;
275 } else {
276 g_debug("%s: CLS=0x%x,INS=0x%x,P1=0x%x,P2=0x%x,Lc=%d,Le=%d %s\n",
277 __func__, apdu->a_cla, apdu->a_ins, apdu->a_p1, apdu->a_p2,
278 apdu->a_Lc, apdu->a_Le, apdu_ins_to_string(apdu->a_ins));
279 card_status = vcard_process_apdu(card, apdu, &response);
280 if (response) {
281 g_debug("%s: status=%d sw1=0x%x sw2=0x%x len=%d (total=%d)\n",
282 __func__, response->b_status, response->b_sw1,
283 response->b_sw2, response->b_len, response->b_total_len);
284 }
285 }
286 assert(card_status == VCARD_DONE);
287 if (card_status == VCARD_DONE) {
288 int size = MIN(*receive_buf_len, response->b_total_len);
289 memcpy(receive_buf, response->b_data, size);
290 *receive_buf_len = size;
291 }
292 vcard_response_delete(response);
293 vcard_apdu_delete(apdu);
294 vcard_free(card); /* free our reference */
295 return VREADER_OK;
296 }
297
298 struct VReaderListStruct {
299 VReaderListEntry *head;
300 VReaderListEntry *tail;
301 };
302
303 struct VReaderListEntryStruct {
304 VReaderListEntry *next;
305 VReaderListEntry *prev;
306 VReader *reader;
307 };
308
309
310 static VReaderListEntry *
311 vreader_list_entry_new(VReader *reader)
312 {
313 VReaderListEntry *new_reader_list_entry;
314
315 new_reader_list_entry = (VReaderListEntry *)
316 g_malloc(sizeof(VReaderListEntry));
317 new_reader_list_entry->next = NULL;
318 new_reader_list_entry->prev = NULL;
319 new_reader_list_entry->reader = vreader_reference(reader);
320 return new_reader_list_entry;
321 }
322
323 static void
324 vreader_list_entry_delete(VReaderListEntry *entry)
325 {
326 if (entry == NULL) {
327 return;
328 }
329 vreader_free(entry->reader);
330 g_free(entry);
331 }
332
333
334 static VReaderList *
335 vreader_list_new(void)
336 {
337 VReaderList *new_reader_list;
338
339 new_reader_list = (VReaderList *)g_malloc(sizeof(VReaderList));
340 new_reader_list->head = NULL;
341 new_reader_list->tail = NULL;
342 return new_reader_list;
343 }
344
345 void
346 vreader_list_delete(VReaderList *list)
347 {
348 VReaderListEntry *current_entry;
349 VReaderListEntry *next_entry = NULL;
350 for (current_entry = vreader_list_get_first(list); current_entry;
351 current_entry = next_entry) {
352 next_entry = vreader_list_get_next(current_entry);
353 vreader_list_entry_delete(current_entry);
354 }
355 list->head = NULL;
356 list->tail = NULL;
357 g_free(list);
358 }
359
360
361 VReaderListEntry *
362 vreader_list_get_first(VReaderList *list)
363 {
364 return list ? list->head : NULL;
365 }
366
367 VReaderListEntry *
368 vreader_list_get_next(VReaderListEntry *current)
369 {
370 return current ? current->next : NULL;
371 }
372
373 VReader *
374 vreader_list_get_reader(VReaderListEntry *entry)
375 {
376 return entry ? vreader_reference(entry->reader) : NULL;
377 }
378
379 static void
380 vreader_queue(VReaderList *list, VReaderListEntry *entry)
381 {
382 if (entry == NULL) {
383 return;
384 }
385 entry->next = NULL;
386 entry->prev = list->tail;
387 if (list->head) {
388 list->tail->next = entry;
389 } else {
390 list->head = entry;
391 }
392 list->tail = entry;
393 }
394
395 static void
396 vreader_dequeue(VReaderList *list, VReaderListEntry *entry)
397 {
398 if (entry == NULL) {
399 return;
400 }
401 if (entry->next == NULL) {
402 list->tail = entry->prev;
403 } else if (entry->prev == NULL) {
404 list->head = entry->next;
405 } else {
406 entry->prev->next = entry->next;
407 entry->next->prev = entry->prev;
408 }
409 if ((list->tail == NULL) || (list->head == NULL)) {
410 list->head = list->tail = NULL;
411 }
412 entry->next = entry->prev = NULL;
413 }
414
415 static VReaderList *vreader_list;
416 static QemuMutex vreader_list_mutex;
417
418 static void
419 vreader_list_init(void)
420 {
421 vreader_list = vreader_list_new();
422 qemu_mutex_init(&vreader_list_mutex);
423 }
424
425 static void
426 vreader_list_lock(void)
427 {
428 qemu_mutex_lock(&vreader_list_mutex);
429 }
430
431 static void
432 vreader_list_unlock(void)
433 {
434 qemu_mutex_unlock(&vreader_list_mutex);
435 }
436
437 static VReaderList *
438 vreader_copy_list(VReaderList *list)
439 {
440 VReaderList *new_list = NULL;
441 VReaderListEntry *current_entry = NULL;
442
443 new_list = vreader_list_new();
444 if (new_list == NULL) {
445 return NULL;
446 }
447 for (current_entry = vreader_list_get_first(list); current_entry;
448 current_entry = vreader_list_get_next(current_entry)) {
449 VReader *reader = vreader_list_get_reader(current_entry);
450 VReaderListEntry *new_entry = vreader_list_entry_new(reader);
451
452 vreader_free(reader);
453 vreader_queue(new_list, new_entry);
454 }
455 return new_list;
456 }
457
458 VReaderList *
459 vreader_get_reader_list(void)
460 {
461 VReaderList *new_reader_list;
462
463 vreader_list_lock();
464 new_reader_list = vreader_copy_list(vreader_list);
465 vreader_list_unlock();
466 return new_reader_list;
467 }
468
469 VReader *
470 vreader_get_reader_by_id(vreader_id_t id)
471 {
472 VReader *reader = NULL;
473 VReaderListEntry *current_entry = NULL;
474
475 if (id == (vreader_id_t) -1) {
476 return NULL;
477 }
478
479 vreader_list_lock();
480 for (current_entry = vreader_list_get_first(vreader_list); current_entry;
481 current_entry = vreader_list_get_next(current_entry)) {
482 VReader *creader = vreader_list_get_reader(current_entry);
483 if (creader->id == id) {
484 reader = creader;
485 break;
486 }
487 vreader_free(creader);
488 }
489 vreader_list_unlock();
490 return reader;
491 }
492
493 VReader *
494 vreader_get_reader_by_name(const char *name)
495 {
496 VReader *reader = NULL;
497 VReaderListEntry *current_entry = NULL;
498
499 vreader_list_lock();
500 for (current_entry = vreader_list_get_first(vreader_list); current_entry;
501 current_entry = vreader_list_get_next(current_entry)) {
502 VReader *creader = vreader_list_get_reader(current_entry);
503 if (strcmp(creader->name, name) == 0) {
504 reader = creader;
505 break;
506 }
507 vreader_free(creader);
508 }
509 vreader_list_unlock();
510 return reader;
511 }
512
513 /* called from card_emul to initialize the readers */
514 VReaderStatus
515 vreader_add_reader(VReader *reader)
516 {
517 VReaderListEntry *reader_entry;
518
519 reader_entry = vreader_list_entry_new(reader);
520 if (reader_entry == NULL) {
521 return VREADER_OUT_OF_MEMORY;
522 }
523 vreader_list_lock();
524 vreader_queue(vreader_list, reader_entry);
525 vreader_list_unlock();
526 vevent_queue_vevent(vevent_new(VEVENT_READER_INSERT, reader, NULL));
527 return VREADER_OK;
528 }
529
530
531 VReaderStatus
532 vreader_remove_reader(VReader *reader)
533 {
534 VReaderListEntry *current_entry;
535
536 vreader_list_lock();
537 for (current_entry = vreader_list_get_first(vreader_list); current_entry;
538 current_entry = vreader_list_get_next(current_entry)) {
539 if (current_entry->reader == reader) {
540 break;
541 }
542 }
543 vreader_dequeue(vreader_list, current_entry);
544 vreader_list_unlock();
545 vreader_list_entry_delete(current_entry);
546 vevent_queue_vevent(vevent_new(VEVENT_READER_REMOVE, reader, NULL));
547 return VREADER_OK;
548 }
549
550 /*
551 * Generate VEVENT_CARD_INSERT or VEVENT_CARD_REMOVE based on vreader
552 * state. Separated from vreader_insert_card to allow replaying events
553 * for a given state.
554 */
555 void
556 vreader_queue_card_event(VReader *reader)
557 {
558 vevent_queue_vevent(vevent_new(
559 reader->card ? VEVENT_CARD_INSERT : VEVENT_CARD_REMOVE, reader,
560 reader->card));
561 }
562
563 /*
564 * insert/remove a new card. for removal, card == NULL
565 */
566 VReaderStatus
567 vreader_insert_card(VReader *reader, VCard *card)
568 {
569 vreader_lock(reader);
570 if (reader->card) {
571 /* decrement reference count */
572 vcard_free(reader->card);
573 reader->card = NULL;
574 }
575 reader->card = vcard_reference(card);
576 vreader_unlock(reader);
577 vreader_queue_card_event(reader);
578 return VREADER_OK;
579 }
580
581 /*
582 * initialize all the static reader structures
583 */
584 void
585 vreader_init(void)
586 {
587 vreader_list_init();
588 }
589