Ticket #128: new_piv.patch

src/libopensc/compression.c

@@ +1 @@
+/*
+ * compression.c: Generic wrapper for compression of data
+ *
+ * Copyright (C) 2006, Identity Alliance, Thomas Harning <thomas.harning@identityalliance.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include "compression.h"
+
+#include <zlib.h>
+#include <memory.h>
+#include <stdlib.h>
+#include "errors.h"
+
+static int zerr_to_opensc(int err) {
+        switch(err) {
+        case Z_OK:
+        case Z_STREAM_END:
+                return SC_SUCCESS;
+        case Z_UNKNOWN:
+                return SC_ERROR_UNKNOWN;
+        case Z_BUF_ERROR:
+        case Z_MEM_ERROR:
+                return SC_ERROR_MEMORY_FAILURE;
+        case Z_VERSION_ERROR:
+        case Z_DATA_ERROR:
+        case Z_STREAM_ERROR:
+        //case Z_NEED_DICT:
+        default:
+                return SC_ERROR_INTERNAL;
+        }
+}
+static int detect_method(const u8* in, size_t inLen) {
+        if(inLen > 2 && in[0] == 0x1f && in[1] == 0x8b) { /* GZIP */
+                return COMPRESSION_GZIP;
+        } else if(inLen > 1 /*&& (in[0] & 0x10) == Z_DEFLATED*/) {
+                /* REALLY SIMPLE ZLIB TEST -- 
+                 * Check for the compression method to be set to 8...
+                 * many things can spoof this, but this is ok for now
+                 * */
+                return COMPRESSION_ZLIB;
+        } else {
+                return COMPRESSION_UNKNOWN;
+        }
+}
+
+static int do_decompress_gzip(u8* out, size_t* outLen, const u8* in, size_t inLen) {
+        /* Since uncompress does not offer a way to make it uncompress gzip... manually set it up */
+        z_stream gz;
+        int err;
+        int window_size = 15 + 0x20;
+        memset(&gz, 0, sizeof(gz));
+
+        gz.next_in = (u8*)in;
+        gz.avail_in = inLen;
+        gz.next_out = out;
+        gz.avail_out = *outLen;
+
+        err = inflateInit2(&gz, window_size);
+        if(err != Z_OK) return zerr_to_opensc(err);
+        err = inflate(&gz, Z_FINISH);
+        if(err != Z_STREAM_END) {
+                inflateEnd(&gz);
+                return zerr_to_opensc(err);
+        }
+        *outLen = gz.total_out;
+
+        err = inflateEnd(&gz);
+        return zerr_to_opensc(err);     
+}
+
+int do_decompress(u8* out, size_t* outLen, const u8* in, size_t inLen, int method) {
+        if(method == COMPRESSION_AUTO) {
+                method = detect_method(in, inLen);
+                if(method == COMPRESSION_UNKNOWN) {
+                        return SC_ERROR_UNKNOWN_DATA_RECEIVED;
+                }
+        }
+        switch(method) {
+        case COMPRESSION_ZLIB:
+                return zerr_to_opensc(uncompress(out, outLen, in, inLen));
+        case COMPRESSION_GZIP:
+                return do_decompress_gzip(out, outLen, in, inLen);
+        default:
+                return SC_ERROR_INVALID_ARGUMENTS;
+        }
+}
+
+static int do_decompress_zlib_alloc(u8** out, size_t* outLen, const u8* in, size_t inLen, int gzip) {
+        /* Since uncompress does not offer a way to make it uncompress gzip... manually set it up */
+        z_stream gz;
+        int err;
+        int window_size = 15;
+        const int startSize = inLen < 1024 ? 2048 : inLen * 2;
+        const int blockSize = inLen < 1024 ? 512 : inLen / 2;
+        int bufferSize = startSize;
+        if(gzip)
+                window_size += 0x20;
+        memset(&gz, 0, sizeof(gz));
+        
+        gz.next_in = (u8*)in;
+        gz.avail_in = inLen;
+
+        err = inflateInit2(&gz, window_size);
+        if(err != Z_OK) return zerr_to_opensc(err);
+
+        *outLen = 0;
+
+        while(1) {
+                /* Setup buffer... */
+                int num;
+                u8* buf = realloc(*out, bufferSize);
+                if(!buf) {
+                        if(*out)
+                                free(*out);
+                        *out = NULL;
+                        return Z_MEM_ERROR;
+                }
+                *out = buf;
+                gz.next_out = buf + *outLen;
+                gz.avail_out = bufferSize - *outLen;
+
+                err = inflate(&gz, Z_FULL_FLUSH);
+                if(err != Z_STREAM_END && err != Z_OK) {
+                        if(*out)
+                                free(*out);
+                        *out = NULL;
+                        break;
+                }
+                num = bufferSize - *outLen - gz.avail_out;
+                if(num > 0) {
+                        *outLen += num;
+                        bufferSize += num + blockSize;
+                }
+                if(err == Z_STREAM_END) {
+                        buf = realloc(buf, *outLen); /* Shrink it down, if it fails, just use old data */
+                        if(buf) {
+                                *out = buf;
+                        }
+                        break;
+                }
+        }
+        inflateEnd(&gz);
+        return zerr_to_opensc(err);
+}
+int do_decompress_alloc(u8** out, size_t* outLen, const u8* in, size_t inLen, int method) {
+        if(method == COMPRESSION_AUTO) {
+                method = detect_method(in, inLen);
+                if(method == COMPRESSION_UNKNOWN) {
+                        return SC_ERROR_UNKNOWN_DATA_RECEIVED;
+                }
+        }
+        switch(method) {
+        case COMPRESSION_ZLIB:
+                return do_decompress_zlib_alloc(out, outLen, in, inLen, 0);
+        case COMPRESSION_GZIP:
+                return do_decompress_zlib_alloc(out, outLen, in, inLen, 1);
+        default:
+                return SC_ERROR_INVALID_ARGUMENTS;
+        }
+}

src/libopensc/card-piv.c

@@ -4 +4 @@
  *
  * Copyright (C) 2001, 2002  Juha YrjölÀ <juha.yrjola@iki.fi>
  * Copyright (C) 2005, Douglas E. Engert <deengert@anl.gov>
+ * Copyright (C) 2006, Identity Alliance, Thomas Harning <thomas.harning@identityalliance.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -29 +30 @@
 #include <openssl/rsa.h>
 #include "asn1.h"
 #include "cardctl.h"
+#include "compression.h"
 
-struct piv_private_data {
+typedef struct {
+        u8* data;
+        size_t length;
+        int enumtag;
+} piv_cache_item;
+
+typedef struct piv_private_data {
         struct sc_pin_cmd_pin pin_info;
         sc_file_t *aid_file;
         int enumtag;
@@ -39 +47 @@
         size_t max_recv_size; /* saved size, need to lie to pkcs15_read_file */
         size_t max_send_size; 
         int key_ref; /* saved from set_security_env and */
-        int alg_id;  /* used in decrypy, signature */ 
-};
+        int alg_id;  /* used in decrypt, signature */ 
+        piv_cache_item* cache;
+        int cacheLen;
+        piv_cache_item* current_item;
+} piv_private_data_t;
 
+#define PIV_DATA(card) ((piv_private_data_t*)card->drv_data)
+
+static int add_cache_item(piv_private_data_t* priv, int enumtag, u8* data, size_t length) {
+        int idx, len = priv->cacheLen;
+        piv_cache_item* cache = priv->cache;
+        for(idx = 0; idx < len; idx++) {
+                if(!cache[idx].data)
+                        break;
+                if(cache[idx].enumtag == enumtag) /* Found matching tag */
+                        break;
+        }
+        if(idx == len) 
+                return -1; /* FAILED NO FREE ROOM */
+        if(cache[idx].data)
+                free(cache[idx].data);
+        cache[idx].data = data;
+        cache[idx].length = length;
+        cache[idx].enumtag = enumtag;
+        return 0;
+}
+
+static piv_cache_item* get_cache_item(piv_private_data_t* priv, int enumtag) {
+        int idx, len = priv->cacheLen;
+        piv_cache_item* cache = priv->cache;
+        for(idx = 0; idx < len; idx++) {
+                if(cache[idx].enumtag == enumtag)
+                        return &cache[idx];
+        }
+        return NULL;
+}
+
+static void free_cache_items(piv_private_data_t* priv) {
+        int idx, len = priv->cacheLen;
+        piv_cache_item* cache = priv->cache;
+        for(idx = 0; idx < len; idx++) {
+                if(cache[idx].data) {
+                        free(cache[idx].data);
+                        cache[idx].data = NULL;
+                }
+        }
+}
+
 struct piv_aid {
         int enumtag;
         size_t len_short;       /* min lenght without version */
@@ -71 +124 @@
         PIV_OBJ_X509_CARD_AUTH,
         PIV_OBJ_SEC_OBJ,
         PIV_OBJ_9B03,
-        PIV_OBJ_9A06
+        PIV_OBJ_9A06,
+        PIV_CACHE_SIZE
 };
 
 struct piv_object {
@@ -88 +142 @@
         { PIV_OBJ_CCC, "Card Capability Container", 
                         "2.16.840.1.101.3.7.1.219.0", 3, "\x5F\xC1\x07", "\xDB\x00", 266},
         { PIV_OBJ_CHUI, "Card Holder Unique Identifier", 
-                        "2.16.840.1.101.3.7.2.48.0", 3, "\x5F\xC1\x02", "\x30\x00", 3377},
+                        "2.16.840.1.101.3.7.2.48.0", 3, "\x5F\xC1\x02", "\x30\x00", 3379}, /* Updated per SP800-73-1 Errata */
         { PIV_OBJ_X509_PIV_AUTH, "X.509 Certificate for PIV Authentication", 
                         "2.16.840.1.101.3.7.2.1.1", 3, "\x5F\xC1\x05", "\x01\x01", 1856+4+400} , 
                 /* extra 400 is hack for MultOS card which returns 2200 bytes  */
-        { PIV_OBJ_CHF1, "Card Holder Fingerprint I",
-                        "2.16.840.1.101.3.7.2.96.16", 3, "\x5F\xC1\x03", "\x60\x01", 7768},
-        { PIV_OBJ_CHF2, "Card Holder Fingerprint II",
-                        "2.16.840.1.101.3.7.2.96.17", 3, "\x5F\xC1\x04", "\x60\x11", 7768},
+        { PIV_OBJ_CHF1, "Card Holder Fingerprints",
+                        "2.16.840.1.101.3.7.2.96.16", 3, "\x5F\xC1\x03", "\x60\x10", 7768},
         { PIV_OBJ_PI, "Printed Information", 
                         "2.16.840.1.101.3.7.2.48.1", 3, "\x5F\xC1\x09", "\x30\x01", 106},
         { PIV_OBJ_CHFI, "Card Holder Facial Image",
@@ -184 +236 @@
         const u8 * sendbuf, size_t sendbuflen, u8 ** recvbuf,
         size_t * recvbuflen)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = PIV_DATA(card);
         int r;
         sc_apdu_t apdu;
         u8 rbufinitbuf[20000]; /* crude way to do this  see above comments */
@@ -502 +554 @@
 static int piv_get_data(sc_card_t * card, unsigned int enumtag, 
                         u8 **buf, size_t *buf_len)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = PIV_DATA(card);
         u8 *p;
         int r = 0;
         u8 tagbuf[8];
         size_t tag_len;
-                
+        
         SC_FUNC_CALLED(card->ctx,1);
         sc_debug(card->ctx, "get_data: tag=%d \n", enumtag);
 
@@ -599 +651 @@
 
         SC_FUNC_RETURN(card->ctx, 1, r);
 }
-          
+
+
+static int piv_handle_certificate_data(sc_card_t *card,
+                int enumtag,
+                unsigned idx, u8* buf, size_t count,
+                u8* data, size_t length) {
+        piv_private_data_t * priv = PIV_DATA(card);
+        u8* tag;
+        size_t taglen;
+        int compressed = 0;
+        piv_cache_item* item;
+        /* get the certificate out */
+        tag = (u8 *) sc_asn1_find_tag(card->ctx, data, length, 0x71, &taglen);
+        if (tag && (((*tag) & 0x80) || ((*tag) & 0x01))) {
+                compressed = 1;
+        }
+        tag = (u8 *) sc_asn1_find_tag(card->ctx, data,  length, 0x70, &taglen);
+        if (tag == NULL) {
+                return SC_ERROR_OBJECT_NOT_VALID;
+        }
+        /* Potential truncation */
+        if(compressed) {
+                size_t len = count;
+                u8* newBuf = NULL;
+                if(SC_SUCCESS != do_decompress_alloc(&newBuf, &len, tag, taglen, COMPRESSION_AUTO)) {
+                        return SC_ERROR_OBJECT_NOT_VALID;
+                } else {
+                        if(len < count + idx)
+                                count = len - idx;
+                        if(count <= 0)
+                                return 0;
+                        memcpy(buf, newBuf + idx, count);
+                        if(0 != add_cache_item(priv, enumtag, newBuf, len)) {
+                                /* Failed to cache item */
+                                free(newBuf);
+                        }
+                        priv->current_item = get_cache_item(priv, enumtag);
+                }
+                return count;
+        }
+        if(taglen < count + idx)
+                count = taglen - idx;
+        if(count <= 0)
+                return 0;
+        memcpy(buf, tag, count);
+        if(0 == add_cache_item(priv, enumtag, NULL, 0)) {
+                /* Space available in the cache array, use it */
+                item = get_cache_item(priv, enumtag);
+                if(item) {
+                        item->data = malloc(taglen);
+                        if(item->data) {
+                                item->length = taglen;
+                                memcpy(item->data, tag, taglen);
+                        }
+                        priv->current_item = item;
+                }
+        }
+        return count;
+}
+
+static int piv_handle_data(sc_card_t *card, int enumtag, 
+                unsigned idx, u8* buf, size_t count, u8* data, size_t length) {
+        /* For now get the first tag, and return the data */
+        piv_private_data_t * priv = PIV_DATA(card);
+        u8* tag;
+        size_t taglen;
+        piv_cache_item* item;
+
+        tag = (u8 *) sc_asn1_find_tag(card->ctx, data,  length, *data, &taglen);
+        if (tag == NULL) {
+                return SC_ERROR_OBJECT_NOT_VALID;
+        }
+        if(taglen < count + idx)
+                count = taglen - idx;
+        if(count <= 0)
+                return 0;
+        memcpy(buf, tag + idx, count);
+        if(0 == add_cache_item(priv, enumtag, NULL, 0)) {
+                item = get_cache_item(priv, enumtag);
+                if(item) {
+                        item->data = malloc(taglen);
+                        if(item->data) {
+                                item->length = taglen;
+                                memcpy(item->data, tag, taglen);
+                        }
+                        priv->current_item = item;
+                }
+        }
+        return count;
+}
 /* 
  * Callers of this are expecting a file without tags,
  * So we need to know what type of file this is, so we can get the
@@ -609 +750 @@
 static int piv_read_binary(sc_card_t *card, unsigned int idx,
                 unsigned char *buf, size_t count, unsigned long flags)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = PIV_DATA(card);
+        piv_cache_item* item = NULL;
+        int enumtag;
         int r;
         u8 *rbuf = NULL;
         size_t rbuflen = 0;
-        u8 *tag;
-        size_t taglen;
         u8 *body;
         size_t bodylen;
 
         SC_FUNC_CALLED(card->ctx,1);
         if (priv->selected_obj < 0) 
                  SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_INTERNAL);
+        enumtag = piv_objects[priv->selected_obj].enumtag;
 
+        /* Hit the cache */
+        if(priv->current_item) {
+                item = priv->current_item;
+                if(idx + count > item->length) {
+                        count = item->length - idx;
+                }
+                if(count <= 0)
+                        return 0;
+                memcpy(buf, item->data + idx, count);
+                return count;
+        }
+
         if (priv->eof == 1)
                 return 0;
 
@@ -629 +783 @@
         
         if (r >=0) {
                 /* if tag is 0, assume card is telling us no object on card */
-                if (rbuf[0] == '0') {
+                if (!rbuf || rbuf[0] == '0') {
                         r = SC_ERROR_FILE_NOT_FOUND;
                         goto err;
                 }
@@ -639 +793 @@
                         /* if missing, assume its the body */
                         /* DEE bug in the beta card */
                         sc_debug(card->ctx," ***** tag 0x53 MISSING \n");
-                        body =  rbuf;
-                        bodylen = rbuflen;
-#if 0
                         r = SC_ERROR_INVALID_DATA;
                         goto err;
-#endif
                 }
-                switch (piv_objects[priv->selected_obj].enumtag) {
+                switch (enumtag) {
                         case PIV_OBJ_X509_PIV_AUTH:
                         case PIV_OBJ_X509_DS:
                         case PIV_OBJ_X509_KM:
                         case PIV_OBJ_X509_CARD_AUTH:
-                                /* get the certificate out */
-                                tag = (u8 *) sc_asn1_find_tag(card->ctx, body,  bodylen, 0x70, &taglen);
-                                if (tag == NULL) {
-                                        r = SC_ERROR_OBJECT_NOT_VALID;
-                                        break;
-                                }
-                                memcpy(buf, tag, taglen); /*DEE should check lengths */
-                                r = taglen;
-                                tag = (u8 *) sc_asn1_find_tag(card->ctx, body,  bodylen, 0x71, &taglen);
-                                if (tag && ((*tag) & 0x80)) {
-                                        sc_debug(card->ctx,0,"Cert is gziped! %0x2.2x\n",*tag);
-                                }
+                                r = piv_handle_certificate_data(card, enumtag, idx, buf, count, body, bodylen);
                                 break;
                         default:
-                                /* For now get the first tag, and return the data */
-                                tag = (u8 *) sc_asn1_find_tag(card->ctx, body,  bodylen, *body, &taglen);
-                                if (tag == NULL) {
-                                        r = SC_ERROR_OBJECT_NOT_VALID;
-                                        break;
-                                }
-                                memcpy(buf, tag, taglen); /*DEE should check lengths */
-                                r = taglen;
+                                r = piv_handle_data(card, enumtag, idx, buf, count, body, bodylen);
                                 break;
                 }
         }
@@ -720 +852 @@
         SC_FUNC_RETURN(card->ctx, 1, r);
 }
 
+static int piv_write_certificate(sc_card_t *card,
+                unsigned idx, const u8* buf, size_t count) {
+        piv_private_data_t * priv = PIV_DATA(card);
+        int r = SC_SUCCESS;
+        u8 *sbuf = NULL;
+        u8 *p;
+        size_t sbuflen;
+        size_t taglen;
 
+        sc_debug(card->ctx,"DEE cert len=%d",count);
+        taglen = put_tag_and_len(0x70, count, NULL) 
+                + put_tag_and_len(0x71, 1, NULL);
+
+        sbuflen =  put_tag_and_len(0x53, taglen, NULL);
+
+        sbuf = (u8*) malloc(sbuflen);
+        if (sbuf == NULL) 
+                SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_OUT_OF_MEMORY);
+        p = sbuf;
+        put_tag_and_len(0x53, taglen, &p);
+
+        put_tag_and_len(0x70, count, &p);
+        memcpy(p, buf, count);
+        p += count;
+        put_tag_and_len(0x71, 1, &p);
+        *p++ = 0x00; /* certinfo, i.e. not gziped */
+        sc_debug(card->ctx,"DEE buf %p len %d %d", sbuf, p -sbuf, sbuflen);
+
+        r = piv_put_data(card, priv->selected_obj, sbuf, sbuflen);
+        if (sbuf)
+                free(sbuf);
+
+        return r;
+}
 /* 
  * We need to add the 0x53 tag and other specific tags, 
  * and call the piv_put_data 
@@ -730 +895 @@
 static int piv_write_binary(sc_card_t *card, unsigned int idx,
                 const u8 *buf, size_t count, unsigned long flags)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
-        int r = 0;
-        u8 *sbuf = NULL;
-        u8 *p;
-        size_t sbuflen;
-        size_t taglen;
-        
+        piv_private_data_t * priv = PIV_DATA(card);
+        /* TODO: Add cache hooks */     
         SC_FUNC_CALLED(card->ctx,1);
 
         if (priv->selected_obj < 0)
@@ -749 +909 @@
                 case PIV_OBJ_X509_DS:
                 case PIV_OBJ_X509_KM:
                 case PIV_OBJ_X509_CARD_AUTH:
-                sc_debug(card->ctx,"DEE cert len=%d",count);
-                
-                        taglen = put_tag_and_len(0x70, count, NULL) 
-                                + put_tag_and_len(0x71, 1, NULL);
-
-                        sbuflen =  put_tag_and_len(0x53, taglen, NULL);
-
-                        sbuf = (u8*) malloc(sbuflen);
-                        if (sbuf == NULL) 
-                                SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_OUT_OF_MEMORY);
-                        p = sbuf;
-                        put_tag_and_len(0x53, taglen, &p);
-
-                        put_tag_and_len(0x70, count, &p);
-                        memcpy(p, buf, count);
-                        p += count;
-                        put_tag_and_len(0x71, 1, &p);
-                        *p++ = 0x00; /* certinfo, i.e. not gziped */
-                        sc_debug(card->ctx,"DEE buf %p len %d %d", sbuf, p -sbuf, sbuflen);
-                        break;
-                        
+                        SC_FUNC_RETURN(card->ctx, 1, piv_write_certificate(card, idx, buf, count));
                 default:
                 sc_debug(card->ctx, "Don't know how to write object %s\n",
                         piv_objects[priv->selected_obj].name);
-                        r = SC_ERROR_NOT_SUPPORTED;
-                        break;
+                        SC_FUNC_RETURN(card->ctx, 1, SC_ERROR_NOT_SUPPORTED);
         }
-
-        if (r == 0) 
-                r = piv_put_data(card, priv->selected_obj, sbuf, sbuflen);
-        if (sbuf)
-                free(sbuf);
-
-        SC_FUNC_RETURN(card->ctx, 1, r);
 }
 
 /*
@@ -955 +1087 @@
 static int piv_general_external_authenticate(sc_card_t *card, 
                 unsigned int key_ref, unsigned int alg_id)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = PIV_DATA(card);
         int r;
         u8  *rbuf = NULL;
         size_t rbuflen;
@@ -1049 +1181 @@
                         return piv_generate_key(card, 
                                 (struct sc_cardctl_cryptoflex_genkey_info *) ptr);
                         break;
+                case SC_CARDCTL_PIV_GET_FULL_DATA: {
+                        int ret;
+                        piv_private_data_t * priv = PIV_DATA(card);
+                        sc_cardctl_piv_get_full_data_t* data = (sc_cardctl_piv_get_full_data_t*)ptr;
+                        /* Clear out the data so that failure returns leave data in a clean state */
+                        memset(data, 0, sizeof(sc_cardctl_piv_get_full_data_t));
+                        /* Make sure the cache item is fresh */
+                        {
+                                /* In order for sc_read_binary to actually call into the card, 1 byte must be read... */
+                                u8 buf[1];
+                                ret = sc_read_binary(card, 0, buf, 1, 0);
+                                if(ret < 0) return ret;
+                        }
+                        /* No cached item or the cached item is forcibly marked as non-existent */
+                        if(!priv->current_item || priv->current_item->length == -1) 
+                                return SC_ERROR_FILE_NOT_FOUND;
+                        data->buf = priv->current_item->data;
+                        data->length = priv->current_item->length;
+                        data->should_free = 0;
+                        return SC_SUCCESS;
+                }
         }
 
         return SC_ERROR_NOT_SUPPORTED;
@@ -1108 +1261 @@
                     const sc_security_env_t *env,
                     int se_num)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = (piv_private_data_t *) card->drv_data;
         
         SC_FUNC_CALLED(card->ctx,1);
 
@@ -1138 +1291 @@
                                         const u8 * data, size_t datalen,
                                         u8 * out, size_t outlen)
 {
-        struct piv_private_data * priv = (struct piv_private_data *) card->drv_data;
+        piv_private_data_t * priv = (piv_private_data_t *) card->drv_data;
         int r;
         u8 *p;
         u8 *tag;
@@ -1227 +1380 @@
 static int piv_select_file(sc_card_t *card, const sc_path_t *in_path,
         sc_file_t **file_out)
 {
-        str