#include "p11-tests.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x400
#include <windows.h>
#else
#include <errno.h>
#endif

#include <openssl/err.h>

static const char *the_prefix = NULL;

const char*
p11t_msg_rv(CK_RV rv)
{
	switch(rv) {
	#define CT(x)	case x: return #x;
	CT(CKR_OK)
	CT(CKR_CANCEL)
	CT(CKR_HOST_MEMORY)
	CT(CKR_SLOT_ID_INVALID)
	CT(CKR_GENERAL_ERROR)
	CT(CKR_FUNCTION_FAILED)
	CT(CKR_ARGUMENTS_BAD)
	CT(CKR_NO_EVENT)
	CT(CKR_NEED_TO_CREATE_THREADS)
	CT(CKR_CANT_LOCK)
	CT(CKR_ATTRIBUTE_READ_ONLY)
	CT(CKR_ATTRIBUTE_SENSITIVE)
	CT(CKR_ATTRIBUTE_TYPE_INVALID)
	CT(CKR_ATTRIBUTE_VALUE_INVALID)
	CT(CKR_DATA_INVALID)
	CT(CKR_DATA_LEN_RANGE)
	CT(CKR_DEVICE_ERROR)
	CT(CKR_DEVICE_MEMORY)
	CT(CKR_DEVICE_REMOVED)
	CT(CKR_ENCRYPTED_DATA_INVALID)
	CT(CKR_ENCRYPTED_DATA_LEN_RANGE)
	CT(CKR_FUNCTION_CANCELED)
	CT(CKR_FUNCTION_NOT_PARALLEL)
	CT(CKR_FUNCTION_NOT_SUPPORTED)
	CT(CKR_KEY_HANDLE_INVALID)
	CT(CKR_KEY_SIZE_RANGE)
	CT(CKR_KEY_TYPE_INCONSISTENT)
	CT(CKR_KEY_NOT_NEEDED)
	CT(CKR_KEY_CHANGED)
	CT(CKR_KEY_NEEDED)
	CT(CKR_KEY_INDIGESTIBLE)
	CT(CKR_KEY_FUNCTION_NOT_PERMITTED)
	CT(CKR_KEY_NOT_WRAPPABLE)
	CT(CKR_KEY_UNEXTRACTABLE)
	CT(CKR_MECHANISM_INVALID)
	CT(CKR_MECHANISM_PARAM_INVALID)
	CT(CKR_OBJECT_HANDLE_INVALID)
	CT(CKR_OPERATION_ACTIVE)
	CT(CKR_OPERATION_NOT_INITIALIZED)
	CT(CKR_PIN_INCORRECT)
	CT(CKR_PIN_INVALID)
	CT(CKR_PIN_LEN_RANGE)
	CT(CKR_PIN_EXPIRED)
	CT(CKR_PIN_LOCKED)
	CT(CKR_SESSION_CLOSED)
	CT(CKR_SESSION_COUNT)
	CT(CKR_SESSION_HANDLE_INVALID)
	CT(CKR_SESSION_PARALLEL_NOT_SUPPORTED)
	CT(CKR_SESSION_READ_ONLY)
	CT(CKR_SESSION_EXISTS)
	CT(CKR_SESSION_READ_ONLY_EXISTS)
	CT(CKR_SESSION_READ_WRITE_SO_EXISTS)
	CT(CKR_SIGNATURE_INVALID)
	CT(CKR_SIGNATURE_LEN_RANGE)
	CT(CKR_TEMPLATE_INCOMPLETE)
	CT(CKR_TEMPLATE_INCONSISTENT)
	CT(CKR_TOKEN_NOT_PRESENT)
	CT(CKR_TOKEN_NOT_RECOGNIZED)
	CT(CKR_TOKEN_WRITE_PROTECTED)
	CT(CKR_UNWRAPPING_KEY_HANDLE_INVALID)
	CT(CKR_UNWRAPPING_KEY_SIZE_RANGE)
	CT(CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT)
	CT(CKR_USER_ALREADY_LOGGED_IN)
	CT(CKR_USER_NOT_LOGGED_IN)
	CT(CKR_USER_PIN_NOT_INITIALIZED)
	CT(CKR_USER_TYPE_INVALID)
	CT(CKR_USER_ANOTHER_ALREADY_LOGGED_IN)
	CT(CKR_USER_TOO_MANY_TYPES)
	CT(CKR_WRAPPED_KEY_INVALID)
	CT(CKR_WRAPPED_KEY_LEN_RANGE)
	CT(CKR_WRAPPING_KEY_HANDLE_INVALID)
	CT(CKR_WRAPPING_KEY_SIZE_RANGE)
	CT(CKR_WRAPPING_KEY_TYPE_INCONSISTENT)
	CT(CKR_RANDOM_SEED_NOT_SUPPORTED)
	CT(CKR_RANDOM_NO_RNG)
	CT(CKR_DOMAIN_PARAMS_INVALID)
	CT(CKR_BUFFER_TOO_SMALL)
	CT(CKR_SAVED_STATE_INVALID)
	CT(CKR_INFORMATION_SENSITIVE)
	CT(CKR_STATE_UNSAVEABLE)
	CT(CKR_CRYPTOKI_NOT_INITIALIZED)
	CT(CKR_CRYPTOKI_ALREADY_INITIALIZED)
	CT(CKR_MUTEX_BAD)
	CT(CKR_MUTEX_NOT_LOCKED)
	CT(CKR_FUNCTION_REJECTED)
	CT(CKR_VENDOR_DEFINED)
	#undef CT
	default:
		p11t_check_warn("unknown or invalid CK_RV value encountered: 0x%08X", rv);
		return "";
	}
}

#ifdef _WIN32

static char last_error[1024];

const char*
p11t_msg_os(void)
{
	LPVOID lpMsgBuf;
	DWORD error = GetLastError();
	DWORD dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
	                            FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, error,
	                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
								(LPTSTR) &lpMsgBuf, 0, NULL);
	if(dwRet && lpMsgBuf)
	{
		strncpy(last_error, lpMsgBuf, 1024);
		LocalFree(lpMsgBuf);
	}
	else
	{
		_snprintf(last_error, 1024, "unknown error: 0x%08x", (int)error);
	}

	return last_error;
}

#else /* _WIN32 */

const char*
p11t_msg_os(void)
{
	return strerror(errno);
}

#endif /* _WIN32 */

const char*
p11t_msg_openssl(void)
{
	return ERR_error_string(ERR_get_error(), NULL);
}

void
p11t_msg_va(const char *message, va_list va)
{
	size_t len;

	if(the_prefix)
		fprintf(stdout, "%s: ", the_prefix);
	vfprintf(stdout, message, va);
	len = strlen(message);
	if(len && message[len - 1] != '\n')
		fputc('\n', stdout);
	fflush(stdout);
}

void
p11t_msg_code(const char *code, const char *message, va_list va)
{
	size_t len;

	fprintf(stdout, "%s: ", code);
	if(the_prefix)
		fprintf(stdout, "%s: ", the_prefix);
	vfprintf(stdout, message, va);
	len = strlen(message);
	if(len && message[len - 1] != '\n')
		fputc('\n', stdout);
	fflush(stdout);
}


void
p11t_msg_print(const char *message, ...)
{
	va_list va;
	va_start(va, message);
	p11t_msg_va(message, va);
	va_end(va);
}

void
p11t_msg_fatal(const char *message, ...)
{
	va_list va;
	va_start(va, message);
	p11t_msg_va(message, va);
	va_end(va);
	exit(1);
}

const char*
p11t_msg_prefix(const char *prefix)
{
	const char *old = the_prefix;
	the_prefix = prefix;
	return old;
}