Changeset 3481

Timestamp:

04/20/08 11:59:23 (6 months ago)

Author:

alonbl

Message:

Initial Plug&Play support

Add detect_readers() to reader opts.
Add sc_ctx_detect_readers() that calls readers' detect_readers().
Allow context to be created without readers.
Call sc_ctx_detect_readers() from PKCS#11 C_GetSlotList with NULL_PTR.

Since I broke ABI, I updated the external module version requirement
to match OpenSC version. In the future a separate version should be
maintaind for each interface, this should be unrelated to the package
version.

Location:

branches/alonbl/pnp/src

Files:

• libopensc/ctx.c (modified) (3 diffs)
• libopensc/libopensc.exports (modified) (1 diff)
• libopensc/opensc.h (modified) (2 diffs)
• libopensc/reader-ctapi.c (modified) (1 diff)
• libopensc/reader-openct.c (modified) (2 diffs)
• libopensc/reader-pcsc.c (modified) (6 diffs)
• pkcs11/pkcs11-global.c (modified) (1 diff)

branches/alonbl/pnp/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;

branches/alonbl/pnp/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

branches/alonbl/pnp/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);
 
 /**

branches/alonbl/pnp/src/libopensc/reader-ctapi.c

@@ -608 +608 @@
 }
 
+static int ctapi_detect_readers(sc_context_t *ctx, void *prv_data)
+{
+        return 0;
+}
+
 struct sc_reader_driver * sc_get_ctapi_driver(void)
 {
         ctapi_ops.init = ctapi_init;
         ctapi_ops.finish = ctapi_finish;
+        ctapi_ops.detect_readers = ctapi_detect_readers;
         ctapi_ops.transmit = ctapi_transmit;
         ctapi_ops.detect_card_presence = ctapi_detect_card_presence;

branches/alonbl/pnp/src/libopensc/reader-openct.c

@@ -167 +167 @@
 
 /*
+ * We do not support Plug&Play here
+ */
+static int openct_reader_detect_readers(sc_context_t *ctx, void *priv_data)
+{
+        return SC_NO_ERROR;
+}
+
+/*
  * Called when releasing a reader.  release() has to
  * deallocate the private data.  Other fields will be
@@ -480 +488 @@
         openct_ops.init = openct_reader_init;
         openct_ops.finish = openct_reader_finish;
+        openct_ops.detect_readers = openct_reader_detect_readers;
         openct_ops.release = openct_reader_release;
         openct_ops.detect_card_presence = openct_reader_detect_card_presence;

branches/alonbl/pnp/src/libopensc/reader-pcsc.c

@@ -732 +732 @@
 {
         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;
@@ -825 +821 @@
                 goto out;
         }
+
+        *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;
+
         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 */
+        if (rv != SCARD_S_SUCCESS) {
+                ret = pcsc_ret_to_error(rv);
                 goto out;
         }
@@ -843 +879 @@
                 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 +920 @@
                 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 +933 @@
                 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 +983 @@
         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;

branches/alonbl/pnp/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();