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
 649     VCardEmulOptions *command_line_options = NULL;
 650
 651     char *cert_names[MAX_CERTS];
 652     char *emul_args = NULL;
 653     int cert_count = 0;
 654     int c, sock;
 655
 656     if (socket_init() != 0)
 657         return 1;
 658
 659     while ((c = getopt(argc, argv, "c:e:pd:")) != -1) {
 660         switch (c) {
 661         case 'c':
 662             if (cert_count >= MAX_CERTS) {
 663                 printf("too many certificates (max = %d)\n", MAX_CERTS);
 664                 exit(5);
 665             }
 666             cert_names[cert_count++] = optarg;
 667             break;
 668         case 'e':
 669             emul_args = optarg;
 670             break;
 671         case 'p':
 672             print_usage();
 673             exit(4);
 674             break;
 675         case 'd':
 676             verbose = get_id_from_string(optarg, 1);
 677             break;
 678         }
 679     }
 680
 681     if (argc - optind != 2) {
 682         print_usage();
 683         exit(4);
 684     }
 685
 686     if (cert_count > 0) {
 687         char *new_args;
 688         int len, i;
 689         /* if we've given some -c options, we clearly we want do so some
 690          * software emulation.  add that emulation now. this is NSS Emulator
 691          * specific */
 692         if (emul_args == NULL) {
 693             emul_args = (char *)"db=\"/etc/pki/nssdb\"";
 694         }
 695 #define SOFT_STRING ",soft=(,Virtual Reader,CAC,,"
 696              /* 2 == close paren & null */
 697         len = strlen(emul_args) + strlen(SOFT_STRING) + 2;
 698         for (i = 0; i < cert_count; i++) {
 699             len += strlen(cert_names[i])+1; /* 1 == comma */
 700         }
 701         new_args = g_malloc(len);
 702         strcpy(new_args, emul_args);
 703         strcat(new_args, SOFT_STRING);
 704         for (i = 0; i < cert_count; i++) {
 705             strcat(new_args, cert_names[i]);
 706             strcat(new_args, ",");
 707         }
 708         strcat(new_args, ")");
 709         emul_args = new_args;
 710     }
 711     if (emul_args) {
 712         command_line_options = vcard_emul_options(emul_args);
 713     }
 714
 715     qemu_host = g_strdup(argv[argc - 2]);
 716     qemu_port = g_strdup(argv[argc - 1]);
 717     sock = connect_to_qemu(qemu_host, qemu_port);
 718     if (sock == -1) {
 719         fprintf(stderr, "error opening socket, exiting.\n");
 720         exit(5);
 721     }
 722
 723     socket_to_send = g_byte_array_new();
 724     qemu_mutex_init(&socket_to_send_lock);
 725     qemu_mutex_init(&pending_reader_lock);
 726     qemu_cond_init(&pending_reader_condition);
 727
 728     vcard_emul_init(command_line_options);
 729
 730     loop = g_main_loop_new(NULL, true);
 731
 732     printf("> ");
 733     fflush(stdout);
 734
 735 #ifdef _WIN32
 736     channel_stdin = g_io_channel_win32_new_fd(STDIN_FILENO);
 737 #else
 738     channel_stdin = g_io_channel_unix_new(STDIN_FILENO);
 739 #endif
 740     g_io_add_watch(channel_stdin, G_IO_IN, do_command, NULL);
 741 #ifdef _WIN32
 742     channel_socket = g_io_channel_win32_new_socket(sock);
 743 #else
 744     channel_socket = g_io_channel_unix_new(sock);
 745 #endif
 746     g_io_channel_set_encoding(channel_socket, NULL, NULL);
 747     /* we buffer ourself for thread safety reasons */
 748     g_io_channel_set_buffered(channel_socket, FALSE);
 749
 750     /* Send init message, Host responds (and then we send reader attachments) */
 751     VSCMsgInit init = {
 752         .version = htonl(VSCARD_VERSION),
 753         .magic = VSCARD_MAGIC,
 754         .capabilities = {0}
 755     };
 756     send_msg(VSC_Init, 0, &init, sizeof(init));
 757
 758     g_main_loop_run(loop);
 759     g_main_loop_unref(loop);
 760
 761     g_io_channel_unref(channel_stdin);
 762     g_io_channel_unref(channel_socket);
 763     g_byte_array_unref(socket_to_send);
 764
 765     closesocket(sock);
 766     return 0;
 767 }