softGeneral.c revision a62b4373b57aaff719d270821a0de8cea0e79e95
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <strings.h>
#include <errno.h>
#include <cryptoutil.h>
#include <unistd.h> /* for pid_t */
#include <pthread.h>
#include <security/cryptoki.h>
#include "softGlobal.h"
#include "softSession.h"
#include "softObject.h"
#include "softKeystore.h"
#include "softKeystoreUtil.h"
#pragma fini(softtoken_fini)
static struct CK_FUNCTION_LIST functionList = {
{ 2, 20 }, /* version */
};
static pid_t softtoken_pid = 0;
/* This mutex protects soft_session_list, all_sessions_closing */
int all_sessions_closing = 0;
int soft_urandom_fd = -1;
int soft_random_fd = -1;
/* protects softtoken_initialized and access to C_Initialize/C_Finalize */
static void softtoken_fini();
{
int initialize_pid;
/*
* Get lock to insure only one thread enters this
* function at a time.
*/
(void) pthread_mutex_lock(&soft_giant_mutex);
initialize_pid = getpid();
if (softtoken_initialized) {
if (initialize_pid == softtoken_pid) {
/*
* This process has called C_Initialize already
*/
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_CRYPTOKI_ALREADY_INITIALIZED);
} else {
/*
* A fork has happened and the child is
* reinitializing. Do a finalize_common to close
* out any state from the parent, and then
* continue on.
*/
}
}
/* pReserved must be NULL */
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_ARGUMENTS_BAD);
}
/*
* ALL supplied function pointers need to have the value
* either NULL or non-NULL.
*/
if (!supplied_ok) {
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_ARGUMENTS_BAD);
}
/*
* When the CKF_OS_LOCKING_OK flag isn't set and mutex
* function pointers are supplied by an application,
* return an error. We must be able to use our own primitives.
*/
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_CANT_LOCK);
}
}
/* Initialize the session list lock */
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_CANT_LOCK);
}
/*
* token object related initialization
*/
soft_slot.authenticated = 0;
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (rv);
}
/* Initialize the slot lock */
(void) soft_destroy_token_session();
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (CKR_CANT_LOCK);
}
/* Get keystore version because it might not be 1 at this time */
0) {
}
if (soft_token_present) {
/* Load all the public token objects from keystore */
PUB_TOKENOBJS)) != CKR_OK) {
(void) soft_destroy_token_session();
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (rv);
} else {
/*
* Invalidate public token objects until the
* C_OpenSession is called.
*/
}
}
(void) pthread_mutex_unlock(&soft_giant_mutex);
/* Initialize the object_to_be_freed list */
obj_delay_freed.count = 0;
ses_delay_freed.count = 0;
return (CKR_OK);
}
/*
* C_Finalize is a wrapper around finalize_common. The
* soft_giant_mutex should be locked by C_Finalize().
*/
{
(void) pthread_mutex_lock(&soft_giant_mutex);
(void) pthread_mutex_unlock(&soft_giant_mutex);
return (rv);
}
/*
* finalize_common() does the work for C_Finalize. soft_giant_mutex
* must be held before calling this function.
*/
static CK_RV
if (!softtoken_initialized) {
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
/* Check to see if pReseved is NULL */
return (CKR_ARGUMENTS_BAD);
}
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
/*
* Set all_sessions_closing flag so any access to any
* existing sessions will be rejected.
*/
all_sessions_closing = 1;
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
/* Delete all the sessions and release the allocated resources */
(void) pthread_mutex_lock(&soft_sessionlist_mutex);
/* Reset all_sessions_closing flag. */
all_sessions_closing = 0;
(void) pthread_mutex_unlock(&soft_sessionlist_mutex);
softtoken_pid = 0;
if (soft_urandom_fd > 0) {
(void) close(soft_urandom_fd);
soft_urandom_fd = -1;
}
if (soft_random_fd > 0) {
(void) close(soft_random_fd);
soft_random_fd = -1;
}
/* Destroy the session list lock here */
(void) pthread_mutex_destroy(&soft_sessionlist_mutex);
/*
* Destroy token object related stuffs
* 1. Clean up the token object list
* 2. Destroy slot mutex
* 3. Destroy mutex in token_session
*/
(void) soft_destroy_token_session();
/*
* free all entries in the delay_freed list
*/
while (delay_free_obj != NULL) {
}
while (delay_free_ses != NULL) {
}
return (rv);
}
/*
* softtoken_fini() function required to make sure complete cleanup
* is done if softtoken is ever unloaded without a C_Finalize() call.
*/
static void
{
(void) pthread_mutex_lock(&soft_giant_mutex);
/* if we're not initilized, do not attempt to finalize */
if (!softtoken_initialized) {
(void) pthread_mutex_unlock(&soft_giant_mutex);
return;
}
(void) pthread_mutex_unlock(&soft_giant_mutex);
}
{
if (!softtoken_initialized)
return (CKR_CRYPTOKI_NOT_INITIALIZED);
return (CKR_ARGUMENTS_BAD);
}
/* Provide general information in the provided buffer */
SOFT_MANUFACTURER_ID, 32);
LIBRARY_DESCRIPTION, 32);
return (CKR_OK);
}
{
if (ppFunctionList == NULL) {
return (CKR_ARGUMENTS_BAD);
}
return (CKR_OK);
}
/*
* PKCS#11 states that C_GetFunctionStatus should always return
* CKR_FUNCTION_NOT_PARALLEL
*/
/*ARGSUSED*/
{
return (CKR_FUNCTION_NOT_PARALLEL);
}
/*
* PKCS#11 states that C_CancelFunction should always return
* CKR_FUNCTION_NOT_PARALLEL
*/
/*ARGSUSED*/
{
return (CKR_FUNCTION_NOT_PARALLEL);
}
/*
* Perform a write that can handle EINTR.
*/
int
{
char *p = buf;
if (len == 0)
return (0);
do {
if (cc < 0) {
continue;
return (cc);
} else if (cc == 0) {
return (len2);
} else {
p += cc;
}
} while (len > 0);
return (len2);
}
/*
* Perform a read that can handle EINTR.
*/
int
{
char *p = buf;
do {
if (cc < 0) {
continue;
return (cc); /* errno is already set */
} else if (cc == 0) {
return (len2);
} else {
p += cc;
}
} while (len > 0);
return (len2);
}