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 #define closesocket(x) close(x)
  16 #endif
  17
  18 #include "qemu-common.h"
  19
  20 #include "vscard_common.h"
  21
  22 #include "vreader.h"
  23 #include "vcard_emul.h"
  24 #include "vevent.h"
  25
  26 static int verbose;
  27
  28 static void
  29 print_byte_array(
  30     uint8_t *arrBytes,
  31     unsigned int nSize
  32 ) {
  33     int i;
  34     for (i = 0; i < nSize; i++) {
  35         printf("%02X ", arrBytes[i]);
  36     }
  37     printf("\n");
  38 }
  39
  40 static void
  41 print_usage(void) {
  42     printf("vscclient [-c <certname> .. -e <emul_args> -d <level>%s] "
  43             "<host> <port>\n",
  44 #ifdef USE_PASSTHRU
  45     " -p");
  46     printf(" -p use passthrough mode\n");
  47 #else
  48    "");
  49 #endif
  50     vcard_emul_usage();
  51 }
  52
  53 static GIOChannel *channel_socket;
  54 static GByteArray *socket_to_send;
  55 static CompatGMutex socket_to_send_lock;
  56 static guint socket_tag;
  57
  58 static void
  59 update_socket_watch(void);
  60
  61 static gboolean
  62 do_socket_send(GIOChannel *source,
  63                GIOCondition condition,
  64                gpointer data)
  65 {
  66     gsize bw;
  67     GError *err = NULL;
  68
  69     g_return_val_if_fail(socket_to_send->len != 0, FALSE);
  70     g_return_val_if_fail(condition & G_IO_OUT, FALSE);
  71
  72     g_io_channel_write_chars(channel_socket,
  73         (gchar *)socket_to_send->data, socket_to_send->len, &bw, &err);
  74     if (err != NULL) {
  75         g_error("Error while sending socket %s", err->message);
  76         return FALSE;
  77     }
  78     g_byte_array_remove_range(socket_to_send, 0, bw);
  79
  80     if (socket_to_send->len == 0) {
  81         update_socket_watch();
  82         return FALSE;
  83     }
  84     return TRUE;
  85 }
  86
  87 static gboolean
  88 socket_prepare_sending(gpointer user_data)
  89 {
  90     update_socket_watch();
  91
  92     return FALSE;
  93 }
  94
  95 static int
  96 send_msg(
  97     VSCMsgType type,
  98     uint32_t reader_id,
  99     const void *msg,
 100     unsigned int length
 101 ) {
 102     VSCMsgHeader mhHeader;
 103
 104     g_mutex_lock(&socket_to_send_lock);
 105
 106     if (verbose > 10) {
 107         printf("sending type=%d id=%u, len =%u (0x%x)\n",
 108                type, reader_id, length, length);
 109     }
 110
 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);
 117
 118     g_mutex_unlock(&socket_to_send_lock);
 119
 120     return 0;
 121 }
 122
 123 static VReader *pending_reader;
 124 static CompatGMutex pending_reader_lock;
 125 static CompatGCond pending_reader_condition;
 126
 127 #define MAX_ATR_LEN 40
 128 static gpointer
 129 event_thread(gpointer arg)
 130 {
 131     unsigned char atr[MAX_ATR_LEN];
 132     int atr_len;
 133     VEvent *event;
 134     unsigned int reader_id;
 135
 136
 137     while (1) {
 138         const char *reader_name;
 139
 140         event = vevent_wait_next_vevent();
 141         if (event == NULL) {
 142             break;
 143         }
 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);
 156                 continue;
 157             }
 158             /* this reader hasn't been told its status from qemu yet, wait for
 159              * that status */
 160             while (pending_reader != NULL) {
 161                 g_cond_wait(&pending_reader_condition, &pending_reader_lock);
 162             }
 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);
 169                 continue;
 170             }
 171             /* reader was accepted, now forward the event */
 172         }
 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
 178              * */
 179             g_mutex_lock(&pending_reader_lock);
 180             while (pending_reader != NULL) {
 181                 g_cond_wait(&pending_reader_condition, &pending_reader_lock);
 182             }
 183             pending_reader = vreader_reference(event->reader);
 184             g_mutex_unlock(&pending_reader_lock);
 185             reader_name = vreader_get_name(event->reader);
 186             if (verbose > 10) {
 187                 printf(" READER INSERT: %s\n", reader_name);
 188             }
 189             send_msg(VSC_ReaderAdd,
 190                 reader_id, /* currerntly VSCARD_UNDEFINED_READER_ID */
 191                 NULL, 0 /* TODO reader_name, strlen(reader_name) */);
 192             break;
 193         case VEVENT_READER_REMOVE:
 194             /* future, tell qemu that an old CCID reader has been removed */
 195             if (verbose > 10) {
 196                 printf(" READER REMOVE: %u\n", reader_id);
 197             }
 198             send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
 199             break;
 200         case VEVENT_CARD_INSERT:
 201             /* get the ATR (intended as a response to a power on from the
 202              * reader */
 203             atr_len = MAX_ATR_LEN;
 204             vreader_power_on(event->reader, atr, &atr_len);
 205             /* ATR call functions as a Card Insert event */
 206             if (verbose > 10) {
 207                 printf(" CARD INSERT %u: ", reader_id);
 208                 print_byte_array(atr, atr_len);
 209             }
 210             send_msg(VSC_ATR, reader_id, atr, atr_len);
 211             break;
 212         case VEVENT_CARD_REMOVE:
 213             /* Card removed */
 214             if (verbose > 10) {
 215                 printf(" CARD REMOVE %u:\n", reader_id);
 216             }
 217             send_msg(VSC_CardRemove, reader_id, NULL, 0);
 218             break;
 219         default:
 220             break;
 221         }
 222         vevent_delete(event);
 223     }
 224     return NULL;
 225 }
 226
 227
 228 static unsigned int
 229 get_id_from_string(char *string, unsigned int default_id)
 230 {
 231     unsigned int id = atoi(string);
 232
 233     /* don't accidentally swith to zero because no numbers have been supplied */
 234     if ((id == 0) && *string != '0') {
 235         return default_id;
 236     }
 237     return id;
 238 }
 239
 240 static int
 241 on_host_init(VSCMsgHeader *mhHeader, VSCMsgInit *incoming)
 242 {
 243     uint32_t *capabilities = (incoming->capabilities);
 244     int num_capabilities =
 245         1 + ((mhHeader->length - sizeof(VSCMsgInit)) / sizeof(uint32_t));
 246     int i;
 247
 248     incoming->version = ntohl(incoming->version);
 249     if (incoming->version != VSCARD_VERSION) {
 250         if (verbose > 0) {
 251             printf("warning: host has version %d, we have %d\n",
 252                 verbose, VSCARD_VERSION);
 253         }
 254     }
 255     if (incoming->magic != VSCARD_MAGIC) {
 256         printf("unexpected magic: got %d, expected %d\n",
 257             incoming->magic, VSCARD_MAGIC);
 258         return -1;
 259     }
 260     for (i = 0 ; i < num_capabilities; ++i) {
 261         capabilities[i] = ntohl(capabilities[i]);
 262     }
 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);
 270     return 0;
 271 }
 272
 273
 274 enum {
 275     STATE_HEADER,
 276     STATE_MESSAGE,
 277 };
 278
 279 #define APDUBufSize 270
 280
 281 static gboolean
 282 do_socket_read(GIOChannel *source,
 283                GIOCondition condition,
 284                gpointer data)
 285 {
 286     int rv;
 287     int dwSendLength;
 288     int dwRecvLength;
 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;
 295     GError *err = NULL;
 296
 297     static gchar *buf;
 298     static gsize br, to_read;
 299     static int state = STATE_HEADER;
 300
 301     if (state == STATE_HEADER && to_read == 0) {
 302         buf = (gchar *)&mhHeader;
 303         to_read = sizeof(mhHeader);
 304     }
 305
 306     if (to_read > 0) {
 307         g_io_channel_read_chars(source, (gchar *)buf, to_read, &br, &err);
 308         if (err != NULL) {
 309             g_error("error while reading: %s", err->message);
 310         }
 311         buf += br;
 312         to_read -= br;
 313         if (to_read != 0) {
 314             return TRUE;
 315         }
 316     }
 317
 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);
 322         if (verbose) {
 323             printf("Header: type=%d, reader_id=%u length=%d (0x%x)\n",
 324                    mhHeader.type, mhHeader.reader_id, mhHeader.length,
 325                    mhHeader.length);
 326         }
 327         switch (mhHeader.type) {
 328         case VSC_APDU:
 329         case VSC_Flush:
 330         case VSC_Error:
 331         case VSC_Init:
 332             buf = (gchar *)pbSendBuffer;
 333             to_read = mhHeader.length;
 334             state = STATE_MESSAGE;
 335             return TRUE;
 336         default:
 337             fprintf(stderr, "Unexpected message of type 0x%X\n", mhHeader.type);
 338             return FALSE;
 339         }
 340     }
 341
 342     if (state == STATE_MESSAGE) {
 343         switch (mhHeader.type) {
 344         case VSC_APDU:
 345             if (verbose) {
 346                 printf(" recv APDU: ");
 347                 print_byte_array(pbSendBuffer, mhHeader.length);
 348             }
 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;
 358                 if (verbose) {
 359                     printf(" send response: ");
 360                     print_byte_array(pbRecvBuffer, mhHeader.length);
 361                 }
 362                 send_msg(VSC_APDU, mhHeader.reader_id,
 363                          pbRecvBuffer, dwRecvLength);
 364             } else {
 365                 rv = reader_status; /* warning: not meaningful */
 366                 send_msg(VSC_Error, mhHeader.reader_id, &rv, sizeof(uint32_t));
 367             }
 368             vreader_free(reader);
 369             reader = NULL; /* we've freed it, don't use it by accident
 370                               again */
 371             break;
 372         case VSC_Flush:
 373             /* TODO: actually flush */
 374             send_msg(VSC_FlushComplete, mhHeader.reader_id, NULL, 0);
 375             break;
 376         case VSC_Error:
 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);
 385                 }
 386                 g_mutex_unlock(&pending_reader_lock);
 387                 break;
 388             }
 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);
 397                 }
 398                 g_mutex_unlock(&pending_reader_lock);
 399             }
 400             break;
 401         case VSC_Init:
 402             if (on_host_init(&mhHeader, (VSCMsgInit *)pbSendBuffer) < 0) {
 403                 return FALSE;
 404             }
 405             break;
 406         default:
 407             g_assert_not_reached();
 408             return FALSE;
 409         }
 410
 411         state = STATE_HEADER;
 412     }
 413
 414
 415     return TRUE;
 416 }
 417
 418 static gboolean
 419 do_socket(GIOChannel *source,
 420           GIOCondition condition,
 421           gpointer data)
 422 {
 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)) {
 426             return FALSE;
 427         }
 428     }
 429
 430     if (condition & G_IO_IN) {
 431         if (!do_socket_read(source, condition, data)) {
 432             return FALSE;
 433         }
 434     }
 435
 436     return TRUE;
 437 }
 438
 439 static void
 440 update_socket_watch(void)
 441 {
 442     gboolean out = socket_to_send->len > 0;
 443
 444     if (socket_tag != 0) {
 445         g_source_remove(socket_tag);
 446     }
 447
 448     socket_tag = g_io_add_watch(channel_socket,
 449         G_IO_IN | (out ? G_IO_OUT : 0), do_socket, NULL);
 450 }
 451
 452 static gboolean
 453 do_command(GIOChannel *source,
 454            GIOCondition condition,
 455            gpointer data)
 456 {
 457     char *string;
 458     VCardEmulError error;
 459     static unsigned int default_reader_id;
 460     unsigned int reader_id;
 461     VReader *reader = NULL;
 462     GError *err = NULL;
 463
 464     g_assert(condition & G_IO_IN);
 465
 466     reader_id = default_reader_id;
 467     g_io_channel_read_line(source, &string, NULL, NULL, &err);
 468     if (err != NULL) {
 469         g_error("Error while reading command: %s", err->message);
 470     }
 471
 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) {
 484                     continue;
 485                 }
 486                 /* be nice and signal card removal first (qemu probably should
 487                  * do this itself) */
 488                 if (vreader_card_is_present(reader) == VREADER_OK) {
 489                     send_msg(VSC_CardRemove, reader_id, NULL, 0);
 490                 }
 491                 send_msg(VSC_ReaderRemove, reader_id, NULL, 0);
 492             }
 493             exit(0);
 494         } else if (strncmp(string, "insert", 6) == 0) {
 495             if (string[6] == ' ') {
 496                 reader_id = get_id_from_string(&string[7], reader_id);
 497             }
 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);
 503             } else {
 504                 printf("no reader by id %u found\n", reader_id);
 505             }
 506         } else if (strncmp(string, "remove", 6) == 0) {
 507             if (string[6] == ' ') {
 508                 reader_id = get_id_from_string(&string[7], reader_id);
 509             }
 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);
 515             } else {
 516                 printf("no reader by id %u found\n", reader_id);
 517             }
 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);
 522             }
 523             if (reader_id != VSCARD_UNDEFINED_READER_ID) {
 524                 reader = vreader_get_reader_by_id(reader_id);
 525             }
 526             if (reader) {
 527                 printf("Selecting reader %u, %s\n", reader_id,
 528                         vreader_get_name(reader));
 529                 default_reader_id = reader_id;
 530             } else {
 531                 printf("Reader with id %u not found\n", reader_id);
 532             }
 533         } else if (strncmp(string, "debug", 5) == 0) {
 534             if (string[5] == ' ') {
 535                 verbose = get_id_from_string(&string[6], 0);
 536             }
 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) {
 548                     continue;
 549                 }
 550                 printf("%3u %s %s\n", reader_id,
 551                        vreader_card_is_present(reader) == VREADER_OK ?
 552                        "CARD_PRESENT" : "            ",
 553                        vreader_get_name(reader));
 554             }
 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) {
 562                     continue;
 563                 }
 564
 565                 printf("INA %s %s\n",
 566                        vreader_card_is_present(reader) == VREADER_OK ?
 567                        "CARD_PRESENT" : "            ",
 568                        vreader_get_name(reader));
 569             }
 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");
 576             printf("list\n");
 577             printf("debug [level]\n");
 578             printf("exit\n");
 579         }
 580     }
 581     vreader_free(reader);
 582     printf("> ");
 583     fflush(stdout);
 584
 585     return TRUE;
 586 }
 587
 588
 589 /* just for ease of parsing command line arguments. */
 590 #define MAX_CERTS 100
 591
 592 static int
 593 connect_to_qemu(
 594     const char *host,
 595     const char *port
 596 ) {
 597     struct addrinfo hints;
 598     struct addrinfo *server;
 599     int ret, sock;
 600
 601     sock = socket(AF_INET, SOCK_STREAM, 0);
 602     if (sock < 0) {
 603         /* Error */
 604         fprintf(stderr, "Error opening socket!\n");
 605         return -1;
 606     }
 607
 608     memset(&hints, 0, sizeof(struct addrinfo));
 609     hints.ai_family = AF_UNSPEC;
 610     hints.ai_socktype = SOCK_STREAM;
 611     hints.ai_flags = 0;
 612     hints.ai_protocol = 0;          /* Any protocol */
 613
 614     ret = getaddrinfo(host, port, &hints, &server);
 615
 616     if (ret != 0) {
 617         /* Error */
 618         fprintf(stderr, "getaddrinfo failed\n");
 619         goto cleanup_socket;
 620     }
 621
 622     if (connect(sock, server->ai_addr, server->ai_addrlen) < 0) {
 623         /* Error */
 624         fprintf(stderr, "Could not connect\n");
 625         goto cleanup_socket;
 626     }
 627     if (verbose) {
 628         printf("Connected (sizeof Header=%zd)!\n", sizeof(VSCMsgHeader));
 629     }
 630     return sock;
 631
 632 cleanup_socket:
 633     closesocket(sock);
 634     return -1;
 635 }
 636
 637 int
 638 main(
 639     int argc,
 640     char *argv[]
 641 ) {
 642     GMainLoop *loop;
 643     GIOChannel *channel_stdin;
 644     char *qemu_host;
 645     char *qemu_port;
 646
 647     VCardEmulOptions *command_line_options = NULL;
 648
 649     char *cert_names[MAX_CERTS];
 650     char *emul_args = NULL;
 651     int cert_count = 0;
 652     int c, sock;
 653
 654 #ifdef _WIN32
 655     WSADATA Data;
 656
 657     if (WSAStartup(MAKEWORD(2, 2), &Data) != 0) {
 658         c = WSAGetLastError();
 659         fprintf(stderr, "WSAStartup: %d\n", c);
 660         return 1;
 661     }
 662 #endif
 663 #if !GLIB_CHECK_VERSION(2, 31, 0)
 664     if (!g_thread_supported()) {
 665          g_thread_init(NULL);
 666     }
 667 #endif
 668
 669     while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
 670         switch (c) {
 671         case 'c':
 672             if (cert_count >= MAX_CERTS) {
 673                 printf("too many certificates (max = %d)\n", MAX_CERTS);
 674                 exit(5);
 675             }
 676             cert_names[cert_count++] = optarg;
 677             break;
 678         case 'e':
 679             emul_args = optarg;
 680             break;
 681         case 'p':
 682             print_usage();
 683             exit(4);
 684             break;
 685         case 'd':
 686             verbose = get_id_from_string(optarg, 1);
 687             break;
 688         }
 689     }
 690
 691     if (argc - optind != 2) {
 692         print_usage();
 693         exit(4);
 694     }
 695
 696     if (cert_count > 0) {
 697         char *new_args;
 698         int len, i;
 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
 701          * specific */
 702         if (emul_args == NULL) {
 703             emul_args = (char *)"db=\"/etc/pki/nssdb\"";
 704         }
 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 */
 710         }
 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, ",");
 717         }
 718         strcat(new_args, ")");
 719         emul_args = new_args;
 720     }
 721     if (emul_args) {
 722         command_line_options = vcard_emul_options(emul_args);
 723     }
 724
 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);
 728     if (sock == -1) {
 729         fprintf(stderr, "error opening socket, exiting.\n");
 730         exit(5);
 731     }
 732
 733     socket_to_send = g_byte_array_new();
 734     vcard_emul_init(command_line_options);
 735     loop = g_main_loop_new(NULL, TRUE);
 736
 737     printf("> ");
 738     fflush(stdout);
 739
 740 #ifdef _WIN32
 741     channel_stdin = g_io_channel_win32_new_fd(STDIN_FILENO);
 742 #else
 743     channel_stdin = g_io_channel_unix_new(STDIN_FILENO);
 744 #endif
 745     g_io_add_watch(channel_stdin, G_IO_IN, do_command, NULL);
 746 #ifdef _WIN32
 747     channel_socket = g_io_channel_win32_new_socket(sock);
 748 #else
 749     channel_socket = g_io_channel_unix_new(sock);
 750 #endif
 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);
 754
 755     /* Send init message, Host responds (and then we send reader attachments) */
 756     VSCMsgInit init = {
 757         .version = htonl(VSCARD_VERSION),
 758         .magic = VSCARD_MAGIC,
 759         .capabilities = {0}
 760     };
 761     send_msg(VSC_Init, 0, &init, sizeof(init));
 762
 763     g_main_loop_run(loop);
 764     g_main_loop_unref(loop);
 765
 766     g_io_channel_unref(channel_stdin);
 767     g_io_channel_unref(channel_socket);
 768     g_byte_array_free(socket_to_send, TRUE);
 769
 770     closesocket(sock);
 771     return 0;
 772 }