/*
* This thread looks for card and reader insertions and puts events on the
* event queue
*/
static void
vcard_emul_event_thread(void *arg)
{
PK11SlotInfo *slot;
VReader *vreader;
VReaderEmul *vreader_emul;
VCard *vcard;
SECMODModule *module = (SECMODModule *)arg;
do {
slot = SECMOD_WaitForAnyTokenEvent(module, 0, 500);
if (slot == NULL) {
break;
}
vreader = vcard_emul_find_vreader_from_slot(slot);
if (vreader == NULL) {
/* new vreader */
vreader_emul = vreader_emul_new(slot, default_card_type,
default_type_params);
vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,
vreader_emul_delete);
PK11_FreeSlot(slot);
slot = NULL;
vreader_add_reader(vreader);
vreader_free(vreader);
continue;
}
/* card remove/insert */
vreader_emul = vreader_get_private(vreader);
if (PK11_IsPresent(slot)) {
int series = PK11_GetSlotSeries(slot);
if (series != vreader_emul->series) {
if (vreader_emul->present) {
vreader_insert_card(vreader, NULL);
}
vcard = vcard_emul_mirror_card(vreader);
vreader_insert_card(vreader, vcard);
vcard_free(vcard);
}
vreader_emul->series = series;
vreader_emul->present = 1;
vreader_free(vreader);
PK11_FreeSlot(slot);
continue;
}
if (vreader_emul->present) {
vreader_insert_card(vreader, NULL);
}
vreader_emul->series = 0;
vreader_emul->present = 0;
PK11_FreeSlot(slot);
vreader_free(vreader);
} while (1);
}
/*
* This is the main work of the emulator, handling the thread that looks for
* changes in the readers and the cards.
*/
static void *
passthru_emul_event_thread(void *args)
{
char *reader_list = NULL;
int reader_list_len = 0;
SCARD_READERSTATE_A *reader_states = NULL;
int reader_count = 0; /* number of active readers */
int max_reader_count = 0; /* size of the reader_state array (including
inactive readers) */
LONG rv;
int timeout=1000;
int i;
do {
/* variables to hold on to our new values until we are ready to replace
* our old values */
char *new_reader_list = NULL;
int new_reader_list_len = 0;
int new_reader_count = 0;
/* other temps */
char * reader_entry;
VReader *reader;
/*
* First check to see if the reader list has changed
*/
rv = SCardListReaders(global_context, NULL, NULL, &new_reader_list_len);
if (rv != SCARD_S_SUCCESS) {
goto next;
}
/*
* If the names have changed, we need to update our list and states.
* This is where we detect reader insertions and removals.
*/
if (new_reader_list_len != reader_list_len) {
/* update the list */
new_reader_list = (char *)malloc(new_reader_list_len);
if (new_reader_list == NULL) {
goto next;
}
rv = SCardListReaders(global_context, NULL, new_reader_list,
&new_reader_list_len);
if (rv != SCARD_S_SUCCESS) {
free(new_reader_list);
goto next;
}
/* clear out our event state */
for (i=0; i < reader_count; i++) {
reader_states[i].dwEventState = 0;
}
/* count the readers and mark the ones that are still with us */
for (reader_entry = new_reader_list; *reader_entry;
reader_entry += strlen(reader_entry)+1) {
SCARD_READERSTATE_A *this_state;
new_reader_count++;
/* if the reader is still on the list, mark it present */
this_state = passthru_get_reader_state(reader_states,
reader_count,
reader_entry);
if (this_state) {
this_state->dwEventState = SCARD_STATE_PRESENT;
}
}
/* eject any removed readers */
for (i=0; i < reader_count; i++) {
if (reader_states[i].dwEventState == SCARD_STATE_PRESENT) {
reader_states[i].dwEventState = 0;
continue;
}
reader = vreader_get_reader_by_name(reader_states[i].szReader);
vreader_remove_reader(reader);
vreader_free(reader);
reader_states[i].szReader = NULL;
}
/* handle the shrinking list */
if (new_reader_count < reader_count) {
/* fold all the valid entries at the end of our reader_states
* array up into those locations vacated by ejected readers. */
for (i=reader_count-1; i < (new_reader_count -1); i--) {
if (reader_states[i].szReader) {
SCARD_READERSTATE_A *blank_reader;
blank_reader =
passthru_get_blank_reader(reader_states,
new_reader_count);
assert(blank_reader);
*blank_reader = reader_states[i];
reader_states[i].szReader = NULL;
}
}
}
/* handle the growing list */
if (new_reader_count > max_reader_count) {
SCARD_READERSTATE_A *new_reader_states;
/* grow the list */
new_reader_states =
(SCARD_READERSTATE_A *)realloc(reader_states,
sizeof(SCARD_READERSTATE_A)*new_reader_count);
if (new_reader_states) {
/* successful, update our current state */
reader_states = new_reader_states;
max_reader_count = new_reader_count;
} else {
new_reader_count = max_reader_count; /* couldn't get enough
* space to handle
* all the new readers
* */
}
/* mark our new entries as empty */
for (i=reader_count; i > new_reader_count; i++) {
reader_states[i].szReader = NULL;
}
}
/* now walk the reader list, updating the state */
for (reader_entry = new_reader_list; *reader_entry;
reader_entry += strlen(reader_entry)+1) {
SCARD_READERSTATE_A *this_state;
this_state = passthru_get_reader_state(reader_states,
new_reader_count,
reader_entry);
if (this_state) {
/* replace the old copy of the string with the new copy.
* This will allow us to free reader_list at the end */
reader_states->szReader = reader_entry;
continue;
}
/* this is a new reader, add it to the list */
this_state =
passthru_get_blank_reader(reader_states, new_reader_count);
if (!this_state) {
continue; /* this can happen of we couldn't get enough
slots in the grow list */
}
this_state->szReader = reader_entry;
this_state->dwCurrentState = SCARD_STATE_UNAWARE;
reader = vreader_new(reader_entry, NULL, NULL);
if (reader) {
vreader_add_reader(reader);
}
vreader_free(reader);
}
/* finally update our current variables */
free(reader_list);
reader_list = new_reader_list;
reader_list_len = new_reader_list_len;
reader_count = new_reader_count;
}
next:
rv = SCardGetStatusChange(global_context, timeout,
reader_states, reader_count);
if (rv == SCARD_E_TIMEOUT) {
continue; /* check for new readers */
}
if (rv != SCARD_S_SUCCESS) {
static int restarts = 0;
VCardStatus status;
/* try resetting the pcsc_lite subsystem */
SCardReleaseContext(global_context);
global_context = 0; /* should close it */
printf("***** SCard failure %x\n", rv);
restarts++;
if (restarts >= 3) {
printf("***** SCard failed %d times\n", restarts);
return; /* exit thread */
}
status = passthru_pcsc_lite_init();
assert(status == CARD_DONE);
sleep(1);
continue;
}
/* deal with card insertion/removal */
for (i=0; i < reader_count ; i++) {
if ((reader_states[i].dwEventState & SCARD_STATE_CHANGED) == 0) {
continue;
}
reader_states[i].dwCurrentState = reader_states[i].dwEventState;
reader = vreader_get_reader_by_name(reader_states[i].szReader);
if (reader == NULL) {
continue;
}
if (reader_states[i].dwEventState & SCARD_STATE_EMPTY) {
if (vreader_card_is_present(reader) == VREADER_OK) {
vreader_insert_card(reader, NULL);
}
}
if (reader_states[i].dwEventState & SCARD_STATE_PRESENT) {
VCard *card;
VCardStatus status = VCARD_FAIL;
/* if there already was a card present, eject it before we
* insert the new one */
if (vreader_card_is_present(reader) == VREADER_OK) {
vreader_insert_card(reader, NULL);
}
card = vcard_new(NULL, NULL);
if (card != NULL) {
status = passthru_card_init(reader, card, "",
NULL, NULL, NULL, 0);
passthru_card_set_atr(card, reader_states[i].rgbAtr,
reader_states[i].cbAtr);
vcard_set_atr_func(card, passthru_card_get_atr);
}
if (status == VCARD_DONE) {
vreader_insert_card(reader, card);
}
vcard_free(card);
}
vreader_free(reader);
}
} while (1);
return NULL;
}
VCardEmulError
vcard_emul_init(const VCardEmulOptions *options)
{
SECStatus rv;
PRBool ret, has_readers = PR_FALSE;
VReader *vreader;
VReaderEmul *vreader_emul;
SECMODListLock *module_lock;
SECMODModuleList *module_list;
SECMODModuleList *mlp;
int i;
if (vcard_emul_init_called) {
return VCARD_EMUL_INIT_ALREADY_INITED;
}
vcard_emul_init_called = 1;
vreader_init();
vevent_queue_init();
if (options == NULL) {
options = &default_options;
}
/* first initialize NSS */
if (options->nss_db) {
rv = NSS_Init(options->nss_db);
} else {
gchar *path;
#ifndef _WIN32
path = g_strdup("/etc/pki/nssdb");
#else
if (g_get_system_config_dirs() == NULL ||
g_get_system_config_dirs()[0] == NULL) {
return VCARD_EMUL_FAIL;
}
path = g_build_filename(
g_get_system_config_dirs()[0], "pki", "nssdb", NULL);
#endif
rv = NSS_Init(path);
g_free(path);
}
if (rv != SECSuccess) {
return VCARD_EMUL_FAIL;
}
/* Set password callback function */
PK11_SetPasswordFunc(vcard_emul_get_password);
/* set up soft cards emulated by software certs rather than physical cards
* */
for (i = 0; i < options->vreader_count; i++) {
int j;
int cert_count;
unsigned char **certs;
int *cert_len;
VCardKey **keys;
PK11SlotInfo *slot;
slot = PK11_FindSlotByName(options->vreader[i].name);
if (slot == NULL) {
continue;
}
vreader_emul = vreader_emul_new(slot, options->vreader[i].card_type,
options->vreader[i].type_params);
vreader = vreader_new(options->vreader[i].vname, vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
cert_count = options->vreader[i].cert_count;
ret = vcard_emul_alloc_arrays(&certs, &cert_len, &keys,
options->vreader[i].cert_count);
if (ret == PR_FALSE) {
continue;
}
cert_count = 0;
for (j = 0; j < options->vreader[i].cert_count; j++) {
/* we should have a better way of identifying certs than by
* nickname here */
CERTCertificate *cert = PK11_FindCertFromNickname(
options->vreader[i].cert_name[j],
NULL);
if (cert == NULL) {
continue;
}
certs[cert_count] = cert->derCert.data;
cert_len[cert_count] = cert->derCert.len;
keys[cert_count] = vcard_emul_make_key(slot, cert);
/* this is safe because the key is still holding a cert reference */
CERT_DestroyCertificate(cert);
cert_count++;
}
if (cert_count) {
VCard *vcard = vcard_emul_make_card(vreader, certs, cert_len,
keys, cert_count);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
/* allow insertion and removal of soft cards */
vreader_emul->saved_vcard = vcard_reference(vcard);
vcard_free(vcard);
vreader_free(vreader);
has_readers = PR_TRUE;
}
g_free(certs);
g_free(cert_len);
g_free(keys);
}
/* if we aren't suppose to use hw, skip looking up hardware tokens */
if (!options->use_hw) {
nss_emul_init = has_readers;
return has_readers ? VCARD_EMUL_OK : VCARD_EMUL_FAIL;
}
/* make sure we have some PKCS #11 module loaded */
module_lock = SECMOD_GetDefaultModuleListLock();
module_list = SECMOD_GetDefaultModuleList();
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
if (module_has_removable_hw_slots(module)) {
break;
}
}
SECMOD_ReleaseReadLock(module_lock);
/* now examine all the slots, finding which should be readers */
/* We should control this with options. For now we mirror out any
* removable hardware slot */
default_card_type = options->hw_card_type;
default_type_params = g_strdup(options->hw_type_params);
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
/* Ignore the internal module */
if (module == NULL || module == SECMOD_GetInternalModule()) {
continue;
}
for (i = 0; i < module->slotCount; i++) {
PK11SlotInfo *slot = module->slots[i];
/* only map removable HW slots */
if (slot == NULL || !PK11_IsRemovable(slot) || !PK11_IsHW(slot)) {
continue;
}
if (strcmp("E-Gate 0 0", PK11_GetSlotName(slot)) == 0) {
/*
* coolkey <= 1.1.0-20 emulates this reader if it can't find
* any hardware readers. This causes problems, warn user of
* problems.
*/
fprintf(stderr, "known bad coolkey version - see "
"https://bugzilla.redhat.com/show_bug.cgi?id=802435\n");
continue;
}
vreader_emul = vreader_emul_new(slot, options->hw_card_type,
options->hw_type_params);
vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
if (PK11_IsPresent(slot)) {
VCard *vcard;
vcard = vcard_emul_mirror_card(vreader);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
vcard_free(vcard);
}
}
vcard_emul_new_event_thread(module);
}
SECMOD_ReleaseReadLock(module_lock);
nss_emul_init = PR_TRUE;
return VCARD_EMUL_OK;
}
/*
* This thread looks for card and reader insertions and puts events on the
* event queue
*/
static void
vcard_emul_event_thread(void *arg)
{
PK11SlotInfo *slot;
VReader *vreader;
VReaderEmul *vreader_emul;
VCard *vcard;
SECMODModule *module = (SECMODModule *)arg;
do {
/*
* XXX - the latency value doesn't matter one bit. you only get no
* blocking (flags |= CKF_DONT_BLOCK) or PKCS11_WAIT_LATENCY (==500),
* hard coded in coolkey. And it isn't coolkey's fault - the timeout
* value we pass get's dropped on the floor before C_WaitForSlotEvent
* is called.
*/
slot = SECMOD_WaitForAnyTokenEvent(module, 0, 500);
if (slot == NULL) {
/* this could be just a no event indication */
if (PORT_GetError() == SEC_ERROR_NO_EVENT) {
continue;
}
break;
}
vreader = vcard_emul_find_vreader_from_slot(slot);
if (vreader == NULL) {
/* new vreader */
vreader_emul = vreader_emul_new(slot, default_card_type,
default_type_params);
vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,
vreader_emul_delete);
PK11_FreeSlot(slot);
slot = NULL;
vreader_add_reader(vreader);
vreader_free(vreader);
continue;
}
/* card remove/insert */
vreader_emul = vreader_get_private(vreader);
if (PK11_IsPresent(slot)) {
int series = PK11_GetSlotSeries(slot);
if (series != vreader_emul->series) {
if (vreader_emul->present) {
vreader_insert_card(vreader, NULL);
}
vcard = vcard_emul_mirror_card(vreader);
vreader_insert_card(vreader, vcard);
vcard_free(vcard);
}
vreader_emul->series = series;
vreader_emul->present = 1;
vreader_free(vreader);
PK11_FreeSlot(slot);
continue;
}
if (vreader_emul->present) {
vreader_insert_card(vreader, NULL);
}
vreader_emul->series = 0;
vreader_emul->present = 0;
PK11_FreeSlot(slot);
vreader_free(vreader);
} while (1);
}
VCardEmulError
vcard_emul_init(const VCardEmulOptions *options)
{
SECStatus rv;
PRBool ret, has_readers = PR_FALSE, need_coolkey_module;
VReader *vreader;
VReaderEmul *vreader_emul;
SECMODListLock *module_lock;
SECMODModuleList *module_list;
SECMODModuleList *mlp;
int i;
if (vcard_emul_init_called) {
return VCARD_EMUL_INIT_ALREADY_INITED;
}
vcard_emul_init_called = 1;
vreader_init();
vevent_queue_init();
if (options == NULL) {
options = &default_options;
}
/* first initialize NSS */
if (options->nss_db) {
rv = NSS_Init(options->nss_db);
} else {
rv = NSS_Init("sql:/etc/pki/nssdb");
}
if (rv != SECSuccess) {
return VCARD_EMUL_FAIL;
}
/* Set password callback function */
PK11_SetPasswordFunc(vcard_emul_get_password);
/* set up soft cards emulated by software certs rather than physical cards
* */
for (i = 0; i < options->vreader_count; i++) {
int j;
int cert_count;
unsigned char **certs;
int *cert_len;
VCardKey **keys;
PK11SlotInfo *slot;
slot = PK11_FindSlotByName(options->vreader[i].name);
if (slot == NULL) {
continue;
}
vreader_emul = vreader_emul_new(slot, options->vreader[i].card_type,
options->vreader[i].type_params);
vreader = vreader_new(options->vreader[i].vname, vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
cert_count = options->vreader[i].cert_count;
ret = vcard_emul_alloc_arrays(&certs, &cert_len, &keys,
options->vreader[i].cert_count);
if (ret == PR_FALSE) {
continue;
}
cert_count = 0;
for (j = 0; j < options->vreader[i].cert_count; j++) {
/* we should have a better way of identifying certs than by
* nickname here */
CERTCertificate *cert = PK11_FindCertFromNickname(
options->vreader[i].cert_name[j],
NULL);
if (cert == NULL) {
continue;
}
certs[cert_count] = cert->derCert.data;
cert_len[cert_count] = cert->derCert.len;
keys[cert_count] = vcard_emul_make_key(slot, cert);
/* this is safe because the key is still holding a cert reference */
CERT_DestroyCertificate(cert);
cert_count++;
}
if (cert_count) {
VCard *vcard = vcard_emul_make_card(vreader, certs, cert_len,
keys, cert_count);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
/* allow insertion and removal of soft cards */
vreader_emul->saved_vcard = vcard_reference(vcard);
vcard_free(vcard);
vreader_free(vreader);
has_readers = PR_TRUE;
}
g_free(certs);
g_free(cert_len);
g_free(keys);
}
/* if we aren't suppose to use hw, skip looking up hardware tokens */
if (!options->use_hw) {
nss_emul_init = has_readers;
return has_readers ? VCARD_EMUL_OK : VCARD_EMUL_FAIL;
}
/* make sure we have some PKCS #11 module loaded */
module_lock = SECMOD_GetDefaultModuleListLock();
module_list = SECMOD_GetDefaultModuleList();
need_coolkey_module = !has_readers;
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
if (module_has_removable_hw_slots(module)) {
need_coolkey_module = PR_FALSE;
break;
}
}
SECMOD_ReleaseReadLock(module_lock);
if (need_coolkey_module) {
SECMODModule *module;
module = SECMOD_LoadUserModule(
(char *)"library=libcoolkeypk11.so name=Coolkey",
NULL, PR_FALSE);
if (module == NULL) {
return VCARD_EMUL_FAIL;
}
SECMOD_DestroyModule(module); /* free our reference, Module will still
* be on the list.
* until we destroy it */
}
/* now examine all the slots, finding which should be readers */
/* We should control this with options. For now we mirror out any
* removable hardware slot */
default_card_type = options->hw_card_type;
default_type_params = strdup(options->hw_type_params);
SECMOD_GetReadLock(module_lock);
for (mlp = module_list; mlp; mlp = mlp->next) {
SECMODModule *module = mlp->module;
PRBool has_emul_slots = PR_FALSE;
if (module == NULL) {
continue;
}
for (i = 0; i < module->slotCount; i++) {
PK11SlotInfo *slot = module->slots[i];
/* only map removable HW slots */
if (slot == NULL || !PK11_IsRemovable(slot) || !PK11_IsHW(slot)) {
continue;
}
vreader_emul = vreader_emul_new(slot, options->hw_card_type,
options->hw_type_params);
vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,
vreader_emul_delete);
vreader_add_reader(vreader);
has_readers = PR_TRUE;
has_emul_slots = PR_TRUE;
if (PK11_IsPresent(slot)) {
VCard *vcard;
vcard = vcard_emul_mirror_card(vreader);
vreader_insert_card(vreader, vcard);
vcard_emul_init_series(vreader, vcard);
vcard_free(vcard);
}
}
if (has_emul_slots) {
vcard_emul_new_event_thread(module);
}
}
SECMOD_ReleaseReadLock(module_lock);
nss_emul_init = has_readers;
return VCARD_EMUL_OK;
}