gecko/security/nss/lib/libpkix/pkix/util/pkix_logger.c
2009-01-21 04:43:31 +01:00

1122 lines
35 KiB
C

/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is the PKIX-C library.
*
* The Initial Developer of the Original Code is
* Sun Microsystems, Inc.
* Portions created by the Initial Developer are
* Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
*
* Contributor(s):
* Sun Microsystems, Inc.
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/*
* pkix_logger.c
*
* Logger Object Functions
*
*/
#include "pkix_logger.h"
#ifndef PKIX_ERROR_DESCRIPTION
#include "prprf.h"
#endif
/* Global variable to keep PKIX_Logger List */
PKIX_List *pkixLoggers = NULL;
/*
* Once the Logger has been set, for any logging related operations, we have
* to go through the List to find a match, and if found, issue the
* corresponding callback. The overhead to check for DEBUG and TRACE in each
* PKIX function entering and exiting is very expensive (400X), and redundant
* if they are not the interest of the Logger. Therefore, the PKIX_Logger List
* pkixLoggers is separated into two lists based on its Loggers' trace level.
*
* Whenever the pkixLoggers List is updated by PKIX_Logger_AddLogger() or
* PKIX_Logger_SetLoggers(), we destroy and reconstruct pkixLoggersErrors
* and pkixLoggersDebugTrace Logger Lists. The ERROR, FATAL_ERROR and
* WARNING goes to pkixLoggersErrors and the DEBUG and TRACE goes to
* pkixLoggersDebugTrace.
*
* Currently we provide five logging levels and the default setting are by:
*
* PKIX_FATAL_ERROR() macro invokes pkix_Logger_Check of FATAL_ERROR level
* PKIX_ERROR() macro invokes pkix_Logger_Check of ERROR level
* WARNING is not invoked as default
* PKIX_DEBUG() macro invokes pkix_Logger_Check of DEBUG level. This needs
* compilation -DPKIX_<component>DEBUG flag to turn on
* PKIX_ENTER() and PKIX_RETURN() macros invoke pkix_Logger_Check of TRACE
* level. TRACE provides duplicate information of DEBUG, but needs no
* recompilation and cannot choose component. To allow application
* to use DEBUG level, TRACE is put as last.
*
*/
PKIX_List *pkixLoggersErrors = NULL;
PKIX_List *pkixLoggersDebugTrace = NULL;
/* To ensure atomic update on pkixLoggers lists */
PKIX_PL_MonitorLock *pkixLoggerLock = NULL;
/* --Private-Functions-------------------------------------------- */
/*
* FUNCTION: pkix_Logger_CheckErrors
* DESCRIPTION:
*
* This function goes through each PKIX_Logger at "pkixLoggersList" and
* checks if "maxLevel" and "logComponent" satisfies what is specified in the
* PKIX_Logger. If satisfies, it invokes the callback in PKIX_Logger and
* passes a PKIX_PL_String that is the concatenation of "message" and
* "message2" to the application for processing.
* Since this call is inserted into a handful of PKIX macros, no macros are
* applied in this function, to avoid infinite recursion.
* If an error occurs, this call is aborted.
*
* PARAMETERS:
* "pkixLoggersList"
* A list of PKIX_Loggers to be examined for invoking callback. Must be
* non-NULL.
* "message"
* Address of "message" to be logged. Must be non-NULL.
* "message2"
* Address of "message2" to be concatenated and logged. May be NULL.
* "logComponent"
* A PKIX_UInt32 that indicates the component the message is from.
* "maxLevel"
* A PKIX_UInt32 that represents the level of severity of the message.
* "plContext"
* Platform-specific context pointer.
* THREAD SAFETY:
* Thread Safe (see Thread Safety Definitions in Programmer's Guide)
* RETURNS:
* Returns NULL if the function succeeds
* Returns a Fatal Error if the function fails in an unrecoverable way
*/
PKIX_Error *
pkix_Logger_Check(
PKIX_List *pkixLoggersList,
const char *message,
const char *message2,
PKIX_ERRORCLASS logComponent,
PKIX_UInt32 currentLevel,
void *plContext)
{
PKIX_Logger *logger = NULL;
PKIX_List *savedPkixLoggersErrors = NULL;
PKIX_List *savedPkixLoggersDebugTrace = NULL;
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *messageString = NULL;
PKIX_PL_String *message2String = NULL;
PKIX_PL_String *msgString = NULL;
PKIX_Error *error = NULL;
PKIX_Boolean needLogging = PKIX_FALSE;
PKIX_UInt32 i, length;
/*
* We cannot use any the PKIX_ macros here, since this function is
* called from some of these macros. It can create infinite recursion.
*/
if ((pkixLoggersList == NULL) || (message == NULL)) {
return(NULL);
}
/*
* Disable all subsequent loggings to avoid recursion. The result is
* if other thread is calling this function at the same time, there
* won't be any logging because the pkixLoggersErrors and
* pkixLoggersDebugTrace are set to null.
* It would be nice if we provide control per thread (e.g. make
* plContext threadable) then we can avoid the recursion by setting
* flag at plContext. Then other thread's logging won't be affected.
*
* Also we need to use a reentrant Lock. Although we avoid recursion
* for TRACE. When there is an ERROR occurs in subsequent call, this
* function will be called.
*/
error = PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext);
if (error) { return(NULL); }
savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
pkixLoggersDebugTrace = NULL;
savedPkixLoggersErrors = pkixLoggersErrors;
pkixLoggersErrors = NULL;
/* Convert message and message2 to String */
error = PKIX_PL_String_Create
(PKIX_ESCASCII, message, 0, &messageString, plContext);
if (error) { goto cleanup; }
if (message2) {
error = PKIX_PL_String_Create
(PKIX_ESCASCII, message2, 0, &message2String, plContext);
if (error) { goto cleanup; }
error = PKIX_PL_String_Create
(PKIX_ESCASCII, "%s %s", 0, &formatString, plContext);
if (error) { goto cleanup; }
} else {
error = PKIX_PL_String_Create
(PKIX_ESCASCII, "%s", 0, &formatString, plContext);
if (error) { goto cleanup; }
}
error = PKIX_PL_Sprintf
(&msgString,
plContext,
formatString,
messageString,
message2String);
if (error) { goto cleanup; }
/* Go through the Logger list */
error = PKIX_List_GetLength(pkixLoggersList, &length, plContext);
if (error) { goto cleanup; }
for (i = 0; i < length; i++) {
error = PKIX_List_GetItem
(pkixLoggersList,
i,
(PKIX_PL_Object **) &logger,
plContext);
if (error) { goto cleanup; }
/* Intended logging level less or equal than the max */
needLogging = (currentLevel <= logger->maxLevel);
if (needLogging && (logger->callback)) {
/*
* We separate Logger into two lists based on log level
* but log level is not modified. We need to check here to
* avoid logging the higher log level (lower value) twice.
*/
if (pkixLoggersList == pkixLoggersErrors) {
needLogging = needLogging &&
(currentLevel <= PKIX_LOGGER_LEVEL_WARNING);
} else if (pkixLoggersList == pkixLoggersDebugTrace) {
needLogging = needLogging &&
(currentLevel > PKIX_LOGGER_LEVEL_WARNING);
}
if (needLogging) {
if (logComponent == logger->logComponent) {
needLogging = PKIX_TRUE;
} else {
needLogging = PKIX_FALSE;
}
}
if (needLogging) {
error = logger->callback
(logger,
msgString,
currentLevel,
logComponent,
plContext);
if (error) { goto cleanup; }
}
}
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)logger, plContext);
logger = NULL;
if (error) { goto cleanup; }
}
cleanup:
if (formatString) {
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)formatString, plContext);
}
if (messageString) {
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)messageString, plContext);
}
if (message2String) {
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)message2String, plContext);
}
if (msgString) {
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)msgString, plContext);
}
if (logger) {
error = PKIX_PL_Object_DecRef
((PKIX_PL_Object *)logger, plContext);
}
if (pkixLoggersErrors == NULL && savedPkixLoggersErrors != NULL) {
pkixLoggersErrors = savedPkixLoggersErrors;
}
if (pkixLoggersDebugTrace == NULL &&
savedPkixLoggersDebugTrace != NULL) {
pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
}
error = PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext);
if (error) { return(NULL); }
return(NULL);
}
PKIX_Error *
pkix_Logger_CheckWithCode(
PKIX_List *pkixLoggersList,
PKIX_UInt32 errorCode,
const char *message2,
PKIX_ERRORCLASS logComponent,
PKIX_UInt32 currentLevel,
void *plContext)
{
char error[32];
char *errorString = NULL;
PKIX_ENTER(LOGGER, "pkix_Logger_CheckWithCode");
#if defined PKIX_ERROR_DESCRIPTION
errorString = PKIX_ErrorText[errorCode];
#else
PR_snprintf(error, 32, "Error code: %d", errorCode);
errorString = error;
#endif /* PKIX_ERROR_DESCRIPTION */
pkixErrorResult = pkix_Logger_Check(pkixLoggersList, errorString,
message2, logComponent,
currentLevel, plContext);
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_Destroy
* (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Logger_Destroy(
PKIX_PL_Object *object,
void *plContext)
{
PKIX_Logger *logger = NULL;
PKIX_ENTER(LOGGER, "pkix_Logger_Destroy");
PKIX_NULLCHECK_ONE(object);
/* Check that this object is a logger */
PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),
PKIX_OBJECTNOTLOGGER);
logger = (PKIX_Logger *)object;
/* We have a valid logger. DecRef its item and recurse on next */
logger->callback = NULL;
PKIX_DECREF(logger->context);
logger->logComponent = (PKIX_ERRORCLASS)NULL;
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_ToString
* (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Logger_ToString(
PKIX_PL_Object *object,
PKIX_PL_String **pString,
void *plContext)
{
PKIX_Logger *logger = NULL;
char *asciiFormat = NULL;
PKIX_PL_String *formatString = NULL;
PKIX_PL_String *contextString = NULL;
PKIX_PL_String *componentString = NULL;
PKIX_PL_String *loggerString = NULL;
PKIX_ENTER(LOGGER, "pkix_Logger_ToString_Helper");
PKIX_NULLCHECK_TWO(object, pString);
/* Check that this object is a logger */
PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),
PKIX_OBJECTNOTLOGGER);
logger = (PKIX_Logger *)object;
asciiFormat =
"[\n"
"\tLogger: \n"
"\tContext: %s\n"
"\tMaximum Level: %d\n"
"\tComponent Name: %s\n"
"]\n";
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
asciiFormat,
0,
&formatString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_TOSTRING(logger->context, &contextString, plContext,
PKIX_OBJECTTOSTRINGFAILED);
PKIX_CHECK(PKIX_PL_String_Create
(PKIX_ESCASCII,
(void *)PKIX_ERRORCLASSNAMES[logger->logComponent],
0,
&componentString,
plContext),
PKIX_STRINGCREATEFAILED);
PKIX_CHECK(PKIX_PL_Sprintf
(&loggerString,
plContext,
formatString,
contextString,
logger->maxLevel,
componentString),
PKIX_SPRINTFFAILED);
*pString = loggerString;
cleanup:
PKIX_DECREF(formatString);
PKIX_DECREF(contextString);
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_Equals
* (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Logger_Equals(
PKIX_PL_Object *first,
PKIX_PL_Object *second,
PKIX_Boolean *pResult,
void *plContext)
{
PKIX_UInt32 secondType;
PKIX_Boolean cmpResult;
PKIX_Logger *firstLogger = NULL;
PKIX_Logger *secondLogger = NULL;
PKIX_ENTER(LOGGER, "pkix_Logger_Equals");
PKIX_NULLCHECK_THREE(first, second, pResult);
/* test that first is a Logger */
PKIX_CHECK(pkix_CheckType(first, PKIX_LOGGER_TYPE, plContext),
PKIX_FIRSTOBJECTNOTLOGGER);
/*
* Since we know first is a Logger, if both references are
* identical, they must be equal
*/
if (first == second){
*pResult = PKIX_TRUE;
goto cleanup;
}
/*
* If second isn't a Logger, we don't throw an error.
* We simply return a Boolean result of FALSE
*/
*pResult = PKIX_FALSE;
PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
if (secondType != PKIX_LOGGER_TYPE) goto cleanup;
firstLogger = (PKIX_Logger *)first;
secondLogger = (PKIX_Logger *)second;
cmpResult = PKIX_FALSE;
if (firstLogger->callback != secondLogger->callback) {
goto cleanup;
}
if (firstLogger->logComponent != secondLogger->logComponent) {
goto cleanup;
}
PKIX_EQUALS
(firstLogger->context,
secondLogger->context,
&cmpResult,
plContext,
PKIX_OBJECTEQUALSFAILED);
if (cmpResult == PKIX_FALSE) {
goto cleanup;
}
if (firstLogger->maxLevel != secondLogger->maxLevel) {
goto cleanup;
}
*pResult = cmpResult;
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_Hashcode
* (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Logger_Hashcode(
PKIX_PL_Object *object,
PKIX_UInt32 *pHashcode,
void *plContext)
{
PKIX_Logger *logger = NULL;
PKIX_UInt32 hash = 0;
PKIX_UInt32 tempHash = 0;
PKIX_ENTER(LOGGER, "pkix_Logger_Hashcode");
PKIX_NULLCHECK_TWO(object, pHashcode);
PKIX_CHECK(pkix_CheckType(object, PKIX_LOGGER_TYPE, plContext),
PKIX_OBJECTNOTLOGGER);
logger = (PKIX_Logger *)object;
PKIX_HASHCODE(logger->context, &tempHash, plContext,
PKIX_OBJECTHASHCODEFAILED);
hash = (((((PKIX_UInt32) logger->callback + tempHash) << 7) +
logger->maxLevel) << 7) + (PKIX_UInt32)logger->logComponent;
*pHashcode = hash;
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_Duplicate
* (see comments for PKIX_PL_DuplicateCallback in pkix_pl_system.h)
*/
static PKIX_Error *
pkix_Logger_Duplicate(
PKIX_PL_Object *object,
PKIX_PL_Object **pNewObject,
void *plContext)
{
PKIX_Logger *logger = NULL;
PKIX_Logger *dupLogger = NULL;
PKIX_ENTER(LOGGER, "pkix_Logger_Duplicate");
PKIX_NULLCHECK_TWO(object, pNewObject);
PKIX_CHECK(pkix_CheckType
((PKIX_PL_Object *)object, PKIX_LOGGER_TYPE, plContext),
PKIX_OBJECTNOTLOGGER);
logger = (PKIX_Logger *) object;
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_LOGGER_TYPE,
sizeof (PKIX_Logger),
(PKIX_PL_Object **)&dupLogger,
plContext),
PKIX_COULDNOTCREATELOGGEROBJECT);
dupLogger->callback = logger->callback;
dupLogger->maxLevel = logger->maxLevel;
PKIX_DUPLICATE
(logger->context,
&dupLogger->context,
plContext,
PKIX_OBJECTDUPLICATEFAILED);
dupLogger->logComponent = logger->logComponent;
*pNewObject = (PKIX_PL_Object *) dupLogger;
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_DECREF(dupLogger);
}
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: pkix_Logger_RegisterSelf
* DESCRIPTION:
* Registers PKIX_LOGGER_TYPE and its related functions with systemClasses[]
* THREAD SAFETY:
* Not Thread Safe - for performance and complexity reasons
*
* Since this function is only called by PKIX_PL_Initialize, which should
* only be called once, it is acceptable that this function is not
* thread-safe.
*/
PKIX_Error *
pkix_Logger_RegisterSelf(void *plContext)
{
extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
pkix_ClassTable_Entry entry;
PKIX_ENTER(LOGGER, "pkix_Logger_RegisterSelf");
entry.description = "Logger";
entry.objCounter = 0;
entry.typeObjectSize = sizeof(PKIX_Logger);
entry.destructor = pkix_Logger_Destroy;
entry.equalsFunction = pkix_Logger_Equals;
entry.hashcodeFunction = pkix_Logger_Hashcode;
entry.toStringFunction = pkix_Logger_ToString;
entry.comparator = NULL;
entry.duplicateFunction = pkix_Logger_Duplicate;
systemClasses[PKIX_LOGGER_TYPE] = entry;
PKIX_RETURN(LOGGER);
}
/* --Public-Logger-Functions--------------------------------------------- */
/*
* FUNCTION: PKIX_Logger_Create (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_Create(
PKIX_Logger_LogCallback callback,
PKIX_PL_Object *loggerContext,
PKIX_Logger **pLogger,
void *plContext)
{
PKIX_Logger *logger = NULL;
PKIX_ENTER(LOGGER, "PKIX_Logger_Create");
PKIX_NULLCHECK_ONE(pLogger);
PKIX_CHECK(PKIX_PL_Object_Alloc
(PKIX_LOGGER_TYPE,
sizeof (PKIX_Logger),
(PKIX_PL_Object **)&logger,
plContext),
PKIX_COULDNOTCREATELOGGEROBJECT);
logger->callback = callback;
logger->maxLevel = 0;
logger->logComponent = (PKIX_ERRORCLASS)NULL;
PKIX_INCREF(loggerContext);
logger->context = loggerContext;
*pLogger = logger;
logger = NULL;
cleanup:
PKIX_DECREF(logger);
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_GetLogCallback (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_GetLogCallback(
PKIX_Logger *logger,
PKIX_Logger_LogCallback *pCallback,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_GetLogCallback");
PKIX_NULLCHECK_TWO(logger, pCallback);
*pCallback = logger->callback;
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_GetLoggerContext (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_GetLoggerContext(
PKIX_Logger *logger,
PKIX_PL_Object **pLoggerContext,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggerContex");
PKIX_NULLCHECK_TWO(logger, pLoggerContext);
PKIX_INCREF(logger->context);
*pLoggerContext = logger->context;
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_GetMaxLoggingLevel (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_GetMaxLoggingLevel(
PKIX_Logger *logger,
PKIX_UInt32 *pLevel,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_GetMaxLoggingLevel");
PKIX_NULLCHECK_TWO(logger, pLevel);
*pLevel = logger->maxLevel;
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_SetMaxLoggingLevel (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_SetMaxLoggingLevel(
PKIX_Logger *logger,
PKIX_UInt32 level,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_SetMaxLoggingLevel");
PKIX_NULLCHECK_ONE(logger);
if (level > PKIX_LOGGER_LEVEL_MAX) {
PKIX_ERROR(PKIX_LOGGINGLEVELEXCEEDSMAXIMUM);
} else {
logger->maxLevel = level;
}
cleanup:
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_GetLoggingComponent (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_GetLoggingComponent(
PKIX_Logger *logger,
PKIX_ERRORCLASS *pComponent,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggingComponent");
PKIX_NULLCHECK_TWO(logger, pComponent);
*pComponent = logger->logComponent;
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_SetLoggingComponent (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_Logger_SetLoggingComponent(
PKIX_Logger *logger,
PKIX_ERRORCLASS component,
void *plContext)
{
PKIX_ENTER(LOGGER, "PKIX_Logger_SetLoggingComponent");
PKIX_NULLCHECK_ONE(logger);
logger->logComponent = component;
PKIX_RETURN(LOGGER);
}
/*
* Following PKIX_GetLoggers(), PKIX_SetLoggers() and PKIX_AddLogger() are
* documented as not thread-safe. However they are thread-safe now. We need
* the lock when accessing the logger lists.
*/
/*
* FUNCTION: PKIX_Logger_GetLoggers (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_GetLoggers(
PKIX_List **pLoggers, /* list of PKIX_Logger */
void *plContext)
{
PKIX_List *list = NULL;
PKIX_List *savedPkixLoggersDebugTrace = NULL;
PKIX_List *savedPkixLoggersErrors = NULL;
PKIX_Logger *logger = NULL;
PKIX_Logger *dupLogger = NULL;
PKIX_UInt32 i, length;
PKIX_Boolean locked = PKIX_FALSE;
PKIX_ENTER(LOGGER, "PKIX_Logger_GetLoggers");
PKIX_NULLCHECK_ONE(pLoggers);
PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),
PKIX_MONITORLOCKENTERFAILED);
locked = PKIX_TRUE;
/*
* Temporarily disable DEBUG/TRACE Logging to avoid possible
* deadlock:
* When the Logger List is being accessed, e.g. by PKIX_ENTER or
* PKIX_DECREF, pkix_Logger_Check may check whether logging
* is requested, creating a deadlock situation.
*/
savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
pkixLoggersDebugTrace = NULL;
savedPkixLoggersErrors = pkixLoggersErrors;
pkixLoggersErrors = NULL;
if (pkixLoggers == NULL) {
length = 0;
} else {
PKIX_CHECK(PKIX_List_GetLength
(pkixLoggers, &length, plContext),
PKIX_LISTGETLENGTHFAILED);
}
/* Create a list and copy the pkixLoggers item to the list */
PKIX_CHECK(PKIX_List_Create(&list, plContext),
PKIX_LISTCREATEFAILED);
for (i = 0; i < length; i++) {
PKIX_CHECK(PKIX_List_GetItem
(pkixLoggers,
i,
(PKIX_PL_Object **) &logger,
plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(pkix_Logger_Duplicate
((PKIX_PL_Object *)logger,
(PKIX_PL_Object **)&dupLogger,
plContext),
PKIX_LOGGERDUPLICATEFAILED);
PKIX_CHECK(PKIX_List_AppendItem
(list,
(PKIX_PL_Object *) dupLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
PKIX_DECREF(logger);
PKIX_DECREF(dupLogger);
}
/* Set the list to be immutable */
PKIX_CHECK(PKIX_List_SetImmutable(list, plContext),
PKIX_LISTSETIMMUTABLEFAILED);
*pLoggers = list;
cleanup:
PKIX_DECREF(logger);
/* Restore logging capability */
pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
pkixLoggersErrors = savedPkixLoggersErrors;
if (locked) {
PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),
PKIX_MONITORLOCKEXITFAILED);
}
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_SetLoggers (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_SetLoggers(
PKIX_List *loggers, /* list of PKIX_Logger */
void *plContext)
{
PKIX_List *list = NULL;
PKIX_List *savedPkixLoggersErrors = NULL;
PKIX_List *savedPkixLoggersDebugTrace = NULL;
PKIX_Logger *logger = NULL;
PKIX_Logger *dupLogger = NULL;
PKIX_Boolean locked = PKIX_FALSE;
PKIX_UInt32 i, length;
PKIX_ENTER(LOGGER, "PKIX_SetLoggers");
PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),
PKIX_MONITORLOCKENTERFAILED);
locked = PKIX_TRUE;
/* Disable tracing, etc. to avoid recursion and deadlock */
savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
pkixLoggersDebugTrace = NULL;
savedPkixLoggersErrors = pkixLoggersErrors;
pkixLoggersErrors = NULL;
/* discard any prior loggers */
PKIX_DECREF(pkixLoggers);
PKIX_DECREF(savedPkixLoggersErrors);
PKIX_DECREF(savedPkixLoggersDebugTrace);
if (loggers != NULL) {
PKIX_CHECK(PKIX_List_Create(&list, plContext),
PKIX_LISTCREATEFAILED);
PKIX_CHECK(PKIX_List_GetLength(loggers, &length, plContext),
PKIX_LISTGETLENGTHFAILED);
for (i = 0; i < length; i++) {
PKIX_CHECK(PKIX_List_GetItem
(loggers,
i,
(PKIX_PL_Object **) &logger,
plContext),
PKIX_LISTGETITEMFAILED);
PKIX_CHECK(pkix_Logger_Duplicate
((PKIX_PL_Object *)logger,
(PKIX_PL_Object **)&dupLogger,
plContext),
PKIX_LOGGERDUPLICATEFAILED);
PKIX_CHECK(PKIX_List_AppendItem
(list,
(PKIX_PL_Object *) dupLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
/* Make two lists */
/* Put in pkixLoggersErrors in any case*/
if (savedPkixLoggersErrors == NULL) {
PKIX_CHECK(PKIX_List_Create
(&savedPkixLoggersErrors,
plContext),
PKIX_LISTCREATEFAILED);
}
PKIX_CHECK(PKIX_List_AppendItem
(savedPkixLoggersErrors,
(PKIX_PL_Object *) dupLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
if (logger->maxLevel > PKIX_LOGGER_LEVEL_WARNING) {
/* Put in pkixLoggersDebugTrace */
if (savedPkixLoggersDebugTrace == NULL) {
PKIX_CHECK(PKIX_List_Create
(&savedPkixLoggersDebugTrace,
plContext),
PKIX_LISTCREATEFAILED);
}
PKIX_CHECK(PKIX_List_AppendItem
(savedPkixLoggersDebugTrace,
(PKIX_PL_Object *) dupLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
}
PKIX_DECREF(logger);
PKIX_DECREF(dupLogger);
}
pkixLoggers = list;
}
cleanup:
if (PKIX_ERROR_RECEIVED){
PKIX_DECREF(list);
PKIX_DECREF(savedPkixLoggersErrors);
PKIX_DECREF(savedPkixLoggersDebugTrace);
pkixLoggers = NULL;
}
PKIX_DECREF(logger);
/* Reenable logging capability with new lists */
pkixLoggersErrors = savedPkixLoggersErrors;
pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
if (locked) {
PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),
PKIX_MONITORLOCKEXITFAILED);
}
PKIX_RETURN(LOGGER);
}
/*
* FUNCTION: PKIX_Logger_AddLogger (see comments in pkix_util.h)
*/
PKIX_Error *
PKIX_AddLogger(
PKIX_Logger *logger,
void *plContext)
{
PKIX_Logger *dupLogger = NULL;
PKIX_Logger *addLogger = NULL;
PKIX_List *savedPkixLoggersErrors = NULL;
PKIX_List *savedPkixLoggersDebugTrace = NULL;
PKIX_Boolean locked = PKIX_FALSE;
PKIX_UInt32 i, length;
PKIX_ENTER(LOGGER, "PKIX_Logger_AddLogger");
PKIX_NULLCHECK_ONE(logger);
PKIX_CHECK(PKIX_PL_MonitorLock_Enter(pkixLoggerLock, plContext),
PKIX_MONITORLOCKENTERFAILED);
locked = PKIX_TRUE;
savedPkixLoggersDebugTrace = pkixLoggersDebugTrace;
pkixLoggersDebugTrace = NULL;
savedPkixLoggersErrors = pkixLoggersErrors;
pkixLoggersErrors = NULL;
PKIX_DECREF(savedPkixLoggersErrors);
PKIX_DECREF(savedPkixLoggersDebugTrace);
if (pkixLoggers == NULL) {
PKIX_CHECK(PKIX_List_Create(&pkixLoggers, plContext),
PKIX_LISTCREATEFAILED);
}
PKIX_CHECK(pkix_Logger_Duplicate
((PKIX_PL_Object *)logger,
(PKIX_PL_Object **)&dupLogger,
plContext),
PKIX_LOGGERDUPLICATEFAILED);
PKIX_CHECK(PKIX_List_AppendItem
(pkixLoggers,
(PKIX_PL_Object *) dupLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
PKIX_CHECK(PKIX_List_GetLength(pkixLoggers, &length, plContext),
PKIX_LISTGETLENGTHFAILED);
/* Reconstruct pkixLoggersErrors and pkixLoggersDebugTrace */
for (i = 0; i < length; i++) {
PKIX_CHECK(PKIX_List_GetItem
(pkixLoggers,
i,
(PKIX_PL_Object **) &addLogger,
plContext),
PKIX_LISTGETITEMFAILED);
/* Put in pkixLoggersErrors */
if (savedPkixLoggersErrors == NULL) {
PKIX_CHECK(PKIX_List_Create
(&savedPkixLoggersErrors,
plContext),
PKIX_LISTCREATEFAILED);
}
PKIX_CHECK(PKIX_List_AppendItem
(savedPkixLoggersErrors,
(PKIX_PL_Object *) addLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
if (addLogger->maxLevel > PKIX_LOGGER_LEVEL_WARNING) {
/* Put in pkixLoggersDebugTrace */
if (savedPkixLoggersDebugTrace == NULL) {
PKIX_CHECK(PKIX_List_Create
(&savedPkixLoggersDebugTrace,
plContext),
PKIX_LISTCREATEFAILED);
}
PKIX_CHECK(PKIX_List_AppendItem
(savedPkixLoggersDebugTrace,
(PKIX_PL_Object *) addLogger,
plContext),
PKIX_LISTAPPENDITEMFAILED);
}
PKIX_DECREF(addLogger);
}
cleanup:
PKIX_DECREF(dupLogger);
PKIX_DECREF(addLogger);
/* Restore logging capability */
pkixLoggersErrors = savedPkixLoggersErrors;
pkixLoggersDebugTrace = savedPkixLoggersDebugTrace;
if (locked) {
PKIX_CHECK(PKIX_PL_MonitorLock_Exit(pkixLoggerLock, plContext),
PKIX_MONITORLOCKEXITFAILED);
}
PKIX_RETURN(LOGGER);
}