giomba
/
opensc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove gcc specific code from usbtoken/openct drivers, untested. 

git-svn-id: https://www.opensc-project.org/svnp/opensc/trunk@1417 c6295689-39f2-0310-b995-f0e70906c6a9
This commit is contained in:
aet 2003-09-04 16:41:49 +00:00
parent 915ddc91ca
commit e66bb1ef16
4 changed files with 43 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libopensc/reader-ctapi.c
View File

@ -362,7 +362,7 @@ static int ctapi_finish(struct sc_context *ctx, void *prv_data)
return 0;
}
const struct sc_reader_driver * sc_get_ctapi_driver()
const struct sc_reader_driver * sc_get_ctapi_driver(void)
{
ctapi_ops.init = ctapi_init;
ctapi_ops.finish = ctapi_finish;

44
src/libopensc/reader-openct.c
View File

@ -55,30 +55,12 @@ static int openct_reader_unlock(struct sc_reader *reader,
struct sc_slot_info *slot);
static int openct_error(struct sc_reader *, int);
/* the operations struct, already initialized */
static struct sc_reader_operations openct_reader_operations = {
.init = openct_reader_init,
.finish = openct_reader_finish,
.release = openct_reader_release,
.detect_card_presence = openct_reader_detect_card_presence,
.connect = openct_reader_connect,
.disconnect = openct_reader_disconnect,
.transmit = openct_reader_transmit,
.perform_verify = openct_reader_perform_verify,
.lock = openct_reader_lock,
.unlock = openct_reader_unlock,
};
static struct sc_reader_operations openct_ops;
/* also, the driver struct */
static struct sc_reader_driver openct_reader_driver = {
.name = "OpenCT Reader",
.short_name = "openct",
.ops = &openct_reader_operations
};
/* return our structure */
const struct sc_reader_driver *sc_get_openct_driver() {
return &openct_reader_driver;
"OpenCT Reader",
"openct",
&openct_ops
};
/* private data structures */
@ -141,7 +123,7 @@ openct_add_reader(struct sc_context *ctx, unsigned int num, ct_info_t *info)
data->num = num;
reader->driver = &openct_reader_driver;
reader->ops = &openct_reader_operations;
reader->ops = &openct_ops;
reader->drv_data = data;
reader->name = strdup(data->info.ct_name);
reader->slot_count = data->info.ct_slots;
@ -445,4 +427,20 @@ openct_error(struct sc_reader *reader, int code)
return SC_ERROR_READER;
}
const struct sc_reader_driver *sc_get_openct_driver(void)
{
openct_ops.init = openct_reader_init;
openct_ops.finish = openct_reader_finish;
openct_ops.release = openct_reader_release;
openct_ops.detect_card_presence = openct_reader_detect_card_presence;
openct_ops.connect = openct_reader_connect;
openct_ops.disconnect = openct_reader_disconnect;
openct_ops.transmit = openct_reader_transmit;
openct_ops.perform_verify = openct_reader_perform_verify;
openct_ops.lock = openct_reader_lock;
openct_ops.unlock = openct_reader_unlock;
return &openct_reader_driver;
};
#endif /* HAVE_OPENCT */

2
src/libopensc/reader-pcsc.c
View File

@ -591,7 +591,7 @@ static int pcsc_finish(struct sc_context *ctx, void *prv_data)
return 0;
}
const struct sc_reader_driver * sc_get_pcsc_driver()
const struct sc_reader_driver * sc_get_pcsc_driver(void)
{
pcsc_ops.init = pcsc_init;
pcsc_ops.finish = pcsc_finish;

43
src/libopensc/reader-usbtoken.c
View File

@ -43,30 +43,12 @@ int usbtoken_reader_lock(struct sc_reader *reader,
int usbtoken_reader_unlock(struct sc_reader *reader,
struct sc_slot_info *slot);
/* the operations struct, already initialized */
static struct sc_reader_operations usbtoken_reader_operations = {
.init = usbtoken_reader_init,
.finish = usbtoken_reader_finish,
.release = usbtoken_reader_release,
.detect_card_presence = usbtoken_reader_detect_card_presence,
.connect = usbtoken_reader_connect,
.disconnect = usbtoken_reader_disconnect,
.transmit = usbtoken_reader_transmit,
.lock = usbtoken_reader_lock,
.unlock = usbtoken_reader_unlock,
};
static struct sc_reader_operations usbtoken_ops;
/* also, the driver struct */
static struct sc_reader_driver usbtoken_reader_driver = {
.name = "USB Crypto Token Reader",
.short_name = "usbtoken",
.ops = &usbtoken_reader_operations
};
/* return our structure */
const struct sc_reader_driver *sc_get_usbtoken_driver()
{
return &usbtoken_reader_driver;
"USB Crypto Token Reader",
"usbtoken",
&usbtoken_ops
};
/* private data structures */
@ -90,7 +72,7 @@ int usbtoken_reader_init(struct sc_context *ctx, void **priv_data)
myreader = malloc(sizeof(struct sc_reader));
bzero(myreader, sizeof(struct sc_reader));
myreader->driver = &usbtoken_reader_driver;
myreader->ops = &usbtoken_reader_operations;
myreader->ops = &usbtoken_ops;
myreader->slot_count = 1;
myreader->name = strdup("USB Crypto Token %d");
snprintf(myreader->name, strlen(myreader->name),
@ -351,4 +333,19 @@ int usbtoken_reader_unlock(struct sc_reader *reader,
return usbtoken_reader_unix_cmd(reader, slot, 5);
}
const struct sc_reader_driver *sc_get_usbtoken_driver(void)
{
usbtoken_ops.init = usbtoken_reader_init;
usbtoken_ops.finish = usbtoken_reader_finish;
usbtoken_ops.release = usbtoken_reader_release;
usbtoken_ops.detect_card_presence = usbtoken_reader_detect_card_presence;
usbtoken_ops.connect = usbtoken_reader_connect;
usbtoken_ops.disconnect = usbtoken_reader_disconnect;
usbtoken_ops.transmit = usbtoken_reader_transmit;
usbtoken_ops.lock = usbtoken_reader_lock;
usbtoken_ops.unlock = usbtoken_reader_unlock;
return &usbtoken_reader_driver;
};
#endif /* HAVE_USBTOKEN */