/* 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_valresult.c

 *

 * ValidateResult Object Functions

 *

 */

#include "pkix_valresult.h"

/* --Private-Functions-------------------------------------------- */

/*

 * FUNCTION: pkix_ValidateResult_Destroy

 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)

 */

static PKIX_Error *

pkix_ValidateResult_Destroy(

        PKIX_PL_Object *object,

        void *plContext)

{

        PKIX_ValidateResult *result = NULL;

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Destroy");

        PKIX_NULLCHECK_ONE(object);

        /* Check that this object is a validate result object */

        PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext),

                PKIX_OBJECTNOTVALIDATERESULT);

        result = (PKIX_ValidateResult *)object;

        PKIX_DECREF(result->anchor);

        PKIX_DECREF(result->pubKey);

        PKIX_DECREF(result->policyTree);

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: pkix_ValidateResult_Equals

 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)

 */

static PKIX_Error *

pkix_ValidateResult_Equals(

        PKIX_PL_Object *first,

        PKIX_PL_Object *second,

        PKIX_Boolean *pResult,

        void *plContext)

{

        PKIX_UInt32 secondType;

        PKIX_Boolean cmpResult;

        PKIX_ValidateResult *firstValResult = NULL;

        PKIX_ValidateResult *secondValResult = NULL;

        PKIX_TrustAnchor *firstAnchor = NULL;

        PKIX_TrustAnchor *secondAnchor = NULL;

        PKIX_PolicyNode *firstTree = NULL;

        PKIX_PolicyNode *secondTree = NULL;

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Equals");

        PKIX_NULLCHECK_THREE(first, second, pResult);

        PKIX_CHECK(pkix_CheckType(first, PKIX_VALIDATERESULT_TYPE, plContext),

                PKIX_FIRSTOBJECTNOTVALIDATERESULT);

        PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),

                PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);

        *pResult = PKIX_FALSE;

        if (secondType != PKIX_VALIDATERESULT_TYPE) goto cleanup;

        firstValResult = (PKIX_ValidateResult *)first;

        secondValResult = (PKIX_ValidateResult *)second;

        PKIX_CHECK(PKIX_PL_Object_Equals

                ((PKIX_PL_Object *)firstValResult->pubKey,

                (PKIX_PL_Object *)secondValResult->pubKey,

                &cmpResult,

                plContext),

                PKIX_OBJECTEQUALSFAILED);

        if (!cmpResult) goto cleanup;

        firstAnchor = firstValResult->anchor;

        secondAnchor = secondValResult->anchor;

        if ((firstAnchor != NULL) && (secondAnchor != NULL)) {

                PKIX_CHECK(PKIX_PL_Object_Equals

                        ((PKIX_PL_Object *)firstAnchor,

                        (PKIX_PL_Object *)secondAnchor,

                        &cmpResult,

                        plContext),

                        PKIX_OBJECTEQUALSFAILED);

        } else {

                cmpResult = (firstAnchor == secondAnchor);

        }

        if (!cmpResult) goto cleanup;

        firstTree = firstValResult->policyTree;

        secondTree = secondValResult->policyTree;

        if ((firstTree != NULL) && (secondTree != NULL)) {

                PKIX_CHECK(PKIX_PL_Object_Equals

                        ((PKIX_PL_Object *)firstTree,

                        (PKIX_PL_Object *)secondTree,

                        &cmpResult,

                        plContext),

                        PKIX_OBJECTEQUALSFAILED);

        } else {

                cmpResult = (firstTree == secondTree);

        }

        *pResult = cmpResult;

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: pkix_ValidateResult_Hashcode

 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)

 */

static PKIX_Error *

pkix_ValidateResult_Hashcode(

        PKIX_PL_Object *object,

        PKIX_UInt32 *pHashcode,

        void *plContext)

{

        PKIX_ValidateResult *valResult = NULL;

        PKIX_UInt32 hash = 0;

        PKIX_UInt32 pubKeyHash = 0;

        PKIX_UInt32 anchorHash = 0;

        PKIX_UInt32 policyTreeHash = 0;

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Hashcode");

        PKIX_NULLCHECK_TWO(object, pHashcode);

        PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext),

                PKIX_OBJECTNOTVALIDATERESULT);

        valResult = (PKIX_ValidateResult*)object;

        PKIX_CHECK(PKIX_PL_Object_Hashcode

                ((PKIX_PL_Object *)valResult->pubKey, &pubKeyHash, plContext),

                PKIX_OBJECTHASHCODEFAILED);

        if (valResult->anchor) {

                PKIX_CHECK(PKIX_PL_Object_Hashcode

                        ((PKIX_PL_Object *)valResult->anchor,

                        &anchorHash,

                        plContext),

                        PKIX_OBJECTHASHCODEFAILED);

        }

        if (valResult->policyTree) {

                PKIX_CHECK(PKIX_PL_Object_Hashcode

                        ((PKIX_PL_Object *)valResult->policyTree,

                        &policyTreeHash,

                        plContext),

                        PKIX_OBJECTHASHCODEFAILED);

        }

        hash = 31*(31 * pubKeyHash + anchorHash) + policyTreeHash;

        *pHashcode = hash;

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: pkix_ValidateResult_ToString

 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)

 */

static PKIX_Error *

pkix_ValidateResult_ToString(

        PKIX_PL_Object *object,

        PKIX_PL_String **pString,

        void *plContext)

{

        PKIX_ValidateResult *valResult = NULL;

        PKIX_PL_String *formatString = NULL;

        PKIX_PL_String *valResultString = NULL;

        PKIX_TrustAnchor *anchor = NULL;

        PKIX_PL_PublicKey *pubKey = NULL;

        PKIX_PolicyNode *policyTree = NULL;

        PKIX_PL_String *anchorString = NULL;

        PKIX_PL_String *pubKeyString = NULL;

        PKIX_PL_String *treeString = NULL;

        char *asciiNullString = "(null)";

        char *asciiFormat =

                "[\n"

                "\tTrustAnchor: \t\t%s"

                "\tPubKey:    \t\t%s\n"

                "\tPolicyTree:  \t\t%s\n"

                "]\n";

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_ToString");

        PKIX_NULLCHECK_TWO(object, pString);

        PKIX_CHECK(pkix_CheckType(object, PKIX_VALIDATERESULT_TYPE, plContext),

                PKIX_OBJECTNOTVALIDATERESULT);

        PKIX_CHECK(PKIX_PL_String_Create

                (PKIX_ESCASCII, asciiFormat, 0, &formatString, plContext),

                PKIX_STRINGCREATEFAILED);

        valResult = (PKIX_ValidateResult*)object;

        anchor = valResult->anchor;

        if (anchor) {

                PKIX_CHECK(PKIX_PL_Object_ToString

                        ((PKIX_PL_Object *)anchor, &anchorString, plContext),

                        PKIX_OBJECTTOSTRINGFAILED);

        } else {

                PKIX_CHECK(PKIX_PL_String_Create

                        (PKIX_ESCASCII,

                        asciiNullString,

                        0,

                        &anchorString,

                        plContext),

                        PKIX_STRINGCREATEFAILED);

        }

        pubKey = valResult->pubKey;

        PKIX_CHECK(PKIX_PL_Object_ToString

                ((PKIX_PL_Object *)pubKey, &pubKeyString, plContext),

                PKIX_OBJECTTOSTRINGFAILED);

        policyTree = valResult->policyTree;

        if (policyTree) {

                PKIX_CHECK(PKIX_PL_Object_ToString

                        ((PKIX_PL_Object *)policyTree, &treeString, plContext),

                        PKIX_OBJECTTOSTRINGFAILED);

        } else {

                PKIX_CHECK(PKIX_PL_String_Create

                        (PKIX_ESCASCII,

                        asciiNullString,

                        0,

                        &treeString,

                        plContext),

                        PKIX_STRINGCREATEFAILED);

        }

        PKIX_CHECK(PKIX_PL_Sprintf

                (&valResultString,

                plContext,

                formatString,

                anchorString,

                pubKeyString,

                treeString),

                PKIX_SPRINTFFAILED);

        *pString = valResultString;

cleanup:

        PKIX_DECREF(formatString);

        PKIX_DECREF(anchorString);

        PKIX_DECREF(pubKeyString);

        PKIX_DECREF(treeString);

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: pkix_ValidateResult_RegisterSelf

 * DESCRIPTION:

 *  Registers PKIX_VALIDATERESULT_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_ValidateResult_RegisterSelf(void *plContext)

{

        extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];

        pkix_ClassTable_Entry entry;

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_RegisterSelf");

        entry.description = "ValidateResult";

        entry.objCounter = 0;

        entry.typeObjectSize = sizeof(PKIX_ValidateResult);

        entry.destructor = pkix_ValidateResult_Destroy;

        entry.equalsFunction = pkix_ValidateResult_Equals;

        entry.hashcodeFunction = pkix_ValidateResult_Hashcode;

        entry.toStringFunction = pkix_ValidateResult_ToString;

        entry.comparator = NULL;

        entry.duplicateFunction = pkix_duplicateImmutable;

        systemClasses[PKIX_VALIDATERESULT_TYPE] = entry;

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: pkix_ValidateResult_Create

 * DESCRIPTION:

 *

 *  Creates a new ValidateResult Object using the PublicKey pointed to by

 *  "pubKey", the TrustAnchor pointed to by "anchor", and the PolicyNode

 *  pointed to by "policyTree", and stores it at "pResult".

 *

 * PARAMETERS

 *  "pubKey"

 *      PublicKey of the desired ValidateResult. Must be non-NULL.

 *  "anchor"

 *      TrustAnchor of the desired Validateresult. May be NULL.

 *  "policyTree"

 *      PolicyNode of the desired ValidateResult; may be NULL

 *  "pResult"

 *      Address where object pointer will be stored. Must be non-NULL.

 *  "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_ValidateResult_Create(

        PKIX_PL_PublicKey *pubKey,

        PKIX_TrustAnchor *anchor,

        PKIX_PolicyNode *policyTree,

        PKIX_ValidateResult **pResult,

        void *plContext)

{

        PKIX_ValidateResult *result = NULL;

        PKIX_ENTER(VALIDATERESULT, "pkix_ValidateResult_Create");

        PKIX_NULLCHECK_TWO(pubKey, pResult);

        PKIX_CHECK(PKIX_PL_Object_Alloc

                    (PKIX_VALIDATERESULT_TYPE,

                    sizeof (PKIX_ValidateResult),

                    (PKIX_PL_Object **)&result,

                    plContext),

                    PKIX_COULDNOTCREATEVALIDATERESULTOBJECT);

        /* initialize fields */

        PKIX_INCREF(pubKey);

        result->pubKey = pubKey;

        PKIX_INCREF(anchor);

        result->anchor = anchor;

        PKIX_INCREF(policyTree);

        result->policyTree = policyTree;

        *pResult = result;

        result = NULL;

cleanup:

        PKIX_DECREF(result);

        PKIX_RETURN(VALIDATERESULT);

}

/* --Public-Functions--------------------------------------------- */

/*

 * FUNCTION: PKIX_ValidateResult_GetPublicKey

 *      (see comments in pkix_result.h)

 */

PKIX_Error *

PKIX_ValidateResult_GetPublicKey(

        PKIX_ValidateResult *result,

        PKIX_PL_PublicKey **pPublicKey,

        void *plContext)

{

        PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetPublicKey");

        PKIX_NULLCHECK_TWO(result, pPublicKey);

        PKIX_INCREF(result->pubKey);

        *pPublicKey = result->pubKey;

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: PKIX_ValidateResult_GetTrustAnchor

 *      (see comments in pkix_result.h)

 */

PKIX_Error *

PKIX_ValidateResult_GetTrustAnchor(

        PKIX_ValidateResult *result,

        PKIX_TrustAnchor **pTrustAnchor,

        void *plContext)

{

        PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetTrustAnchor");

        PKIX_NULLCHECK_TWO(result, pTrustAnchor);

        PKIX_INCREF(result->anchor);

        *pTrustAnchor = result->anchor;

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}

/*

 * FUNCTION: PKIX_ValidateResult_GetPolicyTree

 *      (see comments in pkix_result.h)

 */

PKIX_Error *

PKIX_ValidateResult_GetPolicyTree(

        PKIX_ValidateResult *result,

        PKIX_PolicyNode **pPolicyTree,

        void *plContext)

{

        PKIX_ENTER(VALIDATERESULT, "PKIX_ValidateResult_GetPolicyTree");

        PKIX_NULLCHECK_TWO(result, pPolicyTree);

        PKIX_INCREF(result->policyTree);

        (*pPolicyTree) = result->policyTree;

cleanup:

        PKIX_RETURN(VALIDATERESULT);

}