Return to vscclient.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / libcacard

Annotation of qemu/libcacard/vscclient.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.