Ejemplo n.º 1
0
void pkcs11_logger_log(const char* message, ...)
{
	FILE *fw = NULL;
	FILE *output = stdout;
	va_list ap;
	
	// Acquire exclusive access to the file
	pkcs11_logger_lock_acquire();
	
	va_start(ap, message);
	
	// Determine log filename
	char *log_file_name = getenv("PKCS11_LOGGER_LOG_FILE");
	if (NULL == log_file_name)
		log_file_name = DEFAULT_PKCS11_LOGGER_LOG_FILE;
	
	// Open log file
	fw = fopen(log_file_name, "a");
	if (NULL != fw)
		output = fw;
	
	// Output message to log file or stdout
	fprintf(output, "%0#10x : ", get_process_id());
	fprintf(output, "%0#10x : ", get_thread_id());
	vfprintf(output, message, ap);
	fprintf(output, "\n");
	
	// Cleanup
	va_end(ap);
	CALL_N_CLEAR(fclose, fw);
	
	// Release exclusive access to the file
	pkcs11_logger_lock_release();
}
Ejemplo n.º 2
0
void pkcs11_logger_log_attribute_template_with_indent(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, int level)
{
	int i = 0;
	char indent[level*3+1];
	char horizontal_line[] = "--------------------------------------";


	if ((NULL == pTemplate) || (ulCount < 1))
		return;
	
	for(i = 0; i < level*3+1; i++)
	{
		indent[i] = ' ';
	}
	if(i > 1) {
		indent[i++] = '|';
	}
	indent[i] = '\0';

	for (i = 0; i < ulCount; i++)
	{
		pkcs11_logger_log("%s  Attribute %d", indent, i);
		pkcs11_logger_log("%s   Attribute: %lu (%s)", indent, pTemplate[i].type, pkcs11_logger_translate_ck_attribute(pTemplate[i].type));
		pkcs11_logger_log("%s   pValue: %p", indent, pTemplate[i].pValue);
		pkcs11_logger_log("%s   ulValueLen: %lu", indent, pTemplate[i].ulValueLen);

		if (NULL != pTemplate[i].pValue)
		{
			char *value = NULL;
			if(0x40000000 & pTemplate[i].type)
			{
				pkcs11_logger_log("%s   *pValue: is nested attribute array", indent);
				pkcs11_logger_log("%s   %s", indent, horizontal_line);
				pkcs11_logger_log_attribute_template_with_indent(pTemplate[i].pValue, pTemplate[i].ulValueLen / sizeof(CK_ATTRIBUTE), level + 1);
				pkcs11_logger_log("%s   %s", indent, horizontal_line);
			}
			else
			{
				value = pkcs11_logger_translate_ck_byte_ptr(pTemplate[i].pValue, pTemplate[i].ulValueLen);
				if (NULL != value)
				{
					pkcs11_logger_log("%s   *pValue: HEX(%s)", indent, value);
					CALL_N_CLEAR(free, value);
				}
				else
				{
					pkcs11_logger_log("%s   *pValue: *** cannot be displayed ***", indent);
				}
			}
		}
	}
}
Ejemplo n.º 3
0
void pkcs11_logger_log_byte_array(const char *name, CK_BYTE_PTR byte_array, CK_ULONG byte_array_len)
{
	if (NULL != byte_array)
	{
		char *array = NULL;
		array = pkcs11_logger_translate_ck_byte_ptr(byte_array, byte_array_len);
		if (NULL != array)
		{
			pkcs11_logger_log("%s: HEX(%s)", name, array);
			CALL_N_CLEAR(free, array);
		}
		else
		{
			pkcs11_logger_log("%s: *** cannot be displayed ***", name);
		}
	}
}
Ejemplo n.º 4
0
// Logs array of cryptoki attributes
void pkcs11_logger_log_attribute_template(CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
{
    CK_ULONG i = 0;
    
    if ((NULL == pTemplate) || (ulCount < 1))
        return;
    
    pkcs11_logger_log("  *** Begin attribute template ***");
    
    for (i = 0; i < ulCount; i++)
    {
        pkcs11_logger_log("  Attribute %d", i);
        pkcs11_logger_log("   Attribute: %lu (%s)", pTemplate[i].type, pkcs11_logger_translate_ck_attribute(pTemplate[i].type));
        pkcs11_logger_log("   pValue: %p", pTemplate[i].pValue);
        pkcs11_logger_log("   ulValueLen: %lu", pTemplate[i].ulValueLen);

        if (NULL != pTemplate[i].pValue)
        {
            char *value = NULL;

            if ((pTemplate[i].type & CKF_ARRAY_ATTRIBUTE) == CKF_ARRAY_ATTRIBUTE)
            {
                if (0 == (pTemplate[i].ulValueLen % sizeof(CK_ATTRIBUTE)))
                {
                    pkcs11_logger_log_attribute_template(pTemplate[i].pValue, pTemplate[i].ulValueLen / sizeof(CK_ATTRIBUTE));
                    continue;
                }
            }

            value = pkcs11_logger_translate_ck_byte_ptr(pTemplate[i].pValue, pTemplate[i].ulValueLen);
            if (NULL != value)
            {
                pkcs11_logger_log("   *pValue: HEX(%s)", value);
                CALL_N_CLEAR(free, value);
            }
            else
            {
                pkcs11_logger_log("   *pValue: *** cannot be displayed ***");
            }
        }
    }

    pkcs11_logger_log("  *** End attribute template ***");
}
Ejemplo n.º 5
0
void pkcs11_logger_log_nonzero_string(const char *name, const unsigned char *nonzero_string, CK_ULONG nonzero_string_len)
{
	if (NULL != nonzero_string)
	{
		unsigned char *zero_string = NULL;
		zero_string = (unsigned char*) malloc(nonzero_string_len + 1);
		if (NULL != zero_string)
		{
			memset(zero_string, 0, nonzero_string_len + 1);
			memcpy(zero_string, nonzero_string, nonzero_string_len);
			pkcs11_logger_log("%s: %s", name, zero_string);
			CALL_N_CLEAR(free, zero_string);
		}
		else
		{
			pkcs11_logger_log("%s: *** cannot be displayed ***", name);
		}
	}
}
Ejemplo n.º 6
0
// Logs message
void pkcs11_logger_log(const char* message, ...)
{
    va_list ap;

    unsigned long disable_log_file = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_DISABLE_LOG_FILE) == PKCS11_LOGGER_FLAG_DISABLE_LOG_FILE);
    unsigned long disable_process_id = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_DISABLE_PROCESS_ID) == PKCS11_LOGGER_FLAG_DISABLE_PROCESS_ID);
    unsigned long disable_thread_id = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_DISABLE_THREAD_ID) == PKCS11_LOGGER_FLAG_DISABLE_THREAD_ID);
    unsigned long enable_stdout = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_ENABLE_STDOUT) == PKCS11_LOGGER_FLAG_ENABLE_STDOUT);
    unsigned long enable_stderr = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_ENABLE_STDERR) == PKCS11_LOGGER_FLAG_ENABLE_STDERR);
    unsigned long enable_fclose = ((pkcs11_logger_globals.flags & PKCS11_LOGGER_FLAG_ENABLE_FCLOSE) == PKCS11_LOGGER_FLAG_ENABLE_FCLOSE);

    // Acquire exclusive access to the file
    pkcs11_logger_lock_acquire();

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable: 4996)
#endif

    // Open log file
    if ((!disable_log_file) && (NULL != pkcs11_logger_globals.env_var_log_file_path) && (NULL == pkcs11_logger_globals.log_file_handle))
    {
        pkcs11_logger_globals.log_file_handle = fopen((const char *)pkcs11_logger_globals.env_var_log_file_path, "a");
    }

#ifdef _WIN32
#pragma warning(pop)
#endif

    // Log to file
    if ((!disable_log_file) && (NULL != pkcs11_logger_globals.log_file_handle))
    {
        va_start(ap, message);

        if (!disable_process_id)
            fprintf(pkcs11_logger_globals.log_file_handle, "%0#10x : ", pkcs11_logger_utils_get_process_id());
        if (!disable_thread_id)
            fprintf(pkcs11_logger_globals.log_file_handle, "%0#10x : ", pkcs11_logger_utils_get_thread_id());
        vfprintf(pkcs11_logger_globals.log_file_handle, message, ap);
        fprintf(pkcs11_logger_globals.log_file_handle, "\n");

        va_end(ap);
    }

    // Log to stdout
    if (enable_stdout)
    {
        va_start(ap, message);

        if (!disable_process_id)
            fprintf(stdout, "%0#10x : ", pkcs11_logger_utils_get_process_id());
        if (!disable_thread_id)
            fprintf(stdout, "%0#10x : ", pkcs11_logger_utils_get_thread_id());
        vfprintf(stdout, message, ap);
        fprintf(stdout, "\n");

        va_end(ap);
    }

    // Log to stderr
    if (enable_stderr || CK_FALSE == pkcs11_logger_globals.env_vars_read)
    {
        va_start(ap, message);

        if (!disable_process_id)
            fprintf(stderr, "%0#10x : ", pkcs11_logger_utils_get_process_id());
        if (!disable_thread_id)
            fprintf(stderr, "%0#10x : ", pkcs11_logger_utils_get_thread_id());
        vfprintf(stderr, message, ap);
        fprintf(stderr, "\n");

        va_end(ap);
    }

    // Cleanup
    if (enable_fclose)
    {
        CALL_N_CLEAR(fclose, pkcs11_logger_globals.log_file_handle);
    }
    else
    {
        if (NULL != pkcs11_logger_globals.log_file_handle)
            fflush(pkcs11_logger_globals.log_file_handle);
    }
    
    // Release exclusive access to the file
    pkcs11_logger_lock_release();
}