Changeset 3506 for trunk/src

Timestamp:

04/29/08 17:01:19 (9 months ago)

Author:

alonbl

Message:

Plug&Play support

This is not the best solution, but focus on smallest code change.

Changes:

1. Add detect_readers() to reader opts, this adds new readers to the end

of the readers list until list is full.

2. Add sc_ctx_detect_readers() that calls readers' detect_readers().

3. Fixup pcsc_lock() so that it reconnect to the card and report proper

error so caller may be notified if session was lost.

4. Allow context to be created without readers.

5. Call sc_ctx_detect_readers() from PKCS#11 C_GetSlotList with NULL_PTR.

6. Allow no reader at detect_card, as reader my be removed.

7. Since I broke ABI, I updated the external module version requirement

to match OpenSC version. In the future a separate version should be
maintained for each interface, this should be unrelated to the package
version.

Alon

---

svn merge -r 3480:3505 https://www.opensc-project.org/svn/opensc/branches/alonbl/pnp

M src/tools/opensc-tool.c
M src/pkcs11/pkcs11-global.c
M src/pkcs11/slot.c
M src/libopensc/reader-pcsc.c
M src/libopensc/internal-winscard.h
M src/libopensc/ctx.c
M src/libopensc/reader-ctapi.c
M src/libopensc/libopensc.exports
M src/libopensc/reader-openct.c
M src/libopensc/opensc.h

Location:

trunk/src

Files:

• libopensc/ctx.c (modified) (3 diffs)
• libopensc/internal-winscard.h (modified) (1 diff)
• libopensc/libopensc.exports (modified) (1 diff)
• libopensc/opensc.h (modified) (2 diffs)
• libopensc/reader-ctapi.c (modified) (1 diff)
• libopensc/reader-openct.c (modified) (1 diff)
• libopensc/reader-pcsc.c (modified) (8 diffs)
• pkcs11/pkcs11-global.c (modified) (1 diff)
• pkcs11/slot.c (modified) (1 diff)
• tools/opensc-tool.c (modified) (1 diff)

trunk/src/libopensc/ctx.c

@@ -355 +355 @@
         /* verify module version */
         version = modversion();
-        if (version == NULL || strncmp(version, "0.9.", strlen("0.9.")) > 0) {
+        /* XXX: We really need to have ABI version for each interface */
+        if (version == NULL || strncmp(version, PACKAGE_VERSION, strlen(PACKAGE_VERSION)) != 0) {
                 sc_error(ctx,"dynamic library '%s': invalid module version\n",libname);
                 lt_dlclose(handle);
@@ -638 +639 @@
 }
 
+int sc_ctx_detect_readers(sc_context_t *ctx)
+{
+        int i;
+
+        sc_mutex_lock(ctx, ctx->mutex);
+
+        for (i = 0; ctx->reader_drivers[i] != NULL; i++) {
+                const struct sc_reader_driver *drv = ctx->reader_drivers[i];
+
+                if (drv->ops->detect_readers != NULL)
+                        drv->ops->detect_readers(ctx, ctx->reader_drv_data[i]);
+        }
+
+        sc_mutex_unlock(ctx, ctx->mutex);
+
+        /* XXX: Do not ignore erros? */
+        return SC_SUCCESS;
+}
+
 sc_reader_t *sc_ctx_get_reader(sc_context_t *ctx, unsigned int i)
 {
@@ -725 +745 @@
         del_drvs(&opts, 0);
         del_drvs(&opts, 1);
-        if (ctx->reader_count == 0) {
-                sc_release_context(ctx);
-                return SC_ERROR_NO_READERS_FOUND;
-        }
+        sc_ctx_detect_readers(ctx);
         *ctx_out = ctx;
         return SC_SUCCESS;

trunk/src/libopensc/internal-winscard.h

@@ -52 +52 @@
 
 #define SCARD_S_SUCCESS                 0x00000000 /**< No error was encountered. */
+#define SCARD_E_INVALID_HANDLE          0x80100003 /**< The supplied handle was invalid. */
 #define SCARD_E_TIMEOUT                 0x8010000A /**< The user-specified timeout value has expired. */
 #define SCARD_E_SHARING_VIOLATION       0x8010000B /**< The smart card cannot be accessed because of other connections outstanding. */
 #define SCARD_E_NOT_TRANSACTED          0x80100016 /**< An attempt was made to end a non-existent transaction. */
+#define SCARD_E_READER_UNAVAILABLE      0x80100017 /**< The specified reader is not currently available for use. */
 #define SCARD_E_NO_READERS_AVAILABLE    0x8010002E /**< Cannot find a smart card reader. */
 #define SCARD_W_UNRESPONSIVE_CARD       0x80100066 /**< The smart card is not responding to a reset. */

trunk/src/libopensc/libopensc.exports

@@ -38 +38 @@
 sc_copy_asn1_entry
 sc_create_file
+sc_ctx_detect_readers
 sc_ctx_get_reader
 sc_ctx_get_reader_count

trunk/src/libopensc/opensc.h

@@ -374 +374 @@
          * deallocate the private data and any resources. */
         int (*finish)(struct sc_context *ctx, void *priv_data);
+        /* Called when library wish to detect new readers
+         * should add only new readers. */
+        int (*detect_readers)(struct sc_context *ctx, void *priv_data);
         /* Called when releasing a reader.  release() has to
          * deallocate the private data.  Other fields will be
@@ -726 +729 @@
  */
 int sc_release_context(sc_context_t *ctx);
+
+/**
+ * Detect new readers available on system.
+ * @param  ctx  OpenSC context
+ * @return SC_SUCCESS on success and an error code otherwise.
+ */
+int sc_ctx_detect_readers(sc_context_t *ctx);
 
 /**

trunk/src/libopensc/reader-ctapi.c

@@ -612 +612 @@
         ctapi_ops.init = ctapi_init;
         ctapi_ops.finish = ctapi_finish;
+        ctapi_ops.detect_readers = NULL;
         ctapi_ops.transmit = ctapi_transmit;
         ctapi_ops.detect_card_presence = ctapi_detect_card_presence;

trunk/src/libopensc/reader-openct.c

@@ -480 +480 @@
         openct_ops.init = openct_reader_init;
         openct_ops.finish = openct_reader_finish;
+        openct_ops.detect_readers = NULL;
         openct_ops.release = openct_reader_release;
         openct_ops.detect_card_presence = openct_reader_detect_card_presence;

trunk/src/libopensc/reader-pcsc.c

@@ -645 +645 @@
         rv = priv->gpriv->SCardBeginTransaction(pslot->pcsc_card);
 
-        if ((unsigned int)rv == SCARD_W_RESET_CARD) {
-                /* try to reconnect if the card was reset by some other application */
-                rv = pcsc_reconnect(reader, slot, 0);
-                if (rv != SCARD_S_SUCCESS) {
-                        PCSC_ERROR(reader->ctx, "SCardReconnect failed", rv);
+        switch (rv) {
+                case SCARD_E_INVALID_HANDLE:
+                case SCARD_E_READER_UNAVAILABLE:
+                        rv = pcsc_connect(reader, slot);
+                        if (rv != SCARD_S_SUCCESS) {
+                                PCSC_ERROR(reader->ctx, "SCardConnect failed", rv);
+                                return pcsc_ret_to_error(rv);
+                        }
+                        /* return failure so that upper layers will be notified and try to lock again */
+                        return SC_ERROR_READER_REATTACHED;
+                case SCARD_W_RESET_CARD:
+                        /* try to reconnect if the card was reset by some other application */
+                        rv = pcsc_reconnect(reader, slot, 0);
+                        if (rv != SCARD_S_SUCCESS) {
+                                PCSC_ERROR(reader->ctx, "SCardReconnect failed", rv);
+                                return pcsc_ret_to_error(rv);
+                        }
+                        /* return failure so that upper layers will be notified and try to lock again */
+                        return SC_ERROR_CARD_RESET;
+                case SCARD_S_SUCCESS:
+                        pslot->locked = 1;
+                        return SC_SUCCESS;
+                default:
+                        PCSC_ERROR(reader->ctx, "SCardBeginTransaction failed", rv);
                         return pcsc_ret_to_error(rv);
-                }
-                /* Now try to begin a new transaction after we reconnected and we fail if
-                 some other program was faster to lock the reader */
-                rv = priv->gpriv->SCardBeginTransaction(pslot->pcsc_card);
-        }
-
-        if (rv != SCARD_S_SUCCESS) {
-                PCSC_ERROR(reader->ctx, "SCardBeginTransaction failed", rv);
-                return pcsc_ret_to_error(rv);
-        }
-
-        pslot->locked = 1;
-        
-        return SC_SUCCESS;
+        }
 }
 
@@ -732 +738 @@
 {
         LONG rv;
-        DWORD reader_buf_size;
-        char *reader_buf = NULL, *p;
-        const char *mszGroups = NULL;
-        int r;
         struct pcsc_global_private_data *gpriv;
         scconf_block *conf_block = NULL;
@@ -754 +756 @@
         gpriv->enable_pinpad = 0;
         gpriv->provider_library = DEFAULT_PCSC_PROVIDER;
+        gpriv->pcsc_ctx = -1;
         
         conf_block = sc_get_conf_block(ctx, "reader_driver", "pcsc", 1);
@@ -819 +822 @@
         }
 
-        rv = gpriv->SCardEstablishContext(SCARD_SCOPE_USER,
-                              NULL, NULL, &gpriv->pcsc_ctx);
-        if (rv != SCARD_S_SUCCESS) {
-                ret = pcsc_ret_to_error(rv);
+        *reader_data = gpriv;
+        gpriv = NULL;
+        ret = SC_SUCCESS;
+
+out:
+        if (ret != SC_SUCCESS) {
+                if (gpriv->pcsc_ctx != 0)
+                        gpriv->SCardReleaseContext(gpriv->pcsc_ctx);
+                if (gpriv->dlhandle != NULL)
+                        lt_dlclose(gpriv->dlhandle);
+                if (gpriv != NULL)
+                        free(gpriv);
+        }
+
+        return 0;
+}
+
+static int pcsc_finish(sc_context_t *ctx, void *prv_data)
+{
+        struct pcsc_global_private_data *priv = (struct pcsc_global_private_data *) prv_data;
+
+        if (priv) {
+                priv->SCardReleaseContext(priv->pcsc_ctx);
+                lt_dlclose(priv->dlhandle);
+                free(priv);
+        }
+
+        return 0;
+}
+
+static int pcsc_detect_readers(sc_context_t *ctx, void *prv_data)
+{
+        struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *) prv_data;
+        LONG rv;
+        DWORD reader_buf_size;
+        char *reader_buf = NULL, *p;
+        const char *mszGroups = NULL;
+        int ret = SC_ERROR_INTERNAL;
+        int again;
+
+        if (!prv_data) {
+                ret = SC_ERROR_NO_READERS_FOUND;
                 goto out;
         }
-        rv = gpriv->SCardListReaders(gpriv->pcsc_ctx, NULL, NULL,
-                              (LPDWORD) &reader_buf_size);
-        if (rv != SCARD_S_SUCCESS || reader_buf_size < 2) {
-                ret = pcsc_ret_to_error(rv);    /* No readers configured */
-                goto out;
-        }
+
+        do {
+                rv = gpriv->SCardListReaders(gpriv->pcsc_ctx, NULL, NULL,
+                                      (LPDWORD) &reader_buf_size);
+                if (rv != SCARD_S_SUCCESS) {
+                        if (rv != SCARD_E_INVALID_HANDLE) {
+                                ret = pcsc_ret_to_error(rv);
+                                goto out;
+                        }
+
+                        rv = gpriv->SCardEstablishContext(SCARD_SCOPE_USER,
+                                              NULL, NULL, &gpriv->pcsc_ctx);
+                        if (rv != SCARD_S_SUCCESS) {
+                                ret = pcsc_ret_to_error(rv);
+                                goto out;
+                        }
+
+                        rv = SCARD_E_INVALID_HANDLE;
+                }
+        } while (rv != SCARD_S_SUCCESS);
 
         reader_buf = (char *) malloc(sizeof(char) * reader_buf_size);
@@ -843 +898 @@
                 goto out;
         }
-        p = reader_buf;
-        do {
-                sc_reader_t *reader = (sc_reader_t *) calloc(1, sizeof(sc_reader_t));
-                struct pcsc_private_data *priv = (struct pcsc_private_data *) malloc(sizeof(struct pcsc_private_data));
-                struct pcsc_slot_data *pslot = (struct pcsc_slot_data *) malloc(sizeof(struct pcsc_slot_data));
-                sc_slot_info_t *slot;
-
-                if (reader == NULL || priv == NULL || pslot == NULL) {
-                        if (reader)
-                                free(reader);
-                        if (priv)
-                                free(priv);
-                        if (pslot)
-                                free(pslot);
-                        break;
+        for (p = reader_buf; *p != '\x0'; p += strlen (p) + 1) {
+                sc_reader_t *reader = NULL;
+                struct pcsc_private_data *priv = NULL;
+                struct pcsc_slot_data *pslot = NULL;
+                sc_slot_info_t *slot = NULL;
+                int i;
+                int found = 0;
+
+                for (i=0;i < sc_ctx_get_reader_count (ctx) && !found;i++) {
+                        sc_reader_t *reader = sc_ctx_get_reader (ctx, i);
+                        if (reader == NULL) {
+                                ret = SC_ERROR_INTERNAL;
+                                goto err1;
+                        }
+                        if (reader->ops == &pcsc_ops && !strcmp (reader->name, p)) {
+                                found = 1;
+                        }
+                }
+
+                /* Reader already available, skip */
+                if (found) {
+                        continue;
+                }
+
+                if ((reader = (sc_reader_t *) calloc(1, sizeof(sc_reader_t))) == NULL) {
+                        ret = SC_ERROR_OUT_OF_MEMORY;
+                        goto err1;
+                }
+                if ((priv = (struct pcsc_private_data *) malloc(sizeof(struct pcsc_private_data))) == NULL) {
+                        ret = SC_ERROR_OUT_OF_MEMORY;
+                        goto err1;
+                }
+                if ((pslot = (struct pcsc_slot_data *) malloc(sizeof(struct pcsc_slot_data))) == NULL) {
+                        ret = SC_ERROR_OUT_OF_MEMORY;
+                        goto err1;
                 }
 
@@ -864 +939 @@
                 reader->driver = &pcsc_drv;
                 reader->slot_count = 1;
-                reader->name = strdup(p);
+                if ((reader->name = strdup(p)) == NULL) {
+                        ret = SC_ERROR_OUT_OF_MEMORY;
+                        goto err1;
+                }
                 priv->gpriv = gpriv;
-                priv->reader_name = strdup(p);
-                r = _sc_add_reader(ctx, reader);
-                if (r) {
-                        free(priv->reader_name);
-                        free(priv);
-                        free(reader->name);
-                        free(reader);
-                        free(pslot);
-                        break;
+                if ((priv->reader_name = strdup(p)) == NULL) {
+                        ret = SC_ERROR_OUT_OF_MEMORY;
+                        goto err1;
                 }
                 slot = &reader->slot[0];
@@ -880 +952 @@
                 slot->drv_data = pslot;
                 memset(pslot, 0, sizeof(*pslot));
+                if (_sc_add_reader(ctx, reader)) {
+                        ret = SC_SUCCESS;       /* silent ignore */
+                        goto err1;
+                }
                 refresh_slot_attributes(reader, slot);
 
-                while (*p++ != 0);
-        } while (p < (reader_buf + reader_buf_size - 1));
-
-        *reader_data = gpriv;
-        gpriv = NULL;
+                continue;
+        
+        err1:
+                if (priv != NULL) {
+                        if (priv->reader_name)
+                                free(priv->reader_name);
+                        free(priv);
+                }
+                if (reader != NULL) {
+                        if (reader->name)
+                                free(reader->name);
+                        free(reader);
+                }
+                if (slot != NULL)
+                        free(pslot);
+
+                goto out;
+        }
+
         ret = SC_SUCCESS;
 
 out:
-        if (ret != SC_SUCCESS) {
-                if (gpriv->pcsc_ctx != 0)
-                        gpriv->SCardReleaseContext(gpriv->pcsc_ctx);
-                if (reader_buf != NULL)
-                        free(reader_buf);
-                if (gpriv->dlhandle != NULL)
-                        lt_dlclose(gpriv->dlhandle);
-                if (gpriv != NULL)
-                        free(gpriv);
-        }
-
-        return 0;
-}
-
-static int pcsc_finish(sc_context_t *ctx, void *prv_data)
-{
-        struct pcsc_global_private_data *priv = (struct pcsc_global_private_data *) prv_data;
-
-        if (priv) {
-                priv->SCardReleaseContext(priv->pcsc_ctx);
-                lt_dlclose(priv->dlhandle);
-                free(priv);
-        }
-
-        return 0;
+
+        if (reader_buf != NULL)
+                free (reader_buf);
+
+        return ret;
 }
 
@@ -932 +1002 @@
         pcsc_ops.init = pcsc_init;
         pcsc_ops.finish = pcsc_finish;
+        pcsc_ops.detect_readers = pcsc_detect_readers;
         pcsc_ops.transmit = pcsc_transmit;
         pcsc_ops.detect_card_presence = pcsc_detect_card_presence;

trunk/src/pkcs11/pkcs11-global.c

@@ -348 +348 @@
 
         sc_debug(context, "Getting slot listing\n");
+        if (pSlotList == NULL_PTR) {
+                sc_ctx_detect_readers(context);
+        }
         card_detect_all();
 

trunk/src/pkcs11/slot.c

@@ -87 +87 @@
 
                 if (rdr == NULL)
-                        return CKR_GENERAL_ERROR;
+                        return CKR_TOKEN_NOT_PRESENT;
                 slot = virtual_slots + card->first_slot + i;
                 strcpy_bp(slot->slot_info.slotDescription, rdr->name, 64);

trunk/src/tools/opensc-tool.c

@@ -247 +247 @@
         
         if (rcount == 0) {
-                printf("No readers configured!\n");
+                printf("No readers found.\n");
                 return 0;
         }