Changeset 6e70c09 in OpenSC

Timestamp:

06/15/11 08:07:52 (11 months ago)

Author:

martin

Branches:

master, staging

Children:

2757253, 6c24bd5

Parents:

0ae9962 (diff), d4e90c1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

git-author:

Martin Paljak <martin@…> (06/15/11 08:07:52)

git-committer:

Martin Paljak <martin@…> (06/15/11 08:07:52)

Message:

Merge branch 'github-transition' into proposed

Files:

• .gitignore (added)
• Makefile.am (modified) (1 diff)
• configure.ac (modified) (3 diffs)
• doc/Makefile.am (modified) (1 diff)
• doc/svn2cl.xsl (deleted)
• src/libopensc/card-openpgp.c (modified) (13 diffs)
• src/libopensc/internal-winscard.h (modified) (1 diff)
• src/libopensc/reader-pcsc.c (modified) (7 diffs)
• src/pkcs11/opensc-pkcs11.exports (modified) (1 diff)
• src/pkcs15init/pkcs15-lib.c (modified) (1 diff)
• src/tools/opensc-explorer.c (modified) (63 diffs)
• src/tools/opensc-tool.c (modified) (2 diffs)

Makefile.am

@@ -24 +24 @@
 Generate-ChangeLog:
         rm -f ChangeLog.tmp "$(srcdir)/ChangeLog"
-        test -n "$(SVN)" -a -n "$(XSLTPROC)"
-        if test -d "$(top_srcdir)/.svn"; then \
-                $(SVN) --verbose --xml log "$(top_srcdir)" | \
-                        $(XSLTPROC) --nonet --stringparam linelen 75 \
-                        --stringparam groupbyday no \
-                        --stringparam include-rev no \
-                        "$(top_srcdir)/doc/svn2cl.xsl" - > ChangeLog.tmp; \
+        test -n "$(GIT)"
+        if test -d "$(top_srcdir)/.git"; then \
+                echo "# Generated by Makefile. Do not edit!" > ChangeLog.tmp; \
+                $(GIT) log >> ChangeLog.tmp; \
         else \
-                echo "Warning: Unable to generate ChangeLog from none svn checkout" >&2; \
+                echo "Warning: Unable to generate ChangeLog. Need a Git repostiroy." >&2; \
                 echo > ChangeLog.tmp; \
         fi

configure.ac

@@ -6 +6 @@
 define([PACKAGE_VERSION_MINOR], [12])
 define([PACKAGE_VERSION_FIX], [2])
-define([PACKAGE_SUFFIX], [-svn])
+define([PACKAGE_SUFFIX], [-pre1])
 
 AC_INIT([opensc],[PACKAGE_VERSION_MAJOR.PACKAGE_VERSION_MINOR.PACKAGE_VERSION_FIX[]PACKAGE_SUFFIX])
@@ -193 +193 @@
 )
 
-dnl These required for svn checkout
-AC_ARG_VAR([SVN], [subversion utility])
+dnl These required for repository checkout
 AC_ARG_VAR([XSLTPROC], [xsltproc utility])
-AC_CHECK_PROGS([SVN],[svn])
+AC_ARG_VAR([git], [git])
 AC_CHECK_PROGS([XSLTPROC],[xsltproc])
+AC_CHECK_PROGS([GIT],[git])
 
 AC_MSG_CHECKING([xsl-stylesheets])
@@ -491 +491 @@
 if test "${enable_man}" = "yes" -o "${enable_doc}" = "yes"; then
         AC_MSG_CHECKING([XSLTPROC requirement])
-        test -n "${XSLTPROC}" || AC_MSG_ERROR([Missing XSLTPROC svn build with man or doc])
+        test -n "${XSLTPROC}" || AC_MSG_ERROR([Missing XSLTPROC])
         test "${xslstylesheetsdir}" != "no" || AC_MSG_ERROR([Missing xslstylesheetsdir])
         AC_MSG_RESULT([ok])

doc/Makefile.am

@@ -1 +1 @@
 MAINTAINERCLEANFILES = $(srcdir)/Makefile.in
 
-dist_noinst_SCRIPTS = svn2cl.xsl html.xsl man.xsl
+dist_noinst_SCRIPTS = html.xsl man.xsl
 dist_noinst_DATA = $(srcdir)/tools/*.xml api.css
 if ENABLE_DOC

src/libopensc/card-openpgp.c

@@ -123 +123 @@
 static int              pgp_get_blob(sc_card_t *card, struct blob *blob,
                                  unsigned int id, struct blob **ret);
-static struct blob *    pgp_new_blob(struct blob *, unsigned int, int,
-                                struct do_info *);
+static struct blob *    pgp_new_blob(sc_card_t *, struct blob *, unsigned int, sc_file_t *);
 static void             pgp_free_blob(struct blob *);
 static int              pgp_get_pubkey(sc_card_t *, unsigned int,
@@ -162 +161 @@
         { 0x00e1, CONSTRUCTED, READ_NEVER  | WRITE_PIN3,  NULL,               sc_put_data },
         { 0x00e2, CONSTRUCTED, READ_NEVER  | WRITE_PIN3,  NULL,               sc_put_data },
-        { 0x00ff, CONSTRUCTED, READ_ALWAYS | WRITE_NEVER, sc_get_data,        NULL        },
         { 0x0101, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  sc_get_data,        sc_put_data },
         { 0x0102, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  sc_get_data,        sc_put_data },
         { 0x0103, SIMPLE,      READ_PIN1   | WRITE_PIN1,  sc_get_data,        sc_put_data },
         { 0x0104, SIMPLE,      READ_PIN3   | WRITE_PIN3,  sc_get_data,        sc_put_data },
+        { 0x3f00, CONSTRUCTED, READ_ALWAYS | WRITE_NEVER, NULL,               NULL        },
         { 0x5f2d, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  NULL,               sc_put_data },
         { 0x5f35, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  NULL,               sc_put_data },
@@ -217 +216 @@
         { 0x0103, SIMPLE,      READ_PIN1   | WRITE_PIN1,  sc_get_data,        sc_put_data },
         { 0x0104, SIMPLE,      READ_PIN3   | WRITE_PIN3,  sc_get_data,        sc_put_data },
+        { 0x3f00, CONSTRUCTED, READ_ALWAYS | WRITE_NEVER, NULL,               NULL        },
         { 0x5f2d, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  NULL,               sc_put_data },
         { 0x5f35, SIMPLE,      READ_ALWAYS | WRITE_PIN3,  NULL,               sc_put_data },
@@ -277 +277 @@
         card->drv_data = priv;
 
-        priv->mf = calloc(1, sizeof(struct blob));
-        if (!priv->mf) {
-                pgp_finish(card);
-                return SC_ERROR_OUT_OF_MEMORY;
-        }
-
         card->cla = 0x00;
 
@@ -310 +304 @@
         }
 
+        /* change file path to MF for re-use in MF */
         sc_format_path("3f00", &file->path);
-        file->type = SC_FILE_TYPE_DF;
-        file->id = 0x3f00;
-
-        priv->mf->file = file;
-        priv->mf->id = 0x3F00;
+
+        /* set up the root of our fake file tree */
+        priv->mf = pgp_new_blob(card, NULL, 0x3f00, file);
+        if (!priv->mf) {
+                pgp_finish(card);
+                return SC_ERROR_OUT_OF_MEMORY;
+        }
 
         /* select MF */
@@ -324 +321 @@
                 if (((info->access & READ_MASK) == READ_ALWAYS) &&
                     (info->get_fn != NULL)) {
-                        child = pgp_new_blob(priv->mf, info->id, info->type, info);
+                        child = pgp_new_blob(card, priv->mf, info->id, sc_file_new());
+
                         /* catch out of memory condition */
-                        if (child == NULL)
-                                break;
-                }
-        }
-
-        /* treat out of memory condition */
-        if (child == NULL) {
-                pgp_finish(card);
-                return SC_ERROR_OUT_OF_MEMORY;
-        }
-
+                        if (child == NULL) {
+                                pgp_finish(card);
+                                return SC_ERROR_OUT_OF_MEMORY;
+                        }
+                }
+        }
 
         /* get card_features from ATR & DOs */
@@ -401 +394 @@
 
                 /* get supported algorithms & key lengths from "algorithm attributes" DOs */
-                for (i = 0x00c1; i < 0x0c3; i++) {
+                for (i = 0x00c1; i <= 0x00c3; i++) {
                         unsigned long flags;
 
@@ -476 +469 @@
 /* internal: append a blob to the list of children of a given parent blob */
 static struct blob *
-pgp_new_blob(struct blob *parent, unsigned int file_id,
-                int file_type, struct do_info *info)
-{
-        sc_file_t       *file = sc_file_new();
-        struct blob     *blob, **p;
-
-        if ((blob = calloc(1, sizeof(*blob))) != NULL) {
+pgp_new_blob(sc_card_t *card, struct blob *parent, unsigned int file_id,
+                sc_file_t *file)
+{
+        struct blob *blob = NULL;
+
+        if (file == NULL)
+                return NULL;
+
+        if ((blob = calloc(1, sizeof(struct blob))) != NULL) {
+                struct pgp_priv_data *priv = DRVDATA (card);
+                struct do_info *info;
+
+                blob->file = file;
+
+                blob->file->type         = SC_FILE_TYPE_WORKING_EF; /* default */
+                blob->file->ef_structure = SC_FILE_EF_TRANSPARENT;
+                blob->file->id           = file_id;
+
+                blob->id     = file_id;
                 blob->parent = parent;
-                blob->id     = file_id;
-                blob->file   = file;
-                blob->info   = info;
-
-                file->type   = file_type;
-                file->path   = parent->file->path;
-                file->ef_structure = SC_FILE_EF_TRANSPARENT;
-                sc_append_file_id(&file->path, file_id);
-
-                for (p = &parent->files; *p; p = &(*p)->next)
-                        ;
-                *p = blob;
+
+                if (parent != NULL) {
+                        struct blob **p;
+
+                        /* set file's path = parent's path + file's id */
+                        blob->file->path = parent->file->path;
+                        sc_append_file_id(&blob->file->path, file_id);
+
+                        /* append blob to list of parent's children */
+                        for (p = &parent->files; *p != NULL; p = &(*p)->next)
+                                ;
+                        *p = blob;
+                }
+                else {
+                        u8 id_str[2];
+
+                        /* no parent: set file's path = file's id */
+                        sc_format_path(ushort2bebytes(id_str, file_id), &blob->file->path);
+                }
+
+                /* find matching DO info: set file type depending on it */
+                for (info = priv->pgp_objects; (info != NULL) && (info->id > 0); info++) {
+                        if (info->id == file_id) {
+                                blob->info = info;
+                                blob->file->type = blob->info->type;
+                                break;
+                        }
+                }
         }
 
@@ -507 +528 @@
 {
         if (blob) {
+                if (blob->parent) {
+                        struct blob **p;
+
+                        /* remove blob from list of parent's children */
+                        for (p = &blob->parent->files; *p != NULL && *p != blob; p = &(*p)->next)
+                                ;
+                        if (*p == blob)
+                                *p = blob->next;
+                }
+
                 if (blob->file)
                         sc_file_free(blob->file);
@@ -584 +615 @@
         while ((int) blob->len > (in - blob->data)) {
                 unsigned int    cla, tag, tmptag;
-                unsigned int    type = SC_FILE_TYPE_WORKING_EF;
                 size_t          len;
                 const u8        *data = in;
@@ -597 +627 @@
                 }
 
-                /* create fake file system hierarchy by
-                 * using constructed DOs as DF */
-                if (cla & SC_ASN1_TAG_CONSTRUCTED)
-                        type = SC_FILE_TYPE_DF;
-
                 /* undo ASN1's split of tag & class */
                 for (tmptag = tag; tmptag > 0x0FF; tmptag >>= 8) {
@@ -608 +633 @@
                 tag |= cla;
 
-                if ((new = pgp_new_blob(blob, tag, type, NULL)) == NULL)
+                /* create fake file system hierarchy by
+                 * using constructed DOs as DF */
+                if ((new = pgp_new_blob(card, blob, tag, sc_file_new())) == NULL)
                         return SC_ERROR_OUT_OF_MEMORY;
                 pgp_set_blob(new, data, len);
@@ -710 +737 @@
                 LOG_FUNC_RETURN(card->ctx, r);
 
-        for (k = 0, blob = blob->files; (blob != NULL) && (k + 2 <= buflen); blob = blob->next, k += 2) {
-                ushort2bebytes(buf + k, blob->id);
+        for (k = 0, blob = blob->files; blob != NULL; blob = blob->next) {
+                if (blob->info != NULL && (blob->info->access & READ_MASK) != READ_NEVER) {
+                        if (k + 2 > buflen)
+                                LOG_FUNC_RETURN(card->ctx, SC_ERROR_BUFFER_TOO_SMALL);
+
+                        ushort2bebytes(buf + k, blob->id);
+                        k += 2;
+                }
         }
 

src/libopensc/internal-winscard.h

@@ -173 +173 @@
 #define FEATURE_GET_TLV_PROPERTIES       0x12
 #define FEATURE_CCID_ESC_COMMAND         0x13
+
+/* properties returned by FEATURE_GET_TLV_PROPERTIES */
+#define PCSCv2_PART10_PROPERTY_wLcdLayout 1
+#define PCSCv2_PART10_PROPERTY_bEntryValidationCondition 2
+#define PCSCv2_PART10_PROPERTY_bTimeOut2 3
+#define PCSCv2_PART10_PROPERTY_wLcdMaxCharacters 4
+#define PCSCv2_PART10_PROPERTY_wLcdMaxLines 5
+#define PCSCv2_PART10_PROPERTY_bMinPINSize 6
+#define PCSCv2_PART10_PROPERTY_bMaxPINSize 7
+#define PCSCv2_PART10_PROPERTY_sFirmwareID 8
+#define PCSCv2_PART10_PROPERTY_bPPDUSupport 9
 
 /* structures used (but not defined) in PCSC Part 10:

src/libopensc/reader-pcsc.c

@@ -87 +87 @@
         DWORD pin_properties_ioctl;
 
+        DWORD get_tlv_properties;
+
         int locked;
 };
@@ -790 +792 @@
                 } else if (pcsc_tlv[i].tag == FEATURE_IFD_PIN_PROPERTIES) {
                         priv->pin_properties_ioctl = ntohl(pcsc_tlv[i].value);
+                } else if (pcsc_tlv[i].tag == FEATURE_GET_TLV_PROPERTIES)  {
+                        priv->get_tlv_properties = ntohl(pcsc_tlv[i].value);
                 } else {
                         sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Reader feature %02x is not supported", pcsc_tlv[i].tag);
@@ -1030 +1034 @@
         unsigned int num_watch;
         int r = SC_ERROR_INTERNAL;
+        DWORD dwtimeout;
 
         SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL);
@@ -1168 +1173 @@
                 /* Set the timeout if caller wants to time out */
                 if (timeout == -1) {
-                        timeout = INFINITE;
-                }
-
-                rv = gpriv->SCardGetStatusChange(gpriv->pcsc_wait_ctx, timeout, rgReaderStates, num_watch);
+                        dwtimeout = INFINITE;
+                }
+                else
+                        dwtimeout = timeout;
+
+                rv = gpriv->SCardGetStatusChange(gpriv->pcsc_wait_ctx, dwtimeout, rgReaderStates, num_watch);
 
                 if (rv == (LONG) SCARD_E_CANCELLED) {
@@ -1428 +1435 @@
 }
 
+/* Find a given PCSC v2 part 10 property */
+static int
+part10_find_property_by_tag(unsigned char buffer[], int length,
+        int tag_searched)
+{
+        unsigned char *p;
+        int found = 0, len, value = -1;
+
+        p = buffer;
+        while (p-buffer < length)
+        {
+                if (*p++ == tag_searched)
+                {
+                        found = 1;
+                        break;
+                }
+
+                /* go to next tag */
+                len = *p++;
+                p += len;
+        }
+
+        if (found)
+        {
+                len = *p++;
+
+                switch(len)
+                {
+                        case 1:
+                                value = *p;
+                                break;
+                        case 2:
+                                value = *p + (*(p+1)<<8);
+                                break;
+                        case 4:
+                                value = *p + (*(p+1)<<8) + (*(p+2)<<16) + (*(p+3)<<24);
+                                break;
+                        default:
+                                value = -1;
+                }
+        }
+
+        return value;
+} /* part10_find_property_by_tag */
+
+/* Make sure the pin min and max are supported by the reader
+ * and fix the values if needed */
+static int
+part10_check_pin_min_max(sc_reader_t *reader, struct sc_pin_cmd_data *data)
+{
+        int r;
+        unsigned char buffer[256];
+        size_t length = sizeof buffer;
+        struct pcsc_private_data *priv = GET_PRIV_DATA(reader);
+
+        r = pcsc_internal_transmit(reader, NULL, 0, buffer, &length,
+                priv->get_tlv_properties);
+        SC_TEST_RET(reader->ctx, SC_LOG_DEBUG_NORMAL, r,
+                "PC/SC v2 part 10: Get TLV properties failed!");
+
+        /* minimum pin size */
+        r = part10_find_property_by_tag(buffer, length,
+                PCSCv2_PART10_PROPERTY_bMinPINSize);
+        if (r >= 0)
+        {
+                unsigned int value = r;
+
+                if (data->pin1.min_length < value)
+                        data->pin1.min_length = r;
+        }
+
+        /* maximum pin size */
+        r = part10_find_property_by_tag(buffer, length,
+                PCSCv2_PART10_PROPERTY_bMaxPINSize);
+        if (r >= 0)
+        {
+                unsigned int value = r;
+
+                if (data->pin1.max_length > value)
+                        data->pin1.max_length = r;
+        }
+
+        return 0;
+}
+
 /* Do the PIN command */
 static int
@@ -1458 +1550 @@
                         return SC_ERROR_NOT_SUPPORTED;
                 }
+                part10_check_pin_min_max(reader, data);
                 r = part10_build_verify_pin_block(reader, sbuf, &scount, data);
                 ioctl = priv->verify_ioctl ? priv->verify_ioctl : priv->verify_ioctl_start;
@@ -1467 +1560 @@
                         return SC_ERROR_NOT_SUPPORTED;
                 }
+                part10_check_pin_min_max(reader, data);
                 r = part10_build_modify_pin_block(reader, sbuf, &scount, data);
                 ioctl = priv->modify_ioctl ? priv->modify_ioctl : priv->modify_ioctl_start;

src/pkcs11/opensc-pkcs11.exports

@@ -1 @@
-C_CancelFunction
-C_CloseAllSessions
-C_CloseSession
-C_CopyObject
-C_CreateObject
-C_Decrypt
-C_DecryptDigestUpdate
-C_DecryptFinal
-C_DecryptInit
-C_DecryptUpdate
-C_DecryptVerifyUpdate
-C_DeriveKey
-C_DestroyObject
-C_Digest
-C_DigestEncryptUpdate
-C_DigestFinal
-C_DigestInit
-C_DigestKey
-C_DigestUpdate
-C_Encrypt
-C_EncryptFinal
-C_EncryptInit
-C_EncryptUpdate
-C_Finalize
-C_FindObjects
-C_FindObjectsFinal
-C_FindObjectsInit
-C_GenerateKey
-C_GenerateKeyPair
-C_GenerateRandom
-C_GetAttributeValue
 C_GetFunctionList
-C_GetFunctionStatus
-C_GetInfo
-C_GetMechanismInfo
-C_GetMechanismList
-C_GetObjectSize
-C_GetOperationState
-C_GetSessionInfo
-C_GetSlotInfo
-C_GetSlotList
-C_GetTokenInfo
-C_InitPIN
-C_InitToken
-C_Initialize
-C_Login
-C_Logout
-C_OpenSession
-C_SeedRandom
-C_SetAttributeValue
-C_SetOperationState
-C_SetPIN
-C_Sign
-C_SignEncryptUpdate
-C_SignFinal
-C_SignInit
-C_SignRecover
-C_SignRecoverInit
-C_SignUpdate
-C_UnwrapKey
-C_Verify
-C_VerifyFinal
-C_VerifyInit
-C_VerifyRecover
-C_VerifyRecoverInit
-C_VerifyUpdate
-C_WaitForSlotEvent
-C_WrapKey

src/pkcs15init/pkcs15-lib.c

@@ -1066 +1066 @@
 }
 
-int
+static int
 sc_pkcs15init_encode_prvkey_content(struct sc_pkcs15_card *p15card, struct sc_pkcs15_prkey *prvkey,
                 struct sc_pkcs15_object *object)

src/tools/opensc-explorer.c

@@ -38 +38 @@
 #define DIM(v) (sizeof(v)/sizeof((v)[0]))
 
+/* type for associations of IDs to names */
+typedef struct _id2str {
+        unsigned int id;
+        const char *str;
+} id2str_t;
+
 static const char *app_name = "opensc-explorer";
 
@@ -66 +72 @@
 };
 
-static size_t hex2binary(u8 *out, size_t outlen, const char *in);
+
+/* declare functions called by user commands */
+static int do_ls(int argc, char **argv);
+static int do_cd(int argc, char **argv);
+static int do_cat(int argc, char **argv);
+static int do_info(int argc, char **argv);
+static int do_create(int argc, char **argv);
+static int do_mkdir(int argc, char **argv);
+static int do_delete(int argc, char **argv);
+static int do_verify(int argc, char **argv);
+static int do_change(int argc, char **argv);
+static int do_unblock(int argc, char **argv);
+static int do_get(int argc, char **argv);
+static int do_update_binary(int argc, char **argv);
+static int do_update_record(int argc, char **argv);
+static int do_put(int argc, char **argv);
+static int do_debug(int argc, char **argv);
+static int do_erase(int argc, char **argv);
+static int do_random(int argc, char **argv);
+static int do_get_data(int argc, char **argv);
+static int do_put_data(int argc, char **argv);
+static int do_apdu(int argc, char **argv);
+static int do_asn1(int argc, char **argv);
+static int do_help(int argc, char **argv);
+static int do_quit(int argc, char **argv);
+
 
 struct command {
+        int             (*func)(int, char **);
         const char *    name;
-        int             (*func)(int, char **);
+        const char *    args;
         const char *    help;
 };
+
+static struct command   cmds[] = {
+        { do_ls,
+                "ls",   "",
+                "list all files in the current DF"      },
+        { do_cd,
+                "cd",   "{.. | <file id> | aid:<DF name>}",
+                "change to another DF"                  },
+        { do_cat,
+                "cat",  "[<file id> | sfi:<sfi id>]"
+        ,       "print the contents of an EF"           },
+        { do_info,
+                "info", "[<file id>]",
+                "display attributes of card file"       },
+        { do_create,
+                "create",       "<file id> <size>",
+                "create a new EF"                       },
+        { do_mkdir,
+                "mkdir",        "<file id> <size>",
+                "create a new DF"                       },
+        { do_delete,
+                "delete",       "<file id>",
+                "remove an EF/DF"                       },
+        { do_delete,
+                "rm",   "<file id>",
+                "remove an EF/DF"                       },
+        { do_verify,
+                "verify",       "<key type><key ref> [<pin>]",
+                "present a PIN or key to the card"      },
+        { do_change,
+                "change",       "CHV<pin ref> [[<old pin>] <new pin>]",
+                "change a PIN"                          },
+        { do_unblock,
+                "unblock",      "CHV<pin ref> [<puk> [<new pin>]]",
+                "unblock a PIN"                         },
+        { do_put,
+                "put",  "<file id> [<input file>]",
+                "copy a local file to the card"         },
+        { do_get,
+                "get",  "<file id> [<output file>]",
+                "copy an EF to a local file"            },
+        { do_get_data,
+                "do_get",       "<hex tag> [<output file>]",
+                "get a data object"                     },
+        { do_put_data,
+                "do_put",       "<hex tag> <data>",
+                "put a data object"                     },
+        { do_erase,
+                "erase",        "",
+                "erase card"                            },
+        { do_random,
+                "random",       "<count>",
+                "obtain <count> random bytes from card" },
+        { do_update_record,
+                "update_record", "<file id> <rec no> <rec offs> <data>",
+                "update record"                         },
+        { do_update_binary,
+                "update_binary", "<file id> <offs> <data>",
+                "update binary"                         },
+        { do_apdu,
+                "apdu", "<data>+",
+                "send a custom apdu command"            },
+        { do_asn1,
+                "asn1", "[<file id>]",
+                "decode an asn1 file"                   },
+        { do_debug,
+                "debug",        "[<value>]",
+                "get/set the debug level"               },
+        { do_quit,
+                "quit", "",
+                "quit this program"                     },
+        { do_quit,
+                "exit", "",
+                "quit this program"                     },
+        { do_help,
+                "help", "",
+                "show this help"                        },
+        { NULL, NULL, NULL, NULL }
+};
+
+
+static char *path_to_filename(const sc_path_t *path, const char sep)
+{
+        static char buf[2*SC_MAX_PATH_STRING_SIZE];
+        int i, j;
+
+        for (i = 0, j = 0; path != NULL && i < path->len; i++) {
+                if (sep != '\0' && i > 0 && (i & 1) == 0)
+                        j += sprintf(buf+j, "%c", sep);
+                j += sprintf(buf+j, "%02X", path->value[i]);
+        }
+        buf[j] = 0;
+
+        return buf;
+}
+
+static int parse_string_or_hexdata(const char *in, u8 *out, size_t *outlen)
+{
+        if (in == NULL)
+                return SC_ERROR_INVALID_ARGUMENTS;
+
+        if (*in == '"') {
+                u8 quote = *in++;
+                size_t count = 0;
+
+                while (*in != quote && *in != '\0' && count < *outlen)
+                        out[count++] = *in++;
+                if (*in == '\0')
+                        return SC_ERROR_INVALID_ARGUMENTS;
+                if (count >= *outlen)
+                        return SC_ERROR_BUFFER_TOO_SMALL;
+
+                *outlen = count;
+                return 0;
+        }
+        else
+                return sc_hex_to_bin(in, out, outlen);
+}
+
+static int usage(int (*func)(int, char **))
+{
+        struct command  *cmd;
+
+        for (cmd = cmds; cmd->func; cmd++)
+                if (cmd->func == func)
+                        printf("Usage: %s %s\n", cmd->name, cmd->args);
+        return -1;
+}
 
 static void die(int ret)
@@ -131 +291 @@
                 /* DF aid */
                 const char *p = arg + strlen("aid:");
-                path->len  = hex2binary(path->value, sizeof(path->value), p);
+                int r;
+
                 path->type = SC_PATH_TYPE_DF_NAME;
+                path->len  = sizeof(path->value);
+                if ((r = sc_hex_to_bin(p, path->value, &path->len)) < 0) {
+                        printf("Error parsing AID: %s\n", p);
+                        return r;
+                }
         } else {
                 /* file id */
                 unsigned int buf[2];
                 u8 cbuf[2];
-        
+
                 if (strlen(arg) != 4) {
                         printf("Wrong ID length.\n");
@@ -151 +317 @@
                         path->len = 2;
                         memcpy(path->value, cbuf, 2);
-                        if (is_id)
-                                path->type = SC_PATH_TYPE_FILE_ID;
-                        else
-                                path->type = SC_PATH_TYPE_PATH;
+                        path->type = (is_id) ? SC_PATH_TYPE_FILE_ID : SC_PATH_TYPE_PATH;
                 } else {
                         *path = current_path;
@@ -173 +336 @@
         }
 
-        return 0;       
+        return 0;
 }
 
@@ -210 +373 @@
 
         if (argc)
-                goto usage;
+                return usage(do_ls);
+
         r = sc_list_files(card, buf, sizeof(buf));
         if (r < 0) {
@@ -231 +395 @@
                         }
                 }
-                        
+
                 r = sc_select_file(card, &path, &file);
                 if (r) {
@@ -245 +409 @@
         }
         return 0;
-usage:
-        puts("Usage: ls");
-        return -1;
 }
 
@@ -257 +418 @@
 
         if (argc != 1)
-                goto usage;
+                return usage(do_cd);
+
         if (strcmp(argv[0], "..") == 0) {
                 path = current_path;
@@ -284 +446 @@
         }
         if (arg_to_path(argv[0], &path, 0) != 0) 
-                goto usage;
+                return usage(do_cd);
 
         r = sc_select_file(card, &path, &file);
@@ -303 +465 @@
 
         return 0;
-usage:
-        puts("Usage: cd <file_id>|aid:<DF name>");
-        return -1;
 }
 
@@ -314 +473 @@
         size_t count;
         int r;
-        
+
         count = file->size;
         while (count) {
@@ -365 +524 @@
 
         if (argc > 1)
-                goto usage;
+                return usage(do_cat);
+
         if (!argc) {
                 path = current_path;
@@ -386 +546 @@
                         if ((sfi < 1) || (sfi > 30)) {
                                 printf("Invalid SFI: %s\n", sfi_n);
-                                goto usage;
+                                return usage(do_cat);
                         }
                 } else {
                         if (arg_to_path(argv[0], &path, 0) != 0)
-                                goto usage;
+                                return usage(do_cat);
+
                         r = sc_select_file(card, &path, &file);
                         if (r) {
@@ -408 +569 @@
         else
                 read_and_print_record_file(file, sfi);
-        
+
         err = 0;
-
 err:
         if (not_current) {
-                if (file != NULL) {
+                if (file != NULL)
                         sc_file_free(file);
-                }
                 select_current_path_or_die();
         }
 
         return -err;
-usage:
-        puts("Usage: cat [file_id] or");
-        puts("       cat sfi:<sfi_id>");
-        return -1;
 }
 
@@ -433 +588 @@
         const char *st;
         int r, not_current = 1;
+        const id2str_t *ac_ops = NULL;
 
         if (!argc) {
@@ -440 +596 @@
         } else if (argc == 1) {
                 if (arg_to_path(argv[0], &path, 0) != 0) 
-                        goto usage;
+                        return usage(do_info);
+
                 r = sc_select_file(card, &path, &file);
                 if (r) {
@@ -447 +604 @@
                 }
         } else 
-                goto usage;
+                return usage(do_info);
 
         switch (file->type) {
@@ -462 +619 @@
         }
         printf("\n%s  ID %04X\n\n", st, file->id);
-        printf("%-15s", "File path:");
-        for (i = 0; i < path.len; i++) {
-                for (i = 0; i < path.len; i++) {
-                        if ((i & 1) == 0 && i)
-                                printf("/");
-                        printf("%02X", path.value[i]);
-                }
-        }
-        printf("\n%-15s%lu bytes\n", "File size:", (unsigned long) file->size);
+        printf("%-15s%s\n", "File path:", path_to_filename(&path, '/'));
+        printf("%-15s%lu bytes\n", "File size:", (unsigned long) file->size);
 
         if (file->type == SC_FILE_TYPE_DF) {
-                const char *ops[] = {
-                        "SELECT", "LOCK", "DELETE", "CREATE", "REHABILITATE",
-                        "INVALIDATE", "LIST FILES", "CRYPTO", "DELETE SELF"
+                static const id2str_t ac_ops_df[] = {
+                        { SC_AC_OP_SELECT,       "SELECT"       },
+                        { SC_AC_OP_LOCK,         "LOCK"         },
+                        { SC_AC_OP_DELETE,       "DELETE"       },
+                        { SC_AC_OP_CREATE,       "CREATE"       },
+                        { SC_AC_OP_REHABILITATE, "REHABILITATE" },
+                        { SC_AC_OP_INVALIDATE,   "INVALIDATE"   },
+                        { SC_AC_OP_LIST_FILES,   "LIST FILES"   },
+                        { SC_AC_OP_CRYPTO,       "CRYPTO"       },
+                        { SC_AC_OP_DELETE_SELF,  "DELETE SELF"  },
+                        { 0, NULL }
                 };
+
                 if (file->namelen) {
                         printf("%-15s", "DF name:");
@@ -482 +641 @@
                         printf("\n");
                 }
-                for (i = 0; i < sizeof(ops)/sizeof(ops[0]); i++) {
-                        char buf[80];
-                        
-                        sprintf(buf, "ACL for %s:", ops[i]);
-                        printf("%-25s%s\n", buf, util_acl_to_str(sc_file_get_acl_entry(file, i)));
-                }
+
+                ac_ops = ac_ops_df;
         } else {
-                const char *structs[] = {
-                        "Unknown", "Transparent", "Linear fixed",
-                        "Linear fixed, SIMPLE-TLV", "Linear variable",
-                        "Linear variable TLV", "Cyclic, SIMPLE-TLV",
+                static const id2str_t ac_ops_ef[] = {
+                        { SC_AC_OP_READ,         "READ"         },
+                        { SC_AC_OP_UPDATE,       "UPDATE"       },
+                        { SC_AC_OP_DELETE,       "DELETE"       },
+                        { SC_AC_OP_WRITE,        "WRITE"        },
+                        { SC_AC_OP_REHABILITATE, "REHABILITATE" },
+                        { SC_AC_OP_INVALIDATE,   "INVALIDATE"   },
+                        { SC_AC_OP_LIST_FILES,   "LIST FILES"   },
+                        { SC_AC_OP_CRYPTO,       "CRYPTO"       },
+                        { 0, NULL }
                 };
-                const struct {
-                        const char * label;
-                        int op;
-                } ops[] = {
-                        { "READ", SC_AC_OP_READ },
-                        { "UPDATE", SC_AC_OP_UPDATE },
-                        { "DELETE", SC_AC_OP_DELETE },
-                        { "WRITE", SC_AC_OP_WRITE },
-                        { "REHABILITATE", SC_AC_OP_REHABILITATE },
-                        { "INVALIDATE", SC_AC_OP_INVALIDATE },
-                        { "LIST_FILES", SC_AC_OP_LIST_FILES },
-                        { "CRYPTO", SC_AC_OP_CRYPTO },
+                const id2str_t ef_type_name[] = {
+                        { SC_FILE_EF_TRANSPARENT,         "Transparent"                 },
+                        { SC_FILE_EF_LINEAR_FIXED,        "Linear fixed"                },
+                        { SC_FILE_EF_LINEAR_FIXED_TLV,    "Linear fixed, SIMPLE-TLV"    },
+                        { SC_FILE_EF_LINEAR_VARIABLE,     "Linear variable"             },
+                        { SC_FILE_EF_LINEAR_VARIABLE_TLV, "Linear variable, SIMPLE-TLV" },
+                        { SC_FILE_EF_CYCLIC,              "Cyclic"                      },
+                        { SC_FILE_EF_CYCLIC_TLV,          "Cyclic, SIMPLE-TLV"          },
+                        { 0, NULL }
                 };
-                printf("%-15s%s\n", "EF structure:", structs[file->ef_structure]);
-                for (i = 0; i < sizeof(ops)/sizeof(ops[0]); i++) {
-                        char buf[80];
-                        
-                        sprintf(buf, "ACL for %s:", ops[i].label);
-                        printf("%-25s%s\n", buf, util_acl_to_str(sc_file_get_acl_entry(file, ops[i].op)));
-                }
-        }       
+                const char *ef_type = "Unknown";
+
+                for (i = 0; ef_type_name[i].str != NULL; i++)
+                        if (file->ef_structure == ef_type_name[i].id)
+                                ef_type = ef_type_name[i].str;
+                printf("%-15s%s\n", "EF structure:", ef_type);
+
+                ac_ops = ac_ops_ef;
+        }
+
+        for (i = 0; ac_ops != NULL && ac_ops[i].str != NULL; i++) {
+                int len = strlen(ac_ops[i].str);
+
+                printf("ACL for %s:%*s %s\n",
+                        ac_ops[i].str,
+                        (12 > len) ? (12 - len) : 0, "",
+                        util_acl_to_str(sc_file_get_acl_entry(file, ac_ops[i].id)));
+        }
+
         if (file->prop_attr_len) {
                 printf("%-25s", "Proprietary attributes:");
-                for (i = 0; i < file->prop_attr_len; i++)
-                        printf("%02X ", file->prop_attr[i]);
+                util_hex_dump(stdout, file->prop_attr, file->prop_attr_len, " ");
                 printf("\n");
         }
         if (file->sec_attr_len) {
                 printf("%-25s", "Security attributes:");
-                for (i = 0; i < file->sec_attr_len; i++)
-                        printf("%02X ", file->sec_attr[i]);
+                util_hex_dump(stdout, file->sec_attr, file->sec_attr_len, " ");
                 printf("\n");
         }
@@ -533 +700 @@
         }
         return 0;
-
-usage:
-        puts("Usage: info [file_id]");
-        return -1;
 }
 
@@ -542 +705 @@
 {
         int r;
-        
+
         r = sc_create_file(card, file);
         if (r) {
@@ -562 +725 @@
 
         if (argc != 2)
-                goto usage;
+                return usage(do_create);
         if (arg_to_path(argv[0], &path, 1) != 0)
-                goto usage;
+                return usage(do_create);
         /* %z isn't supported everywhere */
         if (sscanf(argv[1], "%u", &size) != 1)
-                goto usage;
+                return usage(do_create);
         file = sc_file_new();
         file->id = (path.value[0] << 8) | path.value[1];
@@ -576 +739 @@
         for (op = 0; op < SC_MAX_AC_OPS; op++)
                 sc_file_add_acl_entry(file, op, SC_AC_NONE, 0);
-        
+
         r = create_file(file);
         sc_file_free(file);
         return r;
- usage:
-        printf("Usage: create <file_id> <file_size>\n");
-        return -1;
 }
 
@@ -593 +753 @@
 
         if (argc != 2)
-                goto usage;
+                return usage(do_mkdir);
         if (arg_to_path(argv[0], &path, 1) != 0)
-                goto usage;
+                return usage(do_mkdir);
         if (sscanf(argv[1], "%u", &size) != 1)
-                goto usage;
+                return usage(do_mkdir);
         file = sc_file_new();
         file->id = (path.value[0] << 8) | path.value[1];
@@ -609 +769 @@
         sc_file_free(file);
         return r;
- usage:
-        printf("Usage: mkdir <file_id> <df_size>\n");
-        return -1;
 }
 
@@ -620 +777 @@
 
         if (argc != 1)
-                goto usage;
+                return usage(do_delete);
         if (arg_to_path(argv[0], &path, 1) != 0)
-                goto usage;
+                return usage(do_delete);
         if (path.len != 2)
-                goto usage;
+                return usage(do_delete);
         path.type = SC_PATH_TYPE_FILE_ID;
         r = sc_delete_file(card, &path);
@@ -632 +789 @@
         }
         return 0;
-usage:
-        printf("Usage: delete <file_id>\n");
-        return -1;
 }
 
 static int do_verify(int argc, char **argv)
 {
-        struct {
-                const char *    name;
-                int             type;
-        } typeNames[] = {
-                { "CHV",        SC_AC_CHV       },
-                { "KEY",        SC_AC_AUT       },
-                { "AUT",        SC_AC_AUT       },
-                { "PRO",        SC_AC_PRO       },
-                { NULL,         SC_AC_NONE      }
+        const id2str_t typeNames[] = {
+                { SC_AC_CHV,    "CHV"   },
+                { SC_AC_AUT,    "KEY"   },
+                { SC_AC_AUT,    "AUT"   },
+                { SC_AC_PRO,    "PRO"   },
+                { SC_AC_NONE,   NULL,   }
         };
         int r, tries_left = -1;
         u8 buf[64];
-        const char *s;
         size_t buflen = sizeof(buf), i;
         struct sc_pin_cmd_data data;
@@ -662 +812 @@
 
         data.pin_type = SC_AC_NONE;
-        for (i = 0; typeNames[i].name; i++) {
-                if (strncasecmp(argv[0], typeNames[i].name, 3) == 0) {
-                        data.pin_type = typeNames[i].type;
+        for (i = 0; typeNames[i].str; i++) {
+                if (strncasecmp(argv[0], typeNames[i].str, 3) == 0) {
+                        data.pin_type = typeNames[i].id;
                         break;
                 }
@@ -685 +835 @@
                 data.pin1.prompt = "Please enter PIN";
                 data.flags |= SC_PIN_CMD_USE_PINPAD;
-        } else if (argv[1][0] == '"') {
-                for (s=argv[1]+1, i=0; i < sizeof(buf) && *s && *s != '"';i++) 
-                        buf[i] = *s++;
-                data.pin1.data = buf;
-                data.pin1.len = i;
         } else {
-                r = sc_hex_to_bin(argv[1], buf, &buflen); 
+                r = parse_string_or_hexdata(argv[1], buf, &buflen);
                 if (0 != r) {
                         printf("Invalid key value.\n");
@@ -714 +859 @@
         return 0;
 usage:
-        printf("Usage: verify <key type><key ref> [<key in hex>]\n");
+        printf("Usage: verify <key type><key ref> [<pin>]\n");
         printf("Possible values of <key type>:\n");
-        for (i = 0; typeNames[i].name; i++)
-                printf("\t%s\n", typeNames[i].name);
+        for (i = 0; typeNames[i].str; i++)
+                printf("\t%s\n", typeNames[i].str);
         printf("Example: verify CHV2 31:32:33:34:00:00:00:00\n");
         printf("If key is omitted, card reader's keypad will be used to collect PIN.\n");
@@ -729 +874 @@
         u8 oldpin[30];
         u8 newpin[30];
-        const char *s;
-        size_t oldpinlen = sizeof(oldpin), i;
-        size_t newpinlen = sizeof(newpin);
-        
+        size_t oldpinlen = 0;
+        size_t newpinlen = 0;
+
         if (argc < 1 || argc > 3)
                 goto usage;
@@ -743 +887 @@
                 goto usage;
         }
-        argc--;
-        argv++;
-
-        if (argc == 0) {
-                /* set without verification */
-                oldpinlen = 0;
-                newpinlen = 0;
-        } else if (argc == 1) {
-                /* set without verification */
-                oldpinlen = 0;
-        } else {
-                if (argv[0][0] == '"') {
-                        for (s = argv[0] + 1, i = 0;
-                             i < sizeof(oldpin) && *s && *s != '"'; i++) 
-                                oldpin[i] = *s++;
-                        oldpinlen = i;
-                } else if (sc_hex_to_bin(argv[0], oldpin, &oldpinlen) != 0) {
+
+        if (argc == 3) {
+                oldpinlen = sizeof(oldpin);
+                if (parse_string_or_hexdata(argv[1], oldpin, &oldpinlen) != 0) {
                         printf("Invalid key value.\n");
                         goto usage;
                 }
-                argc--;
-                argv++;
-        }
-
-        if (argc)   {
-                if (argv[0][0] == '"') {
-                        for (s = argv[0] + 1, i = 0;
-                             i < sizeof(newpin) && *s && *s != '"'; i++) 
-                                newpin[i] = *s++;
-                        newpinlen = i;
-                } else if (sc_hex_to_bin(argv[0], newpin, &newpinlen) != 0) {
+        }
+
+        if (argc >= 2) {
+                newpinlen = sizeof(newpin);
+                if (parse_string_or_hexdata(argv[argc-1], newpin, &newpinlen) != 0) {
                         printf("Invalid key value.\n");
                         goto usage;
@@ -808 +933 @@
 {
         int ref, r;
-        u8 puk_buf[30], *puk = NULL;
-        u8 newpin_buf[30], *newpin = NULL;
-        const char *s;
-        size_t puklen = sizeof(puk_buf), i;
-        size_t newpinlen = sizeof(newpin_buf);
-        
+        u8 puk[30];
+        u8 newpin[30];
+        size_t puklen = 0;
+        size_t newpinlen = 0;
+
         if (argc < 1 || argc > 3)
                 goto usage;
@@ -824 +948 @@
                 goto usage;
         }
-        argc--;
-        argv++;
-
-        if (argc == 0) {
-                puklen = 0;
-                puk = NULL;
-        } else {
-                if (argv[0][0] == '"') {
-                        for (s = argv[0] + 1, i = 0;
-                             i < sizeof(puk_buf) && *s && *s != '"'; i++) 
-                                puk_buf[i] = *s++;
-                        puklen = i;
-                } else if (sc_hex_to_bin(argv[0], puk_buf, &puklen) != 0) {
+
+        if (argc > 1) {
+                puklen = sizeof(puk);
+                if (parse_string_or_hexdata(argv[1], puk, &puklen) != 0) {
                         printf("Invalid key value.\n");
                         goto usage;
                 }
-                puk = &puk_buf[0];
-
-                argc--;
-                argv++;
-        }
-
-        if (argc)   {
-                if (argv[0][0] == '"') {
-                        for (s = argv[0] + 1, i = 0;
-                             i < sizeof(newpin_buf) && *s && *s != '"'; i++) 
-                                newpin_buf[i] = *s++;
-                        newpinlen = i;
-                } else if (sc_hex_to_bin(argv[0], newpin_buf, &newpinlen) != 0) {
+        }
+
+        if (argc > 2)   {
+                newpinlen = sizeof(newpin);
+                if (parse_string_or_hexdata(argv[2], newpin, &newpinlen) != 0) {
                         printf("Invalid key value.\n");
                         goto usage;
                 }
-
-                newpin = &newpin_buf[0];
-        }
-        else   {
-                newpinlen = 0;
-                newpin = NULL;
         }
 
         r = sc_reset_retry_counter (card, SC_AC_CHV, ref,
-                                      puk, puklen,
-                                      newpin, newpinlen);
+                                      puklen ? puk : NULL, puklen,
+                                      newpinlen ? newpin : NULL, newpinlen);
         if (r) {
                 if (r == SC_ERROR_PIN_CODE_INCORRECT)
@@ -876 +977 @@
         return 0;
 usage:
-        printf("Usage: unblock CHV<pin ref> [<puk>] [<new pin>]\n");
+        printf("Usage: unblock CHV<pin ref> [<puk> [<new pin>]]\n");
         printf("PUK and PIN values can be hexadecimal, ASCII, empty (\"\") or absent\n");
         printf("Examples:\n");
@@ -897 +998 @@
         sc_path_t path;
         sc_file_t *file = NULL;
-        char fbuf[256], *filename;
+        char *filename;
         FILE *outf = NULL;
-        
+
         if (argc < 1 || argc > 2)
-                goto usage;
+                return usage(do_get);
         if (arg_to_path(argv[0], &path, 0) != 0)
-                goto usage;
-        if (argc == 2)
-                filename = argv[1];
-        else {
-                size_t i = 0;
-
-                while (2*i < path.len) {
-                        sprintf(&fbuf[5*i], "%02X%02X_", path.value[2*i], path.value[2*i+1]);
-                        i++;
-                }
-                fbuf[5*i-1] = 0;
-                filename = fbuf;
-        }
+                return usage(do_get);
+
+        filename = (argc == 2) ? argv[1] : path_to_filename(&path, '_');
         outf = (strcmp(filename, "-") == 0)
                 ? stdout
@@ -958 +1049 @@
                        idx, argv[0], filename);
         }
-        
+
         err = 0;
 err:
@@ -967 +1058 @@
         select_current_path_or_die();
         return -err;
-usage:
-        printf("Usage: get <file id> [output file]\n");
-        return -1;
-}
-
-static size_t hex2binary(u8 *out, size_t outlen, const char *in)
-{
-        size_t      inlen = strlen(in), len = outlen;
-        const char *p = in;
-        int         s = 0;
-
-        out--;
-        while (inlen && (len || s)) {
-                char c = *p++;
-                inlen--;
-                if (!isxdigit(c))
-                        continue;
-                if (c >= '0' && c <= '9')
-                        c -= '0';
-                else if (c >= 'a' && c <= 'f')
-                        c -= 'a' - 10;
-                else /* (c >= 'A' && c <= 'F') */
-                        c -= 'A' - 10;
-                if (s)
-                        *out <<= 4;
-                else {
-                        len--;
-                        *(++out) = 0;
-                }
-                s = !s;
-                *out |= (u8)c;
-        } 
-        if (s) {
-                printf("Error: the number of hex digits must be even.\n");
-                return 0;
-        }
-
-        return outlen - len;
 }
 
@@ -1010 +1063 @@
 {
         u8 buf[240];
-        int r, err = 1, in_len;
+        size_t buflen = sizeof(buf);
+        int r, err = 1;
         int offs;
         sc_path_t path;
         sc_file_t *file;
-        char *in_str;
-        
-        if (argc < 2 || argc > 3)
-                goto usage;
+
+        if (argc != 3)
+                return usage(do_update_binary);
         if (arg_to_path(argv[0], &path, 0) != 0)
-                goto usage;
+                return usage(do_update_binary);
         offs = strtol(argv[1],NULL,10);
 
-        in_str = argv[2];
-        printf("in: %i; %s\n", offs, in_str);
-        if (*in_str=='\"')   {
-                in_len = strlen(in_str)-2 >= sizeof(buf) ? sizeof(buf)-1 : strlen(in_str)-2;
-                strncpy((char *) buf, in_str+1, in_len);
-        } else {
-                in_len = hex2binary(buf, sizeof(buf), in_str);
-                if (!in_len) {
-                        printf("unable to parse hex value\n");
-                        return -1;
-                }
-        }
-        
+        printf("in: %i; %s\n", offs, argv[2]);
+
+        r = parse_string_or_hexdata(argv[2], buf, &buflen);
+        if (r < 0) {
+                printf("unable to parse data\n");
+                return -1;
+        }
+
         r = sc_select_file(card, &path, &file);
         if (r) {
@@ -1045 +1093 @@
                 goto err;
         }
-        
-        r = sc_update_binary(card, offs, buf, in_len, 0);
+
+        r = sc_update_binary(card, offs, buf, buflen, 0);
         if (r < 0) {
                 printf("Cannot update %04X; return %i\n", file->id, r);
@@ -1056 +1104 @@
 
         err = 0;
-
 err:
         sc_file_free(file);
         select_current_path_or_die();
         return -err;
-usage:
-        printf("Usage: update <file id> offs <hex value> | <'\"' enclosed string>\n");
-        return -1;
 }
 
@@ -1069 +1113 @@
 {
         u8 buf[240];
+        size_t buflen;
         int r, i, err = 1;
         int rec, offs;
         sc_path_t path;
         sc_file_t *file;
-        char *in_str;
-        
-        if (argc < 3 || argc > 4)
-                goto usage;
+
+        if (argc != 4)
+                return usage(do_update_record);
         if (arg_to_path(argv[0], &path, 0) != 0)
-                goto usage;
+                return usage(do_update_record);
         rec  = strtol(argv[1],NULL,10);
         offs = strtol(argv[2],NULL,10);
 
-        in_str = argv[3];
-        printf("in: %i; %i; %s\n", rec, offs, in_str);
+        printf("in: %i; %i; %s\n", rec, offs, argv[3]);
 
         r = sc_select_file(card, &path, &file);
@@ -1098 +1141 @@
                 goto err;
         }
-        
+
         r = sc_read_record(card, rec, buf, sizeof(buf), SC_RECORD_BY_REC_NR);
         if (r<0)   {
@@ -1105 +1148 @@
         }
 
-        i = hex2binary(buf + offs, sizeof(buf) - offs, in_str);
+        buflen = sizeof(buf) - offs;
+        i = parse_string_or_hexdata(argv[3], buf + offs, &buflen);
         if (!i) {
-                printf("unable to parse hex value\n");
+                printf("unable to parse data\n");
                 goto err;
         }
@@ -1119 +1163 @@
         printf("Total of %d bytes written to record %i at %i offset.\n", 
                i, rec, offs);
+
         err = 0;
-
 err:
         sc_file_free(file);
         select_current_path_or_die();
         return -err;
-usage:
-        printf("Usage: update_record <file id> rec_nr rec_offs <hex value>\n");
-        return -1;
 }
 
@@ -1143 +1184 @@
 
         if (argc < 1 || argc > 2)
-                goto usage;
+                return usage(do_put);
         if (arg_to_path(argv[0], &path, 0) != 0)
-                goto usage;
-        if (argc == 2)
-                filename = argv[1];
-        else {
-                sprintf((char *) buf, "%02X%02X", path.value[0], path.value[1]);
-                filename = (char *) buf;
-        }
+                return usage(do_put);
+
+        filename = (argc == 2) ? argv[1] : path_to_filename(&path, '_');
         outf = fopen(filename, "rb");
         if (outf == NULL) {
@@ -1188 +1225 @@
 
         err = 0;
-
 err:
-
         if (file)
                 sc_file_free(file);
@@ -1197 +1232 @@
         select_current_path_or_die();
         return -err;
-usage:
-        printf("Usage: put <file id> [input file]\n");
-        return -1;
 }
 
@@ -1221 +1253 @@
 
 
-static int
-do_erase(int argc, char **argv)
+static int do_erase(int argc, char **argv)
 {
         int     r;
 
         if (argc != 0)
-                goto usage;
+                return usage(do_erase);
 
         r = sc_card_ctl(card, SC_CARDCTL_ERASE_CARD, NULL);
@@ -1235 +1266 @@
         }
         return 0;
-
-usage:
-        printf("Usage: erase\n");
-        return -1;
-}
-
-static int
-do_random(int argc, char **argv)
+}
+
+static int do_random(int argc, char **argv)
 {
         unsigned char buffer[128];
@@ -1248 +1274 @@
 
         if (argc != 1)
-                goto usage;
+                return usage(do_random);
 
         count = atoi(argv[0]);
@@ -1264 +1290 @@
         util_hex_dump_asc(stdout, buffer, count, 0);
         return 0;
-
-usage:
-        printf("Usage: random count\n");
-        return -1;
 }
 
@@ -1278 +1300 @@
 
         if (argc != 1 && argc != 2)
-                goto usage;
+                return usage(do_get_data);
 
         tag = strtoul(argv[0], NULL, 16);
@@ -1302 +1324 @@
 
         return 0;
-
-usage:  printf("Usage: do_get hex_tag [dest_file]\n");
-        return -1;
 }
 
 static int do_put_data(int argc, char **argv)
 {
-        printf("Usage: do_put hex_tag source_file\n"
-               "or:    do_put hex_tag aa:bb:cc\n"
-               "or:    do_put hex_tag \"foobar...\"\n");
-        return -1;
+        return usage(do_put_data);
 }
 
@@ -1320 +1336 @@
         u8 buf[SC_MAX_APDU_BUFFER_SIZE];
         u8 rbuf[SC_MAX_APDU_BUFFER_SIZE];
-        size_t len, len0, r, ii;
-
-        if (argc < 1) {
-                puts("Usage: apdu [apdu:hex:codes:...]");
-                return -1;
-        }
-
-        for (ii = 0, len = 0; ii < (unsigned) argc; ii++)   {
-                len0 = strlen(argv[ii]);
-                sc_hex_to_bin(argv[ii], buf + len, &len0);
+        size_t len, r, i;
+
+        if (argc < 1)
+                return usage(do_apdu);
+
+        for (i = 0, len = 0; i < (unsigned) argc; i++)   {
+                size_t len0 = strlen(argv[i]);
+
+                if ((r = parse_string_or_hexdata(argv[i], buf + len, &len0)) < 0) {
+                        fprintf(stderr, "error parsing %s: %s\n", argv[i], sc_strerror(r));
+                        return r;
+                };
                 len += len0;
         }
@@ -1343 +1361 @@
 
         printf("Sending: ");
-        for (r = 0; r < len0; r++)
-                printf("%02X ", buf[r]);
+        util_hex_dump(stdout, buf, len, " ");
         printf("\n");
         r = sc_transmit_apdu(card, &apdu);
@@ -1368 +1385 @@
         unsigned char *buf = NULL;
 
-        if (argc > 1) {
-                puts("Usage: asn1 [file_id]");
-                return -1;
-        }
+        if (argc > 1)
+                return usage(do_asn1);
 
         /* select file */
@@ -1429 +1444 @@
 }
 
+static int do_help(int argc, char **argv)
+{
+        struct command  *cmd;
+
+        if (argc)
+                return usage(do_help);
+
+        printf("Supported commands:\n");
+        for (cmd = cmds; cmd->name; cmd++) {
+                int len = strlen(cmd->name) + strlen(cmd->args);
+                printf("  %s %s%*s  %s\n",
+                        cmd->name, cmd->args,
+                        (len > 40) ? 0 : (40 - len), "",
+                        cmd->help);
+        }
+        return 0;
+}
+
 static int do_quit(int argc, char **argv)
 {
         die(0);
         return 0;
-}
-
-static struct command   cmds[] = {
- { "ls",        do_ls,          "list all files in the current DF"      },
- { "cd",        do_cd,          "change to another DF"                  },
- { "cat",       do_cat,         "print the contents of an EF"           },
- { "info",      do_info,        "display attributes of card file"       },
- { "create",    do_create,      "create a new EF"                       },
- { "delete",    do_delete,      "remove an EF/DF"                       },
- { "rm",        do_delete,      "remove an EF/DF"                       },
- { "verify",    do_verify,      "present a PIN or key to the card"      },
- { "change",    do_change,      "change a PIN"                          },
- { "unblock",   do_unblock,     "unblock a PIN"                         },
- { "put",       do_put,         "copy a local file to the card"         },
- { "get",       do_get,         "copy an EF to a local file"            },
- { "do_get",    do_get_data,    "get a data object"                     },
- { "do_put",    do_put_data,    "put a data object"                     },
- { "mkdir",     do_mkdir,       "create a DF"                           },
- { "erase",     do_erase,       "erase card"                            },
- { "random",    do_random,      "obtain N random bytes from card"       },
- { "quit",      do_quit,        "quit this program"                     },
- { "exit",      do_quit,        "quit this program"                     },
- { "update_record", do_update_record, "update record"                   },
- { "update_binary", do_update_binary, "update binary"                   },
- { "debug",     do_debug,       "set the debug level"                   },
- { "apdu",      do_apdu,        "send a custom apdu command"            },
- { "asn1",      do_asn1,        "decode an asn1 file"                   },
- { NULL, NULL, NULL }
-};
-
-static void usage(void)
-{
-        struct command  *cmd;
-
-        printf("Supported commands:\n");
-        for (cmd = cmds; cmd->name; cmd++)
-                printf("  %-16s %s\n", cmd->name, cmd->help);
 }
 
@@ -1619 +1615 @@
                 }
         }
-        
+
         r = sc_card_ctl(card, SC_CARDCTL_LIFECYCLE_SET, &lcycle);
         if (r && r != SC_ERROR_NOT_SUPPORTED)
@@ -1626 +1622 @@
         while (1) {
                 struct command *cmd;
-                size_t i;
-                char prompt[40];
-
-                sprintf(prompt, "OpenSC [");
-                for (i = 0; i < current_path.len; i++) {
-                        if ((i & 1) == 0 && i && current_path.type != SC_PATH_TYPE_DF_NAME)
-                                sprintf(prompt+strlen(prompt), "/");
-                        sprintf(prompt+strlen(prompt), "%02X",
-                                current_path.value[i]);
-                }
-                sprintf(prompt+strlen(prompt), "]> ");
+                char prompt[3*SC_MAX_PATH_STRING_SIZE];
+
+                sprintf(prompt, "OpenSC [%s]> ", path_to_filename(&current_path, '/'));
                 line = my_readline(prompt);
                 if (line == NULL)
@@ -1647 +1635 @@
                 cmd = ambiguous_match(cmds, cargv[0]);
                 if (cmd == NULL) {
-                        usage();
+                        do_help(0, NULL);
                 } else {
                         cmd->func(cargc-1, cargv+1);
@@ -1654 +1642 @@
 end:
         die(err);
-        
+
         return 0; /* not reached */
 }

src/tools/opensc-tool.c

@@ -333 +333 @@
                 break;
         case SC_FILE_TYPE_DF:
-                tmps = " DF";
+                tmps = "DF";
                 break;
         default:
@@ -339 +339 @@
                 break;
         }
-        printf("type: %-3s, ", tmps);
+        printf("type: %s, ", tmps);
         if (file->type != SC_FILE_TYPE_DF) {
                 const id2str_t ef_type_name[] = {
-                        { SC_FILE_EF_TRANSPARENT,         "transpnt"     },
-                        { SC_FILE_EF_LINEAR_FIXED,        "linrfix"      },
-                        { SC_FILE_EF_LINEAR_FIXED_TLV,    "linrfix(TLV)" },
-                        { SC_FILE_EF_LINEAR_VARIABLE,     "linvar"       },
-                        { SC_FILE_EF_LINEAR_VARIABLE_TLV, "linvar(TLV)"  },
-                        { SC_FILE_EF_CYCLIC,              "lincyc"       },
-                        { SC_FILE_EF_CYCLIC_TLV,          "lincyc(TLV)"  },
+                        { SC_FILE_EF_TRANSPARENT,         "transparent"           },
+                        { SC_FILE_EF_LINEAR_FIXED,        "linear-fixed"          },
+                        { SC_FILE_EF_LINEAR_FIXED_TLV,    "linear-fixed (TLV)"    },
+                        { SC_FILE_EF_LINEAR_VARIABLE,     "linear-variable"       },
+                        { SC_FILE_EF_LINEAR_VARIABLE_TLV, "linear-variable (TLV)" },
+                        { SC_FILE_EF_CYCLIC,              "cyclic"                },
+                        { SC_FILE_EF_CYCLIC_TLV,          "cyclic (TLV)"          },
                         { 0, NULL }
                 };