/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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
 * or http://www.opensolaris.org/os/licensing.
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <unistd.h>
#include <string.h>
#include <cryptoutil.h>
#include <pthread.h>

#include <security/cryptoki.h>
#include "pkcs11Global.h"
#include "pkcs11Slot.h"
#include "pkcs11Conf.h"
#include "pkcs11Session.h"
#include "metaGlobal.h"

#pragma init(pkcs11_init)
#pragma fini(pkcs11_fini)

static struct CK_FUNCTION_LIST functionList = {
	{ 2, 20 },	/* version */
	C_Initialize,
	C_Finalize,
	C_GetInfo,
	C_GetFunctionList,
	C_GetSlotList,
	C_GetSlotInfo,
	C_GetTokenInfo,
	C_GetMechanismList,
	C_GetMechanismInfo,
	C_InitToken,
	C_InitPIN,
	C_SetPIN,
	C_OpenSession,
	C_CloseSession,
	C_CloseAllSessions,
	C_GetSessionInfo,
	C_GetOperationState,
	C_SetOperationState,
	C_Login,
	C_Logout,
	C_CreateObject,
	C_CopyObject,
	C_DestroyObject,
	C_GetObjectSize,
	C_GetAttributeValue,
	C_SetAttributeValue,
	C_FindObjectsInit,
	C_FindObjects,
	C_FindObjectsFinal,
	C_EncryptInit,
	C_Encrypt,
	C_EncryptUpdate,
	C_EncryptFinal,
	C_DecryptInit,
	C_Decrypt,
	C_DecryptUpdate,
	C_DecryptFinal,
	C_DigestInit,
	C_Digest,
	C_DigestUpdate,
	C_DigestKey,
	C_DigestFinal,
	C_SignInit,
	C_Sign,
	C_SignUpdate,
	C_SignFinal,
	C_SignRecoverInit,
	C_SignRecover,
	C_VerifyInit,
	C_Verify,
	C_VerifyUpdate,
	C_VerifyFinal,
	C_VerifyRecoverInit,
	C_VerifyRecover,
	C_DigestEncryptUpdate,
	C_DecryptDigestUpdate,
	C_SignEncryptUpdate,
	C_DecryptVerifyUpdate,
	C_GenerateKey,
	C_GenerateKeyPair,
	C_WrapKey,
	C_UnwrapKey,
	C_DeriveKey,
	C_SeedRandom,
	C_GenerateRandom,
	C_GetFunctionStatus,
	C_CancelFunction,
	C_WaitForSlotEvent
};

boolean_t pkcs11_initialized = B_FALSE;
boolean_t pkcs11_cant_create_threads = B_FALSE;
boolean_t fini_called = B_FALSE;
static boolean_t pkcs11_atfork_initialized = B_FALSE;
static pid_t pkcs11_pid = 0;

/* protects pkcs11_[initialized|pid], and fastpath */
static pthread_mutex_t globalmutex = PTHREAD_MUTEX_INITIALIZER;

static CK_RV finalize_common(CK_VOID_PTR pReserved);
static void pkcs11_init();
static void pkcs11_fini();

/*
 * Ensure that before a fork, all mutexes are taken.
 * We cannot acquire globalmutex, because it can cause deadlock when
 * atfork() and fork() are called in parallel. It can happen when
 * C_Ininitialize() tries to dlopen() a provider. The dlopen() operation
 * is protected by globalmutex and when another thread calls fork()
 * pkcs11_fork_prepare cannot acquire the mutex again and thus it must wait.
 * When a provider tries to register its atfork handler, atfork() must
 * wait on fork(). See the comment in fork() libc function for more details.
 *
 * Order:
 * 1. slottable->st_mutex
 * 2. all slottable->st_slots' mutexes
 */
static void
pkcs11_fork_prepare(void)
{
	int i;
	if (pkcs11_initialized) {
		if (slottable != NULL) {
			(void) pthread_mutex_lock(&slottable->st_mutex);

			/* Take the sl_mutex of all slots */
			for (i = slottable->st_first;
			    i <= slottable->st_last; i++) {
				if (slottable->st_slots[i] != NULL) {
					(void) pthread_mutex_lock(
					    &slottable->st_slots[i]->sl_mutex);
				}
			}
		}
	}
}


/*
 * Ensure that after a fork, in the parent, all mutexes are released in opposite
 * order to pkcs11_fork_prepare().
 */
static void
pkcs11_fork_parent(void)
{
	int i;
	if (pkcs11_initialized) {
		if (slottable != NULL) {
			/* Release the sl_mutex of all slots */
			for (i = slottable->st_first;
			    i <= slottable->st_last; i++) {
				if (slottable->st_slots[i] != NULL) {
					(void) pthread_mutex_unlock(
					    &slottable->st_slots[i]->sl_mutex);
				}
			}
		}
		(void) pthread_mutex_unlock(&slottable->st_mutex);
	}
}


/*
 * Ensure that after a fork, in the child, all mutexes are released in opposite
 * order to pkcs11_fork_prepare() and cleanup is done.
 * Because we need to handle fork correctly before library is initialized two
 * handlers are necessary.
 *
 * 1) pkcs11_fork_child() - unlock mutexes
 * 2) pkcs11_fork_child_fini() - cleanup library after fork, it is registered in
 *                               C_Initialize() after providers initialization.
 */
static void
pkcs11_fork_child(void)
{
	int i;
	if (pkcs11_initialized) {
		if (slottable != NULL) {
			/* Release the sl_mutex of all slots */
			for (i = slottable->st_first;
			    i <= slottable->st_last; i++) {
				if (slottable->st_slots[i] != NULL) {
					(void) pthread_mutex_unlock(
					    &slottable->st_slots[i]->sl_mutex);
				}
			}
		}
		(void) pthread_mutex_unlock(&slottable->st_mutex);
	}

	(void) pthread_mutex_destroy(&globalmutex);
	(void) pthread_mutex_init(&globalmutex, NULL);
}

/* Library cleanup have to be last afterfork child handler. */
static void
pkcs11_fork_child_fini(void)
{
	pkcs11_fini();
}

CK_RV
C_Initialize(CK_VOID_PTR pInitArgs)
{
	CK_RV rv;
	uentrylist_t *pliblist = NULL;
	int initialize_pid;

	/*
	 * Grab lock to insure only one thread enters
	 * this function at a time.
	 */
	(void) pthread_mutex_lock(&globalmutex);

	initialize_pid = getpid();

	/* Make sure function hasn't been called twice */
	if (pkcs11_initialized) {
		if (initialize_pid == pkcs11_pid) {
			(void) pthread_mutex_unlock(&globalmutex);
			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.
			 */
			(void) finalize_common(NULL);
		}
	}

	/* Check if application has provided mutex-handling functions */
	if (pInitArgs != NULL) {
		CK_C_INITIALIZE_ARGS_PTR initargs =
		    (CK_C_INITIALIZE_ARGS_PTR) pInitArgs;

		/* pReserved should not be set */
		if (initargs->pReserved != NULL) {
			rv = CKR_ARGUMENTS_BAD;
			goto errorexit;
		}

		/*
		 * Make sure function pointers are either all NULL or
		 * all set.
		 */
		if (!(((initargs->CreateMutex   != NULL) &&
		    (initargs->LockMutex    != NULL) &&
		    (initargs->UnlockMutex  != NULL) &&
		    (initargs->DestroyMutex != NULL)) ||
		    ((initargs->CreateMutex == NULL) &&
		    (initargs->LockMutex    == NULL) &&
		    (initargs->UnlockMutex  == NULL) &&
		    (initargs->DestroyMutex == NULL)))) {
			rv = CKR_ARGUMENTS_BAD;
			goto errorexit;
		}

		if (!(initargs->flags & CKF_OS_LOCKING_OK)) {
			if (initargs->CreateMutex != NULL) {
				/*
				 * Do not accept application supplied
				 * locking primitives.
				 */
				rv = CKR_CANT_LOCK;
				goto errorexit;
			}

		}
		if (initargs->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS) {
			/*
			 * Calling application does not want the library
			 * to create threads.  This will effect
			 * C_WaitForSlotEvent().
			 */
			pkcs11_cant_create_threads = B_TRUE;
		}
	}

	/* Initialize slot table */
	rv = pkcs11_slottable_initialize();

	if (rv != CKR_OK)
		goto errorexit;

	/* Get the list of providers */
	if (get_pkcs11conf_info(&pliblist) != SUCCESS) {
		rv = CKR_FUNCTION_FAILED;
		goto errorexit;
	}

	/*
	 * Load each provider, check for accessible slots,
	 * and populate slottable.  If metaslot is enabled,
	 * it will be initialized as well.
	 */
	rv = pkcs11_slot_mapping(pliblist, pInitArgs);

	if (rv != CKR_OK)
		goto errorexit;

	pkcs11_initialized = B_TRUE;
	pkcs11_pid = initialize_pid;
	/* Children inherit parent's atfork handlers */
	if (!pkcs11_atfork_initialized) {
		(void) pthread_atfork(NULL, NULL, pkcs11_fork_child_fini);
		pkcs11_atfork_initialized = B_TRUE;
	}

	(void) pthread_mutex_unlock(&globalmutex);

	/* Cleanup data structures no longer needed */
	free_uentrylist(pliblist);

	return (CKR_OK);

errorexit:
	/* Cleanup any data structures that have already been allocated */
	if (slottable)
		(void) pkcs11_slottable_delete();
	if (pliblist)
		(void) free_uentrylist(pliblist);

	(void) pthread_mutex_unlock(&globalmutex);
	return (rv);

}

/*
 * C_Finalize is a wrapper around finalize_common. The
 * globalmutex should be locked by C_Finalize().
 *
 * When an explicit C_Finalize() call is received, all
 * plugins currently in the slottable will also be
 * finalized.  This must occur, even if libpkcs11(3lib)
 * was not the first one to initialize the plugins, since it
 * is the only way in PKCS#11 to force a refresh of the
 * slot listings (ie to get new hardware devices).
 */
CK_RV
C_Finalize(CK_VOID_PTR pReserved)
{

	CK_RV rv;

	(void) pthread_mutex_lock(&globalmutex);

	rv = finalize_common(pReserved);

	(void) pthread_mutex_unlock(&globalmutex);

	return (rv);
}

/*
 * finalize_common() does the work for C_Finalize.  globalmutex
 * must be held before calling this function.
 */
static CK_RV
finalize_common(CK_VOID_PTR pReserved)
{

	CK_RV rv;

	if (!pkcs11_initialized) {
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}

	if (pReserved != NULL) {
		return (CKR_ARGUMENTS_BAD);
	}

	purefastpath = B_FALSE;
	policyfastpath = B_FALSE;
	fast_funcs = NULL;
	fast_slot = 0;
	pkcs11_initialized = B_FALSE;
	pkcs11_cant_create_threads = B_FALSE;
	pkcs11_pid = 0;

	/* Check if C_WaitForSlotEvent() is currently active */
	(void) pthread_mutex_lock(&slottable->st_mutex);
	if (slottable->st_wfse_active) {
		/*
		 * Wait for this thread to proceed far enough to block or
		 * end on its own.  Otherwise, teardown of slottable may
		 * occurr before this active function completes.
		 */
		while (slottable->st_wfse_active) {
			/*
			 * If C_WaitForSlotEvent is blocking, wake it up and
			 * return error to calling application.
			 */
			if (slottable->st_blocking) {
				slottable->st_list_signaled = B_TRUE;
				(void) pthread_cond_signal(
				    &slottable->st_wait_cond);
				(void) pthread_mutex_unlock(
				    &slottable->st_mutex);
				(void) pthread_join(slottable->st_tid, NULL);
			}
		}
	} else {
		(void) pthread_mutex_unlock(&slottable->st_mutex);
	}

	rv = pkcs11_slottable_delete();

	return (rv);
}

static void
pkcs11_init()
{
	(void) pthread_atfork(pkcs11_fork_prepare,
	    pkcs11_fork_parent, pkcs11_fork_child);
}

/*
 * pkcs11_fini() function required to make sure complete cleanup
 * is done of plugins if the framework is ever unloaded without
 * a C_Finalize() call.  This would be common when applications
 * load and unload other libraries that use libpkcs11(3lib), since
 * shared libraries should not call C_Finalize().
 *
 * If pkcs11_fini() is used, we set fini_called to B_TRUE so that
 * pkcs11_slottable_delete() will not call C_Finalize() on the plugins.
 *
 * This is to protect in cases where the application has dlopened
 * an object (for example, dlobj) that links to libpkcs11(3lib), but
 * the application is unaware that the object is doing PKCS#11 calls
 * underneath.  This application may later directly dlopen one of the
 * plugins (like pkcs11_softtoken.so, or any other 3rd party provided
 * plugin) in order to directly perform PKCS#11 operations.
 *
 * While it is still actively using the PKCS#11 plugin directly,
 * the application may finish with dlobj and dlclose it.  As the
 * reference count for libpkcs11(3lib) has become 0, pkcs11_fini()
 * will be run by the linker.  Even though libpkcs11(3lib) was the
 * first to initialize the plugin in this case, it is not safe for
 * libpkcs11(3lib) to finalize the plugin, as the application would
 * lose state.
 */
static void
pkcs11_fini()
{
	(void) pthread_mutex_lock(&globalmutex);

	/* if we're not initilized, do not attempt to finalize */
	if (!pkcs11_initialized) {
		(void) pthread_mutex_unlock(&globalmutex);
		return;
	}

	fini_called = B_TRUE;

	(void) finalize_common(NULL_PTR);

	(void) pthread_mutex_unlock(&globalmutex);

}

CK_RV
C_GetInfo(CK_INFO_PTR pInfo)
{

	/* Check for a fastpath */
	if (purefastpath || policyfastpath) {
		return (fast_funcs->C_GetInfo(pInfo));
	}

	if (!pkcs11_initialized)
		return (CKR_CRYPTOKI_NOT_INITIALIZED);

	if (pInfo == NULL) {
		return (CKR_ARGUMENTS_BAD);
	}

	/*
	 * Copy data into the provided buffer, use strncpy() instead
	 * of strlcpy() so that the strings are NOT NULL terminated,
	 * as required by the PKCS#11 standard
	 */
	(void) strncpy((char *)pInfo->manufacturerID, MANUFACTURER_ID,
	    PKCS11_STRING_LENGTH);
	(void) strncpy((char *)pInfo->libraryDescription,
	    LIBRARY_DESCRIPTION, PKCS11_STRING_LENGTH);

	pInfo->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR;
	pInfo->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR;
	pInfo->flags = 0;
	pInfo->libraryVersion.major = LIBRARY_VERSION_MAJOR;
	pInfo->libraryVersion.minor = LIBRARY_VERSION_MINOR;

	return (CKR_OK);
}

/*
 * This function is unaffected by the fast-path, since it is likely
 * called before C_Initialize is, so we will not yet know the status
 * of the fast-path.  Additionally, policy will still need to be
 * enforced if applicable.
 */
CK_RV
C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList)
{
	if (ppFunctionList == NULL) {
		return (CKR_ARGUMENTS_BAD);
	}

	*ppFunctionList = &functionList;

	return (CKR_OK);
}


/*
 * This function is no longer supported in this revision of the PKCS#11
 * standard.  It is maintained for backwards compatibility only.
 */
/*ARGSUSED*/
CK_RV
C_GetFunctionStatus(CK_SESSION_HANDLE hSession)
{
	return (CKR_FUNCTION_NOT_PARALLEL);
}


/*
 * This function is no longer supported in this revision of the PKCS#11
 * standard.  It is maintained for backwards compatibility only.
 */
/*ARGSUSED*/
CK_RV
C_CancelFunction(CK_SESSION_HANDLE hSession)
{
	return (CKR_FUNCTION_NOT_PARALLEL);
}