From 72d961beb235628e58ca254be691816eab7af6bc Mon Sep 17 00:00:00 2001 From: martin Date: Sat, 11 Sep 2010 13:00:47 +0000 Subject: [PATCH] Fix #216: initial go with multiple reader subsystem removal. * One sc_context has only a single reader driver. * remove dynamic reader driver loading capabilities * remove opensc-tool -R command * change the internal API, we don't need to pass around a "driver data" pointer as it can be found directly from the context. * check in ./configure for only a single enabled reader driver git-svn-id: https://www.opensc-project.org/svnp/opensc/trunk@4709 c6295689-39f2-0310-b995-f0e70906c6a9 --- configure.ac | 10 +- doc/tools/opensc-tool.xml | 4 - etc/opensc.conf.in | 21 +-- src/libopensc/ctx.c | 243 +++++++++------------------------- src/libopensc/opensc.h | 19 ++- src/libopensc/reader-ctapi.c | 8 +- src/libopensc/reader-openct.c | 8 +- src/libopensc/reader-pcsc.c | 23 ++-- src/tools/opensc-tool.c | 32 +---- 9 files changed, 105 insertions(+), 263 deletions(-) diff --git a/configure.ac b/configure.ac index c090ca73..45d96b04 100644 --- a/configure.ac +++ b/configure.ac @@ -205,7 +205,15 @@ AC_ARG_WITH( , [with_pcsc_provider="detect"] ) - +dnl ./configure check +reader_count="" +for rdriver in "${enable_pcsc}" "${enable_openct}" "${enable_ctapi}"; do + test "${rdriver}" = "yes" && reader_count="${reader_count}x" +done +if test "${reader_count}" != "x"; then + AC_MSG_ERROR([Only one of --enable-pcsc, --enable-openct, --enable-ctapi can be specified!]) +fi + dnl Checks for programs. AC_PROG_CPP AC_PROG_INSTALL diff --git a/doc/tools/opensc-tool.xml b/doc/tools/opensc-tool.xml index 8b6c26e0..2b54b95f 100644 --- a/doc/tools/opensc-tool.xml +++ b/doc/tools/opensc-tool.xml @@ -66,10 +66,6 @@ format Lists all installed card drivers - - - Lists all installed reader drivers - num, num Use the given reader number. The default is 0, the first reader diff --git a/etc/opensc.conf.in b/etc/opensc.conf.in index cbf10625..a56b59dc 100644 --- a/etc/opensc.conf.in +++ b/etc/opensc.conf.in @@ -28,18 +28,7 @@ app default { # # profile_dir = @pkgdatadir@; - # What reader drivers to load at start-up - # - # A special value of 'internal' will load all - # statically linked drivers. If an unknown (ie. not - # internal) driver is supplied, a separate configuration - # configuration block has to be written for the driver. - # Default: internal - # NOTE: if "internal" keyword is used, must be the - # last entry in reader_drivers list - # - # reader_drivers = openct, pcsc, ctapi; - + # CT-API module configuration. reader_driver ctapi { # module /usr/local/towitoko/lib/libtowitoko.so { # CT-API ports: @@ -51,11 +40,7 @@ app default { # } } - # Define parameters specific to your readers. - # The following section shows definitions for PC/SC readers, - # but the same set of variables are applicable to ctapi and - # openct readers, simply by using "reader_driver ctapi" and - # "reader_driver openct", respectively. + # The following section shows definitions for PC/SC readers. reader_driver pcsc { # This sets the maximum send and receive sizes. # Some reader drivers have limitations, so you need @@ -431,7 +416,7 @@ app tokend { app cardmod { #allow only cardmodule pcsc reader for minidriver (mandatory) - reader_drivers = cardmod; + # FIXME cardmod pcsc hack is now broken. reader_driver cardmod { # Enable pinpad if detected (PC/SC v2.0.2 Part 10) diff --git a/src/libopensc/ctx.c b/src/libopensc/ctx.c index 3d49fe0e..e633eecf 100644 --- a/src/libopensc/ctx.c +++ b/src/libopensc/ctx.c @@ -98,21 +98,6 @@ static const struct _sc_driver_entry internal_card_drivers[] = { { NULL, NULL } }; -static const struct _sc_driver_entry internal_reader_drivers[] = { -#ifdef ENABLE_PCSC - { "pcsc", (void *(*)(void)) sc_get_pcsc_driver }, -#endif -#ifdef ENABLE_CTAPI - { "ctapi", (void *(*)(void)) sc_get_ctapi_driver }, -#endif -#ifndef _WIN32 -#ifdef ENABLE_OPENCT - { "openct", (void *(*)(void)) sc_get_openct_driver }, -#endif -#endif - { NULL, NULL } -}; - struct _sc_ctx_options { struct _sc_driver_entry rdrv[SC_MAX_READER_DRIVERS]; int rcount; @@ -132,38 +117,28 @@ static int reader_list_seeker(const void *el, const void *key) { return 0; } -static void del_drvs(struct _sc_ctx_options *opts, int type) +static void del_drvs(struct _sc_ctx_options *opts) { struct _sc_driver_entry *lst; int *cp, i; - if (type == 0) { - lst = opts->rdrv; - cp = &opts->rcount; - } else { - lst = opts->cdrv; - cp = &opts->ccount; - } + lst = opts->cdrv; + cp = &opts->ccount; + for (i = 0; i < *cp; i++) { free((void *)lst[i].name); } *cp = 0; } -static void add_drv(struct _sc_ctx_options *opts, int type, const char *name) +static void add_drv(struct _sc_ctx_options *opts, const char *name) { struct _sc_driver_entry *lst; int *cp, max, i; - - if (type == 0) { - lst = opts->rdrv; - cp = &opts->rcount; - max = SC_MAX_READER_DRIVERS; - } else { - lst = opts->cdrv; - cp = &opts->ccount; - max = SC_MAX_CARD_DRIVERS; - } + + lst = opts->cdrv; + cp = &opts->ccount; + max = SC_MAX_CARD_DRIVERS; if (*cp == max) /* No space for more drivers... */ return; for (i = 0; i < *cp; i++) @@ -174,18 +149,15 @@ static void add_drv(struct _sc_ctx_options *opts, int type, const char *name) *cp = *cp + 1; } -static void add_internal_drvs(struct _sc_ctx_options *opts, int type) +static void add_internal_drvs(struct _sc_ctx_options *opts) { const struct _sc_driver_entry *lst; int i; - if (type == 0) - lst = internal_reader_drivers; - else - lst = internal_card_drivers; + lst = internal_card_drivers; i = 0; while (lst[i].name != NULL) { - add_drv(opts, type, lst[i].name); + add_drv(opts, lst[i].name); i++; } } @@ -203,8 +175,7 @@ static void set_defaults(sc_context_t *ctx, struct _sc_ctx_options *opts) ctx->debug_file = fopen("/tmp/opensc-tokend.log", "a"); #endif ctx->forced_driver = NULL; - add_internal_drvs(opts, 0); - add_internal_drvs(opts, 1); + add_internal_drvs(opts); } static int load_parameters(sc_context_t *ctx, scconf_block *block, @@ -237,58 +208,34 @@ static int load_parameters(sc_context_t *ctx, scconf_block *block, free(opts->forced_card_driver); opts->forced_card_driver = strdup(val); } - list = scconf_find_list(block, "reader_drivers"); - if (list != NULL) - del_drvs(opts, 0); - while (list != NULL) { - if (strcmp(list->data, s_internal) == 0) - add_internal_drvs(opts, 0); - else - add_drv(opts, 0, list->data); - list = list->next; - } list = scconf_find_list(block, "card_drivers"); if (list != NULL) - del_drvs(opts, 1); + del_drvs(opts); while (list != NULL) { if (strcmp(list->data, s_internal) == 0) - add_internal_drvs(opts, 1); + add_internal_drvs(opts); else - add_drv(opts, 1, list->data); + add_drv(opts, list->data); list = list->next; } return err; } -static void load_reader_driver_options(sc_context_t *ctx, - struct sc_reader_driver *driver) +static void load_reader_driver_options(sc_context_t *ctx) { - const char *name = driver->short_name; - scconf_block *conf_block = NULL; - int i; - - for (i = 0; ctx->conf_blocks[i] != NULL; i++) { - scconf_block **blocks; - - blocks = scconf_find_blocks(ctx->conf, ctx->conf_blocks[i], - "reader_driver", name); - if (blocks) { - conf_block = blocks[0]; - free(blocks); - } - if (conf_block != NULL) - break; - } - + struct sc_reader_driver *driver = ctx->reader_driver; + scconf_block *conf_block = NULL; + driver->max_send_size = SC_DEFAULT_MAX_SEND_SIZE; driver->max_recv_size = SC_DEFAULT_MAX_RECV_SIZE; + + conf_block = sc_get_conf_block(ctx, "reader_driver", driver->name, 1); + if (conf_block != NULL) { - driver->max_send_size = scconf_get_int(conf_block, - "max_send_size", SC_DEFAULT_MAX_SEND_SIZE); - driver->max_recv_size = scconf_get_int(conf_block, - "max_recv_size", SC_DEFAULT_MAX_RECV_SIZE); + driver->max_send_size = scconf_get_int(conf_block, "max_send_size", driver->max_send_size); + driver->max_recv_size = scconf_get_int(conf_block, "max_recv_size", driver->max_recv_size); } } @@ -296,15 +243,14 @@ static void load_reader_driver_options(sc_context_t *ctx, * find library module for provided driver in configuration file * if not found assume library name equals to module name */ -static const char *find_library(sc_context_t *ctx, const char *name, int type) +static const char *find_library(sc_context_t *ctx, const char *name) { int i; const char *libname = NULL; scconf_block **blocks, *blk; for (i = 0; ctx->conf_blocks[i]; i++) { - blocks = scconf_find_blocks(ctx->conf, ctx->conf_blocks[i], - (type==0) ? "reader_driver" : "card_driver", name); + blocks = scconf_find_blocks(ctx->conf, ctx->conf_blocks[i], "card_driver", name); if (!blocks) continue; blk = blocks[0]; @@ -332,12 +278,8 @@ static const char *find_library(sc_context_t *ctx, const char *name, int type) * that returns a pointer to the function _sc_get_xxxx_driver() * used to initialize static modules * Also, an exported "char *sc_module_version" variable should exist in module - * - * type == 0 -> reader driver - * type == 1 -> card driver */ -static void *load_dynamic_driver(sc_context_t *ctx, void **dll, - const char *name, int type) +static void *load_dynamic_driver(sc_context_t *ctx, void **dll, const char *name) { const char *version, *libname; lt_dlhandle handle; @@ -350,7 +292,7 @@ static void *load_dynamic_driver(sc_context_t *ctx, void **dll, sc_debug(ctx, SC_LOG_DEBUG_NORMAL,"No module specified\n",name); return NULL; } - libname = find_library(ctx, name, type); + libname = find_library(ctx, name); if (libname == NULL) return NULL; handle = lt_dlopen(libname); @@ -376,57 +318,10 @@ static void *load_dynamic_driver(sc_context_t *ctx, void **dll, return NULL; } *dll = handle; - sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "successfully loaded %s driver '%s'\n", - type ? "card" : "reader", name); + sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "successfully loaded card driver '%s'\n", name); return modinit(name); } -static int load_reader_drivers(sc_context_t *ctx, - struct _sc_ctx_options *opts) -{ - const struct _sc_driver_entry *ent; - int drv_count; - int i; - - for (drv_count = 0; ctx->reader_drivers[drv_count] != NULL; drv_count++); - - for (i = 0; i < opts->rcount; i++) { - struct sc_reader_driver *driver; - struct sc_reader_driver *(*func)(void) = NULL; - struct sc_reader_driver *(**tfunc)(void) = &func; - int j; - void *dll = NULL; - - ent = &opts->rdrv[i]; - for (j = 0; internal_reader_drivers[j].name != NULL; j++) - if (strcmp(ent->name, internal_reader_drivers[j].name) == 0) { - func = (struct sc_reader_driver *(*)(void)) internal_reader_drivers[j].func; - break; - } - #ifdef ENABLE_CARDMOD - /* carmod reader driver is subset of pcsc driver and - must be required on config file not set with 'internal' */ - if (strcmp(ent->name, "cardmod") == 0) func = sc_get_cardmod_driver; - #endif - /* if not initialized assume external module */ - if (func == NULL) - *(void**)(tfunc) = load_dynamic_driver(ctx, &dll, ent->name, 0); - /* if still null, assume driver not found */ - if (func == NULL) { - sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Unable to load '%s'.\n", ent->name); - continue; - } - driver = func(); - driver->dll = dll; - load_reader_driver_options(ctx, driver); - driver->ops->init(ctx, &ctx->reader_drv_data[i]); - - ctx->reader_drivers[drv_count] = driver; - drv_count++; - } - return SC_SUCCESS; -} - static int load_card_driver_options(sc_context_t *ctx, struct sc_card_driver *driver) { @@ -473,7 +368,7 @@ static int load_card_drivers(sc_context_t *ctx, } /* if not initialized assume external module */ if (func == NULL) - *(void **)(tfunc) = load_dynamic_driver(ctx, &dll, ent->name, 1); + *(void **)(tfunc) = load_dynamic_driver(ctx, &dll, ent->name); /* if still null, assume driver not found */ if (func == NULL) { sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "Unable to load '%s'.\n", ent->name); @@ -660,21 +555,17 @@ static void process_config_file(sc_context_t *ctx, struct _sc_ctx_options *opts) int sc_ctx_detect_readers(sc_context_t *ctx) { - int i; + int r; + const struct sc_reader_driver *drv = ctx->reader_driver; 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]); - } - + if (drv->ops->detect_readers != NULL) + r = drv->ops->detect_readers(ctx); + sc_mutex_unlock(ctx, ctx->mutex); - /* XXX: Do not ignore erros? */ - return SC_SUCCESS; + return r; } sc_reader_t *sc_ctx_get_reader(sc_context_t *ctx, unsigned int i) @@ -747,14 +638,24 @@ int sc_context_create(sc_context_t **ctx_out, const sc_context_param_t *parm) sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "===================================\n"); /* first thing in the log */ sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "opensc version: %s\n", sc_get_version()); - /* initialize ltdl */ + /* initialize ltdl */ if (lt_dlinit() != 0) { sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "lt_dlinit failed\n"); sc_release_context(ctx); return SC_ERROR_OUT_OF_MEMORY; } - load_reader_drivers(ctx, &opts); +#ifdef ENABLE_PCSC + ctx->reader_driver = sc_get_pcsc_driver(); +#elif ENABLE_CTAPI + ctx->reader_driver = sc_get_ctapi_driver(); +#elif ENABLE_OPENCT + ctx->reader_driver = sc_get_openct_driver(); +#endif + + load_reader_driver_options(ctx); + ctx->reader_driver->ops->init(ctx); + load_card_drivers(ctx, &opts); load_card_atrs(ctx, &opts); if (opts.forced_card_driver) { @@ -762,8 +663,7 @@ int sc_context_create(sc_context_t **ctx_out, const sc_context_param_t *parm) sc_set_card_driver(ctx, opts.forced_card_driver); free(opts.forced_card_driver); } - del_drvs(&opts, 0); - del_drvs(&opts, 1); + del_drvs(&opts); sc_ctx_detect_readers(ctx); *ctx_out = ctx; return SC_SUCCESS; @@ -772,33 +672,21 @@ int sc_context_create(sc_context_t **ctx_out, const sc_context_param_t *parm) /* Following two are only implemented with internal PC/SC and don't consume a reader object */ int sc_cancel(sc_context_t *ctx) { - int i; - const struct sc_reader_driver *driver; - SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); - for (i = 0; ctx->reader_drivers[i] != NULL; i++) { - sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "trying %s", ctx->reader_drivers[i]->short_name); - driver = ctx->reader_drivers[i]; - if (driver->ops->cancel != NULL) - return driver->ops->cancel(ctx, ctx->reader_drv_data[i]); - } - return SC_ERROR_NOT_SUPPORTED; + SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); + if (ctx->reader_driver->ops->cancel != NULL) + return ctx->reader_driver->ops->cancel(ctx); + + return SC_ERROR_NOT_SUPPORTED; } -int sc_wait_for_event(sc_context_t *ctx, unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, int timeout, - void **reader_states) +int sc_wait_for_event(sc_context_t *ctx, unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, int timeout, void **reader_states) { - int i; - const struct sc_reader_driver *driver; - SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); - for (i = 0; ctx->reader_drivers[i] != NULL; i++) { - sc_debug(ctx, SC_LOG_DEBUG_NORMAL, "trying to wait event from %s", ctx->reader_drivers[i]->short_name); - driver = ctx->reader_drivers[i]; - if (driver->ops->wait_for_event != NULL) - return driver->ops->wait_for_event(ctx, ctx->reader_drv_data[i], event_mask, event_reader, event, timeout, - reader_states); - } - return SC_ERROR_NOT_SUPPORTED; + SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); + if (ctx->reader_driver->ops->wait_for_event != NULL) + return ctx->reader_driver->ops->wait_for_event(ctx, event_mask, event_reader, event, timeout, reader_states); + + return SC_ERROR_NOT_SUPPORTED; } @@ -816,14 +704,9 @@ int sc_release_context(sc_context_t *ctx) free(rdr); } - for (i = 0; ctx->reader_drivers[i] != NULL; i++) { - const struct sc_reader_driver *drv = ctx->reader_drivers[i]; + if (ctx->reader_driver->ops->finish != NULL) + ctx->reader_driver->ops->finish(ctx); - if (drv->ops->finish != NULL) - drv->ops->finish(ctx, ctx->reader_drv_data[i]); - if (drv->dll) - lt_dlclose(drv->dll); - } for (i = 0; ctx->card_drivers[i]; i++) { struct sc_card_driver *drv = ctx->card_drivers[i]; diff --git a/src/libopensc/opensc.h b/src/libopensc/opensc.h index f7d4709a..8169b691 100644 --- a/src/libopensc/opensc.h +++ b/src/libopensc/opensc.h @@ -283,14 +283,14 @@ typedef struct sc_serial_number { struct sc_reader_operations { /* Called during sc_establish_context(), when the driver * is loaded */ - int (*init)(struct sc_context *ctx, void **priv_data); + int (*init)(struct sc_context *ctx); /* Called when the driver is being unloaded. finish() has to - * deallocate the private data and any resources. */ - int (*finish)(struct sc_context *ctx, void *priv_data); + * release any resources. */ + int (*finish)(struct sc_context *ctx); /* Called when library wish to detect new readers * should add only new readers. */ - int (*detect_readers)(struct sc_context *ctx, void *priv_data); - int (*cancel)(struct sc_context *ctx, void *priv_data); + int (*detect_readers)(struct sc_context *ctx); + int (*cancel)(struct sc_context *ctx); /* Called when releasing a reader. release() has to * deallocate the private data. Other fields will be * freed by OpenSC. */ @@ -308,8 +308,7 @@ struct sc_reader_operations { int (*perform_verify)(struct sc_reader *, struct sc_pin_cmd_data *); /* Wait for an event */ - int (*wait_for_event)(struct sc_context *ctx, void *priv_data, - unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, + int (*wait_for_event)(struct sc_context *ctx, unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, int timeout, void **reader_states); /* Reset a reader */ int (*reset)(struct sc_reader *); @@ -561,10 +560,10 @@ typedef struct sc_context { list_t readers; - const struct sc_reader_driver *reader_drivers[SC_MAX_READER_DRIVERS]; - void *reader_drv_data[SC_MAX_READER_DRIVERS]; + struct sc_reader_driver *reader_driver; + void *reader_drv_data; - struct sc_card_driver *card_drivers[SC_MAX_CARD_DRIVERS]; + struct sc_card_driver *card_drivers[SC_MAX_CARD_DRIVERS]; struct sc_card_driver *forced_driver; sc_thread_context_t *thread_ctx; diff --git a/src/libopensc/reader-ctapi.c b/src/libopensc/reader-ctapi.c index 005cd4bd..ed6d03cc 100644 --- a/src/libopensc/reader-ctapi.c +++ b/src/libopensc/reader-ctapi.c @@ -499,7 +499,7 @@ symerr: return -1; } -static int ctapi_init(sc_context_t *ctx, void **reader_data) +static int ctapi_init(sc_context_t *ctx) { int i; struct ctapi_global_private_data *gpriv; @@ -508,7 +508,7 @@ static int ctapi_init(sc_context_t *ctx, void **reader_data) gpriv = calloc(1, sizeof(struct ctapi_global_private_data)); if (gpriv == NULL) return SC_ERROR_OUT_OF_MEMORY; - *reader_data = gpriv; + ctx->reader_drv_data = gpriv; for (i = 0; ctx->conf_blocks[i] != NULL; i++) { blocks = scconf_find_blocks(ctx->conf, ctx->conf_blocks[i], @@ -529,9 +529,9 @@ static int ctapi_init(sc_context_t *ctx, void **reader_data) return 0; } -static int ctapi_finish(sc_context_t *ctx, void *prv_data) +static int ctapi_finish(sc_context_t *ctx) { - struct ctapi_global_private_data *priv = (struct ctapi_global_private_data *) prv_data; + struct ctapi_global_private_data *priv = (struct ctapi_global_private_data *) ctx->reader_drv_data; if (priv) { int i; diff --git a/src/libopensc/reader-openct.c b/src/libopensc/reader-openct.c index 8eb5cbab..e19160b5 100644 --- a/src/libopensc/reader-openct.c +++ b/src/libopensc/reader-openct.c @@ -25,9 +25,9 @@ #include "internal.h" /* function declarations */ -static int openct_reader_init(sc_context_t *ctx, void **priv_data); +static int openct_reader_init(sc_context_t *ctx); static int openct_add_reader(sc_context_t *ctx, unsigned int num, ct_info_t *info); -static int openct_reader_finish(sc_context_t *ctx, void *priv_data); +static int openct_reader_finish(sc_context_t *ctx); static int openct_reader_release(sc_reader_t *reader); static int openct_reader_detect_card_presence(sc_reader_t *reader); static int openct_reader_connect(sc_reader_t *reader); @@ -64,7 +64,7 @@ struct driver_data { * is loaded */ static int -openct_reader_init(sc_context_t *ctx, void **priv_data) +openct_reader_init(sc_context_t *ctx) { unsigned int i,max_virtual; scconf_block *conf_block; @@ -135,7 +135,7 @@ openct_add_reader(sc_context_t *ctx, unsigned int num, ct_info_t *info) * Called when the driver is being unloaded. finish() has to * deallocate the private data and any resources. */ -static int openct_reader_finish(sc_context_t *ctx, void *priv_data) +static int openct_reader_finish(sc_context_t *ctx) { SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_VERBOSE); return SC_NO_ERROR; diff --git a/src/libopensc/reader-pcsc.c b/src/libopensc/reader-pcsc.c index 97b70be5..d2284d95 100644 --- a/src/libopensc/reader-pcsc.c +++ b/src/libopensc/reader-pcsc.c @@ -547,10 +547,10 @@ static int pcsc_reset(sc_reader_t *reader) } -static int pcsc_cancel(sc_context_t *ctx, void *reader_data) +static int pcsc_cancel(sc_context_t *ctx) { LONG rv = SCARD_S_SUCCESS; - struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *)reader_data; + struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *)ctx->reader_drv_data; SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); #ifndef _WIN32 @@ -579,13 +579,12 @@ static struct sc_reader_driver pcsc_drv = { 0, 0, NULL }; -static int pcsc_init(sc_context_t *ctx, void **reader_data) +static int pcsc_init(sc_context_t *ctx) { struct pcsc_global_private_data *gpriv; scconf_block *conf_block = NULL; int ret = SC_ERROR_INTERNAL; - *reader_data = NULL; gpriv = calloc(1, sizeof(struct pcsc_global_private_data)); if (gpriv == NULL) { @@ -677,7 +676,7 @@ static int pcsc_init(sc_context_t *ctx, void **reader_data) goto out; } - *reader_data = gpriv; + ctx->reader_drv_data = gpriv; gpriv = NULL; ret = SC_SUCCESS; @@ -691,9 +690,9 @@ out: return ret; } -static int pcsc_finish(sc_context_t *ctx, void *prv_data) +static int pcsc_finish(sc_context_t *ctx) { - struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *) prv_data; + struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *) ctx->reader_drv_data; SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); @@ -708,13 +707,13 @@ static int pcsc_finish(sc_context_t *ctx, void *prv_data) return SC_SUCCESS; } -static int pcsc_detect_readers(sc_context_t *ctx, void *prv_data) +static int pcsc_detect_readers(sc_context_t *ctx) { DWORD active_proto; SCARDHANDLE card_handle; u8 feature_buf[256], rbuf[SC_MAX_APDU_BUFFER_SIZE]; PCSC_TLV_STRUCTURE *pcsc_tlv; - struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *) prv_data; + struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *) ctx->reader_drv_data; LONG rv; DWORD reader_buf_size, rcount, feature_len; char *reader_buf = NULL, *reader_name; @@ -724,6 +723,7 @@ static int pcsc_detect_readers(sc_context_t *ctx, void *prv_data) SC_FUNC_CALLED(ctx, SC_LOG_DEBUG_NORMAL); if (!gpriv) { + /* FIXME: this is not the correct error */ ret = SC_ERROR_NO_READERS_FOUND; goto out; } @@ -967,11 +967,10 @@ out: /* Wait for an event to occur. */ -static int pcsc_wait_for_event(sc_context_t *ctx, void *reader_data, - unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, +static int pcsc_wait_for_event(sc_context_t *ctx, unsigned int event_mask, sc_reader_t **event_reader, unsigned int *event, int timeout, void **reader_states) { - struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *)reader_data; + struct pcsc_global_private_data *gpriv = (struct pcsc_global_private_data *)ctx->reader_drv_data; LONG rv; SCARD_READERSTATE *rgReaderStates; size_t i; diff --git a/src/tools/opensc-tool.c b/src/tools/opensc-tool.c index bc51ef8b..876d47de 100644 --- a/src/tools/opensc-tool.c +++ b/src/tools/opensc-tool.c @@ -56,7 +56,6 @@ static const struct option options[] = { { "set-conf-entry", 1, NULL, 'S' }, { "list-readers", 0, NULL, 'l' }, { "list-drivers", 0, NULL, 'D' }, - { "list-rdrivers", 0, NULL, 'R' }, { "list-files", 0, NULL, 'f' }, { "send-apdu", 1, NULL, 's' }, { "reader", 1, NULL, 'r' }, @@ -74,9 +73,8 @@ static const char *option_help[] = { "Identify the card and print its name", "Get configuration key, format: section:name:key", "Set configuration key, format: section:name:key:value", - "Lists all configured readers", + "Lists readers", "Lists all installed card drivers", - "Lists all installed reader drivers", "Recursively lists files stored on card", "Sends an APDU in format AA:BB:CC:DD:EE:FF...", "Uses reader number [0]", @@ -271,22 +269,6 @@ static int list_readers(void) return 0; } -static int list_reader_drivers(void) -{ - int i; - - if (ctx->reader_drivers[0] == NULL) { - printf("No reader drivers installed!\n"); - return 0; - } - printf("Configured reader drivers:\n"); - for (i = 0; ctx->reader_drivers[i] != NULL; i++) { - printf(" %-16s %s\n", ctx->reader_drivers[i]->short_name, - ctx->reader_drivers[i]->name); - } - return 0; -} - static int list_drivers(void) { int i; @@ -640,7 +622,6 @@ int main(int argc, char * const argv[]) int do_set_conf_entry = 0; int do_list_readers = 0; int do_list_drivers = 0; - int do_list_rdrivers = 0; int do_list_files = 0; int do_send_apdu = 0; int do_print_atr = 0; @@ -656,7 +637,7 @@ int main(int argc, char * const argv[]) setbuf(stdout, NULL); while (1) { - c = getopt_long(argc, argv, "inlG:S:fr:vs:DRc:aw", options, &long_optind); + c = getopt_long(argc, argv, "inlG:S:fr:vs:Dc:aw", options, &long_optind); if (c == -1) break; if (c == '?') @@ -684,10 +665,6 @@ int main(int argc, char * const argv[]) do_list_drivers = 1; action_count++; break; - case 'R': - do_list_rdrivers = 1; - action_count++; - break; case 'f': do_list_files = 1; action_count++; @@ -759,11 +736,6 @@ int main(int argc, char * const argv[]) goto end; action_count--; } - if (do_list_rdrivers) { - if ((err = list_reader_drivers())) - goto end; - action_count--; - } if (do_list_readers) { if ((err = list_readers())) goto end;