trap signals for "-serial mon:stdio"
[qemu.git] / libcacard / vscclient.c
1 /*
2 * Tester for VSCARD protocol, client side.
3 *
4 * Can be used with ccid-card-passthru.
5 *
6 * Copyright (c) 2011 Red Hat.
7 * Written by Alon Levy.
8 *
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.
11 */
12
13 #ifndef _WIN32
14 #include <netdb.h>
15 #endif
16 #include <glib.h>
17
18 #include "qemu-common.h"
19 #include "qemu/thread.h"
20 #include "qemu/sockets.h"
21
22 #include "vscard_common.h"
23
24 #include "vreader.h"
25 #include "vcard_emul.h"
26 #include "vevent.h"
27
28 static int verbose;
29
30 static void
31 print_byte_array(
32 uint8_t *arrBytes,
33 unsigned int nSize
34 ) {
35 int i;
36 for (i = 0; i < nSize; i++) {
37 printf("%02X ", arrBytes[i]);
38 }
39 printf("\n");
40 }
41
42 static void
43 print_usage(void) {
44 printf("vscclient [-c <certname> .. -e <emul_args> -d <level>%s] "
45 "<host> <port>\n",
46 #ifdef USE_PASSTHRU
47 " -p");
48 printf(" -p use passthrough mode\n");
49 #else
50 "");
51 #endif
52 vcard_emul_usage();
53 }
54
55 static GIOChannel *channel_socket;
56 static GByteArray *socket_to_send;
57 static QemuMutex socket_to_send_lock;
58 static guint socket_tag;
59
60 static void
61 update_socket_watch(gboolean out);
62
63 static gboolean
64 do_socket_send(GIOChannel *source,
65 GIOCondition condition,
66 gpointer data)
67 {
68 gsize bw;
69 GError *err = NULL;
70
71 g_return_val_if_fail(socket_to_send->len != 0, FALSE);
72 g_return_val_if_fail(condition & G_IO_OUT, FALSE);
73
74 g_io_channel_write_chars(channel_socket,
75 (gchar *)socket_to_send->data, socket_to_send->len, &bw, &err);
76 if (err != NULL) {
77 g_error("Error while sending socket %s", err->message);
78 return FALSE;
79 }
80 g_byte_array_remove_range(socket_to_send, 0, bw);
81
82 if (socket_to_send->len == 0) {
83 update_socket_watch(FALSE);
84 return FALSE;
85 }
86 return TRUE;
87 }
88
89 static gboolean
90 socket_prepare_sending(gpointer user_data)
91 {
92 update_socket_watch(TRUE);
93
94 return FALSE;
95 }
96
97 static int
98 send_msg(
99 VSCMsgType type,
100 uint32_t reader_id,
101 const void *msg,
102 unsigned int length
103 ) {
104 VSCMsgHeader mhHeader;
105
106 qemu_mutex_lock(&socket_to_send_lock);
107
108 if (verbose > 10) {
109 printf("sending type=%d id=%u, len =%u (0x%x)\n",
110 type, reader_id, length, length);
111 }
112
113 mhHeader.type = htonl(type);
114 mhHeader.reader_id = 0;
115 mhHeader.length = htonl(length);
116 g_byte_array_append(socket_to_send, (guint8 *)&mhHeader, sizeof(mhHeader));
117 g_byte_array_append(socket_to_send, (guint8 *)msg, length);
118 g_idle_add(socket_prepare_sending, NULL);
119
120 qemu_mutex_unlock(&socket_to_send_lock);
121
122 return 0;
123 }
124
125 static VReader *pending_reader;
126 static QemuMutex pending_reader_lock;
127 static QemuCond pending_reader_condition;
128
129 #define MAX_ATR_LEN 40
130 static void *
131 event_thread(void *arg)
132 {
133 unsigned char atr[MAX_ATR_LEN];
134 int atr_len = MAX_ATR_LEN;
135 VEvent *event = NULL;
136 unsigned int reader_id;
137
138
139 while (1) {
140 const char *reader_name;
141
142 event = vevent_wait_next_vevent();
143 if (event == NULL) {
144 break;
145 }
146 reader_id = vreader_get_id(event->reader);
147 if (reader_id == VSCARD_UNDEFINED_READER_ID &&
148 event->type != VEVENT_READER_INSERT) {
149 /* ignore events from readers qemu has rejected */
150 /* if qemu is still deciding on this reader, wait to see if need to
151 * forward this event */
152 qemu_mutex_lock(&pending_reader_lock);
153 if (!pending_reader || (pending_reader != event->reader)) {
154 /* wasn't for a pending reader, this reader has already been
155 * rejected by qemu */
156 qemu_mutex_unlock(&pending_reader_lock);
157 vevent_delete(event);
158 continue;
159 }
160 /* this reader hasn't been told its status from qemu yet, wait for
161 * that status */
162 while (pending_reader != NULL) {
163 qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
164 }
165 qemu_mutex_unlock(&pending_reader_lock);
166 /* now recheck the id */
167 reader_id = vreader_get_id(event->reader);
168 if (reader_id == VSCARD_UNDEFINED_READER_ID) {
169 /* this reader was rejected */
170 vevent_delete(event);
171 continue;
172 }
173 /* reader was accepted, now forward the event */
174 }
175 switch (event->type) {
176 case VEVENT_READER_INSERT:
177 /* tell qemu to insert a new CCID reader */
178 /* wait until qemu has responded to our first reader insert
179 * before we send a second. That way we won't confuse the responses
180 * */
181 qemu_mutex_lock(&pending_reader_lock);
182 while (pending_reader != NULL) {
183 qemu_cond_wait(&pending_reader_condition, &pending_reader_lock);
184 }
185 pending_reader = vreader_reference(event->reader);
186 qemu_mutex_unlock(&pending_reader_lock);
187 reader_name = vreader_get_name(event->reader);
188 if (verbose > 10) {
189 printf(" READER INSERT: %s\n", reader_name);
190 }
191 send_msg(VSC_ReaderAdd,
192 reader_id, /* currerntly VSCARD_UNDEFINED_READER_ID */
193 NULL, 0 /* TODO reader_name, strlen(reader_name) */);
194 break;
195 case VEVENT_READER_REMOVE:
196 /* future, tell qemu that an old CCID reader has been removed */
197 if (verbose > 10) {
198 printf(" READER REMOVE: %u\n", reader_id);
199 }
200 send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
201 break;
202 case VEVENT_CARD_INSERT:
203 /* get the ATR (intended as a response to a power on from the
204 * reader */
205 atr_len = MAX_ATR_LEN;
206 vreader_power_on(event->reader, atr, &atr_len);
207 /* ATR call functions as a Card Insert event */
208 if (verbose > 10) {
209 printf(" CARD INSERT %u: ", reader_id);
210 print_byte_array(atr, atr_len);
211 }
212 send_msg(VSC_ATR, reader_id, atr, atr_len);
213 break;
214 case VEVENT_CARD_REMOVE:
215 /* Card removed */
216 if (verbose > 10) {
217 printf(" CARD REMOVE %u:\n", reader_id);
218 }
219 send_msg(VSC_CardRemove, reader_id, NULL, 0);
220 break;
221 default:
222 break;
223 }
224 vevent_delete(event);
225 }
226 return NULL;
227 }
228
229
230 static unsigned int
231 get_id_from_string(char *string, unsigned int default_id)
232 {
233 unsigned int id = atoi(string);
234
235 /* don't accidentally swith to zero because no numbers have been supplied */
236 if ((id == 0) && *string != '0') {
237 return default_id;
238 }
239 return id;
240 }
241
242 static int
243 on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming)
244 {
245 uint32_t *capabilities = (incoming->capabilities);
246 int num_capabilities =
247 1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t));
248 int i;
249 QemuThread thread_id;
250
251 incoming->version = ntohl(incoming->version);
252 if (incoming->version != VSCARD_VERSION) {
253 if (verbose > 0) {
254 printf("warning: host has version %d, we have %d\n",
255 verbose, VSCARD_VERSION);
256 }
257 }
258 if (incoming->magic != VSCARD_MAGIC) {
259 printf("unexpected magic: got %d, expected %d\n",
260 incoming->magic, VSCARD_MAGIC);
261 return -1;
262 }
263 for (i = 0 ; i < num_capabilities; ++i) {
264 capabilities[i] = ntohl(capabilities[i]);
265 }
266 /* Future: check capabilities */
267 /* remove whatever reader might be left in qemu,
268 * in case of an unclean previous exit. */
269 send_msg(VSC_ReaderRemove, VSCARD_MINIMAL_READER_ID, NULL, 0);
270 /* launch the event_thread. This will trigger reader adds for all the
271 * existing readers */
272 qemu_thread_create(&thread_id, event_thread, NULL, 0);
273 return 0;
274 }
275
276
277 enum {
278 STATE_HEADER,
279 STATE_MESSAGE,
280 };
281
282 #define APDUBufSize 270
283
284 static gboolean
285 do_socket_read(GIOChannel *source,
286 GIOCondition condition,
287 gpointer data)
288 {
289 int rv;
290 int dwSendLength;
291 int dwRecvLength;
292 uint8_t pbRecvBuffer[APDUBufSize];
293 static uint8_t pbSendBuffer[APDUBufSize];
294 VReaderStatus reader_status;
295 VReader *reader = NULL;
296 static VSCMsgHeader mhHeader;
297 VSCMsgError *error_msg;
298 GError *err = NULL;
299
300 static gchar *buf;
301 static gsize br, to_read;
302 static int state = STATE_HEADER;
303
304 if (state == STATE_HEADER && to_read == 0) {
305 buf = (gchar *)&mhHeader;
306 to_read = sizeof(mhHeader);
307 }
308
309 if (to_read > 0) {
310 g_io_channel_read_chars(source, (gchar *)buf, to_read, &br, &err);
311 if (err != NULL) {
312 g_error("error while reading: %s", err->message);
313 }
314 buf += br;
315 to_read -= br;
316 if (to_read != 0) {
317 return TRUE;
318 }
319 }
320
321 if (state == STATE_HEADER) {
322 mhHeader.type = ntohl(mhHeader.type);
323 mhHeader.reader_id = ntohl(mhHeader.reader_id);
324 mhHeader.length = ntohl(mhHeader.length);
325 if (verbose) {
326 printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
327 mhHeader.type, mhHeader.reader_id, mhHeader.length,
328 mhHeader.length);
329 }
330 switch (mhHeader.type) {
331 case VSC_APDU:
332 case VSC_Flush:
333 case VSC_Error:
334 case VSC_Init:
335 buf = (gchar *)pbSendBuffer;
336 to_read = mhHeader.length;
337 state = STATE_MESSAGE;
338 return TRUE;
339 default:
340 fprintf(stderr, "Unexpected message of type 0x%X\n", mhHeader.type);
341 return FALSE;
342 }
343 }
344
345 if (state == STATE_MESSAGE) {
346 switch (mhHeader.type) {
347 case VSC_APDU:
348 if (verbose) {
349 printf(" recv APDU: ");
350 print_byte_array(pbSendBuffer, mhHeader.length);
351 }
352 /* Transmit received APDU */
353 dwSendLength = mhHeader.length;
354 dwRecvLength = sizeof(pbRecvBuffer);
355 reader = vreader_get_reader_by_id(mhHeader.reader_id);
356 reader_status = vreader_xfr_bytes(reader,
357 pbSendBuffer, dwSendLength,
358 pbRecvBuffer, &dwRecvLength);
359 if (reader_status == VREADER_OK) {
360 mhHeader.length = dwRecvLength;
361 if (verbose) {
362 printf(" send response: ");
363 print_byte_array(pbRecvBuffer, mhHeader.length);
364 }
365 send_msg(VSC_APDU, mhHeader.reader_id,
366 pbRecvBuffer, dwRecvLength);
367 } else {
368 rv = reader_status; /* warning: not meaningful */
369 send_msg(VSC_Error, mhHeader.reader_id, &rv, sizeof(uint32_t));
370 }
371 vreader_free(reader);
372 reader = NULL; /* we've freed it, don't use it by accident
373 again */
374 break;
375 case VSC_Flush:
376 /* TODO: actually flush */
377 send_msg(VSC_FlushComplete, mhHeader.reader_id, NULL, 0);
378 break;
379 case VSC_Error:
380 error_msg = (VSCMsgError *) pbSendBuffer;
381 if (error_msg->code == VSC_SUCCESS) {
382 qemu_mutex_lock(&pending_reader_lock);
383 if (pending_reader) {
384 vreader_set_id(pending_reader, mhHeader.reader_id);
385 vreader_free(pending_reader);
386 pending_reader = NULL;
387 qemu_cond_signal(&pending_reader_condition);
388 }
389 qemu_mutex_unlock(&pending_reader_lock);
390 break;
391 }
392 printf("warning: qemu refused to add reader\n");
393 if (error_msg->code == VSC_CANNOT_ADD_MORE_READERS) {
394 /* clear pending reader, qemu can't handle any more */
395 qemu_mutex_lock(&pending_reader_lock);
396 if (pending_reader) {
397 pending_reader = NULL;
398 /* make sure the event loop doesn't hang */
399 qemu_cond_signal(&pending_reader_condition);
400 }
401 qemu_mutex_unlock(&pending_reader_lock);
402 }
403 break;
404 case VSC_Init:
405 if (on_host_init(&mhHeader, (VSCMsgInit *)pbSendBuffer) < 0) {
406 return FALSE;
407 }
408 break;
409 default:
410 g_warn_if_reached();
411 return FALSE;
412 }
413
414 state = STATE_HEADER;
415 }
416
417
418 return TRUE;
419 }
420
421 static gboolean
422 do_socket(GIOChannel *source,
423 GIOCondition condition,
424 gpointer data)
425 {
426 /* not sure if two watches work well with a single win32 sources */
427 if (condition & G_IO_OUT) {
428 if (!do_socket_send(source, condition, data)) {
429 return FALSE;
430 }
431 }
432
433 if (condition & G_IO_IN) {
434 if (!do_socket_read(source, condition, data)) {
435 return FALSE;
436 }
437 }
438
439 return TRUE;
440 }
441
442 static void
443 update_socket_watch(gboolean out)
444 {
445 if (socket_tag != 0) {
446 g_source_remove(socket_tag);
447 }
448
449 socket_tag = g_io_add_watch(channel_socket,
450 G_IO_IN | (out ? G_IO_OUT : 0), do_socket, NULL);
451 }
452
453 static gboolean
454 do_command(GIOChannel *source,
455 GIOCondition condition,
456 gpointer data)
457 {
458 char *string;
459 VCardEmulError error;
460 static unsigned int default_reader_id;
461 unsigned int reader_id;
462 VReader *reader = NULL;
463 GError *err = NULL;
464
465 g_assert(condition & G_IO_IN);
466
467 reader_id = default_reader_id;
468 g_io_channel_read_line(source, &string, NULL, NULL, &err);
469 if (err != NULL) {
470 g_error("Error while reading command: %s", err->message);
471 }
472
473 if (string != NULL) {
474 if (strncmp(string, "exit", 4) == 0) {
475 /* remove all the readers */
476 VReaderList *list = vreader_get_reader_list();
477 VReaderListEntry *reader_entry;
478 printf("Active Readers:\n");
479 for (reader_entry = vreader_list_get_first(list); reader_entry;
480 reader_entry = vreader_list_get_next(reader_entry)) {
481 VReader *reader = vreader_list_get_reader(reader_entry);
482 vreader_id_t reader_id;
483 reader_id = vreader_get_id(reader);
484 if (reader_id == -1) {
485 continue;
486 }
487 /* be nice and signal card removal first (qemu probably should
488 * do this itself) */
489 if (vreader_card_is_present(reader) == VREADER_OK) {
490 send_msg(VSC_CardRemove, reader_id, NULL, 0);
491 }
492 send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
493 }
494 exit(0);
495 } else if (strncmp(string, "insert", 6) == 0) {
496 if (string[6] == ' ') {
497 reader_id = get_id_from_string(&string[7], reader_id);
498 }
499 reader = vreader_get_reader_by_id(reader_id);
500 if (reader != NULL) {
501 error = vcard_emul_force_card_insert(reader);
502 printf("insert %s, returned %d\n",
503 reader ? vreader_get_name(reader)
504 : "invalid reader", error);
505 } else {
506 printf("no reader by id %u found\n", reader_id);
507 }
508 } else if (strncmp(string, "remove", 6) == 0) {
509 if (string[6] == ' ') {
510 reader_id = get_id_from_string(&string[7], reader_id);
511 }
512 reader = vreader_get_reader_by_id(reader_id);
513 if (reader != NULL) {
514 error = vcard_emul_force_card_remove(reader);
515 printf("remove %s, returned %d\n",
516 reader ? vreader_get_name(reader)
517 : "invalid reader", error);
518 } else {
519 printf("no reader by id %u found\n", reader_id);
520 }
521 } else if (strncmp(string, "select", 6) == 0) {
522 if (string[6] == ' ') {
523 reader_id = get_id_from_string(&string[7],
524 VSCARD_UNDEFINED_READER_ID);
525 }
526 if (reader_id != VSCARD_UNDEFINED_READER_ID) {
527 reader = vreader_get_reader_by_id(reader_id);
528 }
529 if (reader) {
530 printf("Selecting reader %u, %s\n", reader_id,
531 vreader_get_name(reader));
532 default_reader_id = reader_id;
533 } else {
534 printf("Reader with id %u not found\n", reader_id);
535 }
536 } else if (strncmp(string, "debug", 5) == 0) {
537 if (string[5] == ' ') {
538 verbose = get_id_from_string(&string[6], 0);
539 }
540 printf("debug level = %d\n", verbose);
541 } else if (strncmp(string, "list", 4) == 0) {
542 VReaderList *list = vreader_get_reader_list();
543 VReaderListEntry *reader_entry;
544 printf("Active Readers:\n");
545 for (reader_entry = vreader_list_get_first(list); reader_entry;
546 reader_entry = vreader_list_get_next(reader_entry)) {
547 VReader *reader = vreader_list_get_reader(reader_entry);
548 vreader_id_t reader_id;
549 reader_id = vreader_get_id(reader);
550 if (reader_id == -1) {
551 continue;
552 }
553 printf("%3u %s %s\n", reader_id,
554 vreader_card_is_present(reader) == VREADER_OK ?
555 "CARD_PRESENT" : " ",
556 vreader_get_name(reader));
557 }
558 printf("Inactive Readers:\n");
559 for (reader_entry = vreader_list_get_first(list); reader_entry;
560 reader_entry = vreader_list_get_next(reader_entry)) {
561 VReader *reader = vreader_list_get_reader(reader_entry);
562 vreader_id_t reader_id;
563 reader_id = vreader_get_id(reader);
564 if (reader_id != -1) {
565 continue;
566 }
567
568 printf("INA %s %s\n",
569 vreader_card_is_present(reader) == VREADER_OK ?
570 "CARD_PRESENT" : " ",
571 vreader_get_name(reader));
572 }
573 } else if (*string != 0) {
574 printf("valid commands:\n");
575 printf("insert [reader_id]\n");
576 printf("remove [reader_id]\n");
577 printf("select reader_id\n");
578 printf("list\n");
579 printf("debug [level]\n");
580 printf("exit\n");
581 }
582 }
583 vreader_free(reader);
584 printf("> ");
585 fflush(stdout);
586
587 return TRUE;
588 }
589
590
591 /* just for ease of parsing command line arguments. */
592 #define MAX_CERTS 100
593
594 static int
595 connect_to_qemu(
596 const char *host,
597 const char *port
598 ) {
599 struct addrinfo hints;
600 struct addrinfo *server;
601 int ret, sock;
602
603 sock = qemu_socket(AF_INET, SOCK_STREAM, 0);
604 if (sock < 0) {
605 /* Error */
606 fprintf(stderr, "Error opening socket!\n");
607 return -1;
608 }
609
610 memset(&hints, 0, sizeof(struct addrinfo));
611 hints.ai_family = AF_UNSPEC;
612 hints.ai_socktype = SOCK_STREAM;
613 hints.ai_flags = 0;
614 hints.ai_protocol = 0; /* Any protocol */
615
616 ret = getaddrinfo(host, port, &hints, &server);
617
618 if (ret != 0) {
619 /* Error */
620 fprintf(stderr, "getaddrinfo failed\n");
621 goto cleanup_socket;
622 }
623
624 if (connect(sock, server->ai_addr, server->ai_addrlen) < 0) {
625 /* Error */
626 fprintf(stderr, "Could not connect\n");
627 goto cleanup_socket;
628 }
629 if (verbose) {
630 printf("Connected (sizeof Header=%zd)!\n", sizeof(VSCMsgHeader));
631 }
632 return sock;
633
634 cleanup_socket:
635 closesocket(sock);
636 return -1;
637 }
638
639 int
640 main(
641 int argc,
642 char *argv[]
643 ) {
644 GMainLoop *loop;
645 GIOChannel *channel_stdin;
646 char *qemu_host;
647 char *qemu_port;
648 VSCMsgHeader mhHeader;
649
650 VCardEmulOptions *command_line_options = NULL;
651
652 char *cert_names[MAX_CERTS];
653 char *emul_args = NULL;
654 int cert_count = 0;
655 int c, sock;
656
657 if (socket_init() != 0)
658 return 1;
659
660 while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
661 switch (c) {
662 case 'c':
663 if (cert_count >= MAX_CERTS) {
664 printf("too many certificates (max = %d)\n", MAX_CERTS);
665 exit(5);
666 }
667 cert_names[cert_count++] = optarg;
668 break;
669 case 'e':
670 emul_args = optarg;
671 break;
672 case 'p':
673 print_usage();
674 exit(4);
675 break;
676 case 'd':
677 verbose = get_id_from_string(optarg, 1);
678 break;
679 }
680 }
681
682 if (argc - optind != 2) {
683 print_usage();
684 exit(4);
685 }
686
687 if (cert_count > 0) {
688 char *new_args;
689 int len, i;
690 /* if we've given some -c options, we clearly we want do so some
691 * software emulation. add that emulation now. this is NSS Emulator
692 * specific */
693 if (emul_args == NULL) {
694 emul_args = (char *)"db=\"/etc/pki/nssdb\"";
695 }
696 #define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
697 /* 2 == close paren & null */
698 len = strlen(emul_args) + strlen(SOFT_STRING) + 2;
699 for (i = 0; i < cert_count; i++) {
700 len += strlen(cert_names[i])+1; /* 1 == comma */
701 }
702 new_args = g_malloc(len);
703 strcpy(new_args, emul_args);
704 strcat(new_args, SOFT_STRING);
705 for (i = 0; i < cert_count; i++) {
706 strcat(new_args, cert_names[i]);
707 strcat(new_args, ",");
708 }
709 strcat(new_args, ")");
710 emul_args = new_args;
711 }
712 if (emul_args) {
713 command_line_options = vcard_emul_options(emul_args);
714 }
715
716 qemu_host = g_strdup(argv[argc - 2]);
717 qemu_port = g_strdup(argv[argc - 1]);
718 sock = connect_to_qemu(qemu_host, qemu_port);
719 if (sock == -1) {
720 fprintf(stderr, "error opening socket, exiting.\n");
721 exit(5);
722 }
723
724 socket_to_send = g_byte_array_new();
725 qemu_mutex_init(&socket_to_send_lock);
726 qemu_mutex_init(&pending_reader_lock);
727 qemu_cond_init(&pending_reader_condition);
728
729 vcard_emul_init(command_line_options);
730
731 loop = g_main_loop_new(NULL, true);
732
733 printf("> ");
734 fflush(stdout);
735
736 #ifdef _WIN32
737 channel_stdin = g_io_channel_win32_new_fd(STDIN_FILENO);
738 #else
739 channel_stdin = g_io_channel_unix_new(STDIN_FILENO);
740 #endif
741 g_io_add_watch(channel_stdin, G_IO_IN, do_command, NULL);
742 #ifdef _WIN32
743 channel_socket = g_io_channel_win32_new_socket(sock);
744 #else
745 channel_socket = g_io_channel_unix_new(sock);
746 #endif
747 g_io_channel_set_encoding(channel_socket, NULL, NULL);
748 /* we buffer ourself for thread safety reasons */
749 g_io_channel_set_buffered(channel_socket, FALSE);
750
751 /* Send init message, Host responds (and then we send reader attachments) */
752 VSCMsgInit init = {
753 .version = htonl(VSCARD_VERSION),
754 .magic = VSCARD_MAGIC,
755 .capabilities = {0}
756 };
757 send_msg(VSC_Init, mhHeader.reader_id, &init, sizeof(init));
758
759 g_main_loop_run(loop);
760 g_main_loop_unref(loop);
761
762 g_io_channel_unref(channel_stdin);
763 g_io_channel_unref(channel_socket);
764 g_byte_array_unref(socket_to_send);
765
766 closesocket(sock);
767 return 0;
768 }