/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*

 * pkix_tools.h

 *

 * Header for Utility Functions and Macros

 *

 */

#ifndef _PKIX_TOOLS_H

#define _PKIX_TOOLS_H

#include "pkix.h"

#include <stddef.h>

#include <stdio.h>

#include "secport.h"

#include "prlong.h"

/* private PKIX system headers */

#include "pkix_basicconstraintschecker.h"

#include "pkix_buildresult.h"

#include "pkix_certchainchecker.h"

#include "pkix_certselector.h"

#include "pkix_comcertselparams.h"

#include "pkix_comcrlselparams.h"

#include "pkix_crlselector.h"

#include "pkix_error.h"

#include "pkix_expirationchecker.h"

#include "pkix_list.h"

#include "pkix_logger.h"

#include "pkix_namechainingchecker.h"

#include "pkix_nameconstraintschecker.h"

#include "pkix_policychecker.h"

#include "pkix_policynode.h"

#include "pkix_procparams.h"

#include "pkix_resourcelimits.h"

#include "pkix_revocationmethod.h"

#include "pkix_revocationchecker.h"

#include "pkix_crlchecker.h"

#include "pkix_ocspchecker.h"

#include "pkix_signaturechecker.h"

#include "pkix_store.h"

#include "pkix_targetcertchecker.h"

#include "pkix_validate.h"

#include "pkix_valresult.h"

#include "pkix_verifynode.h"

#ifdef __cplusplus

extern "C" {

#endif

typedef struct pkixStdVarsStr {

    const char        *aMyFuncName;

    PKIX_Error        *aPkixErrorResult;

    PKIX_Error        *aPkixTempResult;

    PKIX_Error        *aPkixReturnResult;

    PKIX_ERRORCODE     aPkixErrorCode;

    PKIX_Boolean       aPkixErrorReceived;

    PKIX_Boolean       aPkixTempErrorReceived;

    PKIX_ERRORCLASS    aPkixErrorClass;

    PKIX_UInt32        aPkixType;

    PKIX_PL_Object    *aLockedObject;

    PKIX_List         *aPkixErrorList;

} PKIX_StdVars;

#ifdef PKIX_STDVARS_POINTER

#define myFuncName                  stdVars->aMyFuncName

#define pkixErrorResult             stdVars->aPkixErrorResult

#define pkixTempResult              stdVars->aPkixTempResult

#define pkixReturnResult            stdVars->aPkixReturnResult

#define pkixErrorCode               stdVars->aPkixErrorCode

#define pkixErrorReceived           stdVars->aPkixErrorReceived

#define pkixTempErrorReceived       stdVars->aPkixTempErrorReceived 

#define pkixErrorClass              stdVars->aPkixErrorClass

#define pkixType                    stdVars->aPkixType

#define lockedObject                stdVars->aLockedObject

#define pkixErrorList               stdVars->aPkixErrorList

#define stdVarsPtr                  stdVars

#else

#define myFuncName                  stdVars.aMyFuncName

#define pkixErrorResult             stdVars.aPkixErrorResult

#define pkixTempResult              stdVars.aPkixTempResult

#define pkixReturnResult            stdVars.aPkixReturnResult

#define pkixErrorCode               stdVars.aPkixErrorCode

#define pkixErrorReceived           stdVars.aPkixErrorReceived

#define pkixTempErrorReceived       stdVars.aPkixTempErrorReceived 

#define pkixErrorClass              stdVars.aPkixErrorClass

#define pkixType                    stdVars.aPkixType

#define lockedObject                stdVars.aLockedObject

#define pkixErrorList               stdVars.aPkixErrorList

#define stdVarsPtr                  &stdVars

#endif

extern PKIX_Error * PKIX_DoReturn(PKIX_StdVars * stdVars, 

                                  PKIX_ERRORCLASS errClass, 

                                  PKIX_Boolean doLogger,

                                  void * plContext);

extern PKIX_Error * PKIX_DoThrow(PKIX_StdVars * stdVars, 

                                 PKIX_ERRORCLASS errClass, 

                                 PKIX_ERRORCODE errCode,

                                 PKIX_ERRORCLASS overrideClass, 

                                 void * plContext);

extern void PKIX_DoAddError(PKIX_StdVars * stdVars, 

                            PKIX_Error * error,

                            void * plContext);

#ifdef PKIX_OBJECT_LEAK_TEST

extern PKIX_Error * pkix_CheckForGeneratedError(PKIX_StdVars * stdVars, 

                                                PKIX_ERRORCLASS errClass, 

                                                char * fnName,

                                                PKIX_Boolean *errorStateSet,

                                                void * plContext);

#endif /* PKIX_OBJECT_LEAK_TEST */

extern const PKIX_StdVars zeroStdVars;

extern PRLogModuleInfo *pkixLog;

/*

 * UTILITY MACROS

 * Documentation for these common utility macros can be found in the

 * Implementation Guidelines document (Section 4.3)

 *

 * In general, macros with multiple statements (or a single "if" statement)

 * use the "do {<body>} while (0)" technique in order to convert the multiple

 * statements into one statement, thus avoiding the dangling else problem.

 * For macros which ALWAYS exit with a "return" or "goto", there is no

 * need to use this technique (and it yields compiler warnings of "statement

 * not reached"), so we just use "{<body>}" to group the statements together.

 */

#if !defined (PKIX_OBJECT_LEAK_TEST)

#define PKIX_STD_VARS(funcName) \

    static const char cMyFuncName[] = {funcName}; \

    PKIX_StdVars      stdVars = zeroStdVars; \

    myFuncName = cMyFuncName

#else /* PKIX_OBJECT_LEAK_TEST */

extern char **fnStackNameArr;

extern PKIX_UInt32 *fnStackInvCountArr;

extern PKIX_UInt32  stackPosition;

extern PKIX_Boolean noErrorState;

extern PKIX_Boolean errorGenerated;

extern PKIX_Boolean runningLeakTest;

extern PLHashTable *fnInvTable;

extern PKIX_UInt32 testStartFnStackPosition;

extern char *errorFnStackString;

extern PLHashNumber PR_CALLBACK pkix_ErrorGen_Hash (const void *key);

#define PKIX_STD_VARS(funcName) \

    static const char cMyFuncName[] = {funcName}; \

    PKIX_StdVars      stdVars = zeroStdVars; \

    PKIX_Boolean      errorSetFlag = PKIX_FALSE; \

    myFuncName = cMyFuncName; \

    if (runningLeakTest) { \

        if (fnStackNameArr) { \

            fnStackInvCountArr[stackPosition] += 1; \

            stackPosition += 1; \

            fnStackInvCountArr[stackPosition] = 0; \

            fnStackNameArr[stackPosition] = (char*)myFuncName; \

            fnStackNameArr[stackPosition + 1] = NULL; \

            PR_LOG(pkixLog, 5, \

                    ("%s%*s+> %s(%d) - %s\n", (errorGenerated ? "*" : " "), \

                             stackPosition, " ", fnStackNameArr[stackPosition], \

                             stackPosition, myFuncName)); \

        } \

        do { \

            pkixErrorResult = pkix_CheckForGeneratedError(&stdVars, PKIX_MEM_ERROR, \

                                                          funcName, &errorSetFlag, \

                                                          plContext); \

            if (pkixErrorResult) { \

                 PR_LOG(pkixLog, 5, \

                    ("%s%*s<- %s(%d) - %s\n", (errorGenerated ? "*" : " "), \

                              stackPosition, " ", fnStackNameArr[stackPosition], \

                              stackPosition, myFuncName)); \

                 fnStackNameArr[stackPosition--] = NULL; \

                 if (errorSetFlag) { \

                       noErrorState = (noErrorState) ? PKIX_FALSE : PKIX_TRUE; \

                 } \

                 return pkixErrorResult; \

            } \

        } while (0); \

    }

#endif /* PKIX_OBJECT_LEAK_TEST */

#ifdef DEBUG

#define _PKIX_DEBUG_TRACE(cond, prefix, level) \

    do { \

	if (cond) { \

	    pkix_Logger_Check(pkixLoggersDebugTrace, myFuncName, \

	                      prefix, pkixType, level, plContext); \

	} \

    } while (0)

#else

#define _PKIX_DEBUG_TRACE(cond, prefix, level) 

#endif

#define _PKIX_LOG_ERROR(code, level) \

    { \

	if (pkixLoggersErrors) { \

	    pkix_Logger_CheckWithCode(pkixLoggersErrors, code, \

	                      NULL, pkixType, level, plContext); \

	} \

    }

#define PKIX_ENTER(type, funcName) \

    PKIX_STD_VARS(funcName); \

    pkixType = PKIX_ ## type ## _ERROR; \

    PKIX_DEBUG_ENTER(type); \

    _PKIX_DEBUG_TRACE(pkixLoggersDebugTrace, ">>>", PKIX_LOGGER_LEVEL_TRACE);

#define PKIX_ENTER_NO_LOGGER(type, funcName) \

    PKIX_STD_VARS(funcName); \

    pkixType = PKIX_ ## type ## _ERROR; \

    PKIX_DEBUG_ENTER(type);

#define PKIX_DEBUG_ENTER(type) \

    PKIX_ ## type ## _DEBUG_ARG("( Entering %s).\n", myFuncName)

#define PKIX_DEBUG_EXIT(type) \

    PKIX_ ## type ## _DEBUG_ARG("( Exiting %s).\n", myFuncName)

#define PKIX_OBJECT_UNLOCK(obj) \

    do { \

	if (obj && lockedObject == (PKIX_PL_Object *)(obj)){ \

	    pkixTempResult = \

		    PKIX_PL_Object_Unlock \

		    ((PKIX_PL_Object *)(obj), plContext); \

	    if (pkixTempResult) { \

		PKIX_DoAddError(stdVarsPtr, pkixTempResult, plContext); \

		pkixTempResult = NULL; \

	    } \

	    lockedObject = NULL; \

	} else { \

	    PORT_Assert(lockedObject == NULL); \

	} \

    } while (0)

#define PKIX_DECREF(obj) \

    do { \

	if (obj){ \

	    pkixTempResult = PKIX_PL_Object_DecRef \

			((PKIX_PL_Object *)(obj), plContext); \

	    if (pkixTempResult) { \

		PKIX_DoAddError(stdVarsPtr, pkixTempResult, plContext); \

		pkixTempResult = NULL; \

	    } \

	    obj = NULL; \

	} \

    } while (0)

#define PKIX_THROW(type, descNum) \

    return PKIX_DoThrow(&stdVars, (PKIX_ ## type ## _ERROR), descNum, \

                        pkixErrorClass, plContext);

#ifdef PKIX_OBJECT_LEAK_TEST

#define PKIX_RETURN(type) \

    if (runningLeakTest && fnStackNameArr) { \

        PR_LOG(pkixLog, 5, \

               ("%s%*s<- %s(%d) - %s\n", (errorGenerated ? "*" : " "), \

               stackPosition, " ", fnStackNameArr[stackPosition], \

               stackPosition, myFuncName)); \

        fnStackNameArr[stackPosition--] = NULL; \

        if (errorSetFlag) noErrorState = (noErrorState) ? PKIX_FALSE : PKIX_TRUE; \

    } \

    return PKIX_DoReturn(&stdVars, (PKIX_ ## type ## _ERROR), PKIX_TRUE, plContext);

#else

#define PKIX_RETURN(type) \

    return PKIX_DoReturn(&stdVars, (PKIX_ ## type ## _ERROR), PKIX_TRUE, plContext);

#endif /* PKIX_OBJECT_LEAK_TEST */

#if defined(DEBUG) && !defined(DEBUG_nb95248)

#define PKIX_RETURN_NO_LOGGER(type) \

    { \

	PKIX_OBJECT_UNLOCK(lockedObject); \

	if ((pkixErrorReceived) || (pkixErrorResult) || pkixErrorList) \

	    PKIX_THROW(type, pkixErrorCode); \

	PKIX_DEBUG_EXIT(type); \

	return NULL; \

    }

#else

#define PKIX_RETURN_NO_LOGGER(type) \

    return PKIX_DoReturn(&stdVars, (PKIX_ ## type ## _ERROR), PKIX_FALSE, plContext);

#endif

/* disable to disable ;-) */

/* #define WANT_TRACE_CHECK_FAILURES */

#ifdef WANT_TRACE_CHECK_FAILURES

#define TRACE_CHECK_FAILURE(what, errorstring) \

    if (pkixLog) { \

      PR_LOG(pkixLog, PR_LOG_DEBUG, \

        ("====> [%s] failed: %s\n", #what, errorstring)); \

    }

#else

#define TRACE_CHECK_FAILURE(what, errorstring)

#endif

#define PKIX_CHECK(func, descNum) \

    do { \

	pkixErrorResult = (func); \

	if (pkixErrorResult) { \

            TRACE_CHECK_FAILURE((func), PKIX_ErrorText[descNum]) \

	    pkixErrorClass = pkixErrorResult->errClass; \

	    pkixErrorCode = descNum; \

	    goto cleanup; \

	} \

    } while (0)

/* like PKIX_CHECK but without goto cleanup */

#define PKIX_CHECK_NO_GOTO(func, descNum) \

    do { \

	pkixErrorResult = (func); \

	if (pkixErrorResult) { \

            TRACE_CHECK_FAILURE((func), PKIX_ErrorText[descNum]) \

	    pkixErrorClass = pkixErrorResult->errClass; \

	    pkixErrorCode = descNum; \

	} \

    } while (0)

#define PKIX_CHECK_ONLY_FATAL(func, descNum) \

    do { \

	pkixTempErrorReceived = PKIX_FALSE; \

	pkixErrorResult = (func); \

	if (pkixErrorResult) { \

            TRACE_CHECK_FAILURE((func), PKIX_ErrorText[descNum]) \

	    pkixTempErrorReceived = PKIX_TRUE; \

	    pkixErrorClass = pkixErrorResult->errClass; \

            if (pkixErrorClass == PKIX_FATAL_ERROR) { \

	         goto cleanup; \

	    } \

	    PKIX_DECREF(pkixErrorResult); \

	} \

    } while (0)

#define PKIX_LOG_ERROR(descNum) \

    _PKIX_LOG_ERROR(descNum, PKIX_LOGGER_LEVEL_ERROR)

#define PKIX_ERROR(descNum) \

    { \

	PKIX_LOG_ERROR(descNum) \

	pkixErrorReceived = PKIX_TRUE; \

	pkixErrorCode = descNum; \

	goto cleanup; \

    }

#define PKIX_ERROR_ALLOC_ERROR() \

    { \

	PKIX_LOG_ERROR(PKIX_ALLOCERROR) \