2 * Tester for VSCARD protocol, client side.
4 * Can be used with ccid-card-passthru.
6 * Copyright (c) 2011 Red Hat.
7 * Written by Alon Levy.
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
15 #define closesocket(x) close(x)
18 #include "qemu-common.h"
20 #include "vscard_common.h"
23 #include "vcard_emul.h"
34 for (i
= 0; i
< nSize
; i
++) {
35 printf("%02X ", arrBytes
[i
]);
42 printf("vscclient [-c <certname> .. -e <emul_args> -d <level>%s] "
46 printf(" -p use passthrough mode\n");
53 static GIOChannel
*channel_socket
;
54 static GByteArray
*socket_to_send
;
55 static CompatGMutex socket_to_send_lock
;
56 static guint socket_tag
;
59 update_socket_watch(void);
62 do_socket_send(GIOChannel
*source
,
63 GIOCondition condition
,
69 g_return_val_if_fail(socket_to_send
->len
!= 0, FALSE
);
70 g_return_val_if_fail(condition
& G_IO_OUT
, FALSE
);
72 g_io_channel_write_chars(channel_socket
,
73 (gchar
*)socket_to_send
->data
, socket_to_send
->len
, &bw
, &err
);
75 g_error("Error while sending socket %s", err
->message
);
78 g_byte_array_remove_range(socket_to_send
, 0, bw
);
80 if (socket_to_send
->len
== 0) {
81 update_socket_watch();
88 socket_prepare_sending(gpointer user_data
)
90 update_socket_watch();
102 VSCMsgHeader mhHeader
;
104 g_mutex_lock(&socket_to_send_lock
);
107 printf("sending type=%d id=%u, len =%u (0x%x)\n",
108 type
, reader_id
, length
, length
);
111 mhHeader
.type
= htonl(type
);
112 mhHeader
.reader_id
= 0;
113 mhHeader
.length
= htonl(length
);
114 g_byte_array_append(socket_to_send
, (guint8
*)&mhHeader
, sizeof(mhHeader
));
115 g_byte_array_append(socket_to_send
, (guint8
*)msg
, length
);
116 g_idle_add(socket_prepare_sending
, NULL
);
118 g_mutex_unlock(&socket_to_send_lock
);
123 static VReader
*pending_reader
;
124 static CompatGMutex pending_reader_lock
;
125 static CompatGCond pending_reader_condition
;
127 #define MAX_ATR_LEN 40
129 event_thread(gpointer arg
)
131 unsigned char atr
[MAX_ATR_LEN
];
134 unsigned int reader_id
;
138 const char *reader_name
;
140 event
= vevent_wait_next_vevent();
144 reader_id
= vreader_get_id(event
->reader
);
145 if (reader_id
== VSCARD_UNDEFINED_READER_ID
&&
146 event
->type
!= VEVENT_READER_INSERT
) {
147 /* ignore events from readers qemu has rejected */
148 /* if qemu is still deciding on this reader, wait to see if need to
149 * forward this event */
150 g_mutex_lock(&pending_reader_lock
);
151 if (!pending_reader
|| (pending_reader
!= event
->reader
)) {
152 /* wasn't for a pending reader, this reader has already been
153 * rejected by qemu */
154 g_mutex_unlock(&pending_reader_lock
);
155 vevent_delete(event
);
158 /* this reader hasn't been told its status from qemu yet, wait for
160 while (pending_reader
!= NULL
) {
161 g_cond_wait(&pending_reader_condition
, &pending_reader_lock
);
163 g_mutex_unlock(&pending_reader_lock
);
164 /* now recheck the id */
165 reader_id
= vreader_get_id(event
->reader
);
166 if (reader_id
== VSCARD_UNDEFINED_READER_ID
) {
167 /* this reader was rejected */
168 vevent_delete(event
);
171 /* reader was accepted, now forward the event */
173 switch (event
->type
) {
174 case VEVENT_READER_INSERT
:
175 /* tell qemu to insert a new CCID reader */
176 /* wait until qemu has responded to our first reader insert
177 * before we send a second. That way we won't confuse the responses
179 g_mutex_lock(&pending_reader_lock
);
180 while (pending_reader
!= NULL
) {
181 g_cond_wait(&pending_reader_condition
, &pending_reader_lock
);
183 pending_reader
= vreader_reference(event
->reader
);
184 g_mutex_unlock(&pending_reader_lock
);
185 reader_name
= vreader_get_name(event
->reader
);
187 printf(" READER INSERT: %s\n", reader_name
);
189 send_msg(VSC_ReaderAdd
,
190 reader_id
, /* currerntly VSCARD_UNDEFINED_READER_ID */
191 NULL
, 0 /* TODO reader_name, strlen(reader_name) */);
193 case VEVENT_READER_REMOVE
:
194 /* future, tell qemu that an old CCID reader has been removed */
196 printf(" READER REMOVE: %u\n", reader_id
);
198 send_msg(VSC_ReaderRemove
, reader_id
, NULL
, 0);
200 case VEVENT_CARD_INSERT
:
201 /* get the ATR (intended as a response to a power on from the
203 atr_len
= MAX_ATR_LEN
;
204 vreader_power_on(event
->reader
, atr
, &atr_len
);
205 /* ATR call functions as a Card Insert event */
207 printf(" CARD INSERT %u: ", reader_id
);
208 print_byte_array(atr
, atr_len
);
210 send_msg(VSC_ATR
, reader_id
, atr
, atr_len
);
212 case VEVENT_CARD_REMOVE
:
215 printf(" CARD REMOVE %u:\n", reader_id
);
217 send_msg(VSC_CardRemove
, reader_id
, NULL
, 0);
222 vevent_delete(event
);
229 get_id_from_string(char *string
, unsigned int default_id
)
231 unsigned int id
= atoi(string
);
233 /* don't accidentally swith to zero because no numbers have been supplied */
234 if ((id
== 0) && *string
!= '0') {
241 on_host_init(VSCMsgHeader
*mhHeader
, VSCMsgInit
*incoming
)
243 uint32_t *capabilities
= (incoming
->capabilities
);
244 int num_capabilities
=
245 1 + ((mhHeader
->length
- sizeof(VSCMsgInit
)) / sizeof(uint32_t));
248 incoming
->version
= ntohl(incoming
->version
);
249 if (incoming
->version
!= VSCARD_VERSION
) {
251 printf("warning: host has version %d, we have %d\n",
252 verbose
, VSCARD_VERSION
);
255 if (incoming
->magic
!= VSCARD_MAGIC
) {
256 printf("unexpected magic: got %d, expected %d\n",
257 incoming
->magic
, VSCARD_MAGIC
);
260 for (i
= 0 ; i
< num_capabilities
; ++i
) {
261 capabilities
[i
] = ntohl(capabilities
[i
]);
263 /* Future: check capabilities */
264 /* remove whatever reader might be left in qemu,
265 * in case of an unclean previous exit. */
266 send_msg(VSC_ReaderRemove
, VSCARD_MINIMAL_READER_ID
, NULL
, 0);
267 /* launch the event_thread. This will trigger reader adds for all the
268 * existing readers */
269 g_thread_new("vsc/event", event_thread
, NULL
);
279 #define APDUBufSize 270
282 do_socket_read(GIOChannel
*source
,
283 GIOCondition condition
,
289 uint8_t pbRecvBuffer
[APDUBufSize
];
290 static uint8_t pbSendBuffer
[APDUBufSize
];
291 VReaderStatus reader_status
;
292 VReader
*reader
= NULL
;
293 static VSCMsgHeader mhHeader
;
294 VSCMsgError
*error_msg
;
298 static gsize br
, to_read
;
299 static int state
= STATE_HEADER
;
301 if (state
== STATE_HEADER
&& to_read
== 0) {
302 buf
= (gchar
*)&mhHeader
;
303 to_read
= sizeof(mhHeader
);
307 g_io_channel_read_chars(source
, (gchar
*)buf
, to_read
, &br
, &err
);
309 g_error("error while reading: %s", err
->message
);
318 if (state
== STATE_HEADER
) {
319 mhHeader
.type
= ntohl(mhHeader
.type
);
320 mhHeader
.reader_id
= ntohl(mhHeader
.reader_id
);
321 mhHeader
.length
= ntohl(mhHeader
.length
);
323 printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
324 mhHeader
.type
, mhHeader
.reader_id
, mhHeader
.length
,
327 switch (mhHeader
.type
) {
332 buf
= (gchar
*)pbSendBuffer
;
333 to_read
= mhHeader
.length
;
334 state
= STATE_MESSAGE
;
337 fprintf(stderr
, "Unexpected message of type 0x%X\n", mhHeader
.type
);
342 if (state
== STATE_MESSAGE
) {
343 switch (mhHeader
.type
) {
346 printf(" recv APDU: ");
347 print_byte_array(pbSendBuffer
, mhHeader
.length
);
349 /* Transmit received APDU */
350 dwSendLength
= mhHeader
.length
;
351 dwRecvLength
= sizeof(pbRecvBuffer
);
352 reader
= vreader_get_reader_by_id(mhHeader
.reader_id
);
353 reader_status
= vreader_xfr_bytes(reader
,
354 pbSendBuffer
, dwSendLength
,
355 pbRecvBuffer
, &dwRecvLength
);
356 if (reader_status
== VREADER_OK
) {
357 mhHeader
.length
= dwRecvLength
;
359 printf(" send response: ");
360 print_byte_array(pbRecvBuffer
, mhHeader
.length
);
362 send_msg(VSC_APDU
, mhHeader
.reader_id
,
363 pbRecvBuffer
, dwRecvLength
);
365 rv
= reader_status
; /* warning: not meaningful */
366 send_msg(VSC_Error
, mhHeader
.reader_id
, &rv
, sizeof(uint32_t));
368 vreader_free(reader
);
369 reader
= NULL
; /* we've freed it, don't use it by accident
373 /* TODO: actually flush */
374 send_msg(VSC_FlushComplete
, mhHeader
.reader_id
, NULL
, 0);
377 error_msg
= (VSCMsgError
*) pbSendBuffer
;
378 if (error_msg
->code
== VSC_SUCCESS
) {
379 g_mutex_lock(&pending_reader_lock
);
380 if (pending_reader
) {
381 vreader_set_id(pending_reader
, mhHeader
.reader_id
);
382 vreader_free(pending_reader
);
383 pending_reader
= NULL
;
384 g_cond_signal(&pending_reader_condition
);
386 g_mutex_unlock(&pending_reader_lock
);
389 printf("warning: qemu refused to add reader\n");
390 if (error_msg
->code
== VSC_CANNOT_ADD_MORE_READERS
) {
391 /* clear pending reader, qemu can't handle any more */
392 g_mutex_lock(&pending_reader_lock
);
393 if (pending_reader
) {
394 pending_reader
= NULL
;
395 /* make sure the event loop doesn't hang */
396 g_cond_signal(&pending_reader_condition
);
398 g_mutex_unlock(&pending_reader_lock
);
402 if (on_host_init(&mhHeader
, (VSCMsgInit
*)pbSendBuffer
) < 0) {
407 g_assert_not_reached();
411 state
= STATE_HEADER
;
419 do_socket(GIOChannel
*source
,
420 GIOCondition condition
,
423 /* not sure if two watches work well with a single win32 sources */
424 if (condition
& G_IO_OUT
) {
425 if (!do_socket_send(source
, condition
, data
)) {
430 if (condition
& G_IO_IN
) {
431 if (!do_socket_read(source
, condition
, data
)) {
440 update_socket_watch(void)
442 gboolean out
= socket_to_send
->len
> 0;
444 if (socket_tag
!= 0) {
445 g_source_remove(socket_tag
);
448 socket_tag
= g_io_add_watch(channel_socket
,
449 G_IO_IN
| (out
? G_IO_OUT
: 0), do_socket
, NULL
);
453 do_command(GIOChannel
*source
,
454 GIOCondition condition
,
458 VCardEmulError error
;
459 static unsigned int default_reader_id
;
460 unsigned int reader_id
;
461 VReader
*reader
= NULL
;
464 g_assert(condition
& G_IO_IN
);
466 reader_id
= default_reader_id
;
467 g_io_channel_read_line(source
, &string
, NULL
, NULL
, &err
);
469 g_error("Error while reading command: %s", err
->message
);
472 if (string
!= NULL
) {
473 if (strncmp(string
, "exit", 4) == 0) {
474 /* remove all the readers */
475 VReaderList
*list
= vreader_get_reader_list();
476 VReaderListEntry
*reader_entry
;
477 printf("Active Readers:\n");
478 for (reader_entry
= vreader_list_get_first(list
); reader_entry
;
479 reader_entry
= vreader_list_get_next(reader_entry
)) {
480 VReader
*reader
= vreader_list_get_reader(reader_entry
);
481 vreader_id_t reader_id
;
482 reader_id
= vreader_get_id(reader
);
483 if (reader_id
== -1) {
486 /* be nice and signal card removal first (qemu probably should
488 if (vreader_card_is_present(reader
) == VREADER_OK
) {
489 send_msg(VSC_CardRemove
, reader_id
, NULL
, 0);
491 send_msg(VSC_ReaderRemove
, reader_id
, NULL
, 0);
494 } else if (strncmp(string
, "insert", 6) == 0) {
495 if (string
[6] == ' ') {
496 reader_id
= get_id_from_string(&string
[7], reader_id
);
498 reader
= vreader_get_reader_by_id(reader_id
);
499 if (reader
!= NULL
) {
500 error
= vcard_emul_force_card_insert(reader
);
501 printf("insert %s, returned %d\n",
502 vreader_get_name(reader
), error
);
504 printf("no reader by id %u found\n", reader_id
);
506 } else if (strncmp(string
, "remove", 6) == 0) {
507 if (string
[6] == ' ') {
508 reader_id
= get_id_from_string(&string
[7], reader_id
);
510 reader
= vreader_get_reader_by_id(reader_id
);
511 if (reader
!= NULL
) {
512 error
= vcard_emul_force_card_remove(reader
);
513 printf("remove %s, returned %d\n",
514 vreader_get_name(reader
), error
);
516 printf("no reader by id %u found\n", reader_id
);
518 } else if (strncmp(string
, "select", 6) == 0) {
519 if (string
[6] == ' ') {
520 reader_id
= get_id_from_string(&string
[7],
521 VSCARD_UNDEFINED_READER_ID
);
523 if (reader_id
!= VSCARD_UNDEFINED_READER_ID
) {
524 reader
= vreader_get_reader_by_id(reader_id
);
527 printf("Selecting reader %u, %s\n", reader_id
,
528 vreader_get_name(reader
));
529 default_reader_id
= reader_id
;
531 printf("Reader with id %u not found\n", reader_id
);
533 } else if (strncmp(string
, "debug", 5) == 0) {
534 if (string
[5] == ' ') {
535 verbose
= get_id_from_string(&string
[6], 0);
537 printf("debug level = %d\n", verbose
);
538 } else if (strncmp(string
, "list", 4) == 0) {
539 VReaderList
*list
= vreader_get_reader_list();
540 VReaderListEntry
*reader_entry
;
541 printf("Active Readers:\n");
542 for (reader_entry
= vreader_list_get_first(list
); reader_entry
;
543 reader_entry
= vreader_list_get_next(reader_entry
)) {
544 VReader
*reader
= vreader_list_get_reader(reader_entry
);
545 vreader_id_t reader_id
;
546 reader_id
= vreader_get_id(reader
);
547 if (reader_id
== -1) {
550 printf("%3u %s %s\n", reader_id
,
551 vreader_card_is_present(reader
) == VREADER_OK
?
552 "CARD_PRESENT" : " ",
553 vreader_get_name(reader
));
555 printf("Inactive Readers:\n");
556 for (reader_entry
= vreader_list_get_first(list
); reader_entry
;
557 reader_entry
= vreader_list_get_next(reader_entry
)) {
558 VReader
*reader
= vreader_list_get_reader(reader_entry
);
559 vreader_id_t reader_id
;
560 reader_id
= vreader_get_id(reader
);
561 if (reader_id
!= -1) {
565 printf("INA %s %s\n",
566 vreader_card_is_present(reader
) == VREADER_OK
?
567 "CARD_PRESENT" : " ",
568 vreader_get_name(reader
));
570 vreader_list_delete(list
);
571 } else if (*string
!= 0) {
572 printf("valid commands:\n");
573 printf("insert [reader_id]\n");
574 printf("remove [reader_id]\n");
575 printf("select reader_id\n");
577 printf("debug [level]\n");
581 vreader_free(reader
);
589 /* just for ease of parsing command line arguments. */
590 #define MAX_CERTS 100
597 struct addrinfo hints
;
598 struct addrinfo
*server
;
601 sock
= socket(AF_INET
, SOCK_STREAM
, 0);
604 fprintf(stderr
, "Error opening socket!\n");
608 memset(&hints
, 0, sizeof(struct addrinfo
));
609 hints
.ai_family
= AF_UNSPEC
;
610 hints
.ai_socktype
= SOCK_STREAM
;
612 hints
.ai_protocol
= 0; /* Any protocol */
614 ret
= getaddrinfo(host
, port
, &hints
, &server
);
618 fprintf(stderr
, "getaddrinfo failed\n");
622 if (connect(sock
, server
->ai_addr
, server
->ai_addrlen
) < 0) {
624 fprintf(stderr
, "Could not connect\n");
628 printf("Connected (sizeof Header=%zd)!\n", sizeof(VSCMsgHeader
));
643 GIOChannel
*channel_stdin
;
647 VCardEmulOptions
*command_line_options
= NULL
;
649 char *cert_names
[MAX_CERTS
];
650 char *emul_args
= NULL
;
657 if (WSAStartup(MAKEWORD(2, 2), &Data
) != 0) {
658 c
= WSAGetLastError();
659 fprintf(stderr
, "WSAStartup: %d\n", c
);
663 #if !GLIB_CHECK_VERSION(2, 31, 0)
664 if (!g_thread_supported()) {
669 while ((c
= getopt(argc
, argv
, "c:e:pd:")) != -1) {
672 if (cert_count
>= MAX_CERTS
) {
673 printf("too many certificates (max = %d)\n", MAX_CERTS
);
676 cert_names
[cert_count
++] = optarg
;
686 verbose
= get_id_from_string(optarg
, 1);
691 if (argc
- optind
!= 2) {
696 if (cert_count
> 0) {
699 /* if we've given some -c options, we clearly we want do so some
700 * software emulation. add that emulation now. this is NSS Emulator
702 if (emul_args
== NULL
) {
703 emul_args
= (char *)"db=\"/etc/pki/nssdb\"";
705 #define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
706 /* 2 == close paren & null */
707 len
= strlen(emul_args
) + strlen(SOFT_STRING
) + 2;
708 for (i
= 0; i
< cert_count
; i
++) {
709 len
+= strlen(cert_names
[i
])+1; /* 1 == comma */
711 new_args
= g_malloc(len
);
712 strcpy(new_args
, emul_args
);
713 strcat(new_args
, SOFT_STRING
);
714 for (i
= 0; i
< cert_count
; i
++) {
715 strcat(new_args
, cert_names
[i
]);
716 strcat(new_args
, ",");
718 strcat(new_args
, ")");
719 emul_args
= new_args
;
722 command_line_options
= vcard_emul_options(emul_args
);
725 qemu_host
= g_strdup(argv
[argc
- 2]);
726 qemu_port
= g_strdup(argv
[argc
- 1]);
727 sock
= connect_to_qemu(qemu_host
, qemu_port
);
729 fprintf(stderr
, "error opening socket, exiting.\n");
733 socket_to_send
= g_byte_array_new();
734 vcard_emul_init(command_line_options
);
735 loop
= g_main_loop_new(NULL
, TRUE
);
741 channel_stdin
= g_io_channel_win32_new_fd(STDIN_FILENO
);
743 channel_stdin
= g_io_channel_unix_new(STDIN_FILENO
);
745 g_io_add_watch(channel_stdin
, G_IO_IN
, do_command
, NULL
);
747 channel_socket
= g_io_channel_win32_new_socket(sock
);
749 channel_socket
= g_io_channel_unix_new(sock
);
751 g_io_channel_set_encoding(channel_socket
, NULL
, NULL
);
752 /* we buffer ourself for thread safety reasons */
753 g_io_channel_set_buffered(channel_socket
, FALSE
);
755 /* Send init message, Host responds (and then we send reader attachments) */
757 .version
= htonl(VSCARD_VERSION
),
758 .magic
= VSCARD_MAGIC
,
761 send_msg(VSC_Init
, 0, &init
, sizeof(init
));
763 g_main_loop_run(loop
);
764 g_main_loop_unref(loop
);
766 g_io_channel_unref(channel_stdin
);
767 g_io_channel_unref(channel_socket
);
768 g_byte_array_free(socket_to_send
, TRUE
);