/ - Diff - qemu - Greek Research and Technology Network's projects

Revision 111a38b0

     check-qfloat: check-qfloat.o qfloat.o $(CHECK_PROG_DEPS)
     check-qjson: check-qjson.o qfloat.o qint.o qdict.o qstring.o qlist.o qbool.o qjson.o json-streamer.o json-lexer.o json-parser.o $(CHECK_PROG_DEPS)
     QEMULIBS=libhw32 libhw64 libuser libdis libdis-user
     clean:
     # avoid old build problems by removing potentially incorrect old files
     	rm -f config.mak op-i386.h opc-i386.h gen-op-i386.h op-arm.h opc-arm.h gen-op-arm.h
-...
     	rm -f trace-dtrace.dtrace trace-dtrace.dtrace-timestamp
     	rm -f trace-dtrace.h trace-dtrace.h-timestamp
     	$(MAKE) -C tests clean
     	for d in $(ALL_SUBDIRS) libhw32 libhw64 libuser libdis libdis-user; do \
     	for d in $(ALL_SUBDIRS) $(QEMULIBS) libcacard; do \
     	if test -d $$d; then $(MAKE) -C $$d $@ || exit 1; fi; \
     	rm -f $$d/qemu-options.def; \
             done
-...
     	rm -f roms/seabios/config.mak roms/vgabios/config.mak
     	rm -f qemu-doc.info qemu-doc.aux qemu-doc.cp qemu-doc.dvi qemu-doc.fn qemu-doc.info qemu-doc.ky qemu-doc.log qemu-doc.pdf qemu-doc.pg qemu-doc.toc qemu-doc.tp qemu-doc.vr
     	rm -f qemu-tech.info qemu-tech.aux qemu-tech.cp qemu-tech.dvi qemu-tech.fn qemu-tech.info qemu-tech.ky qemu-tech.log qemu-tech.pdf qemu-tech.pg qemu-tech.toc qemu-tech.tp qemu-tech.vr
     	for d in $(TARGET_DIRS) libhw32 libhw64 libuser libdis libdis-user; do \
     	for d in $(TARGET_DIRS) $(QEMULIBS); do \
     	rm -rf $$d || exit 1 ; \
             done

     endif
     endif
     ######################################################################
     # smartcard
     libcacard-y = cac.o event.o vcard.o vreader.o vcard_emul_nss.o vcard_emul_type.o card_7816.o
     vl.o: QEMU_CFLAGS+=$(GPROF_CFLAGS)
     vl.o: QEMU_CFLAGS+=$(SDL_CFLAGS)

     endif # CONFIG_SOFTMMU
     ifndef CONFIG_LINUX_USER
     # libcacard needs qemu-thread support, and besides is only needed by devices
     # so not requires with linux-user targets
     obj-$(CONFIG_SMARTCARD_NSS) += $(addprefix ../libcacard/, $(libcacard-y))
     endif # CONFIG_LINUX_USER
     obj-y += $(addprefix ../, $(trace-obj-y))
     obj-$(CONFIG_GDBSTUB_XML) += gdbstub-xml.o

     spice=""
     rbd=""
     smartcard=""
     smartcard_nss=""
     # parse CC options first
     for opt do
-...
       ;;
       --enable-smartcard) smartcard="yes"
       ;;
       --disable-smartcard-nss) smartcard_nss="no"
       ;;
       --enable-smartcard-nss) smartcard_nss="yes"
       ;;
       *) echo "ERROR: unknown option $opt"; show_help="yes"
       ;;
       esac
-...
     echo "  --enable-rbd             enable building the rados block device (rbd)"
     echo "  --disable-smartcard      disable smartcard support"
     echo "  --enable-smartcard       enable smartcard support"
     echo "  --disable-smartcard-nss  disable smartcard nss support"
     echo "  --enable-smartcard-nss   enable smartcard nss support"
     echo ""
     echo "NOTE: The object files are built at the place where configure is launched"
     exit 1
-...
       fi
     fi
     # check for libcacard for smartcard support
     if test "$smartcard" != "no" ; then
         smartcard="yes"
         smartcard_cflags=""
         # TODO - what's the minimal nss version we support?
         if test "$smartcard_nss" != "no"; then
             if $pkg_config --atleast-version=3.12.8 nss >/dev/null 2>&1 ; then
                 smartcard_nss="yes"
                 smartcard_cflags="-I\$(SRC_PATH)/libcacard"
                 libcacard_libs=$($pkg_config --libs nss 2>/dev/null)
                 libcacard_cflags=$($pkg_config --cflags nss 2>/dev/null)
                 QEMU_CFLAGS="$QEMU_CFLAGS $smartcard_cflags $libcacard_cflags"
                 LIBS="$libcacard_libs $LIBS"
             else
                 if test "$smartcard_nss" = "yes"; then
                     feature_not_found "nss"
                 fi
                 smartcard_nss="no"
             fi
         fi
     fi
     if test "$smartcard" = "no" ; then
         smartcard_nss="no"
     fi
     ##########################################
     ##########################################
-...
     echo "spice support     $spice"
     echo "rbd support       $rbd"
     echo "xfsctl support    $xfs"
     echo "nss used          $smartcard_nss"
     if test $sdl_too_old = "yes"; then
     echo "-> Your SDL version is too old - please upgrade to have SDL support"
-...
       echo "CONFIG_SMARTCARD=y" >> $config_host_mak
     fi
     if test "$smartcard_nss" = "yes" ; then
       echo "CONFIG_SMARTCARD_NSS=y" >> $config_host_mak
     fi
     # XXX: suppress that
     if [ "$bsd" = "yes" ] ; then
       echo "CONFIG_BSD=y" >> $config_host_mak
-...
     if test "$target_darwin_user" = "yes" ; then
       echo "CONFIG_DARWIN_USER=y" >> $config_target_mak
     fi
     if test "$smartcard_nss" = "yes" ; then
       echo "subdir-$target: subdir-libcacard" >> $config_host_mak
       echo "libcacard_libs=$libcacard_libs" >> $config_host_mak
       echo "libcacard_cflags=$libcacard_cflags" >> $config_host_mak
     fi
     list=""
     if test ! -z "$gdb_xml_files" ; then
       for x in $gdb_xml_files; do
-...
       echo "QEMU_CFLAGS+=-DTARGET_PHYS_ADDR_BITS=$hwlib" > $d/config.mak
     done
     if [ "$source_path" != `pwd` ]; then
         # out of tree build
         mkdir -p libcacard
         rm -f libcacard/Makefile
         ln -s "$source_path/libcacard/Makefile" libcacard/Makefile
     fi
     d=libuser
     mkdir -p $d
     symlink $source_path/Makefile.user $d/Makefile

     -include ../config-host.mak
     -include $(SRC_PATH)/Makefile.objs
     -include $(SRC_PATH)/rules.mak
     $(call set-vpath, $(SRC_PATH):$(SRC_PATH)/libcacard)
     ifeq ($(CONFIG_WIN32),y)
     QEMU_THREAD=qemu-thread-win32.o
     else
     QEMU_THREAD=qemu-thread-posix.o
     endif
     QEMU_OBJS=$(addprefix ../, $(QEMU_THREAD) $(oslib-obj-y) $(trace-obj-y) qemu-malloc.o qemu-timer-common.o)
     QEMU_CFLAGS+=-I../
     clean:
     	rm -f *.o */*.o *.d */*.d *.a */*.a *~ */*~

     /*
      * implement the applets for the CAC card.
+     *
      * This code is licensed under the GNU LGPL, version 2.1 or later.
      * See the COPYING.LIB file in the top-level directory.
      */
     #include "qemu-common.h"
     #include "cac.h"
     #include "vcard.h"
     #include "vcard_emul.h"
     #include "card_7816.h"
     #define CAC_GET_PROPERTIES  0x56
     #define CAC_GET_ACR         0x4c
     #define CAC_READ_BUFFER     0x52
     #define CAC_UPDATE_BUFFER   0x58
     #define CAC_SIGN_DECRYPT    0x42
     #define CAC_GET_CERTIFICATE 0x36
     /* private data for PKI applets */
     typedef struct CACPKIAppletDataStruct {
         unsigned char *cert;
         int cert_len;
         unsigned char *cert_buffer;
         int cert_buffer_len;
         unsigned char *sign_buffer;
         int sign_buffer_len;
         VCardKey *key;
     } CACPKIAppletData;
     /*
      * CAC applet private data
      */
     struct VCardAppletPrivateStruct {
         union {
             CACPKIAppletData pki_data;
             void *reserved;
         } u;
     };
     /*
      * handle all the APDU's that are common to all CAC applets
      */
     static VCardStatus
     cac_common_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
+    {
         int ef;
         switch (apdu->a_ins) {
         case VCARD7816_INS_SELECT_FILE:
             if (apdu->a_p1 != 0x02) {
                 /* let the 7816 code handle applet switches */
                 return VCARD_NEXT;
+            }
             /* handle file id setting */
             if (apdu->a_Lc != 2) {
                 *response = vcard_make_response(
                     VCARD7816_STATUS_ERROR_DATA_INVALID);
                 return VCARD_DONE;
+            }
             /* CAC 1.0 only supports ef = 0 */
             ef = apdu->a_body[0] | (apdu->a_body[1] << 8);
             if (ef != 0) {
                 *response = vcard_make_response(
                     VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
                 return VCARD_DONE;
+            }
             *response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
             return VCARD_DONE;
         case VCARD7816_INS_GET_RESPONSE:
         case VCARD7816_INS_VERIFY:
             /* let the 7816 code handle these */
             return VCARD_NEXT;
         case CAC_GET_PROPERTIES:
         case CAC_GET_ACR:
             /* skip these for now, this will probably be needed */
             *response = vcard_make_response(VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
             return VCARD_DONE;
+        }
         *response = vcard_make_response(
             VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
         return VCARD_DONE;
+    }
     /*
      *  reset the inter call state between applet selects
      */
     static VCardStatus
     cac_applet_pki_reset(VCard *card, int channel)
+    {
         VCardAppletPrivate *applet_private = NULL;
         CACPKIAppletData *pki_applet = NULL;
         applet_private = vcard_get_current_applet_private(card, channel);
         assert(applet_private);
         pki_applet = &(applet_private->u.pki_data);
         pki_applet->cert_buffer = NULL;
         if (pki_applet->sign_buffer) {
             qemu_free(pki_applet->sign_buffer);
             pki_applet->sign_buffer = NULL;
+        }
         pki_applet->cert_buffer_len = 0;
         pki_applet->sign_buffer_len = 0;
         return VCARD_DONE;
+    }
     static VCardStatus
     cac_applet_pki_process_apdu(VCard *card, VCardAPDU *apdu,
                                 VCardResponse **response)
+    {
         CACPKIAppletData *pki_applet = NULL;
         VCardAppletPrivate *applet_private = NULL;
         int size, next;
         unsigned char *sign_buffer;
         vcard_7816_status_t status;
         applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
         assert(applet_private);
         pki_applet = &(applet_private->u.pki_data);
         switch (apdu->a_ins) {
         case CAC_UPDATE_BUFFER:
             *response = vcard_make_response(
                 VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
             return VCARD_DONE;
         case CAC_GET_CERTIFICATE:
             if ((apdu->a_p2 != 0) || (apdu->a_p1 != 0)) {
                 *response = vcard_make_response(
                                  VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
                 break;
+            }
             assert(pki_applet->cert != NULL);
             size = apdu->a_Le;
             if (pki_applet->cert_buffer == NULL) {
                 pki_applet->cert_buffer = pki_applet->cert;
                 pki_applet->cert_buffer_len = pki_applet->cert_len;
+            }
             size = MIN(size, pki_applet->cert_buffer_len);
             next = MIN(255, pki_applet->cert_buffer_len - size);
             *response = vcard_response_new_bytes(
                             card, pki_applet->cert_buffer, size,
                             apdu->a_Le, next ?
                             VCARD7816_SW1_WARNING_CHANGE :
                             VCARD7816_SW1_SUCCESS,
                             next);
             pki_applet->cert_buffer += size;
             pki_applet->cert_buffer_len -= size;
             if ((*response == NULL) || (next == 0)) {
                 pki_applet->cert_buffer = NULL;
+            }
             if (*response == NULL) {
                 *response = vcard_make_response(
                                 VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
+            }
             return VCARD_DONE;
         case CAC_SIGN_DECRYPT:
             if (apdu->a_p2 != 0) {
                 *response = vcard_make_response(
                                  VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
                 break;
+            }
             size = apdu->a_Lc;
             sign_buffer = realloc(pki_applet->sign_buffer,
                           pki_applet->sign_buffer_len+size);
             if (sign_buffer == NULL) {
                 qemu_free(pki_applet->sign_buffer);
                 pki_applet->sign_buffer = NULL;
                 pki_applet->sign_buffer_len = 0;
                 *response = vcard_make_response(
                                 VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
                 return VCARD_DONE;
+            }
             memcpy(sign_buffer+pki_applet->sign_buffer_len, apdu->a_body, size);
             size += pki_applet->sign_buffer_len;
             switch (apdu->a_p1) {
             case  0x80:
                 /* p1 == 0x80 means we haven't yet sent the whole buffer, wait for
                  * the rest */
                 pki_applet->sign_buffer = sign_buffer;
                 pki_applet->sign_buffer_len = size;
                 *response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
                 return VCARD_DONE;
             case 0x00:
                 /* we now have the whole buffer, do the operation, result will be
                  * in the sign_buffer */
                 status = vcard_emul_rsa_op(card, pki_applet->key,
                                            sign_buffer, size);
                 if (status != VCARD7816_STATUS_SUCCESS) {
                     *response = vcard_make_response(status);
                     break;
+                }
                 *response = vcard_response_new(card, sign_buffer, size, apdu->a_Le,
                                                          VCARD7816_STATUS_SUCCESS);
                 if (*response == NULL) {
                     *response = vcard_make_response(
                                     VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
+                }
                 break;
             default:
                *response = vcard_make_response(
                                     VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
                 break;
+            }
             qemu_free(sign_buffer);
             pki_applet->sign_buffer = NULL;
             pki_applet->sign_buffer_len = 0;
             return VCARD_DONE;
         case CAC_READ_BUFFER:
             /* new CAC call, go ahead and use the old version for now */
             /* TODO: implement */
             *response = vcard_make_response(
                                     VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             return VCARD_DONE;
+        }
         return cac_common_process_apdu(card, apdu, response);
+    }
     static VCardStatus
     cac_applet_id_process_apdu(VCard *card, VCardAPDU *apdu,
                                VCardResponse **response)
+    {
         switch (apdu->a_ins) {
         case CAC_UPDATE_BUFFER:
             *response = vcard_make_response(
                             VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
             return VCARD_DONE;
         case CAC_READ_BUFFER:
             /* new CAC call, go ahead and use the old version for now */
             /* TODO: implement */
             *response = vcard_make_response(
                             VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             return VCARD_DONE;
+        }
         return cac_common_process_apdu(card, apdu, response);
+    }
     /*
      * TODO: if we ever want to support general CAC middleware, we will need to
      * implement the various containers.
      */
     static VCardStatus
     cac_applet_container_process_apdu(VCard *card, VCardAPDU *apdu,
                                       VCardResponse **response)
+    {
         switch (apdu->a_ins) {
         case CAC_READ_BUFFER:
         case CAC_UPDATE_BUFFER:
             *response = vcard_make_response(
                             VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             return VCARD_DONE;
         default:
             break;
+        }
         return cac_common_process_apdu(card, apdu, response);
+    }
     /*
      * utilities for creating and destroying the private applet data
      */
     static void
     cac_delete_pki_applet_private(VCardAppletPrivate *applet_private)
+    {
         CACPKIAppletData *pki_applet_data = NULL;
         if (pki_applet_data == NULL) {
             return;
+        }
         pki_applet_data = &(applet_private->u.pki_data);
         if (pki_applet_data->cert != NULL) {
             qemu_free(pki_applet_data->cert);
+        }
         if (pki_applet_data->sign_buffer != NULL) {
             qemu_free(pki_applet_data->sign_buffer);
+        }
         if (pki_applet_data->key != NULL) {
             vcard_emul_delete_key(pki_applet_data->key);
+        }
         qemu_free(applet_private);
+    }
     static VCardAppletPrivate *
     cac_new_pki_applet_private(const unsigned char *cert,
                                int cert_len, VCardKey *key)
+    {
         CACPKIAppletData *pki_applet_data = NULL;
         VCardAppletPrivate *applet_private = NULL;
         applet_private = (VCardAppletPrivate *)qemu_malloc(sizeof(VCardAppletPrivate));
         pki_applet_data = &(applet_private->u.pki_data);
         pki_applet_data->cert_buffer = NULL;
         pki_applet_data->cert_buffer_len = 0;
         pki_applet_data->sign_buffer = NULL;
         pki_applet_data->sign_buffer_len = 0;
         pki_applet_data->key = NULL;
         pki_applet_data->cert = (unsigned char *)qemu_malloc(cert_len+1);
         /*
          * if we want to support compression, then we simply change the 0 to a 1
          * and compress the cert data with libz
          */
         pki_applet_data->cert[0] = 0; /* not compressed */
         memcpy(&pki_applet_data->cert[1], cert, cert_len);
         pki_applet_data->cert_len = cert_len+1;
         pki_applet_data->key = key;
         return applet_private;
+    }
     /*
      * create a new cac applet which links to a given cert
      */
     static VCardApplet *
     cac_new_pki_applet(int i, const unsigned char *cert,
                        int cert_len, VCardKey *key)
+    {
         VCardAppletPrivate *applet_private = NULL;
         VCardApplet *applet = NULL;
         unsigned char pki_aid[] = { 0xa0, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00 };
         int pki_aid_len = sizeof(pki_aid);
         pki_aid[pki_aid_len-1] = i;
         applet_private = cac_new_pki_applet_private(cert, cert_len, key);
         if (applet_private == NULL) {
             goto failure;
+        }
         applet = vcard_new_applet(cac_applet_pki_process_apdu, cac_applet_pki_reset,
                                   pki_aid, pki_aid_len);
         if (applet == NULL) {
             goto failure;
+        }
         vcard_set_applet_private(applet, applet_private,
                                  cac_delete_pki_applet_private);
         applet_private = NULL;
         return applet;
     failure:
         if (applet_private != NULL) {
             cac_delete_pki_applet_private(applet_private);
+        }
         return NULL;
+    }
     static unsigned char cac_default_container_aid[] = {
 xa0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00 };
     static unsigned char cac_id_aid[] = {
 xa0, 0x00, 0x00, 0x00, 0x79, 0x03, 0x00 };
     /*
      * Initialize the cac card. This is the only public function in this file. All
      * the rest are connected through function pointers.
      */
     VCardStatus
     cac_card_init(VReader *reader, VCard *card,
                   const char *params,
                   unsigned char * const *cert,
                   int cert_len[],
                   VCardKey *key[] /* adopt the keys*/,
                   int cert_count)
+    {
         int i;
         VCardApplet *applet;
         /* CAC Cards are VM Cards */
         vcard_set_type(card, VCARD_VM);
         /* create one PKI applet for each cert */
         for (i = 0; i < cert_count; i++) {
             applet = cac_new_pki_applet(i, cert[i], cert_len[i], key[i]);
             if (applet == NULL) {
                 goto failure;
+            }
             vcard_add_applet(card, applet);
+        }
         /* create a default blank container applet */
         applet = vcard_new_applet(cac_applet_container_process_apdu,
                                   NULL, cac_default_container_aid,
                                   sizeof(cac_default_container_aid));
         if (applet == NULL) {
             goto failure;
+        }
         vcard_add_applet(card, applet);
         /* create a default blank container applet */
         applet = vcard_new_applet(cac_applet_id_process_apdu,
                                   NULL, cac_id_aid,
                                   sizeof(cac_id_aid));
         if (applet == NULL) {
             goto failure;
+        }
         vcard_add_applet(card, applet);
         return VCARD_DONE;
     failure:
         return VCARD_FAIL;
+    }

     /*
      * defines the entry point for the cac card. Only used by cac.c anc
      * vcard_emul_type.c
+     *
      * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
      * See the COPYING.LIB file in the top-level directory.
      */
     #ifndef CAC_H
     #define CAC_H 1
     #include "vcard.h"
     #include "vreader.h"
     /*
      * Initialize the cac card. This is the only public function in this file. All
      * the rest are connected through function pointers.
      */
     VCardStatus cac_card_init(VReader *reader, VCard *card, const char *params,
                   unsigned char * const *cert, int cert_len[],
                   VCardKey *key[] /* adopt the keys*/,
                   int cert_count);
     /* not yet implemented */
     VCardStatus cac_is_cac_card(VReader *reader);
     #endif

     /*
      * Implement the 7816 portion of the card spec
+     *
      * This code is licensed under the GNU LGPL, version 2.1 or later.
      * See the COPYING.LIB file in the top-level directory.
      */
     #include "qemu-common.h"
     #include "vcard.h"
     #include "vcard_emul.h"
     #include "card_7816.h"
     /*
      * set the status bytes based on the status word
      */
     static void
     vcard_response_set_status(VCardResponse *response, vcard_7816_status_t status)
+    {
         unsigned char sw1, sw2;
         response->b_status = status; /* make sure the status and swX representations
                                       * are consistent */
         sw1 = (status >> 8) & 0xff;
         sw2 = status & 0xff;
         response->b_sw1 = sw1;
         response->b_sw2 = sw2;
         response->b_data[response->b_len] = sw1;
         response->b_data[response->b_len+1] = sw2;
+    }
     /*
      * set the status bytes in a response buffer
      */
     static void
     vcard_response_set_status_bytes(VCardResponse *response,
                                    unsigned char sw1, unsigned char sw2)
+    {
         response->b_status = sw1 << 8 | sw2;
         response->b_sw1 = sw1;
         response->b_sw2 = sw2;
         response->b_data[response->b_len] = sw1;
         response->b_data[response->b_len+1] = sw2;
+    }
     /*
      * allocate a VCardResponse structure, plus space for the data buffer, and
      * set up everything but the resonse bytes.
      */
     VCardResponse *
     vcard_response_new_data(unsigned char *buf, int len)
+    {
         VCardResponse *new_response;
         new_response = (VCardResponse *)qemu_malloc(sizeof(VCardResponse));
         new_response->b_data = qemu_malloc(len + 2);
         memcpy(new_response->b_data, buf, len);
         new_response->b_total_len = len+2;
         new_response->b_len = len;
         new_response->b_type = VCARD_MALLOC;
         return new_response;
+    }
     static VCardResponse *
     vcard_init_buffer_response(VCard *card, unsigned char *buf, int len)
+    {
         VCardResponse *response;
         VCardBufferResponse *buffer_response;
         buffer_response = vcard_get_buffer_response(card);
         if (buffer_response) {
             vcard_set_buffer_response(card, NULL);
             vcard_buffer_response_delete(buffer_response);
+        }
         buffer_response = vcard_buffer_response_new(buf, len);
         if (buffer_response == NULL) {
             return NULL;
+        }
         response = vcard_response_new_status_bytes(VCARD7816_SW1_RESPONSE_BYTES,
                                                    len > 255 ? 0 : len);
         if (response == NULL) {
             return NULL;
+        }
         vcard_set_buffer_response(card, buffer_response);
         return response;
+    }
     /*
      * general buffer to hold results from APDU calls
      */
     VCardResponse *
     vcard_response_new(VCard *card, unsigned char *buf,
                        int len, int Le, vcard_7816_status_t status)
+    {
         VCardResponse *new_response;
         if (len > Le) {
             return vcard_init_buffer_response(card, buf, len);
+        }
         new_response = vcard_response_new_data(buf, len);
         if (new_response == NULL) {
             return NULL;
+        }
         vcard_response_set_status(new_response, status);
         return new_response;
+    }
     /*
      * general buffer to hold results from APDU calls
      */
     VCardResponse *
     vcard_response_new_bytes(VCard *card, unsigned char *buf, int len, int Le,
                              unsigned char sw1, unsigned char sw2)
+    {
         VCardResponse *new_response;
         if (len > Le) {
             return vcard_init_buffer_response(card, buf, len);
+        }
         new_response = vcard_response_new_data(buf, len);
         if (new_response == NULL) {
             return NULL;
+        }
         vcard_response_set_status_bytes(new_response, sw1, sw2);
         return new_response;
+    }
     /*
      * get a new Reponse buffer that only has a status.
      */
     static VCardResponse *
     vcard_response_new_status(vcard_7816_status_t status)
+    {
         VCardResponse *new_response;
         new_response = (VCardResponse *)qemu_malloc(sizeof(VCardResponse));
         new_response->b_data = &new_response->b_sw1;
         new_response->b_len = 0;
         new_response->b_total_len = 2;
         new_response->b_type = VCARD_MALLOC_STRUCT;
         vcard_response_set_status(new_response, status);
         return new_response;
+    }
     /*
      * same as above, but specify the status as separate bytes
      */
     VCardResponse *
     vcard_response_new_status_bytes(unsigned char sw1, unsigned char sw2)
+    {
         VCardResponse *new_response;
         new_response = (VCardResponse *)qemu_malloc(sizeof(VCardResponse));
         new_response->b_data = &new_response->b_sw1;
         new_response->b_len = 0;
         new_response->b_total_len = 2;
         new_response->b_type = VCARD_MALLOC_STRUCT;
         vcard_response_set_status_bytes(new_response, sw1, sw2);
         return new_response;
+    }
     /*
      * free the response buffer. The Buffer has a type to handle the buffer
      * allocated in other ways than through malloc.
      */
     void
     vcard_response_delete(VCardResponse *response)
+    {
         if (response == NULL) {
             return;
+        }
         switch (response->b_type) {
         case VCARD_MALLOC:
             /* everything was malloc'ed */
             if (response->b_data) {
                 qemu_free(response->b_data);
+            }
             qemu_free(response);
             break;
         case VCARD_MALLOC_DATA:
             /* only the data buffer was malloc'ed */
             if (response->b_data) {
                 qemu_free(response->b_data);
+            }
             break;
         case VCARD_MALLOC_STRUCT:
             /* only the structure was malloc'ed */
             qemu_free(response);
             break;
         case VCARD_STATIC:
             break;
+        }
+    }
     /*
      * decode the class bit and set our generic type field, channel, and
      * secure messaging values.
      */
     static vcard_7816_status_t
     vcard_apdu_set_class(VCardAPDU *apdu) {
         apdu->a_channel = 0;
         apdu->a_secure_messaging = 0;
         apdu->a_type = apdu->a_cla & 0xf0;
         apdu->a_gen_type = VCARD_7816_ISO;
         /* parse the class  tables 8 & 9 of the 7816-4 Part 4 spec */
         switch (apdu->a_type) {
             /* we only support the basic types */
         case 0x00:
         case 0x80:
         case 0x90:
         case 0xa0:
             apdu->a_channel = apdu->a_cla & 3;
             apdu->a_secure_messaging = apdu->a_cla & 0xe;
             break;
         case 0xb0:
         case 0xc0:
             break;
         case 0x10:
         case 0x20:
         case 0x30:
         case 0x40:
         case 0x50:
         case 0x60:
         case 0x70:
             /* Reserved for future use */
             apdu->a_gen_type = VCARD_7816_RFU;
             break;
         case 0xd0:
         case 0xe0:
         case 0xf0:
         default:
             apdu->a_gen_type =
                 (apdu->a_cla == 0xff) ? VCARD_7816_PTS : VCARD_7816_PROPIETARY;
             break;
+        }
         return VCARD7816_STATUS_SUCCESS;
+    }
     /*
      * set the Le and Lc fiels according to table 5 of the
      * 7816-4 part 4 spec
      */
     static vcard_7816_status_t
     vcard_apdu_set_length(VCardAPDU *apdu)
+    {
         int L, Le;
         /* process according to table 5 of the 7816-4 Part 4 spec.
          * variable names match the variables in the spec */
         L = apdu->a_len-4; /* fixed APDU header */
         apdu->a_Lc = 0;
         apdu->a_Le = 0;
         apdu->a_body = NULL;
         switch (L) {
         case 0:
             /* 1 minimal apdu */
             return VCARD7816_STATUS_SUCCESS;
         case 1:
             /* 2S only return values apdu */
             /*   zero maps to 256 here */
             apdu->a_Le = apdu->a_header->ah_Le ?
                              apdu->a_header->ah_Le : 256;
             return VCARD7816_STATUS_SUCCESS;
         default:
             /* if the ah_Le byte is zero and we have more than
              * 1 byte in the header, then we must be using extended Le and Lc.
              * process the extended now. */
             if (apdu->a_header->ah_Le == 0) {
                 if (L < 3) {
                     /* coding error, need at least 3 bytes */
                     return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
+                }
                 /* calculate the first extended value. Could be either Le or Lc */
                 Le = (apdu->a_header->ah_body[0] << 8)
                    || apdu->a_header->ah_body[1];
                 if (L == 3) {
                     /* 2E extended, return data only */
                     /*   zero maps to 65536 */
                     apdu->a_Le = Le ? Le : 65536;
                     return VCARD7816_STATUS_SUCCESS;
+                }
                 if (Le == 0) {
                     /* reserved for future use, probably for next time we need
                      * to extend the lengths */
                     return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
+                }
                 /* we know that the first extended value is Lc now */
                 apdu->a_Lc = Le;
                 apdu->a_body = &apdu->a_header->ah_body[2];
                 if (L == Le+3) {
                     /* 3E extended, only body parameters */
                     return VCARD7816_STATUS_SUCCESS;
+                }
                 if (L == Le+5) {
                     /* 4E extended, parameters and return data */
                     Le = (apdu->a_data[apdu->a_len-2] << 8)
                        || apdu->a_data[apdu->a_len-1];
                     apdu->a_Le = Le ? Le : 65536;
                     return VCARD7816_STATUS_SUCCESS;
+                }
                 return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
+            }
             /* not extended */
             apdu->a_Lc = apdu->a_header->ah_Le;
             apdu->a_body = &apdu->a_header->ah_body[0];
             if (L ==  apdu->a_Lc + 1) {
                 /* 3S only body parameters */
                 return VCARD7816_STATUS_SUCCESS;
+            }
             if (L ==  apdu->a_Lc + 2) {
                 /* 4S parameters and return data */
                 Le = apdu->a_data[apdu->a_len-1];
                 apdu->a_Le = Le ?  Le : 256;
                 return VCARD7816_STATUS_SUCCESS;
+            }
             break;
+        }
         return VCARD7816_STATUS_ERROR_WRONG_LENGTH;
+    }
     /*
      * create a new APDU from a raw set of bytes. This will decode all the
      * above fields. users of VCARDAPDU's can then depend on the already decoded
      * values.
      */
     VCardAPDU *
     vcard_apdu_new(unsigned char *raw_apdu, int len, vcard_7816_status_t *status)
+    {
         VCardAPDU *new_apdu;
         *status = VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE;
         if (len < 4) {
             *status = VCARD7816_STATUS_ERROR_WRONG_LENGTH;
             return NULL;
+        }
         new_apdu = (VCardAPDU *)qemu_malloc(sizeof(VCardAPDU));
         new_apdu->a_data = qemu_malloc(len);
         memcpy(new_apdu->a_data, raw_apdu, len);
         new_apdu->a_len = len;
         *status = vcard_apdu_set_class(new_apdu);
         if (*status != VCARD7816_STATUS_SUCCESS) {
             qemu_free(new_apdu);
             return NULL;
+        }
         *status = vcard_apdu_set_length(new_apdu);
         if (*status != VCARD7816_STATUS_SUCCESS) {
             qemu_free(new_apdu);
             new_apdu = NULL;
+        }
         return new_apdu;
+    }
     void
     vcard_apdu_delete(VCardAPDU *apdu)
+    {
         if (apdu == NULL) {
             return;
+        }
         if (apdu->a_data) {
             qemu_free(apdu->a_data);
+        }
         qemu_free(apdu);
+    }
     /*
      * declare response buffers for all the 7816 defined error codes
      */
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_SUCCESS)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_RET_CORUPT)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_CHANGE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_WARNING_FILE_FILLED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR_CHANGE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_LENGTH)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(
                         VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_INVALID)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_NO_EF)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_PARAMETERS)
     VCARD_RESPONSE_NEW_STATIC_STATUS(
                                 VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_FILE_NOT_FOUND)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_P1_P2_INCORRECT)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_DATA_NOT_FOUND)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_INS_CODE_INVALID)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_CLA_INVALID)
     VCARD_RESPONSE_NEW_STATIC_STATUS(VCARD7816_STATUS_ERROR_GENERAL)
     /*
      * return a single response code. This function cannot fail. It will always
      * return a response.
      */
     VCardResponse *
     vcard_make_response(vcard_7816_status_t status)
+    {
         VCardResponse *response = NULL;
         switch (status) {
         /* known 7816 response codes */
         case VCARD7816_STATUS_SUCCESS:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_SUCCESS);
         case VCARD7816_STATUS_WARNING:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING);
         case VCARD7816_STATUS_WARNING_RET_CORUPT:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_RET_CORUPT);
         case VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_BUF_END_BEFORE_LE);
         case VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_INVALID_FILE_SELECTED);
         case VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_FCI_FORMAT_INVALID);
         case VCARD7816_STATUS_WARNING_CHANGE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_CHANGE);
         case VCARD7816_STATUS_WARNING_FILE_FILLED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_WARNING_FILE_FILLED);
         case VCARD7816_STATUS_EXC_ERROR:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_EXC_ERROR);
         case VCARD7816_STATUS_EXC_ERROR_CHANGE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_EXC_ERROR_CHANGE);
         case VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
         case VCARD7816_STATUS_ERROR_WRONG_LENGTH:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_WRONG_LENGTH);
         case VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_CLA_NOT_SUPPORTED);
         case VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_CHANNEL_NOT_SUPPORTED);
         case VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED);
         case VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
         case VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_COMMAND_INCOMPATIBLE_WITH_FILE);
         case VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_SECURITY_NOT_SATISFIED);
         case VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_AUTHENTICATION_BLOCKED);
         case VCARD7816_STATUS_ERROR_DATA_INVALID:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_DATA_INVALID);
         case VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
         case VCARD7816_STATUS_ERROR_DATA_NO_EF:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_DATA_NO_EF);
         case VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_SM_OBJECT_MISSING);
         case VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_SM_OBJECT_INCORRECT);
         case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_WRONG_PARAMETERS);
         case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_IN_DATA);
         case VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED);
         case VCARD7816_STATUS_ERROR_FILE_NOT_FOUND:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
         case VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_RECORD_NOT_FOUND);
         case VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_NO_SPACE_FOR_FILE);
         case VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_LC_TLV_INCONSISTENT);
         case VCARD7816_STATUS_ERROR_P1_P2_INCORRECT:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
         case VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_LC_P1_P2_INCONSISTENT);
         case VCARD7816_STATUS_ERROR_DATA_NOT_FOUND:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
         case VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_WRONG_PARAMETERS_2);
         case VCARD7816_STATUS_ERROR_INS_CODE_INVALID:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_INS_CODE_INVALID);
         case VCARD7816_STATUS_ERROR_CLA_INVALID:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_CLA_INVALID);
         case VCARD7816_STATUS_ERROR_GENERAL:
             return VCARD_RESPONSE_GET_STATIC(
                         VCARD7816_STATUS_ERROR_GENERAL);
         default:
             /* we don't know this status code, create a response buffer to
              * hold it */
             response = vcard_response_new_status(status);
             if (response == NULL) {
                 /* couldn't allocate the buffer, return memmory error */
                 return VCARD_RESPONSE_GET_STATIC(
                             VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
+            }
+        }
         assert(response);
         return response;
+    }
     /*
      * Add File card support here if you need it.
      */
     static VCardStatus
     vcard7816_file_system_process_apdu(VCard *card, VCardAPDU *apdu,
                                        VCardResponse **response)
+    {
         /* TODO: if we want to support a virtual file system card, we do it here.
          * It would probably be a pkcs #15 card type */
         *response = vcard_make_response(
                         VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
         return VCARD_DONE;
+    }
     /*
      * VM card (including java cards)
      */
     static VCardStatus
     vcard7816_vm_process_apdu(VCard *card, VCardAPDU *apdu,
                               VCardResponse **response)
+    {
         int bytes_to_copy, next_byte_count, count;
         VCardApplet *current_applet;
         VCardBufferResponse *buffer_response;
         vcard_7816_status_t status;
         /* parse the class first */
         if (apdu->a_gen_type !=  VCARD_7816_ISO) {
             *response = vcard_make_response(
                             VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             return VCARD_DONE;
+        }
         /* use a switch so that if we need to support secure channel stuff later,
          * we know where to put it */
         switch (apdu->a_secure_messaging) {
         case 0x0: /* no SM */
             break;
         case 0x4: /* proprietary SM */
         case 0x8: /* header not authenticated */
         case 0xc: /* header authenticated */
         default:
             /* for now, don't try to support secure channel stuff in the
              * virtual card. */
             *response = vcard_make_response(
                             VCARD7816_STATUS_ERROR_SECURE_NOT_SUPPORTED);
             return VCARD_DONE;
+        }
         /* now parse the instruction */
         switch (apdu->a_ins) {
         case  VCARD7816_INS_MANAGE_CHANNEL: /* secure channel op */
         case  VCARD7816_INS_EXTERNAL_AUTHENTICATE: /* secure channel op */
         case  VCARD7816_INS_GET_CHALLENGE: /* secure channel op */
         case  VCARD7816_INS_INTERNAL_AUTHENTICATE: /* secure channel op */
         case  VCARD7816_INS_ERASE_BINARY: /* applet control op */
         case  VCARD7816_INS_READ_BINARY: /* applet control op */
         case  VCARD7816_INS_WRITE_BINARY: /* applet control op */
         case  VCARD7816_INS_UPDATE_BINARY: /* applet control op */
         case  VCARD7816_INS_READ_RECORD: /* file op */
         case  VCARD7816_INS_WRITE_RECORD: /* file op */
         case  VCARD7816_INS_UPDATE_RECORD: /* file op */
         case  VCARD7816_INS_APPEND_RECORD: /* file op */
         case  VCARD7816_INS_ENVELOPE:
         case  VCARD7816_INS_PUT_DATA:
             *response = vcard_make_response(
                                 VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             break;
         case  VCARD7816_INS_SELECT_FILE:
             if (apdu->a_p1 != 0x04) {
                 *response = vcard_make_response(
                                 VCARD7816_STATUS_ERROR_FUNCTION_NOT_SUPPORTED);
                 break;
+            }
             /* side effect, deselect the current applet if no applet has been found
              * */
             current_applet = vcard_find_applet(card, apdu->a_body, apdu->a_Lc);
             vcard_select_applet(card, apdu->a_channel, current_applet);
             if (current_applet) {
                 unsigned char *aid;
                 int aid_len;
                 aid = vcard_applet_get_aid(current_applet, &aid_len);
                 *response = vcard_response_new(card, aid, aid_len, apdu->a_Le,
                                               VCARD7816_STATUS_SUCCESS);
             } else {
                 *response = vcard_make_response(
                                  VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
+            }
             break;
         case  VCARD7816_INS_VERIFY:
             if ((apdu->a_p1 != 0x00) || (apdu->a_p2 != 0x00)) {
                 *response = vcard_make_response(
                                 VCARD7816_STATUS_ERROR_WRONG_PARAMETERS);
             } else {
                 if (apdu->a_Lc == 0) {
                     /* handle pin count if possible */
                     count = vcard_emul_get_login_count(card);
                     if (count < 0) {
                         *response = vcard_make_response(
                                         VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
                     } else {
                         if (count > 0xf) {
                             count = 0xf;
+                        }
                         *response = vcard_response_new_status_bytes(
                                                     VCARD7816_SW1_WARNING_CHANGE,
 xc0 | count);
                         if (*response == NULL) {
                             *response = vcard_make_response(
                                         VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
+                        }
+                    }
                 } else {
                         status = vcard_emul_login(card, apdu->a_body, apdu->a_Lc);
                     *response = vcard_make_response(status);
+                }
+            }
             break;
         case VCARD7816_INS_GET_RESPONSE:
             buffer_response = vcard_get_buffer_response(card);
             if (!buffer_response) {
                 *response = vcard_make_response(
                                 VCARD7816_STATUS_ERROR_DATA_NOT_FOUND);
                 /* handle error */
                 break;
+            }
             bytes_to_copy = MIN(buffer_response->len, apdu->a_Le);
             next_byte_count = MIN(256, buffer_response->len - bytes_to_copy);
             *response = vcard_response_new_bytes(
                             card, buffer_response->current, bytes_to_copy,
                             apdu->a_Le,
                             next_byte_count ?
                             VCARD7816_SW1_RESPONSE_BYTES : VCARD7816_SW1_SUCCESS,
                             next_byte_count);
             buffer_response->current += bytes_to_copy;
             buffer_response->len -= bytes_to_copy;
             if (*response == NULL || (next_byte_count == 0)) {
                 vcard_set_buffer_response(card, NULL);
                 vcard_buffer_response_delete(buffer_response);
+            }
             if (*response == NULL) {
                 *response =
                     vcard_make_response(VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
+            }
             break;
         case VCARD7816_INS_GET_DATA:
             *response =
                 vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             break;
         default:
             *response =
                 vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
             break;
+        }
         /* response should have been set somewhere */
         assert(*response != NULL);
         return VCARD_DONE;
+    }
     /*
      * APDU processing starts here. This routes the card processing stuff to the
      * right location.
      */
     VCardStatus
     vcard_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
+    {
         VCardStatus status;
         VCardBufferResponse *buffer_response;
         /* first handle any PTS commands, which aren't really APDU's */
         if (apdu->a_type == VCARD_7816_PTS) {
             /* the PTS responses aren't really responses either */
             *response = vcard_response_new_data(apdu->a_data, apdu->a_len);
             /* PTS responses have no status bytes */
             (*response)->b_total_len = (*response)->b_len;
             return VCARD_DONE;
+        }
         buffer_response = vcard_get_buffer_response(card);
         if (buffer_response && apdu->a_ins != VCARD7816_INS_GET_RESPONSE) {
             /* clear out buffer_response, return an error */
             vcard_set_buffer_response(card, NULL);
             vcard_buffer_response_delete(buffer_response);
             *response = vcard_make_response(VCARD7816_STATUS_EXC_ERROR);
             return VCARD_DONE;
+        }
         status = vcard_process_applet_apdu(card, apdu, response);
         if (status != VCARD_NEXT) {
             return status;
+        }
         switch (vcard_get_type(card)) {
         case VCARD_FILE_SYSTEM:
             return vcard7816_file_system_process_apdu(card, apdu, response);
         case VCARD_VM:
             return vcard7816_vm_process_apdu(card, apdu, response);
         case VCARD_DIRECT:
             /* if we are type direct, then the applet should handle everything */
             assert("VCARD_DIRECT: applet failure");
             break;
+        }
         *response =
             vcard_make_response(VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
         return VCARD_DONE;
+    }

     /*
      * Implement the 7816 portion of the card spec
+     *
      * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
      * See the COPYING.LIB file in the top-level directory.
      */
     #ifndef CARD_7816_H
     #define CARD_7816_H  1
     #include "card_7816t.h"
     #include "vcardt.h"

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Archipelago » qemu

Revision 111a38b0