/*
* find a module by name, and add a reference to it.
* return that module.
*/
SECMODModule *
SECMOD_FindModule(const char *name)
{
SECMODModuleList *mlp;
SECMODModule *module = NULL;
if (!moduleLock) {
PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
return module;
}
SECMOD_GetReadLock(moduleLock);
for(mlp = modules; mlp != NULL; mlp = mlp->next) {
if (PORT_Strcmp(name,mlp->module->commonName) == 0) {
module = mlp->module;
SECMOD_ReferenceModule(module);
break;
}
}
if (module) {
goto found;
}
for(mlp = modulesUnload; mlp != NULL; mlp = mlp->next) {
if (PORT_Strcmp(name,mlp->module->commonName) == 0) {
module = mlp->module;
SECMOD_ReferenceModule(module);
break;
}
}
found:
SECMOD_ReleaseReadLock(moduleLock);
return module;
}
SECStatus
SECMOD_AddModuleToDBOnlyList(SECMODModule *newModule)
{
if (defaultDBModule && SECMOD_GetDefaultModDBFlag(newModule)) {
SECMOD_DestroyModule(defaultDBModule);
defaultDBModule = SECMOD_ReferenceModule(newModule);
} else if (defaultDBModule == NULL) {
defaultDBModule = SECMOD_ReferenceModule(newModule);
}
return secmod_AddModuleToList(&modulesDB,newModule);
}
static void
msd_smartcard_set_module (MsdSmartcard *card,
SECMODModule *module)
{
gboolean should_notify;
if (card->priv->module != module) {
should_notify = TRUE;
} else {
should_notify = FALSE;
}
if (card->priv->module != NULL) {
SECMOD_DestroyModule (card->priv->module);
card->priv->module = NULL;
}
if (module != NULL) {
card->priv->module = SECMOD_ReferenceModule (module);
}
if (should_notify) {
g_object_notify (G_OBJECT (card), "module");
}
}
static void
watch_smartcards_from_driver_async (GsdSmartcardManager *self,
SECMODModule *driver,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GsdSmartcardManagerPrivate *priv = self->priv;
GTask *task;
WatchSmartcardsOperation *operation;
operation = g_new0 (WatchSmartcardsOperation, 1);
operation->driver = SECMOD_ReferenceModule (driver);
operation->smartcards = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
(GDestroyNotify) PK11_FreeSlot);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task,
operation,
(GDestroyNotify) destroy_watch_smartcards_operation);
G_LOCK (gsd_smartcards_watch_tasks);
priv->smartcards_watch_tasks = g_list_prepend (priv->smartcards_watch_tasks,
task);
g_object_weak_ref (G_OBJECT (task),
(GWeakNotify) on_smartcards_watch_task_destroyed,
self);
G_UNLOCK (gsd_smartcards_watch_tasks);
g_task_run_in_thread (task, (GTaskThreadFunc) watch_smartcards_from_driver);
}
SECStatus
SECMOD_AddModule(SECMODModule *newModule)
{
SECStatus rv;
SECMODModule *oldModule;
/* Test if a module w/ the same name already exists */
/* and return SECWouldBlock if so. */
/* We should probably add a new return value such as */
/* SECDublicateModule, but to minimize ripples, I'll */
/* give SECWouldBlock a new meaning */
if ((oldModule = SECMOD_FindModule(newModule->commonName)) != NULL) {
SECMOD_DestroyModule(oldModule);
return SECWouldBlock;
/* module already exists. */
}
rv = secmod_LoadPKCS11Module(newModule, NULL);
if (rv != SECSuccess) {
return rv;
}
if (newModule->parent == NULL) {
newModule->parent = SECMOD_ReferenceModule(defaultDBModule);
}
SECMOD_AddPermDB(newModule);
SECMOD_AddModuleToList(newModule);
rv = STAN_AddModuleToDefaultTrustDomain(newModule);
return rv;
}
SECStatus
secmod_AddModuleToList(SECMODModuleList **moduleList,SECMODModule *newModule)
{
SECMODModuleList *mlp, *newListElement, *last = NULL;
newListElement = SECMOD_NewModuleListElement();
if (newListElement == NULL) {
return SECFailure;
}
newListElement->module = SECMOD_ReferenceModule(newModule);
SECMOD_GetWriteLock(moduleLock);
/* Added it to the end (This is very inefficient, but Adding a module
* on the fly should happen maybe 2-3 times through the life this program
* on a given computer, and this list should be *SHORT*. */
for(mlp = *moduleList; mlp != NULL; mlp = mlp->next) {
last = mlp;
}
if (last == NULL) {
*moduleList = newListElement;
} else {
SECMOD_AddList(last,newListElement,NULL);
}
SECMOD_ReleaseWriteLock(moduleLock);
return SECSuccess;
}
SECStatus
SECMOD_AddModuleToList(SECMODModule *newModule)
{
if (newModule->internal && !internalModule) {
internalModule = SECMOD_ReferenceModule(newModule);
}
return secmod_AddModuleToList(&modules,newModule);
}
SmartCardMonitoringThread::SmartCardMonitoringThread(SECMODModule *module_)
: mThread(nsnull)
{
mModule = SECMOD_ReferenceModule(module_);
// simple hash functions, most modules have less than 3 slots, so 10 buckets
// should be plenty
mHash = PL_NewHashTable(10, unity, PL_CompareValues,
PL_CompareStrings, nsnull, 0);
}
nsPKCS11Module::nsPKCS11Module(SECMODModule *module)
{
nsNSSShutDownPreventionLock locker;
if (isAlreadyShutDown())
return;
SECMOD_ReferenceModule(module);
mModule = module;
}
/*
* find a slot by it's slot number or label. If slot number is '0' any
* slot is ok.
*/
int find_slot_by_number_and_label(pkcs11_handle_t *h,
int wanted_slot_id,
const char *wanted_token_label,
unsigned int *slot_num)
{
int rv;
const char *token_label = NULL;
PK11SlotInfo *slot = NULL;
/* we want a specific slot id, or we don't kare about the label */
if ((wanted_token_label == NULL) || (wanted_slot_id != 0)) {
rv = find_slot_by_number(h, wanted_slot_id, slot_num);
/* if we don't care about the label, or we failed, we're done */
if ((wanted_token_label == NULL) || (rv != 0)) {
return rv;
}
/* verify it's the label we want */
token_label = PK11_GetTokenName(h->slot);
if ((token_label != NULL) &&
(strcmp (wanted_token_label, token_label) == 0)) {
return 0;
}
return -1;
}
/* we want a specific slot by label only */
slot = PK11_FindSlotByName(wanted_token_label);
if (!slot) {
return -1;
}
/* make sure it's in the right module */
if (h->module) {
if (h->module != PK11_GetModule(slot)) {
PK11_FreeSlot(slot);
return -1;
}
} else {
/* no module was specified, use the one slot came in */
h->module = SECMOD_ReferenceModule(PK11_GetModule(slot));
}
h->slot = slot; /* Adopt the reference */
*slot_num = PK11_GetSlotID(h->slot);
return 0;
}
static SECMODModule *find_module_by_library(char *pkcs11_module)
{
SECMODModule *module = NULL;
SECMODModuleList *modList = SECMOD_GetDefaultModuleList();
/* threaded applications should also acquire the
* DefaultModuleListLock */
DBG("Looking up module in list");
for ( ; modList; modList = modList->next) {
char *dllName = modList->module->dllName;
DBG2("modList = 0x%x next = 0x%x\n", modList, modList->next);
DBG1("dllName= %s \n", dllName ? dllName : "<null>");
if (dllName && strcmp(dllName,pkcs11_module) == 0) {
module = SECMOD_ReferenceModule(modList->module);
break;
}
}
return module;
}
static void
register_driver (GsdSmartcardManager *self,
SECMODModule *driver,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
DriverRegistrationOperation *operation;
task = g_task_new (self, cancellable, callback, user_data);
operation = g_new0 (DriverRegistrationOperation, 1);
operation->driver = SECMOD_ReferenceModule (driver);
g_task_set_task_data (task,
operation,
(GDestroyNotify) destroy_driver_registration_operation);
operation->idle_id = g_idle_add ((GSourceFunc) on_main_thread_to_register_driver, task);
g_source_set_name_by_id (operation->idle_id, "[gnome-settings-daemon] on_main_thread_to_register_driver");
}
/*
* find the function pointer.
*/
SECMODModule *
secmod_FindModuleByFuncPtr(void *funcPtr)
{
SECMODModuleList *mlp;
SECMODModule *module = NULL;
SECMOD_GetReadLock(moduleLock);
for(mlp = modules; mlp != NULL; mlp = mlp->next) {
/* paranoia, shouldn't ever happen */
if (!mlp->module) {
continue;
}
if (funcPtr == mlp->module->functionList) {
module = mlp->module;
SECMOD_ReferenceModule(module);
break;
}
}
SECMOD_ReleaseReadLock(moduleLock);
if (module == NULL) {
PORT_SetError(SEC_ERROR_NO_MODULE);
}
return module;
}
/*
* find a module by ID, and add a reference to it.
* return that module.
*/
SECMODModule *
SECMOD_FindModuleByID(SECMODModuleID id)
{
SECMODModuleList *mlp;
SECMODModule *module = NULL;
if (!moduleLock) {
PORT_SetError(SEC_ERROR_NOT_INITIALIZED);
return module;
}
SECMOD_GetReadLock(moduleLock);
for(mlp = modules; mlp != NULL; mlp = mlp->next) {
if (id == mlp->module->moduleID) {
module = mlp->module;
SECMOD_ReferenceModule(module);
break;
}
}
SECMOD_ReleaseReadLock(moduleLock);
if (module == NULL) {
PORT_SetError(SEC_ERROR_NO_MODULE);
}
return module;
}
int find_slot_by_number(pkcs11_handle_t *h, unsigned int slot_num, unsigned int *slotID)
{
SECMODModule *module = h->module;
int i;
/* if module is null,
* any of the PKCS #11 modules specified in the system config
* is available, find one */
if (module == NULL) {
PK11SlotList *list;
PK11SlotListElement *le;
PK11SlotInfo *slot = NULL;
/* find a slot, we haven't specifically selected a module,
* so find an appropriate one. */
/* get them all */
list = PK11_GetAllTokens(CKM_INVALID_MECHANISM, PR_FALSE, PR_TRUE, NULL);
if (list == NULL) {
return -1;
}
for (le = list->head; le; le = le->next) {
CK_SLOT_INFO slInfo;
SECStatus rv;
slInfo.flags = 0;
rv = PK11_GetSlotInfo(le->slot, &slInfo);
if (rv == SECSuccess && (slInfo.flags & CKF_REMOVABLE_DEVICE)) {
slot = PK11_ReferenceSlot(le->slot);
module = SECMOD_ReferenceModule(PK11_GetModule(le->slot));
break;
}
}
PK11_FreeSlotList(list);
if (slot == NULL) {
return -1;
}
h->slot = slot;
h->module = module;
*slotID = PK11_GetSlotID(slot);
return 0;
}
/*
* we're configured with a specific module, look for a present slot
* on that module. */
if (slot_num == 0) {
/* threaded applications should also acquire the
* DefaultModuleListLock */
for (i=0; i < module->slotCount; i++) {
if (module->slots[i] && PK11_IsPresent(module->slots[i])) {
h->slot = PK11_ReferenceSlot(module->slots[i]);
*slotID = PK11_GetSlotID(h->slot);
return 0;
}
}
}
/* we're configured for a specific module and token, see if it's present */
slot_num--;
if (slot_num < module->slotCount && module->slots &&
module->slots[slot_num] && PK11_IsPresent(module->slots[slot_num])) {
h->slot = PK11_ReferenceSlot(module->slots[slot_num]);
*slotID = PK11_GetSlotID(h->slot);
return 0;
}
return -1;
}